How to use

computePDF

method

in

org.ddogleg.stats.UtilGaussian

/**
 * 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];
    }
  }
}

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);

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;
}

/**
 * <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;
}

/**
 * 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 );
}

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;

double sum = 0;
for (int i = radius; i >= -radius; i--) {
  sum += UtilGaussian.computePDF(0, sigma, i);