onepix-fis-common-function 0.1.0__py3-none-any.whl

fis_common_function/CIE1931-2deg-XYZ.csv

@@ -0,0 +1,95 @@
+360,0.000129900000,0.000003917000,0.000606100000
+365,0.000232100000,0.000006965000,0.001086000000
+370,0.000414900000,0.000012390000,0.001946000000
+375,0.000741600000,0.000022020000,0.003486000000
+380,0.001368000000,0.000039000000,0.006450001000
+385,0.002236000000,0.000064000000,0.010549990000
+390,0.004243000000,0.000120000000,0.020050010000
+395,0.007650000000,0.000217000000,0.036210000000
+400,0.014310000000,0.000396000000,0.067850010000
+405,0.023190000000,0.000640000000,0.110200000000
+410,0.043510000000,0.001210000000,0.207400000000
+415,0.077630000000,0.002180000000,0.371300000000
+420,0.134380000000,0.004000000000,0.645600000000
+425,0.214770000000,0.007300000000,1.039050100000
+430,0.283900000000,0.011600000000,1.385600000000
+435,0.328500000000,0.016840000000,1.622960000000
+440,0.348280000000,0.023000000000,1.747060000000
+445,0.348060000000,0.029800000000,1.782600000000
+450,0.336200000000,0.038000000000,1.772110000000
+455,0.318700000000,0.048000000000,1.744100000000
+460,0.290800000000,0.060000000000,1.669200000000
+465,0.251100000000,0.073900000000,1.528100000000
+470,0.195360000000,0.090980000000,1.287640000000
+475,0.142100000000,0.112600000000,1.041900000000
+480,0.095640000000,0.139020000000,0.812950100000
+485,0.057950010000,0.169300000000,0.616200000000
+490,0.032010000000,0.208020000000,0.465180000000
+495,0.014700000000,0.258600000000,0.353300000000
+500,0.004900000000,0.323000000000,0.272000000000
+505,0.002400000000,0.407300000000,0.212300000000
+510,0.009300000000,0.503000000000,0.158200000000
+515,0.029100000000,0.608200000000,0.111700000000
+520,0.063270000000,0.710000000000,0.078249990000
+525,0.109600000000,0.793200000000,0.057250010000
+530,0.165500000000,0.862000000000,0.042160000000
+535,0.225749900000,0.914850100000,0.029840000000
+540,0.290400000000,0.954000000000,0.020300000000
+545,0.359700000000,0.980300000000,0.013400000000
+550,0.433449900000,0.994950100000,0.008749999000
+555,0.512050100000,1.000000000000,0.005749999000
+560,0.594500000000,0.995000000000,0.003900000000
+565,0.678400000000,0.978600000000,0.002749999000
+570,0.762100000000,0.952000000000,0.002100000000
+575,0.842500000000,0.915400000000,0.001800000000
+580,0.916300000000,0.870000000000,0.001650001000
+585,0.978600000000,0.816300000000,0.001400000000
+590,1.026300000000,0.757000000000,0.001100000000
+595,1.056700000000,0.694900000000,0.001000000000
+600,1.062200000000,0.631000000000,0.000800000000
+605,1.045600000000,0.566800000000,0.000600000000
+610,1.002600000000,0.503000000000,0.000340000000
+615,0.938400000000,0.441200000000,0.000240000000
+620,0.854449900000,0.381000000000,0.000190000000
+625,0.751400000000,0.321000000000,0.000100000000
+630,0.642400000000,0.265000000000,0.000049999990
+635,0.541900000000,0.217000000000,0.000030000000
+640,0.447900000000,0.175000000000,0.000020000000
+645,0.360800000000,0.138200000000,0.000010000000
+650,0.283500000000,0.107000000000,0.000000000000
+655,0.218700000000,0.081600000000,0.000000000000
+660,0.164900000000,0.061000000000,0.000000000000
+665,0.121200000000,0.044580000000,0.000000000000
+670,0.087400000000,0.032000000000,0.000000000000
+675,0.063600000000,0.023200000000,0.000000000000
+680,0.046770000000,0.017000000000,0.000000000000
+685,0.032900000000,0.011920000000,0.000000000000
+690,0.022700000000,0.008210000000,0.000000000000
+695,0.015840000000,0.005723000000,0.000000000000
+700,0.011359160000,0.004102000000,0.000000000000
+705,0.008110916000,0.002929000000,0.000000000000
+710,0.005790346000,0.002091000000,0.000000000000
+715,0.004109457000,0.001484000000,0.000000000000
+720,0.002899327000,0.001047000000,0.000000000000
+725,0.002049190000,0.000740000000,0.000000000000
+730,0.001439971000,0.000520000000,0.000000000000
+735,0.000999949300,0.000361100000,0.000000000000
+740,0.000690078600,0.000249200000,0.000000000000
+745,0.000476021300,0.000171900000,0.000000000000
+750,0.000332301100,0.000120000000,0.000000000000
+755,0.000234826100,0.000084800000,0.000000000000
+760,0.000166150500,0.000060000000,0.000000000000
+765,0.000117413000,0.000042400000,0.000000000000
+770,0.000083075270,0.000030000000,0.000000000000
+775,0.000058706520,0.000021200000,0.000000000000
+780,0.000041509940,0.000014990000,0.000000000000
+785,0.000029353260,0.000010600000,0.000000000000
+790,0.000020673830,0.000007465700,0.000000000000
+795,0.000014559770,0.000005257800,0.000000000000
+800,0.000010253980,0.000003702900,0.000000000000
+805,0.000007221456,0.000002607800,0.000000000000
+810,0.000005085868,0.000001836600,0.000000000000
+815,0.000003581652,0.000001293400,0.000000000000
+820,0.000002522525,0.000000910930,0.000000000000
+825,0.000001776509,0.000000641530,0.000000000000
+830,0.000001251141,0.000000451810,0.000000000000

fis_common_function/FIS_common_acquisition.py

@@ -0,0 +1,34 @@
+import os
+import numpy as np
+from datetime import date
+import time
+import json
+import logging
+from onepix.logging_config import root  
+logger = logging.getLogger(__name__)
+
+class FisCommonAcquisition:
+    def __init__(self,acquisition_class=None):
+        if acquisition_class:
+            self.acquisition_class = acquisition_class
+        base_path = os.path.join(os.path.dirname(os.path.abspath(__file__)))
+        self.config_path = os.path.join(base_path, "FIS_common_param.json")
+        self.hardware_dict = self._load_json(self.config_path)
+        self.spatial_res=self.hardware_dict["spatial_res"]
+        print("in common acquisition spatial res is ",self.spatial_res)
+
+    @staticmethod
+    def _load_json(path):
+        """Charge un fichier JSON en gérant les erreurs."""
+        try:
+            with open(path, "r") as f:
+                return json.load(f)
+        except FileNotFoundError:
+            logger.warning(f"⚠️ Warning: {path} not found. Using empty config.")
+            return {}
+        
+
+        
+        
+
+

fis_common_function/FIS_common_analysis.py

@@ -0,0 +1,656 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+import os
+import glob
+from scipy.signal import savgol_filter
+from tkinter import filedialog
+from tkinter import *
+import cv2
+from sklearn.decomposition import PCA
+from sklearn.cluster import KMeans
+import spectral.io.envi as envi
+from scipy.interpolate import interp1d
+from pathlib import Path
+
+from datetime import date
+import time
+
+class FisAnalysis:
+
+    def __init__(self):
+        return
+
+    def get_header_data(self, path):
+        """
+        This function allows to generate a dictionnary containing acquisition data
+        useful for the data cube reconstruction.
+
+        Parameters
+        ----------
+        path : str
+            Header file path
+
+        Returns
+        -------
+        acq_data : dict
+            Dictionnary containing acquisition data.
+
+        """
+
+        header = []
+        with open(path, "r") as file:
+            for line in file.readlines():
+                header.append(line.split(":"))
+        acq_data = dict()
+        # acq_data['Acquisition_name']=header[0][0][8:]
+        for x in header:
+            if x[0].strip() == "Imaging method":
+                acq_data["imaging_method"] = x[1].strip()
+
+            if x[0].strip() == "Integration time":
+                acq_data["integration_time_ms"] = float(x[1].strip()[:-2])
+
+        return acq_data
+
+    def load_hypercube(self, opt=None):
+        """
+        This function allows to load saved spectra with timers of the displays and spectrometers.
+        at runtime, a window appears to select the folder path in which the data are located.
+
+        Returns
+        -------
+        acq_data : dict
+            Dictionary containing data extracted from files saved after acquisition to reconstruct data cubes.
+
+        """
+
+        res = {"reconstructed_image": [], "wavelengths": []}
+
+        if opt == None:
+            if os.path.isdir("./Hypercubes"):
+                data_folder = "./Hypercubes"
+            elif "../Hypercubes":
+                data_folder = "../Hypercubes"
+            else:
+                data_folder = os.getcwd()
+
+            meas_path = filedialog.askdirectory(
+                title="Select the folder containing the acquisitions",
+                initialdir=data_folder,
+            )
+        elif opt == "last":
+            root_path = os.getcwd()
+            path = os.path.join(root_path, "Hypercubes")
+            meas_path = max(glob.glob(os.path.join(path, "*/")), key=os.path.getmtime)
+
+        else:
+            meas_path = opt
+
+        hyp_filename = glob.glob(f"{meas_path}/*.hdr")[0]
+        try:
+            info_filename = glob.glob(f"{meas_path}/*.txt")[0]
+            res["pattern_method"] = self.get_header_data(info_filename)[
+                "imaging_method"
+            ]
+        except:
+            pass
+        res["infos"] = "ONE_PIX_analysis" + meas_path.split("/")[-1][19:]
+        data = envi.open(hyp_filename)
+        res["reconstructed_image"] = data.load()
+        res["wavelengths"] = np.array(data.bands.centers)
+
+        return res
+
+    def snr_filt(self, spectre_desplit, noise_level=500):
+        """
+        snr_filt filters spectra in which the maximum intensity is lower than a defined level.
+
+        Parameters
+        ----------
+        spectre_desplit : array of floats
+            2D array of spectra.
+        noise_level : float, optional
+            minimum accepted intensity level. The default is 500.
+
+        Returns
+        -------
+        spectre_desplit : array of floats
+            filtered 2D array of spectra.
+
+        """
+        M = np.max(abs(spectre_desplit), axis=1)
+        idx_noise = np.squeeze(np.array(np.where(M < noise_level)))
+        spectre_desplit[idx_noise, :] = 0
+        return spectre_desplit
+
+    def Flux2Ref(self, rawHypercube, Wavelengths, reference=None):
+        """
+        Flux2Ref allows to normalize a raw hypercube in reflectance using a standard present in
+        the reconstructed image and its reflectance certificate.
+
+        Parameters
+        ----------
+        rawHypercube: numpy.array
+            3D array of spectral intensities data cube.
+        Wavelengths: numpy.array of floats
+            1D array of spectrometer's sampled wavelengths.
+        reference: numpy.array, optional
+            2D array of reflectance certificate composed of wavelengths and reflectance data.
+            The default is None for RELATIVE reflectances.
+
+        Returns
+        ----------
+        Normalised_Hypercube (numpy.array)
+            Reflectance normalised hypercube.
+        """
+        if reference == None:
+            reference = np.array([Wavelengths, np.ones_like(Wavelengths)])
+        sz = np.shape(rawHypercube)  # Hypercube dimensions
+        # Display spectral mean of the hypercube and select the reference area
+        fig, ax = plt.subplots(1)
+        ax.imshow(np.mean(rawHypercube, axis=2))
+        plt.title("Select a reference area to normalise the data cube")
+        x1, x2 = plt.ginput(2)  # Select two points to define reference area
+        x1 = np.round(x1).astype(np.int32)
+        x2 = np.round(x2).astype(np.int32)
+        # Create a Rectangle patch
+        rect = patches.Rectangle(
+            (x1[0], x1[1]),
+            x2[0] - x1[0],
+            x2[1] - x1[1],
+            linewidth=1,
+            edgecolor="r",
+            facecolor="none",
+        )
+        ax.add_patch(rect)  # Add the patch to the Axes
+        plt.show()
+        # Determine the spectral normalization coefficient
+        Refmes = np.mean(
+            rawHypercube[x1[1] : x2[1], x1[0] : x2[0], :], axis=(0, 1)
+        )  # 2D spatial mean of the selected area
+        Lref = np.squeeze(
+            np.interp(Wavelengths, reference[:, 0], reference[:, 1])
+        )  # Interpolation of the reflectance certificate to fit with experimental Wavelengths sampling
+        Normcoeff = Lref / Refmes  # Normalisation coefficient
+
+        # Hypercube normalisation without for loops
+        RefHypercube = np.tile(
+            np.reshape(Normcoeff, [1, 1, sz[2]]), [sz[0], sz[1], 1]
+        )  # reshape NormCoeff into a hypercube
+        Normalised_Hypercube = rawHypercube * RefHypercube  # Hypercube Normalisation
+
+        return Normalised_Hypercube
+
+    def spikes_correction(self, res):
+        """
+        Allows to correct by clicking on an over represented frequency in the Fourier domain.
+
+        Parameters
+        ----------
+        res: dict
+            dictionnary of acquisition results. Especially contains the whole spatial spectrum data cube
+            and the association image datacube.
+
+        Returns
+        -------
+        res: dict
+            actualised dictionnary of acquisition results.
+
+
+        """
+
+        fig, ax = plt.subplots()
+        whole_spectrum = np.fft.fftshift(
+            np.fft.fft2(res["reconstructed_image"], axes=(0, 1))
+        )
+        plt.imshow(np.log10(abs(np.mean(whole_spectrum, 2))))
+        plt.title(
+            "Spectral frequencies spikes correction. Pacq_datas escape key to end"
+        )
+        p = plt.ginput(-1)
+        p = np.round(p).astype(np.int32)
+        plt.clf()
+
+        for pixel in p:
+            if pixel[0] == np.size(whole_spectrum, 1) - 1:
+                whole_spectrum[pixel[1], pixel[0], :] = whole_spectrum[
+                    pixel[1], pixel[0] - 2, :
+                ]
+            else:
+                whole_spectrum[pixel[1], pixel[0], :] = whole_spectrum[
+                    pixel[1], pixel[0] + 1, :
+                ]
+        plt.imshow(np.log10(abs(np.mean(whole_spectrum, 2))))
+        plt.show()
+        res["reconstructed_image"] = abs(np.fft.ifft2(whole_spectrum, axes=(0, 1)))
+        return res
+
+    def datacube_normalisation_snv(self, datacube):
+        """
+        datacube_normalisation_snv allows to normamlize an hypercube using Standrad Variate normalisation
+
+        Parameters
+        ----------
+        datacube : array
+            3D image data cube.
+
+        Returns
+        -------
+        datacube : array
+            3D normalize datacube.
+
+        """
+        norm_datacube = np.zeros_like(datacube)
+        for i in range(0, np.shape(datacube)[0]):
+            for j in range(0, np.shape(datacube)[1]):
+                norm_datacube[i, j, :] = (
+                    datacube[i, j, :] - np.mean(datacube[i, j, :])
+                ) / np.std(datacube[i, j, :])
+        return norm_datacube
+
+    def datacube_reflectance_normalisation(self, datacube, ref_datacube):
+        if np.shape(ref_datacube) != np.shape(datacube):
+            ref = np.zeros_like(datacube)
+            for wl in range(np.size(ref, 2)):
+                ref[:, :, wl] = cv2.resize(ref_datacube[:, :, wl], (np.shape(ref)[:2]))
+        else:
+            ref = ref_datacube
+
+        normalised_datacube = datacube / ref
+
+        return normalised_datacube
+
+    def select_disp_spectra(self, datacube, wavelengths, n, mode):
+        """
+        select_disp_spectra allows to select pixel(s) of one hypercube and plot their spectra.
+
+        Parameters
+        ----------
+        datacube : array of floats
+            3D image data cube.
+        wavelengths : array of floats
+            1D array of sampled wavelengths.
+        n : int
+            Number of spectra to plot.
+        mode : str
+            for the mean area of spectra allows to plot mean ('mean') or each
+            selected spectrum in one figure ('single').
+
+        Returns
+        -------
+        spec : array
+            Spectra selected by the user from the data cube.
+
+        """
+        # Display Hypercube spectral mean to visualise an image
+        rgb_image = self.RGB_reconstruction(datacube, wavelengths)
+        fig, ax = plt.subplots()
+        #     plt.subplot(1,2,1)
+        ax.imshow(rgb_image)
+
+        # Selection of pixel(s) or region of interest
+        if mode == "single":
+            self.tick = np.arange(n) + 1
+            # Select pixel(s)
+            self.pixels = fig.ginput(n)
+            self.pixels = np.round(self.pixels).astype(np.int32)
+            # Display results
+            plt.plot(self.pixels[:, 0], self.pixels[:, 1], "x", color="red")
+            for i, txt in enumerate(self.tick):
+                plt.annotate(
+                    txt,
+                    (self.pixels[i, 0] + 1, self.pixels[i, 1] + 1),
+                    color="r",
+                    bbox=dict(boxstyle="circle"),
+                )
+            spec = datacube[self.pixels[:, 1], self.pixels[:, 0], :]
+            plt.show(block=False)
+
+        elif mode == "mean":
+            # Select 2 corner pixels of rectangle area
+            p = plt.ginput(2)
+            p = np.round(p).astype(np.int32)
+            spec = datacube[
+                p[0, 1] : p[1, 1], p[0, 0] : p[1, 0], :
+            ]  # 2D spatial mean of the selected area
+
+            # Display results
+            rect = patches.Rectangle(
+                (p[0, 0], p[0, 1]),
+                p[1, 0] - p[0, 0],
+                p[1, 1] - p[0, 1],
+                linewidth=1,
+                edgecolor="r",
+                facecolor="none",
+            )
+            ax.add_patch(rect)  # Add the patch to the Axes
+            plt.subplot(1, 2, 2)
+            plt.plot(wavelengths, np.mean(spec, axis=(0, 1)))
+            plt.xlabel("Wavelengths (nm)")
+            plt.ylabel("Mean intensity (counts)")
+            plt.show(block=False)
+
+        else:
+            print(
+                "mode='single' to display each spectrum or mode='mean' to display the mean of the spectra from the selected area"
+            )
+
+        plt.close()
+
+        return spec
+
+    def smooth_datacube(self, datacube, window_length, polyorder):
+        """
+        This function allows to smooth spectra of a whole datacube using Savitzky-Golay filter.
+        See more at :
+        https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.savgol_filter.html
+
+        Parameters
+        ----------
+        datacube: array of floats
+            3D image data cube.
+        window_length : int
+            The length of the filter window.
+        polyorder : int
+            The order of the polynomial used to fit the samples.
+            polyorder must be less than window_length.
+
+        Returns
+        -------
+        smoothed_datacube : array
+            3D array of smoothed datacube.
+
+        """
+        sz = np.shape(datacube)
+        smoothed_datacube = np.zeros(sz)
+        for line in range(sz[0]):
+            for col in range(sz[1]):
+                smoothed_datacube[line, col, :] = savgol_filter(
+                    datacube[line, col, :], window_length, polyorder
+                )
+
+        return smoothed_datacube
+
+    def RGB_reconstruction(self, datacube, wavelengths, gamma=2.2):
+        """
+        Convertit une image hyperspectrale en une image en espace CIE XYZ et la transforme en sRGB.
+        
+        :param hsi_image: Image hyperspectrale sous forme (H, W, C)
+        :param wavelengths: Tableau des longueurs d'onde correspondant aux C canaux
+        :param cie_cmfs: Matrice des fonctions colorimétriques CIE 1931 (λ, X, Y, Z)
+        :param gamma: Correction gamma pour l'affichage
+        :return: Image RGB en uint8 (H, W, 3)
+        """
+        # Récupérer le chemin absolu du script en cours d'exécution
+        script_dir = Path(__file__).parent  # Dossier où se trouve le script
+        cie_file = script_dir / "CIE1931-2deg-XYZ.csv"  # Fichier CMF attendu dans le même dossier
+
+        # Chargement des fonctions colorimétriques CIE 1931
+        cie_cmfs = np.loadtxt(cie_file, delimiter=",")
+
+        # Extraction des longueurs d'onde et des fonctions CMF
+        cmf_wavelengths, X_cmf, Y_cmf, Z_cmf = cie_cmfs[:, 0], cie_cmfs[:, 1], cie_cmfs[:, 2], cie_cmfs[:, 3]
+
+        # Interpolation des CMFs pour correspondre aux longueurs d'onde de l'image hyperspectrale
+        interp_X = interp1d(cmf_wavelengths, X_cmf, kind='linear', bounds_error=False, fill_value=0)
+        interp_Y = interp1d(cmf_wavelengths, Y_cmf, kind='linear', bounds_error=False, fill_value=0)
+        interp_Z = interp1d(cmf_wavelengths, Z_cmf, kind='linear', bounds_error=False, fill_value=0)
+
+        # Pondération des bandes spectrales par les CMFs
+        X = np.sum(datacube * interp_X(wavelengths), axis=-1)
+        Y = np.sum(datacube * interp_Y(wavelengths), axis=-1)
+        Z = np.sum(datacube * interp_Z(wavelengths), axis=-1)
+
+        # Empiler les canaux pour obtenir une image XYZ
+        xyz_image = np.stack([X, Y, Z], axis=-1)
+
+        # Transformation de XYZ vers sRGB (D65 standard)
+        M_XYZ_to_sRGB = np.array([[ 3.2406, -1.5372, -0.4986],
+                                [-0.9689,  1.8758,  0.0415],
+                                [ 0.0557, -0.2040,  1.0570]])
+        
+        rgb_image = np.dot(xyz_image, M_XYZ_to_sRGB.T)
+
+        # Normalisation et correction gamma
+        rgb_image -= rgb_image.min()
+        rgb_image /= rgb_image.max()
+        rgb_image = np.power(rgb_image, 1 / gamma)
+
+        # Conversion en uint8 pour affichage
+        return (rgb_image * 255).astype(np.uint8)
+
+
+
+    def clustering(self, datacube, components, n_cluster):
+        """
+        Clustering function allow to realize classification of the datacube
+        using kmeans algorithm on princpal components of the PCA.
+
+
+        Parameters
+        ----------
+        datacube : array
+            3D image data cube.
+        components : int
+            number of principal component used for the kmeans clustering.
+        n_cluster : int
+            number of cluster for the kmeans clustering.
+
+        Returns
+        -------
+        image_seg : array of int
+            2D array of clustered image.
+
+        """
+
+        image_reshape = np.reshape(
+            datacube,
+            (np.size(datacube, 0) * np.size(datacube, 1), np.size(datacube, 2)),
+        )
+
+        pca = PCA(components)
+        principalComponents = pca.fit_transform(image_reshape)
+
+        kmeans = KMeans(n_cluster, n_init=10, random_state=0).fit(principalComponents)
+        image_seg = np.reshape(
+            kmeans.labels_, (np.size(datacube, 0), np.size(datacube, 1))
+        )
+
+        return image_seg
+
+    def display_clust_spectra(self, image_seg, datacube, wl):
+        """
+        display_clust_spectra allows to display mean spectra of each cluster
+        of a segmented image.
+
+        Parameters
+        ----------
+        image_seg : array of int
+            2D array of clustered image.
+        datacube : array
+            3D image data cube.
+        wl : array of floats
+            1D sampled spectrometers wavelengths.
+
+        Returns
+        -------
+        spec : array of floats
+            spectra of each cluster.
+
+        """
+        n_cluster = np.max(image_seg) + 1
+        fig, ax = plt.subplots()
+
+        plt.subplot(1, 2, 1)
+        plt.imshow(image_seg)
+        plt.title("Clustered image")
+        legend = []
+        spec = []
+        mean_spec = np.zeros((n_cluster, len(wl)))
+        plt.subplot(1, 2, 2)
+        for clust in range(n_cluster):
+            idx_clust = np.where(image_seg == clust)
+            spec.append(datacube[idx_clust[0], idx_clust[1], :])
+            mean_spec[clust, :] = np.mean(spec[clust], 0)
+            legend.append(f"Cluster {clust}")
+        plt.plot(wl, mean_spec.T)
+
+        plt.title("Mean spectra of the clusters")
+        plt.xlabel("Wavelengths (nm)")
+        plt.ylabel("Reflectance")
+        plt.legend(legend)
+
+        return spec
+
+    def clip_datacube(self, datacube, wavelengths, lower_bound, upper_bound):
+        """
+        rognage_hyp allows to clip spectral (3rd) dimension of a datacube to
+        limit the analyse to the part of the measured spectra of interest.
+
+        Parameters
+        ----------
+        datacube : array
+            3D image data cube.
+        wavelengths : array of floats
+            1D sampled spectrometers wavelengths.
+        lower_bound : int
+            lower bound pixel of the associated wavelengths to start.
+        upper_bound : int
+            upper bound pixel of the associated wavelengths to end.
+
+        Returns
+        -------
+        datacube_rogn : array
+            3D clipped datacube.
+        wavelengths_rogn : array
+            1D array of clipped wavelengths.
+
+        """
+
+        indice_min = np.abs(wavelengths - lower_bound).argmin()
+        indice_max = np.abs(wavelengths - upper_bound).argmin()
+
+        wavelengths_rogn = wavelengths[indice_min:indice_max]
+        datacube_rogn = datacube[:, :, indice_min:indice_max]
+
+        return datacube_rogn, wavelengths_rogn
+
+    def save_acquisition_envi(
+        self, datacube, wavelengths, header, save_envi_name=None, save_path=None
+    ):
+        """
+        This function allow to save the resulting acquisitions from one
+        OPConfig object into the Hypercube folder.
+
+        Parameters
+        ----------
+        config : class
+            OPConfig class object.
+
+        Returns
+        -------
+        None.
+
+        """
+        root_path = os.getcwd()
+        if save_path is None:
+            save_path = f"..{os.sep}Hypercubes"
+        if os.path.isdir(save_path):
+            pass
+        else:
+            os.mkdir(save_path)
+        os.chdir(save_path)
+
+        self.fdate = date.today().strftime(
+            "%d_%m_%Y"
+        )  # convert the current date in string
+        self.actual_time = time.strftime("%H-%M-%S")  # get the current time
+        folder_name = (
+            f"ONE-PIX_reconstructed_data_{self.fdate}_{self.actual_time}"
+            if save_envi_name is None
+            else save_envi_name
+        )
+        os.mkdir(folder_name)
+        os.chdir(folder_name)
+        self.save_path = folder_name
+        if save_envi_name is None:
+            save_envi_name = folder_name
+        # saving the acquired spatial spectra hypercube
+        self.py2envi(datacube, wavelengths, save_envi_name, save_path)
+        with open(folder_name + ".txt", "w+") as header_file:
+            header_file.write(header)
+        os.chdir(root_path)
+
+    def py2envi(self, datacube, wavelengths, save_envi_name, save_path=None):
+        """
+        py2ms allows to save ONE-PIX data into ENVI format https://www.l3harrisgeospatial.com/docs/enviheaderfiles.html
+        metadata can be improved !
+
+        Parameters
+        ----------
+        save_envi_name : TYPE
+            DESCRIPTION.
+        datacube : TYPE
+            DESCRIPTION.
+        wavelengths : TYPE
+            DESCRIPTION.
+
+        Returns
+        -------
+        None.
+
+        """
+        filename = save_envi_name + ".hdr"
+        path = os.getcwd()
+        if save_path == None:
+            save_path = filedialog.askdirectory(title="Open the save directory")
+
+        envi.save_image(
+            filename, datacube, dtype=np.float32, metadata={"wavelength": wavelengths}
+        )
+
+    def py2ms(self, datacube, wavelengths, save_gerbil_name):
+        """
+
+        py2ms allows to save ONE-PIX data into Gerbil format http://gerbilvis.org/
+        a window appears to select the directory where the hyperspectral data will be saved in gebril format
+        Input:
+            save_gerbil_name : the name of the saved data into gerbil format (without .txt extension)
+
+
+        Parameters
+        ----------
+        save_gerbil_name : str
+            the name of the saved data into gerbil format (without .txt extension).
+        datacube : array
+            datacube to export into Gerbil format.
+        wavelengths : array
+            Sampled wavelengths associated to the measured datacube.
+
+        Returns
+        -------
+        None.
+
+        """
+
+        save_path = filedialog.askdirectory(title="Open the save directory")
+        maxval = datacube.max()
+        minval = datacube.min()
+        Range = maxval - minval
+        datacube = (datacube + minval) * (255 / Range)
+
+        fid = open(save_path + "\\" + save_gerbil_name + ".txt", "w")
+        os.mkdir(save_path + "\\" + save_gerbil_name)
+        nz = np.shape(datacube)
+
+        fid.write("{0} {1} \n".format(nz[2], save_gerbil_name + "\\"))
+
+        for i in range(0, nz[2]):
+            filename = "{0}_{1}.png".format(save_gerbil_name, i)
+            cv2.imwrite(
+                save_path + "\\" + save_gerbil_name + "\\" + filename, datacube[:, :, i]
+            )
+            fid.write("{0} {1}\n".format(filename, wavelengths[i]))
+
+        fid.close()

fis_common_function/FIS_common_param.json

@@ -0,0 +1,3 @@
+{
+"spatial_res":2
+}

fis_common_function/FIS_common_reconstruction.py

@@ -0,0 +1,213 @@
+import os
+import numpy as np
+from tkinter import filedialog
+from datetime import date
+import time
+import spectral.io.envi as envi
+import cv2
+from scipy.interpolate import interp1d
+from pathlib import Path
+
+
+class FisCommonReconstruction:
+    def __init__(self, acquisition_dict=None):
+        self.acquisition_dict = acquisition_dict
+        return
+    
+    def get_result_to_plot(self, datacube, wavelengths, gamma=2.2):
+        """
+        Convertit une image hyperspectrale en une image en espace CIE XYZ et la transforme en sRGB.
+        
+        :param hsi_image: Image hyperspectrale sous forme (H, W, C)
+        :param wavelengths: Tableau des longueurs d'onde correspondant aux C canaux
+        :param cie_cmfs: Matrice des fonctions colorimétriques CIE 1931 (λ, X, Y, Z)
+        :param gamma: Correction gamma pour l'affichage
+        :return: Image RGB en uint8 (H, W, 3)
+        """
+        # Récupérer le chemin absolu du script en cours d'exécution
+        script_dir = Path(__file__).parent  # Dossier où se trouve le script
+        cie_file = script_dir / "CIE1931-2deg-XYZ.csv"  # Fichier CMF attendu dans le même dossier
+
+        # Chargement des fonctions colorimétriques CIE 1931
+        cie_cmfs = np.loadtxt(cie_file, delimiter=",")
+
+        # Extraction des longueurs d'onde et des fonctions CMF
+        cmf_wavelengths, X_cmf, Y_cmf, Z_cmf = cie_cmfs[:, 0], cie_cmfs[:, 1], cie_cmfs[:, 2], cie_cmfs[:, 3]
+
+        # Interpolation des CMFs pour correspondre aux longueurs d'onde de l'image hyperspectrale
+        interp_X = interp1d(cmf_wavelengths, X_cmf, kind='linear', bounds_error=False, fill_value=0)
+        interp_Y = interp1d(cmf_wavelengths, Y_cmf, kind='linear', bounds_error=False, fill_value=0)
+        interp_Z = interp1d(cmf_wavelengths, Z_cmf, kind='linear', bounds_error=False, fill_value=0)
+
+        # Pondération des bandes spectrales par les CMFs
+        X = np.sum(datacube * interp_X(wavelengths), axis=-1)
+        Y = np.sum(datacube * interp_Y(wavelengths), axis=-1)
+        Z = np.sum(datacube * interp_Z(wavelengths), axis=-1)
+
+        # Empiler les canaux pour obtenir une image XYZ
+        xyz_image = np.stack([X, Y, Z], axis=-1)
+
+        # Transformation de XYZ vers sRGB (D65 standard)
+        M_XYZ_to_sRGB = np.array([[ 3.2406, -1.5372, -0.4986],
+                                [-0.9689,  1.8758,  0.0415],
+                                [ 0.0557, -0.2040,  1.0570]])
+        
+        rgb_image = np.dot(xyz_image, M_XYZ_to_sRGB.T)
+
+        # Normalisation et correction gamma
+        rgb_image -= rgb_image.min()
+        rgb_image /= rgb_image.max()
+        rgb_image = np.power(rgb_image, 1 / gamma)
+
+        # Conversion en uint8 pour affichage
+        return (rgb_image * 255).astype(np.uint8)
+
+
+    def save_acquisition_envi(
+        self, reconstruction_results, header, save_envi_name=None, save_path=None
+    ):
+        """
+        This function allow to save the resulting acquisitions from one
+        OPConfig object into the Hypercube folder.
+
+        Parameters
+        ----------
+        config : class
+            OPConfig class object.
+
+        Returns
+        -------
+        None.
+
+        """
+        datacube=reconstruction_results["reconstructed_data"]
+        wavelengths=reconstruction_results["wavelengths"]
+        if save_path==None:
+            save_path = Path(__file__).resolve().parent.parent.parent.parent / "measure"
+            print("save path: ",save_path)
+            if os.path.isdir(save_path):
+                pass
+            else :
+                os.mkdir(save_path)
+
+        self.fdate = date.today().strftime(
+            "%d_%m_%Y"
+        )  # convert the current date in string
+        self.actual_time = time.strftime("%H-%M-%S")  # get the current time
+        folder_name = (
+            f"ONE-PIX_reconstructed_data_{self.fdate}_{self.actual_time}"
+            if save_envi_name is None
+            else save_envi_name
+        )
+        
+        self.final_path = os.path.join(save_path,folder_name)
+        os.mkdir(os.path.join(self.final_path))
+        if save_envi_name is None:
+            save_envi_name = folder_name
+        # saving the acquired spatial spectra hypercube
+        self.py2envi(datacube, wavelengths, save_envi_name, self.final_path)
+        with open(os.path.join(self.final_path,folder_name) + ".txt", "w+") as header_file:
+            header_file.write(header)
+
+
+
+    def py2envi(self, datacube, wavelengths, save_envi_name="cube", save_path=None):
+        """
+        Sauvegarde un cube hyperspectral au format ENVI dans un dossier 'measure'
+        situé à la racine du dossier 'onepix_dev' (3 niveaux au-dessus de plugins/).
+
+        Exemple :
+        onepix_dev/
+        ├── plugins/
+        │   └── imaging_methods/
+        │       └── FIS_common_functions/
+        │           └── FIS_common_reconstruction.py  ← ce script
+        └── measure/
+            └── cube_xxx/
+                ├── cube_xxx.hdr
+                ├── cube_xxx.dat
+        """
+        
+        # 🧠 Si wavelengths est un seul nombre, le transformer en liste
+        if isinstance(wavelengths, (int, float)):
+            wavelengths = [wavelengths]
+
+        # 📁 Dossier du script actuel
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        
+        # 📁 On remonte 4 niveaux pour atteindre onepix_dev/
+        repo_root = os.path.abspath(os.path.join(current_dir, "../../../../"))
+        
+        # 📁 Crée (si besoin) le dossier measure/ dans onepix_dev/
+        measure_dir = os.path.join(repo_root, "measure")
+        os.makedirs(measure_dir, exist_ok=True)
+        
+        # 📁 Si aucun chemin spécifique n’est donné, on crée un sous-dossier
+        if save_path is None:
+            if not save_envi_name:
+                save_envi_name = f"cube_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+            save_path = os.path.join(measure_dir, save_envi_name)
+        
+        os.makedirs(save_path, exist_ok=True)
+        
+        # 📝 Nom complet du fichier HDR
+        hdr_path = os.path.join(save_path, save_envi_name + ".hdr")
+        
+        # 💾 Sauvegarde du cube ENVI
+        envi.save_image(
+            hdr_path,
+            datacube,
+            dtype=np.float32,
+            metadata={"wavelength": list(map(str, wavelengths))}
+        )
+        
+        print(f"[OK] Cube ENVI sauvegardé dans : {save_path}")
+        print(f"    - Fichier HDR : {hdr_path}")
+        
+        # 🔁 Retourne le chemin pour d'autres usages
+        return save_path
+
+    def py2ms(self, datacube, wavelengths, save_gerbil_name):
+        """
+
+        py2ms allows to save ONE-PIX data into Gerbil format http://gerbilvis.org/
+        a window appears to select the directory where the hyperspectral data will be saved in gebril format
+        Input:
+            save_gerbil_name : the name of the saved data into gerbil format (without .txt extension)
+
+
+        Parameters
+        ----------
+        save_gerbil_name : str
+            the name of the saved data into gerbil format (without .txt extension).
+        datacube : array
+            datacube to export into Gerbil format.
+        wavelengths : array
+            Sampled wavelengths associated to the measured datacube.
+
+        Returns
+        -------
+        None.
+
+        """
+
+        save_path = filedialog.askdirectory(title="Open the save directory")
+        maxval = datacube.max()
+        minval = datacube.min()
+        Range = maxval - minval
+        datacube = (datacube + minval) * (255 / Range)
+
+        fid = open(save_path + "\\" + save_gerbil_name + ".txt", "w")
+        os.mkdir(save_path + "\\" + save_gerbil_name)
+        nz = np.shape(datacube)
+
+        fid.write("{0} {1} \n".format(nz[2], save_gerbil_name + "\\"))
+
+        for i in range(0, nz[2]):
+            filename = "{0}_{1}.png".format(save_gerbil_name, i)
+            cv2.imwrite(
+                save_path + "\\" + save_gerbil_name + "\\" + filename, datacube[:, :, i]
+            )
+            fid.write("{0} {1}\n".format(filename, wavelengths[i]))
+
+        fid.close()

fis_common_function/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Apr 11 11:08:45 2022
+
+@author: mribes
+"""
+

onepix_fis_common_function-0.1.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: onepix-fis-common-function
+Version: 0.1.0
+Summary: Common FIS functions for ONE-PIX imaging methods
+Author: M. Ribes
+Author-email: "G. Russias" <contact@photonics-open-projects.com>
+License: MIT
+Project-URL: Homepage, https://gitlab.com/ton_repo/onepix_fis_common_function
+Project-URL: Source, https://gitlab.com/ton_repo/onepix_fis_common_function
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: importlib-metadata; python_version < "3.10"
+
+# fis_common_functions
+
+
+
+## Getting started
+
+To make it easy for you to get started with GitLab, here's a list of recommended next steps.
+
+Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
+
+## Add your files
+
+- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
+- [ ] [Add files using the command line](https://docs.gitlab.com/topics/git/add_files/#add-files-to-a-git-repository) or push an existing Git repository with the following command:
+
+```
+cd existing_repo
+git remote add origin https://gitlab.com/private1120225/onepix_plugins/fis_common_functions.git
+git branch -M main
+git push -uf origin main
+```
+
+## Integrate with your tools
+
+- [ ] [Set up project integrations](https://gitlab.com/private1120225/onepix_plugins/fis_common_functions/-/settings/integrations)
+
+## Collaborate with your team
+
+- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
+- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
+- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
+- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
+- [ ] [Set auto-merge](https://docs.gitlab.com/user/project/merge_requests/auto_merge/)
+
+## Test and Deploy
+
+Use the built-in continuous integration in GitLab.
+
+- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/)
+- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
+- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
+- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
+- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
+
+***
+
+# Editing this README
+
+When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.
+
+## Suggestions for a good README
+
+Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
+
+## Name
+Choose a self-explaining name for your project.
+
+## Description
+Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
+
+## Badges
+On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
+
+## Visuals
+Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
+
+## Installation
+Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
+
+## Usage
+Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
+
+## Support
+Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
+
+## Roadmap
+If you have ideas for releases in the future, it is a good idea to list them in the README.
+
+## Contributing
+State if you are open to contributions and what your requirements are for accepting them.
+
+For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
+
+You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
+
+## Authors and acknowledgment
+Show your appreciation to those who have contributed to the project.
+
+## License
+For open source projects, say how it is licensed.
+
+## Project status
+If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.

onepix_fis_common_function-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+fis_common_function/CIE1931-2deg-XYZ.csv,sha256=Qla56gWPu-IBbsw_TRaHRI_K3cV_osWJ5I9QG7HymUY,4750
+fis_common_function/FIS_common_acquisition.py,sha256=T3wD5vxQyrx_BqC9xoasZdAC6iVVmEfHE-vxUV8fHOE,1079
+fis_common_function/FIS_common_analysis.py,sha256=KQreAqCVOR7VkVQaRWpQBeVxAumZTR63N93HuUxZYCY,23037
+fis_common_function/FIS_common_param.json,sha256=pi7ntvDFuYMCr91exFNycEOUGlaMQViOvz5vkqHlPVw,21
+fis_common_function/FIS_common_reconstruction.py,sha256=S_2tarSAyQDbQWjWtmeLSjTW2ixBTkrwhxuuz3Fkyu8,8344
+fis_common_function/__init__.py,sha256=gLXQR6TNS7cb9ph_nG_zKd0myL9SkqahQFOEZrZ80m0,93
+onepix_fis_common_function-0.1.0.dist-info/METADATA,sha256=SsjbjyaE7rOdJvomMcOVjOa6ECLynx1amqbZHfei3Hk,6802
+onepix_fis_common_function-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+onepix_fis_common_function-0.1.0.dist-info/entry_points.txt,sha256=61G3jgkMrDRno3IwL_yCzYwTI7K057cgdiJcPmLZywE,58
+onepix_fis_common_function-0.1.0.dist-info/top_level.txt,sha256=vWbU_MlnhGxpnI7HmcbCnfVn0J87_RgZXYAYEnrD33A,20
+onepix_fis_common_function-0.1.0.dist-info/RECORD,,

onepix_fis_common_function-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

onepix_fis_common_function-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[onepix.common]
+fis_common_function = fis_common_function

onepix_fis_common_function-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fis_common_function