Class Canny

Implemented Interfaces:
Runnable

(package private) class Canny
extends Algorithmus

Field Summary

private int
breite_maske
private BufferedImage
buffImgHelp
private int
high
private int
low
private static float
mag_scale
private static int
max_maske
private float
sigma
private static int
width
private WritableRaster
wraster

Fields inherited from class .Algorithmus

alt_breite, alt_hoehe, breite, hoehe, img, maskengroesse, max, maxf, min, minf, threshold, ziel

Constructor Summary

Canny(Image img, BildKomp ziel, float sigma, int low, int high)

Method Summary

protected Image
berechne()
private byte[]
berechneCanny(byte[] original, float[] gau, float[] dgau)
private void
canny(byte[] original, int[][] magim, float[] gau, float[] dgau)
private float
dGauss(float x)
private float[][]
dxy_seperableConvolution(float[][] sc, float[] dgau, int breite_maske, boolean richtung)
private void
estimateThresh(int[][] mag)
private void
filterBerechnen(float[] gau, float[] dgau)
private float
gauss(float x)
private int[][]
hysteresis(int[][] mag)
private float
meanGauss(float x)
private void
nonmaxSuppress(float[][] dx, float[][] dy, int[][] mag)
private float
norm(float x, float y)
private boolean
range(int i, int j)
private void
separableConvolution(byte[] original, float[] gau, int breite_maske, float[][] scx, float[][] scy)
private boolean
trace(int i, int j, int[][] im, int[][] mag)

Methods inherited from class .Algorithmus

algorithmus, berechne, berechneAlgo, rescaling, rescaling, run

Field Details

breite_maske

private int breite_maske

buffImgHelp

private BufferedImage buffImgHelp

high

private int high

low

private int low

mag_scale

private static final float mag_scale
Field Value:
20.0f

max_maske

private static final int max_maske
Field Value:
20

sigma

private float sigma

width

private static int width

wraster

private WritableRaster wraster

Constructor Details

Canny

(package private)  Canny(Image img,
                         BildKomp ziel,
                         float sigma,
                         int low,
                         int high)

Method Details

berechne

protected Image berechne()
Overrides:
berechne in interface Algorithmus

berechneCanny

private byte[] berechneCanny(byte[] original,
                             float[] gau,
                             float[] dgau)

canny

private void canny(byte[] original,
                   int[][] magim,
                   float[] gau,
                   float[] dgau)

dGauss

private float dGauss(float x)

dxy_seperableConvolution

private float[][] dxy_seperableConvolution(float[][] sc,
                                           float[] dgau,
                                           int breite_maske,
                                           boolean richtung)

estimateThresh

private void estimateThresh(int[][] mag)

filterBerechnen

private void filterBerechnen(float[] gau,
                             float[] dgau)

gauss

private float gauss(float x)

hysteresis

private int[][] hysteresis(int[][] mag)

meanGauss

private float meanGauss(float x)

nonmaxSuppress

private void nonmaxSuppress(float[][] dx,
                            float[][] dy,
                            int[][] mag)

norm

private float norm(float x,
                   float y)

range

private boolean range(int i,
                      int j)

separableConvolution

private void separableConvolution(byte[] original,
                                  float[] gau,
                                  int breite_maske,
                                  float[][] scx,
                                  float[][] scy)

trace

private boolean trace(int i,
                      int j,
                      int[][] im,
                      int[][] mag)