boofcv.alg.filter.kernel

Class KernelMath

java.lang.Object

boofcv.alg.filter.kernel.KernelMath

public class KernelMath
extends java.lang.Object

Constructor Summary

Constructors

Constructor and Description
KernelMath()

Method Summary

Modifier and Type	Method and Description
static void	convert(double[] input, int[] output, int size, double minFrac)
static void	convert(float[] input, int[] output, int size, float minFrac)
static Kernel1D_I32	convert(Kernel1D_F32 original, float minFrac)
static Kernel1D_I32	convert(Kernel1D_F64 original, double minFrac)
static Kernel2D_I32	convert(Kernel2D_F32 original, float minFrac)
static ImageFloat32	convertToImage(Kernel2D_F32 kernel)
static ImageSInt32	convertToImage(Kernel2D_I32 kernel)
static Kernel2D_F32	convertToKernel(ImageFloat32 image)
static Kernel2D_I32	convertToKernel(ImageInteger image)
static Kernel1D_F32	convolve1D_F32(Kernel1D_F32 a, Kernel1D_F32 b)
static Kernel1D_I32	convolve1D_I32(Kernel1D_I32 a, Kernel1D_I32 b)
static Kernel1D	convolve1D(Kernel1D a, Kernel1D b)
static Kernel2D_F32	convolve2D(Kernel1D_F32 a, Kernel1D_F32 b) Convolve two 1D kernels together to form a 2D kernel.
static Kernel2D_F64	convolve2D(Kernel1D_F64 a, Kernel1D_F64 b) Convolve two 1D kernels together to form a 2D kernel.
static Kernel2D_I32	convolve2D(Kernel1D_I32 a, Kernel1D_I32 b) Convolve two 1D kernels together to form a 2D kernel.
static Kernel2D	convolve2D(Kernel1D a, Kernel1D b) Convolve two 1D kernels together to form a 2D kernel.
static Kernel2D_F32	convolve2D(Kernel2D_F32 a, Kernel2D_F32 b)
static Kernel2D_I32	convolve2D(Kernel2D_I32 a, Kernel2D_I32 b)
static Kernel2D	convolve2D(Kernel2D a, Kernel2D b)
static void	divide(Kernel1D_F32 kernel, float value)
static void	divide(Kernel1D_F64 kernel, double value)
static void	divide(Kernel2D_F32 kernel, float value)
static void	divide(Kernel2D_F64 kernel, double value)
static void	fill(Kernel2D_F32 kernel, float value)
static void	fill(Kernel2D_I32 kernel, int value)
static boolean	isEquals(float[] expected, float[] found, int size, float tol)
static boolean	isEquals(int[] expected, int[] found, int size)
static boolean	isEqualsFrac(float[] expected, float[] found, int size, float fracTol, float zero)
static double	maxAbs(double[] data, int size)
static float	maxAbs(float[] data, int size)
static double	minAbs(double[] data, int size, double minValue)
static float	minAbs(float[] data, int size, float minValue)
static void	normalizeAbsSumToOne(Kernel2D_F32 kernel) Normalizes the array such that the absolute value sums up to one.
static void	normalizeF(Kernel2D_F64 kernel)
static void	normalizeMaxOne(Kernel2D_F64 kernel) Normalizes it such that the largest element is equal to one
static void	normalizeSumToOne(Kernel1D_F32 kernel) Normalizes the array such that it sums up to one.
static void	normalizeSumToOne(Kernel1D_F64 kernel)
static void	normalizeSumToOne(Kernel2D_F32 kernel) Normalizes the array such that it sums up to one.
static void	normalizeSumToOne(Kernel2D_F64 kernel)
static void	scale(Kernel1D_F32 kernel, float value)
static void	scale(Kernel1D_F64 kernel, double value)
static double	sum(Kernel2D_F64 kernel)
static Kernel2D_F32	transpose(Kernel2D_F32 a)
static Kernel2D_I32	transpose(Kernel2D_I32 a)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

KernelMath

public KernelMath()

Method Detail

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_I32 kernel,
                        int value)

transpose

public static Kernel2D_F32 transpose(Kernel2D_F32 a)

transpose

public static Kernel2D_I32 transpose(Kernel2D_I32 a)

convolve1D

public static Kernel1D convolve1D(Kernel1D a,
                                  Kernel1D b)

convolve1D_I32

public static Kernel1D_I32 convolve1D_I32(Kernel1D_I32 a,
                                          Kernel1D_I32 b)

convolve1D_F32

public static Kernel1D_F32 convolve1D_F32(Kernel1D_F32 a,
                                          Kernel1D_F32 b)

convolve2D

public static Kernel2D convolve2D(Kernel2D a,
                                  Kernel2D b)

convolve2D

public static Kernel2D_I32 convolve2D(Kernel2D_I32 a,
                                      Kernel2D_I32 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_I32 convolve2D(Kernel1D_I32 a,
                                      Kernel1D_I32 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 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 ImageFloat32 convertToImage(Kernel2D_F32 kernel)

convertToImage

public static ImageSInt32 convertToImage(Kernel2D_I32 kernel)

convertToKernel

public static Kernel2D_F32 convertToKernel(ImageFloat32 image)

convertToKernel

public static Kernel2D_I32 convertToKernel(ImageInteger image)

convert

public static Kernel2D_I32 convert(Kernel2D_F32 original,
                                   float minFrac)

convert

public static Kernel1D_I32 convert(Kernel1D_F32 original,
                                   float minFrac)

convert

public static Kernel1D_I32 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)