Package boofcv.alg.filter.kernel

Class KernelMath

java.lang.Object
boofcv.alg.filter.kernel.KernelMath
public class KernelMath extends Object
Operations for manipulating different convolution kernels.

  • Constructor Details

    • KernelMath

      public KernelMath()

  • Method Details

    • scale

      public static void scale(Kernel1D_F32 kernel, float value)

    • scale

      public static void scale(Kernel1D_F64 kernel, double value)

    • divide

      public static void divide(Kernel1D_F32 kernel, float value)

    • divide

      public static void divide(Kernel1D_F64 kernel, double value)

    • divide

      public static void divide(Kernel2D_F32 kernel, float value)

    • divide

      public static void divide(Kernel2D_F64 kernel, double value)

    • fill

      public static void fill(Kernel2D_F32 kernel, float value)

    • fill

      public static void fill(Kernel2D_S32 kernel, int value)

    • transpose

      public static Kernel2D_F32 transpose(Kernel2D_F32 a)

    • transpose

      public static Kernel2D_S32 transpose(Kernel2D_S32 a)

    • convolve1D

      public static Kernel1D convolve1D(Kernel1D a, Kernel1D b)

    • convolve1D_I32

      public static Kernel1D_S32 convolve1D_I32(Kernel1D_S32 a, Kernel1D_S32 b)

    • convolve1D_F32

      public static Kernel1D_F32 convolve1D_F32(Kernel1D_F32 a, Kernel1D_F32 b)

    • convolveSmooth

      public static void convolveSmooth(Kernel1D_F32 kernel, float[] src, float[] dst, int length)
      Applies a smoothing kernel the the array. The kernel must sum to 1. Array borders are handling by normalizing based on the overlap of the kernel with the image at that point
      Parameters:
      kernel - Smothing kernel that sums to 1
      src - Input array
      dst - Output array
      length - Effective length of the array

    • convolve2D

      public static Kernel2D convolve2D(Kernel2D a, Kernel2D b)

    • convolve2D

      public static Kernel2D_S32 convolve2D(Kernel2D_S32 a, Kernel2D_S32 b)

    • convolve2D

      public static Kernel2D_F32 convolve2D(Kernel2D_F32 a, Kernel2D_F32 b)

    • convolve2D

      public static Kernel2D convolve2D(Kernel1D a, Kernel1D b)
      Convolve two 1D kernels together to form a 2D kernel.
      Parameters:
      a - Input vertical 1D kernel
      b - Input horizontal 1D kernel
      Returns:
      Resulting 2D kernel

    • convolve2D

      public static Kernel2D_F32 convolve2D(Kernel1D_F32 a, Kernel1D_F32 b)
      Convolve two 1D kernels together to form a 2D kernel.
      Parameters:
      a - Input vertical 1D kernel
      b - Input horizontal 1D kernel
      Returns:
      Resulting 2D kernel

    • convolve2D

      public static Kernel2D_F64 convolve2D(Kernel1D_F64 a, Kernel1D_F64 b)
      Convolve two 1D kernels together to form a 2D kernel.
      Parameters:
      a - Input vertical 1D kernel
      b - Input horizontal 1D kernel
      Returns:
      Resulting 2D kernel

    • convolve2D

      public static Kernel2D_S32 convolve2D(Kernel1D_S32 a, Kernel1D_S32 b)
      Convolve two 1D kernels together to form a 2D kernel.
      Parameters:
      a - Input vertical 1D kernel
      b - Input horizontal 1D kernel
      Returns:
      Resulting 2D kernel

    • normalizeSumToOne

      public static void normalizeSumToOne(Kernel1D_F32 kernel)
      Normalizes the array such that it sums up to one.
      Parameters:
      kernel - The kernel being normalized.

    • normalizeSumToOne

      public static void normalizeSumToOne(Kernel1D_F64 kernel)

    • normalizeSumToOne

      public static void normalizeSumToOne(Kernel2D_F32 kernel)
      Normalizes the array such that it sums up to one.
      Parameters:
      kernel - The kernel being normalized.

    • normalizeSumToOne

      public static void normalizeSumToOne(Kernel2D_F64 kernel)

    • normalizeAbsSumToOne

      public static void normalizeAbsSumToOne(Kernel2D_F32 kernel)
      Normalizes the array such that the absolute value sums up to one.
      Parameters:
      kernel - The kernel being normalized.

    • sum

      public static float sum(Kernel2D_F32 kernel)

    • sum

      public static double sum(Kernel2D_F64 kernel)

    • normalizeF

      public static void normalizeF(Kernel2D_F64 kernel)

    • normalizeMaxOne

      public static void normalizeMaxOne(Kernel2D_F64 kernel)
      Normalizes it such that the largest element is equal to one

    • convertToImage

      public static GrayF32 convertToImage(Kernel2D_F32 kernel)

    • convertToImage

      public static GrayS32 convertToImage(Kernel2D_S32 kernel)

    • convertToKernel

      public static Kernel2D_F32 convertToKernel(GrayF32 image)

    • convertToKernel

      public static Kernel2D_S32 convertToKernel(GrayI image)

    • convert

      public static Kernel2D_S32 convert(Kernel2D_F32 original, float minFrac)

    • convert

      public static Kernel1D_S32 convert(Kernel1D_F32 original, float minFrac)

    • convert

      public static Kernel1D_S32 convert(Kernel1D_F64 original, double minFrac)

    • convert

      public static void convert(float[] input, int[] output, int size, float minFrac)

    • convert

      public static void convert(double[] input, int[] output, int size, double minFrac)

    • maxAbs

      public static float maxAbs(float[] data, int size)

    • maxAbs

      public static double maxAbs(double[] data, int size)

    • minAbs

      public static float minAbs(float[] data, int size, float minValue)

    • minAbs

      public static double minAbs(double[] data, int size, double minValue)

    • isEqualsFrac

      public static boolean isEqualsFrac(float[] expected, float[] found, int size, float fracTol, float zero)

    • isEquals

      public static boolean isEquals(float[] expected, float[] found, int size, float tol)

    • isEquals

      public static boolean isEquals(int[] expected, int[] found, int size)