initialization

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.xml filter=lfs diff=lfs merge=lfs -text
+*.xml.encrypted filter=lfs diff=lfs merge=lfs -text
+*.bin.encrypted filter=lfs diff=lfs merge=lfs -text
+*.encrypted filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,13 +1,13 @@
 ---
 title: RAW Denoise
-emoji: 🐠
-colorFrom: pink
-colorTo: yellow
+emoji: 📚
+colorFrom: gray
+colorTo: green
 sdk: gradio
-sdk_version: 4.37.2
+sdk_version: 4.31.4
 app_file: app.py
 pinned: false
-license: mit
+license: unknown
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,217 @@
+import gradio as gr
+from customs.utils import rgb2rggb, rggb2rgb, CV72fillCurve, rggb2rgb_np
+import torch,os
+import numpy as np
+from openvino.inference_engine import IECore
+from cryptography.fernet import Fernet
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+CONFIG = {
+    "noise_levels": [4, 6, 8, 10, 12],
+    "raw_images": [
+        "data/RAW/noisy/4Card_Gain160_E30.npy",
+        "data/RAW/noisy/4Card_Gain180_E30.npy",
+        "data/RAW/noisy/4Card_Gain200_E30.npy",
+        "data/RAW/noisy/4Card_Gain220_E30.npy",
+        "data/RAW/noisy/4Card_Gain240_E30.npy"
+    ],
+    "weights": [
+        "customs/weights/model_ir_0.xml.encrypted",
+        "customs/weights/model_ir_1.xml.encrypted",
+        "customs/weights/model_ir_2.xml.encrypted",
+        "customs/weights/model_ir_3.xml.encrypted",
+        "customs/weights/model_ir_4.xml.encrypted"
+    ],
+    "SIDD_model_weights": "customs/weights/model_ir_SIDD.xml.encrypted"
+}
+
+def main():
+    with gr.Blocks() as demo:
+        create_text("Raw Image Denoiser",size=10)
+        create_text("Data Detail : Collect images of imx678 image sensor and analyze the noise composition and distribution",size=5)
+        create_text("Model Detail : ",size=5)
+        create_text("Synthesis Data : We have the technology to analyze and apply noise",size=3)
+        create_text("Our Denoiser : Our model architecture is trained on synthesize noise with SIDD ground truth",size=3)
+        create_text("SIDD Denoiser : Our model architecture is trained on SIDD dataset",size=3)
+        create_text("Community : Any questions please contact us (tim.liu@liteon.com)",size=3)
+        with gr.Tab("Synthesis"):
+            with gr.Column():
+                with gr.Row():
+                    image1 = gr.Image(label="Your Input Image")
+                    with gr.Column():
+                        noise_level1 = create_slider("noise level")
+                        denoise_level1 = create_slider("denoise level")
+                        use_synthesis = gr.Checkbox(label="Use synthesis", value=True)
+                        image_button1 = gr.Button("Inference")
+                        # create_text("SIDD Denoiser : Our model architecture is trained to SIDD dataset")
+                        image_input1 = [image1, noise_level1, denoise_level1, use_synthesis]
+                        
+                with gr.Row():
+                    SynthesisNoise1 = gr.Image(label="Synthesis noise")
+                    OurDenoise1 = gr.Image(label="Our denoiser result")
+                with gr.Row():
+                    SIDDDenoise1 = gr.Image(label="SIDD denoiser result")
+                    examples1 = gr.Examples(examples=[["data/RGB/4Card.png"],["data/RGB/Color.png"],["data/RGB/Focus.png"]],inputs=image_input1)
+
+            image_output1 = [SynthesisNoise1, OurDenoise1, SIDDDenoise1]
+            
+        with gr.Tab("Real"):
+            with gr.Column():
+                with gr.Row():
+                    with gr.Column():
+                        noise_level2 = create_slider("noise level")
+                        denoise_level2 = create_slider("denoise level")
+                        image_button2 = gr.Button("Inference")
+                        image_input2 = [noise_level2, denoise_level2]
+                    RealRow = gr.Image(label="Real noise")
+                with gr.Row():
+                    OurDenoise2 = gr.Image(label="Our denoiser result")
+                    SIDDDenoise2 = gr.Image(label="SIDD denoiser result")
+
+            image_output2 = [RealRow, OurDenoise2, SIDDDenoise2]
+        
+        image_button1.click(denoise_synthesis, inputs=image_input1, outputs=image_output1)
+        image_button2.click(denoise_real, inputs=image_input2, outputs=image_output2)
+    demo.launch()
+
+def decrypt_model(encrypted_file_path, decrypted_file_path):
+    """
+    解密模型文件
+    """
+    # if key file not exist, get env key
+    if os.path.exists("IRModelKey.txt"):
+        with open("IRModelKey.txt", "rb") as file:
+            key = file.read()
+    else:
+        # get env key
+        key = os.getenv("IRModelKey")
+    cipher_suite = Fernet(key)
+    with open(encrypted_file_path, 'rb') as file:
+        encrypted_data = file.read()
+    decrypted_data = cipher_suite.decrypt(encrypted_data)
+    with open(decrypted_file_path, 'wb') as file:
+        file.write(decrypted_data)
+
+class IEModel:
+    """Class for inference of models in the Inference Engine format"""
+    def __init__(self, exec_net, inputs_info, input_key, output_key, switch_rb=True):
+        self.net = exec_net
+        self.inputs_info = inputs_info
+        self.input_key = input_key
+        self.output_key = output_key
+        self.reqs_ids = []
+        self.switch_rb = switch_rb
+
+    def _preprocess(self, img):
+        _, _, h, w = self.get_input_shape()
+        img = np.expand_dims(img.transpose(2, 0, 1), axis=0)
+        return img
+
+    def forward(self, img):
+        """Performs forward pass of the wrapped IE model"""
+        res = self.net.infer(inputs={self.input_key: self._preprocess(img)})
+        return np.copy(res[self.output_key])
+
+    def forward_async(self, img):
+        id = len(self.reqs_ids)
+        self.net.start_async(request_id=id,
+                             inputs={self.input_key: self._preprocess(img)})
+        self.reqs_ids.append(id)
+
+    def grab_all_async(self):
+        outputs = []
+        for id in self.reqs_ids:
+            self.net.requests[id].wait(-1)
+            res = self.net.requests[id].output_blobs[self.output_key].buffer
+            outputs.append(np.copy(res))
+        self.reqs_ids = []
+        return outputs
+
+    def get_input_shape(self):
+        """Returns an input shape of the wrapped IE model"""
+        return self.inputs_info[self.input_key].input_data.shape
+    
+def load_ie_model(model_xml, device, plugin_dir, cpu_extension='', num_reqs=1, **kwargs):
+    """Loads a model in the Inference Engine format"""
+    if cpu_extension and 'CPU' in device:
+        IECore().add_extension(cpu_extension, 'CPU')
+    # Read IR
+    net = IECore().read_network(model_xml, os.path.splitext(model_xml)[0] + ".bin")
+
+    assert len(net.input_info) == 1 or len(net.input_info) == 2, \
+        "Supports topologies with only 1 or 2 inputs"
+    assert len(net.outputs) == 1 or len(net.outputs) == 4 or len(net.outputs) == 5, \
+        "Supports topologies with only 1, 4 or 5 outputs"
+
+    input_blob = next(iter(net.input_info))
+    out_blob = next(iter(net.outputs))
+    net.batch_size = 1
+
+    # Loading model to the plugin
+    exec_net = IECore().load_network(network=net, device_name=device, num_requests=num_reqs)
+    model = IEModel(exec_net, net.input_info, input_blob, out_blob, **kwargs)
+    return model
+
+decrypt_model("customs/weights/model_ir_0.xml.encrypted", "customs/weights/model_ir_0_decrypted.xml")
+decrypt_model("customs/weights/model_ir_0.bin.encrypted", "customs/weights/model_ir_0_decrypted.bin")
+decrypt_model("customs/weights/model_ir_1.xml.encrypted", "customs/weights/model_ir_1_decrypted.xml")
+decrypt_model("customs/weights/model_ir_1.bin.encrypted", "customs/weights/model_ir_1_decrypted.bin")
+decrypt_model("customs/weights/model_ir_2.xml.encrypted", "customs/weights/model_ir_2_decrypted.xml")
+decrypt_model("customs/weights/model_ir_2.bin.encrypted", "customs/weights/model_ir_2_decrypted.bin")
+decrypt_model("customs/weights/model_ir_3.xml.encrypted", "customs/weights/model_ir_3_decrypted.xml")
+decrypt_model("customs/weights/model_ir_3.bin.encrypted", "customs/weights/model_ir_3_decrypted.bin")
+decrypt_model("customs/weights/model_ir_4.xml.encrypted", "customs/weights/model_ir_4_decrypted.xml")
+decrypt_model("customs/weights/model_ir_4.bin.encrypted", "customs/weights/model_ir_4_decrypted.bin")
+decrypt_model("customs/weights/model_ir_SIDD.xml.encrypted", "customs/weights/model_ir_SIDD_decrypted.xml")
+decrypt_model("customs/weights/model_ir_SIDD.bin.encrypted", "customs/weights/model_ir_SIDD_decrypted.bin")
+denoiseModelList = [load_ie_model(weight.split('.')[0] + "_decrypted.xml", "CPU", None, "")for weight in CONFIG["weights"]]
+SIDD_model = load_ie_model(CONFIG["SIDD_model_weights"].split('.')[0] + "_decrypted.xml", "CPU", None, "")
+
+def denoise_synthesis(image, noise_level=1, denoise_level=1, use_synthesis=True):
+    # # Assuming image is a numpy array
+    # rgb = np.transpose(image, (2, 0, 1))[np.newaxis, :]
+    # # rgb is not 1080 x 1920, resize it , test in 360 x 640
+    # rgb = cv2.resize(rgb[0].transpose(1,2,0), (1920, 1080)).transpose(2,0,1)[np.newaxis, :]
+    # rggb = rgb2rggb_np(np.transpose(rgb.squeeze(0), (1, 2, 0))) / 255 # Normalize to [0, 1]
+    # if use_synthesis:
+    #     noiseImage = CV72fillCurve_np(rggb, CONFIG["noise_levels"][noise_level-1], CONFIG["noise_levels"][noise_level-1]+1)
+    # rgb = rggb2rgb_np(noiseImage)
+    # rgb = np.clip(rgb, 0, 1) # In-place clipping
+    
+    # torch function speed more than numpy
+    rgb = torch.tensor(image).permute(2, 0, 1).unsqueeze(0)
+    # rgb is not 1080 x 1920, resize it , test in 360 x 640
+    rgb = torch.nn.functional.interpolate(rgb, size=(1080, 1920), mode='bilinear', align_corners=False)
+    rggb = rgb2rggb(rgb.squeeze(0).permute(1, 2, 0)) / 255 # Normalize to [0, 1]
+    if use_synthesis:
+        rggb = CV72fillCurve(rggb, CONFIG["noise_levels"][noise_level-1], CONFIG["noise_levels"][noise_level-1]+1)
+    rgb = rggb2rgb(rggb)
+    rgb = rgb.clamp_(0, 1).cpu().numpy() # In-place clipping
+    noiseImage = rggb.numpy()
+    output = denoiseModelList[denoise_level-1].forward(noiseImage)
+    SIDDOutput = SIDD_model.forward(noiseImage)
+    return rgb, RGGB2RGBNumpy(output.squeeze().transpose(1, 2, 0)), RGGB2RGBNumpy(SIDDOutput.squeeze().transpose(1, 2, 0))
+
+def denoise_real(noise_level=1, denoise_level=1):
+    noiseImage = np.load(CONFIG["raw_images"][noise_level-1]).astype(np.float32) / 65535.0
+    # noiseImage = torch.from_numpy(noiseImage).permute(2, 0, 1).to(device).unsqueeze(0)
+    output = denoiseModelList[denoise_level-1].forward(noiseImage)
+    SIDDOutput = SIDD_model.forward(noiseImage)
+    return RGGB2RGBNumpy(noiseImage), RGGB2RGBNumpy(output.squeeze().transpose(1, 2, 0)), RGGB2RGBNumpy(SIDDOutput.squeeze().transpose(1, 2, 0))
+
+def create_slider(label):
+    return gr.Slider(minimum=1, maximum=5, value=1, step=1, interactive=True, label=label)
+
+def create_text(text,size = 3,color = "black"):
+    gr.Markdown("<font size="+str(size)+" color="+str(color)+">"+str(text)+"</font>")
+
+def RGGB2RGBNumpy(numpyInput):
+    # Assuming rggb2rgb is a function that can handle numpy arrays
+    output = rggb2rgb_np(numpyInput)
+    # In-place clipping
+    output = np.clip(output, 0, 1)
+    return output
+
+if __name__ == "__main__":
+    main()
+    

customs/gaussian_table_AMBA_4k0111_update.json

@@ -0,0 +1,288 @@
+{
+    "0": {
+        "0": {
+            "mu": 0.04884533454585538,
+            "std": 0.00036523623507143493,
+            "row_std": 2.1192263945304984e-05
+        },
+        "1": {
+            "mu": 0.04885432883089133,
+            "std": 0.0003590921086861262,
+            "row_std": 2.0632113591805363e-05
+        },
+        "2": {
+            "mu": 0.04883828976450504,
+            "std": 0.00035916750637214866,
+            "row_std": 2.1054889173977102e-05
+        },
+        "3": {
+            "mu": 0.04886586050908968,
+            "std": 0.00036625797807880045,
+            "row_std": 2.080488683538461e-05
+        }
+    },
+    "1": {
+        "0": {
+            "mu": 0.048910118270361326,
+            "std": 0.0007679587162312924,
+            "row_std": 5.647232988739475e-05
+        },
+        "1": {
+            "mu": 0.04897846737024978,
+            "std": 0.0007657190460110321,
+            "row_std": 5.5061890891124056e-05
+        },
+        "2": {
+            "mu": 0.048902397863624714,
+            "std": 0.0007671995968468128,
+            "row_std": 5.622613422385847e-05
+        },
+        "3": {
+            "mu": 0.04899352096805801,
+            "std": 0.0007698302663261498,
+            "row_std": 5.437209611421559e-05
+        }
+    },
+    "2": {
+        "0": {
+            "mu": 0.048857065013604366,
+            "std": 0.0012123489716326134,
+            "row_std": 7.08703314107849e-05
+        },
+        "1": {
+            "mu": 0.04893770161594236,
+            "std": 0.0011744860955057528,
+            "row_std": 6.74400964749618e-05
+        },
+        "2": {
+            "mu": 0.04883367026277906,
+            "std": 0.0011848557755693141,
+            "row_std": 7.046526265271678e-05
+        },
+        "3": {
+            "mu": 0.04899051627813202,
+            "std": 0.0012225518384126255,
+            "row_std": 6.699616703751188e-05
+        }
+    },
+    "3": {
+        "0": {
+            "mu": 0.04957285036422768,
+            "std": 0.0039884736321273515,
+            "row_std": 0.0001806924709740455
+        },
+        "1": {
+            "mu": 0.048884518345166494,
+            "std": 0.003988940591138176,
+            "row_std": 0.00019624591450196352
+        },
+        "2": {
+            "mu": 0.049503986978813364,
+            "std": 0.004022970723134317,
+            "row_std": 0.0001866611784478792
+        },
+        "3": {
+            "mu": 0.04904338346410105,
+            "std": 0.004021104097136626,
+            "row_std": 0.00020614522450051762
+        }
+    },
+    "4": {
+        "0": {
+            "mu": 0.051179580803712744,
+            "std": 0.01516965579714122,
+            "row_std": 0.0006848126111928647
+        },
+        "1": {
+            "mu": 0.048555232287003126,
+            "std": 0.015131666031611908,
+            "row_std": 0.0008252242178262105
+        },
+        "2": {
+            "mu": 0.05092065717846968,
+            "std": 0.015306564497661098,
+            "row_std": 0.0006824809953618861
+        },
+        "3": {
+            "mu": 0.04921186702957536,
+            "std": 0.015234968339770111,
+            "row_std": 0.0008159484522919293
+        }
+    },
+    "5": {
+        "0": {
+            "mu": 0.05194902646703862,
+            "std": 0.02345391398272158,
+            "row_std": 0.0010309458194859393
+        },
+        "1": {
+            "mu": 0.050978013292755774,
+            "std": 0.023448010228184248,
+            "row_std": 0.0010183040421496512
+        },
+        "2": {
+            "mu": 0.05156257428110727,
+            "std": 0.02358192047699801,
+            "row_std": 0.0010264660962841189
+        },
+        "3": {
+            "mu": 0.052059536793260745,
+            "std": 0.02374497801210408,
+            "row_std": 0.0010426603459159902
+        }
+    },
+    "6": {
+        "0": {
+            "mu": 0.05271847213036449,
+            "std": 0.030823781597773586,
+            "row_std": 0.001320962575344441
+        },
+        "1": {
+            "mu": 0.05340079429850842,
+            "std": 0.030849861367983702,
+            "row_std": 0.0013030114220171606
+        },
+        "2": {
+            "mu": 0.05220449138374486,
+            "std": 0.0310291804422537,
+            "row_std": 0.0013147798525491635
+        },
+        "3": {
+            "mu": 0.05490720655694614,
+            "std": 0.031227799293258977,
+            "row_std": 0.0013365933725464601
+        }
+    },
+    "7": {
+        "0": {
+            "mu": 0.053487917793690366,
+            "std": 0.040509465187225646,
+            "row_std": 0.001692564335078927
+        },
+        "1": {
+            "mu": 0.05582357530426107,
+            "std": 0.04058826046057689,
+            "row_std": 0.0016673200690856791
+        },
+        "2": {
+            "mu": 0.052846408486382446,
+            "std": 0.040828313362224755,
+            "row_std": 0.001684075165197392
+        },
+        "3": {
+            "mu": 0.05775487632063153,
+            "std": 0.0410687029570197,
+            "row_std": 0.001713388113907482
+        }
+    },
+    "8": {
+        "0": {
+            "mu": 0.05425736345701624,
+            "std": 0.06282588232727848,
+            "row_std": 0.002659041836231682
+        },
+        "1": {
+            "mu": 0.058246356310013715,
+            "std": 0.06315593086974453,
+            "row_std": 0.002395979118305699
+        },
+        "2": {
+            "mu": 0.05348832558902004,
+            "std": 0.06334979243468684,
+            "row_std": 0.0025916868606935843
+        },
+        "3": {
+            "mu": 0.060602546084316915,
+            "std": 0.0637482828951418,
+            "row_std": 0.002443527678588156
+        }
+    },
+    "9": {
+        "0": {
+            "mu": 0.06880619950180135,
+            "std": 0.06996771502462133,
+            "row_std": 0.0027787823319460475
+        },
+        "1": {
+            "mu": 0.07468870728144456,
+            "std": 0.07025785434174985,
+            "row_std": 0.002729986426163404
+        },
+        "2": {
+            "mu": 0.06785894824429257,
+            "std": 0.07068767675770854,
+            "row_std": 0.002762983767609609
+        },
+        "3": {
+            "mu": 0.07821418040175274,
+            "std": 0.0710313718425912,
+            "row_std": 0.0028155849988717005
+        }
+    },
+    "10": {
+        "0": {
+            "mu": 0.08335503554658646,
+            "std": 0.09195350372662747,
+            "row_std": 0.003560485329247844
+        },
+        "1": {
+            "mu": 0.09113105825287539,
+            "std": 0.09243620440977662,
+            "row_std": 0.0034932626681255497
+        },
+        "2": {
+            "mu": 0.08222957089956512,
+            "std": 0.09301111329325708,
+            "row_std": 0.003539050538273192
+        },
+        "3": {
+            "mu": 0.09582581471918858,
+            "std": 0.09341568656305245,
+            "row_std": 0.003609317515597133
+        }
+    },
+    "11": {
+        "0": {
+            "mu": 0.0979038715913716,
+            "std": 0.12084783452807416,
+            "row_std": 0.004562090248684959
+        },
+        "1": {
+            "mu": 0.10757340922430622,
+            "std": 0.12161561103366324,
+            "row_std": 0.004469943129229767
+        },
+        "2": {
+            "mu": 0.09660019355483765,
+            "std": 0.12238437579019316,
+            "row_std": 0.004533098912588848
+        },
+        "3": {
+            "mu": 0.1134374490366244,
+            "std": 0.12285403293892105,
+            "row_std": 0.0046268086147698215
+        }
+    },
+    "12": {
+        "0": {
+            "mu": 0.11245270763615671,
+            "std": 0.21799335234166645,
+            "row_std": 0.007758689083129044
+        },
+        "1": {
+            "mu": 0.12401576019573704,
+            "std": 0.21989850331007596,
+            "row_std": 0.007001712632885403
+        },
+        "2": {
+            "mu": 0.11097081621011019,
+            "std": 0.22041589626618188,
+            "row_std": 0.007715688230680361
+        },
+        "3": {
+            "mu": 0.1310490833540602,
+            "std": 0.2227708559950361,
+            "row_std": 0.007402277517094011
+        }
+    }
+}

customs/k_table_AMBA_4k0111_update.json

@@ -0,0 +1,184 @@
+{
+    "0": {
+        "0": {
+            "K": 9.465562984038772e-05
+        },
+        "1": {
+            "K": 9.601915868378001e-05
+        },
+        "2": {
+            "K": 9.599987238132664e-05
+        },
+        "3": {
+            "K": 9.497633660608725e-05
+        }
+    },
+    "1": {
+        "0": {
+            "K": 0.00037416072090588296
+        },
+        "1": {
+            "K": 0.0003771304526158978
+        },
+        "2": {
+            "K": 0.0003777319715400697
+        },
+        "3": {
+            "K": 0.00037443032854174235
+        }
+    },
+    "2": {
+        "0": {
+            "K": 0.001413779109788249
+        },
+        "1": {
+            "K": 0.0014158302616208089
+        },
+        "2": {
+            "K": 0.0014192205107157842
+        },
+        "3": {
+            "K": 0.0014145217849946378
+        }
+    },
+    "3": {
+        "0": {
+            "K": 0.005717976821537382
+        },
+        "1": {
+            "K": 0.005728937593309858
+        },
+        "2": {
+            "K": 0.005743112226402247
+        },
+        "3": {
+            "K": 0.0057202041041990665
+        }
+    },
+    "4": {
+        "0": {
+            "K": 0.02283841937703782
+        },
+        "1": {
+            "K": 0.02313202101123309
+        },
+        "2": {
+            "K": 0.023103205170867457
+        },
+        "3": {
+            "K": 0.022942343069204247
+        }
+    },
+    "5": {
+        "0": {
+            "K": 0.03178069184342341
+        },
+        "1": {
+            "K": 0.03132001430134658
+        },
+        "2": {
+            "K": 0.03132335616453206
+        },
+        "3": {
+            "K": 0.03205151971156825
+        }
+    },
+    "6": {
+        "0": {
+            "K": 0.044795230279835715
+        },
+        "1": {
+            "K": 0.0440557750241913
+        },
+        "2": {
+            "K": 0.044057320482160635
+        },
+        "3": {
+            "K": 0.045203759517728224
+        }
+    },
+    "7": {
+        "0": {
+            "K": 0.06313936353902103
+        },
+        "1": {
+            "K": 0.06197032013803114
+        },
+        "2": {
+            "K": 0.06196805597305982
+        },
+        "3": {
+            "K": 0.06375297935714079
+        }
+    },
+    "8": {
+        "0": {
+            "K": 0.09421036190877768
+        },
+        "1": {
+            "K": 0.09170346908984744
+        },
+        "2": {
+            "K": 0.09137848357396919
+        },
+        "3": {
+            "K": 0.09551643673004001
+        }
+    },
+    "9": {
+        "0": {
+            "K": 0.12544029084557606
+        },
+        "1": {
+            "K": 0.12261554356458139
+        },
+        "2": {
+            "K": 0.12259350310068033
+        },
+        "3": {
+            "K": 0.12680966186589437
+        }
+    },
+    "10": {
+        "0": {
+            "K": 0.17680945218188984
+        },
+        "1": {
+            "K": 0.17247510648543582
+        },
+        "2": {
+            "K": 0.17243175433586605
+        },
+        "3": {
+            "K": 0.17884560579638847
+        }
+    },
+    "11": {
+        "0": {
+            "K": 0.24921484293547064
+        },
+        "1": {
+            "K": 0.24260922793605236
+        },
+        "2": {
+            "K": 0.24253087766752507
+        },
+        "3": {
+            "K": 0.2522343348451105
+        }
+    },
+    "12": {
+        "0": {
+            "K": 0.333474050511197
+        },
+        "1": {
+            "K": 0.31967327985902605
+        },
+        "2": {
+            "K": 0.32024512603330063
+        },
+        "3": {
+            "K": 0.3386428894141024
+        }
+    }
+}

customs/utils.py

@@ -0,0 +1,103 @@
+import torch
+import numpy as np
+import json
+import random
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+def pack_raw(raw):
+    # pack Bayer image to 4 channels
+    im = raw.raw_image_visible.astype(np.float32)
+    im = np.maximum(im - 512, 0) / (16383 - 512)  # subtract the black level
+
+    im = np.expand_dims(im, axis=2)
+    img_shape = im.shape
+    H = img_shape[0]
+    W = img_shape[1]
+
+    out = np.concatenate((im[0:H:2, 0:W:2, :],
+                          im[0:H:2, 1:W:2, :],
+                          im[1:H:2, 1:W:2, :],
+                          im[1:H:2, 0:W:2, :]), axis=2)
+    return out
+
+def CV72fillCurve(img, first_index, end_index):
+    with open('customs/k_table_AMBA_4k0111_update.json') as f:
+        K_tableCV72_load_json = json.load(f)
+    with open('customs/gaussian_table_AMBA_4k0111_update.json') as f:
+        GS_tableCV72_load_json = json.load(f)
+    img = torch.clone(img)
+    imgPoisson = img - (200/4096)
+    imgPoisson = torch.clamp(imgPoisson, 0, 1)
+    gain_index = str(random.randrange(int(first_index), int(end_index)))
+    h, w, c = img.shape
+
+    for i in range(c):
+        syn_noise_R = torch.zeros([h, w], device=img.device)
+        channel = str(i)
+        pu_K = K_tableCV72_load_json[gain_index][channel]['K']
+        pu_std = GS_tableCV72_load_json[gain_index][channel]['std']
+        pu_row_std = GS_tableCV72_load_json[gain_index][channel]['row_std']# std of row noise
+        generated_row = torch.normal(0, pu_row_std, size=(h, 1))
+        for j in range(h):
+            gen_row_noisy = torch.normal(float(generated_row[j]), torch.tensor(pu_std), size=(1, w))
+            syn_noise_R[j] = gen_row_noisy
+        img[:, :, i] = img[:, :, i] + (imgPoisson[:, :, i] - torch.poisson(imgPoisson[:, :, i] / pu_K) * pu_K) ## Don't add 200
+        img[:, :, i] += syn_noise_R
+        img[:, :, i] = torch.clamp(img[:, :, i], 0, 1)
+    return img
+
+def CV72fillCurve_np(img, first_index, end_index):
+    with open('customs/k_table_AMBA_4k0111_update.json') as f:
+        K_tableCV72_load_json = json.load(f)
+    with open('customs/gaussian_table_AMBA_4k0111_update.json') as f:
+        GS_tableCV72_load_json = json.load(f)
+    img = np.copy(img)
+    imgPoisson = img - (200/4096)
+    imgPoisson = np.clip(imgPoisson, 0, 1)
+    gain_index = str(random.randrange(int(first_index), int(end_index)))
+    h, w, c = img.shape
+
+    for i in range(c):
+        syn_noise_R = np.zeros([h, w])
+        channel = str(i)
+        pu_K = K_tableCV72_load_json[gain_index][channel]['K']
+        pu_std = GS_tableCV72_load_json[gain_index][channel]['std']
+        pu_row_std = GS_tableCV72_load_json[gain_index][channel]['row_std']# std of row noise
+        generated_row = np.random.normal(0, pu_row_std, size=(h, 1))
+        for j in range(h):
+            gen_row_noisy = np.random.normal(float(generated_row[j]), pu_std, size=(1, w))
+            syn_noise_R[j] = gen_row_noisy
+        img[:, :, i] = img[:, :, i] + (imgPoisson[:, :, i] - np.random.poisson(imgPoisson[:, :, i] / pu_K) * pu_K) ## Don't add 200
+        img[:, :, i] += syn_noise_R
+        img[:, :, i] = np.clip(img[:, :, i], 0, 1)
+    return img
+
+def rgb2rggb(img):
+    red = img[:, :, 0]
+    green1 = img[:, :, 1]
+    green2 = img[:, :, 1]
+    blue = img[:, :, 2]
+    rggb = torch.stack([red, green1, green2, blue], dim=2)
+    return rggb
+
+def rggb2rgb(img):
+    red = img[:, :, 0]
+    green = img[:, :, 1] / 2 + img[:, :, 2] / 2
+    blue = img[:, :, 3]
+    rgb = torch.stack([red, green, blue], dim=2)
+    return rgb
+
+def rggb2rgb_np(img):
+    red = img[:, :, 0]
+    green = img[:, :, 1] / 2 + img[:, :, 2] / 2
+    blue = img[:, :, 3]
+    rgb = np.stack([red, green, blue], axis=2)
+    return rgb
+
+def rgb2rggb_np(img):
+    red = img[:, :, 0]
+    green1 = img[:, :, 1]
+    green2 = img[:, :, 1]
+    blue = img[:, :, 2]
+    rggb = np.stack([red, green1, green2, blue], axis=2)
+    return rggb

customs/weights/model_ir_0.bin.encrypted

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9cbe0efce62523da961e1a221a64e302ff458be834ed1741a50066337bc29177
+size 1459684

customs/weights/model_ir_0.xml.encrypted

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:17cf2983bd015272e0f34876c9c8486c6ee2a99af1a0530309f7ab39566a12d5
+size 171724

customs/weights/model_ir_1.bin.encrypted

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad4c80d19fe4b0cb6ef2915ab7bbdb2dabd40b7b4cf38d2d5d69114f011057cb
+size 1459684

customs/weights/model_ir_1.xml.encrypted

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:533129654c5df08496311ffdbf9387eb9b83afd08108a607bf7eca1b61b70773
+size 171724

customs/weights/model_ir_2.bin.encrypted

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8cc0142d26d02a2e885a802ea92f3b617861a30c9e309f636b04c7cad0fb033
+size 1459684

customs/weights/model_ir_2.xml.encrypted

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:57c4ebb69702107caa23a24710e33d8c6e26381b02a69b7375fb67a98d1e77d4
+size 171724

customs/weights/model_ir_3.bin.encrypted

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7335eccfb89a5cd560dbc905a4b7b280d6060fd381b60fa7b47b9c36380d5473
+size 1459684

customs/weights/model_ir_3.xml.encrypted

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9bfe8cffa0c854e7c533de4b09bbc9ce707e009c6a0a5b9571bc4372f2adb02a
+size 171724

customs/weights/model_ir_4.bin.encrypted

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:323115dcfeb2b144d3ed904990caef4d204e5fa4f0b9a2100429555aee492144
+size 1459684

customs/weights/model_ir_4.xml.encrypted

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac50ba380a99b4022e951a6dc4e344baae5ee76936c349132ea51e46c95ba7f6
+size 171724

customs/weights/model_ir_SIDD.bin.encrypted

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e53e3e0403e239258e724ee3e97766b39c463f313ac56acdf34cb13f6392d895
+size 1459684

customs/weights/model_ir_SIDD.xml.encrypted

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54454cd30998abcf2ae63d9227e62744aa111063ddca5c4b7c950382b5c9ab31
+size 171724

requirements.txt

@@ -0,0 +1,5 @@
+gradio==4.31.5
+opencv-python==4.10.0.82
+openvino==2023.3.0
+torch==2.2.2
+cryptography==42.0.8