Image correlation

Question

I have two images from motor scan, Image1 is shifted by MxN pixels from Image2. How can I find the shift between Image1 and Image2 ?

Image -1 Image -2

If we compare the shift between the images in terms of {X,Y} I will be able to tell how many steps of the motor scan corresponds to the pixel shift on the image array sensor.

Answer 1

There are many different image registration algorithms, all with different advantages and disadvantages. But I usually try the simplest choice first: I simply pass the two images to ImageCorrelate.

img1 = Import["https://i.stack.imgur.com/laZeT.png"];
img2 = Import["https://i.stack.imgur.com/LAHyF.png"];
corr = ImageAdjust[ImageCorrelate[img1, img2, EuclideanDistance]]

Intuitively, ImageCorrelate shifts img2 by every possible offset, calculates the difference with img1 with that offset, and stores the difference in the output image. So the pixel location with the lowest value in this image corresponds to the offset that minimizes the difference:

minOffset = PixelValuePositions[corr, Min[ImageData[corr]]][[1]] - 
   ImageDimensions[img1]/2;
FlipView[{ImageTransformation[img1, TranslationTransform[minOffset ], 
   PlotRange -> Full], img2}]

If you look at the result of ImageCorrelate, you can see that there's one global minimum. That's the offset where the "U" shapes in the two images are aligned. There's a second local minimum left of it; That's probably where the left "leg" of one U is aligned with the right leg of the other. The shape of the correlation function around the global minimum and the relative correlation values at the local minima give a qualitative impression of the accuracy and reliability of the alignment.

EuclideanDistance compares brightness values. So the different overall brightness in the two images can "move" the minimum. If you don't want that, you can apply a filter to the images that basically removes the low-frequency background lighting changes:

filter = LaplacianGaussianFilter[#, 25] &;
corr = ImageAdjust[
  ImageCorrelate[filter[img1], filter[img2], CosineDistance]]

(where 25 is roughly the width of the U-shape. Details smaller than that and low-frequency changes larger than that are removed by the LoG filter.)

Answer 2

I think ImageCorrespondingPoints is a good use of what you need. You can improve the results by more preprocessing steps. You can also check ImageFeatureTrack and FindGeometricTransform.

img1 = Import["https://i.stack.imgur.com/laZeT.png"];
img2 = Import["https://i.stack.imgur.com/LAHyF.png"];
(*preprocess images*)
images = {DeleteSmallComponents@Binarize[img1, .2], 
  DeleteSmallComponents@Binarize[img2, .2]};
(*find matching points*)
matches = 
 ImageCorrespondingPoints[images[[1]], images[[2]], 
  "Transformation" -> "Translation"];
(*Show points on images*)
MapThread[
 Show[#1, Graphics[{Cyan, 
     MapIndexed[Inset[#2[[1]], #1] & , #2]}]] &, {images, matches}]

{{{351.461, 337.156}}, {{501.884, 358.838}}}

Edit 1

You can also use the option "Transformation" -> "Similarity" which adjusts translation, rotation, and scaling of the images.

images = {DeleteSmallComponents@Binarize[FillingTransform@img1, .2], 
   DeleteSmallComponents@Binarize[FillingTransform@img2, .2]};
matches = 
 ImageCorrespondingPoints[images[[1]], images[[2]], 
  "Transformation" -> "Similarity"]
Show[ImageAssemble[images], 
 Graphics[{Red, PointSize[.02], 
   MapThread[
    If[#2 === Missing[], {Cyan, Point[#1]}, 
      Arrow[{#1, #2 + {ImageDimensions[img1][[1]], 0}}]] &, 
    matches]}]]

{{{353.43, 359.493}, {377.258, 359.066}}, {{503.413, 375.665}, {523.788, 374.315}}}

Answer 3

Here you have the transformation function for the images:

{i1, i2} = Import@# & /@ {"https://i.stack.imgur.com/laZeT.png", 
                          "https://i.stack.imgur.com/LAHyF.png"};  
ch = ChanVeseBinarize /@ {i1, i2};
dsc = FillingTransform /@ (DeleteSmallComponents[#, 5000] & /@ ch);
pts = ImageCorrespondingPoints[dsc[[1]], dsc[[2]]];
f   = FindGeometricTransform[pts[[1]], pts[[2]], "Transformation" -> "Translation", Method->"RANSAC"]
GraphicsGrid@{{i1, ImagePerspectiveTransformation[i2, f[[2]], DataRange -> Full]}}

The coefficients of the translation are:

{ {-146.587}, {-14.2423} }

Here you can see how the images overlap after the transformation (Thanks to Simon for the idea)

ColorCombine[{EdgeDetect[dsc[[1]]], 
              ImagePerspectiveTransformation[EdgeDetect[dsc[[2]]], f[[2]], 
              DataRange -> Full]}]

Answer 4

Another alternative is to use component measurements. But I don't think this will give very accurate results, because the two images are not so similar in many ways, and the images are hard to 'prepare', having a lot of noise. Anyway, it's good to show approaches that don't work so well... :)

{i1, i2} = 
 Erosion[DeleteSmallComponents[
     ChanVeseBinarize[#, TargetColor -> Gray]], 10] & /@ {image1, image2}
c1 = 1 /. ComponentMeasurements[i1, "MinimalBoundingBox"];
c2 = 1 /. ComponentMeasurements[i2, "MinimalBoundingBox"];

To see some results:

Show[
ImageCompose[image1, {image2, .5}],
 Graphics[{Opacity[0.5], White, Polygon[c1], Polygon[c2], Green, 
 Text[#, #] & /@ c1, Text[#, #] & /@ c2}]]

The best 'pair' of coordinates here are the rightmost corners, giving the translation from image1 to image2 as:

{150.42, 30.8978}

which sadly is only approximately close to Belisarius' result.