rawforge 0.0.2__tar.gz → 0.2.0__tar.gz

{rawforge-0.0.2 → rawforge-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rawforge
-Version: 0.0.2
+Version: 0.2.0
 Summary: A compute backend/CLI application for using machine learning models on raw images.
 Author: Ryan Mueller
 License: MIT License
@@ -40,12 +40,20 @@ License-File: LICENSE
 Requires-Dist: numpy>=2.2
 Requires-Dist: RawHandler~=0.2.0
 Requires-Dist: colour_demosaicing~=0.2.6
-Requires-Dist: blended_tiling>=0.0.1.dev7
+Requires-Dist: blended-tiling-numpy
 Requires-Dist: requests~=2.32
 Requires-Dist: platformdirs~=4.5
 Requires-Dist: tqdm~=4.67
 Requires-Dist: cryptography>=46.0
 Requires-Dist: tifffile
+Provides-Extra: cpu
+Requires-Dist: onnxruntime; extra == "cpu"
+Provides-Extra: cuda
+Requires-Dist: onnxruntime-gpu; extra == "cuda"
+Provides-Extra: web
+Requires-Dist: onnxruntime-web; extra == "web"
+Provides-Extra: directml
+Requires-Dist: onnxruntime-directml; extra == "directml"
 Dynamic: license-file
 
 # RawRefinery

rawforge-0.2.0/RawForge/application/ImageSaver.py

@@ -0,0 +1,55 @@
+import numpy as np
+from RawForge.application.dng_utils import convert_color_matrix, to_dng
+import tifffile
+
+class ImageSaver():
+    def __init__(self, model_params, rh, dims=None):
+         self.rh = rh
+         self.model_params = model_params
+         self.dims = dims
+
+    def to_tiff(self, image, filename, apply_ccm=True):
+            image = image 
+            if apply_ccm:
+                transform_matrix = self.rh.rgb_colorspace_transform(colorspace='lin_rec2020')
+                image = image[0].transpose(1, 2, 0)
+                transformed = image @ transform_matrix.T
+            else:
+                 transformed = image[0].transpose(1, 2, 0)
+
+            transformed = np.clip(transformed, 0, 1)
+            transformed = transformed ** (1/2.2)            
+            transformed = transformed * (2 ** 8 - 1)
+            
+            uint_img = transformed.astype(np.uint8)
+
+            tifffile.imwrite(
+                filename,
+                uint_img,
+                photometric='rgb', # Explicitly define the color space
+                compression='deflate' # Optional: Lossless compression supported by darktable
+            )
+
+    def to_raw(self, denoised, filename, save_cfa):
+            # Compute CFA
+            if self.model_params['demosaicing'] == 'rawpy':
+                _, mask = self.rh.compute_mask_and_sparse(dims=self.dims)
+                denoised = denoised[0]
+                denoised = denoised.clip(0, 1)
+
+                denoised = np.where(mask, denoised, 0)
+                denoised = denoised.sum(axis=0)
+                denoised = denoised * ( self.rh.core_metadata.white_level) + self.rh.core_metadata.black_level_per_channel[0]
+                self.rh.to_dng(filename, uint_img=denoised)
+            else:
+                transform_matrix = np.linalg.inv(
+                        self.rh.rgb_colorspace_transform(colorspace=self.rh.colorspace)
+                        )
+                
+                CCM = self.rh.rgb_colorspace_transform(colorspace='XYZ')
+                CCM = np.linalg.inv(CCM)
+                denoised = denoised[0].transpose(1, 2, 0)
+                transformed = denoised @ transform_matrix.T
+                uint_img = np.clip(transformed * 2**16-1, 0, 2**16-1).astype(np.uint16)
+                ccm1 = convert_color_matrix(CCM)
+                to_dng(uint_img, self.rh, filename, ccm1, save_cfa=save_cfa, convert_to_cfa=True)

rawforge-0.2.0/RawForge/application/InferenceWorker.py

@@ -0,0 +1,79 @@
+import onnxruntime as ort
+import numpy as np
+from blended_tiling_numpy import TilingModule
+from RawForge.application.postprocessing import match_colors_linear
+from tqdm import tqdm
+import rawpy
+
+class InferenceWorker():
+    def __init__(self, model, model_params, conditioning, tile_size=512, tile_overlap=0.25, batch_size=2, disable_tqdm=False):
+        super().__init__()
+        self.model = model
+        self.model_params = model_params
+        self.conditioning = conditioning
+        self.tile_size = tile_size
+        if 'tile_size' in model_params:
+            self.tile_size =  model_params['tile_size']
+        self.tile_overlap = tile_overlap
+        self.batch_size = batch_size
+        if 'batch_size' in model_params:
+            self.batch_size = model_params['batch_size']
+        self._is_cancelled = False
+        self.disable_tqdm = disable_tqdm
+
+    def cancel(self):
+        self._is_cancelled = True
+    
+
+    def _tile_process(self, image_RGB, model_params):
+        # Prepare Data
+        full_size = [image_RGB.shape[2], image_RGB.shape[3]]
+        tile_size = [self.tile_size, self.tile_size]
+        overlap = [self.tile_overlap, self.tile_overlap]
+        # Tiling Setup
+        tiling_module_rgb = TilingModule(tile_size=[s for s in tile_size], tile_overlap=overlap, base_size=[s for s in full_size])
+
+        tiles_rgb = tiling_module_rgb.split_into_tiles(image_RGB)
+        
+        batches_rgb = [tiles_rgb[i : i + self.batch_size] 
+                        for i in range(0, len(tiles_rgb), self.batch_size)]
+        # Conditioning Setup
+        cond_tensor = np.array([self.conditioning]).astype(np.float32)
+        cond_tensor[:, 0] /= 6400.
+        cond_tensor[:, 1] = 0.
+        cond_tensor = cond_tensor[:, 0:1]
+        cond_tensor = cond_tensor.astype(np.float16)
+        if 'cond_scale' in model_params:
+            cond_tensor *= cond_tensor * model_params['cond_scale']
+
+        processed_batches = []
+        
+        # Inference Loop
+        for i, (batch_rgb) in tqdm(enumerate(batches_rgb), disable=self.disable_tqdm):
+            if self._is_cancelled: return None, None
+            
+            B = batch_rgb.shape[0]
+            # Expand conditioning to match batch size
+            curr_cond = np.broadcast_to(cond_tensor, (B, cond_tensor.shape[-1])).astype(np.float16)
+
+            payload = {
+                "input": batch_rgb,
+                "cond": curr_cond
+            }
+            # Filter based on inputs
+            model_inputs = {i.name for i in self.model.get_inputs()}
+            filtered_inputs = {k: v for k, v in payload.items() if k in model_inputs}
+            output = self.model.run(["output"], filtered_inputs)
+            
+            processed_batches.append(output[0])
+                    
+        # Rebuild
+        tiles_out = np.concat(processed_batches, axis=0)
+        stitched = tiling_module_rgb.rebuild_with_masks(tiles_out)
+
+        return image_RGB, stitched
+    
+    def run(self, model_params, image_RGB):
+        img, denoised_img = self._tile_process(image_RGB, model_params)
+        return img, denoised_img
+            

rawforge-0.2.0/RawForge/application/MODEL_REGISTRY.py

@@ -0,0 +1,135 @@
+MODEL_REGISTRY = {
+"TreeNetDenoise": {
+        "url": "https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/ShadowWeightedL1.onnx",
+        "filename": "ShadowWeightedL1.onnx",
+        "max_iso": 65535,
+        "demosaicing": "Malvar2004",
+    },
+    "TreeNetDenoiseLight": {
+        "url": "    https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/ShadowWeightedL1_light.onnx",
+        "filename": "ShadowWeightedL1_light.onnx",
+        "max_iso": 65535,
+        "demosaicing": "Malvar2004",
+    },
+    "TreeNetDenoiseSuperLight": {
+        "url": "https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/ShadowWeightedL1_super_light.onnx",
+        "filename": "ShadowWeightedL1_super_light.onnx",
+        "max_iso": 65535,
+        "demosaicing": "Malvar2004",
+    },
+    "TreeNetDenoiseHeavy": {
+        "url": "https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/ShadowWeightedL1_24_deep_500.onnx",
+        "filename": "ShadowWeightedL1_24_deep_500.onnx",
+        "max_iso": 65535,
+        "demosaicing": "Malvar2004",
+    },
+    "Deblur": {
+        "url": "https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/realblur_gamma_140.onnx",
+        "filename": "realblur_gamma_140.onnx",
+        "demosaicing": "Malvar2004",
+    },
+    "DeepSharpen": {
+        "url": "https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/Deblur_deep_24.onnx",
+        "filename": "Deblur_deep_24.onnx",
+        "demosaicing": "Malvar2004",
+    },
+    "TreeNetDenoiseXTrans": {
+        "url": "https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/xtrans_fixed_exposure_no_conditioning_400.onnx",
+        "filename": "xtrans_fixed_exposure_no_conditioning_400.onnx",
+        "demosaicing": "rawpy",
+        "conditioning": "false",
+        "batch_size": 1, 
+        "crop_size": 256,
+        "cond_scale": 0,
+    },
+    "RestormerXTrans": {
+        "url": "https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/restormer.onnx",
+        "filename": "restormer.onnx",
+        "demosaicing": "rawpy",
+        "conditioning": "false",
+        "batch_size": 1, 
+    }, 
+    "XFormerXTrans2": {
+        "url": "https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/xformer_fp16.onnx",
+        "filename": "xformer_fp16.onnx",
+        "demosaicing": "rawpy",
+        "conditioning": "false",
+        "batch_size": 1, 
+    }, 
+
+    "XFormerDenoise": {
+        "url": "https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/xformer_static.onnx",
+        "filename": "xformer_static.onnx",
+        "demosaicing": "rawpy",
+        "conditioning": "false",
+        "batch_size": 1, 
+        "crop_size": 256,
+    }, 
+    "NAFDenoise": {
+        "url": "https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/NAF_static.onnx",
+        "filename": "NAF_static.onnx",
+        "demosaicing": "rawpy",
+        "conditioning": "false",
+        "batch_size": 1, 
+        "crop_size": 256,
+    }, 
+
+    "NAFDenoise_dynamic": {
+        "url": "https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/NAF_dynamic.onnx",
+        "filename": "NAF_dynamic.onnx",
+        "demosaicing": "rawpy",
+        "conditioning": "false",
+        "batch_size": 1, 
+        "crop_size": 256,
+    }, 
+    "NAFDenoise_dynamic_fp16": {
+        "url": "https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/NAF_dynamic_fp16.onnx",
+        "filename": "NAF_dynamic_fp16.onnx",
+        "demosaicing": "rawpy",
+        "conditioning": "false",
+        "batch_size": 1, 
+        "crop_size": 256,
+    }, 
+    "NAF_static_fp16": {
+        "url": "    https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/NAF_static_fp16.onnx",
+        "filename": "NAF_static_fp16.onnx",
+        "demosaicing": "rawpy",
+        "conditioning": "false",
+        "batch_size": 1, 
+        "crop_size": 256,
+    }, 
+    "NAF_trace_test": {
+        "url": "    https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/xtrans_fixed_exposure_no_conditioning_400.onnx",
+        "filename": "xtrans_fixed_exposure_no_conditioning_400.onnx",
+        "demosaicing": "rawpy",
+        "conditioning": "false",
+        "batch_size": 1, 
+        "crop_size": 256,
+    }, 
+    "non_trace_test": {
+        "url": "    https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/non_trace_test.onnx",
+        "filename": "non_trace_test.onnx",
+        "demosaicing": "rawpy",
+        "conditioning": "false",
+        "batch_size": 1, 
+        "crop_size": 256,
+    }, 
+    "trace_test": {
+        "url": "    https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/trace_test.onnx",
+        "filename": "trace_test.onnx",
+        "demosaicing": "rawpy",
+        "conditioning": "false",
+        "batch_size": 1, 
+        "crop_size": 256,
+    },   
+    "non_trace_test_opset_20_static_simp": {
+        "url": "    https://github.com/rymuelle/RawForge/releases/download/onnx_v1.0.0/non_trace_test_opset_20_static_simp.onnx",
+        "filename": "non_trace_test_opset_20_static_simp.onnx",
+        "demosaicing": "rawpy",
+        "conditioning": "false",
+        "batch_size": 1, 
+        "crop_size": 256,
+    },   
+    
+    
+}

{rawforge-0.0.2 → rawforge-0.2.0}/RawForge/application/ModelHandler.py

@@ -1,21 +1,15 @@
-import torch
+import onnxruntime as ort
+import os
 import numpy as np
 from pathlib import Path
 from platformdirs import user_data_dir
-from time import perf_counter
 import requests
 from cryptography.hazmat.primitives import hashes, serialization
 from cryptography.hazmat.primitives.asymmetric import padding
 
-from RawHandler.RawHandler import RawHandler
-from RawHandler.RawHandlerRawpy import RawHandlerRawpy
-
-from RawForge.application.dng_utils import convert_color_matrix, to_dng
-from RawForge.application.utils import can_use_gpu
-
 from RawForge.application.MODEL_REGISTRY import MODEL_REGISTRY
 from RawForge.application.InferenceWorker import InferenceWorker
-from RawForge.application.InferenceWorkerRawpy import InferenceWorkerRawpy
+from RawForge.application.helpers.utils import get_best_providers
 
 key_string = '''-----BEGIN PUBLIC KEY-----
 MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA8iRGMPqFIFVF0TM/AbMI
@@ -40,46 +34,23 @@ class ModelHandler():
     def __init__(self):
         super().__init__()
 
-        self.model = None
-        self.rh = None
-        self.iso = 100
-        self.colorspace = 'lin_rec2020'
-
+        self.model = None        
+        app_name = "RawForge"
+        self.data_dir = Path(user_data_dir(app_name))
+        self.cache_dir = Path(os.path.expanduser(f"{self.data_dir}/model_cache")).resolve()
         # Manage devices
-        devices = {
-                   "cuda": can_use_gpu(),
-                   "mps": torch.backends.mps.is_available(),
-                   "cpu": lambda : True
-        }
-        self.devices = [d for d, is_available in devices.items() if is_available]
-        self.set_device(self.devices[0])
-        
-        self.filename = None
-        self.start_time = None
-        self.model_params = {}
-
+        self.providers = get_best_providers(cache_dir=self.cache_dir)
         self.pub = serialization.load_pem_public_key(key_string.encode('utf-8'))
 
-    def load_rh(self, path):
-        """Loads the raw file handler"""
-        if 'backend' in self.model_params and self.model_params['backend'] == 'rawpy':
-                    self.rh = RawHandlerRawpy(path)
-        else:
-                    self.rh = RawHandler(path)
-        self.iso = self.rh.full_metadata.get_ISO()
-        return self.iso
 
     def load_model(self, model_key):
         """Loads a model by key from the registry"""
         if model_key not in MODEL_REGISTRY:
             print(f"Model {model_key} not found in registry.")
             return
-
         conf = MODEL_REGISTRY[model_key]
         self.model_params = conf
-        app_name = "RawForge"
-        data_dir = Path(user_data_dir(app_name))
-        model_path = data_dir / conf["filename"]
+        model_path = self.data_dir / conf["filename"]
 
         # Handle Download
         if not model_path.is_file():
@@ -97,37 +68,15 @@ class ModelHandler():
             # Verify model before load
             self._verify_model(model_path, model_path.with_suffix(f'{model_path.suffix}.sig'))
             
-            loaded = torch.jit.load(model_path, map_location='cpu')
-            self.model = loaded.eval().to(self.device)
+            session = ort.InferenceSession(
+               model_path, 
+               providers=self.providers, 
+            )
+            print("Loaded!")
+            self.model = session
         except Exception as e:
             print(f"Failed to load model: {e}")
 
-    def set_device(self, device):
-        self.device = torch.device(device)
-        if self.model:
-            self.model.to(self.device)
-        print(f"Using Device {self.device} from {device}")
-
-    def run_inference(self, conditioning, dims=None, inference_kwargs={}):
-        """Starts the worker thread"""
-        if not self.model or not self.rh:
-            print("Model or Image not loaded.")
-            return
-
-        if 'backend' in self.model_params and self.model_params['backend'] == 'rawpy':
-            worker = InferenceWorkerRawpy(self.model, self.model_params, self.device, self.rh, conditioning, dims, **inference_kwargs)
-        else:
-            worker = InferenceWorker(self.model, self.model_params, self.device, self.rh, conditioning, dims, **inference_kwargs)
-        img, final_denoised =  worker.run()
-
-        return img, final_denoised
-
-
-    def generate_thumbnail(self, size=400):
-        if not self.rh: return None
-        thumb = self.rh.generate_thumbnail(min_preview_size=size, clip=True)
-        return thumb
-
     def _verify_model(self, dest_path, sig_path):
         try:
             data = Path(dest_path).read_bytes()
@@ -152,7 +101,6 @@ class ModelHandler():
             print(f"Model {dest_path} not verified! Deleting.")
             return False
 
-
     def _download_file(self, url, dest_path):
         dest_path.parent.mkdir(parents=True, exist_ok=True)
         try:
@@ -175,31 +123,4 @@ class ModelHandler():
         except Exception as e:
             print(e)
             return False
-        
-
-    def handle_full_image(self, denoised, filename, save_cfa):
-        # Compute CFA
-        if 'backend' in self.model_params and self.model_params['backend'] == 'rawpy':
-            _, mask = self.rh.compute_mask_and_sparse(dims=(0, 99999, 0, 99999))
-            denoised = denoised.transpose(2, 0, 1)
-            denoised = denoised.clip(0, 1)
-
-            denoised = np.where(mask, denoised, 0)
-            denoised = denoised.sum(axis=0)
-            denoised = denoised * ( self.rh.core_metadata.white_level) + self.rh.core_metadata.black_level_per_channel[0]
-            self.rh.to_dng(filename, uint_img=denoised)
-        else:
-            transform_matrix = np.linalg.inv(
-                    self.rh.rgb_colorspace_transform(colorspace=self.colorspace)
-                    )
-
-            CCM = self.rh.rgb_colorspace_transform(colorspace='XYZ')
-            CCM = np.linalg.inv(CCM)
-
-            transformed = denoised @ transform_matrix.T
-            uint_img = np.clip(transformed * 2**16-1, 0, 2**16-1).astype(np.uint16)
-            ccm1 = convert_color_matrix(CCM)
-            to_dng(uint_img, self.rh, filename, ccm1, save_cfa=save_cfa, convert_to_cfa=True)
-
-
 

rawforge-0.2.0/RawForge/application/helpers/censored_fit.py

@@ -0,0 +1,100 @@
+import numpy as np
+import math
+
+def norm_cdf(z):
+    erf_vec = np.vectorize(math.erf)
+    return 0.5 * (1 + erf_vec(z / np.sqrt(2)))
+
+def norm_pdf(z):
+    return (1 / np.sqrt(2 * np.pi)) * np.exp(-0.5 * z**2)
+
+
+def censored_linear_fit_twosided(x, y, clip_low=0, clip_high=1,
+                                 max_iter=200, tol=1e-6, include_offset=True):
+    """
+    Fit y ≈ a + b*x + ε, ε ~ N(0, σ²) under two-sided censoring:
+    clip_low ≤ y_true ≤ clip_high
+    Observed y are clipped to [clip_low, clip_high].
+    Returns (a, b, sigma) estimated via EM.
+
+    Parameters
+    ----------
+    x, y : array_like
+        Input data.
+    clip_low, clip_high : float or None
+        Lower/upper clip levels. Can be None for one-sided clipping.
+    max_iter : int
+        Maximum EM iterations.
+    tol : float
+        Relative tolerance for convergence.
+    include_offset : bool
+        If False, forces intercept a=0 (fit y ≈ b*x).
+
+    Returns
+    -------
+    a, b, sigma : floats
+        Estimated regression parameters.
+    """
+    x = np.asarray(x).ravel()
+    y = np.asarray(y).ravel()
+    mask = np.isfinite(x) & np.isfinite(y)
+    x, y = x[mask], y[mask]
+
+    if len(x) < 3:
+        raise ValueError("Not enough data points.")
+
+    # Initial guess (ordinary least squares) 
+    if include_offset:
+        A = np.vstack([np.ones_like(x), x]).T
+        a, b = np.linalg.lstsq(A, y, rcond=None)[0]
+    else:
+        b = np.dot(x, y) / np.dot(x, x)
+        a = 0.0
+    sigma = np.std(y - (a + b*x))
+
+    for _ in range(max_iter):
+        mu = a + b*x
+        y_exp = y.copy()
+
+        # Handle right-censoring (high clip)
+        if clip_high is not None:
+            high_mask = y >= clip_high - 1e-12
+            if np.any(high_mask):
+                z = (clip_high - mu[high_mask]) / sigma
+                Phi = norm_cdf(z)
+                phi = norm_pdf(z)
+                one_minus_Phi = 1.0 - Phi
+                lambda_ = np.zeros_like(z)
+                valid = one_minus_Phi > 1e-15
+                lambda_[valid] = phi[valid] / one_minus_Phi[valid]
+                y_exp[high_mask] = mu[high_mask] + sigma * lambda_
+
+        # Handle left-censoring (low clip)
+        if clip_low is not None:
+            low_mask = y <= clip_low + 1e-12
+            if np.any(low_mask):
+                z = (clip_low - mu[low_mask]) / sigma
+                Phi = norm_cdf(z)
+                phi = norm_pdf(z)
+                lambda_ = np.zeros_like(z)
+                valid = Phi > 1e-15
+                lambda_[valid] = -phi[valid] / Phi[valid]
+                y_exp[low_mask] = mu[low_mask] + sigma * lambda_
+
+        # M-step: re-fit with imputed expectations
+        if include_offset:
+            A = np.vstack([np.ones_like(x), x]).T
+            a_new, b_new = np.linalg.lstsq(A, y_exp, rcond=None)[0]
+        else:
+            b_new = np.dot(x, y_exp) / np.dot(x, x)
+            a_new = 0.0
+
+        sigma_new = np.std(y_exp - (a_new + b_new*x))
+
+        if np.allclose([a, b, sigma], [a_new, b_new, sigma_new],
+                       rtol=tol, atol=tol):
+            break
+
+        a, b, sigma = a_new, b_new, sigma_new
+
+    return a, b, sigma

rawforge-0.2.0/RawForge/application/helpers/get_image.py

@@ -0,0 +1,41 @@
+import numpy as np
+import rawpy
+from RawHandler.RawHandler import RawHandler
+from RawHandler.RawHandlerRawpy import RawHandlerRawpy
+
+def load_rh(path, demosaicing):
+    """Loads the raw file handler"""
+    if demosaicing == 'rawpy':
+                rh = RawHandlerRawpy(path)
+    elif demosaicing == 'Malvar2004':
+                rh = RawHandler(path)
+    iso = rh.full_metadata.get_ISO()
+    return rh, iso
+
+def get_image(path, model_params, dims=None):
+        demosaicing = model_params['demosaicing']
+        rh, iso = load_rh(path, demosaicing)
+        
+        if demosaicing=='Malvar2004':
+            from colour_demosaicing import demosaicing_CFA_Bayer_Malvar2004
+            image_RGB = rh.as_rgb(dims=dims, 
+                                  demosaicing_func=demosaicing_CFA_Bayer_Malvar2004, 
+                                  colorspace='lin_rec2020', clip=True)
+        elif demosaicing=='rawpy':
+            image_RGB = rh.rawpy_object.postprocess(
+                        user_wb=[1, 1, 1, 1],
+                        output_color=rawpy.ColorSpace.raw,
+                        demosaic_algorithm= rawpy.DemosaicAlgorithm(3),
+                        no_auto_bright=True,
+                        use_camera_wb=False,
+                        use_auto_wb=False,
+                        gamma=(1, 1),
+                        user_flip=0,
+                        output_bps=16,
+                        no_auto_scale=True,
+                    ) / rh.rawpy_object.white_level
+            if dims is not None:
+                image_RGB = image_RGB[dims[0]:dims[1], dims[2]:dims[3]]
+            image_RGB = image_RGB.transpose(2, 0, 1)
+        image_RGB = np.expand_dims(image_RGB, axis=0).astype(np.float16)
+        return rh, image_RGB, iso

rawforge-0.2.0/RawForge/application/helpers/utils.py

@@ -0,0 +1,17 @@
+import onnxruntime as ort
+import os
+
+def get_best_providers(cache_dir):
+    os.makedirs(cache_dir, exist_ok=True)
+    available = ort.get_available_providers()
+    return available
+    priority = [
+        "CUDAExecutionProvider",      # NVIDIA
+        "ROCMExecutionProvider",      # AMD (Direct)
+        "MIGraphXExecutionProvider",  # AMD (Optimized)
+        "CoreMLExecutionProvider",    # Apple Silicon
+        "DmlExecutionProvider",       # Windows (AMD/Intel/Generic GPU)
+        "CPUExecutionProvider"        # The fallback
+    ]
+    
+    return [p for p in priority if p in available]