Vision Systems & Engineering

scikit-image

The Python image processing library that works on NumPy arrays, with its modules, its conventions for data types and coordinates, its versions and licence, and an example that checks those conventions on a synthetic image.

beginner

scikit-image is an image processing library for Python whose functions take and return NumPy arrays. Its getting-started guide calls it “an image processing Python package that works with numpy arrays”, imported as skimage. Its licence file names the scikit-image team as the copyright holder of the package as a whole, which is distributed under the 3-clause BSD licence, with a few files under the 2-clause BSD or MIT licence. The README asks users who find the project useful to cite van der Walt et al. (2014); we have not read that paper. Many examples on this site use scikit-image to build and measure synthetic images.

This article covers what the library contains, the conventions that decide the numbers it returns, and how its versions differ. The examples ran with scikit-image 0.25.2. Newer releases exist (0.26.0 is the latest stable release and 0.27.0rc1 a release candidate, as of November 2026), and nothing is claimed about them beyond what the 0.26.0 release notes say. Array basics belong to the NumPy article, and the general clash between (x,y)(x, y) positions and image[row, column] indexing belongs to the digital image article. The OpenCV article lists this library among OpenCV’s alternatives.

Purpose

The library collects classical image processing algorithms behind one Python interface. The interface is plain arrays: in the user guide’s words, “images are simply numpy arrays”, so the output of one function can go straight into another, or into SciPy, scikit-learn or a plotting library. The guide also explains the cost of this choice. An array does not record what its values mean, so the library assumes a value range for each data type.

Core Capabilities

Modules. Most functions live in submodules, which the installed 0.25.2 package lists as color, data, draw, exposure, feature, filters, future, graph, io, measure, metrics, morphology, registration, restoration, segmentation, transform and util. Since 0.19 they load lazily, so after import skimage as ski a call such as ski.transform.warp works without importing the submodule first. The user guide and its glossary name some of what they hold:

  • contrast functions in exposure;
  • label images from measure.label, and segmentation algorithms in segmentation;
  • geometric transforms with an estimate method for fitting them to point pairs, and warp for applying them to images;
  • feature detectors such as ORB and BRIEF, with match_descriptors for matching them;
  • full-field translation estimation with registration.phase_cross_correlation.

Several site articles describe single functions. Region growing covers flood, thresholding covers threshold_sauvola, graph-based image segmentation covers felzenszwalb, and the pixel article covers resize.

Data types and ranges. The library assumes that integer images span their type’s whole range and that float images lie in [0,1][0, 1], or [−1,1][-1, 1] for signed data. img_as_float does not check the range of float input, and the data-types page says plainly that one “should never use astype on an image”, because a cast keeps the values and breaks the assumption.

The converters img_as_float, img_as_ubyte, img_as_uint and img_as_int rescale as they convert. In the 0.25.2 source, an unsigned integer image becomes float by multiplying by 1/max1/\text{max} of its type. Float input that is already float is passed through unchanged, and a float image outside [−1,1][-1, 1] makes the integer converters raise “Images of type float must be between -1 and 1.”

Functions with a preserve_range argument convert their input in the same way unless preserve_range=True is passed, which the guide describes for values that are physical measurements, such as temperature, that should not be rescaled. For cameras with 10-, 12- or 14-bit samples stored in uint16, it recommends exposure.rescale_intensity with in_range set to the true range. The point operations article covers rescale_intensity as a contrast stretch.

Channels. Colour images carry channels on the last axis, as (row, col, ch); a volume is (pln, row, col). Since 0.19 the axis is chosen with channel_axis. Functions that require several channels default to channel_axis=-1, and the others default to None, meaning no channel axis.

Coordinates. The user guide indexes images by (row, col), with the origin at the top-left corner, and keeps (x,y)(x, y) for Cartesian coordinates. Functions differ in which they use. draw and measure.regionprops work in (row, col). The transform classes in transform take and return (x,y)=(col,row)(x, y) = (\text{col}, \text{row}) points, measured from the same top-left origin with yy pointing down (part 3 of the example shows the direction), and warp expects the inverse map, from output coordinates to input coordinates, which is why the user guide writes warp(img, tform.inverse).

Example data. skimage.data returns test images. In 0.25.2 the registry lists 32 files that ship with the package, among them camera, coins and chelsea. Newer datasets, in the module’s words, “are downloaded on demand” through the optional pooch package. Without pooch, the bundled files still load, and the fetcher raises ModuleNotFoundError for any other file.

Minimal Example

The example checks five of these conventions on one synthetic scene with known ground truth. The scene is a 96×12896 \times 128 uint16 image that holds 12-bit values: a horizontal ramp of 200+8 col200 + 8\,\text{col}, and three disks of value 4,095 drawn with draw.disk at (row, col) centres (30, 40), (60, 90) and (70, 25), with radii 8, 10 and 6. The image is not square, so swapping rows and columns would show. The script checks:

  1. img_as_float divides by 65,535, the maximum of uint16, not by 4,095. The script also applies the user guide’s 12-bit remedy.
  2. regionprops centroids come out as (row, col) and equal the drawn centres. A disk drawn at an integer centre is symmetric, so its centroid is exact.
  3. warp with SimilarityTransform(translation=(5, 2)).inverse, applied to the label image at interpolation orders 0 and 1, moves every centroid by 2 rows and 5 columns. The script also records which coordinate pairs warp_coords passes to a callable.
  4. filters.gaussian, whose default border mode is 'nearest', is compared with SciPy’s gaussian_filter, whose default is 'reflect'. A hand-written separable convolution, using SciPy’s kernel definition and np.pad modes 'edge' and 'symmetric', serves as an independent reference for each. The ramp gives the border something to differ on: next to a constant background, the two modes would extend the image identically.
  5. color.rgb2gray (weights 0.2125, 0.7154 and 0.0721) is compared with Pillow 12.0.0’s convert("L") on pure red, green, blue and white patches.

Before the run. Every hypothesis and tolerance was written down before any script ran. Each expected an exact result, one within floating-point rounding, or, for the border difference, a value above a bar; the tolerances are listed with the results. A planning script then computed the reference values with NumPy alone, calling no function under test (only draw.disk, to build the scene):

  • the mean coordinates of each drawn disk;
  • the shift by array slicing;
  • the hand convolutions;
  • Pillow’s integer formula.

Changes to the plan. Several parts go beyond the batch plan’s description of the example, and the editor approved them before the run:

  • the rescale_intensity remedy;
  • the warp_coords check;
  • warping the label image at both orders;
  • the hand references for the Gaussian;
  • Pillow’s expected values taken from its C source;
  • the ramp background, chosen before any run, by the argument above, so that the border modes could differ;
  • the sizes, positions and σ=2\sigma = 2, which are our choices.

Runs. A pilot of the same script printed the same output as the run shown. The script runs in well under a second, and two runs printed identical output. Nothing in it is random.

import os
for v in ("OPENBLAS_NUM_THREADS", "OMP_NUM_THREADS", "MKL_NUM_THREADS"):
    os.environ[v] = "1"                        # one BLAS thread, set before NumPy is imported
import numpy as np
import scipy
from scipy import ndimage as ndi
import skimage as ski
import PIL
from PIL import Image

print("NumPy", np.__version__, "| SciPy", scipy.__version__, "| scikit-image", ski.__version__,
      "| Pillow", PIL.__version__)

# A 12-bit scene stored as uint16, shape (rows, cols) = (96, 128): a horizontal ramp
# 200 + 8 * col and three disks of value 4095 at known (row, col) centres.
H, W = 96, 128
disks = [((30, 40), 8), ((60, 90), 10), ((70, 25), 6)]      # ((row, col), radius)
img = (200 + 8 * np.arange(W, dtype=np.uint16))[None, :].repeat(H, axis=0)
labels = np.zeros((H, W), np.int64)
for k, (centre, radius) in enumerate(disks, start=1):
    rr, cc = ski.draw.disk(centre, radius, shape=(H, W))    # draw takes and returns (row, col)
    labels[rr, cc] = k
    img[rr, cc] = 4095
sizes = [int((labels == k).sum()) for k in (1, 2, 3)]
drawn = [ski.draw.disk(c, r, shape=(H, W))[0].size for c, r in disks]
rows, cols = np.nonzero(labels)
print("data:", img.dtype, img.shape, "max", int(img.max()), "| disk sizes", sizes,
      "drawn", drawn, "| margin after shift: rows", H - 1 - (rows.max() + 2),
      "cols", W - 1 - (cols.max() + 5))

# 1. dtype ranges: img_as_float divides by the dtype's maximum, not by the bit depth's.
f = ski.util.img_as_float(img)
print("\n1. img_as_float:", f.dtype, "max %.17g" % f.max(), "| 4095/65535 = %.17g" % (4095 / 65535),
      "| diff %.3e" % abs(f.max() - 4095 / 65535))
f12 = ski.util.img_as_float(ski.exposure.rescale_intensity(img, in_range="uint12"))
print("   after rescale_intensity(in_range='uint12'):", f12.dtype, "max %.17g" % f12.max(),
      "| diff from 1 %.3e" % abs(f12.max() - 1.0))

# 2. regionprops returns centroids as (row, col).
print("\n2. regionprops centroids (row, col):")
err2 = 0.0
for p, (centre, _) in zip(ski.measure.regionprops(labels), disks):
    err2 = max(err2, abs(p.centroid[0] - centre[0]), abs(p.centroid[1] - centre[1]))
    print("   label", p.label, "true", centre, "measured (%.6f, %.6f)" % p.centroid)
print("   max |error| %.3e px" % err2)

# 3a. Transform objects take (x, y) = (col, row): translation=(5, 2) is 5 columns and 2 rows.
tform = ski.transform.SimilarityTransform(translation=(5, 2))
print("\n3a. warp(labels, SimilarityTransform(translation=(5, 2)).inverse):")
for order in (0, 1):
    moved = ski.transform.warp(labels, tform.inverse, order=order, preserve_range=True)
    moved = np.rint(moved).astype(np.int64)                 # labels, not intensities
    err3 = 0.0
    for p, (centre, _) in zip(ski.measure.regionprops(moved), disks):
        d = (p.centroid[0] - centre[0], p.centroid[1] - centre[1])
        err3 = max(err3, abs(d[0] - 2), abs(d[1] - 5))
    print("   order", order, "| shift of label 3 (d_row, d_col) = (%.6f, %.6f)" % d,
          "| max |shift - (2, 5)| over labels %.3e px" % err3)

# 3b. warp_coords: which pairs does it pass to its callable?
seen = []
def record(xy):
    seen.append(xy.copy())
    return xy
ski.transform.warp_coords(record, (3, 5))                   # output shape (rows, cols) = (3, 5)
print("3b. warp_coords on shape (3, 5): column maxima of the pairs passed",
      seen[0].max(axis=0).astype(int).tolist(), "| (rows-1, cols-1) =", [2, 4])

# 4. gaussian (mode 'nearest') against SciPy's gaussian_filter (mode 'reflect'), and a hand
# separable convolution with the same kernel and np.pad 'edge' / 'symmetric' as reference.
sigma = 2.0
rad = int(4.0 * sigma + 0.5)                                # truncate=4.0 in both libraries
g_ski = ski.filters.gaussian(img, sigma=sigma)
g_sp = ndi.gaussian_filter(f, sigma)
x = np.arange(-rad, rad + 1)
w = np.exp(-0.5 * x**2 / sigma**2)
w /= w.sum()
def sep(a, pad_mode):
    p = np.pad(a, rad, mode=pad_mode)
    t = sum(w[i] * p[i:i + a.shape[0], :] for i in range(2 * rad + 1))      # along rows
    return sum(w[i] * t[:, i:i + a.shape[1]] for i in range(2 * rad + 1))   # along columns
inner = np.zeros((H, W), bool)
inner[rad:-rad, rad:-rad] = True
diff = np.abs(g_ski - g_sp)
print("\n4. gaussian vs gaussian_filter, sigma 2, radius", rad,
      "| interior max |diff| %.3e" % diff[inner].max(), "| border max |diff| %.6e" % diff[~inner].max())
print("   hand 'edge' vs gaussian %.3e | hand 'symmetric' vs gaussian_filter %.3e" %
      (np.abs(sep(f, "edge") - g_ski).max(), np.abs(sep(f, "symmetric") - g_sp).max()))

# 5. rgb2gray against Pillow's convert('L') on pure-colour patches.
names = ["red", "green", "blue", "white"]
colours = np.array([[255, 0, 0], [0, 255, 0], [0, 0, 255], [255, 255, 255]], np.uint8)
rgb = np.repeat(np.repeat(colours.reshape(2, 2, 3), 8, axis=0), 8, axis=1)   # 16 x 16 x 3
gray = ski.color.rgb2gray(rgb)
L = np.asarray(Image.fromarray(rgb).convert("L"))
expect_ski = colours / 255 @ np.array([0.2125, 0.7154, 0.0721])
expect_pil = (colours[:, 0].astype(int) * 19595 + colours[:, 1].astype(int) * 38470
              + colours[:, 2].astype(int) * 7471 + 0x8000) >> 16           # Pillow's L24 macro
print("\n5. pure colours:")
for i, n in enumerate(names):
    r, c = divmod(i, 2)
    g_patch = gray[8 * r:8 * r + 8, 8 * c:8 * c + 8]
    l_patch = L[8 * r:8 * r + 8, 8 * c:8 * c + 8]
    print("   %-5s rgb2gray %.6f (x255 = %7.3f) |err| %.3e | Pillow L %3d..%3d, formula %3d" %
          (n, g_patch.mean(), 255 * g_patch.mean(), np.abs(g_patch - expect_ski[i]).max(),
           l_patch.min(), l_patch.max(), expect_pil[i]))
NumPy 2.3.5 | SciPy 1.16.3 | scikit-image 0.25.2 | Pillow 12.0.0
data: uint16 (96, 128) max 4095 | disk sizes [193, 305, 109] drawn [193, 305, 109] | margin after shift: rows 18 cols 23

1. img_as_float: float64 max 0.062485694666971847 | 4095/65535 = 0.062485694666971847 | diff 0.000e+00
   after rescale_intensity(in_range='uint12'): float64 max 1 | diff from 1 0.000e+00

2. regionprops centroids (row, col):
   label 1 true (30, 40) measured (30.000000, 40.000000)
   label 2 true (60, 90) measured (60.000000, 90.000000)
   label 3 true (70, 25) measured (70.000000, 25.000000)
   max |error| 0.000e+00 px

3a. warp(labels, SimilarityTransform(translation=(5, 2)).inverse):
   order 0 | shift of label 3 (d_row, d_col) = (2.000000, 5.000000) | max |shift - (2, 5)| over labels 0.000e+00 px
   order 1 | shift of label 3 (d_row, d_col) = (2.000000, 5.000000) | max |shift - (2, 5)| over labels 0.000e+00 px
3b. warp_coords on shape (3, 5): column maxima of the pairs passed [4, 2] | (rows-1, cols-1) = [2, 4]

4. gaussian vs gaussian_filter, sigma 2, radius 8 | interior max |diff| 0.000e+00 | border max |diff| 4.647517e-05
   hand 'edge' vs gaussian 2.082e-17 | hand 'symmetric' vs gaussian_filter 2.082e-17

5. pure colours:
   red   rgb2gray 0.212500 (x255 =  54.187) |err| 0.000e+00 | Pillow L  76.. 76, formula  76
   green rgb2gray 0.715400 (x255 = 182.427) |err| 0.000e+00 | Pillow L 150..150, formula 150
   blue  rgb2gray 0.072100 (x255 =  18.386) |err| 0.000e+00 | Pillow L  29.. 29, formula  29
   white rgb2gray 1.000000 (x255 = 255.000) |err| 0.000e+00 | Pillow L 255..255, formula 255

Data. The data check held. The image’s maximum is 4,095, the three disk sizes match what draw.disk drew, so the disks do not overlap, and after the shift every disk stays at least 18 rows from the bottom edge and 23 columns from the right edge, the edges it moves towards.

1. Data types. img_as_float returned float64 with maximum 0.062485694666971847, which is exactly 4095/65535 (tolerance 10−1210^{-12}). A 12-bit white therefore becomes about 0.0625 rather than 1, because the converter reads the dtype, not the bit depth of the camera. After rescale_intensity(in_range='uint12') the maximum is exactly 1. Both checks held. The image file formats article shows how 12-bit samples are scaled up when stored as 16-bit PNG.

2. Centroids. All three centroids equal the drawn (row, col) centres to the printed precision, with a maximum error of 0 (tolerance 10−910^{-9} px). This check held. draw and regionprops agree on (row, col), so passing positions between them needs no swap.

3. Transforms. At order 0 and at order 1, every centroid moved by (2, 5) in (row, col), with no deviation (tolerance 10−910^{-9} px), so translation=(5, 2) means 5 columns and 2 rows: an (x,y)(x, y) pair. Read as (row, col), the same tuple would have predicted a move of (5, 2). The check held. Integer shifts sample the input exactly at pixel centres, so order 1 interpolation changes nothing here.

The warp_coords check also held: on a 3×53 \times 5 output, the pairs passed to the callable have column maxima [4, 2], that is (cols−1,rows−1)(\text{cols} - 1, \text{rows} - 1). The pairs are (col, row), although the function’s docstring describes them as “(row, col)” pairs. A callable written from the docstring’s description would swap the axes.

4. Border modes. In the interior, at least 8 pixels from every edge, the two filters agree exactly (tolerance 10−1510^{-15}). Each output there depends only on input pixels within the radius of 8, and those are the same in both modes. In the border band they differ by up to 4.647517×10−54.647517 \times 10^{-5} (bar: more than 10−610^{-6}). Each library also matched its hand reference to 2.1×10−172.1 \times 10^{-17} (tolerance 10−1210^{-12}), with 'nearest' matching 'edge' and SciPy’s 'reflect' matching 'symmetric'. SciPy’s docstrings describe 'nearest' as repeating the edge value (a a a a | a b c d) and 'reflect' as mirroring about the edge (d c b a | a b c d); on a ramp the mirrored values are not equal to the edge value, so the two modes differ near the edge. All three checks held.

5. Greyscale weights. rgb2gray returned exactly 0.2125, 0.7154 and 0.0721 for pure red, green and blue, and 1 for white (tolerance 10−1210^{-12}). Its docstring calls these weights “calibrated for contemporary CRT phosphors” and cites Poynton’s colour FAQ. Pillow’s convert("L") gave 76, 150, 29 and 255, equal to the integers its C code computes. Both checks held.

Pillow’s Image.convert docstring gives the formula L=R⋅299/1000+G⋅587/1000+B⋅114/1000L = R \cdot 299/1000 + G \cdot 587/1000 + B \cdot 114/1000. The RGB-to-L routine in Convert.c computes (19595R+38470G+7471B+32768)≫16(19595R + 38470G + 7471B + 32768) \gg 16, the same weights in 16-bit fixed point, rounded half up. By our arithmetic, the docstring formula gives 76.245, 149.685 and 29.07 for pure red, green and blue, so rounded it gives the same integers as Convert.c, while truncating it would give 149 for green.

Scaled to 0–255, scikit-image’s pure red is 54.187 and Pillow’s is 76. The two libraries’ grey images of the same photograph therefore differ, and the OpenCV article’s figure of 76 for pure red belongs to the 299/587/114 weights.

Ecosystem and Integrations

scikit-image sits on NumPy and SciPy. Its gaussian, for example, converts the image to floating point and calls scipy.ndimage.gaussian_filter with its own default mode. The user guide describes the exchange with OpenCV: arrays are shared without copying, OpenCV orders colour channels as BGR, so image[:, :, ::-1] swaps the order, and img_as_ubyte turns a scikit-image float result into the uint8 that OpenCV uses by default. Files can be read with io.imread, as the getting-started guide shows, or, in our reading, with any reader that returns a NumPy array, since the functions take plain arrays. Since 0.25.0, io.imshow and io.show are deprecated in favour of Matplotlib, napari or other viewers. The user guide’s note on labelled data says pandas DataFrames and xarray DataArrays are not natively supported. They can be converted to arrays, at the cost of their sampling coordinates.

The library appears throughout this site’s examples. Bioimage analysis names it among the open-source packages of that field, and image moments and connected component labeling use its measurement functions.

Alternatives

Other libraries overlap with parts of scikit-image; this article does not rank them.

  • OpenCV is a C++ library with Python bindings that also works on NumPy arrays, with BGR channel order and saturating uint8 arithmetic; its article describes these conventions.
  • Pillow, as the OpenCV article describes it, provides extensive file format support and image processing functions; part 5 shows that its greyscale conversion uses different weights.
  • SciPy’s ndimage module works on arrays too; its gaussian_filter is documented as a multidimensional Gaussian filter. scikit-image calls it inside gaussian, and warp_coords builds coordinates for its map_coordinates, but scikit-image applies its own defaults and dtype conventions, as part 4 shows.

Versions and Compatibility

Several releases changed behaviour that older code may rely on.

  • 0.19.0 (3 December 2021):
    • deprecated the boolean multichannel argument in favour of channel_axis (multichannel=True becomes channel_axis=-1, and False becomes None);
    • introduced lazy loading of submodules;
    • made most functions return float32 for float32 input.
  • 0.25.0 (13 December 2024):
    • deprecated the io plugin infrastructure, and io.imshow, imshow_collection and show;
    • added morphology.footprint_rectangle in place of the deprecated square, rectangle and cube.
  • 0.25.2 (18 February 2025), whose notes list bug fixes and documentation, infrastructure and maintenance changes, is the version this article’s examples ran with.
  • 0.26.0 (20 December 2025), by its release notes, which describe a version the examples did not run:
    • a from_estimate class constructor replaces the now deprecated estimate method of nine geometric transforms, SimilarityTransform among them, and of measure’s line, circle and ellipse models;
    • transform constructors take their parameters by keyword only, apart from matrix, because the positional order differed from the order in which AffineTransform applies them;
    • binary_erosion, binary_dilation, binary_opening and binary_closing are deprecated in favour of erosion, dilation, opening and closing;
    • in remove_small_objects and remove_small_holes, a new max_size parameter replaces the deprecated min_size and area_threshold; it removes objects and holes up to and including its size;
    • support for Python 3.10 is dropped.
  • 0.27.0rc1 (27 October 2026) is the latest release candidate, as of November 2026, on the project’s GitHub releases list.

Licence. The licence file lists copyright holders and licences file by file. It assigns the 3-clause BSD licence to the package as a whole, the 2-clause BSD licence to filters/thresholding.py and two files of the graph module, and the MIT licence to feature/_fisher_vector.py and one function in _shared/version_requirements.py. The v0.26.0 licence file is identical.

Limitations

  • The value range is an assumption, not a property of the array. A 12-bit image in uint16 is read as dark, and a float image outside [0,1][0, 1] passes unchecked into functions that may expect [0,1][0, 1]; part 1 shows the first case.
  • Two coordinate orders coexist. (row, col) for drawing, labels and region properties; (x,y)(x, y) for transform objects and the pairs warp_coords hands to a callable; part 3 shows both.
  • Defaults differ from neighbouring libraries. The border mode of gaussian differs from SciPy’s, and the greyscale weights differ from Pillow’s and OpenCV’s, so results from different libraries are not interchangeable without checking.
  • Functions may change the dtype. The data-types guide warns that functions may return a different dtype from their input, so a pipeline that needs a particular type converts explicitly.

Related

  • OpenCV

    The open-source C++ library of computer vision and image processing functions, with Python bindings that work on NumPy arrays; its modules, conventions, versions from 1.0 to 5.0, contrib modules and licence.

  • Digital Image

    A digital image is a grid of samples of a continuous scene, each quantized to a finite set of values and stored as an array of numbers.

  • Gaussian Filter

    A linear smoothing filter that replaces each pixel by an average of its neighbors weighted by a Gaussian, whose standard deviation sets the scale of the detail removed.

  • 2D and 3D Geometric Transformations

    The nested families of Euclidean, similarity, affine and projective transformations of the plane and of space, their degrees of freedom, what each preserves, why each forms a group, and the Lie groups SO(3), SE(3) and Sim(3) used to estimate rotations, poses and similarities.

  • Bioimage Analysis

    How biologists turn microscopy images into measurements, covering the imaging modalities from brightfield to electron microscopy, the tasks of segmentation, tracking, classification, restoration and measurement, the open tools from ImageJ and CellProfiler to napari, deep learning and model zoos, open file formats, FAIR data and image archives, and the reporting practices that make an analysis reproducible.

  • Pixel

    The pixel as picture element, where the word came from, the different things it names in images, sensors and displays, how pixels are counted, and why the position of a pixel's centre changes every resize.

References

  1. scikit-image team (2025). Image data types and what they mean, doc/source/user_guide/data_types.rst, scikit-image v0.25.2 source code.
  2. scikit-image team (2025). A crash course on NumPy for images, doc/source/user_guide/numpy_images.rst, scikit-image v0.25.2 source code.
  3. scikit-image team (2025). Getting started, doc/source/user_guide/getting_started.rst, scikit-image v0.25.2 source code.
  4. scikit-image team (2025). Geometrical transformations of images, doc/source/user_guide/geometrical_transform.rst, scikit-image v0.25.2 source code.
  5. scikit-image team (2025). Glossary, doc/source/user_guide/glossary.md, scikit-image v0.25.2 source code.
  6. scikit-image team (2025). Release notes for 0.19 and 0.25, doc/source/release_notes/release_0.19.rst and release_0.25.rst, scikit-image v0.25.2 source code.
  7. scikit-image team (2025). Source of img_as_float and the dtype conversions, skimage/util/dtype.py, scikit-image 0.25.2 source code.
  8. scikit-image team (2025). Source of gaussian, skimage/_shared/filters.py, scikit-image 0.25.2 source code.
  9. scikit-image team (2025). Source of rgb2gray, skimage/color/colorconv.py, scikit-image 0.25.2 source code.
  10. scikit-image team (2025). Source of warp and warp_coords, skimage/transform/_warps.py, scikit-image 0.25.2 source code.
  11. scikit-image team (2025). Example data module, registry and fetchers, skimage/data/__init__.py, _registry.py and _fetchers.py, scikit-image 0.25.2 source code.
  12. scikit-image team (2025). LICENSE.txt (BSD-3-Clause, with BSD-2-Clause and MIT parts), scikit-image v0.25.2 source code.
  13. scikit-image team (2025). README.md (citation), scikit-image v0.25.2 source code.
  14. scikit-image team (2025). Release notes for 0.26.0, doc/source/release_notes/release_0.26.0.rst, scikit-image v0.26.0 source code.
  15. scikit-image (2025). scikit-image 0.26.0 release, GitHub release page, 20 December 2025.
  16. Pillow contributors (2025). RGB to L conversion, src/libImaging/Convert.c, and the convert docstring, src/PIL/Image.py, Pillow 12.0.0 source code.
  17. SciPy Developers (2025). Source of gaussian_filter and the boundary-mode docstrings, scipy/ndimage/_filters.py and _ni_docstrings.py, SciPy 1.16.3 source code.
  18. van der Walt, S., Schönberger, J. L., Nunez-Iglesias, J., Boulogne, F., Warner, J. D., Yager, N., Gouillart, E., Yu, T. & the scikit-image contributors (2014). scikit-image: image processing in Python. PeerJ, 2, e453. (not read)