BOSlib 0.0.1__py3-none-any.whl

BOSlib/shift.py

@@ -0,0 +1,126 @@
+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

BOSlib/shift_utils.py

@@ -0,0 +1,306 @@
+import numpy as np
+from PIL import Image
+import pandas as pd
+from scipy import signal
+
+def _biner_thresh(ar_in: np.ndarray, thresh: int) -> np.ndarray:
+    """
+    Binarize an array based on a threshold value.
+
+    Parameters
+    ----------
+    ar_in : np.ndarray
+        Input array to be binarized.
+    thresh : int
+        Threshold value for binarization.
+
+    Returns
+    -------
+    np.ndarray
+        Binarized array where values above the threshold are `True` and values below are `False`.
+    """
+    ar_bin = ar_in > thresh
+    return ar_bin
+
+def _bin_indexer(ar_in: np.ndarray) -> tuple:
+    """
+    Detect color boundary coordinates in a binarized image by finding gradient edges.
+
+    Parameters
+    ----------
+    ar_in : np.ndarray
+        Input binarized image array.
+
+    Returns
+    -------
+    tuple
+        Arrays containing the y-coordinates for the detected upper and lower boundaries of stripes.
+    """
+    # Convert to int for differentiation
+    ar_in = ar_in.astype(np.int8)
+    ar2 = np.delete(ar_in, 0, 0)
+    ar3 = np.delete(ar_in, ar_in.shape[0] - 1, 0)
+    ar4 = ar2 - ar3
+    
+    # Detect positive gradient (upper boundary)
+    u_tuple = np.where(ar4 > 0)
+    u_index = np.stack([u_tuple[1], u_tuple[0]]).T
+    
+    # Convert to DataFrame for processing
+    df = pd.DataFrame(u_index, columns=["X", "Y"])
+    df = df.pivot(index="Y", columns="X", values="Y")
+    
+    # Group by index for averaging boundaries
+    df["index"] = df.index / 10
+    df["index"] = df[["index"]].astype(int)
+    df = df.groupby("index").mean() / 10
+    df.columns = range(df.shape[1])
+    u_index = np.array(df)
+    
+    # Initialize array to store boundary positions
+    u_index_2 = np.zeros([1000, ar_in.shape[1]])
+    
+    # Process each column to handle NaN values
+    for x in range(ar_in.shape[1]):
+
+        ar_loop=u_index[:,x][np.where(~np.isnan(u_index[:,x]))[0]]
+        u_index_2[:,x]=np.concatenate([ar_loop,np.full(1000-ar_loop.shape[0],np.nan)])
+    
+    # Detect negative gradient (lower boundary)
+    d_tuple = np.where(ar4 < 0)
+    d_index = np.stack([d_tuple[1], d_tuple[0]]).T
+    
+    # Process for lower boundary similar to upper
+    df = pd.DataFrame(d_index, columns=["X", "Y"])
+    df = df.pivot(index="Y", columns="X", values="Y")
+    df["index"] = df.index / 10
+    df["index"] = df[["index"]].astype(int)
+    df = df.groupby("index").mean() / 10
+    df.columns = range(df.shape[1])
+    d_index = np.array(df)
+    
+    # Initialize array for lower boundary positions
+    d_index_2 = np.zeros([1000, ar_in.shape[1]])
+    
+    # Process each column to fill NaNs
+    for x in range(ar_in.shape[1]):
+        ar_loop = d_index[:, x][~np.isnan(d_index[:, x])]
+        d_index_2[:, x] = np.concatenate([ar_loop, np.full(1000 - ar_loop.shape[0], np.nan)])
+    
+    return u_index_2, d_index_2
+
+def _noize_reducer_2(ar_ref: np.ndarray, ar_exp: np.ndarray, diff_thresh: int) -> tuple:
+    """
+    Remove noise by aligning arrays based on a displacement threshold.
+
+    Parameters
+    ----------
+    ar_ref : np.ndarray
+        Reference array.
+    ar_exp : np.ndarray
+        Experimental array.
+    diff_thresh : int
+        Threshold for detecting displacement.
+
+    Returns
+    -------
+    tuple
+        Arrays with noise filtered based on the displacement threshold.
+    """
+    for x in range(ar_ref.shape[1]):
+        ref = ar_ref[:, x]
+        exp = ar_exp[:, x]
+        
+        while np.any(abs(exp - ref) > diff_thresh):
+            if np.any(exp - ref > diff_thresh):
+                y = np.where(exp - ref > diff_thresh)[0].min()
+                ref = np.delete(ref, y)
+                ref = np.insert(ref, ref.shape[0], np.nan)
+            
+            if np.any(exp - ref < -diff_thresh):
+                y = np.where(exp - ref < -diff_thresh)[0].min()
+                exp = np.delete(exp, y)
+                exp = np.insert(exp, exp.shape[0], np.nan)
+        
+        ar_ref[:, x] = ref
+        ar_exp[:, x] = exp
+    
+    return ar_ref, ar_exp
+
+def _mixing(u_ar: np.ndarray, d_ar: np.ndarray) -> np.ndarray:
+    """
+    Calculate the center positions between upper and lower boundaries.
+
+    Parameters
+    ----------
+    u_ar : np.ndarray
+        Array of upper boundary coordinates.
+    d_ar : np.ndarray
+        Array of lower boundary coordinates.
+
+    Returns
+    -------
+    np.ndarray
+        Array with center positions between boundaries.
+    """
+    ar = np.full([u_ar.shape[0] * 2, u_ar.shape[1]], np.nan)
+    ar[::2] = u_ar
+    ar[1::2] = d_ar
+    ar2 = np.delete(ar, 0, 0)
+    ar3 = np.delete(ar, ar.shape[0] - 1, 0)
+    ar = (ar2 + ar3) / 2
+    
+    return ar
+
+def _complementer(ref_ar: np.ndarray, diff_ar: np.ndarray) -> np.ndarray:
+    """
+    Rearrange displacement data to correct positions and interpolate gaps.
+
+    Parameters
+    ----------
+    ref_ar : np.ndarray
+        Reference array containing stripe positions.
+    diff_ar : np.ndarray
+        Array of displacement values.
+
+    Returns
+    -------
+    np.ndarray
+        Compensated displacement array with interpolated gaps.
+    """
+    max_ar = int(np.nanmax(ref_ar))
+    diff_2 = np.vstack([np.full(max_ar, -1), range(max_ar), np.zeros(max_ar)]).T
+    
+    for x in range(ref_ar.shape[1]):
+        ar_loop = np.vstack([np.full_like(ref_ar[:, x], x), ref_ar[:, x], diff_ar[:, x]]).T
+        ar_loop = ar_loop[~np.isnan(ar_loop).any(axis=1)]
+        diff_2 = np.concatenate([diff_2, ar_loop])
+    
+    diff_2[:, 1] = diff_2[:, 1].astype(int)
+    diff_df = pd.DataFrame(diff_2)
+    diff_df = diff_df.pivot_table(columns=0, index=1, values=2)
+    diff_df = diff_df.interpolate(limit=50)
+    
+    diff_comp = diff_df.values
+    
+    return diff_comp
+
+def _stretch_image_vertically(image: np.ndarray, scale_factor: int) -> np.ndarray:
+    """
+    Stretch a grayscale image vertically by a given scale factor.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        Input grayscale image as a 2D numpy array.
+    scale_factor : int
+        The factor by which to stretch the image vertically.
+
+    Returns
+    -------
+    np.ndarray
+        Vertically stretched image.
+    """
+    # Verify that the input image is 2D
+    if image.ndim != 2:
+        raise ValueError("Input image must be a 2D numpy array.")
+
+    # Vertically stretch the image by repeating each row 'scale_factor' times
+    stretched_image = np.repeat(image, scale_factor, axis=0)
+
+    return stretched_image
+
+def _cycle(ref_array: np.ndarray):
+    """
+    Calculate the cycle length of stripes in a reference image.
+
+    Parameters
+    ----------
+    ref_array : np.ndarray
+        The reference image to be analyzed, provided as a 2D numpy array.
+
+    Returns
+    -------
+    float
+        The calculated cycle length based on the detected boundaries in the reference image.
+    """
+    
+    # Vertically stretch the reference image by a factor of 10
+    im_ref=Image.fromarray(ref_array)
+    im_ref=im_ref.resize((im_ref.size[0],im_ref.size[1]*10))
+    
+    # Convert the stretched image to a numpy array
+    ar_ref = np.array(im_ref)
+    
+    # Binarize the stretched image using a threshold of 128
+    bin_ref = _biner_thresh(ar_ref, 128)
+    
+    # Detect upper and lower boundaries in the binarized image
+    ref_u, ref_d = _bin_indexer(bin_ref)
+    
+    # Mix the upper and lower boundary coordinates to find the midpoints
+    ref = _mixing(ref_u, ref_d)
+    
+    # Calculate the intervals between midpoints by finding differences
+    ref_interbal = np.delete(ref, 0, 0) - np.delete(ref, ref.shape[0] - 1, 0)
+    
+    # Count the number of valid intervals (non-NaN values)
+    count = np.count_nonzero(~np.isnan(ref_interbal[:, 0]))
+    
+    # Trim the intervals array to exclude unnecessary values
+    ref_interbal = ref_interbal[0:count - 2]
+    
+    # Calculate the cycle length as twice the average interval length
+    # This accounts for both peaks and valleys in the detected boundaries
+    cycle = np.nanmean(ref_interbal) * 2
+    
+    return cycle
+
+def _biner_HP(ar_in,cycle):
+    # パラメータ設定
+    sample_freq = 1#サンプリング周波数[1/px]
+    cutoff_freq = 1/cycle#カットオフ周波数[1/px]
+    filter_order = 8#次数
+    
+    # フィルタの作成
+    sos_high = signal.butter(filter_order, cutoff_freq, 'highpass', output='sos', fs=sample_freq)
+    #sos_low = signal.butter(filter_order, cutoff_freq, 'lowpass', output='sos', fs=sample_freq)
+    
+    #答え格納用ndarrayの作成(符号付16bitを指定しないと勝手に符号なしにされるZO☆)
+    ar_h=np.zeros_like(ar_in).astype(np.int16)
+    
+    #1行ずつ処理
+    for x in range(ar_in.shape[1]):
+        ar_x=ar_in[:,x]
+        
+        #フィルタの適用
+        ar_h[:,x] = signal.sosfiltfilt(sos_high, ar_x)
+        #yf_l = signal.sosfiltfilt(sos_low, y)
+    
+    #plt.plot(yf_h[100:1500])
+    ar_bin=ar_h>0
+    #y_bin=pd.DataFrame(y_bin*1)
+    
+    
+    
+    #f ar_bin[0,:].sum()==0 or ar_bin[0,:].sum()==ar_bin.shape[1]:
+    first_state=ar_bin[0,0]
+    for x in range(ar_bin.shape[1]):
+        y=0
+        state=ar_bin[0,x]!=first_state
+        
+        while(state==False):
+            ar_bin[y,x]=1-ar_bin[y,x]
+            y=y+1
+            state=ar_bin[y,x]!=first_state
+            
+        
+    #上端の汚い部分をごまかす
+    x=0
+    count=np.nan
+    while(count!=0):
+        count=ar_bin[x-1,:].sum()
+        ar_bin[x,:]=0
+        x=x+1
+    
+    return ar_bin

BOSlib/utils.py

@@ -0,0 +1,204 @@
+import numpy as np
+import BOSlib.shift_utils as ib
+from tqdm import tqdm,trange
+import matplotlib.pyplot as plt
+
+def shift2angle(shift: np.ndarray, ref_array: np.ndarray, sensor_pitch: float, resolution_of_background: float, Lb: float, Lci: float, binarization : str ="HPfilter", thresh : int = 128, freq : int = 500):
+    """
+    Convert the background image displacement to the angle of light refraction.
+
+    Parameters
+    ----------
+    shift : np.ndarray
+        Displacement values from the background image.
+    ref_array : np.ndarray
+        Reference image array used for calculations.
+    sensor_pitch : float
+        The pitch of the image sensor in mm.
+    resolution_of_background : float
+        It represents the number of lines per mm.
+    Lb : float
+        Distance from the background to the object being captured(mm).
+    Lci : float
+        Distance from the image sensor to the object being captured(mm).
+    
+    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
+    -------
+    tuple
+        - angle : np.ndarray
+            The calculated angles of light refraction.
+        - Lc : float
+            The distance from the object to the lens.
+        - Li : float
+            The distance from the lens to the image sensor.
+        - projection_ratio : float
+            The ratio of projection based on the dimensions.
+    """
+    Lb=Lb*10**-3
+    Lci=Lci*10**-3
+    
+    # Size of one LP (in pixels)
+    dpLP = ib._cycle(ref_array)
+
+    sensor_pitch = sensor_pitch * 10**-3  # Convert sensor pitch from mm to m
+    BGmpLP = 1 / resolution_of_background * 10**-3  # Convert pattern resolution from mm to m
+
+    # Size of one LP on the projection plane (m/LP)
+    mpLP = dpLP * sensor_pitch
+
+    # Magnification of the imaging
+    projection_ratio = mpLP / BGmpLP
+
+    # Total length
+    Lbi = Lci + Lb
+
+    Lc = Lbi / (projection_ratio + 1) - Lb  # Distance from the object to the lens
+    Li = Lci - Lc  # Distance from the lens to the image sensor
+
+    # Calculate the angle based on shift and projection properties
+    angle = shift * (sensor_pitch) / (projection_ratio * Lb)
+    np.nan_to_num(angle, copy=False)  # Replace NaN values with zero in the angle array
+
+    return angle, Lc, Li, projection_ratio
+
+def get_gladstone_dale_constant(temperature, pressure, humidity):
+    """
+    Calculate the Gladstone-Dale constant based on temperature, pressure, and humidity without using metpy.
+
+    Parameters
+    ----------
+    temperature : float
+        Temperature in degrees Celsius (°C).
+    pressure : float
+        Pressure in hectopascals (hPa).
+    humidity : float
+        Humidity as a percentage (%).
+
+    Returns
+    -------
+    tuple
+        - G : float
+            The calculated Gladstone-Dale constant.
+        - density : float
+            The density of the atmosphere.
+    """
+    
+    # Constants
+    R_dry = 287.058  # Specific gas constant for dry air, J/(kg·K)
+    R_water_vapor = 461.495  # Specific gas constant for water vapor, J/(kg·K)
+    
+    # Convert input values
+    T_kelvin = temperature + 273.15  # Convert temperature to Kelvin
+    p_pa = pressure * 100  # Convert pressure to Pascals
+    e_saturation = 6.1078 * 10 ** ((7.5 * temperature) / (237.3 + temperature))  # Saturation vapor pressure in hPa
+    e_actual = e_saturation * (humidity / 100)  # Actual vapor pressure in hPa
+    p_dry = p_pa - e_actual * 100  # Partial pressure of dry air in Pa
+    
+    # Calculate densities
+    density_dry = p_dry / (R_dry * T_kelvin)  # Density of dry air
+    density_vapor = (e_actual * 100) / (R_water_vapor * T_kelvin)  # Density of water vapor
+    
+    # Total density of humid air
+    density_air = density_dry + density_vapor
+    
+    # Gladstone-Dale constant calculation
+    n_air = 1.0003  # Refractive index of air
+    G = (n_air - 1) / density_air
+
+    return G, density_air
+
+def _compute_laplacian_chunk(array_chunk):
+    """
+    Compute the Laplacian for a chunk of an array.
+
+    Parameters
+    ----------
+    array_chunk : ndarray
+        A chunk of the original array, assumed to be 3D.
+
+    Returns
+    -------
+    laplacian_chunk : ndarray
+        The Laplacian of the input array chunk.
+    """
+    grad_yy = np.gradient(array_chunk, axis=1)
+    grad_zz = np.gradient(array_chunk, axis=2)
+    laplacian_chunk = grad_yy + grad_zz
+    return laplacian_chunk
+
+def compute_laplacian_in_chunks(array, chunk_size):
+    """
+    Compute the Laplacian of a 3D array in chunks to reduce memory usage.
+
+    Parameters
+    ----------
+    array : ndarray
+        The 3D input array for which the Laplacian is calculated.
+    chunk_size : int
+        The size of each chunk along each dimension.
+
+    Returns
+    -------
+    laplacian : ndarray
+        The computed Laplacian of the input array.
+    """
+    # Get the shape of the input array
+    shape = array.shape
+    
+    # Create an array to store the result
+    laplacian = np.zeros_like(array)
+    
+    # Process each chunk
+    for i in trange(0, shape[0], chunk_size):
+        for j in range(0, shape[1], chunk_size):
+            for k in range(0, shape[2], chunk_size):
+                # Extract the current chunk
+                chunk = array[i:i+chunk_size, j:j+chunk_size, k:k+chunk_size]
+                
+                # Compute the Laplacian for the chunk
+                laplacian_chunk = _compute_laplacian_chunk(chunk)
+                
+                # Store the result in the corresponding position in the original array
+                laplacian[i:i+chunk_size, j:j+chunk_size, k:k+chunk_size] = laplacian_chunk
+    
+    return laplacian
+
+
+def stripe_generator(width:int,height:int,stripe_width:int):
+
+    """
+    Generate a horizontal stripe pattern image and save it as a PNG file.
+
+    Args:
+        width (int): The width of the image in pixels.
+        height (int): The height of the image in pixels.
+        stripe_width (int): The width of each stripe in pixels.
+
+    Returns:
+        None
+    """
+
+    # 横縞パターンの生成
+    image = np.zeros((height, width), dtype=np.uint8)
+    for i in range(height):
+        if (i // stripe_width) % 2 == 0:
+            image[i, :] = 255  # 白 (モノクロ: 255)
+
+    # 画像を表示
+    plt.imshow(image, cmap='binary', interpolation='nearest')
+    plt.axis('off')
+    plt.show()
+
+    # 画像を保存
+    plt.imsave(f'horizontal_stripes{stripe_width}px.png', image, cmap='binary')