Add files using upload-large-folder tool

CCEdit-main/src/controlnet11/README.md

@@ -0,0 +1,620 @@
+# ControlNet 1.1
+
+This is the official release of ControlNet 1.1.
+
+ControlNet 1.1 has the exactly same architecture with ControlNet 1.0. 
+
+We promise that we will not change the neural network architecture before ControlNet 1.5 (at least, and hopefully we will never change the network architecture). Perhaps this is the best news in ControlNet 1.1.
+
+ControlNet 1.1 includes all previous models with improved robustness and result quality. Several new models are added.
+
+Note that we are still working on [updating this to A1111](https://github.com/Mikubill/sd-webui-controlnet/issues/736). 
+
+This repo will be merged to [ControlNet](https://github.com/lllyasviel/ControlNet) after we make sure that everything is OK.
+
+**Note that we are actively editing this page now. The information in this page will be more detailed and finalized when ControlNet 1.1 is ready.**
+
+# This Github Repo is NOT an A1111 Extension
+
+Please do not copy the URL of this repo into your A1111.
+
+If you want to use ControlNet 1.1 in A1111, you only need to install https://github.com/Mikubill/sd-webui-controlnet , and only follow the instructions in that page.
+
+This project is for research use and academic experiments. Again, do NOT install "ControlNet-v1-1-nightly" into your A1111.
+
+# How to use ControlNet 1.1 in A1111?
+
+The Beta Test for A1111 Is Started. 
+
+The A1111 plugin is: https://github.com/Mikubill/sd-webui-controlnet
+
+Note that if you use A1111, you only need to follow the instructions in the above link. (You can ignore all installation steps in this page if you use A1111.)
+
+**For researchers who are not familiar with A1111:** The A1111 plugin supports arbitrary combination of arbitrary number of ControlNets, arbitrary community models, arbitrary LoRAs, and arbitrary sampling methods! We should definitely try it!
+
+Note that our official support for “Multi-ControlNet” is A1111-only. Please use [Automatic1111 with Multi-ControlNet](https://github.com/Mikubill/sd-webui-controlnet#Multi-ControlNet) if you want to use multiple ControlNets at the same time. The ControlNet project perfectly supports combining multiple ControlNets, and all production-ready ControlNets are extensively tested with multiple ControlNets combined.
+
+# Model Specification
+
+Starting from ControlNet 1.1, we begin to use the Standard ControlNet Naming Rules (SCNNRs) to name all models. We hope that this naming rule can improve the user experience.
+
+![img](github_docs/imgs/spec.png)
+
+ControlNet 1.1 include 14 models (11 production-ready models and 3 experimental models):
+
+    control_v11p_sd15_canny
+    control_v11p_sd15_mlsd
+    control_v11f1p_sd15_depth
+    control_v11p_sd15_normalbae
+    control_v11p_sd15_seg
+    control_v11p_sd15_inpaint
+    control_v11p_sd15_lineart
+    control_v11p_sd15s2_lineart_anime
+    control_v11p_sd15_openpose
+    control_v11p_sd15_scribble
+    control_v11p_sd15_softedge
+    control_v11e_sd15_shuffle
+    control_v11e_sd15_ip2p
+    control_v11f1e_sd15_tile
+
+You can download all those models from our [HuggingFace Model Page](https://huggingface.co/lllyasviel/ControlNet-v1-1/tree/main). All these models should be put in the folder "models".
+
+You need to download Stable Diffusion 1.5 model ["v1-5-pruned.ckpt"](https://huggingface.co/runwayml/stable-diffusion-v1-5/tree/main) and put it in the folder "models".
+
+Our python codes will automatically download other annotator models like HED and OpenPose. Nevertheless, if you want to manually download these, you can download all other annotator models from [here](https://huggingface.co/lllyasviel/Annotators/tree/main). All these models should be put in folder "annotator/ckpts". 
+
+To install:
+
+    conda env create -f environment.yaml
+    conda activate control-v11
+
+Note that if you use 8GB GPU, you need to set "save_memory = True" in "config.py".
+
+## ControlNet 1.1 Depth
+
+Control Stable Diffusion with Depth Maps.
+
+Model file: control_v11f1p_sd15_depth.pth
+
+Config file: control_v11f1p_sd15_depth.yaml
+
+Training data: Midas depth (resolution 256/384/512) + Leres Depth (resolution 256/384/512) + Zoe Depth (resolution 256/384/512). Multiple depth map generator at multiple resolution as data augmentation.
+
+Acceptable Preprocessors: Depth_Midas, Depth_Leres, Depth_Zoe. This model is highly robust and can work on real depth map from rendering engines.
+
+    python gradio_depth.py
+
+Non-cherry-picked batch test with random seed 12345 ("a handsome man"):
+
+![img](github_docs/imgs/depth_1.png)
+
+**Update**
+
+2023/04/14: 72 hours ago we uploaded a wrong model "control_v11p_sd15_depth" by mistake. That model is an intermediate checkpoint during the training. That model is not converged and may cause distortion in results. We uploaded the correct depth model as "control_v11f1p_sd15_depth". The "f1" means bug fix 1. The incorrect model is removed. Sorry for the inconvenience.
+
+**Improvements in Depth 1.1:**
+
+1. The training dataset of previous cnet 1.0 has several problems including (1) a small group of greyscale human images are duplicated thousands of times (!!), causing the previous model somewhat likely to generate grayscale human images; (2) some images has low quality, very blurry, or significant JPEG artifacts; (3) a small group of images has wrong paired prompts caused by a mistake in our data processing scripts. The new model fixed all problems of the training dataset and should be more reasonable in many cases.
+2. The new depth model is a relatively unbiased model. It is not trained with some specific type of depth by some specific depth estimation method. It is not over-fitted to one preprocessor. This means this model will work better with different depth estimation, different preprocessor resolutions, or even with real depth created by 3D engines.
+3. Some reasonable data augmentations are applied to training, like random left-right flipping.
+4. The model is resumed from depth 1.0, and it should work well in all cases where depth 1.0 works well. If not, please open an issue with image, and we will take a look at your case. Depth 1.1 works well in many failure cases of depth 1.0.
+5. If you use Midas depth (the "depth" in webui plugin) with 384 preprocessor resolution, the difference between depth 1.0 and 1.1 should be minimal. However, if you try other preprocessor resolutions or other preprocessors (like leres and zoe), the depth 1.1 is expected to be a bit better than 1.0.
+
+## ControlNet 1.1 Normal
+
+Control Stable Diffusion with Normal Maps.
+
+Model file: control_v11p_sd15_normalbae.pth
+
+Config file: control_v11p_sd15_normalbae.yaml
+
+Training data: [Bae's](https://github.com/baegwangbin/surface_normal_uncertainty) normalmap estimation method.
+
+Acceptable Preprocessors: Normal BAE. This model can accept normal maps from rendering engines as long as the normal map follows [ScanNet's](http://www.scan-net.org/) protocol. That is to say, the color of your normal map should look like [the second column of this image](https://raw.githubusercontent.com/baegwangbin/surface_normal_uncertainty/main/figs/readme_scannet.png).
+
+Note that this method is much more reasonable than the normal-from-midas method in ControlNet 1.0. The previous method will be abandoned.
+
+    python gradio_normalbae.py
+
+Non-cherry-picked batch test with random seed 12345 ("a man made of flowers"):
+
+![img](github_docs/imgs/normal_1.png)
+
+Non-cherry-picked batch test with random seed 12345 ("room"):
+
+![img](github_docs/imgs/normal_2.png)
+
+**Improvements in Normal 1.1:**
+
+1. The normal-from-midas method in Normal 1.0 is neither reasonable nor physically correct. That method does not work very well in many images. The normal 1.0 model cannot interpret real normal maps created by rendering engines.
+2. This Normal 1.1 is much more reasonable because the preprocessor is trained to estimate normal maps with a relatively correct protocol (NYU-V2's visualization method). This means the Normal 1.1 can interpret real normal maps from rendering engines as long as the colors are correct (blue is front, red is left, green is top).
+3. In our test, this model is robust and can achieve similar performance to the depth model. In previous CNET 1.0, the Normal 1.0 is not very frequently used. But this Normal 2.0 is much improved and has potential to be used much more frequently.
+
+## ControlNet 1.1 Canny
+
+Control Stable Diffusion with Canny Maps.
+
+Model file: control_v11p_sd15_canny.pth
+
+Config file: control_v11p_sd15_canny.yaml
+
+Training data: Canny with random thresholds.
+
+Acceptable Preprocessors: Canny.
+
+We fixed several problems in previous training datasets.
+
+    python gradio_canny.py
+
+Non-cherry-picked batch test with random seed 12345 ("dog in a room"):
+
+![img](github_docs/imgs/canny_1.png)
+
+**Improvements in Canny 1.1:**
+
+1. The training dataset of previous cnet 1.0 has several problems including (1) a small group of greyscale human images are duplicated thousands of times (!!), causing the previous model somewhat likely to generate grayscale human images; (2) some images has low quality, very blurry, or significant JPEG artifacts; (3) a small group of images has wrong paired prompts caused by a mistake in our data processing scripts. The new model fixed all problems of the training dataset and should be more reasonable in many cases.
+2. Because the Canny model is one of the most important (perhaps the most frequently used) ControlNet, we used a fund to train it on a machine with 8 Nvidia A100 80G with batchsize 8×32=256 for 3 days, spending 72×30=2160 USD (8 A100 80G with 30 USD/hour). The model is resumed from Canny 1.0.
+3. Some reasonable data augmentations are applied to training, like random left-right flipping.
+4. Although it is difficult to evaluate a ControlNet, we find Canny 1.1 is a bit more robust and a bit higher visual quality than Canny 1.0. 
+
+## ControlNet 1.1 MLSD
+
+Control Stable Diffusion with M-LSD straight lines.
+
+Model file: control_v11p_sd15_mlsd.pth
+
+Config file: control_v11p_sd15_mlsd.yaml
+
+Training data: M-LSD Lines.
+
+Acceptable Preprocessors: MLSD.
+
+We fixed several problems in previous training datasets. The model is resumed from ControlNet 1.0 and trained with 200 GPU hours of A100 80G.
+
+    python gradio_mlsd.py
+
+Non-cherry-picked batch test with random seed 12345 ("room"):
+
+![img](github_docs/imgs/mlsd_1.png)
+
+**Improvements in MLSD 1.1:**
+
+1. The training dataset of previous cnet 1.0 has several problems including (1) a small group of greyscale human images are duplicated thousands of times (!!), causing the previous model somewhat likely to generate grayscale human images; (2) some images has low quality, very blurry, or significant JPEG artifacts; (3) a small group of images has wrong paired prompts caused by a mistake in our data processing scripts. The new model fixed all problems of the training dataset and should be more reasonable in many cases.
+2. We enlarged the training dataset by adding 300K more images by using MLSD to find images with more than 16 straight lines in it.
+3. Some reasonable data augmentations are applied to training, like random left-right flipping.
+4. Resumed from MLSD 1.0 with continued training with 200 GPU hours of A100 80G.
+
+## ControlNet 1.1 Scribble
+
+Control Stable Diffusion with Scribbles.
+
+Model file: control_v11p_sd15_scribble.pth
+
+Config file: control_v11p_sd15_scribble.yaml
+
+Training data: Synthesized scribbles.
+
+Acceptable Preprocessors: Synthesized scribbles (Scribble_HED, Scribble_PIDI, etc.) or hand-drawn scribbles.
+
+We fixed several problems in previous training datasets. The model is resumed from ControlNet 1.0 and trained with 200 GPU hours of A100 80G.
+
+    # To test synthesized scribbles
+    python gradio_scribble.py
+    # To test hand-drawn scribbles in an interactive demo
+    python gradio_interactive.py
+
+Non-cherry-picked batch test with random seed 12345 ("man in library"):
+
+![img](github_docs/imgs/scribble_1.png)
+
+Non-cherry-picked batch test with random seed 12345 (interactive, "the beautiful landscape"):
+
+![img](github_docs/imgs/scribble_2.png)
+
+**Improvements in Scribble 1.1:**
+
+1. The training dataset of previous cnet 1.0 has several problems including (1) a small group of greyscale human images are duplicated thousands of times (!!), causing the previous model somewhat likely to generate grayscale human images; (2) some images has low quality, very blurry, or significant JPEG artifacts; (3) a small group of images has wrong paired prompts caused by a mistake in our data processing scripts. The new model fixed all problems of the training dataset and should be more reasonable in many cases.
+2. We find out that users sometimes like to draw very thick scribbles. Because of that, we used more aggressive random morphological transforms to synthesize scribbles. This model should work well even when the scribbles are relatively thick (the maximum width of training data is 24-pixel-width scribble in a 512 canvas, but it seems to work well even for a bit wider scribbles; the minimum width is 1 pixel).
+3. Resumed from Scribble 1.0, continued with 200 GPU hours of A100 80G.
+
+## ControlNet 1.1 Soft Edge
+
+Control Stable Diffusion with Soft Edges.
+
+Model file: control_v11p_sd15_softedge.pth
+
+Config file: control_v11p_sd15_softedge.yaml
+
+Training data: SoftEdge_PIDI, SoftEdge_PIDI_safe, SoftEdge_HED, SoftEdge_HED_safe.
+
+Acceptable Preprocessors: SoftEdge_PIDI, SoftEdge_PIDI_safe, SoftEdge_HED, SoftEdge_HED_safe.
+
+This model is significantly improved compared to previous model. All users should update as soon as possible.
+
+New in ControlNet 1.1: now we added a new type of soft edge called "SoftEdge_safe". This is motivated by the fact that HED or PIDI tends to hide a corrupted greyscale version of the original image inside the soft estimation, and such hidden patterns can distract ControlNet, leading to bad results. The solution is to use a pre-processing to quantize the edge maps into several levels so that the hidden patterns can be completely removed. The implementation is [in the 78-th line of annotator/util.py](https://github.com/lllyasviel/ControlNet-v1-1-nightly/blob/4c9560ebe7679daac53a0599a11b9b7cd984ac55/annotator/util.py#L78).
+
+The perforamce can be roughly noted as:
+
+Robustness: SoftEdge_PIDI_safe > SoftEdge_HED_safe >> SoftEdge_PIDI > SoftEdge_HED
+
+Maximum result quality: SoftEdge_HED > SoftEdge_PIDI > SoftEdge_HED_safe > SoftEdge_PIDI_safe
+
+Considering the trade-off, we recommend to use SoftEdge_PIDI by default. In most cases it works very well.
+
+    python gradio_softedge.py
+
+Non-cherry-picked batch test with random seed 12345 ("a handsome man"):
+
+![img](github_docs/imgs/softedge_1.png)
+
+**Improvements in Soft Edge 1.1:**
+
+1. Soft Edge 1.1 was called HED 1.0 in previous ControlNet.
+2. The training dataset of previous cnet 1.0 has several problems including (1) a small group of greyscale human images are duplicated thousands of times (!!), causing the previous model somewhat likely to generate grayscale human images; (2) some images has low quality, very blurry, or significant JPEG artifacts; (3) a small group of images has wrong paired prompts caused by a mistake in our data processing scripts. The new model fixed all problems of the training dataset and should be more reasonable in many cases.
+3. The Soft Edge 1.1 is significantly (in nealy 100\% cases) better than HED 1.0. This is mainly because HED or PIDI estimator tend to hide a corrupted greyscale version of original image inside the soft edge map and the previous model HED 1.0 is over-fitted to restore that hidden corrupted image rather than perform boundary-aware diffusion. The training of Soft Edge 1.1 used 75\% "safe" filtering to remove such hidden corrupted greyscale images insider control maps. This makes the Soft Edge 1.1 very robust. In out test, Soft Edge 1.1 is as usable as the depth model and has potential to be more frequently used.
+
+## ControlNet 1.1 Segmentation
+
+Control Stable Diffusion with Semantic Segmentation.
+
+Model file: control_v11p_sd15_seg.pth
+
+Config file: control_v11p_sd15_seg.yaml
+
+Training data: COCO + ADE20K.
+
+Acceptable Preprocessors: Seg_OFADE20K (Oneformer ADE20K), Seg_OFCOCO (Oneformer COCO), Seg_UFADE20K (Uniformer ADE20K), or manually created masks.
+
+Now the model can receive both type of ADE20K or COCO annotations. We find that recognizing the segmentation protocol is trivial for the ControlNet encoder and training the model of multiple segmentation protocols lead to better performance.
+
+    python gradio_seg.py
+
+Non-cherry-picked batch test with random seed 12345 (ADE20k protocol, "house"):
+
+![img](github_docs/imgs/seg_1.png)
+
+Non-cherry-picked batch test with random seed 12345 (COCO protocol, "house"):
+
+![img](github_docs/imgs/seg_2.png)
+
+**Improvements in Segmentation 1.1:**
+
+1. COCO protocol is supported. The previous Segmentation 1.0 supports about 150 colors, but Segmentation 1.1 supports another 182 colors from coco.
+2. Resumed from Segmentation 1.0. All previous inputs should still work.
+
+## ControlNet 1.1 Openpose
+
+Control Stable Diffusion with Openpose.
+
+Model file: control_v11p_sd15_openpose.pth
+
+Config file: control_v11p_sd15_openpose.yaml
+
+The model is trained and can accept the following combinations:
+
+* Openpose body
+* Openpose hand
+* Openpose face
+* Openpose body + Openpose hand
+* Openpose body + Openpose face
+* Openpose hand + Openpose face
+* Openpose body + Openpose hand + Openpose face
+
+However, providing all those combinations is too complicated. We recommend to provide the users with only two choices:
+
+* "Openpose" = Openpose body
+* "Openpose Full" = Openpose body + Openpose hand + Openpose face
+
+You can try with the demo:
+
+    python gradio_openpose.py
+
+Non-cherry-picked batch test with random seed 12345 ("man in suit"):
+
+![img](github_docs/imgs/openpose_1.png)
+
+Non-cherry-picked batch test with random seed 12345 (multiple people in the wild, "handsome boys in the party"):
+
+![img](github_docs/imgs/openpose_2.png)
+
+**Improvements in Openpose 1.1:**
+
+1. The improvement of this model is mainly based on our improved implementation of OpenPose. We carefully reviewed the difference between the pytorch OpenPose and CMU's c++ openpose. Now the processor should be more accurate, especially for hands. The improvement of processor leads to the improvement of Openpose 1.1.
+2. More inputs are supported (hand and face).
+3. The training dataset of previous cnet 1.0 has several problems including (1) a small group of greyscale human images are duplicated thousands of times (!!), causing the previous model somewhat likely to generate grayscale human images; (2) some images has low quality, very blurry, or significant JPEG artifacts; (3) a small group of images has wrong paired prompts caused by a mistake in our data processing scripts. The new model fixed all problems of the training dataset and should be more reasonable in many cases.
+
+## ControlNet 1.1 Lineart
+
+Control Stable Diffusion with Linearts.
+
+Model file: control_v11p_sd15_lineart.pth
+
+Config file: control_v11p_sd15_lineart.yaml
+
+This model is trained on awacke1/Image-to-Line-Drawings. The preprocessor can generate detailed or coarse linearts from images (Lineart and Lineart_Coarse). The model is trained with sufficient data augmentation and can receive manually drawn linearts.
+
+    python gradio_lineart.py
+
+Non-cherry-picked batch test with random seed 12345 (detailed lineart extractor, "bag"):
+
+![img](github_docs/imgs/lineart_1.png)
+
+Non-cherry-picked batch test with random seed 12345 (coarse lineart extractor, "Michael Jackson's concert"):
+
+![img](github_docs/imgs/lineart_2.png)
+
+Non-cherry-picked batch test with random seed 12345 (use manually drawn linearts, "wolf"):
+
+![img](github_docs/imgs/lineart_3.png)
+
+
+## ControlNet 1.1 Anime Lineart
+
+Control Stable Diffusion with Anime Linearts.
+
+Model file: control_v11p_sd15s2_lineart_anime.pth
+
+Config file: control_v11p_sd15s2_lineart_anime.yaml
+
+Training data and implementation details: (description removed).
+
+This model can take real anime line drawings or extracted line drawings as inputs.
+
+Some important notice:
+
+1. You need a file "anything-v3-full.safetensors" to run the demo. We will not provide the file. Please find that file on the Internet on your own.
+2. This model is trained with 3x token length and clip skip 2.
+3. This is a long prompt model. Unless you use LoRAs, results are better with long prompts.
+4. This model does not support Guess Mode.
+
+Demo:
+
+    python gradio_lineart_anime.py
+
+
+Non-cherry-picked batch test with random seed 12345 ("1girl, in classroom, skirt, uniform, red hair, bag, green eyes"):
+
+![img](github_docs/imgs/anime_3.png)
+
+Non-cherry-picked batch test with random seed 12345 ("1girl, saber, at night, sword, green eyes, golden hair, stocking"):
+
+![img](github_docs/imgs/anime_4.png)
+
+Non-cherry-picked batch test with random seed 12345 (extracted line drawing, "1girl, Castle, silver hair, dress, Gemstone, cinematic lighting, mechanical hand, 4k, 8k, extremely detailed, Gothic, green eye"):
+
+![img](github_docs/imgs/anime_6.png)
+
+## ControlNet 1.1 Shuffle
+
+Control Stable Diffusion with Content Shuffle.
+
+Model file: control_v11e_sd15_shuffle.pth
+
+Config file: control_v11e_sd15_shuffle.yaml
+
+Demo:
+
+    python gradio_shuffle.py
+
+The model is trained to reorganize images. [We use a random flow to shuffle the image and control Stable Diffusion to recompose the image.](github_docs/annotator.md#content-reshuffle)
+
+Non-cherry-picked batch test with random seed 12345 ("hong kong"):
+
+![img](github_docs/imgs/shuffle_1.png)
+
+In the 6 images on the right, the left-top one is the "shuffled" image. All others are outputs.
+
+In fact, since the ControlNet is trained to recompose images, we do not even need to shuffle the input - sometimes we can just use the original image as input.
+
+In this way, this ControlNet can be guided by prompts or other ControlNets to change the image style.
+
+Note that this method has nothing to do with CLIP vision or some other models. 
+
+This is a pure ControlNet.
+
+Non-cherry-picked batch test with random seed 12345 ("iron man"):
+
+![img](github_docs/imgs/shuffle_2.png)
+
+Non-cherry-picked batch test with random seed 12345 ("spider man"):
+
+![img](github_docs/imgs/shuffle_3.png)
+
+**Multi-ControlNets** (A1111-only)
+
+Source Image (not used):
+
+<img src="https://github.com/lllyasviel/ControlNet-v1-1-nightly/assets/19834515/56050654-6a82-495c-8bdc-d63847053e54" width="200">
+
+Canny Image (Input):
+
+<img src="https://github.com/lllyasviel/ControlNet-v1-1-nightly/assets/19834515/5dcb3d28-b845-4752-948d-6357224ca2ef" width="200">
+
+Shuffle Image (Input):
+
+<img src="https://github.com/lllyasviel/ControlNet-v1-1-nightly/assets/19834515/c0d98c17-d79b-49d8-96af-89b87c532820" width="200">
+
+Outputs:
+
+![image](https://github.com/lllyasviel/ControlNet-v1-1-nightly/assets/19834515/a4b30709-8393-43d1-9da2-5c6c5ea70e9c)
+
+(From: https://github.com/Mikubill/sd-webui-controlnet/issues/736#issuecomment-1509986321)
+
+**Important If You Implement Your Own Inference:**
+
+Note that this ControlNet requires to add a global average pooling " x = torch.mean(x, dim=(2, 3), keepdim=True) " between the ControlNet Encoder outputs and SD Unet layers. And the ControlNet must be put only on the conditional side of cfg scale. We recommend to use the "global_average_pooling" item in the yaml file to control such behaviors.
+
+~Note that this ControlNet Shuffle will be the one and only one image stylization method that we will maintain for the robustness in a long term support. We have tested other CLIP image encoder, Unclip, image tokenization, and image-based prompts but it seems that those methods do not work very well with user prompts or additional/multiple U-Net injections. See also the evidence [here](https://github.com/lllyasviel/ControlNet/issues/255), [here](https://github.com/Mikubill/sd-webui-controlnet/issues/547), and some other related issues.~ After some more recent researches/experiments, we plan to support more types of stylization methods in the future. 
+
+## ControlNet 1.1 Instruct Pix2Pix
+
+Control Stable Diffusion with Instruct Pix2Pix.
+
+Model file: control_v11e_sd15_ip2p.pth
+
+Config file: control_v11e_sd15_ip2p.yaml
+
+Demo:
+
+    python gradio_ip2p.py
+
+This is a controlnet trained on the [Instruct Pix2Pix dataset](https://github.com/timothybrooks/instruct-pix2pix).
+
+Different from official Instruct Pix2Pix, this model is trained with 50\% instruction prompts and 50\% description prompts. For example, "a cute boy" is a description prompt, while "make the boy cute" is a instruction prompt.
+
+Because this is a ControlNet, you do not need to trouble with original IP2P's double cfg tuning. And, this model can be applied to any base model.
+
+Also, it seems that instructions like "make it into X" works better than "make Y into X".
+
+Non-cherry-picked batch test with random seed 12345 ("make it on fire"):
+
+![img](github_docs/imgs/ip2p_1.png)
+
+Non-cherry-picked batch test with random seed 12345 ("make it winter"):
+
+![img](github_docs/imgs/ip2p_2.png)
+
+We mark this model as "experimental" because it sometimes needs cherry-picking. For example, here is non-cherry-picked batch test with random seed 12345 ("make he iron man"):
+
+![img](github_docs/imgs/ip2p_3.png)
+
+
+## ControlNet 1.1 Inpaint
+
+Control Stable Diffusion with Inpaint.
+
+Model file: control_v11p_sd15_inpaint.pth
+
+Config file: control_v11p_sd15_inpaint.yaml
+
+Demo:
+
+    python gradio_inpaint.py
+
+Some notices:
+
+1. This inpainting ControlNet is trained with 50\% random masks and 50\% random optical flow occlusion masks. This means the model can not only support the inpainting application but also work on video optical flow warping. Perhaps we will provide some example in the future (depending on our workloads).
+2. We updated the gradio (2023/5/11) so that the standalone gradio codes in main ControlNet repo also do not change unmasked areas. Automatic 1111 users are not influenced.
+
+Non-cherry-picked batch test with random seed 12345 ("a handsome man"):
+
+![img](github_docs/imgs/inpaint_after_fix.png)
+
+See also the Guidelines for [Using ControlNet Inpaint in Automatic 1111](https://github.com/Mikubill/sd-webui-controlnet/discussions/1143).
+
+## ControlNet 1.1 Tile
+
+Update 2023 April 25: The previously unfinished tile model is finished now. The new name is "control_v11f1e_sd15_tile". The "f1e" means 1st bug fix ("f1"), experimental ("e").  The previous "control_v11u_sd15_tile" is removed. Please update if your model name is "v11u".
+
+Control Stable Diffusion with Tiles.
+
+Model file: control_v11f1e_sd15_tile.pth
+
+Config file: control_v11f1e_sd15_tile.yaml
+
+Demo:
+
+    python gradio_tile.py
+
+The model can be used in many ways. Overall, the model has two behaviors:
+
+* Ignore the details in an image and generate new details.
+* Ignore global prompts if local tile semantics and prompts mismatch, and guide diffusion with local context.
+
+Because the model can generate new details and ignore existing image details, we can use this model to remove bad details and add refined details. For example, remove blurring caused by image resizing.
+
+Below is an example of 8x super resolution. This is a 64x64 dog image.
+
+![p](test_imgs/dog64.png)
+
+Non-cherry-picked batch test with random seed 12345 ("dog on grassland"):
+
+![img](github_docs/imgs/tile_new_1.png)
+
+Note that this model is not a super resolution model. It ignores the details in an image and generate new details. This means you can use it to fix bad details in an image.
+
+For example, below is a dog image corrupted by Real-ESRGAN. This is a typical example that sometimes super resolution methds fail to upscale images when source context is too small.
+
+![p](test_imgs/dog_bad_sr.png)
+
+Non-cherry-picked batch test with random seed 12345 ("dog on grassland"):
+
+![img](github_docs/imgs/tile_new_2.png)
+
+If your image already have good details, you can still use this model to replace image details. Note that Stable Diffusion's I2I can achieve similar effects but this model make it much easier for you to maintain the overall structure and only change details even with denoising strength 1.0 .
+
+Non-cherry-picked batch test with random seed 12345 ("Silver Armor"):
+
+![img](github_docs/imgs/tile_new_3.png)
+
+More and more people begin to think about different methods to diffuse at tiles so that images can be very big (at 4k or 8k). 
+
+The problem is that, in Stable Diffusion, your prompts will always influent each tile.
+
+For example, if your prompts are "a beautiful girl" and you split an image into 4×4=16 blocks and do diffusion in each block, then you are will get 16 "beautiful girls" rather than "a beautiful girl". This is a well-known problem.
+
+Right now people's solution is to use some meaningless prompts like "clear, clear, super clear" to diffuse blocks. But you can expect that the results will be bad if the denonising strength is high. And because the prompts are bad, the contents are pretty random.
+
+ControlNet Tile can solve this problem. For a given tile, it recognizes what is inside the tile and increase the influence of that recognized semantics, and it also decreases the influence of global prompts if contents do not match.
+
+Non-cherry-picked batch test with random seed 12345 ("a handsome man"):
+
+![img](github_docs/imgs/tile_new_4.png)
+
+You can see that the prompt is "a handsome man" but the model does not paint "a handsome man" on that tree leaves. Instead, it recognizes the tree leaves paint accordingly.
+
+In this way, ControlNet is able to change the behavior of any Stable Diffusion model to perform diffusion in tiles. 
+
+**Gallery of ControlNet Tile**
+
+*Note:* Our official support for tiled image upscaling is A1111-only. The gradio example in this repo does not include tiled upscaling scripts. Please use the A1111 extension to perform tiled upscaling (with other tiling scripts like Ultimate SD Upscale or Tiled Diffusion/VAE).
+
+From https://github.com/Mikubill/sd-webui-controlnet/discussions/1142#discussioncomment-5788601
+
+(Output, **Click image to see full resolution**)
+
+![grannie-comp](https://user-images.githubusercontent.com/54312595/235352555-846982dc-eba2-4e6a-8dfa-076a5e9ee4fd.jpg)
+
+(Zooming-in of outputs)
+
+![grannie-Comp_face](https://user-images.githubusercontent.com/54312595/235352557-8f90e59d-8d03-4909-b805-8643940973d0.jpg)
+
+![grannie-Comp_torso](https://user-images.githubusercontent.com/54312595/235352562-ad0a5618-a1dd-40d0-9bfe-65e9786b496f.jpg)
+
+![grannie-Comp_torso2](https://user-images.githubusercontent.com/54312595/235352567-4e9a887f-142f-4f65-8084-d4c7f602985b.jpg)
+
+From https://github.com/Mikubill/sd-webui-controlnet/discussions/1142#discussioncomment-5788617
+
+(Input)
+
+![image](https://user-images.githubusercontent.com/34932866/235639514-31df5838-e251-4a17-b6ad-a678cdb8a58d.png)
+
+(Output, **Click image to see full resolution**)
+![image](https://user-images.githubusercontent.com/34932866/235639422-1f95d228-f902-4d94-b57b-e67460a719ef.png)
+
+From: https://github.com/lllyasviel/ControlNet-v1-1-nightly/issues/50#issuecomment-1541914890
+
+(Input)
+
+![image](https://github.com/lllyasviel/ControlNet-v1-1-nightly/assets/19834515/9132700e-b2f9-4a33-a589-611ba234d325)
+
+(Output, **Click image to see full resolution**, note that this example is extremely challenging)
+
+![image](https://github.com/lllyasviel/ControlNet-v1-1-nightly/assets/19834515/609acf87-1e51-4c03-85dc-37e486566158)
+
+From https://github.com/Mikubill/sd-webui-controlnet/discussions/1142#discussioncomment-5796326:
+
+(before)
+
+![2600914554720735184649534855329348215514636378-166329422](https://user-images.githubusercontent.com/31148570/236037445-f91a060b-698a-4cae-bf18-93796351da66.png)
+
+(after, **Click image to see full resolution**)
+![2600914554720735184649534855329348215514636383-1549088886](https://user-images.githubusercontent.com/31148570/236037509-ce24c816-f50f-4fe0-8c19-423bf30dad26.png)
+
+**Comparison to Midjourney V5/V5.1 coming soon.**
+
+# Annotate Your Own Data
+
+We provide simple python scripts to process images.
+
+[See a gradio example here](github_docs/annotator.md).

CCEdit-main/src/controlnet11/annotator/util.py

@@ -0,0 +1,98 @@
+import random
+
+import numpy as np
+import cv2
+import os
+
+
+annotator_ckpts_path = os.path.join(os.path.dirname(__file__), 'ckpts')
+
+
+def HWC3(x):
+    assert x.dtype == np.uint8
+    if x.ndim == 2:
+        x = x[:, :, None]
+    assert x.ndim == 3
+    H, W, C = x.shape
+    assert C == 1 or C == 3 or C == 4
+    if C == 3:
+        return x
+    if C == 1:
+        return np.concatenate([x, x, x], axis=2)
+    if C == 4:
+        color = x[:, :, 0:3].astype(np.float32)
+        alpha = x[:, :, 3:4].astype(np.float32) / 255.0
+        y = color * alpha + 255.0 * (1.0 - alpha)
+        y = y.clip(0, 255).astype(np.uint8)
+        return y
+
+
+def resize_image(input_image, resolution):
+    H, W, C = input_image.shape
+    H = float(H)
+    W = float(W)
+    k = float(resolution) / min(H, W)
+    H *= k
+    W *= k
+    H = int(np.round(H / 64.0)) * 64
+    W = int(np.round(W / 64.0)) * 64
+    img = cv2.resize(input_image, (W, H), interpolation=cv2.INTER_LANCZOS4 if k > 1 else cv2.INTER_AREA)
+    return img
+
+
+def nms(x, t, s):
+    x = cv2.GaussianBlur(x.astype(np.float32), (0, 0), s)
+
+    f1 = np.array([[0, 0, 0], [1, 1, 1], [0, 0, 0]], dtype=np.uint8)
+    f2 = np.array([[0, 1, 0], [0, 1, 0], [0, 1, 0]], dtype=np.uint8)
+    f3 = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype=np.uint8)
+    f4 = np.array([[0, 0, 1], [0, 1, 0], [1, 0, 0]], dtype=np.uint8)
+
+    y = np.zeros_like(x)
+
+    for f in [f1, f2, f3, f4]:
+        np.putmask(y, cv2.dilate(x, kernel=f) == x, x)
+
+    z = np.zeros_like(y, dtype=np.uint8)
+    z[y > t] = 255
+    return z
+
+
+def make_noise_disk(H, W, C, F):
+    noise = np.random.uniform(low=0, high=1, size=((H // F) + 2, (W // F) + 2, C))
+    noise = cv2.resize(noise, (W + 2 * F, H + 2 * F), interpolation=cv2.INTER_CUBIC)
+    noise = noise[F: F + H, F: F + W]
+    noise -= np.min(noise)
+    noise /= np.max(noise)
+    if C == 1:
+        noise = noise[:, :, None]
+    return noise
+
+
+def min_max_norm(x):
+    x -= np.min(x)
+    x /= np.maximum(np.max(x), 1e-5)
+    return x
+
+
+def safe_step(x, step=2):
+    y = x.astype(np.float32) * float(step + 1)
+    y = y.astype(np.int32).astype(np.float32) / float(step)
+    return y
+
+
+def img2mask(img, H, W, low=10, high=90):
+    assert img.ndim == 3 or img.ndim == 2
+    assert img.dtype == np.uint8
+
+    if img.ndim == 3:
+        y = img[:, :, random.randrange(0, img.shape[2])]
+    else:
+        y = img
+
+    y = cv2.resize(y, (W, H), interpolation=cv2.INTER_CUBIC)
+
+    if random.uniform(0, 1) < 0.5:
+        y = 255 - y
+
+    return y < np.percentile(y, random.randrange(low, high))

CCEdit-main/src/controlnet11/annotator/zoe/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Intelligent Systems Lab Org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

CCEdit-main/src/controlnet11/annotator/zoe/__init__.py

@@ -0,0 +1,49 @@
+# ZoeDepth
+# https://github.com/isl-org/ZoeDepth
+
+import os
+import cv2
+import numpy as np
+import torch
+
+from einops import rearrange
+from .zoedepth.models.zoedepth.zoedepth_v1 import ZoeDepth
+from .zoedepth.utils.config import get_config
+from annotator.util import annotator_ckpts_path
+
+
+class ZoeDetector:
+    def __init__(self):
+        remote_model_path = "https://huggingface.co/lllyasviel/Annotators/resolve/main/ZoeD_M12_N.pt"
+        modelpath = os.path.join(annotator_ckpts_path, "ZoeD_M12_N.pt")
+        if not os.path.exists(modelpath):
+            from basicsr.utils.download_util import load_file_from_url
+            load_file_from_url(remote_model_path, model_dir=annotator_ckpts_path)
+        conf = get_config("zoedepth", "infer")
+        model = ZoeDepth.build_from_config(conf)
+        model.load_state_dict(torch.load(modelpath)['model'])
+        model = model.cuda()
+        model.device = 'cuda'
+        model.eval()
+        self.model = model
+
+    def __call__(self, input_image):
+        assert input_image.ndim == 3
+        image_depth = input_image
+        with torch.no_grad():
+            image_depth = torch.from_numpy(image_depth).float().cuda()
+            image_depth = image_depth / 255.0
+            image_depth = rearrange(image_depth, 'h w c -> 1 c h w')
+            depth = self.model.infer(image_depth)
+
+            depth = depth[0, 0].cpu().numpy()
+
+            vmin = np.percentile(depth, 2)
+            vmax = np.percentile(depth, 85)
+
+            depth -= vmin
+            depth /= vmax - vmin
+            depth = 1.0 - depth
+            depth_image = (depth * 255.0).clip(0, 255).astype(np.uint8)
+
+            return depth_image

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/__init__.py

@@ -0,0 +1,24 @@
+# MIT License
+
+# Copyright (c) 2022 Intelligent Systems Lab Org
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# File author: Shariq Farooq Bhat
+

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/__init__.py

@@ -0,0 +1,24 @@
+# MIT License
+
+# Copyright (c) 2022 Intelligent Systems Lab Org
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# File author: Shariq Farooq Bhat
+

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas.py

@@ -0,0 +1,379 @@
+# MIT License
+import os
+
+# Copyright (c) 2022 Intelligent Systems Lab Org
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# File author: Shariq Farooq Bhat
+
+import torch
+import torch.nn as nn
+import numpy as np
+from torchvision.transforms import Normalize
+
+
+def denormalize(x):
+    """Reverses the imagenet normalization applied to the input.
+
+    Args:
+        x (torch.Tensor - shape(N,3,H,W)): input tensor
+
+    Returns:
+        torch.Tensor - shape(N,3,H,W): Denormalized input
+    """
+    mean = torch.Tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1).to(x.device)
+    std = torch.Tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1).to(x.device)
+    return x * std + mean
+
+def get_activation(name, bank):
+    def hook(model, input, output):
+        bank[name] = output
+    return hook
+
+
+class Resize(object):
+    """Resize sample to given size (width, height).
+    """
+
+    def __init__(
+        self,
+        width,
+        height,
+        resize_target=True,
+        keep_aspect_ratio=False,
+        ensure_multiple_of=1,
+        resize_method="lower_bound",
+    ):
+        """Init.
+        Args:
+            width (int): desired output width
+            height (int): desired output height
+            resize_target (bool, optional):
+                True: Resize the full sample (image, mask, target).
+                False: Resize image only.
+                Defaults to True.
+            keep_aspect_ratio (bool, optional):
+                True: Keep the aspect ratio of the input sample.
+                Output sample might not have the given width and height, and
+                resize behaviour depends on the parameter 'resize_method'.
+                Defaults to False.
+            ensure_multiple_of (int, optional):
+                Output width and height is constrained to be multiple of this parameter.
+                Defaults to 1.
+            resize_method (str, optional):
+                "lower_bound": Output will be at least as large as the given size.
+                "upper_bound": Output will be at max as large as the given size. (Output size might be smaller than given size.)
+                "minimal": Scale as least as possible.  (Output size might be smaller than given size.)
+                Defaults to "lower_bound".
+        """
+        print("Params passed to Resize transform:")
+        print("\twidth: ", width)
+        print("\theight: ", height)
+        print("\tresize_target: ", resize_target)
+        print("\tkeep_aspect_ratio: ", keep_aspect_ratio)
+        print("\tensure_multiple_of: ", ensure_multiple_of)
+        print("\tresize_method: ", resize_method)
+
+        self.__width = width
+        self.__height = height
+
+        self.__keep_aspect_ratio = keep_aspect_ratio
+        self.__multiple_of = ensure_multiple_of
+        self.__resize_method = resize_method
+
+    def constrain_to_multiple_of(self, x, min_val=0, max_val=None):
+        y = (np.round(x / self.__multiple_of) * self.__multiple_of).astype(int)
+
+        if max_val is not None and y > max_val:
+            y = (np.floor(x / self.__multiple_of)
+                 * self.__multiple_of).astype(int)
+
+        if y < min_val:
+            y = (np.ceil(x / self.__multiple_of)
+                 * self.__multiple_of).astype(int)
+
+        return y
+
+    def get_size(self, width, height):
+        # determine new height and width
+        scale_height = self.__height / height
+        scale_width = self.__width / width
+
+        if self.__keep_aspect_ratio:
+            if self.__resize_method == "lower_bound":
+                # scale such that output size is lower bound
+                if scale_width > scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "upper_bound":
+                # scale such that output size is upper bound
+                if scale_width < scale_height:
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            elif self.__resize_method == "minimal":
+                # scale as least as possbile
+                if abs(1 - scale_width) < abs(1 - scale_height):
+                    # fit width
+                    scale_height = scale_width
+                else:
+                    # fit height
+                    scale_width = scale_height
+            else:
+                raise ValueError(
+                    f"resize_method {self.__resize_method} not implemented"
+                )
+
+        if self.__resize_method == "lower_bound":
+            new_height = self.constrain_to_multiple_of(
+                scale_height * height, min_val=self.__height
+            )
+            new_width = self.constrain_to_multiple_of(
+                scale_width * width, min_val=self.__width
+            )
+        elif self.__resize_method == "upper_bound":
+            new_height = self.constrain_to_multiple_of(
+                scale_height * height, max_val=self.__height
+            )
+            new_width = self.constrain_to_multiple_of(
+                scale_width * width, max_val=self.__width
+            )
+        elif self.__resize_method == "minimal":
+            new_height = self.constrain_to_multiple_of(scale_height * height)
+            new_width = self.constrain_to_multiple_of(scale_width * width)
+        else:
+            raise ValueError(
+                f"resize_method {self.__resize_method} not implemented")
+
+        return (new_width, new_height)
+
+    def __call__(self, x):
+        width, height = self.get_size(*x.shape[-2:][::-1])
+        return nn.functional.interpolate(x, (height, width), mode='bilinear', align_corners=True)
+
+class PrepForMidas(object):
+    def __init__(self, resize_mode="minimal", keep_aspect_ratio=True, img_size=384, do_resize=True):
+        if isinstance(img_size, int):
+            img_size = (img_size, img_size)
+        net_h, net_w = img_size
+        self.normalization = Normalize(
+            mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+        self.resizer = Resize(net_w, net_h, keep_aspect_ratio=keep_aspect_ratio, ensure_multiple_of=32, resize_method=resize_mode) \
+            if do_resize else nn.Identity()
+
+    def __call__(self, x):
+        return self.normalization(self.resizer(x))
+
+
+class MidasCore(nn.Module):
+    def __init__(self, midas, trainable=False, fetch_features=True, layer_names=('out_conv', 'l4_rn', 'r4', 'r3', 'r2', 'r1'), freeze_bn=False, keep_aspect_ratio=True,
+                 img_size=384, **kwargs):
+        """Midas Base model used for multi-scale feature extraction.
+
+        Args:
+            midas (torch.nn.Module): Midas model.
+            trainable (bool, optional): Train midas model. Defaults to False.
+            fetch_features (bool, optional): Extract multi-scale features. Defaults to True.
+            layer_names (tuple, optional): Layers used for feature extraction. Order = (head output features, last layer features, ...decoder features). Defaults to ('out_conv', 'l4_rn', 'r4', 'r3', 'r2', 'r1').
+            freeze_bn (bool, optional): Freeze BatchNorm. Generally results in better finetuning performance. Defaults to False.
+            keep_aspect_ratio (bool, optional): Keep the aspect ratio of input images while resizing. Defaults to True.
+            img_size (int, tuple, optional): Input resolution. Defaults to 384.
+        """
+        super().__init__()
+        self.core = midas
+        self.output_channels = None
+        self.core_out = {}
+        self.trainable = trainable
+        self.fetch_features = fetch_features
+        # midas.scratch.output_conv = nn.Identity()
+        self.handles = []
+        # self.layer_names = ['out_conv','l4_rn', 'r4', 'r3', 'r2', 'r1']
+        self.layer_names = layer_names
+
+        self.set_trainable(trainable)
+        self.set_fetch_features(fetch_features)
+
+        self.prep = PrepForMidas(keep_aspect_ratio=keep_aspect_ratio,
+                                 img_size=img_size, do_resize=kwargs.get('do_resize', True))
+
+        if freeze_bn:
+            self.freeze_bn()
+
+    def set_trainable(self, trainable):
+        self.trainable = trainable
+        if trainable:
+            self.unfreeze()
+        else:
+            self.freeze()
+        return self
+
+    def set_fetch_features(self, fetch_features):
+        self.fetch_features = fetch_features
+        if fetch_features:
+            if len(self.handles) == 0:
+                self.attach_hooks(self.core)
+        else:
+            self.remove_hooks()
+        return self
+
+    def freeze(self):
+        for p in self.parameters():
+            p.requires_grad = False
+        self.trainable = False
+        return self
+
+    def unfreeze(self):
+        for p in self.parameters():
+            p.requires_grad = True
+        self.trainable = True
+        return self
+
+    def freeze_bn(self):
+        for m in self.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+        return self
+
+    def forward(self, x, denorm=False, return_rel_depth=False):
+        with torch.no_grad():
+            if denorm:
+                x = denormalize(x)
+            x = self.prep(x)
+            # print("Shape after prep: ", x.shape)
+
+        with torch.set_grad_enabled(self.trainable):
+
+            # print("Input size to Midascore", x.shape)
+            rel_depth = self.core(x)
+            # print("Output from midas shape", rel_depth.shape)
+            if not self.fetch_features:
+                return rel_depth
+        out = [self.core_out[k] for k in self.layer_names]
+
+        if return_rel_depth:
+            return rel_depth, out
+        return out
+
+    def get_rel_pos_params(self):
+        for name, p in self.core.pretrained.named_parameters():
+            if "relative_position" in name:
+                yield p
+
+    def get_enc_params_except_rel_pos(self):
+        for name, p in self.core.pretrained.named_parameters():
+            if "relative_position" not in name:
+                yield p
+
+    def freeze_encoder(self, freeze_rel_pos=False):
+        if freeze_rel_pos:
+            for p in self.core.pretrained.parameters():
+                p.requires_grad = False
+        else:
+            for p in self.get_enc_params_except_rel_pos():
+                p.requires_grad = False
+        return self
+
+    def attach_hooks(self, midas):
+        if len(self.handles) > 0:
+            self.remove_hooks()
+        if "out_conv" in self.layer_names:
+            self.handles.append(list(midas.scratch.output_conv.children())[
+                                3].register_forward_hook(get_activation("out_conv", self.core_out)))
+        if "r4" in self.layer_names:
+            self.handles.append(midas.scratch.refinenet4.register_forward_hook(
+                get_activation("r4", self.core_out)))
+        if "r3" in self.layer_names:
+            self.handles.append(midas.scratch.refinenet3.register_forward_hook(
+                get_activation("r3", self.core_out)))
+        if "r2" in self.layer_names:
+            self.handles.append(midas.scratch.refinenet2.register_forward_hook(
+                get_activation("r2", self.core_out)))
+        if "r1" in self.layer_names:
+            self.handles.append(midas.scratch.refinenet1.register_forward_hook(
+                get_activation("r1", self.core_out)))
+        if "l4_rn" in self.layer_names:
+            self.handles.append(midas.scratch.layer4_rn.register_forward_hook(
+                get_activation("l4_rn", self.core_out)))
+
+        return self
+
+    def remove_hooks(self):
+        for h in self.handles:
+            h.remove()
+        return self
+
+    def __del__(self):
+        self.remove_hooks()
+
+    def set_output_channels(self, model_type):
+        self.output_channels = MIDAS_SETTINGS[model_type]
+
+    @staticmethod
+    def build(midas_model_type="DPT_BEiT_L_384", train_midas=False, use_pretrained_midas=True, fetch_features=False, freeze_bn=True, force_keep_ar=False, force_reload=False, **kwargs):
+        if midas_model_type not in MIDAS_SETTINGS:
+            raise ValueError(
+                f"Invalid model type: {midas_model_type}. Must be one of {list(MIDAS_SETTINGS.keys())}")
+        if "img_size" in kwargs:
+            kwargs = MidasCore.parse_img_size(kwargs)
+        img_size = kwargs.pop("img_size", [384, 384])
+        print("img_size", img_size)
+        midas_path = os.path.join(os.path.dirname(__file__), 'midas_repo')
+        midas = torch.hub.load(midas_path, midas_model_type,
+                               pretrained=use_pretrained_midas, force_reload=force_reload, source='local')
+        kwargs.update({'keep_aspect_ratio': force_keep_ar})
+        midas_core = MidasCore(midas, trainable=train_midas, fetch_features=fetch_features,
+                               freeze_bn=freeze_bn, img_size=img_size, **kwargs)
+        midas_core.set_output_channels(midas_model_type)
+        return midas_core
+
+    @staticmethod
+    def build_from_config(config):
+        return MidasCore.build(**config)
+
+    @staticmethod
+    def parse_img_size(config):
+        assert 'img_size' in config
+        if isinstance(config['img_size'], str):
+            assert "," in config['img_size'], "img_size should be a string with comma separated img_size=H,W"
+            config['img_size'] = list(map(int, config['img_size'].split(",")))
+            assert len(
+                config['img_size']) == 2, "img_size should be a string with comma separated img_size=H,W"
+        elif isinstance(config['img_size'], int):
+            config['img_size'] = [config['img_size'], config['img_size']]
+        else:
+            assert isinstance(config['img_size'], list) and len(
+                config['img_size']) == 2, "img_size should be a list of H,W"
+        return config
+
+
+nchannels2models = {
+    tuple([256]*5): ["DPT_BEiT_L_384", "DPT_BEiT_L_512", "DPT_BEiT_B_384", "DPT_SwinV2_L_384", "DPT_SwinV2_B_384", "DPT_SwinV2_T_256", "DPT_Large", "DPT_Hybrid"],
+    (512, 256, 128, 64, 64): ["MiDaS_small"]
+}
+
+# Model name to number of output channels
+MIDAS_SETTINGS = {m: k for k, v in nchannels2models.items()
+                  for m in v
+                  }

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/.gitignore

@@ -0,0 +1,110 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+*.png
+*.pfm
+*.jpg
+*.jpeg
+*.pt

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/Dockerfile

@@ -0,0 +1,29 @@
+# enables cuda support in docker
+FROM nvidia/cuda:10.2-cudnn7-runtime-ubuntu18.04
+
+# install python 3.6, pip and requirements for opencv-python 
+# (see https://github.com/NVIDIA/nvidia-docker/issues/864)
+RUN apt-get update && apt-get -y install \
+    python3 \
+    python3-pip \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# install python dependencies
+RUN pip3 install --upgrade pip
+RUN pip3 install torch~=1.8 torchvision opencv-python-headless~=3.4 timm
+
+# copy inference code
+WORKDIR /opt/MiDaS
+COPY ./midas ./midas
+COPY ./*.py ./
+
+# download model weights so the docker image can be used offline
+RUN cd weights && {curl -OL https://github.com/isl-org/MiDaS/releases/download/v3/dpt_hybrid_384.pt; cd -; }
+RUN python3 run.py --model_type dpt_hybrid; exit 0
+
+# entrypoint (dont forget to mount input and output directories)
+CMD python3 run.py --model_type dpt_hybrid

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/environment.yaml

@@ -0,0 +1,16 @@
+name: midas-py310
+channels:
+  - pytorch
+  - defaults
+dependencies:
+  - nvidia::cudatoolkit=11.7
+  - python=3.10.8
+  - pytorch::pytorch=1.13.0
+  - torchvision=0.14.0
+  - pip=22.3.1
+  - numpy=1.23.4
+  - pip:
+    - opencv-python==4.6.0.66
+    - imutils==0.5.4
+    - timm==0.6.12
+    - einops==0.6.0

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/.gitignore

@@ -0,0 +1,2 @@
+# ignore model file
+#*.tflite

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/Midas/AppDelegate.swift

@@ -0,0 +1,41 @@
+// Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import UIKit
+
+@UIApplicationMain
+class AppDelegate: UIResponder, UIApplicationDelegate {
+
+  var window: UIWindow?
+
+  func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
+    return true
+  }
+
+  func applicationWillResignActive(_ application: UIApplication) {
+  }
+
+  func applicationDidEnterBackground(_ application: UIApplication) {
+  }
+
+  func applicationWillEnterForeground(_ application: UIApplication) {
+  }
+
+  func applicationDidBecomeActive(_ application: UIApplication) {
+  }
+
+  func applicationWillTerminate(_ application: UIApplication) {
+  }
+}
+

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/Midas/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1 @@
+{"images":[{"size":"60x60","expected-size":"180","filename":"180.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"iphone","scale":"3x"},{"size":"40x40","expected-size":"80","filename":"80.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"iphone","scale":"2x"},{"size":"40x40","expected-size":"120","filename":"120.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"iphone","scale":"3x"},{"size":"60x60","expected-size":"120","filename":"120.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"iphone","scale":"2x"},{"size":"57x57","expected-size":"57","filename":"57.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"iphone","scale":"1x"},{"size":"29x29","expected-size":"58","filename":"58.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"iphone","scale":"2x"},{"size":"29x29","expected-size":"29","filename":"29.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"iphone","scale":"1x"},{"size":"29x29","expected-size":"87","filename":"87.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"iphone","scale":"3x"},{"size":"57x57","expected-size":"114","filename":"114.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"iphone","scale":"2x"},{"size":"20x20","expected-size":"40","filename":"40.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"iphone","scale":"2x"},{"size":"20x20","expected-size":"60","filename":"60.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"iphone","scale":"3x"},{"size":"1024x1024","filename":"1024.png","expected-size":"1024","idiom":"ios-marketing","folder":"Assets.xcassets/AppIcon.appiconset/","scale":"1x"},{"size":"40x40","expected-size":"80","filename":"80.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"ipad","scale":"2x"},{"size":"72x72","expected-size":"72","filename":"72.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"ipad","scale":"1x"},{"size":"76x76","expected-size":"152","filename":"152.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"ipad","scale":"2x"},{"size":"50x50","expected-size":"100","filename":"100.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"ipad","scale":"2x"},{"size":"29x29","expected-size":"58","filename":"58.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"ipad","scale":"2x"},{"size":"76x76","expected-size":"76","filename":"76.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"ipad","scale":"1x"},{"size":"29x29","expected-size":"29","filename":"29.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"ipad","scale":"1x"},{"size":"50x50","expected-size":"50","filename":"50.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"ipad","scale":"1x"},{"size":"72x72","expected-size":"144","filename":"144.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"ipad","scale":"2x"},{"size":"40x40","expected-size":"40","filename":"40.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"ipad","scale":"1x"},{"size":"83.5x83.5","expected-size":"167","filename":"167.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"ipad","scale":"2x"},{"size":"20x20","expected-size":"20","filename":"20.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"ipad","scale":"1x"},{"size":"20x20","expected-size":"40","filename":"40.png","folder":"Assets.xcassets/AppIcon.appiconset/","idiom":"ipad","scale":"2x"}]}

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/Midas/Assets.xcassets/Contents.json

@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  }
+}

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/Midas/Camera Feed/CameraFeedManager.swift

@@ -0,0 +1,316 @@
+// Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import AVFoundation
+import UIKit
+import os
+
+// MARK: - CameraFeedManagerDelegate Declaration
+@objc protocol CameraFeedManagerDelegate: class {
+  /// This method delivers the pixel buffer of the current frame seen by the device's camera.
+  @objc optional func cameraFeedManager(
+    _ manager: CameraFeedManager, didOutput pixelBuffer: CVPixelBuffer
+  )
+
+  /// This method initimates that a session runtime error occured.
+  func cameraFeedManagerDidEncounterSessionRunTimeError(_ manager: CameraFeedManager)
+
+  /// This method initimates that the session was interrupted.
+  func cameraFeedManager(
+    _ manager: CameraFeedManager, sessionWasInterrupted canResumeManually: Bool
+  )
+
+  /// This method initimates that the session interruption has ended.
+  func cameraFeedManagerDidEndSessionInterruption(_ manager: CameraFeedManager)
+
+  /// This method initimates that there was an error in video configurtion.
+  func presentVideoConfigurationErrorAlert(_ manager: CameraFeedManager)
+
+  /// This method initimates that the camera permissions have been denied.
+  func presentCameraPermissionsDeniedAlert(_ manager: CameraFeedManager)
+}
+
+/// This enum holds the state of the camera initialization.
+// MARK: - Camera Initialization State Enum
+enum CameraConfiguration {
+  case success
+  case failed
+  case permissionDenied
+}
+
+/// This class manages all camera related functionalities.
+// MARK: - Camera Related Functionalies Manager
+class CameraFeedManager: NSObject {
+  // MARK: Camera Related Instance Variables
+  private let session: AVCaptureSession = AVCaptureSession()
+
+  private let previewView: PreviewView
+  private let sessionQueue = DispatchQueue(label: "sessionQueue")
+  private var cameraConfiguration: CameraConfiguration = .failed
+  private lazy var videoDataOutput = AVCaptureVideoDataOutput()
+  private var isSessionRunning = false
+
+  // MARK: CameraFeedManagerDelegate
+  weak var delegate: CameraFeedManagerDelegate?
+
+  // MARK: Initializer
+  init(previewView: PreviewView) {
+    self.previewView = previewView
+    super.init()
+
+    // Initializes the session
+    session.sessionPreset = .high
+    self.previewView.session = session
+    self.previewView.previewLayer.connection?.videoOrientation = .portrait
+    self.previewView.previewLayer.videoGravity = .resizeAspectFill
+    self.attemptToConfigureSession()
+  }
+
+  // MARK: Session Start and End methods
+
+  /// This method starts an AVCaptureSession based on whether the camera configuration was successful.
+  func checkCameraConfigurationAndStartSession() {
+    sessionQueue.async {
+      switch self.cameraConfiguration {
+      case .success:
+        self.addObservers()
+        self.startSession()
+      case .failed:
+        DispatchQueue.main.async {
+          self.delegate?.presentVideoConfigurationErrorAlert(self)
+        }
+      case .permissionDenied:
+        DispatchQueue.main.async {
+          self.delegate?.presentCameraPermissionsDeniedAlert(self)
+        }
+      }
+    }
+  }
+
+  /// This method stops a running an AVCaptureSession.
+  func stopSession() {
+    self.removeObservers()
+    sessionQueue.async {
+      if self.session.isRunning {
+        self.session.stopRunning()
+        self.isSessionRunning = self.session.isRunning
+      }
+    }
+
+  }
+
+  /// This method resumes an interrupted AVCaptureSession.
+  func resumeInterruptedSession(withCompletion completion: @escaping (Bool) -> Void) {
+    sessionQueue.async {
+      self.startSession()
+
+      DispatchQueue.main.async {
+        completion(self.isSessionRunning)
+      }
+    }
+  }
+
+  /// This method starts the AVCaptureSession
+  private func startSession() {
+    self.session.startRunning()
+    self.isSessionRunning = self.session.isRunning
+  }
+
+  // MARK: Session Configuration Methods.
+  /// This method requests for camera permissions and handles the configuration of the session and stores the result of configuration.
+  private func attemptToConfigureSession() {
+    switch AVCaptureDevice.authorizationStatus(for: .video) {
+    case .authorized:
+      self.cameraConfiguration = .success
+    case .notDetermined:
+      self.sessionQueue.suspend()
+      self.requestCameraAccess(completion: { granted in
+        self.sessionQueue.resume()
+      })
+    case .denied:
+      self.cameraConfiguration = .permissionDenied
+    default:
+      break
+    }
+
+    self.sessionQueue.async {
+      self.configureSession()
+    }
+  }
+
+  /// This method requests for camera permissions.
+  private func requestCameraAccess(completion: @escaping (Bool) -> Void) {
+    AVCaptureDevice.requestAccess(for: .video) { (granted) in
+      if !granted {
+        self.cameraConfiguration = .permissionDenied
+      } else {
+        self.cameraConfiguration = .success
+      }
+      completion(granted)
+    }
+  }
+
+  /// This method handles all the steps to configure an AVCaptureSession.
+  private func configureSession() {
+    guard cameraConfiguration == .success else {
+      return
+    }
+    session.beginConfiguration()
+
+    // Tries to add an AVCaptureDeviceInput.
+    guard addVideoDeviceInput() == true else {
+      self.session.commitConfiguration()
+      self.cameraConfiguration = .failed
+      return
+    }
+
+    // Tries to add an AVCaptureVideoDataOutput.
+    guard addVideoDataOutput() else {
+      self.session.commitConfiguration()
+      self.cameraConfiguration = .failed
+      return
+    }
+
+    session.commitConfiguration()
+    self.cameraConfiguration = .success
+  }
+
+  /// This method tries to an AVCaptureDeviceInput to the current AVCaptureSession.
+  private func addVideoDeviceInput() -> Bool {
+    /// Tries to get the default back camera.
+    guard
+      let camera = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .back)
+      else {
+        fatalError("Cannot find camera")
+    }
+
+    do {
+      let videoDeviceInput = try AVCaptureDeviceInput(device: camera)
+      if session.canAddInput(videoDeviceInput) {
+        session.addInput(videoDeviceInput)
+        return true
+      } else {
+        return false
+      }
+    } catch {
+      fatalError("Cannot create video device input")
+    }
+  }
+
+  /// This method tries to an AVCaptureVideoDataOutput to the current AVCaptureSession.
+  private func addVideoDataOutput() -> Bool {
+    let sampleBufferQueue = DispatchQueue(label: "sampleBufferQueue")
+    videoDataOutput.setSampleBufferDelegate(self, queue: sampleBufferQueue)
+    videoDataOutput.alwaysDiscardsLateVideoFrames = true
+    videoDataOutput.videoSettings = [
+      String(kCVPixelBufferPixelFormatTypeKey): kCMPixelFormat_32BGRA
+    ]
+
+    if session.canAddOutput(videoDataOutput) {
+      session.addOutput(videoDataOutput)
+      videoDataOutput.connection(with: .video)?.videoOrientation = .portrait
+      return true
+    }
+    return false
+  }
+
+  // MARK: Notification Observer Handling
+  private func addObservers() {
+    NotificationCenter.default.addObserver(
+      self, selector: #selector(CameraFeedManager.sessionRuntimeErrorOccured(notification:)),
+      name: NSNotification.Name.AVCaptureSessionRuntimeError, object: session)
+    NotificationCenter.default.addObserver(
+      self, selector: #selector(CameraFeedManager.sessionWasInterrupted(notification:)),
+      name: NSNotification.Name.AVCaptureSessionWasInterrupted, object: session)
+    NotificationCenter.default.addObserver(
+      self, selector: #selector(CameraFeedManager.sessionInterruptionEnded),
+      name: NSNotification.Name.AVCaptureSessionInterruptionEnded, object: session)
+  }
+
+  private func removeObservers() {
+    NotificationCenter.default.removeObserver(
+      self, name: NSNotification.Name.AVCaptureSessionRuntimeError, object: session)
+    NotificationCenter.default.removeObserver(
+      self, name: NSNotification.Name.AVCaptureSessionWasInterrupted, object: session)
+    NotificationCenter.default.removeObserver(
+      self, name: NSNotification.Name.AVCaptureSessionInterruptionEnded, object: session)
+  }
+
+  // MARK: Notification Observers
+  @objc func sessionWasInterrupted(notification: Notification) {
+    if let userInfoValue = notification.userInfo?[AVCaptureSessionInterruptionReasonKey]
+      as AnyObject?,
+      let reasonIntegerValue = userInfoValue.integerValue,
+      let reason = AVCaptureSession.InterruptionReason(rawValue: reasonIntegerValue)
+    {
+      os_log("Capture session was interrupted with reason: %s", type: .error, reason.rawValue)
+
+      var canResumeManually = false
+      if reason == .videoDeviceInUseByAnotherClient {
+        canResumeManually = true
+      } else if reason == .videoDeviceNotAvailableWithMultipleForegroundApps {
+        canResumeManually = false
+      }
+
+      delegate?.cameraFeedManager(self, sessionWasInterrupted: canResumeManually)
+
+    }
+  }
+
+  @objc func sessionInterruptionEnded(notification: Notification) {
+    delegate?.cameraFeedManagerDidEndSessionInterruption(self)
+  }
+
+  @objc func sessionRuntimeErrorOccured(notification: Notification) {
+    guard let error = notification.userInfo?[AVCaptureSessionErrorKey] as? AVError else {
+      return
+    }
+
+    os_log("Capture session runtime error: %s", type: .error, error.localizedDescription)
+
+    if error.code == .mediaServicesWereReset {
+      sessionQueue.async {
+        if self.isSessionRunning {
+          self.startSession()
+        } else {
+          DispatchQueue.main.async {
+            self.delegate?.cameraFeedManagerDidEncounterSessionRunTimeError(self)
+          }
+        }
+      }
+    } else {
+      delegate?.cameraFeedManagerDidEncounterSessionRunTimeError(self)
+    }
+  }
+}
+
+/// AVCaptureVideoDataOutputSampleBufferDelegate
+extension CameraFeedManager: AVCaptureVideoDataOutputSampleBufferDelegate {
+  /// This method delegates the CVPixelBuffer of the frame seen by the camera currently.
+  func captureOutput(
+    _ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer,
+    from connection: AVCaptureConnection
+  ) {
+
+    // Converts the CMSampleBuffer to a CVPixelBuffer.
+    let pixelBuffer: CVPixelBuffer? = CMSampleBufferGetImageBuffer(sampleBuffer)
+
+    guard let imagePixelBuffer = pixelBuffer else {
+      return
+    }
+
+    // Delegates the pixel buffer to the ViewController.
+    delegate?.cameraFeedManager?(self, didOutput: imagePixelBuffer)
+  }
+}

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/Midas/Camera Feed/PreviewView.swift

@@ -0,0 +1,39 @@
+// Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import UIKit
+import AVFoundation
+
+ /// The camera frame is displayed on this view.
+class PreviewView: UIView {
+  var previewLayer: AVCaptureVideoPreviewLayer {
+    guard let layer = layer as? AVCaptureVideoPreviewLayer else {
+      fatalError("Layer expected is of type VideoPreviewLayer")
+    }
+    return layer
+  }
+
+  var session: AVCaptureSession? {
+    get {
+      return previewLayer.session
+    }
+    set {
+      previewLayer.session = newValue
+    }
+  }
+
+  override class var layerClass: AnyClass {
+    return AVCaptureVideoPreviewLayer.self
+  }
+}

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/Midas/Cells/InfoCell.swift

@@ -0,0 +1,21 @@
+// Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import UIKit
+
+/// Table cell for inference result in bottom view.
+class InfoCell: UITableViewCell {
+  @IBOutlet weak var fieldNameLabel: UILabel!
+  @IBOutlet weak var infoLabel: UILabel!
+}

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/Midas/Constants.swift

@@ -0,0 +1,25 @@
+// Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// =============================================================================
+
+enum Constants {
+  // MARK: - Constants related to the image processing
+  static let bgraPixel = (channels: 4, alphaComponent: 3, lastBgrComponent: 2)
+  static let rgbPixelChannels = 3
+  static let maxRGBValue: Float32 = 255.0
+
+  // MARK: - Constants related to the model interperter
+  static let defaultThreadCount = 2
+  static let defaultDelegate: Delegates = .CPU
+}

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/Midas/Extensions/CGSizeExtension.swift

@@ -0,0 +1,45 @@
+// Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// =============================================================================
+
+import Accelerate
+import Foundation
+
+extension CGSize {
+  /// Returns `CGAfineTransform` to resize `self` to fit in destination size, keeping aspect ratio
+  /// of `self`. `self` image is resized to be inscribe to destination size and located in center of
+  /// destination.
+  ///
+  /// - Parameter toFitIn: destination size to be filled.
+  /// - Returns: `CGAffineTransform` to transform `self` image to `dest` image.
+  func transformKeepAspect(toFitIn dest: CGSize) -> CGAffineTransform {
+    let sourceRatio = self.height / self.width
+    let destRatio = dest.height / dest.width
+
+    // Calculates ratio `self` to `dest`.
+    var ratio: CGFloat
+    var x: CGFloat = 0
+    var y: CGFloat = 0
+    if sourceRatio > destRatio {
+      // Source size is taller than destination. Resized to fit in destination height, and find
+      // horizontal starting point to be centered.
+      ratio = dest.height / self.height
+      x = (dest.width - self.width * ratio) / 2
+    } else {
+      ratio = dest.width / self.width
+      y = (dest.height - self.height * ratio) / 2
+    }
+    return CGAffineTransform(a: ratio, b: 0, c: 0, d: ratio, tx: x, ty: y)
+  }
+}

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/Midas/Extensions/CVPixelBufferExtension.swift

@@ -0,0 +1,172 @@
+// Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// =============================================================================
+
+import Accelerate
+import Foundation
+
+extension CVPixelBuffer {
+  var size: CGSize {
+    return CGSize(width: CVPixelBufferGetWidth(self), height: CVPixelBufferGetHeight(self))
+  }
+
+  /// Returns a new `CVPixelBuffer` created by taking the self area and resizing it to the
+  /// specified target size. Aspect ratios of source image and destination image are expected to be
+  /// same.
+  ///
+  /// - Parameters:
+  ///   - from: Source area of image to be cropped and resized.
+  ///   - to: Size to scale the image to(i.e. image size used while training the model).
+  /// - Returns: The cropped and resized image of itself.
+  func resize(from source: CGRect, to size: CGSize) -> CVPixelBuffer? {
+    let rect = CGRect(origin: CGPoint(x: 0, y: 0), size: self.size)
+    guard rect.contains(source) else {
+      os_log("Resizing Error: source area is out of index", type: .error)
+      return nil
+    }
+    guard rect.size.width / rect.size.height - source.size.width / source.size.height < 1e-5
+    else {
+      os_log(
+        "Resizing Error: source image ratio and destination image ratio is different",
+        type: .error)
+      return nil
+    }
+
+    let inputImageRowBytes = CVPixelBufferGetBytesPerRow(self)
+    let imageChannels = 4
+
+    CVPixelBufferLockBaseAddress(self, CVPixelBufferLockFlags(rawValue: 0))
+    defer { CVPixelBufferUnlockBaseAddress(self, CVPixelBufferLockFlags(rawValue: 0)) }
+
+    // Finds the address of the upper leftmost pixel of the source area.
+    guard
+      let inputBaseAddress = CVPixelBufferGetBaseAddress(self)?.advanced(
+        by: Int(source.minY) * inputImageRowBytes + Int(source.minX) * imageChannels)
+    else {
+      return nil
+    }
+
+    // Crops given area as vImage Buffer.
+    var croppedImage = vImage_Buffer(
+      data: inputBaseAddress, height: UInt(source.height), width: UInt(source.width),
+      rowBytes: inputImageRowBytes)
+
+    let resultRowBytes = Int(size.width) * imageChannels
+    guard let resultAddress = malloc(Int(size.height) * resultRowBytes) else {
+      return nil
+    }
+
+    // Allocates a vacant vImage buffer for resized image.
+    var resizedImage = vImage_Buffer(
+      data: resultAddress,
+      height: UInt(size.height), width: UInt(size.width),
+      rowBytes: resultRowBytes
+    )
+
+    // Performs the scale operation on cropped image and stores it in result image buffer.
+    guard vImageScale_ARGB8888(&croppedImage, &resizedImage, nil, vImage_Flags(0)) == kvImageNoError
+    else {
+      return nil
+    }
+
+    let releaseCallBack: CVPixelBufferReleaseBytesCallback = { mutablePointer, pointer in
+      if let pointer = pointer {
+        free(UnsafeMutableRawPointer(mutating: pointer))
+      }
+    }
+
+    var result: CVPixelBuffer?
+
+    // Converts the thumbnail vImage buffer to CVPixelBuffer
+    let conversionStatus = CVPixelBufferCreateWithBytes(
+      nil,
+      Int(size.width), Int(size.height),
+      CVPixelBufferGetPixelFormatType(self),
+      resultAddress,
+      resultRowBytes,
+      releaseCallBack,
+      nil,
+      nil,
+      &result
+    )
+
+    guard conversionStatus == kCVReturnSuccess else {
+      free(resultAddress)
+      return nil
+    }
+
+    return result
+  }
+
+  /// Returns the RGB `Data` representation of the given image buffer.
+  ///
+  /// - Parameters:
+  ///   - isModelQuantized: Whether the model is quantized (i.e. fixed point values rather than
+  ///       floating point values).
+  /// - Returns: The RGB data representation of the image buffer or `nil` if the buffer could not be
+  ///     converted.
+  func rgbData(
+    isModelQuantized: Bool
+  ) -> Data? {
+    CVPixelBufferLockBaseAddress(self, .readOnly)
+    defer { CVPixelBufferUnlockBaseAddress(self, .readOnly) }
+    guard let sourceData = CVPixelBufferGetBaseAddress(self) else {
+      return nil
+    }
+
+    let width = CVPixelBufferGetWidth(self)
+    let height = CVPixelBufferGetHeight(self)
+    let sourceBytesPerRow = CVPixelBufferGetBytesPerRow(self)
+    let destinationBytesPerRow = Constants.rgbPixelChannels * width
+
+    // Assign input image to `sourceBuffer` to convert it.
+    var sourceBuffer = vImage_Buffer(
+      data: sourceData,
+      height: vImagePixelCount(height),
+      width: vImagePixelCount(width),
+      rowBytes: sourceBytesPerRow)
+
+    // Make `destinationBuffer` and `destinationData` for its data to be assigned.
+    guard let destinationData = malloc(height * destinationBytesPerRow) else {
+      os_log("Error: out of memory", type: .error)
+      return nil
+    }
+    defer { free(destinationData) }
+    var destinationBuffer = vImage_Buffer(
+      data: destinationData,
+      height: vImagePixelCount(height),
+      width: vImagePixelCount(width),
+      rowBytes: destinationBytesPerRow)
+
+    // Convert image type.
+    switch CVPixelBufferGetPixelFormatType(self) {
+    case kCVPixelFormatType_32BGRA:
+      vImageConvert_BGRA8888toRGB888(&sourceBuffer, &destinationBuffer, UInt32(kvImageNoFlags))
+    case kCVPixelFormatType_32ARGB:
+      vImageConvert_BGRA8888toRGB888(&sourceBuffer, &destinationBuffer, UInt32(kvImageNoFlags))
+    default:
+      os_log("The type of this image is not supported.", type: .error)
+      return nil
+    }
+
+    // Make `Data` with converted image.
+    let imageByteData = Data(
+      bytes: destinationBuffer.data, count: destinationBuffer.rowBytes * height)
+
+    if isModelQuantized { return imageByteData }
+
+    let imageBytes = [UInt8](imageByteData)
+    return Data(copyingBufferOf: imageBytes.map { Float($0) / Constants.maxRGBValue })
+  }
+}

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/Midas/Extensions/TFLiteExtension.swift

@@ -0,0 +1,75 @@
+// Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// =============================================================================
+
+import Accelerate
+import CoreImage
+import Foundation
+import TensorFlowLite
+
+// MARK: - Data
+extension Data {
+  /// Creates a new buffer by copying the buffer pointer of the given array.
+  ///
+  /// - Warning: The given array's element type `T` must be trivial in that it can be copied bit
+  ///     for bit with no indirection or reference-counting operations; otherwise, reinterpreting
+  ///     data from the resulting buffer has undefined behavior.
+  /// - Parameter array: An array with elements of type `T`.
+  init<T>(copyingBufferOf array: [T]) {
+    self = array.withUnsafeBufferPointer(Data.init)
+  }
+
+  /// Convert a Data instance to Array representation.
+  func toArray<T>(type: T.Type) -> [T] where T: AdditiveArithmetic {
+    var array = [T](repeating: T.zero, count: self.count / MemoryLayout<T>.stride)
+    _ = array.withUnsafeMutableBytes { self.copyBytes(to: $0) }
+    return array
+  }
+}
+
+// MARK: - Wrappers
+/// Struct for handling multidimension `Data` in flat `Array`.
+struct FlatArray<Element: AdditiveArithmetic> {
+  private var array: [Element]
+  var dimensions: [Int]
+
+  init(tensor: Tensor) {
+    dimensions = tensor.shape.dimensions
+    array = tensor.data.toArray(type: Element.self)
+  }
+
+  private func flatIndex(_ index: [Int]) -> Int {
+    guard index.count == dimensions.count else {
+      fatalError("Invalid index: got \(index.count) index(es) for \(dimensions.count) index(es).")
+    }
+
+    var result = 0
+    for i in 0..<dimensions.count {
+      guard dimensions[i] > index[i] else {
+        fatalError("Invalid index: \(index[i]) is bigger than \(dimensions[i])")
+      }
+      result = dimensions[i] * result + index[i]
+    }
+    return result
+  }
+
+  subscript(_ index: Int...) -> Element {
+    get {
+      return array[flatIndex(index)]
+    }
+    set(newValue) {
+      array[flatIndex(index)] = newValue
+    }
+  }
+}

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/Midas/Info.plist

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+	<key>LSRequiresIPhoneOS</key>
+	<true/>
+	<key>NSCameraUsageDescription</key>
+	<string>This app will use camera to continuously estimate the depth map.</string>
+	<key>UILaunchStoryboardName</key>
+	<string>LaunchScreen</string>
+	<key>UIMainStoryboardFile</key>
+	<string>Main</string>
+	<key>UIRequiredDeviceCapabilities</key>
+	<array>
+		<string>armv7</string>
+	</array>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+	</array>
+	<key>UISupportedInterfaceOrientations~ipad</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+	</array>
+</dict>
+</plist>

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/Midas/ModelDataHandler/ModelDataHandler.swift

@@ -0,0 +1,464 @@
+// Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Accelerate
+import CoreImage
+import Foundation
+import TensorFlowLite
+import UIKit
+
+/// This class handles all data preprocessing and makes calls to run inference on a given frame
+/// by invoking the `Interpreter`. It then formats the inferences obtained.
+class ModelDataHandler {
+  // MARK: - Private Properties
+
+  /// TensorFlow Lite `Interpreter` object for performing inference on a given model.
+  private var interpreter: Interpreter
+
+  /// TensorFlow lite `Tensor` of model input and output.
+  private var inputTensor: Tensor
+
+  //private var heatsTensor: Tensor
+  //private var offsetsTensor: Tensor
+  private var outputTensor: Tensor
+  // MARK: - Initialization
+
+  /// A failable initializer for `ModelDataHandler`. A new instance is created if the model is
+  /// successfully loaded from the app's main bundle. Default `threadCount` is 2.
+  init(
+    threadCount: Int = Constants.defaultThreadCount,
+    delegate: Delegates = Constants.defaultDelegate
+  ) throws {
+    // Construct the path to the model file.
+    guard
+      let modelPath = Bundle.main.path(
+        forResource: Model.file.name,
+        ofType: Model.file.extension
+      )
+    else {
+      fatalError("Failed to load the model file with name: \(Model.file.name).")
+    }
+
+    // Specify the options for the `Interpreter`.
+    var options = Interpreter.Options()
+    options.threadCount = threadCount
+
+    // Specify the delegates for the `Interpreter`.
+    var delegates: [Delegate]?
+    switch delegate {
+    case .Metal:
+      delegates = [MetalDelegate()]
+    case .CoreML:
+      if let coreMLDelegate = CoreMLDelegate() {
+        delegates = [coreMLDelegate]
+      } else {
+        delegates = nil
+      }
+    default:
+      delegates = nil
+    }
+
+    // Create the `Interpreter`.
+    interpreter = try Interpreter(modelPath: modelPath, options: options, delegates: delegates)
+
+    // Initialize input and output `Tensor`s.
+    // Allocate memory for the model's input `Tensor`s.
+    try interpreter.allocateTensors()
+
+    // Get allocated input and output `Tensor`s.
+    inputTensor = try interpreter.input(at: 0)
+    outputTensor = try interpreter.output(at: 0)
+    //heatsTensor = try interpreter.output(at: 0)
+    //offsetsTensor = try interpreter.output(at: 1)
+
+    /*
+    // Check if input and output `Tensor`s are in the expected formats.
+    guard (inputTensor.dataType == .uInt8) == Model.isQuantized else {
+      fatalError("Unexpected Model: quantization is \(!Model.isQuantized)")
+    }
+
+    guard inputTensor.shape.dimensions[0] == Model.input.batchSize,
+      inputTensor.shape.dimensions[1] == Model.input.height,
+      inputTensor.shape.dimensions[2] == Model.input.width,
+      inputTensor.shape.dimensions[3] == Model.input.channelSize
+    else {
+      fatalError("Unexpected Model: input shape")
+    }
+
+    
+    guard heatsTensor.shape.dimensions[0] == Model.output.batchSize,
+      heatsTensor.shape.dimensions[1] == Model.output.height,
+      heatsTensor.shape.dimensions[2] == Model.output.width,
+      heatsTensor.shape.dimensions[3] == Model.output.keypointSize
+    else {
+      fatalError("Unexpected Model: heat tensor")
+    }
+
+    guard offsetsTensor.shape.dimensions[0] == Model.output.batchSize,
+      offsetsTensor.shape.dimensions[1] == Model.output.height,
+      offsetsTensor.shape.dimensions[2] == Model.output.width,
+      offsetsTensor.shape.dimensions[3] == Model.output.offsetSize
+    else {
+      fatalError("Unexpected Model: offset tensor")
+    }
+ */
+
+  }
+
+  /// Runs Midas model with given image with given source area to destination area.
+  ///
+  /// - Parameters:
+  ///   - on: Input image to run the model.
+  ///   - from: Range of input image to run the model.
+  ///   - to: Size of view to render the result.
+  /// - Returns: Result of the inference and the times consumed in every steps.
+  func runMidas(on pixelbuffer: CVPixelBuffer, from source: CGRect, to dest: CGSize)
+    //-> (Result, Times)?
+    //-> (FlatArray<Float32>, Times)?
+    -> ([Float], Int, Int, Times)?
+  {
+    // Start times of each process.
+    let preprocessingStartTime: Date
+    let inferenceStartTime: Date
+    let postprocessingStartTime: Date
+
+    // Processing times in miliseconds.
+    let preprocessingTime: TimeInterval
+    let inferenceTime: TimeInterval
+    let postprocessingTime: TimeInterval
+
+    preprocessingStartTime = Date()
+    guard let data = preprocess(of: pixelbuffer, from: source) else {
+      os_log("Preprocessing failed", type: .error)
+      return nil
+    }
+    preprocessingTime = Date().timeIntervalSince(preprocessingStartTime) * 1000
+
+    inferenceStartTime = Date()
+    inference(from: data)
+    inferenceTime = Date().timeIntervalSince(inferenceStartTime) * 1000
+
+    postprocessingStartTime = Date()
+    //guard let result = postprocess(to: dest) else {
+    //  os_log("Postprocessing failed", type: .error)
+    //  return nil
+    //}
+    postprocessingTime = Date().timeIntervalSince(postprocessingStartTime) * 1000
+
+
+    let results: [Float]
+    switch outputTensor.dataType {
+    case .uInt8:
+      guard let quantization = outputTensor.quantizationParameters else {
+        print("No results returned because the quantization values for the output tensor are nil.")
+        return nil
+      }
+      let quantizedResults = [UInt8](outputTensor.data)
+      results = quantizedResults.map {
+        quantization.scale * Float(Int($0) - quantization.zeroPoint)
+      }
+    case .float32:
+      results = [Float32](unsafeData: outputTensor.data) ?? []
+    default:
+      print("Output tensor data type \(outputTensor.dataType) is unsupported for this example app.")
+      return nil
+    }
+    
+    
+    let times = Times(
+      preprocessing: preprocessingTime,
+      inference: inferenceTime,
+      postprocessing: postprocessingTime)
+
+    return (results, Model.input.width, Model.input.height, times)
+  }
+
+  // MARK: - Private functions to run model
+  /// Preprocesses given rectangle image to be `Data` of disired size by croping and resizing it.
+  ///
+  /// - Parameters:
+  ///   - of: Input image to crop and resize.
+  ///   - from: Target area to be cropped and resized.
+  /// - Returns: The cropped and resized image. `nil` if it can not be processed.
+  private func preprocess(of pixelBuffer: CVPixelBuffer, from targetSquare: CGRect) -> Data? {
+    let sourcePixelFormat = CVPixelBufferGetPixelFormatType(pixelBuffer)
+    assert(sourcePixelFormat == kCVPixelFormatType_32BGRA)
+
+    // Resize `targetSquare` of input image to `modelSize`.
+    let modelSize = CGSize(width: Model.input.width, height: Model.input.height)
+    guard let thumbnail = pixelBuffer.resize(from: targetSquare, to: modelSize)
+    else {
+      return nil
+    }
+
+    // Remove the alpha component from the image buffer to get the initialized `Data`.
+    let byteCount =
+      Model.input.batchSize
+      * Model.input.height * Model.input.width
+      * Model.input.channelSize
+    guard
+      let inputData = thumbnail.rgbData(
+        isModelQuantized: Model.isQuantized
+      )
+    else {
+      os_log("Failed to convert the image buffer to RGB data.", type: .error)
+      return nil
+    }
+
+    return inputData
+  }
+
+   
+    
+    /*
+  /// Postprocesses output `Tensor`s to `Result` with size of view to render the result.
+  ///
+  /// - Parameters:
+  ///   - to: Size of view to be displaied.
+  /// - Returns: Postprocessed `Result`. `nil` if it can not be processed.
+  private func postprocess(to viewSize: CGSize) -> Result? {
+    // MARK: Formats output tensors
+    // Convert `Tensor` to `FlatArray`. As Midas is not quantized, convert them to Float type
+    // `FlatArray`.
+    let heats = FlatArray<Float32>(tensor: heatsTensor)
+    let offsets = FlatArray<Float32>(tensor: offsetsTensor)
+
+    // MARK: Find position of each key point
+    // Finds the (row, col) locations of where the keypoints are most likely to be. The highest
+    // `heats[0, row, col, keypoint]` value, the more likely `keypoint` being located in (`row`,
+    // `col`).
+    let keypointPositions = (0..<Model.output.keypointSize).map { keypoint -> (Int, Int) in
+      var maxValue = heats[0, 0, 0, keypoint]
+      var maxRow = 0
+      var maxCol = 0
+      for row in 0..<Model.output.height {
+        for col in 0..<Model.output.width {
+          if heats[0, row, col, keypoint] > maxValue {
+            maxValue = heats[0, row, col, keypoint]
+            maxRow = row
+            maxCol = col
+          }
+        }
+      }
+      return (maxRow, maxCol)
+    }
+
+    // MARK: Calculates total confidence score
+    // Calculates total confidence score of each key position.
+    let totalScoreSum = keypointPositions.enumerated().reduce(0.0) { accumulator, elem -> Float32 in
+      accumulator + sigmoid(heats[0, elem.element.0, elem.element.1, elem.offset])
+    }
+    let totalScore = totalScoreSum / Float32(Model.output.keypointSize)
+
+    // MARK: Calculate key point position on model input
+    // Calculates `KeyPoint` coordination model input image with `offsets` adjustment.
+    let coords = keypointPositions.enumerated().map { index, elem -> (y: Float32, x: Float32) in
+      let (y, x) = elem
+      let yCoord =
+        Float32(y) / Float32(Model.output.height - 1) * Float32(Model.input.height)
+        + offsets[0, y, x, index]
+      let xCoord =
+        Float32(x) / Float32(Model.output.width - 1) * Float32(Model.input.width)
+        + offsets[0, y, x, index + Model.output.keypointSize]
+      return (y: yCoord, x: xCoord)
+    }
+
+    // MARK: Transform key point position and make lines
+    // Make `Result` from `keypointPosition'. Each point is adjusted to `ViewSize` to be drawn.
+    var result = Result(dots: [], lines: [], score: totalScore)
+    var bodyPartToDotMap = [BodyPart: CGPoint]()
+    for (index, part) in BodyPart.allCases.enumerated() {
+      let position = CGPoint(
+        x: CGFloat(coords[index].x) * viewSize.width / CGFloat(Model.input.width),
+        y: CGFloat(coords[index].y) * viewSize.height / CGFloat(Model.input.height)
+      )
+      bodyPartToDotMap[part] = position
+      result.dots.append(position)
+    }
+
+    do {
+      try result.lines = BodyPart.lines.map { map throws -> Line in
+        guard let from = bodyPartToDotMap[map.from] else {
+          throw PostprocessError.missingBodyPart(of: map.from)
+        }
+        guard let to = bodyPartToDotMap[map.to] else {
+          throw PostprocessError.missingBodyPart(of: map.to)
+        }
+        return Line(from: from, to: to)
+      }
+    } catch PostprocessError.missingBodyPart(let missingPart) {
+      os_log("Postprocessing error: %s is missing.", type: .error, missingPart.rawValue)
+      return nil
+    } catch {
+      os_log("Postprocessing error: %s", type: .error, error.localizedDescription)
+      return nil
+    }
+
+    return result
+  }
+*/
+    
+
+    
+  /// Run inference with given `Data`
+  ///
+  /// Parameter `from`: `Data` of input image to run model.
+  private func inference(from data: Data) {
+    // Copy the initialized `Data` to the input `Tensor`.
+    do {
+      try interpreter.copy(data, toInputAt: 0)
+
+      // Run inference by invoking the `Interpreter`.
+      try interpreter.invoke()
+
+      // Get the output `Tensor` to process the inference results.
+      outputTensor = try interpreter.output(at: 0)
+      //heatsTensor = try interpreter.output(at: 0)
+      //offsetsTensor = try interpreter.output(at: 1)
+        
+
+    } catch let error {
+      os_log(
+        "Failed to invoke the interpreter with error: %s", type: .error,
+        error.localizedDescription)
+      return
+    }
+  }
+
+  /// Returns value within [0,1].
+  private func sigmoid(_ x: Float32) -> Float32 {
+    return (1.0 / (1.0 + exp(-x)))
+  }
+}
+
+// MARK: - Data types for inference result
+struct KeyPoint {
+  var bodyPart: BodyPart = BodyPart.NOSE
+  var position: CGPoint = CGPoint()
+  var score: Float = 0.0
+}
+
+struct Line {
+  let from: CGPoint
+  let to: CGPoint
+}
+
+struct Times {
+  var preprocessing: Double
+  var inference: Double
+  var postprocessing: Double
+}
+
+struct Result {
+  var dots: [CGPoint]
+  var lines: [Line]
+  var score: Float
+}
+
+enum BodyPart: String, CaseIterable {
+  case NOSE = "nose"
+  case LEFT_EYE = "left eye"
+  case RIGHT_EYE = "right eye"
+  case LEFT_EAR = "left ear"
+  case RIGHT_EAR = "right ear"
+  case LEFT_SHOULDER = "left shoulder"
+  case RIGHT_SHOULDER = "right shoulder"
+  case LEFT_ELBOW = "left elbow"
+  case RIGHT_ELBOW = "right elbow"
+  case LEFT_WRIST = "left wrist"
+  case RIGHT_WRIST = "right wrist"
+  case LEFT_HIP = "left hip"
+  case RIGHT_HIP = "right hip"
+  case LEFT_KNEE = "left knee"
+  case RIGHT_KNEE = "right knee"
+  case LEFT_ANKLE = "left ankle"
+  case RIGHT_ANKLE = "right ankle"
+
+  /// List of lines connecting each part.
+  static let lines = [
+    (from: BodyPart.LEFT_WRIST, to: BodyPart.LEFT_ELBOW),
+    (from: BodyPart.LEFT_ELBOW, to: BodyPart.LEFT_SHOULDER),
+    (from: BodyPart.LEFT_SHOULDER, to: BodyPart.RIGHT_SHOULDER),
+    (from: BodyPart.RIGHT_SHOULDER, to: BodyPart.RIGHT_ELBOW),
+    (from: BodyPart.RIGHT_ELBOW, to: BodyPart.RIGHT_WRIST),
+    (from: BodyPart.LEFT_SHOULDER, to: BodyPart.LEFT_HIP),
+    (from: BodyPart.LEFT_HIP, to: BodyPart.RIGHT_HIP),
+    (from: BodyPart.RIGHT_HIP, to: BodyPart.RIGHT_SHOULDER),
+    (from: BodyPart.LEFT_HIP, to: BodyPart.LEFT_KNEE),
+    (from: BodyPart.LEFT_KNEE, to: BodyPart.LEFT_ANKLE),
+    (from: BodyPart.RIGHT_HIP, to: BodyPart.RIGHT_KNEE),
+    (from: BodyPart.RIGHT_KNEE, to: BodyPart.RIGHT_ANKLE),
+  ]
+}
+
+// MARK: - Delegates Enum
+enum Delegates: Int, CaseIterable {
+  case CPU
+  case Metal
+  case CoreML
+
+  var description: String {
+    switch self {
+    case .CPU:
+      return "CPU"
+    case .Metal:
+      return "GPU"
+    case .CoreML:
+      return "NPU"
+    }
+  }
+}
+
+// MARK: - Custom Errors
+enum PostprocessError: Error {
+  case missingBodyPart(of: BodyPart)
+}
+
+// MARK: - Information about the model file.
+typealias FileInfo = (name: String, extension: String)
+
+enum Model {
+  static let file: FileInfo = (
+    name: "model_opt", extension: "tflite"
+  )
+
+  static let input = (batchSize: 1, height: 256, width: 256, channelSize: 3)
+  static let output = (batchSize: 1, height: 256, width: 256, channelSize: 1)
+  static let isQuantized = false
+}
+
+
+extension Array {
+  /// Creates a new array from the bytes of the given unsafe data.
+  ///
+  /// - Warning: The array's `Element` type must be trivial in that it can be copied bit for bit
+  ///     with no indirection or reference-counting operations; otherwise, copying the raw bytes in
+  ///     the `unsafeData`'s buffer to a new array returns an unsafe copy.
+  /// - Note: Returns `nil` if `unsafeData.count` is not a multiple of
+  ///     `MemoryLayout<Element>.stride`.
+  /// - Parameter unsafeData: The data containing the bytes to turn into an array.
+  init?(unsafeData: Data) {
+    guard unsafeData.count % MemoryLayout<Element>.stride == 0 else { return nil }
+    #if swift(>=5.0)
+    self = unsafeData.withUnsafeBytes { .init($0.bindMemory(to: Element.self)) }
+    #else
+    self = unsafeData.withUnsafeBytes {
+      .init(UnsafeBufferPointer<Element>(
+        start: $0,
+        count: unsafeData.count / MemoryLayout<Element>.stride
+      ))
+    }
+    #endif  // swift(>=5.0)
+  }
+}

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/Midas/Storyboards/Base.lproj/Launch Screen.storyboard

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="13142" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="12042"/>
+        <capability name="Constraints with non-1.0 multipliers" minToolsVersion="5.1"/>
+        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="EHf-IW-A2E">
+            <objects>
+                <viewController id="01J-lp-oVM" sceneMemberID="viewController">
+                    <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
+                        <rect key="frame" x="0.0" y="0.0" width="375" height="667"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <subviews>
+                            <label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Copyright © 2019 tensorflow. All rights reserved." textAlignment="center" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" minimumFontSize="9" translatesAutoresizingMaskIntoConstraints="NO" id="obG-Y5-kRd">
+                                <rect key="frame" x="0.0" y="626.5" width="375" height="20.5"/>
+                                <fontDescription key="fontDescription" type="system" pointSize="17"/>
+                                <color key="textColor" red="0.0" green="0.0" blue="0.0" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
+                                <nil key="highlightedColor"/>
+                            </label>
+                            <label opaque="NO" clipsSubviews="YES" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Midas" textAlignment="center" lineBreakMode="middleTruncation" baselineAdjustment="alignBaselines" minimumFontSize="18" translatesAutoresizingMaskIntoConstraints="NO" id="GJd-Yh-RWb">
+                                <rect key="frame" x="0.0" y="202" width="375" height="43"/>
+                                <fontDescription key="fontDescription" type="boldSystem" pointSize="36"/>
+                                <color key="textColor" red="0.0" green="0.0" blue="0.0" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
+                                <nil key="highlightedColor"/>
+                            </label>
+                        </subviews>
+                        <color key="backgroundColor" red="1" green="1" blue="1" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
+                        <constraints>
+                            <constraint firstItem="Bcu-3y-fUS" firstAttribute="centerX" secondItem="obG-Y5-kRd" secondAttribute="centerX" id="5cz-MP-9tL"/>
+                            <constraint firstItem="Bcu-3y-fUS" firstAttribute="centerX" secondItem="GJd-Yh-RWb" secondAttribute="centerX" id="Q3B-4B-g5h"/>
+                            <constraint firstItem="obG-Y5-kRd" firstAttribute="leading" secondItem="Bcu-3y-fUS" secondAttribute="leading" constant="20" symbolic="YES" id="SfN-ll-jLj"/>
+                            <constraint firstAttribute="bottom" secondItem="obG-Y5-kRd" secondAttribute="bottom" constant="20" id="Y44-ml-fuU"/>
+                            <constraint firstItem="GJd-Yh-RWb" firstAttribute="centerY" secondItem="Ze5-6b-2t3" secondAttribute="bottom" multiplier="1/3" constant="1" id="moa-c2-u7t"/>
+                            <constraint firstItem="GJd-Yh-RWb" firstAttribute="leading" secondItem="Bcu-3y-fUS" secondAttribute="leading" constant="20" symbolic="YES" id="x7j-FC-K8j"/>
+                        </constraints>
+                        <viewLayoutGuide key="safeArea" id="Bcu-3y-fUS"/>
+                    </view>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="53" y="375"/>
+        </scene>
+    </scenes>
+</document>

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/Midas/Storyboards/Base.lproj/Main.storyboard

@@ -0,0 +1,236 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="15505" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="BYZ-38-t0r">
+    <device id="retina6_1" orientation="portrait" appearance="light"/>
+    <dependencies>
+        <deployment identifier="iOS"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="15510"/>
+        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="tne-QT-ifu">
+            <objects>
+                <viewController id="BYZ-38-t0r" customClass="ViewController" customModule="Midas" customModuleProvider="target" sceneMemberID="viewController">
+                    <view key="view" contentMode="scaleToFill" id="8bC-Xf-vdC">
+                        <rect key="frame" x="0.0" y="0.0" width="414" height="896"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <subviews>
+                            <view contentMode="scaleToFill" translatesAutoresizingMaskIntoConstraints="NO" id="aEU-Ov-crs" customClass="PreviewView" customModule="Midas" customModuleProvider="target">
+                                <rect key="frame" x="0.0" y="0.0" width="414" height="896"/>
+                                <subviews>
+                                    <button hidden="YES" opaque="NO" contentMode="scaleToFill" contentHorizontalAlignment="center" contentVerticalAlignment="center" buttonType="roundedRect" lineBreakMode="middleTruncation" translatesAutoresizingMaskIntoConstraints="NO" id="JeV-bW-Ogb">
+                                        <rect key="frame" x="150.5" y="433" width="113" height="30"/>
+                                        <state key="normal" title="Resume Session"/>
+                                        <connections>
+                                            <action selector="didTapResumeButton:" destination="BYZ-38-t0r" eventType="touchUpInside" id="eGE-XF-oGN"/>
+                                        </connections>
+                                    </button>
+                                    <label hidden="YES" opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Camera Unavailable" textAlignment="center" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="xja-Am-Oc5">
+                                        <rect key="frame" x="111.5" y="371.5" width="191" height="26.5"/>
+                                        <fontDescription key="fontDescription" type="system" pointSize="22"/>
+                                        <nil key="textColor"/>
+                                        <nil key="highlightedColor"/>
+                                    </label>
+                                    <view contentMode="scaleToFill" insetsLayoutMarginsFromSafeArea="NO" translatesAutoresizingMaskIntoConstraints="NO" id="tWv-pt-h17" userLabel="TopView">
+                                        <rect key="frame" x="0.0" y="0.0" width="414" height="119"/>
+                                        <subviews>
+                                            <imageView clipsSubviews="YES" userInteractionEnabled="NO" contentMode="scaleAspectFit" horizontalHuggingPriority="251" verticalHuggingPriority="251" image="tfl_logo.png" translatesAutoresizingMaskIntoConstraints="NO" id="ijS-RU-qlo">
+                                                <rect key="frame" x="60" y="42.5" width="294" height="68"/>
+                                            </imageView>
+                                        </subviews>
+                                        <color key="backgroundColor" white="0.0" alpha="0.80000000000000004" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                        <constraints>
+                                            <constraint firstItem="ijS-RU-qlo" firstAttribute="bottom" secondItem="tWv-pt-h17" secondAttribute="bottom" multiplier="6.5:7" id="06z-Bq-BW1"/>
+                                            <constraint firstItem="ijS-RU-qlo" firstAttribute="centerX" secondItem="tWv-pt-h17" secondAttribute="centerX" id="DjM-bj-7Aa"/>
+                                            <constraint firstItem="ijS-RU-qlo" firstAttribute="height" secondItem="tWv-pt-h17" secondAttribute="height" multiplier="4:7" id="fU4-ZD-b2i"/>
+                                        </constraints>
+                                    </view>
+                                    <view opaque="NO" contentMode="scaleAspectFit" translatesAutoresizingMaskIntoConstraints="NO" id="FLM-9o-o4W" customClass="OverlayView" customModule="Midas" customModuleProvider="target">
+                                        <rect key="frame" x="0.0" y="119" width="414" height="414"/>
+                                        <constraints>
+                                            <constraint firstAttribute="width" secondItem="FLM-9o-o4W" secondAttribute="height" multiplier="1:1" id="1T9-Bs-Jec"/>
+                                        </constraints>
+                                        <edgeInsets key="layoutMargins" top="8" left="8" bottom="8" right="8"/>
+                                    </view>
+                                    <view contentMode="scaleToFill" translatesAutoresizingMaskIntoConstraints="NO" id="nFg-A5-Dew" userLabel="BottomView">
+                                        <rect key="frame" x="0.0" y="533" width="414" height="363"/>
+                                        <subviews>
+                                            <tableView clipsSubviews="YES" userInteractionEnabled="NO" contentMode="scaleToFill" bounces="NO" scrollEnabled="NO" delaysContentTouches="NO" canCancelContentTouches="NO" bouncesZoom="NO" dataMode="prototypes" style="plain" separatorStyle="none" allowsMultipleSelection="YES" rowHeight="-1" estimatedRowHeight="-1" sectionHeaderHeight="28" sectionFooterHeight="28" translatesAutoresizingMaskIntoConstraints="NO" id="3e4-S8-Ouh">
+                                                <rect key="frame" x="60" y="30" width="294" height="163"/>
+                                                <color key="backgroundColor" white="0.0" alpha="0.0" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                <color key="tintColor" white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                <color key="separatorColor" white="0.0" alpha="0.0" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                <color key="sectionIndexColor" white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                <color key="sectionIndexBackgroundColor" white="0.0" alpha="0.0" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                <color key="sectionIndexTrackingBackgroundColor" white="0.0" alpha="0.0" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                <prototypes>
+                                                    <tableViewCell clipsSubviews="YES" contentMode="scaleToFill" preservesSuperviewLayoutMargins="YES" selectionStyle="default" indentationWidth="10" reuseIdentifier="InfoCell" id="THr-Uf-ggb" customClass="InfoCell" customModule="Midas" customModuleProvider="target">
+                                                        <rect key="frame" x="0.0" y="28" width="294" height="44"/>
+                                                        <autoresizingMask key="autoresizingMask"/>
+                                                        <tableViewCellContentView key="contentView" opaque="NO" clipsSubviews="YES" multipleTouchEnabled="YES" contentMode="center" preservesSuperviewLayoutMargins="YES" insetsLayoutMarginsFromSafeArea="NO" tableViewCell="THr-Uf-ggb" id="5T1-ZQ-m0o">
+                                                            <rect key="frame" x="0.0" y="0.0" width="294" height="44"/>
+                                                            <autoresizingMask key="autoresizingMask"/>
+                                                            <subviews>
+                                                                <label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Field Label" lineBreakMode="clip" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="mTG-UQ-Lwc" userLabel="Field Name Label">
+                                                                    <rect key="frame" x="0.0" y="0.0" width="176.5" height="19.5"/>
+                                                                    <color key="backgroundColor" white="0.0" alpha="0.0" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                                    <color key="tintColor" white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                                    <fontDescription key="fontDescription" type="system" weight="medium" pointSize="16"/>
+                                                                    <color key="textColor" white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                                    <color key="highlightedColor" white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                                </label>
+                                                                <label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="100" verticalHuggingPriority="251" text="Info Label" textAlignment="right" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="3kP-Ho-Tm4" userLabel="Info Label">
+                                                                    <rect key="frame" x="176.5" y="0.0" width="117.5" height="19.5"/>
+                                                                    <color key="backgroundColor" white="0.0" alpha="0.0" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                                    <color key="tintColor" white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                                    <fontDescription key="fontDescription" type="system" pointSize="16"/>
+                                                                    <color key="textColor" white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                                    <color key="highlightedColor" white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                                </label>
+                                                            </subviews>
+                                                            <color key="backgroundColor" white="0.0" alpha="0.0" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                            <color key="tintColor" white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                            <constraints>
+                                                                <constraint firstItem="mTG-UQ-Lwc" firstAttribute="top" secondItem="5T1-ZQ-m0o" secondAttribute="top" id="4yW-Lh-MPd"/>
+                                                                <constraint firstItem="3kP-Ho-Tm4" firstAttribute="top" secondItem="5T1-ZQ-m0o" secondAttribute="top" id="JOU-KJ-V73"/>
+                                                                <constraint firstItem="3kP-Ho-Tm4" firstAttribute="width" secondItem="5T1-ZQ-m0o" secondAttribute="width" multiplier="0.4" id="NXu-3C-w9k"/>
+                                                                <constraint firstItem="mTG-UQ-Lwc" firstAttribute="width" secondItem="5T1-ZQ-m0o" secondAttribute="width" multiplier="0.6" id="Vvh-cz-q4K"/>
+                                                                <constraint firstItem="3kP-Ho-Tm4" firstAttribute="leading" secondItem="mTG-UQ-Lwc" secondAttribute="trailing" id="kwA-sz-1zt"/>
+                                                                <constraint firstItem="mTG-UQ-Lwc" firstAttribute="leading" secondItem="5T1-ZQ-m0o" secondAttribute="leading" id="kxa-T6-w0h"/>
+                                                            </constraints>
+                                                        </tableViewCellContentView>
+                                                        <color key="backgroundColor" white="0.0" alpha="0.0" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                        <constraints>
+                                                            <constraint firstItem="3kP-Ho-Tm4" firstAttribute="top" secondItem="THr-Uf-ggb" secondAttribute="top" id="XTX-Dy-sDb"/>
+                                                            <constraint firstItem="3kP-Ho-Tm4" firstAttribute="trailing" secondItem="THr-Uf-ggb" secondAttribute="trailing" id="kX7-5L-aoX"/>
+                                                        </constraints>
+                                                        <connections>
+                                                            <outlet property="fieldNameLabel" destination="mTG-UQ-Lwc" id="7HD-r4-86n"/>
+                                                            <outlet property="infoLabel" destination="3kP-Ho-Tm4" id="nMw-We-0cp"/>
+                                                        </connections>
+                                                    </tableViewCell>
+                                                </prototypes>
+                                                <connections>
+                                                    <outlet property="dataSource" destination="BYZ-38-t0r" id="8Ah-El-SjN"/>
+                                                    <outlet property="delegate" destination="BYZ-38-t0r" id="bw0-yQ-3jW"/>
+                                                </connections>
+                                            </tableView>
+                                            <stackView opaque="NO" contentMode="scaleToFill" spacing="15" translatesAutoresizingMaskIntoConstraints="NO" id="cOj-2t-SbP" userLabel="Thread Stack View">
+                                                <rect key="frame" x="35" y="203" width="344" height="30"/>
+                                                <subviews>
+                                                    <label opaque="NO" userInteractionEnabled="NO" contentMode="left" verticalHuggingPriority="251" text="Threads" textAlignment="natural" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="eX7-9U-WcH">
+                                                        <rect key="frame" x="0.0" y="0.0" width="209" height="30"/>
+                                                        <fontDescription key="fontDescription" type="boldSystem" pointSize="16"/>
+                                                        <color key="textColor" white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                        <nil key="highlightedColor"/>
+                                                    </label>
+                                                    <label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="0" textAlignment="natural" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="bIb-UK-3tz">
+                                                        <rect key="frame" x="224" y="0.0" width="11" height="30"/>
+                                                        <fontDescription key="fontDescription" type="boldSystem" pointSize="16"/>
+                                                        <color key="textColor" white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                        <color key="highlightedColor" white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                    </label>
+                                                    <stepper opaque="NO" contentMode="scaleToFill" horizontalHuggingPriority="750" verticalHuggingPriority="750" contentHorizontalAlignment="center" contentVerticalAlignment="center" value="1" minimumValue="1" maximumValue="10" translatesAutoresizingMaskIntoConstraints="NO" id="P6P-6m-RWk">
+                                                        <rect key="frame" x="250" y="0.0" width="94" height="30"/>
+                                                        <color key="tintColor" white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                        <connections>
+                                                            <action selector="didChangeThreadCount:" destination="BYZ-38-t0r" eventType="valueChanged" id="Ty8-5M-GAN"/>
+                                                        </connections>
+                                                    </stepper>
+                                                </subviews>
+                                                <constraints>
+                                                    <constraint firstAttribute="height" constant="30" id="PmW-q1-hKU"/>
+                                                </constraints>
+                                            </stackView>
+                                            <stackView opaque="NO" contentMode="scaleToFill" spacing="10" translatesAutoresizingMaskIntoConstraints="NO" id="RXH-7X-MUd" userLabel="Delegates Stack View">
+                                                <rect key="frame" x="35" y="253" width="344" height="31"/>
+                                                <subviews>
+                                                    <label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Delegates" textAlignment="natural" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="gmc-69-mzQ" userLabel="Delegates label">
+                                                        <rect key="frame" x="0.0" y="0.0" width="78.5" height="31"/>
+                                                        <fontDescription key="fontDescription" type="boldSystem" pointSize="16"/>
+                                                        <color key="textColor" white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                                        <nil key="highlightedColor"/>
+                                                    </label>
+                                                    <segmentedControl opaque="NO" contentMode="scaleToFill" contentHorizontalAlignment="left" contentVerticalAlignment="top" segmentControlStyle="plain" selectedSegmentIndex="0" translatesAutoresizingMaskIntoConstraints="NO" id="kS9-M8-aNu">
+                                                        <rect key="frame" x="88.5" y="0.0" width="255.5" height="32"/>
+                                                        <segments>
+                                                            <segment title="First"/>
+                                                            <segment title="Second"/>
+                                                        </segments>
+                                                        <connections>
+                                                            <action selector="didChangeDelegate:" destination="BYZ-38-t0r" eventType="valueChanged" id="mGg-gI-RL2"/>
+                                                        </connections>
+                                                    </segmentedControl>
+                                                </subviews>
+                                            </stackView>
+                                        </subviews>
+                                        <color key="backgroundColor" red="0.0" green="0.0" blue="0.0" alpha="0.80000000000000004" colorSpace="custom" customColorSpace="sRGB"/>
+                                        <constraints>
+                                            <constraint firstItem="RXH-7X-MUd" firstAttribute="leading" secondItem="cOj-2t-SbP" secondAttribute="leading" id="3wP-lN-o3t"/>
+                                            <constraint firstItem="RXH-7X-MUd" firstAttribute="trailing" secondItem="cOj-2t-SbP" secondAttribute="trailing" id="Ej9-gR-bWk"/>
+                                            <constraint firstItem="cOj-2t-SbP" firstAttribute="width" secondItem="nFg-A5-Dew" secondAttribute="width" constant="-70" id="VyB-yT-Tey"/>
+                                            <constraint firstItem="3e4-S8-Ouh" firstAttribute="top" secondItem="nFg-A5-Dew" secondAttribute="top" constant="30" id="XBT-uR-wI0"/>
+                                            <constraint firstAttribute="bottom" relation="greaterThanOrEqual" secondItem="cOj-2t-SbP" secondAttribute="bottom" priority="250" constant="30" id="YjT-kc-3Yi"/>
+                                            <constraint firstItem="3e4-S8-Ouh" firstAttribute="bottom" secondItem="cOj-2t-SbP" secondAttribute="top" constant="-10" id="lEI-3O-3zh"/>
+                                            <constraint firstItem="cOj-2t-SbP" firstAttribute="bottom" secondItem="RXH-7X-MUd" secondAttribute="top" constant="-20" id="npw-gf-o7m"/>
+                                            <constraint firstItem="3e4-S8-Ouh" firstAttribute="width" secondItem="nFg-A5-Dew" secondAttribute="width" constant="-120" id="orY-Ah-Jzt"/>
+                                            <constraint firstItem="3e4-S8-Ouh" firstAttribute="centerX" secondItem="nFg-A5-Dew" secondAttribute="centerX" id="tIF-GC-QXD"/>
+                                            <constraint firstItem="cOj-2t-SbP" firstAttribute="centerX" secondItem="nFg-A5-Dew" secondAttribute="centerX" id="xwh-fU-JP1"/>
+                                        </constraints>
+                                    </view>
+                                </subviews>
+                                <color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+                                <constraints>
+                                    <constraint firstItem="JeV-bW-Ogb" firstAttribute="top" secondItem="xja-Am-Oc5" secondAttribute="bottom" constant="35" id="19f-cQ-jfR"/>
+                                    <constraint firstItem="tWv-pt-h17" firstAttribute="leading" secondItem="aEU-Ov-crs" secondAttribute="leading" id="1Jc-ch-65t"/>
+                                    <constraint firstItem="FLM-9o-o4W" firstAttribute="leading" secondItem="aEU-Ov-crs" secondAttribute="leading" id="23L-Hb-zus"/>
+                                    <constraint firstItem="nFg-A5-Dew" firstAttribute="leading" secondItem="aEU-Ov-crs" secondAttribute="leading" id="2aq-VQ-8jy"/>
+                                    <constraint firstItem="tWv-pt-h17" firstAttribute="top" secondItem="aEU-Ov-crs" secondAttribute="top" id="7aI-Bb-gUy"/>
+                                    <constraint firstItem="FLM-9o-o4W" firstAttribute="width" secondItem="aEU-Ov-crs" secondAttribute="width" priority="750" id="94P-51-fMI"/>
+                                    <constraint firstItem="FLM-9o-o4W" firstAttribute="height" relation="lessThanOrEqual" secondItem="aEU-Ov-crs" secondAttribute="height" id="W3V-ka-9Fq"/>
+                                    <constraint firstItem="FLM-9o-o4W" firstAttribute="height" secondItem="aEU-Ov-crs" secondAttribute="height" priority="750" id="Ycv-Lj-8Xu"/>
+                                    <constraint firstItem="tWv-pt-h17" firstAttribute="width" secondItem="aEU-Ov-crs" secondAttribute="width" id="Yni-oR-3Bk"/>
+                                    <constraint firstItem="JeV-bW-Ogb" firstAttribute="centerX" secondItem="aEU-Ov-crs" secondAttribute="centerX" id="biE-2Z-tkx"/>
+                                    <constraint firstItem="JeV-bW-Ogb" firstAttribute="centerY" secondItem="aEU-Ov-crs" secondAttribute="centerY" id="c8W-L8-dcv"/>
+                                    <constraint firstAttribute="bottom" secondItem="nFg-A5-Dew" secondAttribute="bottom" id="dxP-KD-5bd"/>
+                                    <constraint firstItem="xja-Am-Oc5" firstAttribute="centerX" secondItem="aEU-Ov-crs" secondAttribute="centerX" id="ehn-uM-mdg"/>
+                                    <constraint firstItem="nFg-A5-Dew" firstAttribute="width" secondItem="aEU-Ov-crs" secondAttribute="width" id="peY-3I-8cV"/>
+                                    <constraint firstItem="nFg-A5-Dew" firstAttribute="top" secondItem="FLM-9o-o4W" secondAttribute="bottom" id="sFi-YM-EYA"/>
+                                    <constraint firstItem="FLM-9o-o4W" firstAttribute="top" secondItem="tWv-pt-h17" secondAttribute="bottom" id="trj-PE-5oc"/>
+                                    <constraint firstItem="FLM-9o-o4W" firstAttribute="width" relation="lessThanOrEqual" secondItem="aEU-Ov-crs" secondAttribute="width" id="zae-wS-Evw"/>
+                                </constraints>
+                            </view>
+                        </subviews>
+                        <color key="backgroundColor" red="1" green="1" blue="1" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
+                        <constraints>
+                            <constraint firstItem="aEU-Ov-crs" firstAttribute="bottom" secondItem="8bC-Xf-vdC" secondAttribute="bottom" id="3OD-6W-uRh"/>
+                            <constraint firstItem="RXH-7X-MUd" firstAttribute="centerX" secondItem="6Tk-OE-BBY" secondAttribute="centerX" id="Hiz-DI-CwX"/>
+                            <constraint firstItem="6Tk-OE-BBY" firstAttribute="bottom" secondItem="RXH-7X-MUd" secondAttribute="bottom" constant="45" id="OGm-6n-JMM"/>
+                            <constraint firstItem="aEU-Ov-crs" firstAttribute="leading" secondItem="8bC-Xf-vdC" secondAttribute="leading" id="e9c-LL-cJf"/>
+                            <constraint firstItem="aEU-Ov-crs" firstAttribute="top" secondItem="8bC-Xf-vdC" secondAttribute="top" id="eyF-LV-5Jb"/>
+                            <constraint firstItem="aEU-Ov-crs" firstAttribute="trailing" secondItem="8bC-Xf-vdC" secondAttribute="trailing" id="g7I-ct-vQc"/>
+                            <constraint firstItem="tWv-pt-h17" firstAttribute="bottom" secondItem="6Tk-OE-BBY" secondAttribute="top" constant="75" id="oFt-dT-p0b"/>
+                        </constraints>
+                        <viewLayoutGuide key="safeArea" id="6Tk-OE-BBY"/>
+                    </view>
+                    <connections>
+                        <outlet property="cameraUnavailableLabel" destination="xja-Am-Oc5" id="g9Q-Mh-1ct"/>
+                        <outlet property="delegatesControl" destination="kS9-M8-aNu" id="aq5-y6-e3w"/>
+                        <outlet property="overlayView" destination="FLM-9o-o4W" id="06u-Ci-QDR"/>
+                        <outlet property="previewView" destination="aEU-Ov-crs" id="NMN-in-8FS"/>
+                        <outlet property="resumeButton" destination="JeV-bW-Ogb" id="Y7c-x9-3t3"/>
+                        <outlet property="tableView" destination="3e4-S8-Ouh" id="bhz-PY-Fhd"/>
+                        <outlet property="threadCountLabel" destination="bIb-UK-3tz" id="LvS-wv-2Pq"/>
+                        <outlet property="threadCountStepper" destination="P6P-6m-RWk" id="zPW-0r-KYP"/>
+                    </connections>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="dkx-z0-nzr" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="137.68115942028987" y="137.94642857142856"/>
+        </scene>
+    </scenes>
+    <resources>
+        <image name="tfl_logo.png" width="294" height="47"/>
+    </resources>
+</document>

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/Midas/ViewControllers/ViewController.swift

@@ -0,0 +1,489 @@
+// Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import AVFoundation
+import UIKit
+import os
+
+
+public struct PixelData {
+    var a: UInt8
+    var r: UInt8
+    var g: UInt8
+    var b: UInt8
+}
+
+extension UIImage {
+    convenience init?(pixels: [PixelData], width: Int, height: Int) {
+        guard width > 0 && height > 0, pixels.count == width * height else { return nil }
+        var data = pixels
+        guard let providerRef = CGDataProvider(data: Data(bytes: &data, count: data.count * MemoryLayout<PixelData>.size) as CFData)
+            else { return nil }
+        guard let cgim = CGImage(
+            width: width,
+            height: height,
+            bitsPerComponent: 8,
+            bitsPerPixel: 32,
+            bytesPerRow: width * MemoryLayout<PixelData>.size,
+            space: CGColorSpaceCreateDeviceRGB(),
+            bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.premultipliedFirst.rawValue),
+            provider: providerRef,
+            decode: nil,
+            shouldInterpolate: false,
+            intent: .defaultIntent)
+        else { return nil }
+        self.init(cgImage: cgim)
+    }
+}
+
+
+class ViewController: UIViewController {
+  // MARK: Storyboards Connections
+  @IBOutlet weak var previewView: PreviewView!
+
+  //@IBOutlet weak var overlayView: OverlayView!
+  @IBOutlet weak var overlayView: UIImageView!
+        
+  private var imageView : UIImageView = UIImageView(frame:CGRect(x:0, y:0, width:400, height:400))
+    
+  private var imageViewInitialized: Bool = false
+    
+  @IBOutlet weak var resumeButton: UIButton!
+  @IBOutlet weak var cameraUnavailableLabel: UILabel!
+
+  @IBOutlet weak var tableView: UITableView!
+
+  @IBOutlet weak var threadCountLabel: UILabel!
+  @IBOutlet weak var threadCountStepper: UIStepper!
+
+  @IBOutlet weak var delegatesControl: UISegmentedControl!
+
+  // MARK: ModelDataHandler traits
+  var threadCount: Int = Constants.defaultThreadCount
+  var delegate: Delegates = Constants.defaultDelegate
+
+  // MARK: Result Variables
+  // Inferenced data to render.
+  private var inferencedData: InferencedData?
+
+  // Minimum score to render the result.
+  private let minimumScore: Float = 0.5
+    
+  private var avg_latency: Double = 0.0
+
+  // Relative location of `overlayView` to `previewView`.
+  private var overlayViewFrame: CGRect?
+
+  private var previewViewFrame: CGRect?
+
+  // MARK: Controllers that manage functionality
+  // Handles all the camera related functionality
+  private lazy var cameraCapture = CameraFeedManager(previewView: previewView)
+
+  // Handles all data preprocessing and makes calls to run inference.
+  private var modelDataHandler: ModelDataHandler?
+
+  // MARK: View Handling Methods
+  override func viewDidLoad() {
+    super.viewDidLoad()
+
+    do {
+      modelDataHandler = try ModelDataHandler()
+    } catch let error {
+      fatalError(error.localizedDescription)
+    }
+
+    cameraCapture.delegate = self
+    tableView.delegate = self
+    tableView.dataSource = self
+
+    // MARK: UI Initialization
+    // Setup thread count stepper with white color.
+    // https://forums.developer.apple.com/thread/121495
+    threadCountStepper.setDecrementImage(
+      threadCountStepper.decrementImage(for: .normal), for: .normal)
+    threadCountStepper.setIncrementImage(
+      threadCountStepper.incrementImage(for: .normal), for: .normal)
+    // Setup initial stepper value and its label.
+    threadCountStepper.value = Double(Constants.defaultThreadCount)
+    threadCountLabel.text = Constants.defaultThreadCount.description
+
+    // Setup segmented controller's color.
+    delegatesControl.setTitleTextAttributes(
+      [NSAttributedString.Key.foregroundColor: UIColor.lightGray],
+      for: .normal)
+    delegatesControl.setTitleTextAttributes(
+      [NSAttributedString.Key.foregroundColor: UIColor.black],
+      for: .selected)
+    // Remove existing segments to initialize it with `Delegates` entries.
+    delegatesControl.removeAllSegments()
+    Delegates.allCases.forEach { delegate in
+      delegatesControl.insertSegment(
+        withTitle: delegate.description,
+        at: delegate.rawValue,
+        animated: false)
+    }
+    delegatesControl.selectedSegmentIndex = 0
+  }
+
+  override func viewWillAppear(_ animated: Bool) {
+    super.viewWillAppear(animated)
+
+    cameraCapture.checkCameraConfigurationAndStartSession()
+  }
+
+  override func viewWillDisappear(_ animated: Bool) {
+    cameraCapture.stopSession()
+  }
+
+  override func viewDidLayoutSubviews() {
+    overlayViewFrame = overlayView.frame
+    previewViewFrame = previewView.frame
+  }
+
+  // MARK: Button Actions
+  @IBAction func didChangeThreadCount(_ sender: UIStepper) {
+    let changedCount = Int(sender.value)
+    if threadCountLabel.text == changedCount.description {
+      return
+    }
+
+    do {
+      modelDataHandler = try ModelDataHandler(threadCount: changedCount, delegate: delegate)
+    } catch let error {
+      fatalError(error.localizedDescription)
+    }
+    threadCount = changedCount
+    threadCountLabel.text = changedCount.description
+    os_log("Thread count is changed to: %d", threadCount)
+  }
+
+  @IBAction func didChangeDelegate(_ sender: UISegmentedControl) {
+    guard let changedDelegate = Delegates(rawValue: delegatesControl.selectedSegmentIndex) else {
+      fatalError("Unexpected value from delegates segemented controller.")
+    }
+    do {
+      modelDataHandler = try ModelDataHandler(threadCount: threadCount, delegate: changedDelegate)
+    } catch let error {
+      fatalError(error.localizedDescription)
+    }
+    delegate = changedDelegate
+    os_log("Delegate is changed to: %s", delegate.description)
+  }
+
+  @IBAction func didTapResumeButton(_ sender: Any) {
+    cameraCapture.resumeInterruptedSession { complete in
+
+      if complete {
+        self.resumeButton.isHidden = true
+        self.cameraUnavailableLabel.isHidden = true
+      } else {
+        self.presentUnableToResumeSessionAlert()
+      }
+    }
+  }
+
+  func presentUnableToResumeSessionAlert() {
+    let alert = UIAlertController(
+      title: "Unable to Resume Session",
+      message: "There was an error while attempting to resume session.",
+      preferredStyle: .alert
+    )
+    alert.addAction(UIAlertAction(title: "OK", style: .default, handler: nil))
+
+    self.present(alert, animated: true)
+  }
+}
+
+// MARK: - CameraFeedManagerDelegate Methods
+extension ViewController: CameraFeedManagerDelegate {
+  func cameraFeedManager(_ manager: CameraFeedManager, didOutput pixelBuffer: CVPixelBuffer) {
+    runModel(on: pixelBuffer)
+  }
+
+  // MARK: Session Handling Alerts
+  func cameraFeedManagerDidEncounterSessionRunTimeError(_ manager: CameraFeedManager) {
+    // Handles session run time error by updating the UI and providing a button if session can be
+    // manually resumed.
+    self.resumeButton.isHidden = false
+  }
+
+  func cameraFeedManager(
+    _ manager: CameraFeedManager, sessionWasInterrupted canResumeManually: Bool
+  ) {
+    // Updates the UI when session is interupted.
+    if canResumeManually {
+      self.resumeButton.isHidden = false
+    } else {
+      self.cameraUnavailableLabel.isHidden = false
+    }
+  }
+
+  func cameraFeedManagerDidEndSessionInterruption(_ manager: CameraFeedManager) {
+    // Updates UI once session interruption has ended.
+    self.cameraUnavailableLabel.isHidden = true
+    self.resumeButton.isHidden = true
+  }
+
+  func presentVideoConfigurationErrorAlert(_ manager: CameraFeedManager) {
+    let alertController = UIAlertController(
+      title: "Confirguration Failed", message: "Configuration of camera has failed.",
+      preferredStyle: .alert)
+    let okAction = UIAlertAction(title: "OK", style: .cancel, handler: nil)
+    alertController.addAction(okAction)
+
+    present(alertController, animated: true, completion: nil)
+  }
+
+  func presentCameraPermissionsDeniedAlert(_ manager: CameraFeedManager) {
+    let alertController = UIAlertController(
+      title: "Camera Permissions Denied",
+      message:
+        "Camera permissions have been denied for this app. You can change this by going to Settings",
+      preferredStyle: .alert)
+
+    let cancelAction = UIAlertAction(title: "Cancel", style: .cancel, handler: nil)
+    let settingsAction = UIAlertAction(title: "Settings", style: .default) { action in
+      if let url = URL.init(string: UIApplication.openSettingsURLString) {
+        UIApplication.shared.open(url, options: [:], completionHandler: nil)
+      }
+    }
+
+    alertController.addAction(cancelAction)
+    alertController.addAction(settingsAction)
+
+    present(alertController, animated: true, completion: nil)
+  }
+
+  @objc func runModel(on pixelBuffer: CVPixelBuffer) {
+    guard let overlayViewFrame = overlayViewFrame, let previewViewFrame = previewViewFrame
+    else {
+      return
+    }
+    // To put `overlayView` area as model input, transform `overlayViewFrame` following transform
+    // from `previewView` to `pixelBuffer`. `previewView` area is transformed to fit in
+    // `pixelBuffer`, because `pixelBuffer` as a camera output is resized to fill `previewView`.
+    // https://developer.apple.com/documentation/avfoundation/avlayervideogravity/1385607-resizeaspectfill
+    let modelInputRange = overlayViewFrame.applying(
+      previewViewFrame.size.transformKeepAspect(toFitIn: pixelBuffer.size))
+
+    // Run Midas model.
+    guard
+      let (result, width, height, times) = self.modelDataHandler?.runMidas(
+        on: pixelBuffer,
+        from: modelInputRange,
+        to: overlayViewFrame.size)
+    else {
+      os_log("Cannot get inference result.", type: .error)
+      return
+    }
+
+    if avg_latency == 0 {
+        avg_latency = times.inference
+    } else {
+        avg_latency = times.inference*0.1 + avg_latency*0.9
+    }
+    
+    // Udpate `inferencedData` to render data in `tableView`.
+    inferencedData = InferencedData(score: Float(avg_latency), times: times)
+    
+    //let height = 256
+    //let width = 256
+    
+    let outputs = result
+    let outputs_size = width * height;
+      
+    var multiplier : Float = 1.0;
+    
+    let max_val : Float = outputs.max() ?? 0
+    let min_val : Float = outputs.min() ?? 0
+    
+    if((max_val - min_val) > 0) {
+        multiplier = 255 / (max_val - min_val);
+    }
+    
+    // Draw result.
+    DispatchQueue.main.async {
+      self.tableView.reloadData()
+                        
+        var pixels: [PixelData] = .init(repeating: .init(a: 255, r: 0, g: 0, b: 0), count: width * height)
+             
+        for i in pixels.indices {
+        //if(i < 1000)
+        //{
+            let val = UInt8((outputs[i] - min_val) * multiplier)
+            
+            pixels[i].r = val
+            pixels[i].g = val
+            pixels[i].b = val
+        //}
+        }
+        
+        
+        /*
+           pixels[i].a = 255
+           pixels[i].r = .random(in: 0...255)
+           pixels[i].g = .random(in: 0...255)
+           pixels[i].b = .random(in: 0...255)
+        }
+        */
+        
+        DispatchQueue.main.async {
+            let image = UIImage(pixels: pixels, width: width, height: height)
+
+            self.imageView.image = image
+            
+            if (self.imageViewInitialized == false) {
+                self.imageViewInitialized = true
+                self.overlayView.addSubview(self.imageView)
+                self.overlayView.setNeedsDisplay()
+            }
+        }
+        
+        /*
+        let image = UIImage(pixels: pixels, width: width, height: height)
+        
+        var imageView : UIImageView
+        imageView  = UIImageView(frame:CGRect(x:0, y:0, width:400, height:400));
+        imageView.image = image
+        self.overlayView.addSubview(imageView)
+        self.overlayView.setNeedsDisplay()
+        */
+    }
+  }
+/*
+  func drawResult(of result: Result) {
+    self.overlayView.dots = result.dots
+    self.overlayView.lines = result.lines
+    self.overlayView.setNeedsDisplay()
+  }
+
+  func clearResult() {
+    self.overlayView.clear()
+    self.overlayView.setNeedsDisplay()
+  }
+    */
+    
+}
+
+
+// MARK: - TableViewDelegate, TableViewDataSource Methods
+extension ViewController: UITableViewDelegate, UITableViewDataSource {
+  func numberOfSections(in tableView: UITableView) -> Int {
+    return InferenceSections.allCases.count
+  }
+
+  func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
+    guard let section = InferenceSections(rawValue: section) else {
+      return 0
+    }
+
+    return section.subcaseCount
+  }
+
+  func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
+    let cell = tableView.dequeueReusableCell(withIdentifier: "InfoCell") as! InfoCell
+    guard let section = InferenceSections(rawValue: indexPath.section) else {
+      return cell
+    }
+    guard let data = inferencedData else { return cell }
+
+    var fieldName: String
+    var info: String
+
+    switch section {
+    case .Score:
+      fieldName = section.description
+      info = String(format: "%.3f", data.score)
+    case .Time:
+      guard let row = ProcessingTimes(rawValue: indexPath.row) else {
+        return cell
+      }
+      var time: Double
+      switch row {
+      case .InferenceTime:
+        time = data.times.inference
+      }
+      fieldName = row.description
+      info = String(format: "%.2fms", time)
+    }
+
+    cell.fieldNameLabel.text = fieldName
+    cell.infoLabel.text = info
+
+    return cell
+  }
+
+  func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
+    guard let section = InferenceSections(rawValue: indexPath.section) else {
+      return 0
+    }
+
+    var height = Traits.normalCellHeight
+    if indexPath.row == section.subcaseCount - 1 {
+      height = Traits.separatorCellHeight + Traits.bottomSpacing
+    }
+    return height
+  }
+
+}
+
+// MARK: - Private enums
+/// UI coinstraint values
+fileprivate enum Traits {
+  static let normalCellHeight: CGFloat = 35.0
+  static let separatorCellHeight: CGFloat = 25.0
+  static let bottomSpacing: CGFloat = 30.0
+}
+
+fileprivate struct InferencedData {
+  var score: Float
+  var times: Times
+}
+
+/// Type of sections in Info Cell
+fileprivate enum InferenceSections: Int, CaseIterable {
+  case Score
+  case Time
+
+  var description: String {
+    switch self {
+    case .Score:
+      return "Average"
+    case .Time:
+      return "Processing Time"
+    }
+  }
+
+  var subcaseCount: Int {
+    switch self {
+    case .Score:
+      return 1
+    case .Time:
+      return ProcessingTimes.allCases.count
+    }
+  }
+}
+
+/// Type of processing times in Time section in Info Cell
+fileprivate enum ProcessingTimes: Int, CaseIterable {
+  case InferenceTime
+
+  var description: String {
+    switch self {
+    case .InferenceTime:
+      return "Inference Time"
+    }
+  }
+}

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/Midas/Views/OverlayView.swift

@@ -0,0 +1,63 @@
+// Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import UIKit
+
+/// UIView for rendering inference output.
+class OverlayView: UIView {
+
+  var dots = [CGPoint]()
+  var lines = [Line]()
+
+  override func draw(_ rect: CGRect) {
+    for dot in dots {
+      drawDot(of: dot)
+    }
+    for line in lines {
+      drawLine(of: line)
+    }
+  }
+
+  func drawDot(of dot: CGPoint) {
+    let dotRect = CGRect(
+      x: dot.x - Traits.dot.radius / 2, y: dot.y - Traits.dot.radius / 2,
+      width: Traits.dot.radius, height: Traits.dot.radius)
+    let dotPath = UIBezierPath(ovalIn: dotRect)
+
+    Traits.dot.color.setFill()
+    dotPath.fill()
+  }
+
+  func drawLine(of line: Line) {
+    let linePath = UIBezierPath()
+    linePath.move(to: CGPoint(x: line.from.x, y: line.from.y))
+    linePath.addLine(to: CGPoint(x: line.to.x, y: line.to.y))
+    linePath.close()
+
+    linePath.lineWidth = Traits.line.width
+    Traits.line.color.setStroke()
+
+    linePath.stroke()
+  }
+
+  func clear() {
+    self.dots = []
+    self.lines = []
+  }
+}
+
+private enum Traits {
+  static let dot = (radius: CGFloat(5), color: UIColor.orange)
+  static let line = (width: CGFloat(1.0), color: UIColor.orange)
+}

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/README.md

@@ -0,0 +1,105 @@
+# Tensorflow Lite MiDaS iOS Example
+
+### Requirements
+
+- XCode 11.0 or above
+- iOS 12.0 or above, [iOS 14 breaks the NPU Delegate](https://github.com/tensorflow/tensorflow/issues/43339)
+- TensorFlow 2.4.0, TensorFlowLiteSwift -> 0.0.1-nightly
+
+## Quick Start with a MiDaS Example
+
+MiDaS is a neural network to compute depth from a single image. It uses TensorFlowLiteSwift / C++ libraries on iOS. The code is written in Swift.
+
+Paper: https://arxiv.org/abs/1907.01341
+
+> Towards Robust Monocular Depth Estimation: Mixing Datasets for Zero-shot Cross-dataset Transfer
+> René Ranftl, Katrin Lasinger, David Hafner, Konrad Schindler, Vladlen Koltun
+
+### Install TensorFlow
+
+Set default python version to python3:
+
+```
+echo 'export PATH=/usr/local/opt/python/libexec/bin:$PATH' >> ~/.zshenv
+echo 'alias python=python3' >> ~/.zshenv
+echo 'alias pip=pip3' >> ~/.zshenv
+```
+
+Install TensorFlow
+
+```shell
+pip install tensorflow
+```
+
+### Install TensorFlowLiteSwift via Cocoapods
+
+Set required TensorFlowLiteSwift version in the file (`0.0.1-nightly` is recommended): https://github.com/isl-org/MiDaS/blob/master/mobile/ios/Podfile#L9
+
+Install: brew, ruby, cocoapods
+
+```
+ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
+brew install mc rbenv ruby-build
+sudo gem install cocoapods
+```
+
+
+The TensorFlowLiteSwift library is available in [Cocoapods](https://cocoapods.org/), to integrate it to our project, we can run in the root directory of the project:
+
+```ruby
+pod install
+```
+
+Now open the `Midas.xcworkspace` file in XCode, select your iPhone device (XCode->Product->Destination->iPhone) and launch it (cmd + R). If everything works well, you should see a real-time depth map from your camera.
+
+### Model
+
+The TensorFlow (TFlite) model `midas.tflite` is in the folder `/Midas/Model`
+
+
+To use another model, you should convert it from TensorFlow saved-model to TFlite model (so that it can be deployed):
+
+```python
+saved_model_export_dir = "./saved_model"
+converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_export_dir)    
+tflite_model = converter.convert()
+open(model_tflite_name, "wb").write("model.tflite")
+```
+
+### Setup XCode
+
+* Open directory `.xcworkspace` from the XCode
+
+* Press on your ProjectName (left-top corner) -> change Bundle Identifier to `com.midas.tflite-npu` or something like this (it should be unique)
+
+* select your Developer Team (your should be signed-in by using your AppleID)
+
+* Connect your iPhone (if you want to run it on real device instead of simulator), select your iPhone device (XCode->Product->Destination->iPhone)
+
+* Click in the XCode: Product -> Run
+
+* On your iPhone device go to the: Settings -> General -> Device Management (or Profiles) -> Apple Development -> Trust Apple Development
+
+----
+
+Original repository: https://github.com/isl-org/MiDaS
+
+
+### Examples:
+
+| ![photo_2020-09-27_17-43-20](https://user-images.githubusercontent.com/4096485/94367804-9610de80-00e9-11eb-8a23-8b32a6f52d41.jpg) | ![photo_2020-09-27_17-49-22](https://user-images.githubusercontent.com/4096485/94367974-7201cd00-00ea-11eb-8e0a-68eb9ea10f63.jpg) | ![photo_2020-09-27_17-52-30](https://user-images.githubusercontent.com/4096485/94367976-729a6380-00ea-11eb-8ce0-39d3e26dd550.jpg) | ![photo_2020-09-27_17-43-21](https://user-images.githubusercontent.com/4096485/94367807-97420b80-00e9-11eb-9dcd-848ad9e89e03.jpg) |
+|---|---|---|---|
+
+## LICENSE
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/mobile/ios/RunScripts/download_models.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+# Download TF Lite model from the internet if it does not exist.
+
+TFLITE_MODEL="model_opt.tflite"
+TFLITE_FILE="Midas/Model/${TFLITE_MODEL}"
+MODEL_SRC="https://github.com/isl-org/MiDaS/releases/download/v2/${TFLITE_MODEL}"
+
+if test -f "${TFLITE_FILE}"; then
+    echo "INFO: TF Lite model already exists. Skip downloading and use the local model."
+else
+    curl --create-dirs -o "${TFLITE_FILE}" -LJO "${MODEL_SRC}"
+    echo "INFO: Downloaded TensorFlow Lite model to ${TFLITE_FILE}."
+fi
+

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/base_models/midas_repo/utils.py

@@ -0,0 +1,199 @@
+"""Utils for monoDepth.
+"""
+import sys
+import re
+import numpy as np
+import cv2
+import torch
+
+
+def read_pfm(path):
+    """Read pfm file.
+
+    Args:
+        path (str): path to file
+
+    Returns:
+        tuple: (data, scale)
+    """
+    with open(path, "rb") as file:
+
+        color = None
+        width = None
+        height = None
+        scale = None
+        endian = None
+
+        header = file.readline().rstrip()
+        if header.decode("ascii") == "PF":
+            color = True
+        elif header.decode("ascii") == "Pf":
+            color = False
+        else:
+            raise Exception("Not a PFM file: " + path)
+
+        dim_match = re.match(r"^(\d+)\s(\d+)\s$", file.readline().decode("ascii"))
+        if dim_match:
+            width, height = list(map(int, dim_match.groups()))
+        else:
+            raise Exception("Malformed PFM header.")
+
+        scale = float(file.readline().decode("ascii").rstrip())
+        if scale < 0:
+            # little-endian
+            endian = "<"
+            scale = -scale
+        else:
+            # big-endian
+            endian = ">"
+
+        data = np.fromfile(file, endian + "f")
+        shape = (height, width, 3) if color else (height, width)
+
+        data = np.reshape(data, shape)
+        data = np.flipud(data)
+
+        return data, scale
+
+
+def write_pfm(path, image, scale=1):
+    """Write pfm file.
+
+    Args:
+        path (str): pathto file
+        image (array): data
+        scale (int, optional): Scale. Defaults to 1.
+    """
+
+    with open(path, "wb") as file:
+        color = None
+
+        if image.dtype.name != "float32":
+            raise Exception("Image dtype must be float32.")
+
+        image = np.flipud(image)
+
+        if len(image.shape) == 3 and image.shape[2] == 3:  # color image
+            color = True
+        elif (
+            len(image.shape) == 2 or len(image.shape) == 3 and image.shape[2] == 1
+        ):  # greyscale
+            color = False
+        else:
+            raise Exception("Image must have H x W x 3, H x W x 1 or H x W dimensions.")
+
+        file.write("PF\n" if color else "Pf\n".encode())
+        file.write("%d %d\n".encode() % (image.shape[1], image.shape[0]))
+
+        endian = image.dtype.byteorder
+
+        if endian == "<" or endian == "=" and sys.byteorder == "little":
+            scale = -scale
+
+        file.write("%f\n".encode() % scale)
+
+        image.tofile(file)
+
+
+def read_image(path):
+    """Read image and output RGB image (0-1).
+
+    Args:
+        path (str): path to file
+
+    Returns:
+        array: RGB image (0-1)
+    """
+    img = cv2.imread(path)
+
+    if img.ndim == 2:
+        img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) / 255.0
+
+    return img
+
+
+def resize_image(img):
+    """Resize image and make it fit for network.
+
+    Args:
+        img (array): image
+
+    Returns:
+        tensor: data ready for network
+    """
+    height_orig = img.shape[0]
+    width_orig = img.shape[1]
+
+    if width_orig > height_orig:
+        scale = width_orig / 384
+    else:
+        scale = height_orig / 384
+
+    height = (np.ceil(height_orig / scale / 32) * 32).astype(int)
+    width = (np.ceil(width_orig / scale / 32) * 32).astype(int)
+
+    img_resized = cv2.resize(img, (width, height), interpolation=cv2.INTER_AREA)
+
+    img_resized = (
+        torch.from_numpy(np.transpose(img_resized, (2, 0, 1))).contiguous().float()
+    )
+    img_resized = img_resized.unsqueeze(0)
+
+    return img_resized
+
+
+def resize_depth(depth, width, height):
+    """Resize depth map and bring to CPU (numpy).
+
+    Args:
+        depth (tensor): depth
+        width (int): image width
+        height (int): image height
+
+    Returns:
+        array: processed depth
+    """
+    depth = torch.squeeze(depth[0, :, :, :]).to("cpu")
+
+    depth_resized = cv2.resize(
+        depth.numpy(), (width, height), interpolation=cv2.INTER_CUBIC
+    )
+
+    return depth_resized
+
+def write_depth(path, depth, grayscale, bits=1):
+    """Write depth map to png file.
+
+    Args:
+        path (str): filepath without extension
+        depth (array): depth
+        grayscale (bool): use a grayscale colormap?
+    """
+    if not grayscale:
+        bits = 1
+
+    if not np.isfinite(depth).all():
+        depth=np.nan_to_num(depth, nan=0.0, posinf=0.0, neginf=0.0)
+        print("WARNING: Non-finite depth values present")
+
+    depth_min = depth.min()
+    depth_max = depth.max()
+
+    max_val = (2**(8*bits))-1
+
+    if depth_max - depth_min > np.finfo("float").eps:
+        out = max_val * (depth - depth_min) / (depth_max - depth_min)
+    else:
+        out = np.zeros(depth.shape, dtype=depth.dtype)
+
+    if not grayscale:
+        out = cv2.applyColorMap(np.uint8(out), cv2.COLORMAP_INFERNO)
+
+    if bits == 1:
+        cv2.imwrite(path + ".png", out.astype("uint8"))
+    elif bits == 2:
+        cv2.imwrite(path + ".png", out.astype("uint16"))
+
+    return

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/builder.py

@@ -0,0 +1,51 @@
+# MIT License
+
+# Copyright (c) 2022 Intelligent Systems Lab Org
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# File author: Shariq Farooq Bhat
+
+from importlib import import_module
+from .depth_model import DepthModel
+
+def build_model(config) -> DepthModel:
+    """Builds a model from a config. The model is specified by the model name and version in the config. The model is then constructed using the build_from_config function of the model interface.
+    This function should be used to construct models for training and evaluation.
+
+    Args:
+        config (dict): Config dict. Config is constructed in utils/config.py. Each model has its own config file(s) saved in its root model folder.
+
+    Returns:
+        torch.nn.Module: Model corresponding to name and version as specified in config
+    """
+    module_name = f"zoedepth.models.{config.model}"
+    try:
+        module = import_module(module_name)
+    except ModuleNotFoundError as e:
+        # print the original error message
+        print(e)
+        raise ValueError(
+            f"Model {config.model} not found. Refer above error for details.") from e
+    try:
+        get_version = getattr(module, "get_version")
+    except AttributeError as e:
+        raise ValueError(
+            f"Model {config.model} has no get_version function.") from e
+    return get_version(config.version_name).build_from_config(config)

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/depth_model.py

@@ -0,0 +1,152 @@
+# MIT License
+
+# Copyright (c) 2022 Intelligent Systems Lab Org
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# File author: Shariq Farooq Bhat
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchvision import transforms
+import PIL.Image
+from PIL import Image
+from typing import Union
+
+
+class DepthModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.device = 'cpu'
+    
+    def to(self, device) -> nn.Module:
+        self.device = device
+        return super().to(device)
+    
+    def forward(self, x, *args, **kwargs):
+        raise NotImplementedError
+    
+    def _infer(self, x: torch.Tensor):
+        """
+        Inference interface for the model
+        Args:
+            x (torch.Tensor): input tensor of shape (b, c, h, w)
+        Returns:
+            torch.Tensor: output tensor of shape (b, 1, h, w)
+        """
+        return self(x)['metric_depth']
+    
+    def _infer_with_pad_aug(self, x: torch.Tensor, pad_input: bool=True, fh: float=3, fw: float=3, upsampling_mode: str='bicubic', padding_mode="reflect", **kwargs) -> torch.Tensor:
+        """
+        Inference interface for the model with padding augmentation
+        Padding augmentation fixes the boundary artifacts in the output depth map.
+        Boundary artifacts are sometimes caused by the fact that the model is trained on NYU raw dataset which has a black or white border around the image.
+        This augmentation pads the input image and crops the prediction back to the original size / view.
+
+        Note: This augmentation is not required for the models trained with 'avoid_boundary'=True.
+        Args:
+            x (torch.Tensor): input tensor of shape (b, c, h, w)
+            pad_input (bool, optional): whether to pad the input or not. Defaults to True.
+            fh (float, optional): height padding factor. The padding is calculated as sqrt(h/2) * fh. Defaults to 3.
+            fw (float, optional): width padding factor. The padding is calculated as sqrt(w/2) * fw. Defaults to 3.
+            upsampling_mode (str, optional): upsampling mode. Defaults to 'bicubic'.
+            padding_mode (str, optional): padding mode. Defaults to "reflect".
+        Returns:
+            torch.Tensor: output tensor of shape (b, 1, h, w)
+        """
+        # assert x is nchw and c = 3
+        assert x.dim() == 4, "x must be 4 dimensional, got {}".format(x.dim())
+        assert x.shape[1] == 3, "x must have 3 channels, got {}".format(x.shape[1])
+
+        if pad_input:
+            assert fh > 0 or fw > 0, "atlease one of fh and fw must be greater than 0"
+            pad_h = int(np.sqrt(x.shape[2]/2) * fh)
+            pad_w = int(np.sqrt(x.shape[3]/2) * fw)
+            padding = [pad_w, pad_w]
+            if pad_h > 0:
+                padding += [pad_h, pad_h]
+            
+            x = F.pad(x, padding, mode=padding_mode, **kwargs)
+        out = self._infer(x)
+        if out.shape[-2:] != x.shape[-2:]:
+            out = F.interpolate(out, size=(x.shape[2], x.shape[3]), mode=upsampling_mode, align_corners=False)
+        if pad_input:
+            # crop to the original size, handling the case where pad_h and pad_w is 0
+            if pad_h > 0:
+                out = out[:, :, pad_h:-pad_h,:]
+            if pad_w > 0:
+                out = out[:, :, :, pad_w:-pad_w]
+        return out
+    
+    def infer_with_flip_aug(self, x, pad_input: bool=True, **kwargs) -> torch.Tensor:
+        """
+        Inference interface for the model with horizontal flip augmentation
+        Horizontal flip augmentation improves the accuracy of the model by averaging the output of the model with and without horizontal flip.
+        Args:
+            x (torch.Tensor): input tensor of shape (b, c, h, w)
+            pad_input (bool, optional): whether to use padding augmentation. Defaults to True.
+        Returns:
+            torch.Tensor: output tensor of shape (b, 1, h, w)
+        """
+        # infer with horizontal flip and average
+        out = self._infer_with_pad_aug(x, pad_input=pad_input, **kwargs)
+        out_flip = self._infer_with_pad_aug(torch.flip(x, dims=[3]), pad_input=pad_input, **kwargs)
+        out = (out + torch.flip(out_flip, dims=[3])) / 2
+        return out
+    
+    def infer(self, x, pad_input: bool=True, with_flip_aug: bool=True, **kwargs) -> torch.Tensor:
+        """
+        Inference interface for the model
+        Args:
+            x (torch.Tensor): input tensor of shape (b, c, h, w)
+            pad_input (bool, optional): whether to use padding augmentation. Defaults to True.
+            with_flip_aug (bool, optional): whether to use horizontal flip augmentation. Defaults to True.
+        Returns:
+            torch.Tensor: output tensor of shape (b, 1, h, w)
+        """
+        if with_flip_aug:
+            return self.infer_with_flip_aug(x, pad_input=pad_input, **kwargs)
+        else:
+            return self._infer_with_pad_aug(x, pad_input=pad_input, **kwargs)
+    
+    @torch.no_grad()
+    def infer_pil(self, pil_img, pad_input: bool=True, with_flip_aug: bool=True, output_type: str="numpy", **kwargs) -> Union[np.ndarray, PIL.Image.Image, torch.Tensor]:
+        """
+        Inference interface for the model for PIL image
+        Args:
+            pil_img (PIL.Image.Image): input PIL image
+            pad_input (bool, optional): whether to use padding augmentation. Defaults to True.
+            with_flip_aug (bool, optional): whether to use horizontal flip augmentation. Defaults to True.
+            output_type (str, optional): output type. Supported values are 'numpy', 'pil' and 'tensor'. Defaults to "numpy".
+        """
+        x = transforms.ToTensor()(pil_img).unsqueeze(0).to(self.device)
+        out_tensor = self.infer(x, pad_input=pad_input, with_flip_aug=with_flip_aug, **kwargs)
+        if output_type == "numpy":
+            return out_tensor.squeeze().cpu().numpy()
+        elif output_type == "pil":
+            # uint16 is required for depth pil image
+            out_16bit_numpy = (out_tensor.squeeze().cpu().numpy()*256).astype(np.uint16)
+            return Image.fromarray(out_16bit_numpy)
+        elif output_type == "tensor":
+            return out_tensor.squeeze().cpu()
+        else:
+            raise ValueError(f"output_type {output_type} not supported. Supported values are 'numpy', 'pil' and 'tensor'")
+    

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/model_io.py

@@ -0,0 +1,92 @@
+# MIT License
+
+# Copyright (c) 2022 Intelligent Systems Lab Org
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# File author: Shariq Farooq Bhat
+
+import torch
+
+def load_state_dict(model, state_dict):
+    """Load state_dict into model, handling DataParallel and DistributedDataParallel. Also checks for "model" key in state_dict.
+
+    DataParallel prefixes state_dict keys with 'module.' when saving.
+    If the model is not a DataParallel model but the state_dict is, then prefixes are removed.
+    If the model is a DataParallel model but the state_dict is not, then prefixes are added.
+    """
+    state_dict = state_dict.get('model', state_dict)
+    # if model is a DataParallel model, then state_dict keys are prefixed with 'module.'
+
+    do_prefix = isinstance(
+        model, (torch.nn.DataParallel, torch.nn.parallel.DistributedDataParallel))
+    state = {}
+    for k, v in state_dict.items():
+        if k.startswith('module.') and not do_prefix:
+            k = k[7:]
+
+        if not k.startswith('module.') and do_prefix:
+            k = 'module.' + k
+
+        state[k] = v
+
+    model.load_state_dict(state)
+    print("Loaded successfully")
+    return model
+
+
+def load_wts(model, checkpoint_path):
+    ckpt = torch.load(checkpoint_path, map_location='cpu')
+    return load_state_dict(model, ckpt)
+
+
+def load_state_dict_from_url(model, url, **kwargs):
+    state_dict = torch.hub.load_state_dict_from_url(url, map_location='cpu', **kwargs)
+    return load_state_dict(model, state_dict)
+
+
+def load_state_from_resource(model, resource: str):
+    """Loads weights to the model from a given resource. A resource can be of following types:
+        1. URL. Prefixed with "url::"
+                e.g. url::http(s)://url.resource.com/ckpt.pt
+
+        2. Local path. Prefixed with "local::"
+                e.g. local::/path/to/ckpt.pt
+
+
+    Args:
+        model (torch.nn.Module): Model
+        resource (str): resource string
+
+    Returns:
+        torch.nn.Module: Model with loaded weights
+    """
+    print(f"Using pretrained resource {resource}")
+
+    if resource.startswith('url::'):
+        url = resource.split('url::')[1]
+        return load_state_dict_from_url(model, url, progress=True)
+
+    elif resource.startswith('local::'):
+        path = resource.split('local::')[1]
+        return load_wts(model, path)
+        
+    else:
+        raise ValueError("Invalid resource type, only url:: and local:: are supported")
+    

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/zoedepth/__init__.py

@@ -0,0 +1,31 @@
+# MIT License
+
+# Copyright (c) 2022 Intelligent Systems Lab Org
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# File author: Shariq Farooq Bhat
+
+from .zoedepth_v1 import ZoeDepth 
+
+all_versions = {
+    "v1": ZoeDepth,
+}
+
+get_version = lambda v : all_versions[v]

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/zoedepth/config_zoedepth.json

@@ -0,0 +1,58 @@
+{
+    "model": {
+        "name": "ZoeDepth",
+        "version_name": "v1",
+        "n_bins": 64,
+        "bin_embedding_dim": 128,
+        "bin_centers_type": "softplus",
+        "n_attractors":[16, 8, 4, 1],
+        "attractor_alpha": 1000,
+        "attractor_gamma": 2,
+        "attractor_kind" : "mean",
+        "attractor_type" : "inv",
+        "midas_model_type" : "DPT_BEiT_L_384",
+        "min_temp": 0.0212,
+        "max_temp": 50.0,
+        "output_distribution": "logbinomial",
+        "memory_efficient": true,
+        "inverse_midas": false,
+        "img_size": [384, 512]
+    },
+    
+    "train": {
+        "train_midas": true,
+        "use_pretrained_midas": true,
+        "trainer": "zoedepth",
+        "epochs": 5,
+        "bs": 16,
+        "optim_kwargs": {"lr": 0.000161, "wd": 0.01},
+        "sched_kwargs": {"div_factor": 1, "final_div_factor": 10000, "pct_start": 0.7, "three_phase":false, "cycle_momentum": true},
+        "same_lr": false,
+        "w_si": 1,
+        "w_domain": 0.2,
+        "w_reg": 0,
+        "w_grad": 0,
+        "avoid_boundary": false,
+        "random_crop": false,
+        "input_width": 640,
+        "input_height": 480,
+        "midas_lr_factor": 1,
+        "encoder_lr_factor":10,
+        "pos_enc_lr_factor":10,
+        "freeze_midas_bn": true
+
+    },
+
+    "infer":{
+        "train_midas": false,
+        "use_pretrained_midas": false,
+        "pretrained_resource" : null,
+        "force_keep_ar": true
+    },
+
+    "eval":{
+        "train_midas": false,
+        "use_pretrained_midas": false,
+        "pretrained_resource" : null
+    }
+}

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/zoedepth/config_zoedepth_kitti.json

@@ -0,0 +1,22 @@
+{
+    "model": {
+        "bin_centers_type": "normed",
+        "img_size": [384, 768]
+    },
+    
+    "train": {
+    },
+
+    "infer":{
+        "train_midas": false,
+        "use_pretrained_midas": false,
+        "pretrained_resource" : "url::https://github.com/isl-org/ZoeDepth/releases/download/v1.0/ZoeD_M12_K.pt",
+        "force_keep_ar": true
+    },
+
+    "eval":{
+        "train_midas": false,
+        "use_pretrained_midas": false,
+        "pretrained_resource" : "url::https://github.com/isl-org/ZoeDepth/releases/download/v1.0/ZoeD_M12_K.pt"
+    }
+}

CCEdit-main/src/controlnet11/annotator/zoe/zoedepth/models/zoedepth/zoedepth_v1.py

@@ -0,0 +1,250 @@
+# MIT License
+
+# Copyright (c) 2022 Intelligent Systems Lab Org
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# File author: Shariq Farooq Bhat
+
+import itertools
+
+import torch
+import torch.nn as nn
+from ..depth_model import DepthModel
+from ..base_models.midas import MidasCore
+from ..layers.attractor import AttractorLayer, AttractorLayerUnnormed
+from ..layers.dist_layers import ConditionalLogBinomial
+from ..layers.localbins_layers import (Projector, SeedBinRegressor,
+                                            SeedBinRegressorUnnormed)
+from ..model_io import load_state_from_resource
+
+
+class ZoeDepth(DepthModel):
+    def __init__(self, core,  n_bins=64, bin_centers_type="softplus", bin_embedding_dim=128, min_depth=1e-3, max_depth=10,
+                 n_attractors=[16, 8, 4, 1], attractor_alpha=300, attractor_gamma=2, attractor_kind='sum', attractor_type='exp', min_temp=5, max_temp=50, train_midas=True,
+                 midas_lr_factor=10, encoder_lr_factor=10, pos_enc_lr_factor=10, inverse_midas=False, **kwargs):
+        """ZoeDepth model. This is the version of ZoeDepth that has a single metric head
+
+        Args:
+            core (models.base_models.midas.MidasCore): The base midas model that is used for extraction of "relative" features
+            n_bins (int, optional): Number of bin centers. Defaults to 64.
+            bin_centers_type (str, optional): "normed" or "softplus". Activation type used for bin centers. For "normed" bin centers, linear normalization trick is applied. This results in bounded bin centers.
+                                               For "softplus", softplus activation is used and thus are unbounded. Defaults to "softplus".
+            bin_embedding_dim (int, optional): bin embedding dimension. Defaults to 128.
+            min_depth (float, optional): Lower bound for normed bin centers. Defaults to 1e-3.
+            max_depth (float, optional): Upper bound for normed bin centers. Defaults to 10.
+            n_attractors (List[int], optional): Number of bin attractors at decoder layers. Defaults to [16, 8, 4, 1].
+            attractor_alpha (int, optional): Proportional attractor strength. Refer to models.layers.attractor for more details. Defaults to 300.
+            attractor_gamma (int, optional): Exponential attractor strength. Refer to models.layers.attractor for more details. Defaults to 2.
+            attractor_kind (str, optional): Attraction aggregation "sum" or "mean". Defaults to 'sum'.
+            attractor_type (str, optional): Type of attractor to use; "inv" (Inverse attractor) or "exp" (Exponential attractor). Defaults to 'exp'.
+            min_temp (int, optional): Lower bound for temperature of output probability distribution. Defaults to 5.
+            max_temp (int, optional): Upper bound for temperature of output probability distribution. Defaults to 50.
+            train_midas (bool, optional): Whether to train "core", the base midas model. Defaults to True.
+            midas_lr_factor (int, optional): Learning rate reduction factor for base midas model except its encoder and positional encodings. Defaults to 10.
+            encoder_lr_factor (int, optional): Learning rate reduction factor for the encoder in midas model. Defaults to 10.
+            pos_enc_lr_factor (int, optional): Learning rate reduction factor for positional encodings in the base midas model. Defaults to 10.
+        """
+        super().__init__()
+
+        self.core = core
+        self.max_depth = max_depth
+        self.min_depth = min_depth
+        self.min_temp = min_temp
+        self.bin_centers_type = bin_centers_type
+
+        self.midas_lr_factor = midas_lr_factor
+        self.encoder_lr_factor = encoder_lr_factor
+        self.pos_enc_lr_factor = pos_enc_lr_factor
+        self.train_midas = train_midas
+        self.inverse_midas = inverse_midas
+
+        if self.encoder_lr_factor <= 0:
+            self.core.freeze_encoder(
+                freeze_rel_pos=self.pos_enc_lr_factor <= 0)
+
+        N_MIDAS_OUT = 32
+        btlnck_features = self.core.output_channels[0]
+        num_out_features = self.core.output_channels[1:]
+
+        self.conv2 = nn.Conv2d(btlnck_features, btlnck_features,
+                               kernel_size=1, stride=1, padding=0)  # btlnck conv
+
+        if bin_centers_type == "normed":
+            SeedBinRegressorLayer = SeedBinRegressor
+            Attractor = AttractorLayer
+        elif bin_centers_type == "softplus":
+            SeedBinRegressorLayer = SeedBinRegressorUnnormed
+            Attractor = AttractorLayerUnnormed
+        elif bin_centers_type == "hybrid1":
+            SeedBinRegressorLayer = SeedBinRegressor
+            Attractor = AttractorLayerUnnormed
+        elif bin_centers_type == "hybrid2":
+            SeedBinRegressorLayer = SeedBinRegressorUnnormed
+            Attractor = AttractorLayer
+        else:
+            raise ValueError(
+                "bin_centers_type should be one of 'normed', 'softplus', 'hybrid1', 'hybrid2'")
+
+        self.seed_bin_regressor = SeedBinRegressorLayer(
+            btlnck_features, n_bins=n_bins, min_depth=min_depth, max_depth=max_depth)
+        self.seed_projector = Projector(btlnck_features, bin_embedding_dim)
+        self.projectors = nn.ModuleList([
+            Projector(num_out, bin_embedding_dim)
+            for num_out in num_out_features
+        ])
+        self.attractors = nn.ModuleList([
+            Attractor(bin_embedding_dim, n_bins, n_attractors=n_attractors[i], min_depth=min_depth, max_depth=max_depth,
+                      alpha=attractor_alpha, gamma=attractor_gamma, kind=attractor_kind, attractor_type=attractor_type)
+            for i in range(len(num_out_features))
+        ])
+
+        last_in = N_MIDAS_OUT + 1  # +1 for relative depth
+
+        # use log binomial instead of softmax
+        self.conditional_log_binomial = ConditionalLogBinomial(
+            last_in, bin_embedding_dim, n_classes=n_bins, min_temp=min_temp, max_temp=max_temp)
+
+    def forward(self, x, return_final_centers=False, denorm=False, return_probs=False, **kwargs):
+        """
+        Args:
+            x (torch.Tensor): Input image tensor of shape (B, C, H, W)
+            return_final_centers (bool, optional): Whether to return the final bin centers. Defaults to False.
+            denorm (bool, optional): Whether to denormalize the input image. This reverses ImageNet normalization as midas normalization is different. Defaults to False.
+            return_probs (bool, optional): Whether to return the output probability distribution. Defaults to False.
+        
+        Returns:
+            dict: Dictionary containing the following keys:
+                - rel_depth (torch.Tensor): Relative depth map of shape (B, H, W)
+                - metric_depth (torch.Tensor): Metric depth map of shape (B, 1, H, W)
+                - bin_centers (torch.Tensor): Bin centers of shape (B, n_bins). Present only if return_final_centers is True
+                - probs (torch.Tensor): Output probability distribution of shape (B, n_bins, H, W). Present only if return_probs is True
+
+        """
+        b, c, h, w = x.shape
+        # print("input shape ", x.shape)
+        self.orig_input_width = w
+        self.orig_input_height = h
+        rel_depth, out = self.core(x, denorm=denorm, return_rel_depth=True)
+        # print("output shapes", rel_depth.shape, out.shape)
+
+        outconv_activation = out[0]
+        btlnck = out[1]
+        x_blocks = out[2:]
+
+        x_d0 = self.conv2(btlnck)
+        x = x_d0
+        _, seed_b_centers = self.seed_bin_regressor(x)
+
+        if self.bin_centers_type == 'normed' or self.bin_centers_type == 'hybrid2':
+            b_prev = (seed_b_centers - self.min_depth) / \
+                (self.max_depth - self.min_depth)
+        else:
+            b_prev = seed_b_centers
+
+        prev_b_embedding = self.seed_projector(x)
+
+        # unroll this loop for better performance
+        for projector, attractor, x in zip(self.projectors, self.attractors, x_blocks):
+            b_embedding = projector(x)
+            b, b_centers = attractor(
+                b_embedding, b_prev, prev_b_embedding, interpolate=True)
+            b_prev = b.clone()
+            prev_b_embedding = b_embedding.clone()
+
+        last = outconv_activation
+
+        if self.inverse_midas:
+            # invert depth followed by normalization
+            rel_depth = 1.0 / (rel_depth + 1e-6)
+            rel_depth = (rel_depth - rel_depth.min()) / \
+                (rel_depth.max() - rel_depth.min())
+        # concat rel depth with last. First interpolate rel depth to last size
+        rel_cond = rel_depth.unsqueeze(1)
+        rel_cond = nn.functional.interpolate(
+            rel_cond, size=last.shape[2:], mode='bilinear', align_corners=True)
+        last = torch.cat([last, rel_cond], dim=1)
+
+        b_embedding = nn.functional.interpolate(
+            b_embedding, last.shape[-2:], mode='bilinear', align_corners=True)
+        x = self.conditional_log_binomial(last, b_embedding)
+
+        # Now depth value is Sum px * cx , where cx are bin_centers from the last bin tensor
+        # print(x.shape, b_centers.shape)
+        b_centers = nn.functional.interpolate(
+            b_centers, x.shape[-2:], mode='bilinear', align_corners=True)
+        out = torch.sum(x * b_centers, dim=1, keepdim=True)
+
+        # Structure output dict
+        output = dict(metric_depth=out)
+        if return_final_centers or return_probs:
+            output['bin_centers'] = b_centers
+
+        if return_probs:
+            output['probs'] = x
+
+        return output
+
+    def get_lr_params(self, lr):
+        """
+        Learning rate configuration for different layers of the model
+        Args:
+            lr (float) : Base learning rate
+        Returns:
+            list : list of parameters to optimize and their learning rates, in the format required by torch optimizers.
+        """
+        param_conf = []
+        if self.train_midas:
+            if self.encoder_lr_factor > 0:
+                param_conf.append({'params': self.core.get_enc_params_except_rel_pos(
+                ), 'lr': lr / self.encoder_lr_factor})
+
+            if self.pos_enc_lr_factor > 0:
+                param_conf.append(
+                    {'params': self.core.get_rel_pos_params(), 'lr': lr / self.pos_enc_lr_factor})
+
+            midas_params = self.core.core.scratch.parameters()
+            midas_lr_factor = self.midas_lr_factor
+            param_conf.append(
+                {'params': midas_params, 'lr': lr / midas_lr_factor})
+
+        remaining_modules = []
+        for name, child in self.named_children():
+            if name != 'core':
+                remaining_modules.append(child)
+        remaining_params = itertools.chain(
+            *[child.parameters() for child in remaining_modules])
+
+        param_conf.append({'params': remaining_params, 'lr': lr})
+
+        return param_conf
+
+    @staticmethod
+    def build(midas_model_type="DPT_BEiT_L_384", pretrained_resource=None, use_pretrained_midas=False, train_midas=False, freeze_midas_bn=True, **kwargs):
+        core = MidasCore.build(midas_model_type=midas_model_type, use_pretrained_midas=use_pretrained_midas,
+                               train_midas=train_midas, fetch_features=True, freeze_bn=freeze_midas_bn, **kwargs)
+        model = ZoeDepth(core, **kwargs)
+        if pretrained_resource:
+            assert isinstance(pretrained_resource, str), "pretrained_resource must be a string"
+            model = load_state_from_resource(model, pretrained_resource)
+        return model
+
+    @staticmethod
+    def build_from_config(config):
+        return ZoeDepth.build(**config)

CCEdit-main/src/controlnet11/gradio_annotator.py

@@ -0,0 +1,376 @@
+import gradio as gr
+
+from annotator.util import resize_image, HWC3
+
+
+model_canny = None
+
+
+def canny(img, res, l, h):
+    img = resize_image(HWC3(img), res)
+    global model_canny
+    if model_canny is None:
+        from annotator.canny import CannyDetector
+        model_canny = CannyDetector()
+    result = model_canny(img, l, h)
+    return [result]
+
+
+model_hed = None
+
+
+def hed(img, res):
+    img = resize_image(HWC3(img), res)
+    global model_hed
+    if model_hed is None:
+        from annotator.hed import HEDdetector
+        model_hed = HEDdetector()
+    result = model_hed(img)
+    return [result]
+
+
+model_pidi = None
+
+
+def pidi(img, res):
+    img = resize_image(HWC3(img), res)
+    global model_pidi
+    if model_pidi is None:
+        from annotator.pidinet import PidiNetDetector
+        model_pidi = PidiNetDetector()
+    result = model_pidi(img)
+    return [result]
+
+
+model_mlsd = None
+
+
+def mlsd(img, res, thr_v, thr_d):
+    img = resize_image(HWC3(img), res)
+    global model_mlsd
+    if model_mlsd is None:
+        from annotator.mlsd import MLSDdetector
+        model_mlsd = MLSDdetector()
+    result = model_mlsd(img, thr_v, thr_d)
+    return [result]
+
+
+model_midas = None
+
+
+def midas(img, res):
+    img = resize_image(HWC3(img), res)
+    global model_midas
+    if model_midas is None:
+        from annotator.midas import MidasDetector
+        model_midas = MidasDetector()
+    result = model_midas(img)
+    return [result]
+
+
+model_zoe = None
+
+
+def zoe(img, res):
+    img = resize_image(HWC3(img), res)
+    global model_zoe
+    if model_zoe is None:
+        from annotator.zoe import ZoeDetector
+        model_zoe = ZoeDetector()
+    result = model_zoe(img)
+    return [result]
+
+
+model_normalbae = None
+
+
+def normalbae(img, res):
+    img = resize_image(HWC3(img), res)
+    global model_normalbae
+    if model_normalbae is None:
+        from annotator.normalbae import NormalBaeDetector
+        model_normalbae = NormalBaeDetector()
+    result = model_normalbae(img)
+    return [result]
+
+
+model_openpose = None
+
+
+def openpose(img, res, hand_and_face):
+    img = resize_image(HWC3(img), res)
+    global model_openpose
+    if model_openpose is None:
+        from annotator.openpose import OpenposeDetector
+        model_openpose = OpenposeDetector()
+    result = model_openpose(img, hand_and_face)
+    return [result]
+
+
+model_uniformer = None
+
+
+def uniformer(img, res):
+    img = resize_image(HWC3(img), res)
+    global model_uniformer
+    if model_uniformer is None:
+        from annotator.uniformer import UniformerDetector
+        model_uniformer = UniformerDetector()
+    result = model_uniformer(img)
+    return [result]
+
+
+model_lineart_anime = None
+
+
+def lineart_anime(img, res):
+    img = resize_image(HWC3(img), res)
+    global model_lineart_anime
+    if model_lineart_anime is None:
+        from annotator.lineart_anime import LineartAnimeDetector
+        model_lineart_anime = LineartAnimeDetector()
+    result = model_lineart_anime(img)
+    return [result]
+
+
+model_lineart = None
+
+
+def lineart(img, res, coarse=False):
+    img = resize_image(HWC3(img), res)
+    global model_lineart
+    if model_lineart is None:
+        from annotator.lineart import LineartDetector
+        model_lineart = LineartDetector()
+    result = model_lineart(img, coarse)
+    return [result]
+
+
+model_oneformer_coco = None
+
+
+def oneformer_coco(img, res):
+    img = resize_image(HWC3(img), res)
+    global model_oneformer_coco
+    if model_oneformer_coco is None:
+        from annotator.oneformer import OneformerCOCODetector
+        model_oneformer_coco = OneformerCOCODetector()
+    result = model_oneformer_coco(img)
+    return [result]
+
+
+model_oneformer_ade20k = None
+
+
+def oneformer_ade20k(img, res):
+    img = resize_image(HWC3(img), res)
+    global model_oneformer_ade20k
+    if model_oneformer_ade20k is None:
+        from annotator.oneformer import OneformerADE20kDetector
+        model_oneformer_ade20k = OneformerADE20kDetector()
+    result = model_oneformer_ade20k(img)
+    return [result]
+
+
+model_content_shuffler = None
+
+
+def content_shuffler(img, res):
+    img = resize_image(HWC3(img), res)
+    global model_content_shuffler
+    if model_content_shuffler is None:
+        from annotator.shuffle import ContentShuffleDetector
+        model_content_shuffler = ContentShuffleDetector()
+    result = model_content_shuffler(img)
+    return [result]
+
+
+model_color_shuffler = None
+
+
+def color_shuffler(img, res):
+    img = resize_image(HWC3(img), res)
+    global model_color_shuffler
+    if model_color_shuffler is None:
+        from annotator.shuffle import ColorShuffleDetector
+        model_color_shuffler = ColorShuffleDetector()
+    result = model_color_shuffler(img)
+    return [result]
+
+
+block = gr.Blocks().queue()
+with block:
+    with gr.Row():
+        gr.Markdown("## Canny Edge")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            low_threshold = gr.Slider(label="low_threshold", minimum=1, maximum=255, value=100, step=1)
+            high_threshold = gr.Slider(label="high_threshold", minimum=1, maximum=255, value=200, step=1)
+            resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
+            run_button = gr.Button(label="Run")
+        with gr.Column():
+            gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
+    run_button.click(fn=canny, inputs=[input_image, resolution, low_threshold, high_threshold], outputs=[gallery])
+
+    with gr.Row():
+        gr.Markdown("## HED Edge")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
+            run_button = gr.Button(label="Run")
+        with gr.Column():
+            gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
+    run_button.click(fn=hed, inputs=[input_image, resolution], outputs=[gallery])
+
+    with gr.Row():
+        gr.Markdown("## Pidi Edge")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
+            run_button = gr.Button(label="Run")
+        with gr.Column():
+            gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
+    run_button.click(fn=pidi, inputs=[input_image, resolution], outputs=[gallery])
+
+    with gr.Row():
+        gr.Markdown("## MLSD Edge")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            value_threshold = gr.Slider(label="value_threshold", minimum=0.01, maximum=2.0, value=0.1, step=0.01)
+            distance_threshold = gr.Slider(label="distance_threshold", minimum=0.01, maximum=20.0, value=0.1, step=0.01)
+            resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=384, step=64)
+            run_button = gr.Button(label="Run")
+        with gr.Column():
+            gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
+    run_button.click(fn=mlsd, inputs=[input_image, resolution, value_threshold, distance_threshold], outputs=[gallery])
+
+    with gr.Row():
+        gr.Markdown("## MIDAS Depth")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=384, step=64)
+            run_button = gr.Button(label="Run")
+        with gr.Column():
+            gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
+    run_button.click(fn=midas, inputs=[input_image, resolution], outputs=[gallery])
+
+
+    with gr.Row():
+        gr.Markdown("## Zoe Depth")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
+            run_button = gr.Button(label="Run")
+        with gr.Column():
+            gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
+    run_button.click(fn=zoe, inputs=[input_image, resolution], outputs=[gallery])
+
+    with gr.Row():
+        gr.Markdown("## Normal Bae")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
+            run_button = gr.Button(label="Run")
+        with gr.Column():
+            gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
+    run_button.click(fn=normalbae, inputs=[input_image, resolution], outputs=[gallery])
+
+    with gr.Row():
+        gr.Markdown("## Openpose")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            hand_and_face = gr.Checkbox(label='Hand and Face', value=False)
+            resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
+            run_button = gr.Button(label="Run")
+        with gr.Column():
+            gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
+    run_button.click(fn=openpose, inputs=[input_image, resolution, hand_and_face], outputs=[gallery])
+
+    with gr.Row():
+        gr.Markdown("## Lineart Anime")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
+            run_button = gr.Button(label="Run")
+        with gr.Column():
+            gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
+    run_button.click(fn=lineart_anime, inputs=[input_image, resolution], outputs=[gallery])
+
+    with gr.Row():
+        gr.Markdown("## Lineart")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            coarse = gr.Checkbox(label='Using coarse model', value=False)
+            resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
+            run_button = gr.Button(label="Run")
+        with gr.Column():
+            gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
+    run_button.click(fn=lineart, inputs=[input_image, resolution, coarse], outputs=[gallery])
+
+    with gr.Row():
+        gr.Markdown("## Uniformer Segmentation")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
+            run_button = gr.Button(label="Run")
+        with gr.Column():
+            gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
+    run_button.click(fn=uniformer, inputs=[input_image, resolution], outputs=[gallery])
+
+    with gr.Row():
+        gr.Markdown("## Oneformer COCO Segmentation")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
+            run_button = gr.Button(label="Run")
+        with gr.Column():
+            gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
+    run_button.click(fn=oneformer_coco, inputs=[input_image, resolution], outputs=[gallery])
+
+    with gr.Row():
+        gr.Markdown("## Oneformer ADE20K Segmentation")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=640, step=64)
+            run_button = gr.Button(label="Run")
+        with gr.Column():
+            gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
+    run_button.click(fn=oneformer_ade20k, inputs=[input_image, resolution], outputs=[gallery])
+
+    with gr.Row():
+        gr.Markdown("## Content Shuffle")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
+            run_button = gr.Button(label="Run")
+        with gr.Column():
+            gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
+    run_button.click(fn=content_shuffler, inputs=[input_image, resolution], outputs=[gallery])
+
+    with gr.Row():
+        gr.Markdown("## Color Shuffle")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
+            run_button = gr.Button(label="Run")
+        with gr.Column():
+            gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
+    run_button.click(fn=color_shuffler, inputs=[input_image, resolution], outputs=[gallery])
+
+
+block.launch(server_name='0.0.0.0')

CCEdit-main/src/controlnet11/gradio_inpaint.py

@@ -0,0 +1,122 @@
+from share import *
+import config
+
+import cv2
+import einops
+import gradio as gr
+import numpy as np
+import torch
+import random
+
+from pytorch_lightning import seed_everything
+from annotator.util import resize_image, HWC3
+from cldm.model import create_model, load_state_dict
+from cldm.ddim_hacked import DDIMSampler
+
+
+model_name = 'control_v11p_sd15_inpaint'
+model = create_model(f'./models/{model_name}.yaml').cpu()
+model.load_state_dict(load_state_dict('./models/v1-5-pruned.ckpt', location='cuda'), strict=False)
+model.load_state_dict(load_state_dict(f'./models/{model_name}.pth', location='cuda'), strict=False)
+model = model.cuda()
+ddim_sampler = DDIMSampler(model)
+
+
+def process(input_image_and_mask, prompt, a_prompt, n_prompt, num_samples, image_resolution, ddim_steps, guess_mode, strength, scale, seed, eta, mask_blur):
+    with torch.no_grad():
+        input_image = HWC3(input_image_and_mask['image'])
+        input_mask = input_image_and_mask['mask']
+
+        img_raw = resize_image(input_image, image_resolution).astype(np.float32)
+        H, W, C = img_raw.shape
+
+        mask_pixel = cv2.resize(input_mask[:, :, 0], (W, H), interpolation=cv2.INTER_LINEAR).astype(np.float32) / 255.0
+        mask_pixel = cv2.GaussianBlur(mask_pixel, (0, 0), mask_blur)
+
+        mask_latent = cv2.resize(mask_pixel, (W // 8, H // 8), interpolation=cv2.INTER_AREA)
+
+        detected_map = img_raw.copy()
+        detected_map[mask_pixel > 0.5] = - 255.0
+
+        control = torch.from_numpy(detected_map.copy()).float().cuda() / 255.0
+        control = torch.stack([control for _ in range(num_samples)], dim=0)
+        control = einops.rearrange(control, 'b h w c -> b c h w').clone()
+
+        mask = 1.0 - torch.from_numpy(mask_latent.copy()).float().cuda()
+        mask = torch.stack([mask for _ in range(num_samples)], dim=0)
+        mask = einops.rearrange(mask, 'b h w -> b 1 h w').clone()
+
+        x0 = torch.from_numpy(img_raw.copy()).float().cuda() / 127.0 - 1.0
+        x0 = torch.stack([x0 for _ in range(num_samples)], dim=0)
+        x0 = einops.rearrange(x0, 'b h w c -> b c h w').clone()
+
+        mask_pixel_batched = mask_pixel[None, :, :, None]
+        img_pixel_batched = img_raw.copy()[None]
+
+        if seed == -1:
+            seed = random.randint(0, 65535)
+        seed_everything(seed)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=False)
+
+        cond = {"c_concat": [control], "c_crossattn": [model.get_learned_conditioning([prompt + ', ' + a_prompt] * num_samples)]}
+        un_cond = {"c_concat": None if guess_mode else [control], "c_crossattn": [model.get_learned_conditioning([n_prompt] * num_samples)]}
+        shape = (4, H // 8, W // 8)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=False)
+
+        ddim_sampler.make_schedule(ddim_steps, ddim_eta=eta, verbose=True)
+        x0 = model.get_first_stage_encoding(model.encode_first_stage(x0))
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=True)
+
+        model.control_scales = [strength * (0.825 ** float(12 - i)) for i in range(13)] if guess_mode else ([strength] * 13)
+        # Magic number. IDK why. Perhaps because 0.825**12<0.01 but 0.826**12>0.01
+
+        samples, intermediates = ddim_sampler.sample(ddim_steps, num_samples,
+                                                     shape, cond, verbose=False, eta=eta,
+                                                     unconditional_guidance_scale=scale,
+                                                     unconditional_conditioning=un_cond, x0=x0, mask=mask)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=False)
+
+        x_samples = model.decode_first_stage(samples)
+        x_samples = (einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 + 127.5).cpu().numpy().astype(np.float32)
+        x_samples = x_samples * mask_pixel_batched + img_pixel_batched * (1.0 - mask_pixel_batched)
+
+        results = [x_samples[i].clip(0, 255).astype(np.uint8) for i in range(num_samples)]
+    return [detected_map.clip(0, 255).astype(np.uint8)] + results
+
+
+block = gr.Blocks().queue()
+with block:
+    with gr.Row():
+        gr.Markdown("## Control Stable Diffusion with Inpaint Mask")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy", tool="sketch")
+            prompt = gr.Textbox(label="Prompt")
+            run_button = gr.Button(label="Run")
+            num_samples = gr.Slider(label="Images", minimum=1, maximum=12, value=1, step=1)
+            seed = gr.Slider(label="Seed", minimum=-1, maximum=2147483647, step=1, value=12345)
+            mask_blur = gr.Slider(label="Mask Blur", minimum=0.1, maximum=7.0, value=5.0, step=0.01)
+            with gr.Accordion("Advanced options", open=False):
+                image_resolution = gr.Slider(label="Image Resolution", minimum=256, maximum=768, value=512, step=64)
+                strength = gr.Slider(label="Control Strength", minimum=0.0, maximum=2.0, value=1.0, step=0.01)
+                guess_mode = gr.Checkbox(label='Guess Mode', value=False)
+                ddim_steps = gr.Slider(label="Steps", minimum=1, maximum=100, value=20, step=1)
+                scale = gr.Slider(label="Guidance Scale", minimum=0.1, maximum=30.0, value=9.0, step=0.1)
+                eta = gr.Slider(label="DDIM ETA", minimum=0.0, maximum=1.0, value=1.0, step=0.01)
+                a_prompt = gr.Textbox(label="Added Prompt", value='best quality')
+                n_prompt = gr.Textbox(label="Negative Prompt", value='lowres, bad anatomy, bad hands, cropped, worst quality')
+        with gr.Column():
+            result_gallery = gr.Gallery(label='Output', show_label=False, elem_id="gallery").style(grid=2, height='auto')
+    ips = [input_image, prompt, a_prompt, n_prompt, num_samples, image_resolution, ddim_steps, guess_mode, strength, scale, seed, eta, mask_blur]
+    run_button.click(fn=process, inputs=ips, outputs=[result_gallery])
+
+
+block.launch(server_name='0.0.0.0')

CCEdit-main/src/controlnet11/gradio_ip2p.py

@@ -0,0 +1,99 @@
+from share import *
+import config
+
+import cv2
+import einops
+import gradio as gr
+import numpy as np
+import torch
+import random
+
+from pytorch_lightning import seed_everything
+from annotator.util import resize_image, HWC3
+from cldm.model import create_model, load_state_dict
+from cldm.ddim_hacked import DDIMSampler
+
+
+model_name = 'control_v11e_sd15_ip2p'
+model = create_model(f'./models/{model_name}.yaml').cpu()
+model.load_state_dict(load_state_dict('./models/v1-5-pruned.ckpt', location='cuda'), strict=False)
+model.load_state_dict(load_state_dict(f'./models/{model_name}.pth', location='cuda'), strict=False)
+model = model.cuda()
+ddim_sampler = DDIMSampler(model)
+
+
+def process(input_image, prompt, a_prompt, n_prompt, num_samples, image_resolution, ddim_steps, guess_mode, strength, scale, seed, eta):
+    with torch.no_grad():
+        input_image = HWC3(input_image)
+
+        detected_map = input_image.copy()
+
+        img = resize_image(input_image, image_resolution)
+        H, W, C = img.shape
+
+        detected_map = cv2.resize(detected_map, (W, H), interpolation=cv2.INTER_LINEAR)
+
+        control = torch.from_numpy(detected_map.copy()).float().cuda() / 255.0
+        control = torch.stack([control for _ in range(num_samples)], dim=0)
+        control = einops.rearrange(control, 'b h w c -> b c h w').clone()
+
+        if seed == -1:
+            seed = random.randint(0, 65535)
+        seed_everything(seed)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=False)
+
+        cond = {"c_concat": [control], "c_crossattn": [model.get_learned_conditioning([prompt + ', ' + a_prompt] * num_samples)]}
+        un_cond = {"c_concat": None if guess_mode else [control], "c_crossattn": [model.get_learned_conditioning([n_prompt] * num_samples)]}
+        shape = (4, H // 8, W // 8)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=True)
+
+        model.control_scales = [strength * (0.825 ** float(12 - i)) for i in range(13)] if guess_mode else ([strength] * 13)
+        # Magic number. IDK why. Perhaps because 0.825**12<0.01 but 0.826**12>0.01
+
+        samples, intermediates = ddim_sampler.sample(ddim_steps, num_samples,
+                                                     shape, cond, verbose=False, eta=eta,
+                                                     unconditional_guidance_scale=scale,
+                                                     unconditional_conditioning=un_cond)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=False)
+
+        x_samples = model.decode_first_stage(samples)
+        x_samples = (einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 + 127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
+
+        results = [x_samples[i] for i in range(num_samples)]
+    return [detected_map] + results
+
+
+block = gr.Blocks().queue()
+with block:
+    with gr.Row():
+        gr.Markdown("## Control Stable Diffusion with Instruct Pix2Pix")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            prompt = gr.Textbox(label="Prompt")
+            run_button = gr.Button(label="Run")
+            num_samples = gr.Slider(label="Images", minimum=1, maximum=12, value=1, step=1)
+            seed = gr.Slider(label="Seed", minimum=-1, maximum=2147483647, step=1, value=12345)
+            det = gr.Radio(choices=["None"], type="value", value="None", label="Preprocessor")
+            with gr.Accordion("Advanced options", open=False):
+                image_resolution = gr.Slider(label="Image Resolution", minimum=256, maximum=768, value=512, step=64)
+                strength = gr.Slider(label="Control Strength", minimum=0.0, maximum=2.0, value=1.0, step=0.01)
+                guess_mode = gr.Checkbox(label='Guess Mode', value=False)
+                ddim_steps = gr.Slider(label="Steps", minimum=1, maximum=100, value=20, step=1)
+                scale = gr.Slider(label="Guidance Scale", minimum=0.1, maximum=30.0, value=9.0, step=0.1)
+                eta = gr.Slider(label="DDIM ETA", minimum=0.0, maximum=1.0, value=1.0, step=0.01)
+                a_prompt = gr.Textbox(label="Added Prompt", value='best quality')
+                n_prompt = gr.Textbox(label="Negative Prompt", value='lowres, bad anatomy, bad hands, cropped, worst quality')
+        with gr.Column():
+            result_gallery = gr.Gallery(label='Output', show_label=False, elem_id="gallery").style(grid=2, height='auto')
+    ips = [input_image, prompt, a_prompt, n_prompt, num_samples, image_resolution, ddim_steps, guess_mode, strength, scale, seed, eta]
+    run_button.click(fn=process, inputs=ips, outputs=[result_gallery])
+
+
+block.launch(server_name='0.0.0.0')

CCEdit-main/src/controlnet11/gradio_lineart.py

@@ -0,0 +1,112 @@
+from share import *
+import config
+
+import cv2
+import einops
+import gradio as gr
+import numpy as np
+import torch
+import random
+
+from pytorch_lightning import seed_everything
+from annotator.util import resize_image, HWC3
+from annotator.lineart import LineartDetector
+from cldm.model import create_model, load_state_dict
+from cldm.ddim_hacked import DDIMSampler
+
+
+preprocessor = None
+
+model_name = 'control_v11p_sd15_lineart'
+model = create_model(f'./models/{model_name}.yaml').cpu()
+model.load_state_dict(load_state_dict('./models/v1-5-pruned.ckpt', location='cuda'), strict=False)
+model.load_state_dict(load_state_dict(f'./models/{model_name}.pth', location='cuda'), strict=False)
+model = model.cuda()
+ddim_sampler = DDIMSampler(model)
+
+
+def process(det, input_image, prompt, a_prompt, n_prompt, num_samples, image_resolution, detect_resolution, ddim_steps, guess_mode, strength, scale, seed, eta):
+    global preprocessor
+    if 'Lineart' in det:
+        if not isinstance(preprocessor, LineartDetector):
+            preprocessor = LineartDetector()
+
+    with torch.no_grad():
+        input_image = HWC3(input_image)
+
+        if det == 'None':
+            detected_map = input_image.copy()
+        else:
+            detected_map = preprocessor(resize_image(input_image, detect_resolution), coarse='Coarse' in det)
+            detected_map = HWC3(detected_map)
+
+        img = resize_image(input_image, image_resolution)
+        H, W, C = img.shape
+
+        detected_map = cv2.resize(detected_map, (W, H), interpolation=cv2.INTER_LINEAR)
+
+        control = 1.0 - torch.from_numpy(detected_map.copy()).float().cuda() / 255.0
+        control = torch.stack([control for _ in range(num_samples)], dim=0)
+        control = einops.rearrange(control, 'b h w c -> b c h w').clone()
+
+        if seed == -1:
+            seed = random.randint(0, 65535)
+        seed_everything(seed)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=False)
+
+        cond = {"c_concat": [control], "c_crossattn": [model.get_learned_conditioning([prompt + ', ' + a_prompt] * num_samples)]}
+        un_cond = {"c_concat": None if guess_mode else [control], "c_crossattn": [model.get_learned_conditioning([n_prompt] * num_samples)]}
+        shape = (4, H // 8, W // 8)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=True)
+
+        model.control_scales = [strength * (0.825 ** float(12 - i)) for i in range(13)] if guess_mode else ([strength] * 13)
+        # Magic number. IDK why. Perhaps because 0.825**12<0.01 but 0.826**12>0.01
+
+        samples, intermediates = ddim_sampler.sample(ddim_steps, num_samples,
+                                                     shape, cond, verbose=False, eta=eta,
+                                                     unconditional_guidance_scale=scale,
+                                                     unconditional_conditioning=un_cond)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=False)
+
+        x_samples = model.decode_first_stage(samples)
+        x_samples = (einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 + 127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
+
+        results = [x_samples[i] for i in range(num_samples)]
+    return [detected_map] + results
+
+
+block = gr.Blocks().queue()
+with block:
+    with gr.Row():
+        gr.Markdown("## Control Stable Diffusion with Lineart")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            prompt = gr.Textbox(label="Prompt")
+            run_button = gr.Button(label="Run")
+            num_samples = gr.Slider(label="Images", minimum=1, maximum=12, value=1, step=1)
+            seed = gr.Slider(label="Seed", minimum=-1, maximum=2147483647, step=1, value=12345)
+            det = gr.Radio(choices=["Lineart", "Lineart_Coarse", "None"], type="value", value="Lineart", label="Preprocessor")
+            with gr.Accordion("Advanced options", open=False):
+                image_resolution = gr.Slider(label="Image Resolution", minimum=256, maximum=768, value=512, step=64)
+                strength = gr.Slider(label="Control Strength", minimum=0.0, maximum=2.0, value=1.0, step=0.01)
+                guess_mode = gr.Checkbox(label='Guess Mode', value=False)
+                detect_resolution = gr.Slider(label="Preprocessor Resolution", minimum=128, maximum=1024, value=512, step=1)
+                ddim_steps = gr.Slider(label="Steps", minimum=1, maximum=100, value=20, step=1)
+                scale = gr.Slider(label="Guidance Scale", minimum=0.1, maximum=30.0, value=9.0, step=0.1)
+                eta = gr.Slider(label="DDIM ETA", minimum=0.0, maximum=1.0, value=1.0, step=0.01)
+                a_prompt = gr.Textbox(label="Added Prompt", value='best quality')
+                n_prompt = gr.Textbox(label="Negative Prompt", value='lowres, bad anatomy, bad hands, cropped, worst quality')
+        with gr.Column():
+            result_gallery = gr.Gallery(label='Output', show_label=False, elem_id="gallery").style(grid=2, height='auto')
+    ips = [det, input_image, prompt, a_prompt, n_prompt, num_samples, image_resolution, detect_resolution, ddim_steps, guess_mode, strength, scale, seed, eta]
+    run_button.click(fn=process, inputs=ips, outputs=[result_gallery])
+
+
+block.launch(server_name='0.0.0.0')

CCEdit-main/src/controlnet11/gradio_mlsd.py

@@ -0,0 +1,115 @@
+from share import *
+import config
+
+import cv2
+import einops
+import gradio as gr
+import numpy as np
+import torch
+import random
+
+from pytorch_lightning import seed_everything
+from annotator.util import resize_image, HWC3
+from annotator.mlsd import MLSDdetector
+from cldm.model import create_model, load_state_dict
+from cldm.ddim_hacked import DDIMSampler
+
+
+preprocessor = None
+
+model_name = 'control_v11p_sd15_mlsd'
+model = create_model(f'./models/{model_name}.yaml').cpu()
+model.load_state_dict(load_state_dict('./models/v1-5-pruned.ckpt', location='cuda'), strict=False)
+model.load_state_dict(load_state_dict(f'./models/{model_name}.pth', location='cuda'), strict=False)
+model = model.cuda()
+ddim_sampler = DDIMSampler(model)
+
+
+def process(det, input_image, prompt, a_prompt, n_prompt, num_samples, image_resolution, detect_resolution, ddim_steps, guess_mode, strength, scale, seed, eta, value_threshold, distance_threshold):
+    global preprocessor
+
+    if det == 'MLSD':
+        if not isinstance(preprocessor, MLSDdetector):
+            preprocessor = MLSDdetector()
+
+    with torch.no_grad():
+        input_image = HWC3(input_image)
+
+        if det == 'None':
+            detected_map = input_image.copy()
+        else:
+            detected_map = preprocessor(resize_image(input_image, detect_resolution), value_threshold, distance_threshold)
+            detected_map = HWC3(detected_map)
+
+        img = resize_image(input_image, image_resolution)
+        H, W, C = img.shape
+
+        detected_map = cv2.resize(detected_map, (W, H), interpolation=cv2.INTER_LINEAR)
+
+        control = torch.from_numpy(detected_map.copy()).float().cuda() / 255.0
+        control = torch.stack([control for _ in range(num_samples)], dim=0)
+        control = einops.rearrange(control, 'b h w c -> b c h w').clone()
+
+        if seed == -1:
+            seed = random.randint(0, 65535)
+        seed_everything(seed)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=False)
+
+        cond = {"c_concat": [control], "c_crossattn": [model.get_learned_conditioning([prompt + ', ' + a_prompt] * num_samples)]}
+        un_cond = {"c_concat": None if guess_mode else [control], "c_crossattn": [model.get_learned_conditioning([n_prompt] * num_samples)]}
+        shape = (4, H // 8, W // 8)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=True)
+
+        model.control_scales = [strength * (0.825 ** float(12 - i)) for i in range(13)] if guess_mode else ([strength] * 13)
+        # Magic number. IDK why. Perhaps because 0.825**12<0.01 but 0.826**12>0.01
+
+        samples, intermediates = ddim_sampler.sample(ddim_steps, num_samples,
+                                                     shape, cond, verbose=False, eta=eta,
+                                                     unconditional_guidance_scale=scale,
+                                                     unconditional_conditioning=un_cond)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=False)
+
+        x_samples = model.decode_first_stage(samples)
+        x_samples = (einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 + 127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
+
+        results = [x_samples[i] for i in range(num_samples)]
+    return [detected_map] + results
+
+
+block = gr.Blocks().queue()
+with block:
+    with gr.Row():
+        gr.Markdown("## Control Stable Diffusion with MLSD Lines")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            prompt = gr.Textbox(label="Prompt")
+            run_button = gr.Button(label="Run")
+            num_samples = gr.Slider(label="Images", minimum=1, maximum=12, value=1, step=1)
+            seed = gr.Slider(label="Seed", minimum=-1, maximum=2147483647, step=1, value=12345)
+            det = gr.Radio(choices=["MLSD", "None"], type="value", value="MLSD", label="Preprocessor")
+            with gr.Accordion("Advanced options", open=False):
+                value_threshold = gr.Slider(label="Hough value threshold (MLSD)", minimum=0.01, maximum=2.0, value=0.1, step=0.01)
+                distance_threshold = gr.Slider(label="Hough distance threshold (MLSD)", minimum=0.01, maximum=20.0, value=0.1, step=0.01)
+                image_resolution = gr.Slider(label="Image Resolution", minimum=256, maximum=768, value=512, step=64)
+                strength = gr.Slider(label="Control Strength", minimum=0.0, maximum=2.0, value=1.0, step=0.01)
+                guess_mode = gr.Checkbox(label='Guess Mode', value=False)
+                detect_resolution = gr.Slider(label="Preprocessor Resolution", minimum=128, maximum=1024, value=512, step=1)
+                ddim_steps = gr.Slider(label="Steps", minimum=1, maximum=100, value=20, step=1)
+                scale = gr.Slider(label="Guidance Scale", minimum=0.1, maximum=30.0, value=9.0, step=0.1)
+                eta = gr.Slider(label="DDIM ETA", minimum=0.0, maximum=1.0, value=1.0, step=0.01)
+                a_prompt = gr.Textbox(label="Added Prompt", value='best quality')
+                n_prompt = gr.Textbox(label="Negative Prompt", value='lowres, bad anatomy, bad hands, cropped, worst quality')
+        with gr.Column():
+            result_gallery = gr.Gallery(label='Output', show_label=False, elem_id="gallery").style(grid=2, height='auto')
+    ips = [det, input_image, prompt, a_prompt, n_prompt, num_samples, image_resolution, detect_resolution, ddim_steps, guess_mode, strength, scale, seed, eta, value_threshold, distance_threshold]
+    run_button.click(fn=process, inputs=ips, outputs=[result_gallery])
+
+
+block.launch(server_name='0.0.0.0')

CCEdit-main/src/controlnet11/gradio_seg.py

@@ -0,0 +1,120 @@
+from share import *
+import config
+
+import cv2
+import einops
+import gradio as gr
+import numpy as np
+import torch
+import random
+
+from pytorch_lightning import seed_everything
+from annotator.util import resize_image, HWC3
+from annotator.uniformer import UniformerDetector
+from annotator.oneformer import OneformerCOCODetector, OneformerADE20kDetector
+from cldm.model import create_model, load_state_dict
+from cldm.ddim_hacked import DDIMSampler
+
+
+preprocessor = None
+
+model_name = 'control_v11p_sd15_seg'
+model = create_model(f'./models/{model_name}.yaml').cpu()
+model.load_state_dict(load_state_dict('./models/v1-5-pruned.ckpt', location='cuda'), strict=False)
+model.load_state_dict(load_state_dict(f'./models/{model_name}.pth', location='cuda'), strict=False)
+model = model.cuda()
+ddim_sampler = DDIMSampler(model)
+
+
+def process(det, input_image, prompt, a_prompt, n_prompt, num_samples, image_resolution, detect_resolution, ddim_steps, guess_mode, strength, scale, seed, eta):
+    global preprocessor
+
+    if det == 'Seg_OFCOCO':
+        if not isinstance(preprocessor, OneformerCOCODetector):
+            preprocessor = OneformerCOCODetector()
+    if det == 'Seg_OFADE20K':
+        if not isinstance(preprocessor, OneformerADE20kDetector):
+            preprocessor = OneformerADE20kDetector()
+    if det == 'Seg_UFADE20K':
+        if not isinstance(preprocessor, UniformerDetector):
+            preprocessor = UniformerDetector()
+
+    with torch.no_grad():
+        input_image = HWC3(input_image)
+
+        if det == 'None':
+            detected_map = input_image.copy()
+        else:
+            detected_map = preprocessor(resize_image(input_image, detect_resolution))
+            detected_map = HWC3(detected_map)
+
+        img = resize_image(input_image, image_resolution)
+        H, W, C = img.shape
+
+        detected_map = cv2.resize(detected_map, (W, H), interpolation=cv2.INTER_LINEAR)
+
+        control = torch.from_numpy(detected_map.copy()).float().cuda() / 255.0
+        control = torch.stack([control for _ in range(num_samples)], dim=0)
+        control = einops.rearrange(control, 'b h w c -> b c h w').clone()
+
+        if seed == -1:
+            seed = random.randint(0, 65535)
+        seed_everything(seed)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=False)
+
+        cond = {"c_concat": [control], "c_crossattn": [model.get_learned_conditioning([prompt + ', ' + a_prompt] * num_samples)]}
+        un_cond = {"c_concat": None if guess_mode else [control], "c_crossattn": [model.get_learned_conditioning([n_prompt] * num_samples)]}
+        shape = (4, H // 8, W // 8)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=True)
+
+        model.control_scales = [strength * (0.825 ** float(12 - i)) for i in range(13)] if guess_mode else ([strength] * 13)
+        # Magic number. IDK why. Perhaps because 0.825**12<0.01 but 0.826**12>0.01
+
+        samples, intermediates = ddim_sampler.sample(ddim_steps, num_samples,
+                                                     shape, cond, verbose=False, eta=eta,
+                                                     unconditional_guidance_scale=scale,
+                                                     unconditional_conditioning=un_cond)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=False)
+
+        x_samples = model.decode_first_stage(samples)
+        x_samples = (einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 + 127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
+
+        results = [x_samples[i] for i in range(num_samples)]
+    return [detected_map] + results
+
+
+block = gr.Blocks().queue()
+with block:
+    with gr.Row():
+        gr.Markdown("## Control Stable Diffusion with Semantic Segmentation")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            prompt = gr.Textbox(label="Prompt")
+            run_button = gr.Button(label="Run")
+            num_samples = gr.Slider(label="Images", minimum=1, maximum=12, value=1, step=1)
+            seed = gr.Slider(label="Seed", minimum=-1, maximum=2147483647, step=1, value=12345)
+            det = gr.Radio(choices=["Seg_OFADE20K", "Seg_OFCOCO", "Seg_UFADE20K", "None"], type="value", value="Seg_OFADE20K", label="Preprocessor")
+            with gr.Accordion("Advanced options", open=False):
+                image_resolution = gr.Slider(label="Image Resolution", minimum=256, maximum=768, value=512, step=64)
+                strength = gr.Slider(label="Control Strength", minimum=0.0, maximum=2.0, value=1.0, step=0.01)
+                guess_mode = gr.Checkbox(label='Guess Mode', value=False)
+                detect_resolution = gr.Slider(label="Preprocessor Resolution", minimum=128, maximum=1024, value=512, step=1)
+                ddim_steps = gr.Slider(label="Steps", minimum=1, maximum=100, value=20, step=1)
+                scale = gr.Slider(label="Guidance Scale", minimum=0.1, maximum=30.0, value=9.0, step=0.1)
+                eta = gr.Slider(label="DDIM ETA", minimum=0.0, maximum=1.0, value=1.0, step=0.01)
+                a_prompt = gr.Textbox(label="Added Prompt", value='best quality')
+                n_prompt = gr.Textbox(label="Negative Prompt", value='lowres, bad anatomy, bad hands, cropped, worst quality')
+        with gr.Column():
+            result_gallery = gr.Gallery(label='Output', show_label=False, elem_id="gallery").style(grid=2, height='auto')
+    ips = [det, input_image, prompt, a_prompt, n_prompt, num_samples, image_resolution, detect_resolution, ddim_steps, guess_mode, strength, scale, seed, eta]
+    run_button.click(fn=process, inputs=ips, outputs=[result_gallery])
+
+
+block.launch(server_name='0.0.0.0')

CCEdit-main/src/controlnet11/gradio_shuffle.py

@@ -0,0 +1,105 @@
+from share import *
+import config
+
+import cv2
+import einops
+import gradio as gr
+import numpy as np
+import torch
+import random
+
+from pytorch_lightning import seed_everything
+from annotator.util import resize_image, HWC3
+from annotator.shuffle import ContentShuffleDetector
+from cldm.model import create_model, load_state_dict
+from cldm.ddim_hacked import DDIMSampler
+
+
+model_name = 'control_v11e_sd15_shuffle'
+model = create_model(f'./models/{model_name}.yaml').cpu()
+model.load_state_dict(load_state_dict('./models/v1-5-pruned.ckpt', location='cuda'), strict=False)
+model.load_state_dict(load_state_dict(f'./models/{model_name}.pth', location='cuda'), strict=False)
+model = model.cuda()
+ddim_sampler = DDIMSampler(model)
+
+preprocessor = ContentShuffleDetector()
+
+
+def process(det, input_image, prompt, a_prompt, n_prompt, num_samples, image_resolution, ddim_steps, strength, scale, seed, eta):
+    with torch.no_grad():
+        input_image = HWC3(input_image)
+        detected_map = input_image.copy()
+        img = resize_image(input_image, image_resolution)
+        H, W, C = img.shape
+
+        if det == "Shuffle":
+            np.random.seed(seed)
+            detected_map = preprocessor(detected_map, w=W, h=H, f=256)
+        else:
+            detected_map = img.copy()
+
+        control = torch.from_numpy(detected_map.copy()).float().cuda() / 255.0
+        control = torch.stack([control for _ in range(num_samples)], dim=0)
+        control = einops.rearrange(control, 'b h w c -> b c h w').clone()
+
+        if seed == -1:
+            seed = random.randint(0, 65535)
+        seed_everything(seed)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=False)
+
+        cond = {"c_concat": [control], "c_crossattn": [model.get_learned_conditioning([prompt + ', ' + a_prompt] * num_samples)]}
+        un_cond = {"c_concat": None, "c_crossattn": [model.get_learned_conditioning([n_prompt] * num_samples)]}
+        shape = (4, H // 8, W // 8)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=True)
+
+        model.control_scales = [strength] * 13
+        samples, intermediates = ddim_sampler.sample(ddim_steps, num_samples,
+                                                     shape, cond, verbose=False, eta=eta,
+                                                     unconditional_guidance_scale=scale,
+                                                     unconditional_conditioning=un_cond)
+
+        if config.save_memory:
+            model.low_vram_shift(is_diffusing=False)
+
+        x_samples = model.decode_first_stage(samples)
+        x_samples = (einops.rearrange(x_samples, 'b c h w -> b h w c') * 127.5 + 127.5).cpu().numpy().clip(0, 255).astype(np.uint8)
+
+        results = [x_samples[i] for i in range(num_samples)]
+
+    if det == "Shuffle":
+        return [detected_map] + results
+    else:
+        return results
+
+
+block = gr.Blocks().queue()
+with block:
+    with gr.Row():
+        gr.Markdown("## Control Stable Diffusion with Content Shuffle")
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(source='upload', type="numpy")
+            prompt = gr.Textbox(label="Prompt")
+            run_button = gr.Button(label="Run")
+            num_samples = gr.Slider(label="Images", minimum=1, maximum=12, value=1, step=1)
+            seed = gr.Slider(label="Seed", minimum=-1, maximum=2147483647, step=1, value=12345)
+            det = gr.Radio(choices=["Shuffle", "None"], type="value", value="None", label="Preprocessor")
+            with gr.Accordion("Advanced options", open=False):
+                image_resolution = gr.Slider(label="Image Resolution", minimum=256, maximum=768, value=512, step=64)
+                strength = gr.Slider(label="Control Strength", minimum=0.0, maximum=2.0, value=1.0, step=0.01)
+                ddim_steps = gr.Slider(label="Steps", minimum=1, maximum=100, value=20, step=1)
+                scale = gr.Slider(label="Guidance Scale", minimum=0.1, maximum=30.0, value=9.0, step=0.1)
+                eta = gr.Slider(label="DDIM ETA", minimum=0.0, maximum=1.0, value=1.0, step=0.01)
+                a_prompt = gr.Textbox(label="Added Prompt", value='best quality')
+                n_prompt = gr.Textbox(label="Negative Prompt", value='lowres, bad anatomy, bad hands, cropped, worst quality')
+        with gr.Column():
+            result_gallery = gr.Gallery(label='Output', show_label=False, elem_id="gallery").style(grid=2, height='auto')
+    ips = [det, input_image, prompt, a_prompt, n_prompt, num_samples, image_resolution, ddim_steps, strength, scale, seed, eta]
+    run_button.click(fn=process, inputs=ips, outputs=[result_gallery])
+
+
+block.launch(server_name='0.0.0.0')

CCEdit-main/src/controlnet11/models/cldm_v15.yaml

@@ -0,0 +1,79 @@
+model:
+  target: cldm.cldm.ControlLDM
+  params:
+    linear_start: 0.00085
+    linear_end: 0.0120
+    num_timesteps_cond: 1
+    log_every_t: 200
+    timesteps: 1000
+    first_stage_key: "jpg"
+    cond_stage_key: "txt"
+    control_key: "hint"
+    image_size: 64
+    channels: 4
+    cond_stage_trainable: false
+    conditioning_key: crossattn
+    monitor: val/loss_simple_ema
+    scale_factor: 0.18215
+    use_ema: False
+    only_mid_control: False
+
+    control_stage_config:
+      target: cldm.cldm.ControlNet
+      params:
+        image_size: 32 # unused
+        in_channels: 4
+        hint_channels: 3
+        model_channels: 320
+        attention_resolutions: [ 4, 2, 1 ]
+        num_res_blocks: 2
+        channel_mult: [ 1, 2, 4, 4 ]
+        num_heads: 8
+        use_spatial_transformer: True
+        transformer_depth: 1
+        context_dim: 768
+        use_checkpoint: True
+        legacy: False
+
+    unet_config:
+      target: cldm.cldm.ControlledUnetModel
+      params:
+        image_size: 32 # unused
+        in_channels: 4
+        out_channels: 4
+        model_channels: 320
+        attention_resolutions: [ 4, 2, 1 ]
+        num_res_blocks: 2
+        channel_mult: [ 1, 2, 4, 4 ]
+        num_heads: 8
+        use_spatial_transformer: True
+        transformer_depth: 1
+        context_dim: 768
+        use_checkpoint: True
+        legacy: False
+
+    first_stage_config:
+      target: ldm.models.autoencoder.AutoencoderKL
+      params:
+        embed_dim: 4
+        monitor: val/rec_loss
+        ddconfig:
+          double_z: true
+          z_channels: 4
+          resolution: 256
+          in_channels: 3
+          out_ch: 3
+          ch: 128
+          ch_mult:
+          - 1
+          - 2
+          - 4
+          - 4
+          num_res_blocks: 2
+          attn_resolutions: []
+          dropout: 0.0
+        lossconfig:
+          target: torch.nn.Identity
+
+    cond_stage_config:
+      target: ldm.modules.encoders.modules.FrozenCLIPEmbedder

CCEdit-main/src/controlnet11/models/cldm_v15_avg_pool.yaml

@@ -0,0 +1,80 @@
+model:
+  target: cldm.cldm.ControlLDM
+  params:
+    linear_start: 0.00085
+    linear_end: 0.0120
+    num_timesteps_cond: 1
+    log_every_t: 200
+    timesteps: 1000
+    first_stage_key: "jpg"
+    cond_stage_key: "txt"
+    control_key: "hint"
+    image_size: 64
+    channels: 4
+    cond_stage_trainable: false
+    conditioning_key: crossattn
+    monitor: val/loss_simple_ema
+    scale_factor: 0.18215
+    use_ema: False
+    only_mid_control: False
+    global_average_pooling: True
+
+    control_stage_config:
+      target: cldm.cldm.ControlNet
+      params:
+        image_size: 32 # unused
+        in_channels: 4
+        hint_channels: 3
+        model_channels: 320
+        attention_resolutions: [ 4, 2, 1 ]
+        num_res_blocks: 2
+        channel_mult: [ 1, 2, 4, 4 ]
+        num_heads: 8
+        use_spatial_transformer: True
+        transformer_depth: 1
+        context_dim: 768
+        use_checkpoint: True
+        legacy: False
+
+    unet_config:
+      target: cldm.cldm.ControlledUnetModel
+      params:
+        image_size: 32 # unused
+        in_channels: 4
+        out_channels: 4
+        model_channels: 320
+        attention_resolutions: [ 4, 2, 1 ]
+        num_res_blocks: 2
+        channel_mult: [ 1, 2, 4, 4 ]
+        num_heads: 8
+        use_spatial_transformer: True
+        transformer_depth: 1
+        context_dim: 768
+        use_checkpoint: True
+        legacy: False
+
+    first_stage_config:
+      target: ldm.models.autoencoder.AutoencoderKL
+      params:
+        embed_dim: 4
+        monitor: val/rec_loss
+        ddconfig:
+          double_z: true
+          z_channels: 4
+          resolution: 256
+          in_channels: 3
+          out_ch: 3
+          ch: 128
+          ch_mult:
+          - 1
+          - 2
+          - 4
+          - 4
+          num_res_blocks: 2
+          attn_resolutions: []
+          dropout: 0.0
+        lossconfig:
+          target: torch.nn.Identity
+
+    cond_stage_config:
+      target: ldm.modules.encoders.modules.FrozenCLIPEmbedder

CCEdit-main/src/controlnet11/models/cldm_v21.yaml

@@ -0,0 +1,85 @@
+model:
+  target: cldm.cldm.ControlLDM
+  params:
+    linear_start: 0.00085
+    linear_end: 0.0120
+    num_timesteps_cond: 1
+    log_every_t: 200
+    timesteps: 1000
+    first_stage_key: "jpg"
+    cond_stage_key: "txt"
+    control_key: "hint"
+    image_size: 64
+    channels: 4
+    cond_stage_trainable: false
+    conditioning_key: crossattn
+    monitor: val/loss_simple_ema
+    scale_factor: 0.18215
+    use_ema: False
+    only_mid_control: False
+
+    control_stage_config:
+      target: cldm.cldm.ControlNet
+      params:
+        use_checkpoint: True
+        image_size: 32 # unused
+        in_channels: 4
+        hint_channels: 3
+        model_channels: 320
+        attention_resolutions: [ 4, 2, 1 ]
+        num_res_blocks: 2
+        channel_mult: [ 1, 2, 4, 4 ]
+        num_head_channels: 64 # need to fix for flash-attn
+        use_spatial_transformer: True
+        use_linear_in_transformer: True
+        transformer_depth: 1
+        context_dim: 1024
+        legacy: False
+
+    unet_config:
+      target: cldm.cldm.ControlledUnetModel
+      params:
+        use_checkpoint: True
+        image_size: 32 # unused
+        in_channels: 4
+        out_channels: 4
+        model_channels: 320
+        attention_resolutions: [ 4, 2, 1 ]
+        num_res_blocks: 2
+        channel_mult: [ 1, 2, 4, 4 ]
+        num_head_channels: 64 # need to fix for flash-attn
+        use_spatial_transformer: True
+        use_linear_in_transformer: True
+        transformer_depth: 1
+        context_dim: 1024
+        legacy: False
+
+    first_stage_config:
+      target: ldm.models.autoencoder.AutoencoderKL
+      params:
+        embed_dim: 4
+        monitor: val/rec_loss
+        ddconfig:
+          #attn_type: "vanilla-xformers"
+          double_z: true
+          z_channels: 4
+          resolution: 256
+          in_channels: 3
+          out_ch: 3
+          ch: 128
+          ch_mult:
+          - 1
+          - 2
+          - 4
+          - 4
+          num_res_blocks: 2
+          attn_resolutions: []
+          dropout: 0.0
+        lossconfig:
+          target: torch.nn.Identity
+
+    cond_stage_config:
+      target: ldm.modules.encoders.modules.FrozenOpenCLIPEmbedder
+      params:
+        freeze: True
+        layer: "penultimate"