Upload 4 files

depthmap2mask/README.md

@@ -0,0 +1,132 @@
+# depthmap2mask
+
+Made as a script for the [AUTOMATIC1111/stable-diffusion-webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui) repository.
+
+
+## 💥 Installation 💥
+
+Copy the url of that repository into the extension tab :
+
+![image](https://user-images.githubusercontent.com/15731540/204056273-fc27d1cf-48ac-4dc3-b737-95b4b1efd32e.png)
+
+OR copy that repository in your extension folder :
+
+![image](https://user-images.githubusercontent.com/15731540/203840272-83cccb24-4417-44bc-99df-e45eb5f3360c.png)
+
+You might need to restart the whole UI. Maybe twice.
+
+if you are on colab you can also add this line in a code block before starting the UI/after the installation cells :
+
+    !git clone https://github.com/Extraltodeus/depthmap2mask.git /content/stable-diffusion-webui/extensions/depthmap2mask
+
+## The look
+
+![image](https://user-images.githubusercontent.com/15731540/204043153-09cbffd9-28ac-46be-ad99-fc7f2c8656a3.png)
+
+## What does this extension do?
+
+It creates masks for img2img based on a depth estimation made by [MiDaS](https://github.com/isl-org/MiDaS).
+
+![smallerone](https://user-images.githubusercontent.com/15731540/204043576-5dc02def-29f8-423e-a69e-d392f47d3602.png)![5050](https://user-images.githubusercontent.com/15731540/204043582-ae46d0b8-3c4b-43d5-b669-eaf2659ced14.png)
+
+## Where to find it after installing it?
+
+Go to your img2img tab then select it from the custom scripts list at the bottom.
+
+## Explanations of the different UI elements
+
+- Contrasts cut level
+
+![image](https://user-images.githubusercontent.com/15731540/204043824-6067bd9e-49d6-488b-8f99-47928c31ae46.png)
+
+This slider is **purely optional**.
+The depthmap is in levels of gray. Each pixel has a value in between 0 and 255 depending if they are black (0) or white (255). That threshold slider will cut to black every pixel below the selected value and scale from black to white what is above its value.
+
+Or in a more human language, it will give more depth to your depthmaps while removing a lot of information.
+
+Example before/after with the slider's value around 220 and using the MiDaS-Large model:
+
+![00073--1 0- sampler -85-8 1-ac07d41f-20221125174853](https://user-images.githubusercontent.com/15731540/204044001-4e672bbe-4ff8-46ef-ae87-ec3377e7aa37.png)![00074--1 0- sampler -85-8 1-ac07d41f-20221125174934](https://user-images.githubusercontent.com/15731540/204044306-80c77ba3-3b38-4ea6-941c-f6c6006c8b4e.png)
+
+Using the MiDaS small model will give you similar if not more interesting results.
+
+![smallerone](https://user-images.githubusercontent.com/15731540/204043576-5dc02def-29f8-423e-a69e-d392f47d3602.png)![5050](https://user-images.githubusercontent.com/15731540/204043582-ae46d0b8-3c4b-43d5-b669-eaf2659ced14.png)
+
+So that's more of an extra-extra option or a way to make sure that your backgrounds are untouched by using a low value (like 50).
+
+- Match input size/Net width/Net height
+
+![image](https://user-images.githubusercontent.com/15731540/204044819-0618bf27-0692-4a20-922f-73e33822dc6f.png)
+
+Match input size (On by default) will make the depth analysis at the same size as the original image. Better not to touch it unless you are having performance issues.
+
+The sliders below will be the resolution of the analysis if Match input size is turned off.
+
+You can also just use these functionalities to test out different results.
+
+- Misc options
+
+![image](https://user-images.githubusercontent.com/15731540/204045429-778f3084-63ad-421d-ad43-af9a20c49621.png)
+
+- Override options :
+
+    These two options simply overrides the inpainting Masked content method and mask blur. I added these because using "original" for Masked content and Mask Blur at 0 just works better. This saves you the clics needed to switch to the intpaint tab/reupload the image to that tab and select the right options.
+    
+- MiDaS models :
+
+    I'll let you try what suits your needs the most.
+    
+- Turn the depthmap into absolute black/white
+
+![image](https://user-images.githubusercontent.com/15731540/204057815-1e7d1d38-2fbb-43a1-bb08-133e574138c2.png)
+
+This option will cut out the background of an image into pure black and make the foreground pure white. Like a clean cut.
+
+### Alpha Cropping
+
+You can also save a version of the input image which has had all the masked content replaced with transparent pixels. This is useful when extracting the subject from the background, so that it can be used in designs.
+
+![Image](https://i.imgur.com/yFX6LyQ.jpeg)
+
+Simply check the "Save alpha mask" option before generating.
+
+## Tips
+
+- Avoid using Euler a or you might get really bad results. Usually DDIM works best.
+
+## Credits/Citation
+
+Thanks to [thygate](https://github.com/thygate) for letting me blatantly copy-paste some of his functions for the depth analysis integration in the webui.
+
+This repository runs with [MiDaS](https://github.com/isl-org/MiDaS).
+
+```
+@ARTICLE {Ranftl2022,
+    author  = "Ren\'{e} Ranftl and Katrin Lasinger and David Hafner and Konrad Schindler and Vladlen Koltun",
+    title   = "Towards Robust Monocular Depth Estimation: Mixing Datasets for Zero-Shot Cross-Dataset Transfer",
+    journal = "IEEE Transactions on Pattern Analysis and Machine Intelligence",
+    year    = "2022",
+    volume  = "44",
+    number  = "3"
+}
+```
+```
+@article{Ranftl2021,
+	author    = {Ren\'{e} Ranftl and Alexey Bochkovskiy and Vladlen Koltun},
+	title     = {Vision Transformers for Dense Prediction},
+	journal   = {ICCV},
+	year      = {2021},
+}
+```
+
+## Bug reporting
+
+- Please check if similar issues exist before creating a new one.
+- Make sure to do a "git pull" from your webui folder in order to have your webui up to date
+- Provide as many details as possible when creating a new issue.
+
+## Examples using different MiDaS models and denoising strength
+![00056-589874964- sampler -32-7-ac07d41f-20221125174017](https://user-images.githubusercontent.com/15731540/204048931-20b19823-bba9-44be-a4ff-4d3ae65dd120.png)![00064-1584461722- sampler -32-7-ac07d41f-20221125174328](https://user-images.githubusercontent.com/15731540/204048940-fada95f2-fcb0-4cf7-ba0c-6a1fd6b904ea.png)![00100-717650490- sampler -84-8 1-ac07d41f-20221125175700](https://user-images.githubusercontent.com/15731540/204048949-a4faf745-e9b5-437e-870d-be8ea7bd4b5d.png)
+
+
+<sub>I forgot my settings but in the end it's all pretty easy to guess what you need.</sub>

depthmap2mask/install.py

@@ -0,0 +1,2 @@
+import launch
+launch.git_clone("https://github.com/isl-org/MiDaS.git", "repositories/midas", "midas", "1645b7e")

depthmap2mask/scripts/depth2image_depthmask.py

@@ -0,0 +1,117 @@
+from modules.processing import Processed, StableDiffusionProcessingImg2Img, process_images, images, fix_seed
+from modules.shared import opts, cmd_opts, state
+from PIL import Image, ImageOps
+from math import ceil
+import cv2
+
+import modules.scripts as scripts
+from modules import sd_samplers
+from random import randint, shuffle
+import random
+from skimage.util import random_noise
+import gradio as gr
+import numpy as np
+import sys
+import os
+import copy
+import importlib.util
+
+def module_from_file(module_name, file_path):
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+class Script(scripts.Script):
+    def title(self):
+        return "Depth aware img2img mask"
+    
+    def show(self, is_img2img):
+        return is_img2img
+
+    def ui(self, is_img2img):
+        if not is_img2img: return
+        models = ["dpt_beit_large_512",
+                "dpt_beit_large_384",
+                "dpt_beit_base_384",
+                "dpt_swin2_large_384",
+                "dpt_swin2_base_384",
+                "dpt_swin2_tiny_256",
+                "dpt_swin_large_384",
+                "dpt_next_vit_large_384",
+                "dpt_levit_224",
+                "dpt_large_384",
+                "dpt_hybrid_384",
+                "midas_v21_384",
+                "midas_v21_small_256",
+                # "openvino_midas_v21_small_256"
+            ]
+
+        treshold = gr.Slider(minimum=0, maximum=255, step=1, label='Contrasts cut level', value=0)
+        match_size = gr.Checkbox(label="Match input size",value=True)
+        net_width = gr.Slider(minimum=64, maximum=2048, step=64, label='Net width', value=384)
+        net_height = gr.Slider(minimum=64, maximum=2048, step=64, label='Net height', value=384)
+        with gr.Row():
+            invert_depth = gr.Checkbox(label="Invert DepthMap",value=False)
+            save_depthmap = gr.Checkbox(label='Save depth map', value=False)
+            save_alpha_crop = gr.Checkbox(label='Save alpha crop', value=False)
+            override_mask_blur = gr.Checkbox(label='Override mask blur to 0', value=True)
+            override_fill = gr.Checkbox(label='Override inpaint to original', value=True)
+            clean_cut     = gr.Checkbox(label='Turn the depthmap into absolute black/white', value=False)
+        model_type = gr.Dropdown(label="Model", choices=models, value="dpt_swin2_base_384", type="index", elem_id="model_type")
+        # model_type = gr.Dropdown(label="Model", choices=['dpt_large','dpt_hybrid','midas_v21','midas_v21_small'], value='dpt_large', type="index", elem_id="model_type")
+        return    [save_depthmap,treshold,match_size,net_width,net_height,invert_depth,model_type,override_mask_blur,override_fill,clean_cut, save_alpha_crop]
+
+    def run(self,p,save_depthmap,treshold,match_size,net_width,net_height,invert_depth,model_type,override_mask_blur,override_fill,clean_cut, save_alpha_crop):
+        def remap_range(value, minIn, MaxIn, minOut, maxOut):
+            if value > MaxIn: value = MaxIn;
+            if value < minIn: value = minIn;
+            finalValue = ((value - minIn) / (MaxIn - minIn)) * (maxOut - minOut) + minOut;
+            return finalValue;
+        def create_depth_mask_from_depth_map(img,save_depthmap,p,treshold,clean_cut, save_alpha_crop):
+            img = copy.deepcopy(img.convert("RGBA"))
+            mask_img = copy.deepcopy(img.convert("L"))
+            mask_datas = mask_img.getdata()
+            datas = img.getdata()
+            newData = []
+            maxD = max(mask_datas)
+            if clean_cut and treshold == 0:
+                treshold = 128
+            for i in range(len(mask_datas)):
+                if clean_cut and mask_datas[i] > treshold:
+                    newrgb = 255
+                elif mask_datas[i] > treshold and not clean_cut:
+                    newrgb = int(remap_range(mask_datas[i],treshold,255,0,255))
+                else:
+                    newrgb = 0
+                newData.append((newrgb,newrgb,newrgb,255))
+            img.putdata(newData)
+            return img
+
+        sdmg = module_from_file("depthmap_for_depth2img",'extensions/depthmap2mask/scripts/depthmap_for_depth2img.py')
+        sdmg = sdmg.SimpleDepthMapGenerator() #import midas
+
+        img_x = p.width  if match_size else net_width
+        img_y = p.height if match_size else net_height
+
+        d_m = sdmg.calculate_depth_maps(p.init_images[0],img_x,img_y,model_type,invert_depth)
+
+        if treshold > 0 or clean_cut:
+            d_m = create_depth_mask_from_depth_map(d_m,save_depthmap,p,treshold,clean_cut, save_alpha_crop)
+
+        if save_depthmap:
+            images.save_image(d_m, p.outpath_samples, "", p.seed, p.prompt, opts.samples_format, p=p)
+
+        if save_alpha_crop:
+            alpha_crop = p.init_images[0].copy()
+            alpha_crop.putalpha(d_m.convert("L"))
+            images.save_image(alpha_crop, p.outpath_samples, "alpha-crop", p.seed, p.prompt, opts.samples_format, p=p)
+
+        p.image_mask = d_m
+        if override_mask_blur: p.mask_blur  = 0
+        if override_fill: p.inpainting_fill = 1
+        proc = process_images(p)
+        proc.images.append(d_m)
+        if save_alpha_crop:
+            proc.images.append(alpha_crop)
+        return proc

depthmap2mask/scripts/depthmap_for_depth2img.py

@@ -0,0 +1,349 @@
+import torch, gc
+import cv2
+import requests
+import os.path
+import contextlib
+from PIL import Image
+from modules.shared import opts, cmd_opts
+from modules import processing, images, shared, devices
+import os
+
+from torchvision.transforms import Compose
+
+from repositories.midas.midas.dpt_depth import DPTDepthModel
+from repositories.midas.midas.midas_net import MidasNet
+from repositories.midas.midas.midas_net_custom import MidasNet_small
+from repositories.midas.midas.transforms import Resize, NormalizeImage, PrepareForNet
+
+import numpy as np
+
+def load_model(device, model_path, model_type="dpt_large_384", optimize=True, size=None, square=False):
+    """Load the specified network.
+
+    Args:
+        device (device): the torch device used
+        model_path (str): path to saved model
+        model_type (str): the type of the model to be loaded
+        optimize (bool): optimize the model to half-integer on CUDA?
+        size (int, int): inference encoder image size
+        square (bool): resize to a square resolution?
+
+    Returns:
+        The loaded network, the transform which prepares images as input to the network and the dimensions of the
+        network input
+    """
+    if "openvino" in model_type:
+        from openvino.runtime import Core
+
+    keep_aspect_ratio = not square
+
+    if model_type == "dpt_beit_large_512":
+        model = DPTDepthModel(
+            path=model_path,
+            backbone="beitl16_512",
+            non_negative=True,
+        )
+        net_w, net_h = 512, 512
+        resize_mode = "minimal"
+        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+
+    elif model_type == "dpt_beit_large_384":
+        model = DPTDepthModel(
+            path=model_path,
+            backbone="beitl16_384",
+            non_negative=True,
+        )
+        net_w, net_h = 384, 384
+        resize_mode = "minimal"
+        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+
+    elif model_type == "dpt_beit_base_384":
+        model = DPTDepthModel(
+            path=model_path,
+            backbone="beitb16_384",
+            non_negative=True,
+        )
+        net_w, net_h = 384, 384
+        resize_mode = "minimal"
+        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+
+    elif model_type == "dpt_swin2_large_384":
+        model = DPTDepthModel(
+            path=model_path,
+            backbone="swin2l24_384",
+            non_negative=True,
+        )
+        net_w, net_h = 384, 384
+        keep_aspect_ratio = False
+        resize_mode = "minimal"
+        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+
+    elif model_type == "dpt_swin2_base_384":
+        model = DPTDepthModel(
+            path=model_path,
+            backbone="swin2b24_384",
+            non_negative=True,
+        )
+        net_w, net_h = 384, 384
+        keep_aspect_ratio = False
+        resize_mode = "minimal"
+        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+
+    elif model_type == "dpt_swin2_tiny_256":
+        model = DPTDepthModel(
+            path=model_path,
+            backbone="swin2t16_256",
+            non_negative=True,
+        )
+        net_w, net_h = 256, 256
+        keep_aspect_ratio = False
+        resize_mode = "minimal"
+        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+
+    elif model_type == "dpt_swin_large_384":
+        model = DPTDepthModel(
+            path=model_path,
+            backbone="swinl12_384",
+            non_negative=True,
+        )
+        net_w, net_h = 384, 384
+        keep_aspect_ratio = False
+        resize_mode = "minimal"
+        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+
+    elif model_type == "dpt_next_vit_large_384":
+        model = DPTDepthModel(
+            path=model_path,
+            backbone="next_vit_large_6m",
+            non_negative=True,
+        )
+        net_w, net_h = 384, 384
+        resize_mode = "minimal"
+        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+
+    # We change the notation from dpt_levit_224 (MiDaS notation) to levit_384 (timm notation) here, where the 224 refers
+    # to the resolution 224x224 used by LeViT and 384 is the first entry of the embed_dim, see _cfg and model_cfgs of
+    # https://github.com/rwightman/pytorch-image-models/blob/main/timm/models/levit.py
+    # (commit id: 927f031293a30afb940fff0bee34b85d9c059b0e)
+    elif model_type == "dpt_levit_224":
+        model = DPTDepthModel(
+            path=model_path,
+            backbone="levit_384",
+            non_negative=True,
+            head_features_1=64,
+            head_features_2=8,
+        )
+        net_w, net_h = 224, 224
+        keep_aspect_ratio = False
+        resize_mode = "minimal"
+        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+
+    elif model_type == "dpt_large_384":
+        model = DPTDepthModel(
+            path=model_path,
+            backbone="vitl16_384",
+            non_negative=True,
+        )
+        net_w, net_h = 384, 384
+        resize_mode = "minimal"
+        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+
+    elif model_type == "dpt_hybrid_384":
+        model = DPTDepthModel(
+            path=model_path,
+            backbone="vitb_rn50_384",
+            non_negative=True,
+        )
+        net_w, net_h = 384, 384
+        resize_mode = "minimal"
+        normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+
+    elif model_type == "midas_v21_384":
+        model = MidasNet(model_path, non_negative=True)
+        net_w, net_h = 384, 384
+        resize_mode = "upper_bound"
+        normalization = NormalizeImage(
+            mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+        )
+
+    elif model_type == "midas_v21_small_256":
+        model = MidasNet_small(model_path, features=64, backbone="efficientnet_lite3", exportable=True,
+                               non_negative=True, blocks={'expand': True})
+        net_w, net_h = 256, 256
+        resize_mode = "upper_bound"
+        normalization = NormalizeImage(
+            mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+        )
+
+    elif model_type == "openvino_midas_v21_small_256":
+        ie = Core()
+        uncompiled_model = ie.read_model(model=model_path)
+        model = ie.compile_model(uncompiled_model, "CPU")
+        net_w, net_h = 256, 256
+        resize_mode = "upper_bound"
+        normalization = NormalizeImage(
+            mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+        )
+
+    else:
+        print(f"model_type '{model_type}' not implemented, use: --model_type large")
+        assert False
+
+    if not "openvino" in model_type:
+        print("Model loaded, number of parameters = {:.0f}M".format(sum(p.numel() for p in model.parameters()) / 1e6))
+    else:
+        print("Model loaded, optimized with OpenVINO")
+
+    if "openvino" in model_type:
+        keep_aspect_ratio = False
+
+    if size is not None:
+        net_w, net_h = size
+
+    transform = Compose(
+        [
+            Resize(
+                net_w,
+                net_h,
+                resize_target=None,
+                keep_aspect_ratio=keep_aspect_ratio,
+                ensure_multiple_of=32,
+                resize_method=resize_mode,
+                image_interpolation_method=cv2.INTER_CUBIC,
+            ),
+            normalization,
+            PrepareForNet(),
+        ]
+    )
+
+    if not "openvino" in model_type:
+        model.eval()
+
+    if optimize and (device == torch.device("cuda")):
+        if not "openvino" in model_type:
+            model = model.to(memory_format=torch.channels_last)
+            model = model.half()
+        else:
+            print("Error: OpenVINO models are already optimized. No optimization to half-float possible.")
+            exit()
+
+    if not "openvino" in model_type:
+        model.to(device)
+
+    return model, transform
+
+class SimpleDepthMapGenerator(object):
+    def calculate_depth_maps(self,image,img_x,img_y,model_type_index,invert_depth):
+        try:
+            model = None
+            def download_file(filename, url):
+                print(f"download {filename} form {url}")
+                import sys
+                try:
+                    with open(filename+'.tmp', "wb") as f:
+                        response = requests.get(url, stream=True)
+                        total_length = response.headers.get('content-length')
+
+                        if total_length is None: # no content length header
+                            f.write(response.content)
+                        else:
+                            dl = 0
+                            total_length = int(total_length)
+                            for data in response.iter_content(chunk_size=4096):
+                                dl += len(data)
+                                f.write(data)
+                                done = int(50 * dl / total_length)
+                                sys.stdout.write("\r[%s%s]" % ('=' * done, ' ' * (50-done)) )    
+                                sys.stdout.flush()
+                    os.rename(filename+'.tmp', filename)
+                except Exception as e:
+                    os.remove(filename+'.tmp')
+                    print("\n--------download fail------------\n")
+                    raise e
+
+            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            # model path and name
+            model_dir = "./models/midas"
+            # create path to model if not present
+            os.makedirs(model_dir, exist_ok=True)
+            print("Loading midas model weights ..")
+            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            models = ["dpt_beit_large_512",
+                "dpt_beit_large_384",
+                "dpt_beit_base_384",
+                "dpt_swin2_large_384",
+                "dpt_swin2_base_384",
+                "dpt_swin2_tiny_256",
+                "dpt_swin_large_384",
+                "dpt_next_vit_large_384",
+                "dpt_levit_224",
+                "dpt_large_384",
+                "dpt_hybrid_384",
+                "midas_v21_384",
+                "midas_v21_small_256",
+                # "openvino_midas_v21_small_256"
+            ]
+            model_path = model_dir + '/' + models[model_type_index] + '.pt'
+            if not os.path.exists(model_path):
+                if models.index("midas_v21_384") <= model_type_index:
+                    download_file(model_path, "https://github.com/isl-org/MiDaS/releases/download/v2_1/"+ models[model_type_index] + ".pt")
+                elif models.index("midas_v21_384") > model_type_index > models.index("dpt_large_384"):
+                    download_file(model_path, "https://github.com/isl-org/MiDaS/releases/download/v3/"+ models[model_type_index] + ".pt")
+                else:
+                    download_file(model_path, "https://github.com/isl-org/MiDaS/releases/download/v3_1/"+ models[model_type_index] + ".pt")
+            model, transform = load_model(device, model_path, models[model_type_index], (img_x, img_y))
+
+            img = cv2.cvtColor(np.asarray(image), cv2.COLOR_BGR2RGB) / 255.0
+            img_input = transform({"image": img})["image"]
+            precision_scope = torch.autocast if shared.cmd_opts.precision == "autocast" and device == torch.device("cuda") else contextlib.nullcontext
+            # compute
+            with torch.no_grad(), precision_scope("cuda"):
+                sample = torch.from_numpy(img_input).to(device).unsqueeze(0)
+                if device == torch.device("cuda"):
+                    sample = sample.to(memory_format=torch.channels_last)
+                    if not cmd_opts.no_half:
+                        sample = sample.half()
+                prediction = model.forward(sample)
+                prediction = (
+                    torch.nn.functional.interpolate(
+                        prediction.unsqueeze(1),
+                        size=img.shape[:2],
+                        mode="bicubic",
+                        align_corners=False,
+                    )
+                    .squeeze()
+                    .cpu()
+                    .numpy()
+                )
+            # output
+            depth = prediction
+            numbytes=2
+            depth_min = depth.min()
+            depth_max = depth.max()
+            max_val = (2**(8*numbytes))-1
+
+            # check output before normalizing and mapping to 16 bit
+            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)
+            # single channel, 16 bit image
+            img_output = out.astype("uint16")
+
+            # # invert depth map
+            if invert_depth:
+                img_output = cv2.bitwise_not(img_output)
+
+            # three channel, 8 bits per channel image
+            img_output2 = np.zeros_like(image)
+            img_output2[:,:,0] = img_output / 256.0
+            img_output2[:,:,1] = img_output / 256.0
+            img_output2[:,:,2] = img_output / 256.0
+            img = Image.fromarray(img_output2)
+            return img
+        except Exception:
+            raise
+        finally:
+            del model
+            gc.collect()
+            devices.torch_gc()