Esempio n. 1
0
  public final void exec(final List<Patch> patches, final Set<Patch> fixedPatches)
      throws Exception {
    /* make sure that passed patches are ok */
    if (patches.size() < 2) {
      Utils.log(
          "Elastic montage requires at least 2 patches to be montaged.  You passed me "
              + patches.size());
      return;
    }
    final Project project = patches.get(0).getProject();
    for (final Patch patch : patches) {
      if (patch.getProject() != project) {
        Utils.log(
            "Elastic montage requires all patches to be member of a single project.  You passed me patches from several projects.");
        return;
      }
    }
    for (final Patch patch : fixedPatches) {
      if (patch.getProject() != project) {
        Utils.log(
            "Elastic montage requires all fixed patches to be member of a single project.  You passed me fixed patches from several projects.");
        return;
      }
    }

    final Param param = setup();
    if (param == null) return;
    else exec(param, patches, fixedPatches);
  }
Esempio n. 2
0
 public boolean removeChild(TemplateThing child) {
   // check that it is contained here
   if (-1 == al_children.indexOf(child)) {
     Utils.log("TemplateThing.removeChild: child " + child + " not contained in parent " + this);
     return false;
   }
   al_children.remove(child);
   return true;
 }
Esempio n. 3
0
 final void addResults(final ResultsTable rt, final Calibration cal, final double nameid) {
   for (int i = 0; i < n_points; i++) {
     final Layer la = layer_set.getLayer(p_layer[i]);
     if (null == layer) {
       Utils.log("Dissector.addResults: could not find layer with id " + p_layer[i]);
       continue;
     }
     final Point2D.Double po = M.transform(Dissector.this.at, p[0][i], p[1][i]);
     rt.incrementCounter();
     rt.addLabel("units", cal.getUnit());
     rt.addValue(0, Dissector.this.id);
     rt.addValue(1, tag);
     rt.addValue(2, po.x * cal.pixelWidth);
     rt.addValue(3, po.y * cal.pixelHeight);
     rt.addValue(4, la.getZ() * cal.pixelWidth); // layer Z is in pixels
     rt.addValue(5, radius * cal.pixelWidth);
     rt.addValue(6, nameid);
   }
 }
Esempio n. 4
0
  @SuppressWarnings("deprecation")
  public final void exec(
      final Param param, final List<Patch> patches, final Set<Patch> fixedPatches)
      throws Exception {
    /* free memory */
    patches.get(0).getProject().getLoader().releaseAll();

    /* create tiles and models for all patches */
    final ArrayList<AbstractAffineTile2D<?>> tiles = new ArrayList<AbstractAffineTile2D<?>>();
    final ArrayList<AbstractAffineTile2D<?>> fixedTiles = new ArrayList<AbstractAffineTile2D<?>>();
    Align.tilesFromPatches(param.po, patches, fixedPatches, tiles, fixedTiles);

    if (!param.isAligned) {
      Align.alignTiles(param.po, tiles, fixedTiles, param.tilesAreInPlace, param.maxNumThreads);

      /* Apply the estimated affine transform to patches */
      for (final AbstractAffineTile2D<?> t : tiles)
        t.getPatch().setAffineTransform(t.createAffine());

      Display.update();
    }

    /* generate tile pairs for all by now overlapping tiles */
    final ArrayList<AbstractAffineTile2D<?>[]> tilePairs =
        new ArrayList<AbstractAffineTile2D<?>[]>();
    AbstractAffineTile2D.pairOverlappingTiles(tiles, tilePairs);

    /* check if there was any pair */
    if (tilePairs.size() == 0) {
      Utils.log("Elastic montage could not find any overlapping patches after pre-montaging.");
      return;
    }

    Utils.log(tilePairs.size() + " pairs of patches will be block-matched...");

    /* make pairwise global models local */
    final ArrayList<
            Triple<AbstractAffineTile2D<?>, AbstractAffineTile2D<?>, InvertibleCoordinateTransform>>
        pairs =
            new ArrayList<
                Triple<
                    AbstractAffineTile2D<?>,
                    AbstractAffineTile2D<?>,
                    InvertibleCoordinateTransform>>();

    /*
     * The following casting madness is necessary to get this code compiled
     * with Sun/Oracle Java 6 which otherwise generates an inconvertible
     * type exception.
     *
     * TODO Remove as soon as this bug is fixed in Sun/Oracle javac.
     */
    for (final AbstractAffineTile2D<?>[] pair : tilePairs) {
      final AbstractAffineModel2D<?> m;
      switch (param.po.desiredModelIndex) {
        case 0:
          final TranslationModel2D t =
              (TranslationModel2D) (Object) pair[1].getModel().createInverse();
          t.concatenate((TranslationModel2D) (Object) pair[0].getModel());
          m = t;
          break;
        case 1:
          final RigidModel2D r = (RigidModel2D) (Object) pair[1].getModel().createInverse();
          r.concatenate((RigidModel2D) (Object) pair[0].getModel());
          m = r;
          break;
        case 2:
          final SimilarityModel2D s =
              (SimilarityModel2D) (Object) pair[1].getModel().createInverse();
          s.concatenate((SimilarityModel2D) (Object) pair[0].getModel());
          m = s;
          break;
        case 3:
          final AffineModel2D a = (AffineModel2D) (Object) pair[1].getModel().createInverse();
          a.concatenate((AffineModel2D) (Object) pair[0].getModel());
          m = a;
          break;
        default:
          m = null;
      }
      pairs.add(
          new Triple<
              AbstractAffineTile2D<?>, AbstractAffineTile2D<?>, InvertibleCoordinateTransform>(
              pair[0], pair[1], m));
    }

    /* Elastic alignment */

    /* Initialization */
    final double springTriangleHeightTwice =
        2 * Math.sqrt(0.75 * param.springLengthSpringMesh * param.springLengthSpringMesh);

    final ArrayList<SpringMesh> meshes = new ArrayList<SpringMesh>(tiles.size());
    final HashMap<AbstractAffineTile2D<?>, SpringMesh> tileMeshMap =
        new HashMap<AbstractAffineTile2D<?>, SpringMesh>();
    for (final AbstractAffineTile2D<?> tile : tiles) {
      final double w = tile.getWidth();
      final double h = tile.getHeight();
      final int numX = Math.max(2, (int) Math.ceil(w / param.springLengthSpringMesh) + 1);
      final int numY = Math.max(2, (int) Math.ceil(h / springTriangleHeightTwice) + 1);
      final double wMesh = (numX - 1) * param.springLengthSpringMesh;
      final double hMesh = (numY - 1) * springTriangleHeightTwice;

      final SpringMesh mesh =
          new SpringMesh(
              numX,
              numY,
              wMesh,
              hMesh,
              param.stiffnessSpringMesh,
              param.maxStretchSpringMesh * param.bmScale,
              param.dampSpringMesh);
      meshes.add(mesh);
      tileMeshMap.put(tile, mesh);
    }

    //		final int blockRadius = Math.max( 32, Util.roundPos( param.springLengthSpringMesh / 2 ) );
    final int blockRadius = Math.max(Util.roundPos(16 / param.bmScale), param.bmBlockRadius);

    /** TODO set this something more than the largest error by the approximate model */
    final int searchRadius = param.bmSearchRadius;

    final AbstractModel<?> localSmoothnessFilterModel =
        mpicbg.trakem2.align.Util.createModel(param.bmLocalModelIndex);

    for (final Triple<
            AbstractAffineTile2D<?>, AbstractAffineTile2D<?>, InvertibleCoordinateTransform>
        pair : pairs) {
      final AbstractAffineTile2D<?> t1 = pair.a;
      final AbstractAffineTile2D<?> t2 = pair.b;

      final SpringMesh m1 = tileMeshMap.get(t1);
      final SpringMesh m2 = tileMeshMap.get(t2);

      final ArrayList<PointMatch> pm12 = new ArrayList<PointMatch>();
      final ArrayList<PointMatch> pm21 = new ArrayList<PointMatch>();

      final ArrayList<Vertex> v1 = m1.getVertices();
      final ArrayList<Vertex> v2 = m2.getVertices();

      final String patchName1 = patchName(t1.getPatch());
      final String patchName2 = patchName(t2.getPatch());

      final PatchImage pi1 = t1.getPatch().createTransformedImage();
      if (pi1 == null) {
        Utils.log("Patch `" + patchName1 + "' failed generating a transformed image.  Skipping...");
        continue;
      }
      final PatchImage pi2 = t2.getPatch().createTransformedImage();
      if (pi2 == null) {
        Utils.log("Patch `" + patchName2 + "' failed generating a transformed image.  Skipping...");
        continue;
      }

      final FloatProcessor fp1 = (FloatProcessor) pi1.target.convertToFloat();
      final ByteProcessor mask1 = pi1.getMask();
      final FloatProcessor fpMask1 = mask1 == null ? null : scaleByte(mask1);

      final FloatProcessor fp2 = (FloatProcessor) pi2.target.convertToFloat();
      final ByteProcessor mask2 = pi2.getMask();
      final FloatProcessor fpMask2 = mask2 == null ? null : scaleByte(mask2);

      if (!fixedTiles.contains(t1)) {
        BlockMatching.matchByMaximalPMCC(
            fp1,
            fp2,
            fpMask1,
            fpMask2,
            param.bmScale,
            pair.c,
            blockRadius,
            blockRadius,
            searchRadius,
            searchRadius,
            param.bmMinR,
            param.bmRodR,
            param.bmMaxCurvatureR,
            v1,
            pm12,
            new ErrorStatistic(1));

        if (param.bmUseLocalSmoothnessFilter) {
          Utils.log(
              "`"
                  + patchName1
                  + "' > `"
                  + patchName2
                  + "': found "
                  + pm12.size()
                  + " correspondence candidates.");
          localSmoothnessFilterModel.localSmoothnessFilter(
              pm12, pm12, param.bmLocalRegionSigma, param.bmMaxLocalEpsilon, param.bmMaxLocalTrust);
          Utils.log(
              "`"
                  + patchName1
                  + "' > `"
                  + patchName2
                  + "': "
                  + pm12.size()
                  + " candidates passed local smoothness filter.");
        } else {
          Utils.log(
              "`"
                  + patchName1
                  + "' > `"
                  + patchName2
                  + "': found "
                  + pm12.size()
                  + " correspondences.");
        }
      } else {
        Utils.log("Skipping fixed patch `" + patchName1 + "'.");
      }

      //			/* <visualisation> */
      //			//			final List< Point > s1 = new ArrayList< Point >();
      //			//			PointMatch.sourcePoints( pm12, s1 );
      //			//			final ImagePlus imp1 = new ImagePlus( i + " >", ip1 );
      //			//			imp1.show();
      //			//			imp1.setOverlay( BlockMatching.illustrateMatches( pm12 ), Color.yellow, null );
      //			//			imp1.setRoi( Util.pointsToPointRoi( s1 ) );
      //			//			imp1.updateAndDraw();
      //			/* </visualisation> */

      if (!fixedTiles.contains(t2)) {
        BlockMatching.matchByMaximalPMCC(
            fp2,
            fp1,
            fpMask2,
            fpMask1,
            param.bmScale,
            pair.c.createInverse(),
            blockRadius,
            blockRadius,
            searchRadius,
            searchRadius,
            param.bmMinR,
            param.bmRodR,
            param.bmMaxCurvatureR,
            v2,
            pm21,
            new ErrorStatistic(1));

        if (param.bmUseLocalSmoothnessFilter) {
          Utils.log(
              "`"
                  + patchName1
                  + "' < `"
                  + patchName2
                  + "': found "
                  + pm21.size()
                  + " correspondence candidates.");
          localSmoothnessFilterModel.localSmoothnessFilter(
              pm21, pm21, param.bmLocalRegionSigma, param.bmMaxLocalEpsilon, param.bmMaxLocalTrust);
          Utils.log(
              "`"
                  + patchName1
                  + "' < `"
                  + patchName2
                  + "': "
                  + pm21.size()
                  + " candidates passed local smoothness filter.");
        } else {
          Utils.log(
              "`"
                  + patchName1
                  + "' < `"
                  + patchName2
                  + "': found "
                  + pm21.size()
                  + " correspondences.");
        }
      } else {
        Utils.log("Skipping fixed patch `" + patchName2 + "'.");
      }

      /* <visualisation> */
      //			final List< Point > s2 = new ArrayList< Point >();
      //			PointMatch.sourcePoints( pm21, s2 );
      //			final ImagePlus imp2 = new ImagePlus( i + " <", ip2 );
      //			imp2.show();
      //			imp2.setOverlay( BlockMatching.illustrateMatches( pm21 ), Color.yellow, null );
      //			imp2.setRoi( Util.pointsToPointRoi( s2 ) );
      //			imp2.updateAndDraw();
      /* </visualisation> */

      for (final PointMatch pm : pm12) {
        final Vertex p1 = (Vertex) pm.getP1();
        final Vertex p2 = new Vertex(pm.getP2());
        p1.addSpring(p2, new Spring(0, 1.0f));
        m2.addPassiveVertex(p2);
      }

      for (final PointMatch pm : pm21) {
        final Vertex p1 = (Vertex) pm.getP1();
        final Vertex p2 = new Vertex(pm.getP2());
        p1.addSpring(p2, new Spring(0, 1.0f));
        m1.addPassiveVertex(p2);
      }
    }

    /* initialize */
    for (final Map.Entry<AbstractAffineTile2D<?>, SpringMesh> entry : tileMeshMap.entrySet())
      entry.getValue().init(entry.getKey().getModel());

    /* optimize the meshes */
    try {
      final long t0 = System.currentTimeMillis();
      IJ.log("Optimizing spring meshes...");

      if (param.useLegacyOptimizer) {
        Utils.log("  ...using legacy optimizer...");
        SpringMesh.optimizeMeshes2(
            meshes,
            param.po.maxEpsilon,
            param.maxIterationsSpringMesh,
            param.maxPlateauwidthSpringMesh,
            param.visualize);
      } else {
        SpringMesh.optimizeMeshes(
            meshes,
            param.po.maxEpsilon,
            param.maxIterationsSpringMesh,
            param.maxPlateauwidthSpringMesh,
            param.visualize);
      }
      IJ.log("Done optimizing spring meshes. Took " + (System.currentTimeMillis() - t0) + " ms");

    } catch (final NotEnoughDataPointsException e) {
      Utils.log("There were not enough data points to get the spring mesh optimizing.");
      e.printStackTrace();
      return;
    }

    /* apply */
    for (final Map.Entry<AbstractAffineTile2D<?>, SpringMesh> entry : tileMeshMap.entrySet()) {
      final AbstractAffineTile2D<?> tile = entry.getKey();
      if (!fixedTiles.contains(tile)) {
        final Patch patch = tile.getPatch();
        final SpringMesh mesh = entry.getValue();
        final Set<PointMatch> matches = mesh.getVA().keySet();
        Rectangle box = patch.getCoordinateTransformBoundingBox();

        /* compensate for existing coordinate transform bounding box */
        for (final PointMatch pm : matches) {
          final Point p1 = pm.getP1();
          final double[] l = p1.getL();
          l[0] += box.x;
          l[1] += box.y;
        }

        final MovingLeastSquaresTransform2 mlt = new MovingLeastSquaresTransform2();
        mlt.setModel(AffineModel2D.class);
        mlt.setAlpha(2.0f);
        mlt.setMatches(matches);

        patch.appendCoordinateTransform(mlt);
        box = patch.getCoordinateTransformBoundingBox();

        patch.getAffineTransform().setToTranslation(box.x, box.y);
        patch.updateInDatabase("transform");
        patch.updateBucket();

        patch.updateMipMaps();
      }
    }

    Utils.log("Done.");
  }