proadv 2.0.2__py3-none-any.whl

proadv/filtration/detection/trivariatekernel.py

@@ -0,0 +1,521 @@
+import numpy as np
+from scipy import linalg
+from scipy.stats._stats import gaussian_kernel_estimate as gke
+from scipy.stats import gaussian_kde as kde
+from proadv.statistics.spread import std
+
+
+def _derivatives(data):
+    """
+    Calculate time-independent first and second order derivatives of the input data.
+
+    Parameters
+    ------
+    data (array_like): Input data.
+
+    Returns
+    ------
+    dc (array_like): First derivative of the input data.
+    dc2 (array_like): Second derivative of the input data.
+    """
+
+    # Initialize arrays for first and second derivatives
+    dc = np.zeros_like(data)
+    dc2 = np.zeros_like(data)
+
+    # Calculate first derivative
+    for i in range(1, data.size - 1):
+        dc[i] = (data[i + 1] - data[i - 1]) / 2
+
+    # Calculate second derivative
+    for i in range(1, data.size - 1):
+        dc2[i] = (dc[i + 1] - dc[i - 1]) / 2
+
+    return dc, dc2
+
+
+def _rotation(u1, w1):
+    """
+    Calculate rotation angle theta between vectors u1 and w1.
+
+    Parameters
+    ------
+    u1 (array_like): Vector u1.
+    w1 (array_like): Vector w1.
+
+    Returns
+    ------
+    theta (float): Rotation angle.
+    """
+
+    # Compute data size
+    data_size = u1.size
+
+    # Calculate theta using the arctan2 function
+    theta = np.arctan2((data_size * np.sum(u1 * w1) - np.sum(u1) * np.sum(w1)),
+                       (data_size * np.sum(u1 * u1) - np.sum(u1) * np.sum(u1)))
+
+    return theta
+
+
+def _transform(x, y, theta):
+    """
+    Transform coordinates (x, y) using rotation angle theta.
+
+    Parameters
+    ------
+    x (array_like): x-coordinate.
+    y (array_like): y-coordinate.
+    theta (float): Rotation angle
+
+    Returns
+    ------
+    xt, yt (array_like): Transformed coordinates.
+    """
+
+    # Apply rotation transformation
+    xt = x * np.cos(theta) + y * np.sin(theta)
+    yt = -x * np.sin(theta) + y * np.cos(theta)
+
+    return xt, yt
+
+
+def _scaling(x, y, grid):
+    """
+    Scale coordinates (x, y) into a grid.
+
+    Parameters
+    ------
+    x (array_like): x-coordinate.
+    y (array_like): y-coordinate.
+    grid (int): Number of grid points.
+
+    Returns
+    ------
+    Meshgrid of scaled coordinates.
+    """
+
+    xmin = x.min()
+    xmax = x.max()
+    ymin = y.min()
+    ymax = y.max()
+
+    # Generate a meshgrid of scaled coordinates
+    return np.mgrid[xmin:xmax:grid * 1j, ymin:ymax:grid * 1j]
+
+
+def _profile(meshgrid_x, meshgrid_y):
+    """
+    Extract profile coordinates from meshgrid.
+
+    Parameters
+    ------
+    meshgrid_x (array_like): Meshgrid of x-coordinates.
+    meshgrid_y (array_like): Meshgrid of y-coordinates.
+
+    Returns
+    ------
+    Profile coordinates.
+    """
+
+    # Extract profile coordinates from meshgrid
+    return meshgrid_x[:, 0], meshgrid_y[0, :]
+
+
+def _position(meshgrid_x, meshgrid_y, trans_x, trans_y):
+    """
+    Generate positions and values for interpolation.
+
+    Parameters
+    ------
+    meshgrid_x (array_like): Meshgrid of x-coordinates.
+    meshgrid_y (array_like): Meshgrid of y-coordinates.
+    trans_x (array_like): Transformed x-coordinates.
+    trans_y (array_like): Transformed y-coordinates.
+
+    Returns
+    ------
+    Positions and values for interpolation.
+    """
+
+    # Stack meshgrid coordinates and transformed coordinates
+    positions = np.vstack([meshgrid_x.ravel(), meshgrid_y.ravel()])
+    values = np.vstack([trans_x, trans_y])
+
+    return positions, values
+
+
+def _factor(rows, cols):
+    """
+    Calculate covariance factor based on rows and columns.
+
+    Parameters
+    ------
+    rows (int): Number of rows.
+    cols (int): Number of columns.
+
+    Returns
+    ------
+    Factor.
+    """
+
+    # Calculate the covariance factor
+    return np.power(cols, -1. / (rows + 4))
+
+
+def _weight(cols):
+    """
+    Generate weights.
+
+    Parameters
+    ------
+    cols (int): Number of columns.
+
+    Returns
+    ------
+    Array of weights.
+    """
+
+    # Generate equal weights
+    return np.ones(cols) / cols
+
+
+def _cov(data, aweights):
+    """
+    Compute the weighted covariance matrix.
+
+    Parameters
+    ------
+    data (array_like): Input data.
+    aweights (array_like): Array of weights.
+
+    Returns
+    ------
+    Weighted covariance matrix.
+    """
+
+    # Compute the weighted covariance matrix
+    return np.atleast_2d(np.cov(data, rowvar=1, bias=False, aweights=aweights))
+
+
+def _cholesky(data):
+    """
+    Compute the Cholesky decomposition of a matrix.
+
+    Parameters
+    ------
+    data (array_like): Input matrix.
+
+    Returns
+    ------
+    Cholesky decomposition of the input matrix.
+    """
+
+    # Compute the Cholesky decomposition
+    return linalg.cholesky(data)
+
+
+def _determination(data):
+    """
+    Compute the determinant of a matrix.
+
+    Parameters
+    ------
+    data (array_like): Input matrix.
+
+    Returns
+    ------
+    Determinant of the input matrix.
+    """
+
+    # Compute the determinant
+    return 2 * np.sum(np.log(np.diag(data * np.sqrt(np.pi * 2))))
+
+
+def _covariance(data, rows, cols):
+    """
+    Calculate the covariance and Cholesky decomposition.
+
+    Parameters
+    ------
+    data (array_like): Input data
+    rows (int): Number of rows.
+    cols (int): Number of columns.
+
+    Returns
+    ------
+    Dictionary containing computed factors, weights, net, covariance, Cholesky decomposition, and log.
+    """
+
+    # Compute factors and weights
+    weight = _weight(cols)
+
+    # Compute net and adjust factor
+    net = np.power(np.sum(weight ** 2), -1)
+    factor = _factor(rows, net)
+
+    # Compute covariance matrix and its Cholesky decomposition
+    cov = _cov(data, weight)
+    sky = _cholesky(cov)
+
+    # Adjust covariance and Cholesky decomposition
+    covariance = cov * factor ** 2
+    cholesky = sky * factor
+    cholesky.dtype = np.float64
+
+    # Compute log
+    log = _determination(cholesky)
+
+    # Return computed values as a dictionary
+    compute = {
+        "factor": factor,
+        "weight": weight,
+        "net": net,
+        "covariance": covariance,
+        "cholesky": cholesky,
+        "log": log
+    }
+
+    return compute
+
+
+def _type(cov, scatt):
+    """
+    Determine the data type and size.
+
+    Parameters
+    ------
+    cov (array_like): Covariance matrix.
+    scatt (array_like): Scattering data.
+
+    Returns
+    ------
+    Data type and size.
+    """
+
+    data_type = np.common_type(cov, scatt)
+    data_size = np.dtype(data_type).itemsize
+    if data_size == 4:
+        data_size = 'float'
+    elif data_size == 8:
+        data_size = 'double'
+    elif data_size in (12, 16):
+        data_size = 'long double'
+    return data_type, data_size
+
+
+def _density(values):
+    """
+    Compute the density estimation.
+
+    Parameters
+    ------
+    values (array_like): Values for density estimation.
+
+    Returns
+    ------
+    Dictionary containing the density estimation results.
+    """
+
+    dataset = np.atleast_2d(np.asarray(values))
+    if dataset.size < 1:
+        raise ValueError("Dataset should have more than one element.")
+    rows, cols = dataset.shape
+    if rows > cols:
+        raise ValueError("Number of dimensions exceeds the number of samples.")
+    evals = _covariance(dataset, rows, cols)
+    return evals
+
+
+def _estimation(krn, x):
+    """
+    Perform density estimation.
+
+    Parameters
+    ------
+    krn (array_like): Kernel density estimation.
+    x (array_like): Input data.
+
+    Returns
+    ------
+    Estimated density.
+    """
+    return np.reshape(krn, x.shape)
+
+
+def _extraction(dataset, parameters, poses):
+    """
+    Extract necessary data for extraction.
+
+    Parameters
+    ------
+    dataset (array_like): Input dataset.
+    parameters (dict): Parameters dictionary containing covariance and scattering data.
+    poses (array_like): Scattering positions.
+
+    Returns
+    ------
+    Extracted dataset components.
+    """
+    scatt = np.atleast_2d(np.asarray(poses))
+    data_type, data_mode = _type(parameters["covariance"], scatt)
+    return dataset.T, parameters["weight"][:, None], poses.T, parameters["cholesky"].T, data_type, data_mode
+
+
+def _evolve(dataset, poses, computations):
+    """
+    Evolve the dataset based on computed parameters.
+
+    Parameters
+    ------
+    dataset (array_like): Input dataset.
+    poses (array_like): Scattering poses.
+    computations (dict): Computed parameters.
+
+    Returns
+    ------
+    Evolved dataset.
+    """
+    dataset = _extraction(dataset, computations, poses)
+    dens = gke[dataset[5]](
+        dataset[0],
+        dataset[1],
+        dataset[2],
+        dataset[3],
+        dataset[4])
+    return dens[:, 0]
+
+
+def _peak(pdf):
+    """
+    Find the peak in the probability density function.
+
+    Parameters
+    ------
+    pdf (array_like): Probability density function.
+
+    Returns
+    ------
+    Peak and its indices.
+    """
+    peak = pdf.max()
+    up, wp = np.where(pdf == peak)[0][0], np.where(pdf == peak)[1][0]
+    fu = pdf[:, wp]
+    fw = pdf[up, :]
+    return peak, up, wp, fu, fw
+
+
+def _cutoff(density_profile, velocity_profile, c1_threshold, c2_threshold, force_profile, peak_index, grid):
+    """
+    Find the lower and upper cutoff velocities based on specified criteria.
+
+    Parameters
+    ------
+    density_profile (array_like): Density profile of the system.
+    velocity_profile (array_like): Velocity profile of the system.
+    c1_threshold (float): Threshold ratio for force compared to peak force.
+    c2_threshold (float): Threshold for absolute change in force.
+    force_profile (array_like): Force profile of the system.
+    peak_index (int): Index of the peak force in the force profile.
+    grid (int): Grid spacing or resolution.
+
+    Returns
+    ------
+    lower_cutoff_velocity, upper_cutoff_velocity: A tuple containing the lower and upper cutoff velocities.
+
+    Note
+    ------
+    This function assumes that the input arrays (density_profile, velocity_profile, and force_profile)
+        are of the same length.
+        length.
+    The density profile, velocity profile, and force profile should be consistent and correspond to
+        each other at each index.
+    """
+
+    profile_length = force_profile.size
+    delta_force = np.append([0], np.diff(force_profile)) * grid / density_profile
+
+    # Find lower cutoff index
+    for i in range(peak_index - 1, 0, -1):
+        if force_profile[i] / force_profile[peak_index] <= c1_threshold and abs(delta_force[i]) <= c2_threshold:
+            lower_cutoff_index = i
+            break
+    else:
+        lower_cutoff_index = 1
+
+    # Find upper cutoff index
+    for i in range(peak_index + 1, profile_length - 1):
+        if force_profile[i] / force_profile[peak_index] <= c1_threshold and abs(delta_force[i]) <= c2_threshold:
+            upper_cutoff_index = i
+            break
+    else:
+        upper_cutoff_index = profile_length - 1
+
+    lower_cutoff_velocity = velocity_profile[lower_cutoff_index]
+    upper_cutoff_velocity = velocity_profile[upper_cutoff_index]
+
+    return lower_cutoff_velocity, upper_cutoff_velocity
+
+
+def kernel(u1, w1, grid):
+    """
+    Perform kernel computation.
+
+    Parameters
+    ------
+    u1 (array_like): Input velocity component.
+    w1 (array_like): Input velocity component.
+    grid (int): Grid size.
+
+    Returns
+    ------
+    Spieks Indices and estimation.
+    """
+
+    dataset = np.array([u1, w1])
+    theta = _rotation(u1, w1)
+    ut, wt = _transform(u1, w1, theta)
+    mesh_u, mesh_w = _scaling(ut, wt, grid)
+    uf, wf = _profile(mesh_u, mesh_w)
+    positions, values = _position(mesh_u, mesh_w, ut, wt)
+    evals = _density(values)
+    evole = _evolve(dataset, positions, evals)
+    estimation = _estimation(evole.T, mesh_u)
+    density = np.reshape(kde(values)(positions).T, mesh_u.shape)
+    peak, up, wp, fu, fw = _peak(density)
+    lambda_ = np.sqrt(2 * np.log(u1.size))
+    stdu = std(u1)
+    stdw = std(w1)
+    cu = lambda_ * stdu / np.sqrt(u1.size)
+    cw = lambda_ * stdw / np.sqrt(u1.size)
+    ul, uu = _cutoff(peak, uf, cu, cu, fu, up, grid)
+    wl, wu = _cutoff(peak, wf, cw, cw, fw, wp, grid)
+    uu1 = uu - 0.5 * (uu + ul)
+    wu1 = wu - 0.5 * (wu + wl)
+    Ut1 = ut - 0.5 * (uu + ul)
+    Wt1 = wt - 0.5 * (wu + wl)
+    rho = (Ut1 / uu1) ** 2 + (Wt1 / wu1) ** 2
+    id_ = np.where(rho > 1)[0]
+
+    return id_, estimation
+
+
+def three_dimensional_kernel(data, grid):
+    """
+    Perform three-dimensional kernel computation.
+
+    Parameters
+    ------
+    data (array_like): Input data.
+    grid (int): Grid size.
+
+    Returns
+    ------
+    Spikes  indices.
+    """
+    dc, dc2 = _derivatives(data)
+    x1, _ = kernel(data, dc, grid)
+    x2, _ = kernel(data, dc2, grid)
+    x3, _ = kernel(dc, dc2, grid)
+    kde3d_indices = np.sort(np.unique(np.concatenate((x1, x2, x3))))
+    return kde3d_indices

proadv/filtration/replacement/replacements.py

@@ -0,0 +1,187 @@
+import numpy as np
+from proadv.statistics.descriptive import mean
+from scipy.interpolate import interp1d
+
+
+def last_valid_data(velocities, spike_indices):
+    """
+    Replace spike values in velocities array with the last valid data before each.
+
+    Parameters
+    ------
+        velocities (array_like): Array of velocity data.
+            An array-like object containing velocity values.
+        spike_indices (array_like): Indices of spikes.
+            An array-like object containing the indices of detected spikes.
+
+    Returns
+    ------
+        modified_data (array_like): Modified data with spikes replaced by last valid values.
+            An array containing the modified data.
+    """
+    # Create a copy of the original data
+    modified_data = np.copy(velocities)
+
+    # Replace values at spikes indices with the last valid value
+    for idx in spike_indices:
+        modified_data[idx] = modified_data[idx - 1]
+
+    return modified_data
+
+
+def mean_value(velocities, spike_indices):
+    """
+    Replace spike values in velocities array with the mean value of velocity component.
+
+    Parameters
+    ------
+        velocities (array_like): Array of velocity data.
+            An array-like object containing velocity values.
+        spike_indices (array_like): Indices of spikes.
+            An array-like object containing the indices of detected spikes.
+
+    Returns
+    ------
+        modified_data (array_like): Modified data with spikes replaced by mean value of velocity component.
+            An array containing the modified data.
+    """
+    # Create a copy of the original data
+    modified_data = np.copy(velocities)
+
+    # Replace values at spikes indices with the mean value
+    modified_data[spike_indices] = mean(velocities)
+
+    return modified_data
+
+
+def linear_interpolation(velocities, spike_indices, decimals=4):
+    """
+    Perform linear interpolation to replace spike values in velocity data.
+
+    This function identifies spikes in the velocity data and replaces them with
+        linearly interpolated values based on the nearest valid data points before
+        and after each spike. If a spike occurs at the end of the data, it is replaced
+        with the mean of the entire dataset. The function is robust to handle individual
+        spikes as well as sequences of consecutive spikes.
+
+    Parameters
+    ------
+    velocities : (array_like)
+        An array-like object containing velocity values. It should be a one-dimensional
+        array of numerical data representing velocities.
+    spike_indices : (array_like)
+        An array-like object containing the indices of detected spike events. It should
+        be a one-dimensional array of integers where each integer represents the index
+        in 'velocities' that corresponds to a spike.
+    decimals : int, optional
+        The number of decimal places to round the interpolated values to. This allows
+        the output data to be presented with a consistent level of precision. The default
+        value is 4, but this can be adjusted as needed.
+
+    Returns
+    ------
+    modified_data (array_like):
+        An array containing the modified velocity data with spikes replaced by
+        interpolated values. The shape and type of the array are the same as the
+        input 'velocities' array.
+
+    Notes
+    ------
+    The function uses linear interpolation to estimate the values of spikes based on the
+        surrounding non-spike data. For spikes at the beginning or end of the data where a
+        neighboring non-spike value is not available, the function uses the mean of the entire
+        dataset as a replacement value. This approach ensures that the data remains as accurate
+        and representative of the original dataset as possible.
+
+    """
+
+    # Create a copy of the velocity data to avoid modifying the original array
+    modified_data = np.copy(velocities)
+
+    # Initialize spike values with NaN to facilitate interpolation
+    modified_data[spike_indices] = np.nan
+
+    # Calculate differences between consecutive spike indices
+    spike_diff = np.diff(spike_indices)
+    # Identify the start index of each spike sequence
+    spike_starts = spike_indices[np.insert(spike_diff > 1, 0, True)]
+    # Identify the end index of each spike sequence
+    spike_ends = spike_indices[np.append(spike_diff > 1, True)]
+
+    # Iterate over each spike sequence for interpolation
+    for start, end in zip(spike_starts, spike_ends):
+        # Find the valid data point immediately before the spike sequence
+        valid_start = modified_data[start - 1] if start > 0 else np.nan
+        # Find the valid data point immediately after the spike sequence
+        valid_end = modified_data[end + 1] if end < len(velocities) - 1 else np.nan
+
+        # If valid start and end points are found, perform linear interpolation
+        if not np.isnan(valid_start) and not np.isnan(valid_end):
+            # Calculate the interpolation step size
+            step = (valid_end - valid_start) / (end - start + 2)
+            # Apply linear interpolation across the spike sequence
+            for i, idx in enumerate(range(start, end + 1)):
+                modified_data[idx] = valid_start + step * (i + 1)
+        elif np.isnan(valid_end):  # Handle spike sequences at the end of the data
+            # Replace end spikes with the mean of non-NaN values in the dataset
+            modified_data[start:end + 1] = mean(velocities[~np.isnan(velocities)])
+        else:
+            # Use the mean of valid start and end points as a fallback
+            fallback_value = np.nanmean([valid_start, valid_end])
+            modified_data[start:end + 1] = fallback_value
+
+    # Round the interpolated values to the specified number of decimal places
+    return np.around(modified_data, decimals=decimals)
+
+
+def cubic_12points_polynomial(velocities, spike_indices, decimals=4):
+    """
+    Interpolates missing data points in a velocity array using cubic polynomial interpolation.
+
+    Parameters
+    ------
+    velocities (array_like): Array of velocity data. It should be a one-dimensional array-like object.
+        This function assumes the input velocities array has at least 25 data points.
+    spike_indices (array_like): Indices where data is missing (spikes). It should be a one-dimensional array-like
+        object containing integers representing the indices of missing data points (spikes).
+        If spike_indices contains invalid indices (e.g., negative values or indices exceeding the array size),
+        a ValueError will be raised.
+    decimals (int, optional): Number of decimal places to round the result to. Default is 4.
+
+    Returns
+    ------
+    modified_data (array_like): Array of velocities with missing data interpolated. The interpolated values
+        are calculated based on cubic polynomial interpolation using neighboring data points.
+
+    Raises
+    ------
+    ValueError: If spike_indices contains invalid indices or if velocities is not a one-dimensional array-like object.
+
+    Notes
+    ------
+    - This function uses cubic polynomial interpolation to estimate missing data points based on neighboring values.
+    - If a missing data point (spike) occurs near the boundaries of the velocities array, linear interpolation
+        is used instead of cubic polynomial interpolation.
+    - The input velocities array is modified in-place to replace missing data points with interpolated values.
+    """
+
+    # Make a copy of velocities to preserve original data
+    modified_data = velocities.copy()
+
+    # Replace spike indices with NaN values
+    modified_data[spike_indices] = np.nan
+
+    # Generate x values for interpolation
+    x = np.array(list(range(1, 13)) + list(range(14, 26)))
+
+    for i in spike_indices:
+        # Check if index is near the boundaries
+        if i <= 30 or i >= (len(velocities) - 30):
+            # Use linear interpolation near the boundaries
+            modified_data[i] = np.around((velocities[i - 1] + modified_data[i:][~np.isnan(modified_data[i:])][0]) / 2, 4)
+        else:
+            # Use cubic polynomial interpolation
+            yint = np.delete(np.append(velocities[i - 13:i], modified_data[i:][~np.isnan(modified_data[i:])][0:12]), 12)
+            f = interp1d(x, yint, 3)
+            modified_data[i] = f(13)
+    return np.around(modified_data, decimals=decimals)