BOSlib 0.0.1__tar.gz → 0.0.3__tar.gz

{boslib-0.0.1 → boslib-0.0.3}/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.3'

boslib-0.0.3/BOSlib/evaluation.py

@@ -0,0 +1,344 @@
+#import open3d as o3d
+import numpy as np
+from tqdm import tqdm
+import matplotlib.pyplot as plt
+from matplotlib.colors import Normalize
+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()
+        
+#         # 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
+        
+#         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(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

boslib-0.0.3/BOSlib/shift.py

@@ -0,0 +1,351 @@
+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.
+
+    Parameters
+    ----------
+    ref_array : np.ndarray
+        The reference grayscale image array.
+    exp_array : np.ndarray
+        The experimental grayscale image array.
+
+    Returns
+    -------
+    np.ndarray
+        The inverted SSIM difference matrix, where higher values indicate greater dissimilarity between the two images.
+    """
+    # Compute the structural similarity matrix (SSM) on the grayscale images
+    (score, diff) = ssm(ref_array, exp_array, full=True)
+    diff_inv = -diff
+    return diff_inv
+
+def SP_BOS(ref_array : np.ndarray, exp_array : np.ndarray, binarization : str ="HPfilter", thresh : int = 128, freq : int = 500):
+    """
+    Calculate the displacement map of stripe patterns in experimental images using the Background Oriented Schlieren (BOS) method.
+    
+    This function computes the relative displacement between stripes in a reference and experimental image by compensating for background movement and noise. The displacement map is calculated by processing the images through several steps including image resizing, binarization, boundary detection, noise reduction, displacement calculation, and background compensation.
+
+    Parameters
+    ----------
+    ref_array : np.ndarray
+        The reference grayscale image array. This image represents the original, undisturbed pattern.
+        
+    exp_array : np.ndarray
+        The experimental grayscale image array. This image represents the pattern after deformation due to external factors.
+        
+    binarization : str, optional, default="HPfilter"
+        The method used for binarization of the images. Options are:
+        - "thresh" : Use thresholding for binarization.
+        - "HPfilter" : Use high-pass filtering for binarization.
+        
+    thresh : int, optional, default=128
+        The threshold value used for binarization when `binarization="thresh"`. Pixels with values above the threshold are set to 1, and those below are set to 0.
+        
+    freq : int, optional, default=500
+        The frequency parameter used for high-pass filtering when `binarization="HPfilter"`.
+
+    Returns
+    -------
+    np.ndarray
+        A 2D array representing the displacement map of the stripe patterns, with background movement compensated. Each value represents the relative displacement between the reference and experimental images, with noise and background displacements removed.
+
+    Notes
+    -----
+    The method performs the following steps:
+    1. Vertically stretches both the reference and experimental images by a factor of 10.
+    2. Binarizes the images using either thresholding or high-pass filtering.
+    3. Identifies the upper and lower boundaries of the stripes and calculates their centers for both images.
+    4. Filters out noise by removing displacements larger than a certain threshold.
+    5. Computes the displacement between the stripe centers.
+    6. Compensates for background movement by normalizing the displacement map, subtracting the mean displacement over a specified region.
+    """
+ 
+    im_ref=Image.fromarray(ref_array)
+    im_exp=Image.fromarray(exp_array)
+
+    #streach the image vertivally *10
+    im_ref=im_ref.resize((im_ref.size[0],im_ref.size[1]*10))
+    im_exp=im_exp.resize((im_exp.size[0],im_exp.size[1]*10))
+
+    ar_ref=np.array(im_ref)
+    ar_exp=np.array(im_exp)
+
+    if binarization =="thresh":
+        # Binarization
+        bin_ref = ib._biner_thresh(ar_ref, thresh)
+        bin_exp = ib._biner_thresh(ar_exp, thresh)
+
+        #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)
+    else:
+        raise ValueError("Binarization is thresh or HPfilter")
+    
+    # Detect the coordinates of the color boundaries in the binarized reference image
+    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)
+    # 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)
+
+    # 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)
+    
+    # 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)
+    
+    # Calculate displacement (upward displacement is positive)
+    diff = -(exp - ref)
+    
+    # Rearrange the displacement values into the correct positions and interpolate gaps
+    diff_comp = ib._complementer(ref, diff)
+
+    #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_area):
+    """
+    Compute the phase difference and corresponding displacement (delta_h) 
+    between reference and experimental signal arrays using a 1D Background 
+    Oriented Schlieren (BOS) process.
+
+    Parameters:
+    -----------
+    ref_array : np.ndarray
+        2D numpy array containing reference signals, where each column is a distinct signal.
+    exp_array : np.ndarray
+        2D numpy array containing experimental signals, matching the dimensions of ref_array.
+
+    Returns:
+    --------
+    delta_h : np.ndarray
+        2D numpy array representing the displacement computed from the phase differences.
+    """
+    
+    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_area])
+    # 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 → boslib-0.0.3}/BOSlib.egg-info/PKG-INFO

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

{boslib-0.0.1 → boslib-0.0.3}/PKG-INFO

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

boslib-0.0.1/BOSlib/evaluation.py

@@ -1,344 +0,0 @@
-import open3d as o3d
-import numpy as np
-from tqdm import tqdm
-import matplotlib.pyplot as plt
-from matplotlib.colors import Normalize
-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()
-        
-        # 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
-        
-        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 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-0.0.1/BOSlib/shift.py

@@ -1,126 +0,0 @@
-from skimage.metrics import structural_similarity as ssm
-import numpy as np
-from PIL import Image
-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.
-
-    Parameters
-    ----------
-    ref_array : np.ndarray
-        The reference grayscale image array.
-    exp_array : np.ndarray
-        The experimental grayscale image array.
-
-    Returns
-    -------
-    np.ndarray
-        The inverted SSIM difference matrix, where higher values indicate greater dissimilarity between the two images.
-    """
-    # Compute the structural similarity matrix (SSM) on the grayscale images
-    (score, diff) = ssm(ref_array, exp_array, full=True)
-    diff_inv = -diff
-    return diff_inv
-
-def SP_BOS(ref_array : np.ndarray, exp_array : np.ndarray, binarization : str ="HPfilter", thresh : int = 128, freq : int = 500):
-    """
-    Calculate the displacement map of stripe patterns in experimental images using the Background Oriented Schlieren (BOS) method.
-    
-    This function computes the relative displacement between stripes in a reference and experimental image by compensating for background movement and noise. The displacement map is calculated by processing the images through several steps including image resizing, binarization, boundary detection, noise reduction, displacement calculation, and background compensation.
-
-    Parameters
-    ----------
-    ref_array : np.ndarray
-        The reference grayscale image array. This image represents the original, undisturbed pattern.
-        
-    exp_array : np.ndarray
-        The experimental grayscale image array. This image represents the pattern after deformation due to external factors.
-        
-    binarization : str, optional, default="HPfilter"
-        The method used for binarization of the images. Options are:
-        - "thresh" : Use thresholding for binarization.
-        - "HPfilter" : Use high-pass filtering for binarization.
-        
-    thresh : int, optional, default=128
-        The threshold value used for binarization when `binarization="thresh"`. Pixels with values above the threshold are set to 1, and those below are set to 0.
-        
-    freq : int, optional, default=500
-        The frequency parameter used for high-pass filtering when `binarization="HPfilter"`.
-
-    Returns
-    -------
-    np.ndarray
-        A 2D array representing the displacement map of the stripe patterns, with background movement compensated. Each value represents the relative displacement between the reference and experimental images, with noise and background displacements removed.
-
-    Notes
-    -----
-    The method performs the following steps:
-    1. Vertically stretches both the reference and experimental images by a factor of 10.
-    2. Binarizes the images using either thresholding or high-pass filtering.
-    3. Identifies the upper and lower boundaries of the stripes and calculates their centers for both images.
-    4. Filters out noise by removing displacements larger than a certain threshold.
-    5. Computes the displacement between the stripe centers.
-    6. Compensates for background movement by normalizing the displacement map, subtracting the mean displacement over a specified region.
-    """
- 
-    im_ref=Image.fromarray(ref_array)
-    im_exp=Image.fromarray(exp_array)
-
-    #streach the image vertivally *10
-    im_ref=im_ref.resize((im_ref.size[0],im_ref.size[1]*10))
-    im_exp=im_exp.resize((im_exp.size[0],im_exp.size[1]*10))
-
-    ar_ref=np.array(im_ref)
-    ar_exp=np.array(im_exp)
-
-    if binarization =="thresh":
-        # Binarization
-        bin_ref = ib._biner_thresh(ar_ref, thresh)
-        bin_exp = ib._biner_thresh(ar_exp, thresh)
-
-        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)
-    else:
-        raise ValueError("Binarization is thresh or HPfilter")
-    
-    # Detect the coordinates of the color boundaries in the binarized reference image
-    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)
-    # 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)
-
-    # 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)
-    
-    # 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)
-    
-    # Calculate displacement (upward displacement is positive)
-    diff = -(exp - ref)
-    
-    # Rearrange the displacement values into the correct positions and interpolate gaps
-    diff_comp = ib._complementer(ref, diff)
-
-    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