BOSlib 0.0.1__py3-none-any.whl

BOSlib/__init__.py

@@ -0,0 +1,9 @@
+from .shift import *
+from .shift_utils import *
+from .utils import *
+from .reconstruction import *
+from .reconstruction_utils import *
+from .culculate_refractiveindex import *
+from .evaluation  import *
+
+__version__ = '0.0.1'

BOSlib/culculate_refractiveindex.py

@@ -0,0 +1,89 @@
+from tqdm.contrib import tenumerate
+from tqdm import tqdm
+import numpy as np
+
+def SOR_2D(array_laplacian: np.ndarray,omega_SOR: float,e: float,tolerance:float =1e-24,max_stable_iters:int=1000000):
+    """
+    Performs the Successive Over-Relaxation (SOR) method on a 2D Laplacian array to solve for steady-state solutions 
+    within each slice of the array.
+
+    Parameters
+    ----------
+    array_laplacian : np.ndarray
+        A 3D numpy array where each slice represents a 2D Laplacian grid to be solved.
+    omega_SOR : float
+        The relaxation factor for the SOR method. Values between 1 and 2 can speed up convergence.
+    e : float
+        The convergence tolerance threshold for each slice. Iterations stop once the change (`delta`) 
+        falls below this threshold.
+    tolerance : float, optional
+        The tolerance level to determine stability in convergence. Defaults to 1e-24.
+    max_stable_iters : int, optional
+        The maximum number of stable iterations allowed per slice before termination, regardless of convergence. 
+        Defaults to 1000000.
+
+    Returns
+    -------
+    np.ndarray
+        A 3D numpy array containing the steady-state solution `u` for each 2D slice in `array_laplacian`.
+
+    Notes
+    -----
+    - The SOR method updates each element in the `u` array by considering its neighbors and applying the 
+      relaxation factor `omega_SOR`.
+    - Boundaries are fixed to zero for each slice, enforcing Dirichlet boundary conditions.
+    - Convergence for each slice stops either when `delta` is less than `e` or after a stable count of 
+      iterations (determined by `tolerance` and `max_stable_iters`) has been reached.
+
+    Examples
+    --------
+    >>> laplacian = np.random.rand(10, 100, 100)  # 10 slices of 100x100 grids
+    >>> solution = SOR_2D(laplacian, omega_SOR=1.5, e=1e-6)
+    >>> print(solution.shape)
+    (10, 100, 100)
+    """
+    Lx=array_laplacian.shape[0]
+    Ly=array_laplacian.shape[1]
+    Lz=array_laplacian.shape[2]
+    delta = 1.0
+    n_iter=0
+    u_list=[]
+    stable_count = 0  # Reset stable count for each batch
+    prev_delta = float('inf')  # Initialize previous delta
+    for slice_laplacian in tqdm(array_laplacian,desc="slice",leave=True):
+        u=np.zeros([Ly,Lz])
+        delta = 1.0
+        n_iter=0
+        while delta > e and stable_count < max_stable_iters:
+            u_in=u.copy()
+            delta = np.max(abs(u-u_in))
+            n_iter+=1
+            # Perform SOR update on the inner region
+            u[1:-1, 1:-1] = u[1:-1, 1:-1] + omega_SOR * (
+                (u_in[2:, 1:-1] + u_in[ :-2, 1:-1] + u_in[1:-1, 2:] + u_in[1:-1, :-2] 
+                 + slice_laplacian[1:-1, 1:-1]) / 4 - u[1:-1, 1:-1]
+            )
+
+            u[0][:]=0
+            u[Ly-1][:]=0
+            u[:][0]=0
+            u[:][Lz-1]=0
+
+            delta=np.max(abs(u-u_in))            
+            # Check if residual change is within tolerance to count as stable
+            if abs(delta - prev_delta) < tolerance:
+                stable_count += 1
+            else:
+                stable_count = 0
+
+            prev_delta = delta  # Update previous delta for next iteration
+
+            # Print iteration information
+            print("\r", f'Iteration: {n_iter}, Residual: {delta} Stable Count: {stable_count}', end="")
+
+            # Update iteration count
+            n_iter += 1
+
+        u_list.append(u)
+
+    return np.array(u_list)

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(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/reconstruction.py

@@ -0,0 +1,167 @@
+import numpy as np
+from tqdm import tqdm
+from tqdm.contrib import tzip      
+from skimage.transform import radon, iradon                        
+
+def abel_transform(angle: np.ndarray, center: float, winy0: int, winy1: int, winx0: int, winx1: int) -> np.ndarray:
+    """
+    Perform the Abel transform to convert refractive angle values into density differences.
+
+    This function applies the Abel transform on a 2D array of refractive angles. It compensates
+    for background movement by subtracting the mean value at a reference x-coordinate, calculates
+    distances from the center axis, and integrates to derive density differences using the
+    Gladstone-Dale constant.
+
+    Parameters
+    ----------
+    angle : np.ndarray
+        A 2D numpy array representing refractive angles for each pixel.
+    center : float
+        The index along the y-axis corresponding to the central axis of the transform.
+    winy0 : int
+        The starting index along the y-axis for the region used to calculate the background mean.
+    winy1 : int
+        The ending index along the y-axis for the region used to calculate the background mean.
+    winx0 : int
+        The starting index along the x-axis for the region used to calculate the background mean.
+    winx1 : int
+        The ending index along the x-axis for the region used to calculate the background mean.
+
+    Returns
+    -------
+    np.ndarray
+        A 2D array of refractive index differences derived from the Abel transform.
+
+    Notes
+    -----
+    This function calculates density differences through an integral-based approach. The refractive
+    angle image is rotated to align with the axis of symmetry, and values are integrated from the
+    center outwards, adjusting for axial symmetry.
+    """
+    
+    # Offset the angle values by subtracting the mean value at the reference x-coordinate
+    angle = angle - np.mean(angle[winy0:winy1,winx0:winx1])
+    
+    # Remove values below the center since they are not used in the calculation
+    angle = angle[0:center]
+    
+    # Reverse the angle array so that the upper end becomes the central axis
+    angle = angle[::-1]
+
+    # Calculate the distance from the central axis (η)
+    eta = np.array(range(angle.shape[0]))
+    
+    # Initialize an array to store the results
+    ans = np.zeros_like(angle)
+
+    # Calculate the values outward from r=0
+    for r in tqdm(range(center)):
+        # A: Denominator √(η² - r²)
+        # Calculate η² - r²
+        A = eta**2 - r**2
+        # Trim the array to keep the integration range (we extend to r+1 to avoid division by zero)
+        A = A[r+1:center]
+        # Take the square root to obtain √(η² - r²)
+        A = np.sqrt(A)
+        # Reshape for broadcasting
+        A = np.array([A]).T
+        
+        # B: The integrand (1/π * ε/√(η² - r²))
+        B = angle[r+1:center] / (A * np.pi)
+        # Sum B vertically to perform integration
+        ans[r] = B.sum(axis=0)
+    
+    
+
+    return ans
+
+def ART(sinogram, mu, e, reconstruction_angle : float,circle=True):
+    """
+    Perform Algebraic Reconstruction Technique (ART) to reconstruct images from a sinogram.
+
+    The ART method iteratively updates pixel values to minimize the error between projections
+    and the input sinogram, facilitating accurate image reconstruction from projections.
+
+    Parameters
+    ----------
+    sinogram : np.ndarray
+        A 2D or 3D numpy array representing the sinogram. Each row corresponds to a projection
+        at a specific angle.
+    mu : float
+        The relaxation parameter controlling the update step size during the iterative process.
+    e : float
+        The convergence threshold for the maximum absolute error in the reconstruction.
+
+    Returns
+    -------
+    list of np.ndarray
+        A list of reconstructed 2D arrays, each corresponding to a projection set in the input sinogram.
+
+    Notes
+    -----
+    - The function dynamically adjusts the grid size `N` until it matches the shape of the sinogram projections.
+    - The `radon` and `iradon` functions from `skimage.transform` are used to perform forward and backward
+      projections, respectively.
+    - The method stops when the maximum absolute error between successive updates falls below `e`.
+
+    Examples
+    --------
+    >>> sinogram = np.random.rand(180, 128)  # Example sinogram with 180 projections of length 128
+    >>> reconstructed_images = ART(sinogram, mu=0.1, e=1e-6)
+    >>> print(len(reconstructed_images))
+    180
+    """
+    
+    N = 1  # Initial grid size for reconstruction
+    ANG = reconstruction_angle  # Total rotation angle for projections
+    VIEW = sinogram[0].shape[0]  # Number of views (angles) in each projection
+    THETA = np.linspace(0, ANG, VIEW + 1)[:-1]  # Angles for radon transform
+    pbar = tqdm(total=sinogram[0].shape[0], desc="Initialization", unit="task")
+
+    # Find the optimal N that matches the projection dimensions
+    while True:
+        x = np.ones((N, N))  # Initialize a reconstruction image with ones
+
+        def A(x):
+            # Forward projection (Radon transform)
+            return radon(x, THETA, circle=circle).astype(np.float32)
+
+        def AT(y):
+            # Backprojection (inverse Radon transform)
+            return iradon(y, THETA, circle=circle, output_size=N).astype(np.float32) / (np.pi/2 * len(THETA))
+        
+        ATA = AT(A(np.ones_like(x)))  # ATA matrix for scaling
+
+        # Check if the current grid size N produces projections of the correct shape
+        if A(x).shape[0] == sinogram[0].shape[0]:
+            break
+
+        # Adjust N in larger steps if the difference is significant, else by 1
+        if sinogram[0].shape[0] - A(x).shape[0] > 20:
+            N += 10
+        else:
+            N += 1
+
+        # Update progress bar
+        pbar.n = A(x).shape[0]
+        pbar.refresh()
+    pbar.close()
+
+    loss = np.inf
+    x_list = []
+
+    # Process each projection set in the sinogram
+    for i in tqdm(range(sinogram.shape[0]), desc='Process', leave=True):
+        b = sinogram[i]  # Current projection data
+        ATA = AT(A(np.ones_like(x)))  # Recalculate ATA for current x
+        loss = float('inf')  # Reset loss
+
+        # Iteratively update x until convergence
+        while np.max(np.abs(loss)) > e:
+            # Compute the update based on the difference between projection and reconstruction
+            loss = np.divide(AT(b - A(x)), ATA)
+            x = x + mu * loss
+
+        x_list.append(x)  # Append the reconstructed image for the current projection
+
+    return x_list

BOSlib/reconstruction_utils.py

@@ -0,0 +1,47 @@
+from tqdm import tqdm
+import numpy as np    
+
+def sinogram_maker_axialsymmetry(angle):
+    """
+    Generates a sinogram with axial symmetry from a single 2D refractive angle image.
+
+    Parameters
+    ----------
+    angle : np.ndarray
+        A 2D numpy array representing the refractive angle image. Each row in this array 
+        is broadcast across the height dimension to simulate an axially symmetric sinogram.
+
+    Returns
+    -------
+    np.ndarray
+        A 3D numpy array representing the sinogram with axial symmetry. Each slice along 
+        the first dimension corresponds to a projection at a different angle, where each 
+        projection is a symmetric repetition of the refractive angle row values across 
+        the height and width dimensions.
+
+    Notes
+    -----
+    This function assumes axial symmetry for the generated sinogram by replicating each row 
+    of the input angle image across both dimensions (height and width) for each slice in 
+    the 3D sinogram. The input image is first rotated by 90 degrees for alignment.
+
+    Examples
+    --------
+    >>> angle_image = np.random.rand(100, 200)  # A 100x200 refractive angle image
+    >>> sinogram = sinogram_maker_axialsymmetry(angle_image)
+    >>> print(sinogram.shape)
+    (200, 200, 200)
+    """
+    # Rotate the angle image by 90 degrees
+    angle = np.rot90(angle)
+    height = angle.shape[1]
+    
+    # Initialize an empty 3D array for the sinogram
+    sinogram = np.empty((angle.shape[0], height, height), dtype=angle.dtype)
+
+    # Loop through each row in the rotated angle image
+    for i, d_angle in enumerate(tqdm(angle)):
+        # Broadcast each row across the height to create a symmetric 2D projection
+        sinogram[i] = np.broadcast_to(d_angle[:, np.newaxis], (height, height))
+        
+    return sinogram