BOSlib 0.0.1__py3-none-any.whl → 0.0.4__py3-none-any.whl

BOSlib/__init__.py

@@ -6,4 +6,4 @@ from .reconstruction_utils import *
 from .culculate_refractiveindex import *
 from .evaluation  import *
 
-__version__ = '0.0.1'
+__version__ = '0.0.4'

BOSlib/evaluation.py

@@ -1,4 +1,4 @@
-import open3d as o3d
+#import open3d as o3d
 import numpy as np
 from tqdm import tqdm
 import matplotlib.pyplot as plt
@@ -7,338 +7,338 @@ import matplotlib.colors as mcolors
 import statistics
 import mpl_toolkits.axes_grid1
 
-class CalculateDiff:
-    """
-    A class to calculate the difference between two point clouds in terms of neighbor densities.
-
-    Attributes
-    ----------
-    output_path : str
-        Path where the resulting point cloud with differences will be saved.
-    r : float
-        Radius for neighbor point sampling in KDTree.
-
-    Methods
-    -------
-    diff(pcl1, pcl2)
-        Calculates and visualizes the relative density differences between two point clouds.
-    ectraction_neighborpoints(pointcloud, target_positions)
-        Extracts the density of neighboring points around specified target positions.
-    """
-    def __init__(self, output_path: str, r: float) -> None:
-        """
-        Initializes the CalculateDiff class.
-
-        Parameters
-        ----------
-        output_path : str
-            Path to save the output point cloud.
-        r : float
-            Radius for neighbor point sampling in KDTree.
-        """
-        self.outputpath = output_path
-        self.r = r
-
-    def diff(self, pcl1, pcl2):
-        """
-        Calculates the relative density difference between two point clouds.
-
-        The method computes the difference in neighbor densities for points in two point clouds.
-        It normalizes the differences and clips them for visualization, then creates a new point
-        cloud to save the results.
-
-        Parameters
-        ----------
-        pcl1 : open3d.geometry.PointCloud
-            The first point cloud.
-        pcl2 : open3d.geometry.PointCloud
-            The second point cloud.
-
-        Returns
-        -------
-        open3d.geometry.PointCloud
-            The point cloud representing the relative density differences.
-        """
-        # Initialize the output point cloud
-        diff_pointcloud = o3d.geometry.PointCloud()
+# class CalculateDiff:
+#     """
+#     A class to calculate the difference between two point clouds in terms of neighbor densities.
+
+#     Attributes
+#     ----------
+#     output_path : str
+#         Path where the resulting point cloud with differences will be saved.
+#     r : float
+#         Radius for neighbor point sampling in KDTree.
+
+#     Methods
+#     -------
+#     diff(pcl1, pcl2)
+#         Calculates and visualizes the relative density differences between two point clouds.
+#     ectraction_neighborpoints(pointcloud, target_positions)
+#         Extracts the density of neighboring points around specified target positions.
+#     """
+#     def __init__(self, output_path: str, r: float) -> None:
+#         """
+#         Initializes the CalculateDiff class.
+
+#         Parameters
+#         ----------
+#         output_path : str
+#             Path to save the output point cloud.
+#         r : float
+#             Radius for neighbor point sampling in KDTree.
+#         """
+#         self.outputpath = output_path
+#         self.r = r
+
+#     def diff(self, pcl1, pcl2):
+#         """
+#         Calculates the relative density difference between two point clouds.
+
+#         The method computes the difference in neighbor densities for points in two point clouds.
+#         It normalizes the differences and clips them for visualization, then creates a new point
+#         cloud to save the results.
+
+#         Parameters
+#         ----------
+#         pcl1 : open3d.geometry.PointCloud
+#             The first point cloud.
+#         pcl2 : open3d.geometry.PointCloud
+#             The second point cloud.
+
+#         Returns
+#         -------
+#         open3d.geometry.PointCloud
+#             The point cloud representing the relative density differences.
+#         """
+#         # Initialize the output point cloud
+#         diff_pointcloud = o3d.geometry.PointCloud()
         
-        # Extract point positions from the input point clouds
-        positions_pcl1 = np.array(pcl1.points)
-        positions_pcl2 = np.array(pcl2.points)
-
-        # Use the sparser point cloud for density calculation
-        if positions_pcl1.shape[0] < positions_pcl2.shape[0]:
-            ground_position = positions_pcl1
-        else:
-            ground_position = positions_pcl2
-
-        # Compute neighbor densities for each point cloud
-        density_pcl1 = self.ectraction_neighborpoints(pcl1, ground_position)
-        density_pcl2 = self.ectraction_neighborpoints(pcl2, ground_position)
-        density_diff = density_pcl1 - density_pcl2
-
-        # Convert to relative error
-        density_diff_relative = 100 * np.divide(
-            np.abs(density_diff),
-            np.array(density_pcl1)
-        )
+#         # Extract point positions from the input point clouds
+#         positions_pcl1 = np.array(pcl1.points)
+#         positions_pcl2 = np.array(pcl2.points)
+
+#         # Use the sparser point cloud for density calculation
+#         if positions_pcl1.shape[0] < positions_pcl2.shape[0]:
+#             ground_position = positions_pcl1
+#         else:
+#             ground_position = positions_pcl2
+
+#         # Compute neighbor densities for each point cloud
+#         density_pcl1 = self.ectraction_neighborpoints(pcl1, ground_position)
+#         density_pcl2 = self.ectraction_neighborpoints(pcl2, ground_position)
+#         density_diff = density_pcl1 - density_pcl2
+
+#         # Convert to relative error
+#         density_diff_relative = 100 * np.divide(
+#             np.abs(density_diff),
+#             np.array(density_pcl1)
+#         )
         
-        # Clip relative differences to a maximum of 100
-        density_diff_relative = np.clip(density_diff_relative, 0, 100)
-
-        # Apply the differences to the output point cloud
-        diff_pointcloud.normals = o3d.utility.Vector3dVector(density_diff_relative)
-        diff_pointcloud.points = o3d.utility.Vector3dVector(ground_position)
-
-        # Normalize density differences and map them to RGB values
-        RGB, minval, maxval = _normalize(density_diff)
-        diff_pointcloud.colors = o3d.utility.Vector3dVector(np.array(RGB))
-
-        # Save the resulting point cloud
-        o3d.io.write_point_cloud(self.outputpath, diff_pointcloud, format='pts', compressed=True)
-
-        return diff_pointcloud
-
-    def ectraction_neighborpoints(self, pointcloud, target_positions):
-        """
-        Extracts the density of neighbor points for given target positions in a point cloud.
-
-        This function uses KDTree for efficient neighbor search.
-
-        Parameters
-        ----------
-        pointcloud : open3d.geometry.PointCloud
-            The input point cloud.
-        target_positions : numpy.ndarray
-            Array of positions to search for neighbors.
-
-        Returns
-        -------
-        numpy.ndarray
-            Array of densities (number of neighbor points) for each target position.
-        """
-        # Create a KDTree for neighbor point search
-        kdtree = o3d.geometry.KDTreeFlann(pointcloud)
-        radius = self.r  # Radius for neighbor search
+#         # Clip relative differences to a maximum of 100
+#         density_diff_relative = np.clip(density_diff_relative, 0, 100)
+
+#         # Apply the differences to the output point cloud
+#         diff_pointcloud.normals = o3d.utility.Vector3dVector(density_diff_relative)
+#         diff_pointcloud.points = o3d.utility.Vector3dVector(ground_position)
+
+#         # Normalize density differences and map them to RGB values
+#         RGB, minval, maxval = _normalize(density_diff)
+#         diff_pointcloud.colors = o3d.utility.Vector3dVector(np.array(RGB))
+
+#         # Save the resulting point cloud
+#         o3d.io.write_point_cloud(self.outputpath, diff_pointcloud, format='pts', compressed=True)
+
+#         return diff_pointcloud
+
+#     def ectraction_neighborpoints(self, pointcloud, target_positions):
+#         """
+#         Extracts the density of neighbor points for given target positions in a point cloud.
+
+#         This function uses KDTree for efficient neighbor search.
+
+#         Parameters
+#         ----------
+#         pointcloud : open3d.geometry.PointCloud
+#             The input point cloud.
+#         target_positions : numpy.ndarray
+#             Array of positions to search for neighbors.
+
+#         Returns
+#         -------
+#         numpy.ndarray
+#             Array of densities (number of neighbor points) for each target position.
+#         """
+#         # Create a KDTree for neighbor point search
+#         kdtree = o3d.geometry.KDTreeFlann(pointcloud)
+#         radius = self.r  # Radius for neighbor search
         
-        all_indices = []  # List to store indices of neighbors
-        for pos in tqdm(target_positions, desc="Extracting neighbor points"):
-            [k, idx, _] = kdtree.search_radius_vector_3d(pos, radius)
-            if np.asarray(idx).shape[0] == 0:
-                index = [0]
-            elif np.asarray(idx).shape[0] == 1:
-                index = idx
-            else:
-                index = [np.asarray(idx)[0]]
-            all_indices.extend([index])
-
-        # Extract neighbor densities
-        neighbor_density = np.asarray(pointcloud.normals)[all_indices, :][:, 0]
-        neighbor_density_array = np.asarray(neighbor_density)
-        return neighbor_density_array
+#         all_indices = []  # List to store indices of neighbors
+#         for pos in tqdm(target_positions, desc="Extracting neighbor points"):
+#             [k, idx, _] = kdtree.search_radius_vector_3d(pos, radius)
+#             if np.asarray(idx).shape[0] == 0:
+#                 index = [0]
+#             elif np.asarray(idx).shape[0] == 1:
+#                 index = idx
+#             else:
+#                 index = [np.asarray(idx)[0]]
+#             all_indices.extend([index])
+
+#         # Extract neighbor densities
+#         neighbor_density = np.asarray(pointcloud.normals)[all_indices, :][:, 0]
+#         neighbor_density_array = np.asarray(neighbor_density)
+#         return neighbor_density_array
   
-def _normalize(self,data):
-    """
-    Min-Maxスケーリングを使用してデータを正規化します。
-    """
-    min_val = np.min(data)
-    max_val = np.max(data)
-    normalized_data = [(x - min_val) / (max_val - min_val) for x in data]
-    return normalized_data, min_val, max_val
+# def _normalize(data):
+#     """
+#     Min-Maxスケーリングを使用してデータを正規化します。
+#     """
+#     min_val = np.min(data)
+#     max_val = np.max(data)
+#     normalized_data = [(x - min_val) / (max_val - min_val) for x in data]
+#     return normalized_data, min_val, max_val
     
-def viewer(
-    pointcloud_path: str, vmax: float, vcentre: float, vmin: float, 
-    color: str, unit_colorbar: str, unit_xy: str, rho: float
-) -> None:
-    """
-    Visualizes a point cloud with color-coded density values as a scatter plot.
-
-    Parameters
-    ----------
-    pointcloud_path : str
-        Path to the point cloud file to be loaded.
-    vmax : float
-        Maximum value for the color scale. If None, it is set to the maximum of the normalized density.
-    vcentre : float
-        Center value for the color scale.
-    vmin : float
-        Minimum value for the color scale.
-    color : str
-        Colormap to use for visualization.
-    unit_colorbar : str
-        Label for the colorbar indicating the unit of the density values.
-    unit_xy : str
-        Label for the x and y axes indicating the unit of the coordinates.
-    rho : float
-        Normalization factor for density values.
-
-    Returns
-    -------
-    None
-        Displays a scatter plot of the point cloud with density visualized as colors.
-
-    Notes
-    -----
-    The density values are normalized by `rho`, and their statistics (max, min, mean, median) 
-    are printed to the console. The point cloud's x and y coordinates are used for the scatter plot.
-    """
-    # Load the point cloud
-    pointcloud = o3d.io.read_point_cloud(pointcloud_path)
-
-    # Extract coordinates and density values
-    x = np.asarray(pointcloud.points)[:, 0]
-    y = np.asarray(pointcloud.points)[:, 1]
-    density = np.asarray(pointcloud.normals)[:, 0]
-    density_nondim = density / rho  # Normalize density by rho
-
-    # Configure color normalization for the scatter plot
-    if vmax is None:
-        norm = Normalize(vmin=density_nondim.min(), vmax=density_nondim.max())
-    else:
-        # Use a TwoSlopeNorm for customized vmin, vcenter, and vmax
-        norm = mcolors.TwoSlopeNorm(vmin=vmin, vcenter=vcentre, vmax=vmax)
-
-    # Create figure and axes for the scatter plot
-    fig = plt.figure(figsize=(9, 6))
-    ax = fig.add_subplot(111)
-
-    # Plot the scatter plot
-    sc = ax.scatter(x, y, c=density_nondim, cmap=color, s=1, norm=norm)
-    ax.set_aspect('equal', adjustable='box')  # Set equal aspect ratio
-
-    # Add a colorbar to the plot
-    divider = mpl_toolkits.axes_grid1.make_axes_locatable(ax)
-    cax = divider.append_axes('right', '5%', pad=0.1)
-    cbar = plt.colorbar(sc, ax=ax, cax=cax, orientation='vertical')
-    cbar.set_label(unit_colorbar)  # Set colorbar label
-
-    # Set axis labels and titles
-    ax.set_xlabel(unit_xy)
-    ax.set_ylabel(unit_xy)
-
-    # Display the plot
-    plt.show()
-
-class array2pointcloud:
-    """
-    Converts a 2D array into a 3D point cloud with associated density and color information.
-
-    Parameters
-    ----------
-    px2mm_y : float
-        Conversion factor from pixels to millimeters along the y-axis.
-    px2mm_x : float
-        Conversion factor from pixels to millimeters along the x-axis.
-    array : np.array
-        Input 2D array representing pixel data.
-    ox : int
-        Origin offset in pixels along the x-axis.
-    oy : int
-        Origin offset in pixels along the y-axis.
-    outpath : str
-        Path where the resulting point cloud file will be saved.
-    Flip : bool
-        Whether to flip the array horizontally.
-
-    Attributes
-    ----------
-    data_px : np.array
-        The original or flipped array data in pixel units.
-    data_mm : np.array
-        Transformed data with coordinates in millimeter units and density as the fourth column.
-    points : np.array
-        3D points representing the x, y, and z coordinates.
-    density : np.array
-        Density values expanded for storing as normals.
-    RGB : np.array
-        RGB color values derived from the density data.
-
-    Methods
-    -------
-    __call__()
-        Executes the conversion process and saves the resulting point cloud.
-    px2mm_method()
-        Converts the pixel coordinates and density values to millimeter units.
-    reshaper()
-        Extracts and reshapes the 3D points, density, and RGB values.
-    set_array()
-        Assembles the data into an Open3D PointCloud object.
-    """
-    def __init__(self, px2mm_y: float, px2mm_x: float, array: np.array, 
-                 ox: int, oy: int, outpath: str, Flip: bool) -> None:
-        self.px2mm_x = px2mm_x
-        self.px2mm_y = px2mm_y
-        self.data_px = array
-        self.ox = ox
-        self.oy = oy
-        self.output_path = outpath
-        self.flip = Flip
-
-        # Initialize placeholders for processed data
-        self.data_mm = None
-        self.points = None
-        self.density = None
-        self.RGB = None
-
-    def __call__(self):
-        """
-        Executes the full conversion pipeline and saves the result as a point cloud.
-        """
-        self.px2mm_method()
-        self.reshaper()
-        pcd = self.set_array()
-        o3d.io.write_point_cloud(self.output_path, pcd, format='pts', compressed=True)
-
-    def px2mm_method(self):
-        """
-        Converts pixel-based coordinates to millimeter-based coordinates.
-
-        Notes
-        -----
-        If `self.flip` is True, the input array is flipped horizontally. The resulting
-        millimeter-based coordinates and density values are stored in `self.data_mm`.
-        """
-        if self.flip:
-            self.data_px = np.fliplr(self.data_px)
-
-        data_list = []
-        for i in range(self.data_px.shape[0]):
-            for j in range(self.data_px.shape[1]):
-                # Calculate millimeter coordinates and append density value
-                point = [float(self.px2mm_x * (j - self.ox)),
-                         float(self.px2mm_y * (i - self.oy)),
-                         0.0,  # z-coordinate is 0
-                         float(self.data_px[i, j])]
-                data_list.append(point)
-
-        self.data_mm = np.array(data_list)
-
-    def reshaper(self):
-        """
-        Reshapes the transformed data into points, density, and RGB values.
-
-        Notes
-        -----
-        Density values are tiled to create normals for the point cloud.
-        The `nm` function is used to normalize density values into RGB colors.
-        """
-        self.points = self.data_mm[:, :3]  # Extract 3D coordinates
-        self.density = np.tile(self.data_mm[:, 3], (3, 1)).T  # Expand density values
-        colors, _, _ = _normalize(self.density)  # Normalize density to RGB
-        self.RGB = np.array(colors)
-
-    def set_array(self):
-        """
-        Creates an Open3D PointCloud object from the processed data.
-
-        Returns
-        -------
-        pcd : o3d.geometry.PointCloud
-            The resulting point cloud object with points, colors, and normals.
-        """
-        pcd = o3d.geometry.PointCloud()
-        pcd.points = o3d.utility.Vector3dVector(self.points)
-        pcd.colors = o3d.utility.Vector3dVector(self.RGB)
-        pcd.normals = o3d.utility.Vector3dVector(self.density)
-
-        return pcd
+# def viewer(
+#     pointcloud_path: str, vmax: float, vcentre: float, vmin: float, 
+#     color: str, unit_colorbar: str, unit_xy: str, rho: float
+# ) -> None:
+#     """
+#     Visualizes a point cloud with color-coded density values as a scatter plot.
+
+#     Parameters
+#     ----------
+#     pointcloud_path : str
+#         Path to the point cloud file to be loaded.
+#     vmax : float
+#         Maximum value for the color scale. If None, it is set to the maximum of the normalized density.
+#     vcentre : float
+#         Center value for the color scale.
+#     vmin : float
+#         Minimum value for the color scale.
+#     color : str
+#         Colormap to use for visualization.
+#     unit_colorbar : str
+#         Label for the colorbar indicating the unit of the density values.
+#     unit_xy : str
+#         Label for the x and y axes indicating the unit of the coordinates.
+#     rho : float
+#         Normalization factor for density values.
+
+#     Returns
+#     -------
+#     None
+#         Displays a scatter plot of the point cloud with density visualized as colors.
+
+#     Notes
+#     -----
+#     The density values are normalized by `rho`, and their statistics (max, min, mean, median) 
+#     are printed to the console. The point cloud's x and y coordinates are used for the scatter plot.
+#     """
+#     # Load the point cloud
+#     pointcloud = o3d.io.read_point_cloud(pointcloud_path)
+
+#     # Extract coordinates and density values
+#     x = np.asarray(pointcloud.points)[:, 0]
+#     y = np.asarray(pointcloud.points)[:, 1]
+#     density = np.asarray(pointcloud.normals)[:, 0]
+#     density_nondim = density / rho  # Normalize density by rho
+
+#     # Configure color normalization for the scatter plot
+#     if vmax is None:
+#         norm = Normalize(vmin=density_nondim.min(), vmax=density_nondim.max())
+#     else:
+#         # Use a TwoSlopeNorm for customized vmin, vcenter, and vmax
+#         norm = mcolors.TwoSlopeNorm(vmin=vmin, vcenter=vcentre, vmax=vmax)
+
+#     # Create figure and axes for the scatter plot
+#     fig = plt.figure(figsize=(9, 6))
+#     ax = fig.add_subplot(111)
+
+#     # Plot the scatter plot
+#     sc = ax.scatter(x, y, c=density_nondim, cmap=color, s=1, norm=norm)
+#     ax.set_aspect('equal', adjustable='box')  # Set equal aspect ratio
+
+#     # Add a colorbar to the plot
+#     divider = mpl_toolkits.axes_grid1.make_axes_locatable(ax)
+#     cax = divider.append_axes('right', '5%', pad=0.1)
+#     cbar = plt.colorbar(sc, ax=ax, cax=cax, orientation='vertical')
+#     cbar.set_label(unit_colorbar)  # Set colorbar label
+
+#     # Set axis labels and titles
+#     ax.set_xlabel(unit_xy)
+#     ax.set_ylabel(unit_xy)
+
+#     # Display the plot
+#     plt.show()
+
+# class array2pointcloud:
+#     """
+#     Converts a 2D array into a 3D point cloud with associated density and color information.
+
+#     Parameters
+#     ----------
+#     px2mm_y : float
+#         Conversion factor from pixels to millimeters along the y-axis.
+#     px2mm_x : float
+#         Conversion factor from pixels to millimeters along the x-axis.
+#     array : np.array
+#         Input 2D array representing pixel data.
+#     ox : int
+#         Origin offset in pixels along the x-axis.
+#     oy : int
+#         Origin offset in pixels along the y-axis.
+#     outpath : str
+#         Path where the resulting point cloud file will be saved.
+#     Flip : bool
+#         Whether to flip the array horizontally.
+
+#     Attributes
+#     ----------
+#     data_px : np.array
+#         The original or flipped array data in pixel units.
+#     data_mm : np.array
+#         Transformed data with coordinates in millimeter units and density as the fourth column.
+#     points : np.array
+#         3D points representing the x, y, and z coordinates.
+#     density : np.array
+#         Density values expanded for storing as normals.
+#     RGB : np.array
+#         RGB color values derived from the density data.
+
+#     Methods
+#     -------
+#     __call__()
+#         Executes the conversion process and saves the resulting point cloud.
+#     px2mm_method()
+#         Converts the pixel coordinates and density values to millimeter units.
+#     reshaper()
+#         Extracts and reshapes the 3D points, density, and RGB values.
+#     set_array()
+#         Assembles the data into an Open3D PointCloud object.
+#     """
+#     def __init__(self, px2mm_y: float, px2mm_x: float, array: np.array, 
+#                  ox: int, oy: int, outpath: str, Flip: bool) -> None:
+#         self.px2mm_x = px2mm_x
+#         self.px2mm_y = px2mm_y
+#         self.data_px = array
+#         self.ox = ox
+#         self.oy = oy
+#         self.output_path = outpath
+#         self.flip = Flip
+
+#         # Initialize placeholders for processed data
+#         self.data_mm = None
+#         self.points = None
+#         self.density = None
+#         self.RGB = None
+
+#     def __call__(self):
+#         """
+#         Executes the full conversion pipeline and saves the result as a point cloud.
+#         """
+#         self.px2mm_method()
+#         self.reshaper()
+#         pcd = self.set_array()
+#         o3d.io.write_point_cloud(self.output_path, pcd, format='pts', compressed=True)
+
+#     def px2mm_method(self):
+#         """
+#         Converts pixel-based coordinates to millimeter-based coordinates.
+
+#         Notes
+#         -----
+#         If `self.flip` is True, the input array is flipped horizontally. The resulting
+#         millimeter-based coordinates and density values are stored in `self.data_mm`.
+#         """
+#         if self.flip:
+#             self.data_px = np.fliplr(self.data_px)
+
+#         data_list = []
+#         for i in range(self.data_px.shape[0]):
+#             for j in range(self.data_px.shape[1]):
+#                 # Calculate millimeter coordinates and append density value
+#                 point = [float(self.px2mm_x * (j - self.ox)),
+#                          float(self.px2mm_y * (i - self.oy)),
+#                          0.0,  # z-coordinate is 0
+#                          float(self.data_px[i, j])]
+#                 data_list.append(point)
+
+#         self.data_mm = np.array(data_list)
+
+#     def reshaper(self):
+#         """
+#         Reshapes the transformed data into points, density, and RGB values.
+
+#         Notes
+#         -----
+#         Density values are tiled to create normals for the point cloud.
+#         The `nm` function is used to normalize density values into RGB colors.
+#         """
+#         self.points = self.data_mm[:, :3]  # Extract 3D coordinates
+#         self.density = np.tile(self.data_mm[:, 3], (3, 1)).T  # Expand density values
+#         colors, _, _ = _normalize(self.density)  # Normalize density to RGB
+#         self.RGB = np.array(colors)
+
+#     def set_array(self):
+#         """
+#         Creates an Open3D PointCloud object from the processed data.
+
+#         Returns
+#         -------
+#         pcd : o3d.geometry.PointCloud
+#             The resulting point cloud object with points, colors, and normals.
+#         """
+#         pcd = o3d.geometry.PointCloud()
+#         pcd.points = o3d.utility.Vector3dVector(self.points)
+#         pcd.colors = o3d.utility.Vector3dVector(self.RGB)
+#         pcd.normals = o3d.utility.Vector3dVector(self.density)
+
+#         return pcd

BOSlib/shift.py

@@ -1,8 +1,12 @@
 from skimage.metrics import structural_similarity as ssm
 import numpy as np
 from PIL import Image
+from scipy import signal
+import pandas as pd
+
 import BOSlib.shift_utils as ib
 
+
 def SSIM(ref_array : np.ndarray, exp_array : np.ndarray):
     """
     Compute the inverted Structural Similarity Index (SSIM) difference matrix between two grayscale images.
@@ -80,11 +84,11 @@ def SP_BOS(ref_array : np.ndarray, exp_array : np.ndarray, binarization : str ="
         bin_ref = ib._biner_thresh(ar_ref, thresh)
         bin_exp = ib._biner_thresh(ar_exp, thresh)
 
-        print("Binarization",bin_ref.shape,bin_exp.shape)
+        #print("Binarization",bin_ref.shape,bin_exp.shape)
     elif binarization =="HPfilter":
         bin_ref=ib._biner_HP(ar_ref, freq)
         bin_exp=ib._biner_HP(ar_exp, freq)
-        print("Binarization",bin_ref.shape,bin_exp.shape)
+        #print("Binarization",bin_ref.shape,bin_exp.shape)
     else:
         raise ValueError("Binarization is thresh or HPfilter")
     
@@ -92,25 +96,25 @@ def SP_BOS(ref_array : np.ndarray, exp_array : np.ndarray, binarization : str ="
     ref_u, ref_d = ib._bin_indexer(bin_ref)
     ref_u = np.nan_to_num(ref_u)
     ref_d = np.nan_to_num(ref_d)
-    print("bin_indexer_ref",ref_u.shape,ref_d.shape)
+    #print("bin_indexer_ref",ref_u.shape,ref_d.shape)
     # Detect the coordinates of the color boundaries in the binarized experimental image
     # u represents the upper boundary of the white stripe, d represents the lower boundary
     exp_u, exp_d = ib._bin_indexer(bin_exp)
     exp_u = np.nan_to_num(exp_u)
     exp_d = np.nan_to_num(exp_d)
-    print("bin_indexer_exp",exp_u.shape,exp_d.shape)
+    #print("bin_indexer_exp",exp_u.shape,exp_d.shape)
 
     # Remove data with abnormally large displacements as noise
     ref_u, exp_u = ib._noize_reducer_2(ref_u, exp_u, 10)
     ref_d, exp_d = ib._noize_reducer_2(ref_d, exp_d, 10)
-    print("noize_reducer_2",exp_u.shape,exp_d.shape)
-    print("noize_reducer_2",ref_u.shape,ref_d.shape)
+    #print("noize_reducer_2",exp_u.shape,exp_d.shape)
+    #print("noize_reducer_2",ref_u.shape,ref_d.shape)
     
     # Combine the upper and lower boundary data to calculate the center of the stripe
     ref = ib._mixing(ref_u, ref_d)
     exp = ib._mixing(exp_u, exp_d)
 
-    print("mixing",ref.shape,exp.shape)
+    #print("mixing",ref.shape,exp.shape)
     
     # Calculate displacement (upward displacement is positive)
     diff = -(exp - ref)
@@ -118,9 +122,243 @@ def SP_BOS(ref_array : np.ndarray, exp_array : np.ndarray, binarization : str ="
     # Rearrange the displacement values into the correct positions and interpolate gaps
     diff_comp = ib._complementer(ref, diff)
 
-    print("complementer",diff_comp.shape)
+    #print("complementer",diff_comp.shape)
     
     # Subtract the overall background movement by dividing by the mean displacement
     diff_comp = diff_comp - np.nanmean(diff_comp[0:1000, 10:100])
 
     return diff_comp
+
+def S_BOS(ref_array: np.ndarray, exp_array: np.ndarray,freq_sample_row : int = 0):
+    """
+    Compute a 1D BOS displacement field by estimating phase differences
+    between reference and experimental stripe signals.
+
+    This function first identifies the dominant stripe frequency via FFT
+    from a representative row (`freq_sample_area`) of `ref_array`. Then for
+    each column signal it:
+      1. Bandpass-filters around the base frequency.
+      2. Normalizes amplitude and applies a sine-based phase correction.
+      3. Calculates the local phase difference via lowpass filtered
+         sine/cosine products.
+      4. Converts phase shifts to physical displacement values.
+
+    Parameters
+    ----------
+    ref_array : np.ndarray, shape (M, N)
+        Reference image signals, with M samples (rows) and N separate
+        stripe‐signal columns.
+    exp_array : np.ndarray, shape (M, N)
+        Experimental image signals matching the dimensions of `ref_array`.
+    freq_sample_row : int
+        Row index in `ref_array` used to detect the dominant stripe frequency
+        for filtering and phase calculation.
+
+    Returns
+    -------
+    delta_h : np.ndarray, shape (M, N)
+        Displacement field (Δh) computed from the phase differences between
+        each column of `ref_array` and `exp_array`. Units are cycles/(2π·f),
+        where f is the dominant stripe frequency.
+    """
+    def freq_finder(sig):
+        """
+        Identify the dominant frequency in the signal using the FFT.
+        
+        Parameters:
+        -----------
+        sig : np.ndarray
+            1D numpy array representing a signal.
+            
+        Returns:
+        --------
+        float
+            The dominant frequency (above 0.01 Hz) based on amplitude.
+        """
+        # Compute FFT frequencies
+        freq = np.fft.fftfreq(sig.shape[0])
+        # Compute FFT of the signal and normalize the amplitude
+        fk = np.fft.fft(sig)
+        fk = abs(fk / (sig.shape[0] / 2))
+        # Combine frequencies and amplitudes into a DataFrame
+        fk_df = pd.DataFrame(np.vstack([freq, fk]).T, columns=["freq", "amp"])
+        # Sort DataFrame by frequency and keep only non-negative frequencies
+        fk_df = fk_df.sort_values('freq')
+        fk_df = fk_df[fk_df["freq"] >= 0]
+        # Select frequencies above 0.01 Hz and sort by amplitude in descending order
+        freq_search = fk_df[fk_df["freq"] >= 0.01].sort_values('amp', ascending=False)
+        # Return the frequency corresponding to the highest amplitude
+        return freq_search.iloc[0, 0]
+
+    def bandpass(x, fa, fb):
+        """
+        Apply a bandpass Butterworth filter to the signal.
+        
+        Parameters:
+        -----------
+        x : np.ndarray
+            Input signal.
+        fa : float
+            Lower cutoff frequency multiplier.
+        fb : float
+            Upper cutoff frequency multiplier.
+            
+        Returns:
+        --------
+        np.ndarray
+            The bandpass-filtered signal.
+        """
+        gpass, gstop = 2, 60  # Passband and stopband gains (dB)
+        fp, fs = np.array([fa, fb]), np.array([fa / 2, fb * 2])
+        fn = 1 / 2  # Nyquist frequency (assuming a normalized sample rate)
+        wp, ws = fp / fn, fs / fn
+        # Determine the minimum filter order that meets the specifications
+        N, Wn = signal.buttord(wp, ws, gpass, gstop)
+        # Get the filter coefficients for a Butterworth filter
+        b, a = signal.butter(N, Wn, "band")
+        # Apply the filter forward and backward to avoid phase distortion
+        return signal.filtfilt(b, a, x)
+
+    def lowpass(x, lowcut):
+        """
+        Apply a lowpass Butterworth filter to the signal.
+        
+        Parameters:
+        -----------
+        x : np.ndarray
+            Input signal.
+        lowcut : float
+            The low cutoff frequency.
+            
+        Returns:
+        --------
+        np.ndarray
+            The lowpass-filtered signal.
+        """
+        order, nyq = 8, 0.5 * 1  # Order and Nyquist frequency (assuming sample rate = 1)
+        low = lowcut / nyq
+        # Get the filter coefficients for a lowpass Butterworth filter
+        b, a = signal.butter(order, low, btype='low')
+        # Apply the filter with zero-phase distortion
+        return signal.filtfilt(b, a, x)
+
+    def signal_separate(sig, f1):
+        """
+        Separate the signal into a constant (mean) component and a bandpass-filtered component.
+        
+        Parameters:
+        -----------
+        sig : np.ndarray
+            Input signal.
+        f1 : float
+            Base frequency used to define the bandpass range.
+            
+        Returns:
+        --------
+        np.ndarray
+            2D array where the first column is the signal mean and the second column is the bandpass-filtered signal.
+        """
+        sig_f = np.zeros([sig.shape[0], 2])
+        # First column: constant value equal to the mean of the signal
+        sig_f[:, 0] = sig.mean()
+        # Second column: bandpass filtered signal using a frequency window around f1
+        sig_f[:, 1] = bandpass(sig, f1 * 0.7, f1 * 1.5)
+        return sig_f
+
+    def signal_scale_normalize(sig, f):
+        """
+        Normalize the signal based on a rolling maximum amplitude and add a sine correction.
+        
+        Parameters:
+        -----------
+        sig : np.ndarray
+            Input signal.
+        f : float
+            Frequency used to calculate the sine correction.
+            
+        Returns:
+        --------
+        np.ndarray
+            The normalized signal.
+        """
+        # Calculate the rolling maximum absolute value over a window of 0.5/f samples
+        sig_abs = np.array(pd.Series(abs(sig)).rolling(int(0.5 / f), center=True).max())
+        # Suppress parts of the signal where the amplitude is significantly below the mean
+        sig[sig_abs < np.nanmean(sig_abs) * 0.5] = 0
+        y = np.arange(0, sig.shape[0], 1)
+        # Generate a sine wave for phase correction
+        S = np.sin(2 * np.pi * f * y)
+        # Create a correction term based on the amplitude threshold
+        S1 = (1 - (sig_abs > np.nanmean(sig_abs * 0.5))) * S
+        # Add the correction term to the signal
+        sig = sig + S1
+        # Avoid division by very small numbers
+        sig_abs[sig_abs < np.nanmean(sig_abs * 0.5)] = 1
+        # Normalize the signal
+        sig_norm = sig / sig_abs
+        sig_norm[np.isnan(sig_norm)] = 0
+        return sig_norm
+
+    def phase_calculate(ref, exp, f1):
+        """
+        Calculate the phase difference between the reference and experimental signals.
+        
+        Parameters:
+        -----------
+        ref : np.ndarray
+            Normalized reference signal.
+        exp : np.ndarray
+            Normalized experimental signal.
+        f1 : float
+            Base frequency.
+            
+        Returns:
+        --------
+        np.ndarray
+            The phase difference calculated using lowpass filtered sine and cosine components.
+        """
+        # Compute sine and its gradient (approximation for cosine)
+        sin_ref = ref
+        cos_ref = np.gradient(ref) / (f1 * 2 * np.pi)
+        # Compute lowpass filtered products to obtain sine and cosine components of the phase difference
+        cos_phi = lowpass(sin_ref * exp, f1)
+        sin_phi = lowpass(cos_ref * exp, f1)
+        # Calculate the phase difference using arctan2 for correct quadrant determination
+        return np.arctan2(sin_phi, cos_phi)
+
+    def phase_1DBOS_process(sig_ref, sig_exp, f1):
+        """
+        Process a pair of reference and experimental signals to compute the phase difference.
+        
+        Parameters:
+        -----------
+        sig_ref : np.ndarray
+            Single column from the reference signal array.
+        sig_exp : np.ndarray
+            Corresponding column from the experimental signal array.
+        f1 : float
+            Base frequency obtained from the reference array.
+            
+        Returns:
+        --------
+        np.ndarray
+            The phase difference between the processed reference and experimental signals.
+        """
+        # Separate the signal into mean and bandpass-filtered components and normalize them
+        separate_sig_ref = signal_scale_normalize(signal_separate(sig_ref, f1)[:, 1], f1)
+        separate_sig_exp = signal_scale_normalize(signal_separate(sig_exp, f1)[:, 1], f1)
+        # Calculate the phase difference between the normalized signals
+        return phase_calculate(separate_sig_ref, separate_sig_exp, f1)
+
+    # Determine the dominant frequency from a representative column (column 100) of the reference array
+    f1 = freq_finder(ref_array[:,freq_sample_row])
+    # Initialize a 2D array to store phase differences for each column
+    phi_2D = np.zeros([ref_array.shape[0], ref_array.shape[1]]).astype("float64")
+    
+    # Process each column of the reference and experimental arrays
+    for x in range(ref_array.shape[1]):
+        phi_2D[:, x] = phase_1DBOS_process(ref_array[:, x], exp_array[:, x], f1)
+    
+    # Convert phase differences into displacement by dividing by (2*pi*f1)
+    delta_h = phi_2D / (2 * np.pi * f1)
+    return delta_h

{BOSlib-0.0.1.dist-info → BOSlib-0.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: BOSlib
-Version: 0.0.1
+Version: 0.0.4
 Summary: the library of Background Oriented Schlieren
 Home-page: https://github.com/ogayuuki0202/BOSlib
 Download-URL: https://github.com/ogayuuki0202/BOSlib

BOSlib-0.0.4.dist-info/RECORD

@@ -0,0 +1,13 @@
+BOSlib/__init__.py,sha256=00N8-Ti4_R4lmLuqi08jwokhPvlvudBQXpHRZveEtds,225
+BOSlib/culculate_refractiveindex.py,sha256=v-yIZEtsJchOjO7RFIR3XU4mCYdmbGxKjar03OC5MsA,3421
+BOSlib/evaluation.py,sha256=Ipf5TUXFRuVlwILucJRyqZRazS02Wb7QQ6okXw-P4Vs,12809
+BOSlib/reconstruction.py,sha256=qBxid-wJfsyTfKK1EWa6NejxJ7lHA1HEeIRV6743k98,6545
+BOSlib/reconstruction_utils.py,sha256=hoJQ9crumwdLvmOkIpWasADi2H3-3272P3QPhTrcWu8,1809
+BOSlib/shift.py,sha256=fa0QxJXuBUELOmLLT2dB_uNaWMU5oxeTI0ZScZx5c5c,14877
+BOSlib/shift_utils.py,sha256=XZ7cwKWV6gkPBcWDkhgU34fRNt1nxAFJNZqC42NIqbk,9397
+BOSlib/utils.py,sha256=ceuHxQmvIsx6z2iudQC9j3SVpQ0m9myTBXuWf6C1eMs,6934
+BOSlib-0.0.4.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+BOSlib-0.0.4.dist-info/METADATA,sha256=beniVbiXOpdcT5iQgI4Lh6l9Xe6wFH46-2hLDq6ffYI,3458
+BOSlib-0.0.4.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+BOSlib-0.0.4.dist-info/top_level.txt,sha256=ZLqE8iduIk6Ng-LYGvz_faKu-yW4JJwjJpOsXDfBo14,7
+BOSlib-0.0.4.dist-info/RECORD,,

BOSlib-0.0.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-BOSlib/__init__.py,sha256=kb_Iy46y664fgo_rYX3A3DnWzsLsMYXPRD3X5SW4-ik,225
-BOSlib/culculate_refractiveindex.py,sha256=v-yIZEtsJchOjO7RFIR3XU4mCYdmbGxKjar03OC5MsA,3421
-BOSlib/evaluation.py,sha256=c0AtR9jz3ShYI-C4PAsHanZAXIsX1d-Le1wdO-fVh0c,12241
-BOSlib/reconstruction.py,sha256=qBxid-wJfsyTfKK1EWa6NejxJ7lHA1HEeIRV6743k98,6545
-BOSlib/reconstruction_utils.py,sha256=hoJQ9crumwdLvmOkIpWasADi2H3-3272P3QPhTrcWu8,1809
-BOSlib/shift.py,sha256=tKBFo-rEPj9BX4070LGdYYRUttRZs1yhJBDwQyWIb0g,5631
-BOSlib/shift_utils.py,sha256=XZ7cwKWV6gkPBcWDkhgU34fRNt1nxAFJNZqC42NIqbk,9397
-BOSlib/utils.py,sha256=ceuHxQmvIsx6z2iudQC9j3SVpQ0m9myTBXuWf6C1eMs,6934
-BOSlib-0.0.1.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-BOSlib-0.0.1.dist-info/METADATA,sha256=KdnGZNLmiH4x80Uc_sUz6EWzEPP7QCY_7VCk0PacoqY,3458
-BOSlib-0.0.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-BOSlib-0.0.1.dist-info/top_level.txt,sha256=ZLqE8iduIk6Ng-LYGvz_faKu-yW4JJwjJpOsXDfBo14,7
-BOSlib-0.0.1.dist-info/RECORD,,