public Function_Index getExtendedPolygonIterator() {
   final List l = new LinkedList();
   for (final Iterator it = this.lLTL.iterator(); it.hasNext(); ) {
     final int[] iA = (int[]) it.next();
     l.add(new int[] {iA[1], iA[0]});
   }
   return PolygonFiller.polygonIteratorWithLessThans(
       PolygonFiller.clipPolygons(
           Generators.iteratorGenerator(
               IterationTools.addToEnd(
                   PolygonFiller.cloneEdgeList(
                           PolygonFillerTest.convertOldEdgeListToNewEdgeList(this.lREL))
                       .iterator(),
                   new PolygonFiller.Node(this.width, this.height, this.height, 1))),
           Generators.iteratorGenerator(
               IterationTools.addToEnd(
                   PolygonFiller.cloneEdgeList(
                           PolygonFillerTest.convertOldEdgeListToNewEdgeList(this.rREL))
                       .iterator(),
                   new PolygonFiller.Node(this.width, this.height, this.height, 1))),
           this.width + 1,
           this.height + 1),
       Generators.iteratorGenerator(this.rLTL.iterator()),
       Generators.iteratorGenerator(l.iterator()),
       new int[1000]);
 }
Beispiel #2
0
 public ImageProcessor getMask() {
   if (cachedMask != null && cachedMask.getPixels() != null) return cachedMask;
   PolygonFiller pf = new PolygonFiller();
   if (xSpline != null) pf.setPolygon(toIntR(xSpline), toIntR(ySpline), splinePoints);
   else if (xpf != null) pf.setPolygon(toIntR(xpf), toIntR(ypf), nPoints);
   else pf.setPolygon(xp, yp, nPoints);
   cachedMask = pf.getMask(width, height);
   return cachedMask;
 }
 float[][][] backwardMatrix() {
   int[][] matrix = new int[this.height][this.width];
   PolygonFillerTest.fillInMatrix(
       matrix,
       PolygonFillerTest.convertNewEdgeListToOldEdgeList(
           PolygonFiller.cloneEdgeList(
               PolygonFillerTest.convertOldEdgeListToNewEdgeList(this.eT))),
       1,
       0);
   matrix = (int[][]) Array.transpose2DMatrix().fn(matrix);
   matrix = (int[][]) Array.reverseXAxisOf2DMatrix().fn(matrix);
   matrix = (int[][]) Array.reverseYAxisOf2DMatrix().fn(matrix);
   final float[] eS = this.endStates.clone();
   Array.reverseArray(eS, 0, eS.length);
   final int[] rLTL2 = new int[1000];
   final int[] lLTL2 = new int[1000];
   PolygonFiller.reverseLessThanCoordinates(
       MatrixIteratorTest.convertLTPoints(this.rLTL), rLTL2, this.width - 1, this.height - 1);
   PolygonFiller.reverseLessThanCoordinates(
       MatrixIteratorTest.convertLTPoints(this.lLTL), lLTL2, this.width - 1, this.height - 1);
   final float[][][] matrixB =
       MatrixIteratorTest.computeMatrix(
           matrix,
           new Cell.CellCalculator() {
             /* (non-Javadoc)
              * @see bp.pecan.dpc.Cell.CellCalculator#calc(float[], int, int)
              */
             public void calc(float[] cells, int offset, int x, int y) {
               ForwardBackwardMatrixIterTest.this.setCellsBackwardsLL.calc(
                   cells,
                   offset,
                   ForwardBackwardMatrixIterTest.this.width - 1 - x,
                   ForwardBackwardMatrixIterTest.this.height - 1 - y);
             }
           },
           this.stateNumber,
           eS,
           Float.NEGATIVE_INFINITY,
           rLTL2,
           lLTL2);
   final float[][][] matrixB2 = new float[matrixB.length][matrixB[0].length][this.stateNumber];
   for (int i = 0; i < matrixB.length; i++) {
     for (int j = 0; j < matrixB[i].length; j++) {
       for (int k = 0; k < matrixB[i][j].length; k++) {
         matrixB2[matrixB.length - 1 - i][matrixB[i].length - 1 - j][this.stateNumber - 1 - k] =
             matrixB[i][j][k];
       }
     }
   }
   return matrixB2;
 }
 float[][][] forwardMatrix() {
   int[][] matrix = new int[this.height][this.width];
   PolygonFillerTest.fillInMatrix(
       matrix,
       PolygonFillerTest.convertNewEdgeListToOldEdgeList(
           PolygonFiller.cloneEdgeList(
               PolygonFillerTest.convertOldEdgeListToNewEdgeList(this.eT))),
       1,
       0);
   matrix = (int[][]) Array.transpose2DMatrix().fn(matrix);
   return MatrixIteratorTest.computeMatrix(
       matrix,
       this.setCellsForwardsLL,
       this.stateNumber,
       this.startStates.clone(),
       Float.NEGATIVE_INFINITY,
       MatrixIteratorTest.convertLTPoints(this.lLTL),
       MatrixIteratorTest.convertLTPoints(this.rLTL));
 }
  protected void setup(final int minWidth) throws Exception {
    super.setUp();
    this.r = new Random();
    this.minMaxOffset = 1 + (int) (Math.random() * 5);
    this.height = 2 * this.minMaxOffset + (int) (Math.random() * 300);
    this.width = 2 * this.minMaxOffset + (int) (Math.random() * 300);
    this.stateNumber = 3;
    this.d1 = MatrixIteratorTest.getRandomSeq(this.width + 1, 4);
    this.d2 = MatrixIteratorTest.getRandomSeq(this.height + 1, 4);
    final Object[] oA =
        ForwardBackwardMatrixIterTest.getStateMachine_Float(
            ForwardBackwardMatrixIterTest.getD(this.d1),
            ForwardBackwardMatrixIterTest.getD(this.d2),
            "bp/pecan/asymmetric.hmm",
            1001);

    this.setCellsForwardsLL = (Cell.CellCalculator) oA[0];
    this.setCellsBackwardsLL = (Cell.CellCalculator) oA[1];
    this.setCellsForwardsL = (Cell.CellCalculator) oA[2];
    this.setCellsForwardsR = (Cell.CellCalculator) oA[3];
    this.setCellsBackwardsL = (Cell.CellCalculator) oA[4];
    this.setCellsBackwardsR = (Cell.CellCalculator) oA[5];

    final List[] poly =
        PolygonFillerTest.getRandomPolygon(this.width, this.height, this.minMaxOffset, minWidth);
    this.lREL = poly[0];
    this.rREL = poly[1];
    // lLTL =
    // MatrixIteratorTest.getRandomLTPoints(PolygonFillerTest.convertOldEdgeListToNewEdgeList(lREL));
    // rLTL =
    // MatrixIteratorTest.getRandomLTPoints(PolygonFillerTest.convertOldEdgeListToNewEdgeList(rREL));

    this.eT =
        PolygonFillerTest.convertNewEdgeListToOldEdgeList(
            (List)
                IterationTools.append(
                    PolygonFiller.combineEdgeLists(
                        PolygonFiller.cloneEdgeList(
                                PolygonFillerTest.convertOldEdgeListToNewEdgeList(this.lREL))
                            .iterator(),
                        PolygonFiller.cloneEdgeList(
                                PolygonFillerTest.convertOldEdgeListToNewEdgeList(this.rREL))
                            .iterator()),
                    new ArrayList()));

    int[][] matrix = new int[this.height][this.width];
    PolygonFillerTest.fillInMatrix(
        matrix,
        PolygonFillerTest.convertNewEdgeListToOldEdgeList(
            PolygonFiller.cloneEdgeList(
                PolygonFillerTest.convertOldEdgeListToNewEdgeList(this.eT))),
        1,
        0);
    matrix = (int[][]) Array.transpose2DMatrix().fn(matrix);

    this.lLTL = MatrixIteratorTest.getRandomLTPPointsL(matrix);
    this.rLTL = MatrixIteratorTest.getRandomLTPPointsR(matrix);

    this.mI = new MatrixIterator(this.stateNumber, 1000);
    this.polygonClipper =
        PolygonFiller.clipPolygons(
            Generators.iteratorGenerator(
                PolygonFiller.cloneEdgeList(
                        PolygonFillerTest.convertOldEdgeListToNewEdgeList(this.lREL))
                    .iterator()),
            Generators.iteratorGenerator(
                PolygonFiller.cloneEdgeList(
                        PolygonFillerTest.convertOldEdgeListToNewEdgeList(this.rREL))
                    .iterator()),
            this.width,
            this.height);
    this.startStates =
        new float[] {
          (float) Math.log(1.0 / 3), (float) Math.log(1.0 / 3), (float) Math.log(1.0 / 3)
        };
    this.endStates =
        new float[] {
          (float) Math.log(1.0 / 3), (float) Math.log(1.0 / 3), (float) Math.log(1.0 / 3)
        };
  }
 void analyzeParticle(int x, int y, ImagePlus imp, ImageProcessor ip) {
   // Wand wand = new Wand(ip);
   ImageProcessor ip2 = redirectIP != null ? redirectIP : ip;
   wand.autoOutline(x, y, level1, level2, wandMode);
   if (wand.npoints == 0) {
     IJ.log("wand error: " + x + " " + y);
     return;
   }
   Roi roi = new PolygonRoi(wand.xpoints, wand.ypoints, wand.npoints, roiType);
   Rectangle r = roi.getBounds();
   if (r.width > 1 && r.height > 1) {
     PolygonRoi proi = (PolygonRoi) roi;
     pf.setPolygon(proi.getXCoordinates(), proi.getYCoordinates(), proi.getNCoordinates());
     ip2.setMask(pf.getMask(r.width, r.height));
     if (floodFill) ff.particleAnalyzerFill(x, y, level1, level2, ip2.getMask(), r);
   }
   ip2.setRoi(r);
   ip.setValue(fillColor);
   ImageStatistics stats = getStatistics(ip2, measurements, calibration);
   boolean include = true;
   if (excludeEdgeParticles) {
     if (r.x == minX || r.y == minY || r.x + r.width == maxX || r.y + r.height == maxY)
       include = false;
     if (polygon != null) {
       Rectangle bounds = roi.getBounds();
       int x1 = bounds.x + wand.xpoints[wand.npoints - 1];
       int y1 = bounds.y + wand.ypoints[wand.npoints - 1];
       int x2, y2;
       for (int i = 0; i < wand.npoints; i++) {
         x2 = bounds.x + wand.xpoints[i];
         y2 = bounds.y + wand.ypoints[i];
         if (!polygon.contains(x2, y2)) {
           include = false;
           break;
         }
         if ((x1 == x2 && ip.getPixel(x1, y1 - 1) == fillColor)
             || (y1 == y2 && ip.getPixel(x1 - 1, y1) == fillColor)) {
           include = false;
           break;
         }
         x1 = x2;
         y1 = y2;
       }
     }
   }
   ImageProcessor mask = ip2.getMask();
   if (minCircularity > 0.0 || maxCircularity < 1.0) {
     double perimeter = roi.getLength();
     double circularity =
         perimeter == 0.0 ? 0.0 : 4.0 * Math.PI * (stats.pixelCount / (perimeter * perimeter));
     if (circularity > 1.0) circularity = 1.0;
     // IJ.log(circularity+"	"+perimeter+"  "+stats.area);
     if (circularity < minCircularity || circularity > maxCircularity) include = false;
   }
   if (stats.pixelCount >= minSize && stats.pixelCount <= maxSize && include) {
     particleCount++;
     if (roiNeedsImage) roi.setImage(imp);
     stats.xstart = x;
     stats.ystart = y;
     saveResults(stats, roi);
     if (showChoice != NOTHING) drawParticle(drawIP, roi, stats, mask);
   }
   if (redirectIP != null) ip.setRoi(r);
   ip.fill(mask);
 }