Docs updated

Author: Quickmarble

src/filter/bilateral.rs

@@ -62,6 +62,7 @@ where
 ///     define how different two pixels are based on their colors. Common examples may include simple
 ///     absolute difference for greyscale pixels or cartesian distance in the CIE-Lab color space
 ///     \[1\].
+/// * `extend` - Enum specifying how to sample pixels outside of image boundaries.
 ///
 /// This filter averages pixels based on their spatial distance as well as their color
 /// distance. Spatial distance is measured by the Gaussian function of the Euclidean distance

src/filter/box_filter.rs

@@ -9,8 +9,7 @@ use crate::integral_image::{column_running_sum, row_running_sum};
 /// sum to one. i.e. each output pixel is the unweighted mean of
 /// a rectangular region surrounding its corresponding input pixel.
 /// We handle locations where the kernel would extend past the image's
-/// boundary by treating the image as if its boundary pixels were
-/// repeated indefinitely.
+/// boundary according to `extend`.
 // TODO: for small kernels we probably want to do the convolution
 // TODO: directly instead of using an integral image.
 // TODO: more formats!

src/filter/median.rs

@@ -5,7 +5,8 @@ use image::Pixel;
 /// Applies a median filter of given dimensions to an image. Each output pixel is the median
 /// of the pixels in a `(2 * x_radius + 1) * (2 * y_radius + 1)` kernel of pixels in the input image.
 ///
-/// Pads by continuity. Performs O(max(x_radius, y_radius)) operations per pixel.
+/// Sampling outside of image boundaries is controlled by `extend`.
+/// Performs O(max(x_radius, y_radius)) operations per pixel.
 ///
 /// # Examples
 /// ```
@@ -34,14 +35,17 @@ use image::Pixel;
 /// //   9 |   9   100    11 |  11
 /// //      -----------------
 /// //   9     9   100    11    11
+/// //
+/// // Here we choose `Border<P>` corresponding to it:
+/// let extend = Border::Replicate;
 ///
 /// let filtered = gray_image!(
 ///     2,  3,  3;
 ///     9,  7,  7;
 ///     9, 11, 11
 /// );
 ///
-/// assert_pixels_eq!(median_filter(&image, 1, 1, Border::Replicate), filtered);
+/// assert_pixels_eq!(median_filter(&image, 1, 1, extend), filtered);
 /// # }
 /// ```
 ///
@@ -323,7 +327,7 @@ impl HistSet {
         }
     }
 
-    /// Safety: requires pixel.channels.len() <= self.data.len()
+    /// Safety: requires P::CHANNEL_COUNT <= self.data.len()
     unsafe fn incr<P: Pixel<Subpixel = u8>>(&mut self, pixel: P) {
         let channels = pixel.channels();
         unsafe {
@@ -335,7 +339,7 @@ impl HistSet {
         }
     }
 
-    /// Safety: requires pixel.channels.len() <= self.data.len()
+    /// Safety: requires P::CHANNEL_COUNT <= self.data.len()
     unsafe fn decr<P: Pixel<Subpixel = u8>>(&mut self, pixel: P) {
         let channels = pixel.channels();
         unsafe {
@@ -347,7 +351,7 @@ impl HistSet {
         }
     }
 
-    /// Safety: requires pixel.channels.len() <= self.data.len()
+    /// Safety: requires P::CHANNEL_COUNT <= self.data.len()
     unsafe fn set_to_median<P: Pixel<Subpixel = u8>>(&self, pixel: &mut P) {
         let channels = pixel.channels_mut();
         unsafe {

src/filter/mod.rs

@@ -22,7 +22,8 @@ use num::Num;
 use std::f32;
 
 /// Returns 2d correlation of an image. Intermediate calculations are performed
-/// at type K, and the results converted to pixel Q via f. Pads by continuity.
+/// at type K, and the results converted to pixel Q via f.
+/// Sampling outside of image boundaries is controlled by `extend`.
 ///
 /// # Panics
 /// If `P::CHANNEL_COUNT != Q::CHANNEL_COUNT`
@@ -186,7 +187,8 @@ where
 }
 
 /// Returns 2d correlation of an image with a row-major kernel. Intermediate calculations are
-/// performed at type K, and the results clamped to subpixel type S. Pads by continuity.
+/// performed at type K, and the results clamped to subpixel type S.
+/// Sampling outside of image boundaries is controlled by `extend`.
 ///
 /// A parallelized version of this function exists with [`filter_clamped_parallel`] when
 /// the crate `rayon` feature is enabled.
@@ -222,8 +224,8 @@ where
 }
 
 /// Returns horizontal correlations between an image and a 1d kernel.
-/// Pads by continuity. Intermediate calculations are performed at
-/// type K.
+/// Sampling outside of image boundaries is controlled by `extend`.
+/// Intermediate calculations are performed at type K.
 #[must_use = "the function does not modify the original image"]
 pub fn horizontal_filter<P, K>(image: &Image<P>, kernel: &[K], extend: Border<P>) -> Image<P>
 where
@@ -250,8 +252,9 @@ where
     out
 }
 
-/// Returns horizontal correlations between an image and a 1d kernel.
-/// Pads by continuity.
+/// Returns vertical correlations between an image and a 1d kernel.
+/// Sampling outside of image boundaries is controlled by `extend`.
+/// Intermediate calculations are performed at type K.
 #[must_use = "the function does not modify the original image"]
 pub fn vertical_filter<P, K>(image: &Image<P>, kernel: &[K], extend: Border<P>) -> Image<P>
 where

src/gradients.rs

@@ -249,6 +249,7 @@ pub fn prewitt_gradients(image: &GrayImage, extend: Border<Luma<u8>>) -> Image<L
 ///     [ 4,  0,  8], [ 8,  0,  8], [ 4,  0,  8]
 /// );
 ///
+/// // Padding by continuity.
 /// let extend = Border::Replicate;
 ///
 /// assert_pixels_eq!(

src/integral_image.rs

@@ -317,7 +317,7 @@ pub fn variance(
 }
 
 /// Computes the running sum of one row of image, padded
-/// at the beginning and end. The padding is by continuity.
+/// at the beginning and end. Padding method is controlled by `extend`.
 /// Takes a reference to buffer so that this can be reused
 /// for all rows in an image.
 ///
@@ -388,7 +388,7 @@ pub fn row_running_sum(
 }
 
 /// Computes the running sum of one column of image, padded
-/// at the top and bottom. The padding is by continuity.
+/// at the top and bottom. Padding method is controlled by `extend`.
 /// Takes a reference to buffer so that this can be reused
 /// for all columns in an image.
 ///