petal-qc 0.0.0__py3-none-any.whl

petal_qc/thermal/IRCore.py

@@ -0,0 +1,110 @@
+"""Thermal result of core."""
+import json
+
+import numpy as np
+
+from petal_qc.thermal import Petal_IR_Analysis
+from petal_qc.thermal import IRPetalParam
+
+
+class NumpyArrayEncoder(json.JSONEncoder):
+    """Encoder to dump in JSon."""
+    
+    def default(self, obj):
+        if isinstance(obj, np.integer):
+            return int(obj)
+        elif isinstance(obj, np.floating):
+            return float(obj)
+        elif isinstance(obj, np.ndarray):
+            return obj.tolist()
+        else:
+            return vars(obj)
+
+
+class IRCore(object):
+    """All the thermal data needed for one core."""
+
+    def __init__(self, SN, alias="", results=None, params=None) -> None:
+        """Initializarion.
+
+        Args:
+            SN (str): Serial number of the core
+            alias (str): Alternative ID for the core
+            params (IRPetalParam): Parameters
+
+        """
+        self.coreID = SN
+        self.aliasID = alias
+        self.date = None
+        self.institute = params.institute if params is not None else None
+        self.params = params
+        self.files = []
+        self.results = [] if results is None else results  # list of AnalysisResults. One per side
+        self.golden = []                                    # list of Golden results. One per side.
+
+    def set_files(self, files):
+        """Set the input files."""
+        self.files = []
+        for F in files:
+            self.files.append(F)
+
+        print(self.files)
+
+    def set_results(self, results):
+        """Set results.
+
+        Args:
+            results (list): list of AnalysisResults
+
+        """
+        self.results = results
+
+    def add_file(self, fnam):
+        """Add a new file path."""
+        self.files.append(fnam)
+
+    def to_json(self, pf=None):
+        """Dumps to JSon."""
+        out = json.dumps(self, indent=3, cls=NumpyArrayEncoder)
+        if pf:
+            pf.write(out)
+
+        return out
+
+    def apply_deltaT(self, deltaT):
+        """Applies a delta T correction."""
+        for i in range(2):
+            self.results[i].path_temp = np.array(self.results[i].path_temp) + deltaT
+            self.results[i].sensor_avg = np.array(self.results[i].sensor_avg) + deltaT
+
+    @staticmethod
+    def read_json(fnam):
+        """Read a JSon file."""
+        js = None
+        with open(fnam, 'r', encoding='UTF-8') as ifp:
+            js = json.load(ifp)
+
+        return IRCore.from_json(js)
+
+    @staticmethod
+    def from_json(J):
+        """Loads a JSon object."""
+        param = IRPetalParam.IRPetalParam(J["params"])
+        results = []
+        for o in J["results"]:
+            r = Petal_IR_Analysis.AnalysisResult()
+            r.from_json(o)
+            results.append(r)
+
+        C = IRCore(J["coreID"], J["aliasID"], results=results, params=param)
+        C.date = J["date"]
+        for F in J["files"]:
+            C.add_file(F)
+
+        return C
+
+
+if __name__ == "__main__":
+    with open("core.json", "r", encoding="UTF-8") as ifp:
+        O = IRCore.from_json(json.load(ifp))
+        print(O)

petal_qc/thermal/IRDataGetter.py

@@ -0,0 +1,359 @@
+"""Encapsulates different data structure at DESY and IFIC.
+"""
+
+
+import numpy as np
+from petal_qc.thermal import IRPetal
+from petal_qc.thermal import Petal_IR_Analysis
+
+
+class IRDataGetter(object):
+    """BAse class defining the interface."""
+
+    def __init__(self):
+        """Initialization."""
+        self.factor = 1
+        return
+
+    @staticmethod
+    def factory(institute, params):
+        """Returns the data getter corresponding to the given institute."""
+        if institute == "DESY":
+            out = IRDataDESY()
+
+        elif institute == "IFIC":
+            out = IRDataIFIC()
+
+        else:
+            raise NotImplementedError
+
+        out.fine_tune_params(params)
+        return out
+
+    def fine_tune_params(self, param):
+        """Set default values for the parameters."""
+        return
+
+    def get_IR_data(self, image, **kargs):
+        """_summary_
+
+        Args:
+        ----
+            image (IRBImage): the input IRB image
+            kargs: keyword arguments to pass.
+
+        """
+        pass
+
+    def find_reference_image(self, irbf, *args, **kargs):
+        """Find first image in sequence with T < T_min.
+
+        Args:
+        ----
+            irbf: The sequence of IR images
+            T_min: The temperature threshold
+            kargs (keyword arguments): keyword arguments
+
+        Returns
+        -------
+            min_T, i_min, values: The actual temperature of the image,
+                                  the sequence nubmer
+                                  and the array of values (a 2d array)
+
+
+        """
+        return 0, 0, []
+
+    def extract_pipe_path(self, image, params) -> list:
+        """Extract the "pipe path"  in a petal IR image.
+
+        Args:
+        ----
+            image (mdarray): The 2D array containing the input image
+            params: IRPetalPam object with options.
+
+        Returns
+        -------
+            pipe: the list of pipe contours or paths.
+
+        """
+        return []
+
+    def analyze_IR_image(self, img, pipe, sensors, iside, params):
+        """Analyze the IR image at input.
+
+        Args:
+        ----
+            img (IRBImage): THe image
+            pipes: The pipe
+            sensors: The sensor areas
+            iside: petal image with EoS on the left(0) or right (1)
+            params: IRPetal parameters
+
+        Returns
+        -------
+            An array of AnalysisResult objects.
+
+        """
+        pass
+
+    def get_analysis_frame(self, irbf):
+        """Get the frame where we want to perform the analysis."""
+        return None
+
+
+class IRDataIFIC(IRDataGetter):
+    """Gets data for IFIC analysis."""
+
+    def __init__(self) -> None:
+        """Initialization."""
+        super().__init__()
+
+    def find_reference_image(self, irbf, *args, **kargs):
+        """Find first image in sequence with T < T_min.
+
+        Args:
+        ----
+            irbf: The sequence of IR images
+            T_min: The temperature threshold
+            kargs (keyword arguments): keyword arguments
+
+        Returns
+        -------
+            min_T, i_min, values: The actual temperature of the image,
+                                  the sequence nubmer
+                                  and the array of values (a 2d array)
+
+
+        """
+        if len(args) == 0:
+            T_min = -22.0
+        else:
+            T_min = args[0]
+
+        irbf.set_concatenate(True)
+        min_T, i_min, ref_img = IRPetal.find_reference_image(irbf, T_min)
+        values = self.get_IR_data(ref_img)
+        self.factor = values.shape[0]/640
+
+        return min_T, i_min, [values, ]
+
+    def get_IR_data(self, image, **kargs):
+        """Get the data from the image in the proper orientation.
+
+        Proper orientation means that petals are vertical (in the  mirror image).
+        It will eventually try to rotate the image to compensate a camera rotation.
+
+        Args:
+        ----
+            image: IRBimage. If a list of IRBFile objects is given, only the frist is taken.
+            rotate: True to make the rotation compensation.
+
+        Returns
+        -------
+            2d array: The 2d array wit the temperature data.
+
+        """
+        if isinstance(image, list) or isinstance(image, tuple):
+            image = image[0]
+
+        nrow, ncol = image.image.shape
+        landscape = (ncol > nrow)
+
+        if landscape:
+            values = image.image.T
+        else:
+            values = image.image
+
+        rotate = False
+        if 'rotate' in kargs:
+            rotate = kargs['rotate']
+
+        if rotate:
+            values = IRPetal.rotate_full_image(values)
+
+        return values
+
+    def extract_pipe_path(self, image, params) -> list:
+        """Extract the "pipe path"  in a petal IR image.
+
+        Args:
+        ----
+            image(ndarray): The 2D array containing the 2 specular images
+            params: IRPetalPam object with options.
+
+        Returns
+        -------
+            pipe: the list of pipe contours or paths.
+
+        """
+        try:
+            pipes = IRPetal.extract_mirrored_pipe_path(image, params)
+        except Exception:
+            pipes = IRPetal.extract_mirrored_pipe_path(image[0], params)
+        return pipes
+
+    def analyze_IR_image(self, img, pipe, sensors, iside, params):
+        """IFIC implementation.
+
+        Analyzes an image with specular images of petal core.
+
+        Inputs have same meaning as bas eclass but are arrays with the 2 core sides.
+        """
+        res, _ = Petal_IR_Analysis.analyze_IR_mirrored_image(img, pipe, sensors, params)
+        return res
+
+    @staticmethod
+    def find_minimum(values):
+        """Find minima in series."""
+        indx = []
+
+        for i, v in enumerate(values):
+            if i == 0:
+                vprev = v
+                continue
+
+            try:
+                vnext = values[i+1]
+            except IndexError:
+                continue
+
+            if vprev > v and vnext > v:
+                indx.append(i)
+
+            vprev = v
+
+        return indx
+
+    def get_analysis_frame(self, irbf):
+        """Get the frame where we want to perform the analysis.
+
+        IFIC takes the minimum of the last cycle.
+        """
+        # Get all the temperatures
+        min_T = []
+        for img in irbf.images():
+            min_T.append(np.min(img[0].image))
+
+        indx = IRDataIFIC.find_minimum(min_T)
+        return [irbf.getImage(indx[-1])]
+
+
+class IRDataDESY(IRDataGetter):
+    """Gets data for DESY."""
+
+    def __init__(self) -> None:
+        """Initialization."""
+        super().__init__()
+
+    def fine_tune_params(self, param):
+        """Set default values for the parameters."""
+        param.distance = 16
+        param.width = 16
+
+    def get_IR_data(self, image, **kargs):
+        """Get the data from the image in the proper orientation.
+
+        Args:
+        ----
+            image: IRBimage
+            kargs: keyword arguments
+
+        Returns
+        -------
+            2d array: The 2d array wit the temperature data.
+
+        """
+        try:
+            values = np.rot90(image.image)
+        except Exception:
+            values = []
+            for img in image:
+                values.append(np.rot90(img.image))
+
+        return values
+
+    def find_reference_image(self, irbf, *args, **kargs):
+        """DESY wants the average of all images in the sequence.
+
+        Args:
+        ----
+            irbf: The sequence of IR images
+            args: The temperature threshold
+            kargs (keyword arguments): keyword arguments
+
+        Returns
+        -------
+            min_T, i_min, values: The actual temperature of the image,
+                                  the sequence nubmer
+                                  and the array of values (a 2d array)
+
+        """
+        if 'nframes' in kargs:
+            nframes = kargs['nframes']
+        else:
+            nframes = -1
+
+        min_T = 1e50
+        avg_img = irbf.append_average(nframes=nframes)
+        for img in avg_img:
+            val = np.min(img.image)
+            if val < min_T:
+                min_T = val
+
+        i_min = irbf.nimages-1
+        values = self.get_IR_data(avg_img)
+
+        factors = []
+        for img in values:
+            factors.append(img.shape[0]/640)
+        self.factor = max(factors)
+
+        return min_T, i_min, values
+
+    def extract_pipe_path(self, images, params) -> list:
+        """Extract the "pipe path"  in a petal IR image.
+
+        Args:
+        ----
+            images(list(ndarray)): The array of 2D arrays containing the images
+            params: IRPetalPam object with options.
+
+        Returns
+        -------
+            pipe: the list of pipe contours or paths.
+
+        """
+        pipes = []
+        for img in images:
+            pipe = IRPetal.extract_pipe_path(img, params)
+            pipes.append(pipe)
+
+        IRPetal.set_images(images)
+        return pipes
+
+    def analyze_IR_image(self, img, pipes, sensors, iside, params):
+        """DESY implementation.
+
+        Only one petal side at imput.
+        """
+        if isinstance(img, list):
+            res = Petal_IR_Analysis.analyze_IR_image_list(img, pipes, sensors, params)
+            return res
+
+        else:
+            res = Petal_IR_Analysis.analyze_IR_image(img, pipes[0], sensors[0], iside[0], params)
+            if iside[0]:
+                return [None, res]
+            else:
+                return [res, None]
+
+    def get_analysis_frame(self, irbf):
+        """Get the frame where we want to perform the analysis.
+
+        DESY gets the average of all frames.
+        """
+        if not irbf.has_average:
+            irbf.append_average(nframes=5)
+
+        return [v[-1] for v in irbf.file_images]