// @Override
public void run(String arg0) {
// get list of image stacks
final int[] idList = WindowManager.getIDList();
if (idList == null || idList.length < 2) {
IJ.error("You need at least two open images.");
return;
}
final String[] imgList = new String[idList.length];
for (int i = 0; i < idList.length; ++i)
imgList[i] = WindowManager.getImage(idList[i]).getTitle();
if (defaultImg1 >= imgList.length || defaultImg2 >= imgList.length) {
defaultImg1 = 0;
defaultImg2 = 1;
}
/** The first dialog for choosing the images */
final GenericDialog gd = new GenericDialog("Descriptor based registration");
gd.addChoice("First_image (to register)", imgList, imgList[defaultImg1]);
gd.addChoice("Second_image (reference)", imgList, imgList[defaultImg2]);
if (lastModel1 != null) gd.addCheckbox("Reapply last model", defaultReApply);
gd.addMessage(
"Warning: if images are of RGB or 8-bit color they will be converted to hyperstacks.");
gd.addMessage(
"Please note that the SPIM Registration is based on a publication.\n"
+ "If you use it successfully for your research please be so kind to cite our work:\n"
+ "Preibisch et al., Nature Methods (2010), 7(6):418-419\n");
MultiLineLabel text = (MultiLineLabel) gd.getMessage();
Bead_Registration.addHyperLinkListener(text, paperURL);
gd.showDialog();
if (gd.wasCanceled()) return;
ImagePlus imp1 = WindowManager.getImage(idList[defaultImg1 = gd.getNextChoiceIndex()]);
ImagePlus imp2 = WindowManager.getImage(idList[defaultImg2 = gd.getNextChoiceIndex()]);
boolean reApply = false;
if (lastModel1 != null) {
reApply = gd.getNextBoolean();
defaultReApply = reApply;
}
// if one of the images is rgb or 8-bit color convert them to hyperstack
imp1 = Hyperstack_rearranger.convertToHyperStack(imp1);
imp2 = Hyperstack_rearranger.convertToHyperStack(imp2);
// test if the images are compatible
String error = testRegistrationCompatibility(imp1, imp2);
if (error != null) {
IJ.log(error);
return;
}
// get the parameters
final int dimensionality;
if (imp1.getNSlices() > 1) dimensionality = 3;
else dimensionality = 2;
if (imp1.getNFrames() > 1 || imp2.getNFrames() > 2)
IJ.log(
"WARNING: Images have more than one timepoint, same model as the first timepoint will be applied to all timepoints.");
if (imp1.getNFrames() != imp2.getNFrames())
IJ.log(
"CRITICAL: Images do not have the same amount of timepoints. Will use the number of timepoints of the smaller series.");
// reapply?
if (reApply) {
if (dimensionality < lastDimensionality) {
IJ.log(
"Cannot reapply, cannot apply a "
+ lastModel1.getClass().getSimpleName()
+ " to "
+ dimensionality
+ " data.");
defaultReApply = false;
return;
} else if (dimensionality > lastDimensionality) {
IJ.log(
"WARNING: applying a "
+ lastModel1.getClass().getSimpleName()
+ " to "
+ dimensionality
+ " data.");
}
// just fuse
final DescriptorParameters params = new DescriptorParameters();
params.dimensionality = dimensionality;
params.reApply = true;
params.fuse = 0;
params.setPointsRois = false;
Matching.descriptorBasedRegistration(imp1, imp2, params);
return;
}
// open a second dialog and query the other parameters
final DescriptorParameters params = getParameters(imp1, imp2, dimensionality);
if (params == null) return;
// compute the actual matching
Matching.descriptorBasedRegistration(imp1, imp2, params);
}
/**
* Ask for all other required parameters ..
*
* @param dimensionality
*/
protected DescriptorParameters getParameters(
final ImagePlus imp1, final ImagePlus imp2, final int dimensionality) {
final String[] transformationModel =
dimensionality == 2 ? transformationModels2d : transformationModels3d;
// check if default selection of transformation model holds
if (defaultTransformationModel >= transformationModel.length) defaultTransformationModel = 1;
if (defaultRegularizationTransformationModel >= transformationModel.length)
defaultRegularizationTransformationModel = 1;
// one of them is by default interactive, then all are interactive
if (defaultDetectionBrightness == detectionBrightness.length - 1
|| defaultDetectionSize == detectionSize.length - 1
|| defaultDetectionType == detectionTypes.length - 1) {
defaultDetectionBrightness = detectionBrightness.length - 1;
defaultDetectionSize = detectionSize.length - 1;
defaultDetectionType = detectionTypes.length - 1;
}
final GenericDialog gd =
new GenericDialog(dimensionality + "-dimensional descriptor based registration");
gd.addChoice(
"Brightness_of detections",
detectionBrightness,
detectionBrightness[defaultDetectionBrightness]);
gd.addChoice(
"Approximate_size of detections", detectionSize, detectionSize[defaultDetectionSize]);
gd.addChoice("Type_of_detections", detectionTypes, detectionTypes[defaultDetectionType]);
gd.addChoice(
"Subpixel_Localization",
Descriptor_based_series_registration.localizationChoice,
Descriptor_based_series_registration.localizationChoice[
Descriptor_based_series_registration.defaultLocalization]);
gd.addChoice(
"Transformation_model",
transformationModel,
transformationModel[defaultTransformationModel]);
gd.addCheckbox("Regularize_model", defaultRegularize);
gd.addChoice("Images_pre-alignemnt", orientation, orientation[defaultSimilarOrientation]);
if (dimensionality == 2) {
if (defaultNumNeighbors < 2) defaultNumNeighbors = 2;
gd.addSlider("Number_of_neighbors for the descriptors", 2, 10, defaultNumNeighbors);
} else {
if (defaultNumNeighbors < 3) defaultNumNeighbors = 3;
gd.addSlider("Number_of_neighbors for the descriptors", 3, 10, defaultNumNeighbors);
}
gd.addSlider("Redundancy for descriptor matching", 0, 10, defaultRedundancy);
gd.addSlider("Significance required for a descriptor match", 1.0, 10.0, defaultSignificance);
gd.addSlider("Allowed_error_for_RANSAC (px)", 0.5, 20.0, defaultRansacThreshold);
final int numChannels1 = imp1.getNChannels();
final int numChannels2 = imp2.getNChannels();
if (defaultChannel1 > numChannels1) defaultChannel1 = 1;
if (defaultChannel2 > numChannels2) defaultChannel2 = 1;
gd.addSlider("Choose_registration_channel_for_image_1", 1, numChannels1, defaultChannel1);
gd.addSlider("Choose_registration_channel_for_image_2", 1, numChannels2, defaultChannel2);
gd.addMessage("Image fusion");
gd.addCheckbox("Create_overlayed images", defaultCreateOverlay);
gd.addCheckbox("Add_point_rois for corresponding features to images", defaultAddPointRoi);
gd.addMessage("");
gd.addMessage("This Plugin is developed by Stephan Preibisch\n" + myURL);
MultiLineLabel text = (MultiLineLabel) gd.getMessage();
Bead_Registration.addHyperLinkListener(text, myURL);
gd.showDialog();
if (gd.wasCanceled()) return null;
final DescriptorParameters params = new DescriptorParameters();
params.dimensionality = dimensionality;
params.roi1 = imp1.getRoi();
params.roi2 = imp2.getRoi();
final int detectionBrightnessIndex = gd.getNextChoiceIndex();
final int detectionSizeIndex = gd.getNextChoiceIndex();
final int detectionTypeIndex = gd.getNextChoiceIndex();
final int localization = gd.getNextChoiceIndex();
final int transformationModelIndex = gd.getNextChoiceIndex();
final boolean regularize = gd.getNextBoolean();
final int similarOrientation = gd.getNextChoiceIndex();
final int numNeighbors = (int) Math.round(gd.getNextNumber());
final int redundancy = (int) Math.round(gd.getNextNumber());
final double significance = gd.getNextNumber();
final double ransacThreshold = gd.getNextNumber();
// zero-offset channel
final int channel1 = (int) Math.round(gd.getNextNumber()) - 1;
final int channel2 = (int) Math.round(gd.getNextNumber()) - 1;
final boolean createOverlay = gd.getNextBoolean();
final boolean addPointRoi = gd.getNextBoolean();
// update static values for next call
defaultDetectionBrightness = detectionBrightnessIndex;
defaultDetectionSize = detectionSizeIndex;
defaultDetectionType = detectionTypeIndex;
Descriptor_based_series_registration.defaultLocalization = localization;
defaultTransformationModel = transformationModelIndex;
defaultRegularize = regularize;
defaultSimilarOrientation = similarOrientation;
defaultNumNeighbors = numNeighbors;
defaultRedundancy = redundancy;
defaultSignificance = significance;
defaultRansacThreshold = ransacThreshold;
defaultChannel1 = channel1 + 1;
defaultChannel2 = channel2 + 1;
defaultCreateOverlay = createOverlay;
defaultAddPointRoi = addPointRoi;
// instantiate model
if (dimensionality == 2) {
switch (transformationModelIndex) {
case 0:
params.model = new TranslationModel2D();
break;
case 1:
params.model = new RigidModel2D();
break;
case 2:
params.model = new SimilarityModel2D();
break;
case 3:
params.model = new AffineModel2D();
break;
case 4:
if (regularize) {
IJ.log("HomographyModel2D cannot be regularized yet");
return null;
}
params.model = new HomographyModel2D();
break;
default:
params.model = new RigidModel2D();
break;
}
} else {
switch (transformationModelIndex) {
case 0:
params.model = new TranslationModel3D();
break;
case 1:
params.model = new RigidModel3D();
break;
case 2:
params.model = new SimilarityModel3D();
break;
case 3:
params.model = new AffineModel3D();
break;
default:
params.model = new RigidModel3D();
break;
}
}
// regularization
if (regularize) {
final GenericDialog gdRegularize = new GenericDialog("Choose Regularization Model");
gdRegularize.addChoice(
"Transformation_model",
transformationModel,
transformationModel[defaultRegularizationTransformationModel]);
gdRegularize.addNumericField("Lambda", defaultLambda, 2);
gdRegularize.showDialog();
if (gdRegularize.wasCanceled()) return null;
params.regularize = true;
final int modelIndex =
defaultRegularizationTransformationModel = gdRegularize.getNextChoiceIndex();
params.fixFirstTile = true;
params.lambda = defaultLambda = gdRegularize.getNextNumber();
// update model to a regularized one using the previous model
if (dimensionality == 2) {
switch (modelIndex) {
case 0:
params.model =
new InterpolatedAffineModel2D(
params.model, new TranslationModel2D(), (float) params.lambda);
break;
case 1:
params.model =
new InterpolatedAffineModel2D(
params.model, new RigidModel2D(), (float) params.lambda);
break;
case 2:
params.model =
new InterpolatedAffineModel2D(
params.model, new SimilarityModel2D(), (float) params.lambda);
break;
case 3:
params.model =
new InterpolatedAffineModel2D(
params.model, new AffineModel2D(), (float) params.lambda);
break;
case 4:
IJ.log("HomographyModel2D cannot be used for regularization yet");
return null;
default:
params.model =
new InterpolatedAffineModel2D(
params.model, new RigidModel2D(), (float) params.lambda);
break;
}
} else {
switch (modelIndex) {
case 0:
params.model =
new InterpolatedAffineModel3D(
params.model, new TranslationModel3D(), (float) params.lambda);
break;
case 1:
params.model =
new InterpolatedAffineModel3D(
params.model, new RigidModel3D(), (float) params.lambda);
break;
case 2:
params.model =
new InterpolatedAffineModel3D(
params.model, new SimilarityModel3D(), (float) params.lambda);
break;
case 3:
params.model =
new InterpolatedAffineModel3D(
params.model, new AffineModel3D(), (float) params.lambda);
break;
default:
params.model =
new InterpolatedAffineModel3D(
params.model, new RigidModel3D(), (float) params.lambda);
break;
}
}
} else {
params.regularize = false;
params.fixFirstTile = true;
}
// one of them is by default interactive, then all are interactive
if (detectionBrightnessIndex == detectionBrightness.length - 1
|| detectionSizeIndex == detectionSize.length - 1
|| detectionTypeIndex == detectionTypes.length - 1) {
// query parameters interactively
final double[] values = new double[] {defaultSigma, defaultThreshold};
final InteractiveDoG idog = getInteractiveDoGParameters(imp1, channel1, values, 20);
if (idog.wasCanceled()) return null;
params.sigma1 = values[0];
params.threshold = values[1];
params.lookForMaxima = idog.getLookForMaxima();
params.lookForMinima = idog.getLookForMinima();
} else {
if (detectionBrightnessIndex == detectionBrightness.length - 2
|| detectionSizeIndex == detectionSize.length - 2) {
// ask for the dog parameters
final double[] values = getAdvancedDoGParameters(defaultSigma, defaultThreshold);
// cancelled
if (values == null) return null;
params.sigma1 = values[0];
params.threshold = values[1];
} else {
if (detectionBrightnessIndex == 0) params.threshold = 0.001;
else if (detectionBrightnessIndex == 1) params.threshold = 0.008;
else if (detectionBrightnessIndex == 2) params.threshold = 0.03;
else if (detectionBrightnessIndex == 3) params.threshold = 0.1;
params.sigma1 = (detectionSizeIndex + 2.0) / 2.0;
}
if (detectionTypeIndex == 2) {
params.lookForMaxima = true;
params.lookForMinima = true;
} else if (detectionTypeIndex == 1) {
params.lookForMinima = true;
params.lookForMaxima = false;
} else {
params.lookForMinima = false;
params.lookForMaxima = true;
}
}
// set the new default values
defaultSigma = params.sigma1;
defaultThreshold = params.threshold;
if (params.lookForMaxima && params.lookForMinima) defaultDetectionType = 2;
else if (params.lookForMinima) defaultDetectionType = 1;
else defaultDetectionType = 0;
// other parameters
params.sigma2 =
InteractiveDoG.computeSigma2((float) params.sigma1, InteractiveDoG.standardSenstivity);
if (similarOrientation == 0) params.similarOrientation = false;
else params.similarOrientation = true;
params.numNeighbors = numNeighbors;
params.redundancy = redundancy;
params.significance = significance;
params.ransacThreshold = ransacThreshold;
params.channel1 = channel1;
params.channel2 = channel2;
if (createOverlay) params.fuse = 0;
else params.fuse = 2;
params.setPointsRois = addPointRoi;
params.localization = localization;
// ask for the approximate transformation
if (similarOrientation == 2) {
if (TranslationModel3D.class.isInstance(params.model)
|| TranslationModel2D.class.isInstance(params.model)) {
IJ.log("No parameters necessary ... the matching is anyways translation invariant.");
} else if (RigidModel3D.class.isInstance(params.model)) {
final GenericDialog gd2 = new GenericDialog("Model parameters for rigid model 3d");
gd2.addChoice("1st_Rotation_axis", axes, axes[defaultAxis1]);
gd2.addSlider("1st_Rotation_angle", 0, 359, defaultDegrees1);
gd2.addChoice("2nd_Rotation_axis", axes, axes[defaultAxis2]);
gd2.addSlider("2nd_Rotation_angle", 0, 359, defaultDegrees2);
gd2.addChoice("3rd_Rotation_axis", axes, axes[defaultAxis3]);
gd2.addSlider("3rd_Rotation_angle", 0, 359, defaultDegrees3);
gd2.showDialog();
if (gd2.wasCanceled()) return null;
defaultAxis1 = gd2.getNextChoiceIndex();
defaultDegrees1 = gd2.getNextNumber();
defaultAxis2 = gd2.getNextChoiceIndex();
defaultDegrees2 = gd2.getNextNumber();
defaultAxis3 = gd2.getNextChoiceIndex();
defaultDegrees3 = gd2.getNextNumber();
final Transform3D t3 = new Transform3D();
final Transform3D t2 = new Transform3D();
final Transform3D t1 = new Transform3D();
if (defaultAxis1 == 0) t1.rotX(Math.toRadians(defaultDegrees1));
else if (defaultAxis1 == 1) t1.rotY(Math.toRadians(defaultDegrees1));
else t1.rotZ(Math.toRadians(defaultDegrees1));
if (defaultAxis2 == 0) t2.rotX(Math.toRadians(defaultDegrees2));
else if (defaultAxis2 == 1) t2.rotY(Math.toRadians(defaultDegrees2));
else t2.rotZ(Math.toRadians(defaultDegrees2));
if (defaultAxis3 == 0) t3.rotX(Math.toRadians(defaultDegrees3));
else if (defaultAxis3 == 1) t3.rotY(Math.toRadians(defaultDegrees3));
else t3.rotZ(Math.toRadians(defaultDegrees3));
final AffineModel3D m1 = TransformUtils.getAffineModel3D(t1);
final AffineModel3D m2 = TransformUtils.getAffineModel3D(t2);
final AffineModel3D m3 = TransformUtils.getAffineModel3D(t3);
m1.preConcatenate(m2);
m1.preConcatenate(m3);
// set the model as initial guess
params.initialModel = m1;
} else if (AffineModel3D.class.isInstance(params.model)
|| SimilarityModel3D.class.isInstance(params.model)) {
final GenericDialog gd2 = new GenericDialog("Model parameters for affine model 3d");
gd2.addMessage("");
gd2.addMessage("m00 m01 m02 m03");
gd2.addMessage("m10 m11 m12 m13");
gd2.addMessage("m20 m21 m22 m23");
gd2.addMessage("");
gd2.addMessage("Please provide 3d affine in this form (any brackets will be ignored):");
gd2.addMessage("m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23");
gd2.addStringField(
"Affine_matrix",
m00 + ", " + m01 + ", " + m02 + ", " + m03 + ", " + m10 + ", " + m11 + ", " + m12 + ", "
+ m13 + ", " + m20 + ", " + m21 + ", " + m22 + ", " + m23,
80);
gd2.showDialog();
if (gd2.wasCanceled()) return null;
String entry =
Apply_External_Transformation.removeSequences(
gd2.getNextString().trim(),
new String[] {
"(", ")", "{", "}", "[", "]", "<", ">", ":", "m00", "m01", "m02", "m03", "m10",
"m11", "m12", "m13", "m20", "m21", "m22", "m23", " "
});
final String[] numbers = entry.split(",");
if (numbers.length != 12) {
IJ.log(
"Affine matrix has to have 12 entries: m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23");
IJ.log("This one has only " + numbers.length + " after trimming: " + entry);
return null;
}
m00 = Double.parseDouble(numbers[0]);
m01 = Double.parseDouble(numbers[1]);
m02 = Double.parseDouble(numbers[2]);
m03 = Double.parseDouble(numbers[3]);
m10 = Double.parseDouble(numbers[4]);
m11 = Double.parseDouble(numbers[5]);
m12 = Double.parseDouble(numbers[6]);
m13 = Double.parseDouble(numbers[7]);
m20 = Double.parseDouble(numbers[8]);
m21 = Double.parseDouble(numbers[9]);
m22 = Double.parseDouble(numbers[10]);
m23 = Double.parseDouble(numbers[11]);
// set the model as initial guess
final AffineModel3D model = new AffineModel3D();
model.set(
(float) m00,
(float) m01,
(float) m02,
(float) m03,
(float) m10,
(float) m11,
(float) m12,
(float) m13,
(float) m20,
(float) m21,
(float) m22,
(float) m23);
params.initialModel = model;
} else if (AffineModel2D.class.isInstance(params.model)) {
final GenericDialog gd2 = new GenericDialog("Model parameters for affine model 2d");
gd2.addMessage("");
gd2.addMessage("m00 m01 m02");
gd2.addMessage("m10 m11 m12");
gd2.addMessage("");
gd2.addMessage("Please provide 2d affine in this form (any brackets will be ignored):");
gd2.addMessage("m00, m01, m02, m10, m11, m12");
gd2.addStringField(
"Affine_matrix",
m00 + ", " + m01 + ", " + m02 + ", " + m10 + ", " + m11 + ", " + m12,
60);
gd2.showDialog();
if (gd2.wasCanceled()) return null;
String entry =
Apply_External_Transformation.removeSequences(
gd2.getNextString().trim(),
new String[] {
"(", ")", "{", "}", "[", "]", "<", ">", ":", "m00", "m01", "m02", "m03", "m10",
"m11", "m12", "m13", "m20", "m21", "m22", "m23", " "
});
final String[] numbers = entry.split(",");
if (numbers.length != 6) {
IJ.log("Affine matrix has to have 6 entries: m00, m01, m02, m10, m11, m12");
IJ.log("This one has only " + numbers.length + " after trimming: " + entry);
return null;
}
m00 = Double.parseDouble(numbers[0]);
m01 = Double.parseDouble(numbers[1]);
m02 = Double.parseDouble(numbers[2]);
m10 = Double.parseDouble(numbers[3]);
m11 = Double.parseDouble(numbers[4]);
m12 = Double.parseDouble(numbers[5]);
// set the model as initial guess
final AffineModel2D model = new AffineModel2D();
model.set((float) m00, (float) m01, (float) m02, (float) m10, (float) m11, (float) m12);
params.initialModel = model;
} else if (HomographyModel2D.class.isInstance(params.model)) {
final GenericDialog gd2 = new GenericDialog("Model parameters for homography model 2d");
gd2.addMessage("");
gd2.addMessage("m00 m01 m02");
gd2.addMessage("m10 m11 m12");
gd2.addMessage("m20 m21 m22");
gd2.addMessage("");
gd2.addMessage("Please provide 2d homography in this form (any brackets will be ignored):");
gd2.addMessage("m00, m01, m02, m10, m11, m12, m20, m21, m22");
gd2.addStringField(
"Homography_matrix",
m00 + ", " + m01 + ", " + m02 + ", " + m10 + ", " + m11 + ", " + m12,
70);
gd2.showDialog();
if (gd2.wasCanceled()) return null;
String entry =
Apply_External_Transformation.removeSequences(
gd2.getNextString().trim(),
new String[] {
"(", ")", "{", "}", "[", "]", "<", ">", ":", "m00", "m01", "m02", "m03", "m10",
"m11", "m12", "m13", "m20", "m21", "m22", "m23", " "
});
final String[] numbers = entry.split(",");
if (numbers.length != 9) {
IJ.log(
"Homography matrix has to have 9 entries: m00, m01, m02, m10, m11, m12, m20, m21, m22");
IJ.log("This one has only " + numbers.length + " after trimming: " + entry);
return null;
}
m00 = Double.parseDouble(numbers[0]);
m01 = Double.parseDouble(numbers[1]);
m02 = Double.parseDouble(numbers[2]);
m10 = Double.parseDouble(numbers[3]);
m11 = Double.parseDouble(numbers[4]);
m12 = Double.parseDouble(numbers[5]);
m20 = Double.parseDouble(numbers[6]);
m21 = Double.parseDouble(numbers[7]);
m22 = Double.parseDouble(numbers[8]);
// set the model as initial guess
final HomographyModel2D model = new HomographyModel2D();
model.set(
(float) m00,
(float) m01,
(float) m02,
(float) m10,
(float) m11,
(float) m12,
(float) m20,
(float) m21,
(float) m22);
params.initialModel = model;
} else if (RigidModel2D.class.isInstance(params.model)) {
final GenericDialog gd2 = new GenericDialog("Model parameters for rigid model 2d");
gd2.addSlider("Rotation_angle", 0, 359, defaultDegrees1);
gd2.showDialog();
if (gd2.wasCanceled()) return null;
defaultDegrees1 = gd2.getNextNumber();
// set the model as initial guess
final RigidModel2D model = new RigidModel2D();
model.set((float) Math.toRadians(defaultDegrees1), 0, 0);
params.initialModel = model;
} else if (SimilarityModel2D.class.isInstance(params.model)) {
final GenericDialog gd2 = new GenericDialog("Model parameters for rigid model 2d");
gd2.addSlider("Rotation_angle", 0, 359, defaultDegrees1);
gd2.addNumericField("Scaling", defaultScale, 2);
gd2.showDialog();
if (gd2.wasCanceled()) return null;
defaultDegrees1 = gd2.getNextNumber();
defaultScale = gd2.getNextNumber();
// set the model as initial guess
final SimilarityModel2D model = new SimilarityModel2D();
model.set(
(float) (defaultScale * Math.cos(Math.toRadians(defaultDegrees1))),
(float) (defaultScale * Math.sin(Math.toRadians(defaultDegrees1))),
0,
0);
params.initialModel = model;
} else {
IJ.log("Unfortunately this is not supported this model yet ... ");
IJ.log(params.model.getClass().toString());
return null;
}
}
if (localization == 2
&& !Descriptor_based_series_registration.getGaussianParameters(dimensionality, params))
return null;
return params;
}