void stampIPOs() {
   calAveRadius();
   int i, j;
   for (i = 0; i < h; i++) {
     for (j = 0; j < w; j++) {
       m_pnStamp[i][j] = 0;
     }
   }
   int numRings = m_cvRings.size();
   m_cIMSC.reset();
   Point pt;
   int index, step = 0, r0;
   ImageShape shape;
   while (true) {
     pt = m_cIMSC.getPosition();
     index = getPercentileIndex(step);
     r0 = m_pnAveRadius[index];
     for (i = 0; i <= r0; i++) {
       shape = m_cvRings.get(i);
       shape.setCenter(pt);
       ImageShapeHandler.setValue(m_pnStamp, shape, m_nExcludingType);
     }
     if (m_cIMSC.done()) break;
     m_cIMSC.move();
     step++;
   }
 }
 int calCompensatedPixels() {
   int numRings = m_cvRings.size();
   CommonStatisticsMethods.copyArray(m_pnPixels, m_pnPixelsCompensated);
   CommonMethods.displayPixels(m_pnPixelsCompensated, "before compensation", impl.getType());
   m_cIMSC.reset();
   Point pt;
   int index, step = 0, pixel, i, r0;
   double dm, dsur;
   ImageShape shape;
   while (true) {
     pt = m_cIMSC.getPosition();
     index = getPercentileIndex(step);
     dsur = m_pcRingMeanSems_Mean[index][m_nRMax].mean;
     r0 = m_pnAveRadius[index];
     //
     // m_pnPixelsCompensated[pt.y][pt.x]-=(int)(m_cPixelMeanSems_trail[index].mean-dsur);
     for (i = 0; i < numRings; i++) {
       pixel = (int) (m_pcRingMeanSems_Mean[index][i].mean - dsur);
       if (pixel < 1) break;
       shape = m_cvRings.get(i);
       shape.setCenter(pt);
       ImageShapeHandler.addValue(m_pnPixelsCompensated, shape, -pixel);
     }
     if (m_cIMSC.done()) break;
     m_cIMSC.move();
     step++;
   }
   CommonMethods.displayPixels(m_pnPixelsCompensated, "after compensation", impl.getType());
   return 1;
 }
  public void calAutoCorrelation_RingMean(
      int
          nRefType) { // crosscorrelation coefficients between pixel valuse and the means and
                      // medians of the pixels located on the cocentric rings with radius up to
                      // m_nRMax
    m_nRefType = nRefType;
    int numRings = m_cvRings.size();
    calRefPixels();
    int r, c;
    int len = m_cIMSC.m_nTotalSteps + 1;
    double[] pixels0 = new double[len];
    double[] meanr = new double[len];
    double[] medianr = new double[len];

    int index = 0;

    Point p;
    index = 0;
    while (true) {
      p = m_cIMSC.getPosition();
      pixels0[index] = m_pnPixelsLR[p.y][p.x];
      index++;
      if (m_cIMSC.done()) break;
      m_cIMSC.move();
    }

    ImageShape shape;
    Histogram hist = CommonMethods.getDefaultHistogram(m_pnPixelsLR);

    int y, y0 = 0;
    int nRef;
    for (c = 0; c < numRings - 1; c++) {
      index = 0;
      m_cIMSC.reset();
      y0 = m_cIMSC.getPosition().y;
      shape = m_cvRings.get(c);
      while (true) {
        p = m_cIMSC.getPosition();
        nRef = getRefPixel(p);
        y = p.y;
        if (y > y0) {
          IJ.showStatus(
              "calAutoCorrelation_RingMean: r="
                  + PrintAssist.ToString(c + 1)
                  + "   y="
                  + PrintAssist.ToString(y));
          y0 = y;
        }
        CommonMethods.fillHistogram(m_pnPixels, nRef, shape, p, hist);
        meanr[index] = hist.getMean();
        medianr[index] = hist.getPercentileValue();
        index++;
        if (m_cIMSC.done()) break;
        m_cIMSC.move();
      }
      m_pdAutoCorr_mean[c] = CommonStatisticsMethods.crossCorrelationCoefficient(pixels0, meanr, 0);
      m_pdAutoCorr_median[c] =
          CommonStatisticsMethods.crossCorrelationCoefficient(pixels0, medianr, 0);
    }
  }
 public void exportPixelHeights(String path) {
   Formatter fm = FileAssist.getFormatter(path);
   PrintAssist.printString(fm, "i", 8);
   PrintAssist.printString(fm, "X", 8);
   PrintAssist.printString(fm, "Y", 8);
   PrintAssist.printString(fm, "Height", 12);
   int nSize = m_dvRs.size();
   int i, r0 = 0;
   double r;
   for (i = 0; i < nSize; i++) {
     r = m_dvRs.get(i);
     if (r > m_nRRefI) break;
     PrintAssist.printString(fm, "r=" + PrintAssist.ToString(r, 3), 10);
     r0++;
   }
   PrintAssist.printString(fm, "sur", 10);
   PrintAssist.endLine(fm);
   int len = m_cIMSC.getTotalSteps() + 1;
   m_cIMSC.reset();
   Point p;
   int step = 0;
   double height;
   int numRings = m_cvRings.size();
   while (true) {
     p = m_cIMSC.getPosition();
     height = m_pdPixelHeights[step];
     PrintAssist.printNumber(fm, step, 8, 0);
     PrintAssist.printNumber(fm, p.x, 8, 0);
     PrintAssist.printNumber(fm, p.y, 8, 0);
     PrintAssist.printNumber(fm, height, 12, 1);
     for (i = 0; i < r0; i++) {
       PrintAssist.printNumber(fm, m_pdRingMean[step][i], 10, 2);
     }
     PrintAssist.printNumber(fm, m_pdRingMean[step][numRings - 1], 10, 2);
     PrintAssist.endLine(fm);
     if (m_cIMSC.done()) break;
     m_cIMSC.move();
     step++;
   }
   fm.close();
 }
 public void resetImageScanner() {
   m_cIMSC.reset();
 }
  int refinePixelStatitics() {
    stampIPOs();
    int[][] pixelsTemp = m_pnPixels;
    m_pnPixels = m_pnPixelsCompensated;

    m_cIMSC.reset();
    int len = m_cIMSC.m_nTotalSteps + 1;
    int i, c, step = 0;
    Point p = m_cIMSC.getPosition();
    int index = 0;
    ImageShape shape;
    Histogram hist;
    double mean, median;
    int y, y0 = 0;
    int pixel, nRef;
    double dsur;
    int numRings = m_cvRings.size();
    while (true) {
      p = m_cIMSC.getPosition();
      y = p.y;
      if (y > y0)
        IJ.showStatus(
            "refinePixelStatistics "
                + PrintAssist.ToString(y)
                + "-th line of "
                + PrintAssist.ToString(h)
                + " lines!");
      index = getPercentileIndex(step);
      dsur = m_pcRingMeanSems_Mean[index][m_nRMax].mean;
      ImageShapeHandler.copyElements(m_pnPixelsCompensated, m_pnPixelsTemp, m_cvRings, p);
      for (i = 0; i < numRings; i++) {
        pixel = (int) (m_pcRingMeanSems_Mean[index][i].mean - dsur);
        if (pixel < 1) break;
        shape = m_cvRings.get(i);
        shape.setCenter(p);
        ImageShapeHandler.addValue(m_pnPixelsTemp, shape, pixel);
      }
      nRef =
          (int) ImageShapeHandler.getMean(m_pnPixelsTemp, m_cRefRing, m_pnStamp, m_nExcludingType);
      CommonMethods.fillHistogram(
          m_pnPixelsTemp,
          nRef,
          m_cvRings.get(numRings - 1),
          p,
          m_cvHists.get(numRings - 1),
          m_pnStamp,
          m_nExcludingType);
      CommonMethods.fillHistograms(m_pnPixelsTemp, nRef, m_cvRings, p, m_cvHists);
      for (i = 0; i < numRings; i++) {
        hist = m_cvHists.get(i);
        mean = hist.getMeanSem().mean;
        median = hist.getPercentileValue();
        m_pdRingMean[step][i] = mean;
        m_pdRingMedian[step][i] = median;
      }
      //            m_pnPixels_trail[step]=m_pnPixelsTemp[p.y][p.x]-nRef;
      if (m_cIMSC.done()) break;
      m_cIMSC.move();
      step++;
    }
    for (c = 0; c < numRings; c++) {
      m_pcMeanSems_Median[c] = CommonStatisticsMethods.buildMeanSem(m_pdRingMedian, c);
      m_pcMeanSems_Mean[c] = CommonStatisticsMethods.buildMeanSem(m_pdRingMean, c);
    }
    if (m_bPresetPoints) {
      len = pixelsOfPresetPoints.size();
      int num = len / m_nPercentileDivision;
      int rI, rF;
      for (i = 0; i < m_nPercentileDivision; i++) {
        rI = Math.max(0, (int) ((i - .5) * num));
        rF = Math.min(len - 1, (int) ((i + .5) * num));
        for (c = 0; c < numRings; c++) {
          m_pcRingMeanSems_Median[i][c] =
              CommonStatisticsMethods.buildMeanSem(m_pdRingMedian, rI, rF, 1, c);
          m_pcRingMeanSems_Mean[i][c] =
              CommonStatisticsMethods.buildMeanSem(m_pdRingMean, rI, rF, 1, c);
        }
      }
    }
    m_pnPixels = pixelsTemp;
    return 1;
  }