tessl/pypi-scikit-image
Comprehensive image processing and computer vision library for Python with algorithms for filtering, morphology, segmentation, and feature detection
—
Pending
transform.mddocs/
Transformations
Geometric and coordinate transformations for image registration, warping, scaling, and analysis. Includes support for various transformation models, image pyramids, and specialized transforms like Hough and Radon transforms.
Capabilities
Basic Image Transformations
Fundamental operations for resizing, rotating, and scaling images with various interpolation methods.
def resize(image, output_shape, order=None, mode='reflect', cval=0, clip=True, preserve_range=False, anti_aliasing=None, anti_aliasing_sigma=None):
"""
Resize image to specified dimensions.
Parameters:
image : array_like
Input image
output_shape : tuple
Target output shape (rows, cols)
order : int, optional
Interpolation order (0-5)
mode : str, optional
Boundary condition mode
cval : float, optional
Constant value for constant mode
clip : bool, optional
Whether to clip output to input range
preserve_range : bool, optional
Keep original data range
anti_aliasing : bool, optional
Whether to apply anti-aliasing
anti_aliasing_sigma : float, optional
Standard deviation for anti-aliasing
Returns:
ndarray
Resized image
"""
def rescale(image, scale, order=None, mode='reflect', cval=0, clip=True, preserve_range=False, multichannel=None, anti_aliasing=None, anti_aliasing_sigma=None, channel_axis=None):
"""
Scale image by a given factor.
Parameters:
image : array_like
Input image
scale : float or sequence
Scale factor(s) for each axis
order : int, optional
Interpolation order (0-5)
mode : str, optional
Boundary condition mode
cval : float, optional
Constant value for constant mode
clip : bool, optional
Whether to clip output to input range
preserve_range : bool, optional
Keep original data range
multichannel : bool, optional
Whether last axis is channels (deprecated)
anti_aliasing : bool, optional
Whether to apply anti-aliasing
anti_aliasing_sigma : float, optional
Standard deviation for anti-aliasing
channel_axis : int, optional
Axis for color channels
Returns:
ndarray
Rescaled image
"""
def rotate(image, angle, resize=False, center=None, order=None, mode='constant', cval=0, clip=True, preserve_range=False):
"""
Rotate image by specified angle.
Parameters:
image : array_like
Input image
angle : float
Rotation angle in degrees (counter-clockwise)
resize : bool, optional
Whether to resize output to fit rotated image
center : tuple, optional
Center of rotation
order : int, optional
Interpolation order (0-5)
mode : str, optional
Boundary condition mode
cval : float, optional
Constant value for constant mode
clip : bool, optional
Whether to clip output to input range
preserve_range : bool, optional
Keep original data range
Returns:
ndarray
Rotated image
"""
def swirl(image, center=None, strength=1, radius=120, rotation=0, output_shape=None, order=None, mode='reflect', cval=0, clip=True, preserve_range=False):
"""
Apply swirl transformation to image.
Parameters:
image : array_like
Input image
center : tuple, optional
Center of swirl
strength : float, optional
Swirl strength
radius : float, optional
Swirl radius
rotation : float, optional
Additional rotation angle
output_shape : tuple, optional
Shape of output
order : int, optional
Interpolation order (0-5)
mode : str, optional
Boundary condition mode
cval : float, optional
Constant value for constant mode
clip : bool, optional
Whether to clip output to input range
preserve_range : bool, optional
Keep original data range
Returns:
ndarray
Swirl-transformed image
"""Image Warping
Advanced warping operations using coordinate transformations and mapping functions.
def warp(image, inverse_map, map_args=None, output_shape=None, order=None, mode='constant', cval=0.0, clip=True, preserve_range=False):
"""
Warp image using inverse coordinate transformation.
Parameters:
image : array_like
Input image
inverse_map : callable or ndarray
Inverse coordinate mapping function or coordinate array
map_args : dict, optional
Additional arguments for mapping function
output_shape : tuple, optional
Shape of output image
order : int, optional
Interpolation order (0-5)
mode : str, optional
Boundary condition mode
cval : float, optional
Constant value for constant mode
clip : bool, optional
Whether to clip output to input range
preserve_range : bool, optional
Keep original data range
Returns:
ndarray
Warped image
"""
def warp_coords(coord_map, shape, dtype=np.float64):
"""
Build coordinate map for image warping.
Parameters:
coord_map : callable
Function mapping (row, col) coordinates
shape : tuple
Shape of coordinate array
dtype : data-type, optional
Data type of coordinate array
Returns:
ndarray
Coordinate array for warping
"""
def warp_polar(image, center=None, radius=None, output_shape=None, scaling='linear', multichannel=None, channel_axis=None):
"""
Transform image from Cartesian to polar coordinates.
Parameters:
image : array_like
Input image
center : tuple, optional
Center point for transformation
radius : float, optional
Maximum radius for transformation
output_shape : tuple, optional
Shape of output image
scaling : str, optional
Scaling method ('linear' or 'log')
multichannel : bool, optional
Whether last axis is channels (deprecated)
channel_axis : int, optional
Axis for color channels
Returns:
ndarray
Polar-transformed image
"""Transformation Classes
Object-oriented interface for geometric transformations with parameter estimation and composition.
class EuclideanTransform:
"""
Euclidean (rigid) transformation: rotation + translation.
Parameters:
rotation : float, optional
Rotation angle in radians
translation : tuple, optional
Translation vector (dx, dy)
matrix : array_like, optional
Homogeneous transformation matrix
"""
def __init__(self, rotation=None, translation=None, matrix=None):
pass
def estimate(self, src, dst):
"""Estimate transformation from point correspondences."""
pass
def __call__(self, coords):
"""Apply transformation to coordinates."""
pass
class SimilarityTransform:
"""
Similarity transformation: rotation + translation + uniform scaling.
Parameters:
matrix : array_like, optional
Homogeneous transformation matrix
scale : float, optional
Scale factor
rotation : float, optional
Rotation angle in radians
translation : tuple, optional
Translation vector
"""
def __init__(self, matrix=None, scale=None, rotation=None, translation=None):
pass
def estimate(self, src, dst):
"""Estimate transformation from point correspondences."""
pass
def __call__(self, coords):
"""Apply transformation to coordinates."""
pass
class AffineTransform:
"""
Affine transformation: linear transformation + translation.
Parameters:
matrix : array_like, optional
Homogeneous transformation matrix
scale : tuple, optional
Scale factors for each axis
rotation : float, optional
Rotation angle in radians
shear : float, optional
Shear angle in radians
translation : tuple, optional
Translation vector
"""
def __init__(self, matrix=None, scale=None, rotation=None, shear=None, translation=None):
pass
def estimate(self, src, dst):
"""Estimate transformation from point correspondences."""
pass
def __call__(self, coords):
"""Apply transformation to coordinates."""
pass
class ProjectiveTransform:
"""
Projective (homography) transformation.
Parameters:
matrix : array_like, optional
Homogeneous transformation matrix
"""
def __init__(self, matrix=None):
pass
def estimate(self, src, dst):
"""Estimate transformation from point correspondences."""
pass
def __call__(self, coords):
"""Apply transformation to coordinates."""
pass
class PiecewiseAffineTransform:
"""
Piecewise affine transformation using triangulation.
"""
def __init__(self):
pass
def estimate(self, src, dst):
"""Estimate transformation from point correspondences."""
pass
def __call__(self, coords):
"""Apply transformation to coordinates."""
pass
class PolynomialTransform:
"""
Polynomial coordinate transformation.
Parameters:
params : array_like, optional
Polynomial coefficients
"""
def __init__(self, params=None):
pass
def estimate(self, src, dst, order=2):
"""Estimate transformation from point correspondences."""
pass
def __call__(self, coords):
"""Apply transformation to coordinates."""
passTransformation Estimation
Estimate geometric transformations from point correspondences using various algorithms.
def estimate_transform(ttype, src, dst, **kwargs):
"""
Estimate geometric transformation from point correspondences.
Parameters:
ttype : str or Transform class
Type of transformation ('euclidean', 'similarity', 'affine', 'projective', 'polynomial', 'piecewise-affine')
src : array_like
Source coordinates
dst : array_like
Destination coordinates
**kwargs
Additional arguments for transformation estimation
Returns:
Transform
Estimated transformation object
"""
def matrix_transform(coords, matrix):
"""
Apply matrix transformation to coordinates.
Parameters:
coords : array_like
Input coordinates
matrix : array_like
Transformation matrix
Returns:
ndarray
Transformed coordinates
"""Hough Transforms
Detect geometric shapes using Hough transform methods.
def hough_line(image, theta=None):
"""
Classical Hough transform for straight line detection.
Parameters:
image : array_like
Input binary edge image
theta : array_like, optional
Angles to test (default: 0 to π)
Returns:
tuple
(accumulator, angles, distances)
"""
def hough_line_peaks(hspace, angles, dists, min_angle=1, min_distance=1, threshold=None, num_peaks=np.inf):
"""
Find peaks in Hough line transform.
Parameters:
hspace : array_like
Hough transform accumulator
angles : array_like
Angles corresponding to accumulator
dists : array_like
Distances corresponding to accumulator
min_angle : float, optional
Minimum angle between peaks
min_distance : float, optional
Minimum distance between peaks
threshold : float, optional
Minimum peak threshold
num_peaks : int, optional
Maximum number of peaks
Returns:
tuple
(peak_indices, angles, distances)
"""
def probabilistic_hough_line(image, threshold=10, line_length=50, line_gap=10, theta=None, seed=None):
"""
Probabilistic Hough transform for line detection.
Parameters:
image : array_like
Input binary edge image
threshold : int, optional
Minimum vote threshold
line_length : int, optional
Minimum line length
line_gap : int, optional
Maximum gap between line segments
theta : array_like, optional
Angles to test
seed : int, optional
Random seed
Returns:
list
List of line segments as ((x0, y0), (x1, y1))
"""
def hough_circle(image, radius, normalize=True, full_output=False):
"""
Hough transform for circle detection.
Parameters:
image : array_like
Input binary edge image
radius : array_like
Circle radii to detect
normalize : bool, optional
Normalize accumulator by circle perimeter
full_output : bool, optional
Return additional outputs
Returns:
ndarray or tuple
Accumulator array(s)
"""
def hough_circle_peaks(hspaces, radii, min_xdistance=1, min_ydistance=1, threshold=None, num_peaks=np.inf, total_num_peaks=np.inf, normalize=False):
"""
Find peaks in Hough circle transform.
Parameters:
hspaces : array_like
Circle accumulator arrays
radii : array_like
Circle radii
min_xdistance : int, optional
Minimum x distance between peaks
min_ydistance : int, optional
Minimum y distance between peaks
threshold : float, optional
Minimum peak threshold
num_peaks : int, optional
Maximum peaks per radius
total_num_peaks : int, optional
Maximum total peaks
normalize : bool, optional
Normalize by circle perimeter
Returns:
tuple
(y_peaks, x_peaks, radii_peaks)
"""
def hough_ellipse(image, accuracy=1, threshold=4, min_size=4, max_size=None):
"""
Hough transform for ellipse detection.
Parameters:
image : array_like
Input binary edge image
accuracy : float, optional
Bin size for accumulator
threshold : int, optional
Minimum vote threshold
min_size : float, optional
Minimum ellipse size
max_size : float, optional
Maximum ellipse size
Returns:
list
List of ellipse parameters
"""Radon Transform
Radon transform and inverse transform for tomographic reconstruction and analysis.
def radon(image, theta=None, circle=None, preserve_range=None):
"""
Compute Radon transform (forward projection).
Parameters:
image : array_like
Input image
theta : array_like, optional
Projection angles in degrees
circle : bool, optional
Whether to use circular domain
preserve_range : bool, optional
Keep original data range
Returns:
ndarray
Radon transform (sinogram)
"""
def iradon(radon_image, theta=None, output_size=None, filter_name='ramp', interpolation='linear', circle=None, preserve_range=None):
"""
Compute inverse Radon transform (filtered backprojection).
Parameters:
radon_image : array_like
Input sinogram
theta : array_like, optional
Projection angles in degrees
output_size : int, optional
Output image size
filter_name : str, optional
Filter type ('ramp', 'shepp-logan', 'cosine', 'hamming', 'hann', None)
interpolation : str, optional
Interpolation method ('linear' or 'nearest')
circle : bool, optional
Whether to use circular domain
preserve_range : bool, optional
Keep original data range
Returns:
ndarray
Reconstructed image
"""
def iradon_sart(radon_image, theta=None, image=None, projection_shifts=None, clip=None, relaxation=0.15):
"""
Simultaneous Algebraic Reconstruction Technique (SART).
Parameters:
radon_image : array_like
Input sinogram
theta : array_like, optional
Projection angles in degrees
image : array_like, optional
Initial image estimate
projection_shifts : array_like, optional
Shifts for each projection
clip : tuple, optional
Data range for clipping
relaxation : float, optional
Relaxation parameter
Returns:
ndarray
Reconstructed image
"""Image Pyramids
Generate and manipulate image pyramids for multi-scale analysis and processing.
def pyramid_reduce(image, downscale=2, sigma=None, order=1, mode='reflect', cval=0, multichannel=None, preserve_range=False, channel_axis=None):
"""
Smooth and downsample image.
Parameters:
image : array_like
Input image
downscale : float, optional
Downsampling factor
sigma : float, optional
Gaussian smoothing parameter
order : int, optional
Interpolation order
mode : str, optional
Boundary condition mode
cval : float, optional
Constant value for constant mode
multichannel : bool, optional
Whether last axis is channels (deprecated)
preserve_range : bool, optional
Keep original data range
channel_axis : int, optional
Axis for color channels
Returns:
ndarray
Downsampled image
"""
def pyramid_expand(image, upscale=2, sigma=None, order=1, mode='reflect', cval=0, multichannel=None, preserve_range=False, channel_axis=None):
"""
Upsample and smooth image.
Parameters:
image : array_like
Input image
upscale : float, optional
Upsampling factor
sigma : float, optional
Gaussian smoothing parameter
order : int, optional
Interpolation order
mode : str, optional
Boundary condition mode
cval : float, optional
Constant value for constant mode
multichannel : bool, optional
Whether last axis is channels (deprecated)
preserve_range : bool, optional
Keep original data range
channel_axis : int, optional
Axis for color channels
Returns:
ndarray
Upsampled image
"""
def pyramid_gaussian(image, max_layer=-1, downscale=2, sigma=None, order=1, mode='reflect', cval=0, multichannel=None, preserve_range=False, channel_axis=None):
"""
Generate Gaussian pyramid.
Parameters:
image : array_like
Input image
max_layer : int, optional
Number of pyramid layers
downscale : float, optional
Downsampling factor between layers
sigma : float, optional
Gaussian smoothing parameter
order : int, optional
Interpolation order
mode : str, optional
Boundary condition mode
cval : float, optional
Constant value for constant mode
multichannel : bool, optional
Whether last axis is channels (deprecated)
preserve_range : bool, optional
Keep original data range
channel_axis : int, optional
Axis for color channels
Yields:
ndarray
Images in pyramid from finest to coarsest
"""
def pyramid_laplacian(image, max_layer=-1, downscale=2, sigma=None, order=1, mode='reflect', cval=0, multichannel=None, preserve_range=False, channel_axis=None):
"""
Generate Laplacian pyramid.
Parameters:
image : array_like
Input image
max_layer : int, optional
Number of pyramid layers
downscale : float, optional
Downsampling factor between layers
sigma : float, optional
Gaussian smoothing parameter
order : int, optional
Interpolation order
mode : str, optional
Boundary condition mode
cval : float, optional
Constant value for constant mode
multichannel : bool, optional
Whether last axis is channels (deprecated)
preserve_range : bool, optional
Keep original data range
channel_axis : int, optional
Axis for color channels
Yields:
ndarray
Images in pyramid from finest to coarsest
"""Usage Examples
Basic Geometric Transformations
from skimage import data, transform
import matplotlib.pyplot as plt
import numpy as np
# Load image
image = data.camera()
# Apply basic transformations
resized = transform.resize(image, (256, 256))
rotated = transform.rotate(image, 45)
scaled = transform.rescale(image, 0.5, anti_aliasing=True)
# Display results
fig, axes = plt.subplots(2, 2, figsize=(10, 8))
axes[0, 0].imshow(image, cmap='gray')
axes[0, 0].set_title('Original')
axes[0, 1].imshow(resized, cmap='gray')
axes[0, 1].set_title('Resized')
axes[1, 0].imshow(rotated, cmap='gray')
axes[1, 0].set_title('Rotated 45°')
axes[1, 1].imshow(scaled, cmap='gray')
axes[1, 1].set_title('Scaled 0.5x')
plt.show()Image Registration
from skimage import data, transform
import numpy as np
# Create reference and transformed images
reference = data.camera()
angle = 30
tform = transform.SimilarityTransform(rotation=np.deg2rad(angle))
shifted = transform.warp(reference, tform.inverse)
# Estimate transformation
src = np.array([[100, 100], [200, 100], [100, 200]])
dst = tform(src)
# Estimate transformation from correspondences
estimated_tform = transform.estimate_transform('similarity', src, dst)
recovered = transform.warp(shifted, estimated_tform.inverse)
print(f"Original angle: {angle}°")
print(f"Estimated angle: {np.rad2deg(estimated_tform.rotation):.1f}°")Hough Line Detection
from skimage import data, feature, transform
import matplotlib.pyplot as plt
import numpy as np
# Load and detect edges
image = data.camera()
edges = feature.canny(image, sigma=2, low_threshold=0.1, high_threshold=0.2)
# Classical Hough transform
tested_angles = np.linspace(-np.pi/2, np.pi/2, 360, endpoint=False)
h, theta, d = transform.hough_line(edges, theta=tested_angles)
# Find peaks
hough_peaks = transform.hough_line_peaks(h, theta, d, num_peaks=5)
# Display results
fig, axes = plt.subplots(1, 3, figsize=(15, 5))
axes[0].imshow(image, cmap='gray')
axes[0].set_title('Original')
axes[1].imshow(edges, cmap='gray')
axes[1].set_title('Edges')
axes[2].imshow(h, extent=[np.rad2deg(theta[-1]), np.rad2deg(theta[0]), d[-1], d[0]], cmap='hot', aspect='auto')
axes[2].set_title('Hough Transform')
plt.show()Types
from typing import Union, Optional, Tuple, Callable, Generator
from numpy.typing import NDArray
import numpy as np
# Transformation parameters
TransformMatrix = NDArray[np.floating]
CoordinateArray = NDArray[np.floating]
TransformType = str
# Transformation classes
Transform = Union[EuclideanTransform, SimilarityTransform, AffineTransform, ProjectiveTransform, PiecewiseAffineTransform, PolynomialTransform]
# Hough transform results
HoughAccumulator = NDArray[np.floating]
HoughPeaks = Tuple[NDArray[np.integer], NDArray[np.floating], NDArray[np.floating]]
# Pyramid generator
PyramidGenerator = Generator[NDArray[np.floating], None, None]
# Geometric shapes
LineSegment = Tuple[Tuple[int, int], Tuple[int, int]]
Circle = Tuple[int, int, float] # (center_x, center_y, radius)
Ellipse = Tuple[float, float, float, float, float] # (center_x, center_y, a, b, orientation)Install with Tessl CLI
npx tessl i tessl/pypi-scikit-image