/** * compute the weights by convolving 1D gaussian kernel */ protected void computeWeights(int numSamples, double numSigmas) { weights = new float[ numSamples*numSamples ]; float w[] = new float[ numSamples ]; for( int i = 0; i < numSamples; i++ ) { float x = i/(float)(numSamples-1); w[i] = (float) UtilGaussian.computePDF(0, 1, 2f*numSigmas * (x - 0.5f)); } for( int y = 0; y < numSamples; y++ ) { for( int x = 0; x < numSamples; x++ ) { weights[y*numSamples + x] = w[y]*w[x]; } } }
public static double stdev( GrowQueue_F64 list , double mean ) { return Math.sqrt(variance(list,mean)); }
case 1: for (int i = radius; i >= -radius; i--) { gaussian[index++] = (float) UtilGaussian.derivative1(0, sigma, i); gaussian[index++] = (float) UtilGaussian.derivative2(0, sigma, i); gaussian[index++] = (float) UtilGaussian.derivative3(0, sigma, i); gaussian[index++] = (float) UtilGaussian.derivative4(0, sigma, i); double sum = 0; for (int i = radius; i >= -radius; i--) { sum += UtilGaussian.computePDF(0, sigma, i);
@Test public void derivative3() { // numerical derivative.. test is very crude double expected = deriv3(1.5, 2, 1.8); assertEquals(expected, UtilGaussian.derivative3(1.5, 2, 1.8), 1e-3); }
@Test public void derivative2() { // numerical derivative.. test is very crude double expected = deriv2(1.5, 2, 1.8); assertEquals(expected, UtilGaussian.derivative2(1.5, 2, 1.8), 1e-3); }
@Test public void derivative1() { // numerical derivative double expected = deriv1(1.5, 2, 1.8); assertEquals(expected,UtilGaussian.derivative1(1.5, 2, 1.8),1e-4); }
@Test public void derivative4() { // numerical derivative.. test is very crude double expected = deriv4(1.5, 2, 1.8); assertEquals(expected, UtilGaussian.derivative4(1.5, 2, 1.8), 0.1); }
@Test public void mean_F64() { GrowQueue_F64 l = new GrowQueue_F64(); l.add(0); l.add(1); l.add(2); l.add(3); l.add(4); double found = UtilStatisticsQueue.mean(l); assertEquals(2,found,1e-8); }
for (int row = 0; row < rows; row++) { double drow = row-radiusRow+offsetRow; double pdfRow = UtilGaussian.computePDF(0, radiusRow, drow); double pdfCol = UtilGaussian.computePDF(0, radiusCol, dcol);
public static double stdev( GrowQueue_F64 list , double mean ) { return Math.sqrt(variance(list,mean)); }
protected static Kernel1D_F64 gaussian1D_F64(double sigma, int radius, boolean odd, boolean normalize) { Kernel1D_F64 ret; if( odd ) { ret = new Kernel1D_F64(radius * 2 + 1); int index = 0; for (int i = radius; i >= -radius; i--) { ret.data[index++] = UtilGaussian.computePDF(0, sigma, i); } } else { ret = new Kernel1D_F64(radius * 2); int index = 0; for (int i = radius; i > -radius; i--) { ret.data[index++] = UtilGaussian.computePDF(0, sigma, i-0.5); } } if (normalize) { KernelMath.normalizeSumToOne(ret); } return ret; }
@Test public void variance_F64() { GrowQueue_F64 l = new GrowQueue_F64(); l.add(0); l.add(1); l.add(2); l.add(3); l.add(4); double found = UtilStatisticsQueue.variance(l,2); assertEquals(2.5,found,1e-8); }
/** * Test the PDF based on some of its properties */ @Test public void computePDF() { double max = UtilGaussian.computePDF(2,1.5,2); assertTrue( UtilGaussian.computePDF(2,1.5,1) < max ); assertTrue( UtilGaussian.computePDF(2,1.5,3) < max ); assertEquals(UtilGaussian.computePDF(2, 1.5, 1),UtilGaussian.computePDF(2, 1.5, 3),1e-8 ); assertTrue( UtilGaussian.computePDF(2,2,2) < max ); assertTrue( UtilGaussian.computePDF(2,1,2) > max ); }
/** * <p> * Creates a floating point Gaussian kernel with the sigma and radius. * If normalized is set to true then the elements in the kernel will sum up to one. * </p> * @param sigma Distributions standard deviation. * @param radius Kernel's radius. * @param odd Does the kernel have an even or add width * @param normalize If the kernel should be normalized to one or not. */ protected static Kernel1D_F32 gaussian1D_F32(double sigma, int radius, boolean odd, boolean normalize) { Kernel1D_F32 ret; if( odd ) { ret = new Kernel1D_F32(radius * 2 + 1); int index = 0; for (int i = radius; i >= -radius; i--) { ret.data[index++] = (float) UtilGaussian.computePDF(0, sigma, i); } } else { ret = new Kernel1D_F32(radius * 2); int index = 0; for (int i = radius; i > -radius; i--) { ret.data[index++] = (float) UtilGaussian.computePDF(0, sigma, i-0.5); } } if (normalize) { KernelMath.normalizeSumToOne(ret); } return ret; }
double dx = x <= r ? Math.abs(x-r)+0.5 : Math.abs(x-r-1)+0.5; double d = Math.sqrt(dx*dx + dy*dy); double val = UtilGaussian.computePDF(0,sigma,d); ret.set(x,y,val); sum += val;