grainmorph 0.2.0__py3-none-any.whl

grainmorph/utils/parametric_mask.py

@@ -0,0 +1,199 @@
+import numpy as np
+
+from ..metrics import compute_roundness
+from .geometry import create_poly_mask, polar_vertices
+
+
+def create_particle_mask(
+    shape: tuple[int, int],
+    center: tuple[float, float],
+    radius: float,
+    sphericity: float,
+    roundness: float,
+    *,
+    num_angles: int = 256,
+    frequencies: list[int] | np.ndarray | None = None,
+    decay: float = 1.0,
+    seed: int | None = None,
+    max_iter: int = 12,
+    amp_max: float = 0.45,
+    metric_tol: float = 0.001,
+    report_tol: float = 0.1,
+    return_info: bool = False,
+) -> np.ndarray | tuple[np.ndarray, dict]:
+    """Generates a synthetic particle mask with target morphological features.
+
+    Uses a Fourier-based approach to generate a closed polygon-based mask that
+    matches specified sphericity and roundness values through iterative optimization
+    of the roughness amplitude.
+
+    Args:
+        shape: Dimensions of the output mask (height, width).
+        center: Center coordinates of the particle (y, x).
+        radius: Base radius of the particle.
+        sphericity: Target sphericity (0 to 1).
+        roundness: Target roundness (0 to 1).
+        num_angles: Number of vertices in the generated polygon.
+        frequencies: List of frequencies used to generate surface roughness.
+        decay: Frequency decay rate of the roughness signal.
+        seed: Random seed for phase generation.
+        max_iter: Max iterations for roundness calibration.
+        amp_max: Maximum allowed amplitude for the roughness signal.
+        metric_tol: Internal precision for reaching the target roundness.
+        report_tol: Error threshold for the 'target_met' report flag.
+        return_info: If True, returns a metadata dictionary along with the mask.
+
+    Returns:
+        The binary mask as a numpy array, or a tuple of (mask, info_dict).
+    """
+    try:
+        radius = float(radius)
+        sphericity = float(sphericity)
+        roundness = float(roundness)
+    except (TypeError, ValueError):
+        raise ValueError(
+            "radius, sphericity, and roundness must be finite numbers."
+        ) from None
+
+    if not np.isfinite(radius) or radius < 0:
+        raise ValueError("radius must be finite and >= 0.")
+    if not np.isfinite(sphericity) or not np.isfinite(roundness):
+        raise ValueError("sphericity and roundness must be finite.")
+
+    sphericity = float(np.clip(sphericity, 0.001, 1.0))
+    roundness = float(np.clip(roundness, 0.0, 1.0))
+    if num_angles < 3:
+        raise ValueError("num_angles must be >= 3.")
+
+    frequencies_arr = np.asarray(
+        frequencies if frequencies is not None else np.arange(2, 9), dtype=int
+    )
+    phases = np.random.default_rng(seed).uniform(
+        0.0, 2.0 * np.pi, size=len(frequencies_arr)
+    )
+    cy, cx = center
+    amplitude = 0.0
+
+    if radius == 0.0:
+        mask = np.zeros(shape, dtype=bool)
+        iy, ix = round(cy), round(cx)
+        if 0 <= iy < shape[0] and 0 <= ix < shape[1]:
+            mask[iy, ix] = True
+    else:
+        amplitude = _calibrate_amplitude(
+            radius=radius,
+            sphericity=sphericity,
+            roundness=roundness,
+            frequencies=frequencies_arr,
+            phases=phases,
+            decay=decay,
+            max_iter=max_iter,
+            amp_max=amp_max,
+            metric_tol=metric_tol,
+        )
+        thetas = np.linspace(0.0, 2.0 * np.pi, num_angles, endpoint=False)
+        base_radii, roughness_radii = _radial_components(
+            radius, sphericity, thetas, frequencies_arr, phases, decay
+        )
+        radii = np.maximum(base_radii + amplitude * roughness_radii, 0.5)
+        vertices = polar_vertices((cy, cx), radii, thetas)
+        mask = create_poly_mask(shape, vertices).astype(bool)
+
+    if not return_info:
+        return mask
+
+    measured = compute_roundness(mask.astype(np.uint8, copy=False)) if radius else None
+    achieved = float(measured["val"]) if measured else 0.0
+    abs_error = float(abs(roundness - achieved))
+    info = {
+        "sphericity_target": sphericity,
+        "roundness_target": roundness,
+        "roundness_achieved": achieved,
+        "abs_error": abs_error,
+        "report_tol": float(report_tol),
+        "target_met": bool(abs_error <= report_tol),
+        "amplitude": float(amplitude),
+        "frequencies": frequencies_arr.tolist(),
+        "phases": phases.tolist(),
+    }
+    return mask, info
+
+
+def _calibrate_amplitude(
+    *,
+    radius: float,
+    sphericity: float,
+    roundness: float,
+    frequencies: np.ndarray,
+    phases: np.ndarray,
+    decay: float,
+    max_iter: int,
+    amp_max: float,
+    metric_tol: float,
+) -> float:
+    thetas = np.linspace(0.0, 2.0 * np.pi, 128, endpoint=False)
+    base_radii, roughness_radii = _radial_components(
+        radius, sphericity, thetas, frequencies, phases, decay
+    )
+    scale = min(1.0, 128.0 / radius)
+    size = int(np.ceil((radius * scale * (1.0 + amp_max) + 2) * 2))
+    shape = (size, size)
+    center = size / 2.0
+
+    def measure(amplitude: float) -> float:
+        radii = (base_radii + amplitude * roughness_radii) * scale
+        vertices = polar_vertices((center, center), np.maximum(radii, 0.5), thetas)
+        result = compute_roundness(create_poly_mask(shape, vertices))
+        return float(result["val"]) if result else 0.0
+
+    achieved = measure(0.0)
+    amplitude = 0.0
+    if achieved > roundness + metric_tol:
+        low, high = 0.0, float(amp_max)
+        for _ in range(max_iter):
+            mid = (low + high) / 2
+            measured = measure(mid)
+            if abs(measured - roundness) < abs(achieved - roundness):
+                achieved, amplitude = measured, mid
+            if abs(measured - roundness) <= metric_tol:
+                break
+            if measured > roundness:
+                low = mid
+            else:
+                high = mid
+
+    return amplitude
+
+
+def _radial_components(
+    radius: float,
+    sphericity: float,
+    thetas: np.ndarray,
+    frequencies: np.ndarray,
+    phases: np.ndarray,
+    decay: float,
+) -> tuple[np.ndarray, np.ndarray]:
+    base_radii = ellipse_radius(
+        radius, radius * sphericity, np.cos(thetas), np.sin(thetas)
+    )
+    roughness_radii = roughness_signal(thetas, frequencies, phases, decay) * radius
+    return base_radii, roughness_radii
+
+
+def ellipse_radius(
+    a: float, b: float, cos_t: np.ndarray, sin_t: np.ndarray
+) -> np.ndarray:
+    denom = np.sqrt((b * cos_t) ** 2 + (a * sin_t) ** 2)
+    return a * b / np.maximum(denom, 1e-12)
+
+
+def roughness_signal(
+    thetas: np.ndarray, frequencies: np.ndarray, phases: np.ndarray, decay: float
+) -> np.ndarray:
+    weights = 1.0 / np.maximum(frequencies.astype(float), 1.0) ** decay
+    components = weights[:, None] * np.cos(
+        frequencies[:, None] * thetas[None, :] + phases[:, None]
+    )
+    signal = np.sum(components, axis=0)
+    max_abs = np.max(np.abs(signal))
+    return signal / max_abs if max_abs > 1e-12 else signal

grainmorph/utils/plot.py

@@ -0,0 +1,99 @@
+from collections.abc import Mapping
+from typing import Any
+
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.patches import Circle, Ellipse, Polygon
+
+
+def plot_analysis_results(
+    mask: np.ndarray,
+    results: Mapping[str, Any],
+    figsize: tuple[int, int] = (8, 8),
+    title: str = "Analysis Results",
+    show: bool = True,
+) -> None:
+
+    _, ax = plt.subplots(figsize=figsize)
+    ax.imshow(mask, cmap="gray", alpha=0.3)
+
+    sphericity_data = results.get("sphericity")
+    if sphericity_data:
+        _add_circle_overlay(
+            ax,
+            sphericity_data["inscribed"],
+            color="blue",
+            label="Inscribed",
+            marker="+",
+        )
+        _add_circle_overlay(
+            ax,
+            sphericity_data["enclosing"],
+            color="red",
+            label="Enclosing",
+            marker="x",
+        )
+
+    aspect_ratio_data = results.get("aspect_ratio")
+    if aspect_ratio_data:
+        ellipse = aspect_ratio_data.get("ellipse")
+        if ellipse:
+            _add_ellipse_overlay(ax, ellipse)
+
+    metric_labels = {
+        "roundness": "Roundness",
+        "circularity": "Circularity",
+        "sphericity": "Sphericity",
+        "aspect_ratio": "Aspect Ratio",
+    }
+
+    stats = []
+    for key, label in metric_labels.items():
+        data = results.get(key)
+        if data and "val" in data:
+            stats.append(f"{label}: {data['val']:.4f}")
+
+    ax.set_title(f"{title}\n{', '.join(stats)}")
+    handles, labels = ax.get_legend_handles_labels()
+    if handles:
+        by_label = dict(zip(labels, handles))
+        ax.legend(by_label.values(), by_label.keys(), loc="upper right")
+
+    ax.grid(True, linestyle="--", alpha=0.5)
+    plt.tight_layout()
+    if show:
+        plt.show()
+
+
+def _add_circle_overlay(
+    ax, circle_data: Mapping[str, float], *, color: str, label: str, marker: str
+) -> None:
+    x = circle_data["x"]
+    y = circle_data["y"]
+    r = circle_data["r"]
+    ax.add_patch(Circle((x, y), r, color=color, fill=False, label=label))
+    ax.scatter(x, y, color=color, marker=marker)
+
+
+def _add_ellipse_overlay(ax, ellipse: Mapping[str, Any]) -> None:
+    ax.add_patch(
+        Ellipse(
+            (ellipse["x"], ellipse["y"]),
+            ellipse["w"],
+            ellipse["h"],
+            angle=ellipse["angle"],
+            color="yellow",
+            fill=False,
+            label="Fitted Ellipse",
+        )
+    )
+    if ellipse.get("bbox"):
+        ax.add_patch(
+            Polygon(
+                ellipse["bbox"],
+                closed=True,
+                color="green",
+                fill=False,
+                label="Bounding Box",
+            )
+        )

grainmorph/validation.py

@@ -0,0 +1,44 @@
+from numbers import Integral, Real
+
+import numpy as np
+
+from .schema import Mask
+
+
+def validate_analysis_params(eps: float, target_dim: int) -> tuple[float, int]:
+    if isinstance(eps, (bool, np.bool_)) or not isinstance(eps, Real):
+        raise TypeError("eps must be a real number.")
+    if not np.isfinite(eps) or eps <= 0:
+        raise ValueError("eps must be > 0 and finite.")
+
+    if isinstance(target_dim, (bool, np.bool_)) or not isinstance(target_dim, Integral):
+        raise TypeError("target_dim must be an integer.")
+    if target_dim <= 0:
+        raise ValueError("target_dim must be > 0.")
+
+    return (float(eps), int(target_dim))
+
+
+def to_binary(mask: np.ndarray) -> Mask:
+    if not isinstance(mask, np.ndarray):
+        raise TypeError("mask must be a numpy.ndarray.")
+
+    if mask.ndim != 2:
+        raise ValueError(f"mask must be 2D, got {mask.ndim}D.")
+
+    if mask.dtype == np.bool_:
+        return mask.astype(np.uint8)
+
+    if np.issubdtype(mask.dtype, np.floating):
+        if not np.isfinite(mask).all():
+            raise ValueError("mask must not contain NaN or inf.")
+        if not np.all((mask == 0) | (mask == 1)):
+            raise ValueError("mask must be binary with values in {0, 1}.")
+        return mask.astype(np.uint8)
+
+    if np.issubdtype(mask.dtype, np.integer):
+        if mask.size > 0 and (mask.min() < 0 or mask.max() > 1):
+            raise ValueError("mask must be binary with values in {0, 1}.")
+        return mask.astype(np.uint8)
+
+    raise ValueError("mask must be binary with values in {0, 1}.")

grainmorph/wadell/__init__.py

@@ -0,0 +1,3 @@
+from .roundness import compute_roundness as compute_roundness
+
+__all__ = ["compute_roundness"]

grainmorph/wadell/boundary.py

@@ -0,0 +1,14 @@
+import cv2
+import numpy as np
+
+
+def extract_boundary(mask: np.ndarray) -> np.ndarray:
+    if mask.dtype != np.uint8:
+        mask = mask.astype(np.uint8)
+
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+    if not contours:
+        return np.empty((0, 2), dtype=np.float64)
+
+    contour = max(contours, key=cv2.contourArea)
+    return contour.reshape(-1, 2).astype(np.float64)

grainmorph/wadell/corner.py

@@ -0,0 +1,163 @@
+import numpy as np
+
+
+def compute_corner_radii(
+    keypoints: np.ndarray,
+    r_max: float,
+    r_max_pos: np.ndarray,
+    circle_fit_thresh: float,
+) -> np.ndarray:
+    convex_points = _select_convex_points(keypoints).astype(np.float32)
+    keypoints = keypoints.astype(np.float32)
+    num_points = len(convex_points)
+
+    dist_boundary = np.linalg.norm(convex_points - r_max_pos, axis=1)
+    dist_cumsum = np.concatenate([[0.0], np.cumsum(dist_boundary)])
+
+    radii: list[float] = []
+    start = 0
+
+    while True:
+        ends = np.arange(start + 3, num_points + 1)
+        if len(ends) == 0:
+            break
+
+        sizes = ends - start
+        radius, center = _fit_circles(convex_points[start:], sizes)
+
+        dist_center = np.linalg.norm(center - r_max_pos, axis=1)
+        dist_mean = (dist_cumsum[ends] - dist_cumsum[start]) / sizes
+
+        with np.errstate(invalid="ignore"):
+            valid = (
+                np.isfinite(radius)
+                & (radius > 1e-06)
+                & (dist_center < dist_mean)
+                & (radius < r_max)
+            )
+        idx = np.flatnonzero(valid)
+
+        if len(idx) > 0:
+            dist_all = np.linalg.norm(keypoints[None] - center[idx, None], axis=2)
+            fits = np.all(dist_all / radius[idx, None] > circle_fit_thresh, axis=1)
+            hits = idx[fits]
+
+            if len(hits) > 0:
+                best = hits[-1]
+                radii.append(float(radius[best]))
+                start = int(ends[best])
+                continue
+
+        start += 1
+
+    return np.array(radii)
+
+
+def _select_convex_points(keypoints: np.ndarray) -> np.ndarray:
+    wrapped = np.vstack([keypoints[-1], keypoints, keypoints[0]])
+    vec1 = wrapped[1:-1] - wrapped[:-2]
+    vec2 = wrapped[2:] - wrapped[1:-1]
+
+    angle = np.arctan2(
+        vec1[:, 0] * vec2[:, 1] - vec1[:, 1] * vec2[:, 0],
+        vec1[:, 0] * vec2[:, 0] + vec1[:, 1] * vec2[:, 1],
+    )
+    orientation = 1.0 if _signed_area(keypoints) >= 0.0 else -1.0
+    oriented = angle * orientation
+
+    concave_locs = np.where(oriented < 0.0)[0]
+    idx = concave_locs[0] if len(concave_locs) > 0 else int(np.argmax(oriented))
+    keypoints = np.roll(keypoints, -idx, axis=0)
+    oriented = np.roll(oriented, -idx)
+    return keypoints[oriented > 0.0]
+
+
+def _signed_area(points: np.ndarray) -> float:
+    x, y = points.T
+    area = np.dot(x[:-1], y[1:]) + x[-1] * y[0] - np.dot(y[:-1], x[1:]) - y[-1] * x[0]
+    return 0.5 * float(area)
+
+
+def _fit_circles(
+    points: np.ndarray, sizes: np.ndarray
+) -> tuple[np.ndarray, np.ndarray]:
+    # Moments are taken relative to the first point so the centered sums stay
+    # accurate for short prefixes.
+    origin = points[0].astype(np.float64)
+    x, y = (points.astype(np.float64) - origin).T
+    sums = np.cumsum(
+        np.stack([x, y, x * x, x * y, y * y, x**3, x * x * y, x * y * y, y**3]),
+        axis=1,
+    )[:, sizes - 1]
+    sx, sy, sxx, sxy, syy, sxxx, sxxy, sxyy, syyy = sums
+
+    n = sizes.astype(np.float64)
+    mx = sx / n
+    my = sy / n
+
+    suu = sxx - n * mx * mx
+    suv = sxy - n * mx * my
+    svv = syy - n * my * my
+    suuu = sxxx - 3 * mx * sxx + 2 * n * mx**3
+    svvv = syyy - 3 * my * syy + 2 * n * my**3
+    suuv = sxxy - my * sxx - 2 * mx * sxy + 2 * n * mx * mx * my
+    suvv = sxyy - mx * syy - 2 * my * sxy + 2 * n * mx * my * my
+
+    det = suu * svv - suv * suv
+    # Nearly collinear prefixes make the normal equations ill-conditioned.
+    singular = det <= 1e-06 * np.square(suu + svv)
+    det = np.where(singular, 1.0, det)
+
+    rhs_u = 0.5 * (suuu + suvv)
+    rhs_v = 0.5 * (suuv + svvv)
+    uc = (svv * rhs_u - suv * rhs_v) / det
+    vc = (suu * rhs_v - suv * rhs_u) / det
+
+    radius = np.sqrt(uc * uc + vc * vc + (suu + svv) / n)
+    center = np.stack([uc + mx, vc + my], axis=1) + origin
+
+    for i in np.flatnonzero(singular):
+        radius[i], center[i] = _fit_circle(points[: sizes[i]])
+
+    return radius, center
+
+
+def _fit_circle(points: np.ndarray) -> tuple[float, np.ndarray]:
+    points = points.reshape(-1, 2).copy()
+    num_pts = points.shape[0]
+
+    x_min = float(points[:, 0].min())
+    x_max = float(points[:, 0].max())
+    y_min = float(points[:, 1].min())
+    y_max = float(points[:, 1].max())
+
+    x_span = x_max - x_min
+    y_span = y_max - y_min
+    scale = 0.5 * max(x_span, y_span)
+
+    if scale < 1e-12:
+        return (0.0, points[0].copy())
+
+    offset = np.array([(x_max + x_min) * 0.5, (y_max + y_min) * 0.5], dtype=np.float64)
+    points_norm = (points - offset) / scale
+
+    B = np.empty((num_pts, 3), dtype=points_norm.dtype)
+    B[:, :2] = points_norm
+    B[:, 2] = 1.0
+
+    d = np.square(points_norm).sum(axis=1)
+    y, *_ = np.linalg.lstsq(B, d, rcond=np.finfo(float).eps)
+
+    norm_center = 0.5 * y[:2]
+    norm_radius = float(np.sqrt(y[2] + np.square(norm_center).sum()))
+    center = norm_center * scale + offset
+
+    if not np.all(np.isfinite(center)):
+        return (0.0, points[0].copy())
+
+    radius = norm_radius * scale
+
+    if not np.isfinite(radius):
+        return (0.0, center)
+
+    return (radius, center)

grainmorph/wadell/discretize.py

@@ -0,0 +1,66 @@
+import math
+
+import numpy as np
+
+
+def discretize_boundary(boundary: np.ndarray, max_dev_thresh: float) -> np.ndarray:
+    num_pts = len(boundary)
+
+    segment_start = 0
+    segment_end = num_pts
+    keypoints = [boundary[0]]
+
+    boundary = np.vstack([boundary, boundary[0]])
+    total_length = len(boundary)
+
+    while segment_start < num_pts:
+        max_dev, position_index = max_line_deviation(
+            boundary[segment_start:segment_end]
+        )
+
+        while max_dev > max_dev_thresh:
+            new_end = position_index + segment_start
+
+            if new_end <= segment_start:
+                segment_end = segment_start + 2
+                break
+
+            segment_end = new_end
+            max_dev, position_index = max_line_deviation(
+                boundary[segment_start:segment_end]
+            )
+
+        if segment_end != total_length or segment_start == 0:
+            idx = min(segment_end - 1, total_length - 1)
+            keypoints.append(boundary[idx])
+
+        segment_start = segment_end
+        segment_end = total_length
+
+    return np.array(keypoints)
+
+
+def max_line_deviation(points: np.ndarray) -> tuple[float, int]:
+    if len(points) <= 1:
+        return (0.0, 0)
+
+    x = points[:, 0]
+    y = points[:, 1]
+    x0, y0 = points[0].tolist()
+    x1, y1 = points[-1].tolist()
+
+    dx = x1 - x0
+    dy = y0 - y1
+    dist_end_sq = dx * dx + dy * dy
+
+    if dist_end_sq < 1e-12:
+        dist_sq = np.square(x - x0) + np.square(y - y0)
+        idx = int(dist_sq.argmax())
+
+        return (math.sqrt(float(dist_sq[idx])), idx)
+
+    c = y1 * x0 - y0 * x1
+    dist_num = np.abs(dy * x + dx * y + c)
+    idx = int(dist_num.argmax())
+
+    return (float(dist_num[idx]) / math.sqrt(dist_end_sq), idx)

grainmorph/wadell/roundness.py

@@ -0,0 +1,61 @@
+import cv2
+import numpy as np
+
+from ..fitting import find_inscribed_circle
+from ..mask_ops import crop_mask
+from ..schema import Mask
+from .boundary import extract_boundary
+from .corner import compute_corner_radii
+from .discretize import discretize_boundary
+from .smoothing import smooth_boundary
+
+
+def compute_roundness(
+    mask: Mask,
+    max_dev_thresh: float = 0.3,
+    circle_fit_thresh: float = 0.98,
+    alpha_ratio: float = 0.05,
+    beta_ratio: float = 0.001,
+) -> float | None:
+    mask_cropped, _, _ = crop_mask(mask, pad=1)
+    if mask_cropped.size == 0:
+        return None
+
+    inscribed = find_inscribed_circle(mask_cropped)
+    if inscribed is None or inscribed["r"] < 1e-6:
+        return None
+
+    max_radius = inscribed["r"]
+    max_radius_pos = np.array([inscribed["x"], inscribed["y"]])
+
+    boundary = extract_boundary(mask_cropped)
+    if len(boundary) < 3:
+        return None
+
+    perimeter = float(
+        cv2.arcLength(boundary.astype(np.float32).reshape(-1, 1, 2), closed=True)
+    )
+    if perimeter < 1e-6:
+        return None
+
+    smoothed_boundary = smooth_boundary(
+        boundary,
+        perimeter=perimeter,
+        alpha_ratio=alpha_ratio,
+        beta_ratio=beta_ratio,
+    )
+
+    keypoints = discretize_boundary(smoothed_boundary, max_dev_thresh)
+    if len(keypoints) < 3:
+        return None
+
+    radii = compute_corner_radii(
+        keypoints,
+        max_radius,
+        max_radius_pos,
+        circle_fit_thresh,
+    )
+    if len(radii) == 0:
+        return None
+
+    return float(np.mean(radii) / max_radius)

grainmorph/wadell/smoothing.py

@@ -0,0 +1,41 @@
+import numpy as np
+
+
+def smooth_boundary(
+    points: np.ndarray,
+    perimeter: float,
+    alpha_ratio: float = 0.05,
+    beta_ratio: float = 0.001,
+) -> np.ndarray:
+    num_points = len(points)
+
+    if not np.isfinite(perimeter) or perimeter <= 0:
+        raise ValueError("perimeter must be > 0 and finite.")
+    if not np.isfinite(alpha_ratio) or not np.isfinite(beta_ratio):
+        raise ValueError("smoothing ratios must be finite.")
+
+    alpha = alpha_ratio * perimeter
+    beta = beta_ratio * perimeter
+    kernel = _regularization_kernel(num_points, alpha, beta)
+
+    eigenvalues = np.fft.fft(kernel)
+    transformed = np.fft.fft(points, axis=0)
+    tolerance = np.finfo(float).eps * num_points * float(np.max(np.abs(eigenvalues)))
+    usable = np.abs(eigenvalues) > tolerance
+    solution = np.zeros_like(transformed)
+    np.divide(
+        transformed,
+        eigenvalues[:, None],
+        out=solution,
+        where=usable[:, None],
+    )
+    return np.fft.ifft(solution, axis=0).real
+
+
+def _regularization_kernel(num_points: int, alpha: float, beta: float) -> np.ndarray:
+    coefficients = alpha * np.array([-2, 1, 0, 0]) + beta * np.array([-6, 4, -1, 0])
+    indices = np.arange(num_points)
+    distances = np.minimum(indices, num_points - indices)
+    kernel = -coefficients[np.minimum(distances, len(coefficients) - 1)]
+    kernel[0] += 1.0
+    return kernel