konfai 1.0.0__py3-none-any.whl

konfai/utils/Registration.py

@@ -0,0 +1,199 @@
+import SimpleITK as sitk
+from typing import Union
+import numpy as np
+import sys
+import scipy
+
+def parameterMap_to_transform(path_src: str) -> Union[sitk.Transform, list[sitk.Transform]]:
+    transform = sitk.ReadParameterFile(path_src)
+    format = lambda x: [float(i) for i in x]
+    dimension = int(transform["FixedImageDimension"][0])
+
+    if transform["Transform"][0] == "EulerTransform":
+        if dimension == 2:
+            result = sitk.Euler2DTransform()
+        else:
+            result = sitk.Euler3DTransform()
+        parameters = format(transform["TransformParameters"])
+        fixedParameters = format(transform["CenterOfRotationPoint"])+[0]
+    elif transform["Transform"][0] == "TranslationTransform":
+        result = sitk.TranslationTransform(dimension)
+        parameters = format(transform["TransformParameters"])
+        fixedParameters = []
+    elif transform["Transform"][0] == "AffineTransform":
+        result = sitk.AffineTransform(dimension)
+        parameters = format(transform["TransformParameters"])
+        fixedParameters = format(transform["CenterOfRotationPoint"])+[0]
+    elif transform["Transform"][0] == "BSplineStackTransform":
+        parameters = format(transform["TransformParameters"])
+        GridSize = format(transform["GridSize"])
+        GridOrigin = format(transform["GridOrigin"])
+        GridSpacing = format(transform["GridSpacing"])
+        GridDirection =  np.asarray(format(transform["GridDirection"])).reshape((dimension, dimension)).T.flatten() 
+        fixedParameters = np.concatenate([GridSize, GridOrigin, GridSpacing, GridDirection])
+
+        nb = int(format(transform["Size"])[-1])
+        sub = int(np.prod(GridSize))*dimension
+        results = []
+        for i in range(nb):
+            result = sitk.BSplineTransform(dimension)
+            sub_parameters = np.asarray(parameters[i*sub:(i+1)*sub])
+            result.SetFixedParameters(fixedParameters)
+            result.SetParameters(sub_parameters)
+            results.append(result)
+        return results
+    elif transform["Transform"][0] == "AffineLogStackTransform":
+        parameters = format(transform["TransformParameters"])
+        fixedParameters = format(transform["CenterOfRotationPoint"])+[0]
+
+        nb = int(transform["NumberOfSubTransforms"][0])
+        sub = dimension*4
+        results = []
+        for i in range(nb):
+            result = sitk.AffineTransform(dimension)
+            sub_parameters = np.asarray(parameters[i*sub:(i+1)*sub])
+
+            result.SetFixedParameters(fixedParameters)
+            result.SetParameters(np.concatenate([scipy.linalg.expm(sub_parameters[:dimension*dimension].reshape((dimension,dimension))).flatten(), sub_parameters[-dimension:]]))
+            results.append(result)
+        return results
+    else:
+        result = sitk.BSplineTransform(dimension)
+        
+        parameters = format(transform["TransformParameters"])
+        GridSize = format(transform["GridSize"])
+        GridOrigin = format(transform["GridOrigin"])
+        GridSpacing = format(transform["GridSpacing"])
+        GridDirection = np.array(format(transform["GridDirection"])).reshape((dimension,dimension)).T.flatten() 
+        fixedParameters = np.concatenate([GridSize, GridOrigin, GridSpacing, GridDirection])
+
+    result.SetFixedParameters(fixedParameters)
+    result.SetParameters(parameters)
+    return result
+
+if __name__ == "__main__":
+    out_path = sys.argv[1]
+    finename = sys.argv[2]
+    finename_dest = sys.argv[3]
+    transform = parameterMap_to_transform("{}/{}".format(out_path, finename))
+    sitk.WriteTransform(transform, "{}/{}".format(out_path, finename_dest))
+
+def getFlatLabel(mask: sitk.Image, labels: list[int]) -> sitk.Image:
+    data = sitk.GetArrayFromImage(mask)
+    result_data = np.zeros_like(data, np.uint8)
+
+    for label in labels:
+        result_data[data == label] = 1
+
+    result = sitk.GetImageFromArray(result_data)
+    result.CopyInformation(mask)        
+    return result
+
+def rampFilterHistogram(image: sitk.Image, rampStart: float, rampEnd: float) -> sitk.Image:
+    imageData = sitk.GetArrayFromImage(image)
+    filter = np.logical_and(imageData > rampStart, imageData < rampEnd)
+    rampWidth = rampEnd - rampStart
+    imageData[filter] = (1/rampWidth) * (imageData[filter] - rampStart) * imageData[filter]
+    filteredImage = sitk.GetImageFromArray(imageData)
+    filteredImage.CopyInformation(image)
+    return filteredImage
+
+def elastic_registration(   fixed_image : sitk.Image,
+                            moving_image : sitk.Image,
+                            fixed_mask : Union[sitk.Image, None],
+                            moving_mask : Union[sitk.Image, None],
+                            name_parameterMap : str,
+                            outputDir: str) -> sitk.Transform:
+        labels = np.unique(sitk.GetArrayFromImage(fixed_mask))
+        fixed_mask = getFlatLabel(fixed_mask, labels[1:])
+        moving_mask = getFlatLabel(moving_mask, labels[1:])
+
+        fixed_mask.CopyInformation(fixed_image)
+        moving_mask.CopyInformation(moving_image)
+
+        fixed_mask_dillated = sitk.BinaryDilate(fixed_mask, [5,5,5])
+        moving_mask_dillated = sitk.BinaryDilate(moving_mask, [5,5,5])
+        
+        fixed_image = sitk.Mask(fixed_image, fixed_mask)
+        moving_image = sitk.Mask(moving_image, moving_mask)
+
+
+        minGradientMagnitude = 50
+        fixed_image_gradient = rampFilterHistogram(sitk.VectorMagnitude(sitk.Gradient(fixed_image)), 0, minGradientMagnitude)
+        moving_image_gradient = rampFilterHistogram(sitk.VectorMagnitude(sitk.Gradient(moving_image)), 0, minGradientMagnitude)
+
+        elastixImageFilter = sitk.ElastixImageFilter()
+        elastixImageFilter.SetFixedImage(fixed_image_gradient)
+        elastixImageFilter.AddFixedImage(fixed_image)
+        elastixImageFilter.AddFixedImage(fixed_image)
+
+        if fixed_mask is not None:
+            elastixImageFilter.SetFixedMask(fixed_mask)
+            elastixImageFilter.AddFixedMask(fixed_mask_dillated)
+            elastixImageFilter.AddFixedMask(fixed_mask_dillated)
+
+
+        elastixImageFilter.SetMovingImage(moving_image_gradient)
+        elastixImageFilter.AddMovingImage(moving_image)
+        elastixImageFilter.AddMovingImage(moving_image)
+        
+        if moving_mask is not None:
+            elastixImageFilter.SetMovingMask(moving_mask)
+            elastixImageFilter.AddMovingMask(moving_mask_dillated)
+            elastixImageFilter.AddMovingMask(moving_mask_dillated)
+
+        elastixImageFilter.SetParameterMap(sitk.ReadParameterFile("{}.txt".format(name_parameterMap)))
+        elastixImageFilter.LogToConsoleOn()
+        elastixImageFilter.SetOutputDirectory(outputDir)
+        
+        elastixImageFilter.Execute()
+        
+        transform = parameterMap_to_transform("{}TransformParameters".format(outputDir))
+        
+        return transform
+
+def registration(   fixed_image : sitk.Image,
+                    moving_image : sitk.Image,
+                    fixed_mask : Union[sitk.Image, None],
+                    moving_mask : Union[sitk.Image, None],
+                    name_parameterMap : str,
+                    outputDir: str) -> sitk.Transform:
+        elastixImageFilter = sitk.ElastixImageFilter()
+        elastixImageFilter.SetFixedImage(fixed_image)
+        if fixed_mask is not None:
+            elastixImageFilter.SetFixedMask(fixed_mask)
+
+        elastixImageFilter.SetMovingImage(moving_image)
+        if moving_mask is not None:
+            elastixImageFilter.SetMovingMask(moving_mask)
+
+        elastixImageFilter.SetParameterMap(sitk.ReadParameterFile("{}.txt".format(name_parameterMap)))
+        elastixImageFilter.LogToConsoleOn()
+        elastixImageFilter.SetOutputDirectory(outputDir)
+        elastixImageFilter.Execute()
+        
+        transform = parameterMap_to_transform("{}TransformParameters".format(outputDir))
+        
+        return transform
+
+def registration_groupewise(images_1: sitk.Image, masks: sitk.Image, images_2: sitk.Image, name_parameterMap : str, output_dir: str):
+    elastixImageFilter = sitk.ElastixImageFilter()
+    elastixImageFilter.SetFixedImage(images_1)
+    elastixImageFilter.SetMovingImage(images_1)
+    elastixImageFilter.SetFixedMask(masks)
+    elastixImageFilter.SetMovingMask(masks)
+    
+    if images_2 is not None:
+        elastixImageFilter.AddFixedImage(images_2)
+        elastixImageFilter.AddMovingImage(images_2)
+        #elastixImageFilter.AddFixedImage(images_2)
+        #elastixImageFilter.AddMovingImage(images_2)
+    
+    elastixImageFilter.SetParameterMap(sitk.ReadParameterFile("{}.txt".format(name_parameterMap)))
+    elastixImageFilter.LogToConsoleOn()
+    elastixImageFilter.SetOutputDirectory(output_dir)
+    elastixImageFilter.LogToFileOn()
+    elastixImageFilter.Execute()
+
+    transforms = parameterMap_to_transform("{}TransformParameters".format(output_dir))
+    return transforms

konfai/utils/config.py

@@ -0,0 +1,218 @@
+import os
+import ruamel.yaml
+import inspect 
+import collections
+from copy import deepcopy
+from typing import Union
+import torch
+
+from KonfAI.konfai import CONFIG_FILE
+
+yaml = ruamel.yaml.YAML()
+
+class ConfigError(Exception):
+
+    def __init__(self, message : str = "The config only supports types : config(Object), int, str, bool, float, list[int], list[str], list[bool], list[float], dict[str, Object]") -> None:
+        self.message = message
+        super().__init__(self.message)
+
+class Config():
+
+    def __init__(self, filename, key) -> None:
+        self.filename = filename
+        self.keys = key.split(".")
+
+    def __enter__(self):
+        if not os.path.exists(self.filename):
+            result = input("Create a new config file ? [no,yes,interactive] : ")
+            if result in ["yes", "interactive"]:
+                os.environ["DEEP_LEANING_API_CONFIG_MODE"] = "interactive" if result == "interactive" else "default"
+            else:
+                exit(0)
+            with open(self.filename, "w") as f:
+                pass
+                    
+        self.yml = open(self.filename, 'r')
+        self.data = yaml.load(self.yml)
+        if self.data == None:
+            self.data = {}
+        
+        self.config = self.data
+
+        for key in self.keys:
+            if self.config == None or key not in self.config:
+                self.config = {key : {}}
+            
+            self.config = self.config[key]
+        return self
+
+    def createDictionary(self, data, keys, i) -> dict:
+        if keys[i] not in data:
+            data = {keys[i]: data}
+        if i == 0:
+            return data
+        else:
+            i -= 1
+            return self.createDictionary(data, keys, i)
+    
+    def merge(self, dict1, dict2) -> dict:
+        result = deepcopy(dict1)
+
+        for key, value in dict2.items():
+            if isinstance(value, collections.abc.Mapping):
+                result[key] = self.merge(result.get(key, {}), value)
+            else:
+                if not dict2[key] == None:
+                    result[key] = deepcopy(dict2[key])
+        return result
+
+
+    def __exit__(self, type, value, traceback) -> None:
+        self.yml.close()
+        if os.environ["DEEP_LEANING_API_CONFIG_MODE"] == "remove":
+            if os.path.exists(CONFIG_FILE()):
+                os.remove(CONFIG_FILE())
+            return
+        with open(self.filename, 'r') as yml:
+            data = yaml.load(yml)
+            if data == None:
+                data = {}
+        with open(self.filename, 'w') as yml:
+            yaml.dump(self.merge(data, self.createDictionary(self.config, self.keys, len(self.keys)-1)), yml)
+  
+    @staticmethod
+    def _getInput(name : str, default : str) ->  str:
+        try:
+            return input("{} [{}]: ".format(name, ",".join(default.split(":")[1:]) if len(default.split(":")) else ""))
+        except:
+            result = input("\nKeep a default configuration file ? (yes,no) : ")
+            if result == "yes":
+                os.environ["DEEP_LEANING_API_CONFIG_MODE"] = "default"
+            else:
+                os.environ["DEEP_LEANING_API_CONFIG_MODE"] = "remove"
+                exit(0)
+        return default.split(":")[1] if len(default.split(":")) > 1 else default
+
+    @staticmethod
+    def _getInputDefault(name : str, default : Union[str, None], isList : bool = False) -> Union[list[Union[str, None]], str, None]:
+        if isinstance(default, str) and (default == "default" or (len(default.split(":")) > 1 and default.split(":")[0] == "default")):
+            if os.environ["DEEP_LEANING_API_CONFIG_MODE"] == "interactive":
+                if isList:
+                    list_tmp = []
+                    key_tmp = "OK"
+                    while key_tmp != "!" and os.environ["DEEP_LEANING_API_CONFIG_MODE"] == "interactive":
+                        key_tmp = Config._getInput(name, default)
+                        if key_tmp != "!":
+                            if key_tmp == "":
+                                key_tmp = default.split(":")[1] if len(default.split(":")) > 1 else default
+                            list_tmp.append(key_tmp)
+                    return list_tmp
+                else:
+                    value = Config._getInput(name, default)
+                    if value == "":
+                        return default.split(":")[1] if len(default.split(":")) > 1 else default 
+                    else: 
+                        return value
+            else:
+                default = default.split(":")[1] if len(default.split(":")) > 1 else default
+        return  [default] if isList else default
+
+    def getValue(self, name, default) -> object:  
+        if name in self.config and self.config[name] is not None:
+            value = self.config[name]
+            if value == None:
+                value = default
+            value_config = value
+        else:
+            value = Config._getInputDefault(name, default if default != inspect._empty else None)
+            
+            value_config = value
+            if type(value_config) == tuple:
+                value_config = list(value)
+                
+            if type(value_config) == list:
+                list_tmp = [] 
+                for key in value_config:
+                    list_tmp.extend(Config._getInputDefault(name, key, isList=True))
+
+                value = list_tmp
+                value_config = list_tmp
+
+            if type(value) == dict:
+                key_tmp = []
+                
+                value_config = {}
+                dict_value = {}
+                for key in value:
+                    key_tmp.extend(Config._getInputDefault(name, key, isList=True))
+                for key in key_tmp:
+                    if key in value:
+                        value_tmp = value[key]
+                    else:
+                        value_tmp = next(v for k,v in value.items() if "default" in k)
+
+                    value_config[key] = None
+                    dict_value[key] = value_tmp
+                value = dict_value
+        if isinstance(self.config, str):
+            os.environ['DEEP_LEARNING_API_CONFIG_VARIABLE'] = "True"
+            return None
+
+        self.config[name] = value_config if value_config is not None else "None"
+        if value == "None":
+            value = None
+        return value
+                    
+def config(key : Union[str, None] = None):
+    def decorator(function):
+        def new_function(*args, **kwargs):
+            if "config" in kwargs:
+                filename =  kwargs["config"]
+                if filename == None:
+                    filename = os.environ['DEEP_LEARNING_API_CONFIG_FILE']
+                else:
+                    os.environ['DEEP_LEARNING_API_CONFIG_FILE'] = filename
+                key_tmp =  kwargs["DL_args"]+("."+key if key is not None else "") if "DL_args" in kwargs else key
+                without =  kwargs["DL_without"] if "DL_without" in kwargs else []
+                os.environ['DEEP_LEARNING_API_CONFIG_PATH'] = key_tmp
+                with Config(filename, key_tmp) as config:
+                    os.environ['DEEP_LEARNING_API_CONFIG_VARIABLE'] = "False"
+                    kwargs = {} 
+                    for param in list(inspect.signature(function).parameters.values())[len(args):]:
+                        annotation = param.annotation
+                        if str(annotation).startswith("typing.Union") or str(annotation).startswith("typing.Optional"):
+                            for i in annotation.__args__:
+                                annotation = i
+                                break
+                        if param.name in without:
+                            continue
+                        if not annotation == inspect._empty:
+                            if annotation not in [int, str, bool, float, torch.Tensor]:
+                                if str(annotation).startswith("list") or str(annotation).startswith("tuple") or str(annotation).startswith("typing.Tuple"):
+                                    if annotation.__args__[0] in [int, str, bool, float]:
+                                        values = config.getValue(param.name, param.default)
+                                        kwargs[param.name] = values
+                                    else:
+                                        raise ConfigError()
+                                elif str(annotation).startswith("dict"):
+                                    if annotation.__args__[0] == str:
+                                        values = config.getValue(param.name, param.default)
+                                        if values is not None and annotation.__args__[1] not in [int, str, bool, float]:
+                                            kwargs[param.name] = {value : annotation.__args__[1](config = filename, DL_args = key_tmp+"."+param.name+"."+value) for value in values}
+                                        else:
+                                            kwargs[param.name] = values
+                                    else: 
+                                        raise ConfigError()
+                                else:
+                                    kwargs[param.name] = annotation(config = filename, DL_args = key_tmp)
+                                    if os.environ['DEEP_LEARNING_API_CONFIG_VARIABLE'] == "True":
+                                        os.environ['DEEP_LEARNING_API_CONFIG_VARIABLE'] = "False"
+                                        kwargs[param.name] = None
+                            else:
+                                kwargs[param.name] = config.getValue(param.name, param.default)
+                        elif param.name != "self":
+                            kwargs[param.name] = config.getValue(param.name, param.default)
+            result = function(*args, **kwargs)
+            return result
+        return new_function
+    return decorator