@Override
public boolean equals(Object obj) {
if (obj == this) return true;
if (obj == null || !(obj instanceof Hsp)) return false;
Align cp = Align.class.cast(obj);
return cp.getHsp() == getHsp() && cp.getIndex() == getIndex();
}
@Override
protected Align clone() {
Align a = new Align();
a.indexInAlignment = indexInAlignment;
a.hit_index = hit_index;
a.query_index = query_index;
return a;
}
public static void init() {
Add.init();
Address.init();
Align.init();
Alloc.init();
Anchor.init();
And.init();
Bad.init();
Bitcast.init();
Block.init();
Builtin.init();
Call.init();
Cmp.init();
Cond.init();
Confirm.init();
Const.init();
Conv.init();
CopyB.init();
Deleted.init();
Div.init();
Dummy.init();
End.init();
Eor.init();
Free.init();
IJmp.init();
Id.init();
Jmp.init();
Load.init();
Member.init();
Minus.init();
Mod.init();
Mul.init();
Mulh.init();
Mux.init();
NoMem.init();
Not.init();
Offset.init();
Or.init();
Phi.init();
Pin.init();
Proj.init();
Raise.init();
Return.init();
Sel.init();
Shl.init();
Shr.init();
Shrs.init();
Size.init();
Start.init();
Store.init();
Sub.init();
Switch.init();
Sync.init();
Tuple.init();
Unknown.init();
}
void addToolbarAlign(StringBuffer buffer) {
if (toolbarAlign != null) {
buffer
.append(",\n\t")
.append("theme_advanced_toolbar_align : ")
.append("\"")
.append(toolbarAlign.getName())
.append("\"");
}
}
@Override
public Align next() {
if (curr.indexInAlignment >= owner().getAlignLength()) {
throw new IllegalStateException();
}
Align ret = curr.clone();
char ch = curr.getHitChar();
char cq = curr.getQueryChar();
if (ch != '-' && ch != ' ') {
curr.hit_index += hitShift();
}
if (cq != '-' && cq != ' ') {
curr.query_index++;
}
++curr.indexInAlignment;
return ret;
}
/**
* Returns true if the two have the same properties. Returns false otherwise
*
* @param pString The MultiLineString to check against
* @return true or false if the values are equal
*/
public boolean equalProperties(MultiLineString pString) {
if (!aText.equals(pString.getText())) {
return false;
}
if (aJustification.ordinal() != pString.getJustification()) {
return false;
}
if (aBold != pString.aBold) {
return false;
}
if (aUnderlined != pString.isUnderlined()) {
return false;
}
return true;
}
/*
* @return an HTML version of the text of the string,
* taking into account the properties (underline, bold, etc.)
*/
StringBuffer convertToHtml() {
StringBuffer prefix = new StringBuffer();
StringBuffer suffix = new StringBuffer();
StringBuffer htmlText = new StringBuffer();
// Add some spacing before and after the text.
prefix.append(" ");
suffix.insert(0, " ");
if (aUnderlined) {
prefix.append("<u>");
suffix.insert(0, "</u>");
}
if (aBold) {
prefix.append("<b>");
suffix.insert(0, "</b>");
}
htmlText.append("<html><p align=\"" + aJustification.toString().toLowerCase() + "\">");
StringTokenizer tokenizer = new StringTokenizer(aText, "\n");
boolean first = true;
while (tokenizer.hasMoreTokens()) {
if (first) {
first = false;
} else {
htmlText.append("<br>");
}
htmlText.append(prefix);
String next = tokenizer.nextToken();
String next1 = next.replaceAll("<", "<");
String next2 = next1.replaceAll(">", ">");
htmlText.append(next2);
htmlText.append(suffix);
}
htmlText.append("</p></html>");
return htmlText;
}
@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.");
}
/**
* Sets the value of the justification property.
*
* @param pJustification the justification, one of LEFT, CENTER, RIGHT
*/
public void setJustification(int pJustification) {
assert pJustification >= 0 && pJustification < Align.values().length;
aJustification = Align.values()[pJustification];
}
/**
* Gets the value of the justification property.
*
* @return the justification, one of LEFT, CENTER, RIGHT
*/
public int getJustification() {
return aJustification.ordinal();
}
MyIterator() {
curr = new Align();
curr.query_index = owner().getQueryFrom1();
curr.hit_index = owner().getHitFrom1();
curr.indexInAlignment = 0;
}
