Features2dRegistrationResult =	greySignedFeaturesImg2dRegistration (inOriginImg2d,inTargetImg2d,inRegMotionModel2d)
Features2dRegistrationResult =	greySignedFeaturesImg2dRegistration (inOriginImg2d,inTargetImg2d,inScaleCandidates,inGradStdDev,inOptGradientGaussianCoverage,inCornerDetectionParams2d,inNbFeatures,inFeaturesDistX,inFeaturesDistY,inInterpolationPolicy,inSamplingBallInfo2d,inRegMotionModel2d,inCorrelationThreshold2d,inOptRegistrationEstimationConfig,outFeatures2dRegistrationResults)
Features2dRegistrationResult =	greySignedFeaturesImg2dRegistration (inOriginImg2d,inTargetImg2d)
Features2dRegistrationResult =	greySignedFeaturesImg2dRegistration (inOriginImg2d,inTargetImg2d,inGradStdDev,inNbFeatures,inFeaturesDist,outFeatures2dRegistrationResults)
Features2dRegistrationResult =	greySignedFeaturesImg2dRegistration (inOriginImg2d,inTargetImg2d,inScaleCandidates)
Features2dRegistrationResult =	greySignedFeaturesImg2dRegistration (inOriginImg2d,inTargetImg2d,inScaleCandidates,inGradStdDev,inNbFeatures,inFeaturesDist,outFeatures2dRegistrationResults)

Detailed Description

algorithm allowing registration of 2d images using features associated to grey signature

This algorithm allows to automatically compute motion transform linking two images. Given an origin image $InOriginImg2d$ and a target image $InTargetImg2d$ , this algorithm basically allows to automatically compute motion transform linking. We compute transformation allowing to link points of images with following formula :

$P_{target}=sR(\theta)P_{origin} + T(T_x, T_y)$

with :

a scale factor computed in similarity case (ie. ipsdk::imaproc::attr::eRegistrationMotionModel2d::eRMM2d_Similarity) and equal to 1 in rigid case (ie. ipsdk::imaproc::attr::eRegistrationMotionModel2d::eRMM2d_Rigid).
$R(\theta)$ a rotation matrix, see Rotations 2d.
a translation vector

The computed transformation can also be of form :

$\bar{P}_{target}=H \bar{P}_{origin}$

in case of homography motion model (ipsdk::imaproc::attr::eRegistrationMotionModel2d::eRMM2d_Homography) with :

$\bar{P}$ homogeneous coordinates associated to point
a 3x3 matrix

This algorithm is composed of three main phasis :

extraction of grey signed feature in origin image (see Extract grey signed features 2d)
extraction of grey signed feature in target image (see Extract grey signed features 2d)
computation of motion transform linking extracted grey signed features (see Registration of grey signed features 2d)

Extraction phasis can be controlled via following parameters : $InOptGradStdDev$ , $InOptGradientGaussianCoverage$ , $InOptCornerDetectionParams2d$ , $InOptNbFeatures$ , $InOptFeaturesDistX$ , $InOptFeaturesDistY$ , $InOptInterpolationPolicy$ and $InOptSamplingBallInfo2d$ (see Extract grey signed features 2d).

Motion transform computation phasis can be controlled via following parameters : $InOptRegMotionModel2d$ , $InOptCorrelationThreshold2d$ and $InOptRegistrationEstimationConfig$ . Note that in case where parameter is set to ipsdk::imaproc::attr::eRegistrationMotionModel2d::eRMM2d_Similarity or ipsdk::imaproc::attr::eRegistrationMotionModel2d::eRMM2d_Homography, algorithm will iterate on its three main phasis searching for best results adusting used scale for feature extraction (this phasis is not scale invariant see Extract grey signed features 2d). In this case an additional parameter $InOptScaleCandidates$ allows to defined candidates for tested scale factor.

Here is an example of usage of this algorithm in case of similarity transform computation :

In this case, we ask for 100 detected features. Given used distance between features, algorithm provided 100 detected features in first image and only 95 in second one. Given used correlation threshold (set to 0.95 in this case), only 27 made pairs are keeped (blue points stands for rejected data during pairing phasis).

This allows a robust computation of similarity transformation which detects 8 outliers in input collections (red points) leaving 19 inliers (green points linked between images).

On output algorithm estimates a root mean square of residuals equal to 1.38 pixels which grants a good estimation of transformation.

Here is a second example of usage of this algorithm in case of similarity transform computation :

In this case, we ask for 100 detected features. Given used distance between features, algorithm provided 100 detected features in first image and second images. Given used correlation threshold (set to 0.95 in this case), only 27 made pairs are keeped (blue points stands for rejected data during pairing phasis).

This allows a robust computation of similarity transformation which detects 2 outliers in input collections (red points) leaving 25 inliers (green points linked between images).

On output algorithm estimates a root mean square of residuals equal to 1.77 pixels which grants a good estimation of transformation.

Example of Python code :

Example imports

import PyIPSDK

import PyIPSDK.IPSDKIPLRegistration as registration

Code Example

    # opening of input images
    inImg1 = PyIPSDK.loadTiffImageFile(inputImgPath1)
    inImg2 = PyIPSDK.loadTiffImageFile(inputImgPath2)
    
    # computation of motion transform between images
    outRegistrationResult = registration.greySignedFeaturesImg2dRegistration(inImg1, inImg2)
    transformParams = outRegistrationResult.transform.params
    
    # print of results
    print("Registration results :")
    print("----------------------")
    print("Nb original features : " + str(outRegistrationResult.indicators.nbFeatures1))
    print("Nb target features : " + str(outRegistrationResult.indicators.nbFeatures2))
    print("Nb made pairs : " + str(outRegistrationResult.indicators.nbPairs))
    print("Robust estimation status :")
    print("--------------------------")
    print(outRegistrationResult.indicators.estimationResults.toString())
    print("Estimated motion transform :")
    print("----------------------------")
    print("Rotation (theta in radians) : " + str(transformParams[PyIPSDK.Rigid2d.eTP_Theta]))
    print("Translation : {" + str(transformParams[PyIPSDK.Rigid2d.eTP_Tx]) + ", " + str(transformParams[PyIPSDK.Rigid2d.eTP_Ty]) + "}")

Example of C++ code :

Example informations

Header file

#include <IPSDKIPL/IPSDKIPLRegistration/Processor/GreySignedFeaturesImg2dRegistration/GreySignedFeaturesImg2dRegistration.h>

Code Example

    // Load the input images
    ImagePtr pInImg1 = loadTiffImageFile(inImgFilePath1);
    ImagePtr pInImg2 = loadTiffImageFile(inImgFilePath2);
    // computation of motion transform between images
    Features2dRegistrationResultPtr pOutRegistrationResult = greySignedFeaturesImg2dRegistration(pInImg1, pInImg2);
    const RegistrationMotionTransform2d& outTransform = pOutRegistrationResult->getNode<Features2dRegistrationResult::Transform>();