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);
}
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;
}
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);
}
}
@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.");
}