edu.umich.eecs.april.image

Class SigProc

java.lang.Object

edu.umich.eecs.april.image.SigProc

public class SigProc
extends java.lang.Object

Signal processing algorithms for images.

Field Summary

Fields

Modifier and Type	Field and Description
(package private) static boolean	warned

Constructor Summary

Constructors

Constructor and Description
SigProc()

Method Summary

Modifier and Type	Method and Description
(package private) static byte	clampByte(double v)
static float[]	convolve(float[] a, float[] b)
static void	convolveCenteredDisc2DMax(float[] a, int width, int height, int radius, float[] r)
static void	convolveCenteredDisc2DMax(int[] a, int width, int height, int radius, int[] r)
static void	convolveCenteredDisc2DMaxCont(int[] a, int width, int height, double radius, double mpp, int[] r)
static void	convolveSymmetricCentered(float[] a, int aoff, int alen, float[] f, float[] r, int roff) Convolve the input 'a' (which begins at offset aoff and is alen elements in length) with the filter 'f', depositing the result in 'r' at the offset 'roff'. f.length should be odd.
static void	convolveSymmetricCenteredMax(byte[] a, int aoff, int alen, float[] f, byte[] r, int roff)
static void	convolveSymmetricCenteredMax(float[] a, int aoff, int alen, float[] f, float[] r, int roff)
static void	main(java.lang.String[] args)
static float[]	makeGaussianFilter(double sigma, int n) Computes gaussian low-pass filter with L1 Norm of 1.0 (all elements add up).

Methods inherited from class java.lang.Object

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

Field Detail

warned

static boolean warned

Constructor Detail

SigProc

public SigProc()

Method Detail

convolveSymmetricCentered

public static final void convolveSymmetricCentered(float[] a,
                                                   int aoff,
                                                   int alen,
                                                   float[] f,
                                                   float[] r,
                                                   int roff)

Convolve the input 'a' (which begins at offset aoff and is alen elements in length) with the filter 'f', depositing the result in 'r' at the offset 'roff'. f.length should be odd. The output is shifted by -f.length/2, so that there is no net time delay.

convolveSymmetricCenteredMax

public static final void convolveSymmetricCenteredMax(float[] a,
                                                      int aoff,
                                                      int alen,
                                                      float[] f,
                                                      float[] r,
                                                      int roff)

convolveCenteredDisc2DMaxCont

public static final void convolveCenteredDisc2DMaxCont(int[] a,
                                                       int width,
                                                       int height,
                                                       double radius,
                                                       double mpp,
                                                       int[] r)

convolveCenteredDisc2DMax

public static final void convolveCenteredDisc2DMax(int[] a,
                                                   int width,
                                                   int height,
                                                   int radius,
                                                   int[] r)

convolveCenteredDisc2DMax

public static final void convolveCenteredDisc2DMax(float[] a,
                                                   int width,
                                                   int height,
                                                   int radius,
                                                   float[] r)

clampByte

static final byte clampByte(double v)

convolveSymmetricCenteredMax

public static final void convolveSymmetricCenteredMax(byte[] a,
                                                      int aoff,
                                                      int alen,
                                                      float[] f,
                                                      byte[] r,
                                                      int roff)

convolve

public static final float[] convolve(float[] a,
                                     float[] b)

makeGaussianFilter

public static float[] makeGaussianFilter(double sigma,
                                         int n)

Computes gaussian low-pass filter with L1 Norm of 1.0 (all elements add up). N should be odd.

main

public static void main(java.lang.String[] args)