// @Override
  @Override
  public void estimateInverseBounds(final float[] min, final float[] max)
      throws NoninvertibleModelException {
    assert min.length == max.length : "min and max have to have equal length.";

    final int g = 32;

    final float[] minBounds = new float[min.length];
    final float[] maxBounds = new float[min.length];
    final float[] s = new float[min.length];
    final int[] i = new int[min.length];
    final float[] l = new float[min.length];

    for (int k = 0; k < min.length; ++k) {
      minBounds[k] = Float.MAX_VALUE;
      maxBounds[k] = -Float.MAX_VALUE;
      s[k] = (max[k] - min[k]) / (g - 1);
      l[k] = min[k];
    }

    final long d = Util.pow(g, min.length);

    for (long j = 0; j < d; ++j) {
      final float[] m = applyInverse(l);
      for (int k = 0; k < min.length; ++k) {
        if (m[k] < minBounds[k]) minBounds[k] = m[k];
        if (m[k] > maxBounds[k]) maxBounds[k] = m[k];
      }

      for (int k = 0; k < min.length; ++k) {
        ++i[k];
        if (i[k] >= g) {
          i[k] = 0;
          l[k] = min[k];
          continue;
        }
        l[k] = min[k] + i[k] * s[k];
        break;
      }
    }

    for (int k = 0; k < min.length; ++k) {
      min[k] = minBounds[k];
      max[k] = maxBounds[k];
    }
  }
Exemple #2
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.");
  }
Exemple #3
0
    public boolean setup() {
      /* Block Matching */
      if (bmBlockRadius < 0) {
        bmBlockRadius = Util.roundPos(springLengthSpringMesh / 2);
      }
      final GenericDialog gdBlockMatching =
          new GenericDialog("Elastic montage: Block Matching and Spring Meshes");

      gdBlockMatching.addMessage("Block Matching:");
      gdBlockMatching.addNumericField("patch_scale :", bmScale, 2);
      gdBlockMatching.addNumericField("search_radius :", bmSearchRadius, 0, 6, "px");
      gdBlockMatching.addNumericField("block_radius :", bmBlockRadius, 0, 6, "px");

      gdBlockMatching.addMessage("Correlation Filters:");
      gdBlockMatching.addNumericField("minimal_PMCC_r :", bmMinR, 2);
      gdBlockMatching.addNumericField("maximal_curvature_ratio :", bmMaxCurvatureR, 2);
      gdBlockMatching.addNumericField("maximal_second_best_r/best_r :", bmRodR, 2);

      gdBlockMatching.addMessage("Local Smoothness Filter:");
      gdBlockMatching.addCheckbox("use_local_smoothness_filter", bmUseLocalSmoothnessFilter);
      gdBlockMatching.addChoice(
          "approximate_local_transformation :",
          ParamOptimize.modelStrings,
          ParamOptimize.modelStrings[bmLocalModelIndex]);
      gdBlockMatching.addNumericField("local_region_sigma:", bmLocalRegionSigma, 2, 6, "px");
      gdBlockMatching.addNumericField(
          "maximal_local_displacement (absolute):", bmMaxLocalEpsilon, 2, 6, "px");
      gdBlockMatching.addNumericField("maximal_local_displacement (relative):", bmMaxLocalTrust, 2);

      gdBlockMatching.addMessage("Montage :");
      gdBlockMatching.addCheckbox("tiles_are_pre-montaged", isAligned);

      gdBlockMatching.showDialog();

      if (gdBlockMatching.wasCanceled()) return false;

      bmScale = gdBlockMatching.getNextNumber();
      bmSearchRadius = (int) gdBlockMatching.getNextNumber();
      bmBlockRadius = (int) gdBlockMatching.getNextNumber();
      bmMinR = (float) gdBlockMatching.getNextNumber();
      bmMaxCurvatureR = (float) gdBlockMatching.getNextNumber();
      bmRodR = (float) gdBlockMatching.getNextNumber();

      bmUseLocalSmoothnessFilter = gdBlockMatching.getNextBoolean();
      bmLocalModelIndex = gdBlockMatching.getNextChoiceIndex();
      bmLocalRegionSigma = (float) gdBlockMatching.getNextNumber();
      bmMaxLocalEpsilon = (float) gdBlockMatching.getNextNumber();
      bmMaxLocalTrust = (float) gdBlockMatching.getNextNumber();

      isAligned = gdBlockMatching.getNextBoolean();

      final GenericDialog gdSpringMesh = new GenericDialog("Elastic montage: Spring Meshes");

      /* TODO suggest a resolution that matches maxEpsilon */
      gdSpringMesh.addNumericField("spring_length :", springLengthSpringMesh, 2, 6, "px");
      gdSpringMesh.addNumericField("stiffness :", stiffnessSpringMesh, 2);
      gdSpringMesh.addNumericField("maximal_stretch :", maxStretchSpringMesh, 2, 6, "px");
      gdSpringMesh.addNumericField("maximal_iterations :", maxIterationsSpringMesh, 0);
      gdSpringMesh.addNumericField("maximal_plateauwidth :", maxPlateauwidthSpringMesh, 0);
      gdSpringMesh.addCheckbox("use_legacy_optimizer :", useLegacyOptimizer);

      gdSpringMesh.showDialog();

      if (gdSpringMesh.wasCanceled()) return false;

      springLengthSpringMesh = gdSpringMesh.getNextNumber();
      stiffnessSpringMesh = gdSpringMesh.getNextNumber();
      maxStretchSpringMesh = gdSpringMesh.getNextNumber();
      maxIterationsSpringMesh = (int) gdSpringMesh.getNextNumber();
      maxPlateauwidthSpringMesh = (int) gdSpringMesh.getNextNumber();
      useLegacyOptimizer = gdSpringMesh.getNextBoolean();

      if (isAligned) po.desiredModelIndex = 3;
      else {
        if (!po.setup("Elastic montage : SIFT based pre-montage")) return false;

        final GenericDialog gdSIFT =
            new GenericDialog("Elastic montage : SIFT based pre-montage: Miscellaneous");
        gdSIFT.addCheckbox("tiles_are_roughly_in_place", tilesAreInPlace);
        gdSIFT.showDialog();
        if (gdSIFT.wasCanceled()) return false;

        tilesAreInPlace = gdSIFT.getNextBoolean();
      }

      return true;
    }