Exemple #1
0
def testCircleToCMonomodalSyNEM(lambdaParam, maxOuterIter):
    fname0='data/circle.png'
    #fname0='data/C_trans.png'
    fname1='data/C.png'
    nib_moving=plt.imread(fname0)
    nib_fixed=plt.imread(fname1)
    moving=nib_moving[:,:,0]
    fixed=nib_fixed[:,:,1]
    moving=(moving-moving.min())/(moving.max() - moving.min())
    fixed=(fixed-fixed.min())/(fixed.max() - fixed.min())
    level=3
    maskMoving=moving>0
    maskFixed=fixed>0
    movingPyramid=[img for img in rcommon.pyramid_gaussian_2D(moving, level, maskMoving)]
    fixedPyramid=[img for img in rcommon.pyramid_gaussian_2D(fixed, level, maskFixed)]
    rcommon.plotOverlaidPyramids(movingPyramid, fixedPyramid)
    displacementList=[]
    displacement, dinv=estimateMonomodalSyNField2DMultiScale(movingPyramid, fixedPyramid, lambdaParam, maxOuterIter, 0,displacementList)
    inverse=np.array(tf.invert_vector_field(displacement, 0.75, 300, 1e-7))
    residual, stats=tf.compose_vector_fields(displacement, inverse)
    residual=np.array(residual)
    warpPyramid=[rcommon.warpImage(movingPyramid[i], displacementList[i]) for i in range(level+1)]
    rcommon.plotOverlaidPyramids(warpPyramid, fixedPyramid)
    rcommon.overlayImages(warpPyramid[0], fixedPyramid[0])
    rcommon.plotDiffeomorphism(displacement, inverse, residual, '',7)
def testEstimateMonomodalDiffeomorphicField2DMultiScale(lambdaParam):
    fname0='IBSR_01_to_02.nii.gz'
    fname1='data/t1/IBSR18/IBSR_02/IBSR_02_ana_strip.nii.gz'
    nib_moving = nib.load(fname0)
    nib_fixed= nib.load(fname1)
    moving=nib_moving.get_data().squeeze().astype(np.float64)
    fixed=nib_fixed.get_data().squeeze().astype(np.float64)
    moving=np.copy(moving, order='C')
    fixed=np.copy(fixed, order='C')
    sl=moving.shape
    sr=fixed.shape
    level=5
    #---sagital---
    moving=moving[sl[0]//2,:,:].copy()
    fixed=fixed[sr[0]//2,:,:].copy()
    #---coronal---
    #moving=moving[:,sl[1]//2,:].copy()
    #fixed=fixed[:,sr[1]//2,:].copy()
    #---axial---
    #moving=moving[:,:,sl[2]//2].copy()
    #fixed=fixed[:,:,sr[2]//2].copy()
    maskMoving=moving>0
    maskFixed=fixed>0
    movingPyramid=[img for img in rcommon.pyramid_gaussian_2D(moving, level, maskMoving)]
    fixedPyramid=[img for img in rcommon.pyramid_gaussian_2D(fixed, level, maskFixed)]
    rcommon.plotOverlaidPyramids(movingPyramid, fixedPyramid)
    displacementList=[]
    maxIter=200
    displacement, inverse=estimateMonomodalDiffeomorphicField2DMultiScale(movingPyramid, fixedPyramid, lambdaParam, maxIter, 0,displacementList)
    residual=tf.compose_vector_fields(displacement, inverse)
    warpPyramid=[rcommon.warpImage(movingPyramid[i], displacementList[i]) for i in range(level+1)]
    rcommon.plotOverlaidPyramids(warpPyramid, fixedPyramid)
    rcommon.overlayImages(warpPyramid[0], fixedPyramid[0])
    rcommon.plotDiffeomorphism(displacement, inverse, residual)
Exemple #3
0
def testCircleToCMonomodalSyNEM(lambdaParam, maxOuterIter):
    fname0 = 'data/circle.png'
    #fname0='data/C_trans.png'
    fname1 = 'data/C.png'
    nib_moving = plt.imread(fname0)
    nib_fixed = plt.imread(fname1)
    moving = nib_moving[:, :, 0]
    fixed = nib_fixed[:, :, 1]
    moving = (moving - moving.min()) / (moving.max() - moving.min())
    fixed = (fixed - fixed.min()) / (fixed.max() - fixed.min())
    level = 3
    maskMoving = moving > 0
    maskFixed = fixed > 0
    movingPyramid = [
        img for img in rcommon.pyramid_gaussian_2D(moving, level, maskMoving)
    ]
    fixedPyramid = [
        img for img in rcommon.pyramid_gaussian_2D(fixed, level, maskFixed)
    ]
    rcommon.plotOverlaidPyramids(movingPyramid, fixedPyramid)
    displacementList = []
    displacement, dinv = estimateMonomodalSyNField2DMultiScale(
        movingPyramid, fixedPyramid, lambdaParam, maxOuterIter, 0,
        displacementList)
    inverse = np.array(tf.invert_vector_field(displacement, 0.75, 300, 1e-7))
    residual, stats = tf.compose_vector_fields(displacement, inverse)
    residual = np.array(residual)
    warpPyramid = [
        rcommon.warpImage(movingPyramid[i], displacementList[i])
        for i in range(level + 1)
    ]
    rcommon.plotOverlaidPyramids(warpPyramid, fixedPyramid)
    rcommon.overlayImages(warpPyramid[0], fixedPyramid[0])
    rcommon.plotDiffeomorphism(displacement, inverse, residual, '', 7)
def estimateNewMonomodalDiffeomorphicField2D(moving, fixed, lambdaParam,
                                             maxOuterIter,
                                             previousDisplacement,
                                             previousDisplacementInverse):
    '''
    Warning: in the monomodal case, the parameter lambda must be significantly lower than in the multimodal case. Try lambdaParam=1,
    as opposed as lambdaParam=150 used in the multimodal case
    '''
    innerTolerance = 1e-4
    displacement = np.zeros(shape=(moving.shape) + (2, ), dtype=np.float64)
    gradientField = np.empty(shape=(moving.shape) + (2, ), dtype=np.float64)
    totalDisplacement = np.zeros(shape=(moving.shape) + (2, ),
                                 dtype=np.float64)
    totalDisplacementInverse = np.zeros(shape=(moving.shape) + (2, ),
                                        dtype=np.float64)
    if (previousDisplacement != None):
        totalDisplacement[...] = previousDisplacement
        totalDisplacementInverse[...] = previousDisplacementInverse
    outerIter = 0
    framesToCapture = 5
    maxOuterIter = framesToCapture * (
        (maxOuterIter + framesToCapture - 1) / framesToCapture)
    itersPerCapture = maxOuterIter / framesToCapture
    plt.figure()
    while (outerIter < maxOuterIter):
        outerIter += 1
        print 'Outer iter:', outerIter
        warped = np.array(tf.warp_image(moving, totalDisplacement, None))
        if ((outerIter == 1) or (outerIter % itersPerCapture == 0)):
            plt.subplot(1, framesToCapture + 1,
                        1 + outerIter / itersPerCapture)
            rcommon.overlayImages(warped, fixed, False)
            plt.title('Iter:' + str(outerIter - 1))
        sigmaField = np.ones_like(warped, dtype=np.float64)
        deltaField = fixed - warped
        gradientField[:, :, 0], gradientField[:, :, 1] = sp.gradient(warped)
        maxVariation = 1 + innerTolerance
        innerIter = 0
        displacement[...] = 0
        maxInnerIter = 200
        while ((maxVariation > innerTolerance) and (innerIter < maxInnerIter)):
            innerIter += 1
            maxVariation = tf.iterateDisplacementField2DCYTHON(
                deltaField, sigmaField, gradientField, lambdaParam,
                displacement, None)
        #maxDisplacement=np.max(np.abs(displacement))
        expd, invexpd = tf.vector_field_exponential(displacement, True)
        totalDisplacement, stats = tf.compose_vector_fields(
            displacement, totalDisplacement)
        #totalDisplacement=np.array(totalDisplacement)
        totalDisplacementInverse, stats = tf.compose_vector_fields(
            totalDisplacementInverse, invexpd)
        #totalDisplacementInverse=np.array(totalDisplacementInverse)
        #if(maxDisplacement<outerTolerance):
        #break
    print "Iter: ", innerIter, "Max variation:", maxVariation
    return totalDisplacement, totalDisplacementInverse
def testEstimateECQMMFMultimodalDeformationField2DMultiScale_synthetic():
    ##################parameters############
    maxGTDisplacement=2
    maxPyramidLevel=0
    lambdaMeasureField=0.02
    lambdaDisplacement=200
    mu=0.001
    maxOuterIter=20
    maxInnerIter=50
    tolerance=1e-5
    displacementList=[]
    #######################################3
    #fname0='IBSR_01_to_02.nii.gz'
    #fname1='data/t1/IBSR18/IBSR_02/IBSR_02_ana_strip.nii.gz'
    fnameMoving='data/t2/t2_icbm_normal_1mm_pn0_rf0_peeled.nii.gz'
    fnameFixed='data/t1/t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz'
    nib_moving = nib.load(fnameMoving)
    nib_fixed = nib.load(fnameFixed)
    moving=nib_moving.get_data().squeeze().astype(np.float64)
    fixed=nib_fixed.get_data().squeeze().astype(np.float64)
    sm=moving.shape
    sf=fixed.shape
    #---coronal---
    moving=moving[:,sm[1]//2,:].copy()
    fixed=fixed[:,sf[1]//2,:].copy()
    moving=(moving-moving.min())/(moving.max()-moving.min())
    fixed=(fixed-fixed.min())/(fixed.max()-fixed.min())
    #----apply synthetic deformation field to fixed image
    GT=rcommon.createDeformationField_type2(fixed.shape[0], fixed.shape[1], maxGTDisplacement)
    fixed=rcommon.warpImage(fixed,GT)
    maskMoving=moving>0
    maskFixed=fixed>0
    movingPyramid=[img for img in rcommon.pyramid_gaussian_2D(moving, maxPyramidLevel, maskMoving)]
    fixedPyramid=[img for img in rcommon.pyramid_gaussian_2D(fixed, maxPyramidLevel, maskFixed)]
    plt.figure()
    plt.subplot(1,2,1)
    plt.imshow(moving, cmap=plt.cm.gray)
    plt.title('Moving')
    plt.subplot(1,2,2)
    plt.imshow(fixed, cmap=plt.cm.gray)
    plt.title('Fixed')
    rcommon.plotOverlaidPyramids(movingPyramid, fixedPyramid)
    displacement=estimateECQMMFMultimodalDeformationField2DMultiScale(fixedPyramid, movingPyramid, lambdaMeasureField, lambdaDisplacement, mu, maxOuterIter, maxInnerIter, tolerance, 0,displacementList)
    warpedPyramid=[rcommon.warpImage(movingPyramid[i], displacementList[i]) for i in range(maxPyramidLevel+1)]
    rcommon.plotOverlaidPyramids(warpedPyramid, fixedPyramid)
    rcommon.overlayImages(warpedPyramid[0], fixedPyramid[0])
    rcommon.plotDeformationField(displacement)
    displacement[...,0]*=(maskMoving + maskFixed)
    displacement[...,1]*=(maskMoving + maskFixed)
    nrm=np.sqrt(displacement[...,0]**2 + displacement[...,1]**2)
    maxNorm=np.max(nrm)
    rcommon.plotDeformationField(displacement)
    residual=((displacement-GT))**2
    meanDisplacementError=np.sqrt(residual.sum(2)*(maskMoving + maskFixed)).mean()
    stdevDisplacementError=np.sqrt(residual.sum(2)*(maskMoving + maskFixed)).std()
    print 'Max global displacement: ', maxNorm
    print 'Mean displacement error: ', meanDisplacementError,'(',stdevDisplacementError,')'
def displayRegistrationResultDiff():
    fnameMoving = 'data/affineRegistered/templateT1ToIBSR01T1.nii.gz'
    fnameFixed = 'data/t1/IBSR18/IBSR_01/IBSR_01_ana_strip.nii.gz'
    nib_fixed = nib.load(fnameFixed)
    fixed = nib_fixed.get_data().squeeze()
    fixed = np.copy(fixed, order='C')
    nib_moving = nib.load(fnameMoving)
    moving = nib_moving.get_data().squeeze()
    moving = np.copy(moving, order='C')
    fnameDisplacement = 'displacement_templateT1ToIBSR01T1_diffMulti.npy'
    fnameWarped = 'warped_templateT1ToIBSR01T1_diffMulti.npy'
    displacement = np.load(fnameDisplacement)
    warped = np.load(fnameWarped)
    sh = moving.shape
    shown = warped
    f = rcommon.overlayImages(shown[:, sh[1] // 4, :], fixed[:, sh[1] // 4, :])
    f = rcommon.overlayImages(shown[:, sh[1] // 2, :], fixed[:, sh[1] // 2, :])
    f = rcommon.overlayImages(shown[:, 3 * sh[1] // 4, :],
                              fixed[:, 3 * sh[1] // 4, :])
    f = rcommon.overlayImages(shown[sh[0] // 4, :, :], fixed[sh[0] // 4, :, :])
    f = rcommon.overlayImages(shown[sh[0] // 2, :, :], fixed[sh[0] // 2, :, :])
    f = rcommon.overlayImages(shown[3 * sh[0] // 4, :, :],
                              fixed[3 * sh[0] // 4, :, :])
    f = rcommon.overlayImages(shown[:, :, sh[2] // 4], fixed[:, :, sh[2] // 4])
    f = rcommon.overlayImages(shown[:, :, sh[2] // 2], fixed[:, :, sh[2] // 2])
    f = rcommon.overlayImages(shown[:, :, 3 * sh[2] // 4],
                              fixed[:, :, 3 * sh[2] // 4])
    del f
    del displacement
def displayRegistrationResultDiff():
    fnameMoving='data/affineRegistered/templateT1ToIBSR01T1.nii.gz'
    fnameFixed='data/t1/IBSR18/IBSR_01/IBSR_01_ana_strip.nii.gz'
    nib_fixed = nib.load(fnameFixed)
    fixed=nib_fixed.get_data().squeeze()
    fixed=np.copy(fixed,order='C')
    nib_moving = nib.load(fnameMoving)
    moving=nib_moving.get_data().squeeze()
    moving=np.copy(moving, order='C')
    fnameDisplacement='displacement_templateT1ToIBSR01T1_diffMulti.npy'
    fnameWarped='warped_templateT1ToIBSR01T1_diffMulti.npy'
    displacement=np.load(fnameDisplacement)
    warped=np.load(fnameWarped)
    sh=moving.shape
    shown=warped
    f=rcommon.overlayImages(shown[:,sh[1]//4,:], fixed[:,sh[1]//4,:])
    f=rcommon.overlayImages(shown[:,sh[1]//2,:], fixed[:,sh[1]//2,:])
    f=rcommon.overlayImages(shown[:,3*sh[1]//4,:], fixed[:,3*sh[1]//4,:])
    f=rcommon.overlayImages(shown[sh[0]//4,:,:], fixed[sh[0]//4,:,:])
    f=rcommon.overlayImages(shown[sh[0]//2,:,:], fixed[sh[0]//2,:,:])
    f=rcommon.overlayImages(shown[3*sh[0]//4,:,:], fixed[3*sh[0]//4,:,:])
    f=rcommon.overlayImages(shown[:,:,sh[2]//4], fixed[:,:,sh[2]//4])
    f=rcommon.overlayImages(shown[:,:,sh[2]//2], fixed[:,:,sh[2]//2])
    f=rcommon.overlayImages(shown[:,:,3*sh[2]//4], fixed[:,:,3*sh[2]//4])
    del f
    del displacement
Exemple #8
0
def testEstimateMonomodalSyNField2DMultiScale(lambdaParam):
    fname0 = 'IBSR_01_to_02.nii.gz'
    fname1 = 'data/t1/IBSR18/IBSR_02/IBSR_02_ana_strip.nii.gz'
    nib_moving = nib.load(fname0)
    nib_fixed = nib.load(fname1)
    moving = nib_moving.get_data().squeeze()
    fixed = nib_fixed.get_data().squeeze()
    moving = np.copy(moving, order='C')
    fixed = np.copy(fixed, order='C')
    sl = moving.shape
    sr = fixed.shape
    level = 5
    #---sagital---
    moving = moving[sl[0] // 2, :, :].copy()
    fixed = fixed[sr[0] // 2, :, :].copy()
    #---coronal---
    #moving=moving[:,sl[1]//2,:].copy()
    #fixed=fixed[:,sr[1]//2,:].copy()
    #---axial---
    #moving=moving[:,:,sl[2]//2].copy()
    #fixed=fixed[:,:,sr[2]//2].copy()
    maskMoving = moving > 0
    maskFixed = fixed > 0
    movingPyramid = [
        img for img in rcommon.pyramid_gaussian_2D(moving, level, maskMoving)
    ]
    fixedPyramid = [
        img for img in rcommon.pyramid_gaussian_2D(fixed, level, maskFixed)
    ]
    rcommon.plotOverlaidPyramids(movingPyramid, fixedPyramid)
    displacementList = []
    maxIter = 200
    displacement = estimateMonomodalSyNField2DMultiScale(
        movingPyramid, fixedPyramid, lambdaParam, maxIter, 0, displacementList)
    warpPyramid = [
        rcommon.warpImage(movingPyramid[i], displacementList[i])
        for i in range(level + 1)
    ]
    rcommon.plotOverlaidPyramids(warpPyramid, fixedPyramid)
    rcommon.overlayImages(warpPyramid[0], fixedPyramid[0])
    rcommon.plotDeformationField(displacement)
    nrm = np.sqrt(displacement[..., 0]**2 + displacement[..., 1]**2)
    maxNorm = np.max(nrm)
    displacement[..., 0] *= (maskMoving + maskFixed)
    displacement[..., 1] *= (maskMoving + maskFixed)
    rcommon.plotDeformationField(displacement)
    #nrm=np.sqrt(displacement[...,0]**2 + displacement[...,1]**2)
    #plt.figure()
    #plt.imshow(nrm)
    print 'Max global displacement: ', maxNorm
def estimateNewMonomodalDiffeomorphicField2D(moving, fixed, lambdaParam, maxOuterIter, previousDisplacement, previousDisplacementInverse):
    '''
    Warning: in the monomodal case, the parameter lambda must be significantly lower than in the multimodal case. Try lambdaParam=1,
    as opposed as lambdaParam=150 used in the multimodal case
    '''
    innerTolerance=1e-4
    displacement     =np.zeros(shape=(moving.shape)+(2,), dtype=np.float64)
    gradientField    =np.empty(shape=(moving.shape)+(2,), dtype=np.float64)
    totalDisplacement=np.zeros(shape=(moving.shape)+(2,), dtype=np.float64)
    totalDisplacementInverse=np.zeros(shape=(moving.shape)+(2,), dtype=np.float64)
    if(previousDisplacement!=None):
        totalDisplacement[...]=previousDisplacement
        totalDisplacementInverse[...]=previousDisplacementInverse
    outerIter=0
    framesToCapture=5
    maxOuterIter=framesToCapture*((maxOuterIter+framesToCapture-1)/framesToCapture)
    itersPerCapture=maxOuterIter/framesToCapture
    plt.figure()
    while(outerIter<maxOuterIter):
        outerIter+=1
        print 'Outer iter:', outerIter
        warped=np.array(tf.warp_image(moving, totalDisplacement, None))
        if((outerIter==1) or (outerIter%itersPerCapture==0)):
            plt.subplot(1,framesToCapture+1, 1+outerIter/itersPerCapture)
            rcommon.overlayImages(warped, fixed, False)
            plt.title('Iter:'+str(outerIter-1))
        sigmaField=np.ones_like(warped, dtype=np.float64)
        deltaField=fixed-warped
        gradientField[:,:,0], gradientField[:,:,1]=sp.gradient(warped)
        maxVariation=1+innerTolerance
        innerIter=0
        displacement[...]=0
        maxInnerIter=200
        while((maxVariation>innerTolerance)and(innerIter<maxInnerIter)):
            innerIter+=1
            maxVariation=tf.iterateDisplacementField2DCYTHON(deltaField, sigmaField, gradientField,  lambdaParam, displacement, None)
        #maxDisplacement=np.max(np.abs(displacement))
        expd, invexpd=tf.vector_field_exponential(displacement, True)
        totalDisplacement, stats=tf.compose_vector_fields(displacement, totalDisplacement)
        #totalDisplacement=np.array(totalDisplacement)
        totalDisplacementInverse, stats=tf.compose_vector_fields(totalDisplacementInverse, invexpd)
        #totalDisplacementInverse=np.array(totalDisplacementInverse)
        #if(maxDisplacement<outerTolerance):
            #break
    print "Iter: ",innerIter, "Max variation:",maxVariation
    return totalDisplacement, totalDisplacementInverse
Exemple #10
0
def test_optimizer_monomodal_2d():
    r'''
    Classical Circle-To-C experiment for 2D Monomodal registration
    '''
    fname_moving = 'data/circle.png'
    fname_fixed = 'data/C.png'
    moving = plt.imread(fname_moving)
    fixed = plt.imread(fname_fixed)
    moving = moving[:, :, 0].astype(np.float64)
    fixed = fixed[:, :, 0].astype(np.float64)
    moving = np.copy(moving, order='C')
    fixed = np.copy(fixed, order='C')
    moving = (moving - moving.min()) / (moving.max() - moving.min())
    fixed = (fixed - fixed.min()) / (fixed.max() - fixed.min())
    ################Configure and run the Optimizer#####################
    max_iter = [i for i in [20, 100, 100, 100]]
    similarity_metric = SSDMetric(2, {
        'symmetric': True,
        'lambda': 5.0,
        'stepType': SSDMetric.GAUSS_SEIDEL_STEP
    })
    optimizer_parameters = {
        'max_iter': max_iter,
        'inversion_iter': 40,
        'inversion_tolerance': 1e-3,
        'report_status': True
    }
    update_rule = UpdateRule.Composition()
    registration_optimizer = SymmetricRegistrationOptimizer(
        fixed, moving, None, None, similarity_metric, update_rule,
        optimizer_parameters)
    registration_optimizer.optimize()
    #######################show results#################################
    displacement = registration_optimizer.get_forward()
    direct_inverse = registration_optimizer.get_backward()
    moving_to_fixed = np.array(tf.warp_image(moving, displacement))
    fixed_to_moving = np.array(tf.warp_image(fixed, direct_inverse))
    rcommon.overlayImages(moving_to_fixed, fixed, True)
    rcommon.overlayImages(fixed_to_moving, moving, True)
    direct_residual, stats = tf.compose_vector_fields(displacement,
                                                      direct_inverse)
    direct_residual = np.array(direct_residual)
    rcommon.plotDiffeomorphism(displacement, direct_inverse, direct_residual,
                               'inv-direct', 7)
def testEstimateMonomodalDiffeomorphicField2DMultiScale(lambdaParam):
    fname0 = 'IBSR_01_to_02.nii.gz'
    fname1 = 'data/t1/IBSR18/IBSR_02/IBSR_02_ana_strip.nii.gz'
    nib_moving = nib.load(fname0)
    nib_fixed = nib.load(fname1)
    moving = nib_moving.get_data().squeeze().astype(np.float64)
    fixed = nib_fixed.get_data().squeeze().astype(np.float64)
    moving = np.copy(moving, order='C')
    fixed = np.copy(fixed, order='C')
    sl = moving.shape
    sr = fixed.shape
    level = 5
    #---sagital---
    moving = moving[sl[0] // 2, :, :].copy()
    fixed = fixed[sr[0] // 2, :, :].copy()
    #---coronal---
    #moving=moving[:,sl[1]//2,:].copy()
    #fixed=fixed[:,sr[1]//2,:].copy()
    #---axial---
    #moving=moving[:,:,sl[2]//2].copy()
    #fixed=fixed[:,:,sr[2]//2].copy()
    maskMoving = moving > 0
    maskFixed = fixed > 0
    movingPyramid = [
        img for img in rcommon.pyramid_gaussian_2D(moving, level, maskMoving)
    ]
    fixedPyramid = [
        img for img in rcommon.pyramid_gaussian_2D(fixed, level, maskFixed)
    ]
    rcommon.plotOverlaidPyramids(movingPyramid, fixedPyramid)
    displacementList = []
    maxIter = 200
    displacement, inverse = estimateMonomodalDiffeomorphicField2DMultiScale(
        movingPyramid, fixedPyramid, lambdaParam, maxIter, 0, displacementList)
    residual = tf.compose_vector_fields(displacement, inverse)
    warpPyramid = [
        rcommon.warpImage(movingPyramid[i], displacementList[i])
        for i in range(level + 1)
    ]
    rcommon.plotOverlaidPyramids(warpPyramid, fixedPyramid)
    rcommon.overlayImages(warpPyramid[0], fixedPyramid[0])
    rcommon.plotDiffeomorphism(displacement, inverse, residual)
Exemple #12
0
def testEstimateMonomodalSyNField2DMultiScale(lambdaParam):
    fname0='IBSR_01_to_02.nii.gz'
    fname1='data/t1/IBSR18/IBSR_02/IBSR_02_ana_strip.nii.gz'
    nib_moving = nib.load(fname0)
    nib_fixed= nib.load(fname1)
    moving=nib_moving.get_data().squeeze()
    fixed=nib_fixed.get_data().squeeze()
    moving=np.copy(moving, order='C')
    fixed=np.copy(fixed, order='C')
    sl=moving.shape
    sr=fixed.shape
    level=5
    #---sagital---
    moving=moving[sl[0]//2,:,:].copy()
    fixed=fixed[sr[0]//2,:,:].copy()
    #---coronal---
    #moving=moving[:,sl[1]//2,:].copy()
    #fixed=fixed[:,sr[1]//2,:].copy()
    #---axial---
    #moving=moving[:,:,sl[2]//2].copy()
    #fixed=fixed[:,:,sr[2]//2].copy()
    maskMoving=moving>0
    maskFixed=fixed>0
    movingPyramid=[img for img in rcommon.pyramid_gaussian_2D(moving, level, maskMoving)]
    fixedPyramid=[img for img in rcommon.pyramid_gaussian_2D(fixed, level, maskFixed)]
    rcommon.plotOverlaidPyramids(movingPyramid, fixedPyramid)
    displacementList=[]
    maxIter=200
    displacement=estimateMonomodalSyNField2DMultiScale(movingPyramid, fixedPyramid, lambdaParam, maxIter, 0,displacementList)
    warpPyramid=[rcommon.warpImage(movingPyramid[i], displacementList[i]) for i in range(level+1)]
    rcommon.plotOverlaidPyramids(warpPyramid, fixedPyramid)
    rcommon.overlayImages(warpPyramid[0], fixedPyramid[0])
    rcommon.plotDeformationField(displacement)
    nrm=np.sqrt(displacement[...,0]**2 + displacement[...,1]**2)
    maxNorm=np.max(nrm)
    displacement[...,0]*=(maskMoving + maskFixed)
    displacement[...,1]*=(maskMoving + maskFixed)
    rcommon.plotDeformationField(displacement)
    #nrm=np.sqrt(displacement[...,0]**2 + displacement[...,1]**2)
    #plt.figure()
    #plt.imshow(nrm)
    print 'Max global displacement: ', maxNorm
def test_optimizer_monomodal_2d():
    r'''
    Classical Circle-To-C experiment for 2D Monomodal registration
    '''
    fname_moving = 'data/circle.png'
    fname_fixed = 'data/C.png'
    moving = plt.imread(fname_moving)
    fixed = plt.imread(fname_fixed)
    moving = moving[:, :, 0].astype(np.float64)
    fixed = fixed[:, :, 0].astype(np.float64)
    moving = np.copy(moving, order = 'C')
    fixed = np.copy(fixed, order = 'C')
    moving = (moving-moving.min())/(moving.max() - moving.min())
    fixed = (fixed-fixed.min())/(fixed.max() - fixed.min())
    ################Configure and run the Optimizer#####################
    max_iter = [i for i in [20, 100, 100, 100]]
    similarity_metric = SSDMetric(2, {'symmetric':True,
                                'lambda':5.0,
                                'stepType':SSDMetric.GAUSS_SEIDEL_STEP})
    optimizer_parameters = {
        'max_iter':max_iter,
        'inversion_iter':40,
        'inversion_tolerance':1e-3,
        'report_status':True}
    update_rule = UpdateRule.Composition()
    registration_optimizer = SymmetricRegistrationOptimizer(fixed, moving,
                                                         None, None,
                                                         similarity_metric,
                                                         update_rule, optimizer_parameters)
    registration_optimizer.optimize()
    #######################show results#################################
    displacement = registration_optimizer.get_forward()
    direct_inverse = registration_optimizer.get_backward()
    moving_to_fixed = np.array(tf.warp_image(moving, displacement))
    fixed_to_moving = np.array(tf.warp_image(fixed, direct_inverse))
    rcommon.overlayImages(moving_to_fixed, fixed, True)
    rcommon.overlayImages(fixed_to_moving, moving, True)
    direct_residual, stats = tf.compose_vector_fields(displacement,
                                                     direct_inverse)
    direct_residual = np.array(direct_residual)
    rcommon.plotDiffeomorphism(displacement, direct_inverse, direct_residual,
                               'inv-direct', 7)
def testIntersubjectRigidRegistration(fname0, fname1, level, outfname):
    nib_left = nib.load(fname0)
    nib_right = nib.load(fname1)
    left=nib_left.get_data().astype(np.double).squeeze()
    right=nib_right.get_data().astype(np.double).squeeze()
    leftPyramid=[i for i in rcommon.pyramid_gaussian_3D(left, level)]
    rightPyramid=[i for i in rcommon.pyramid_gaussian_3D(right, level)]
    plotSlicePyramidsAxial(leftPyramid, rightPyramid)
    print 'Estimation started.'
    beta=estimateRigidTransformationMultiscale3D(leftPyramid, rightPyramid)
    print 'Estimation finished.'
    rcommon.applyRigidTransformation3D(left, beta)
    sl=np.array(left.shape)//2
    sr=np.array(right.shape)//2
    rcommon.overlayImages(left[sl[0],:,:], leftPyramid[0][sr[0],:,:])
    rcommon.overlayImages(left[sl[0],:,:], right[sr[0],:,:])
    affine_transform=AffineTransform('ijk', ['aligned-z=I->S','aligned-y=P->A', 'aligned-x=L->R'], np.eye(4))
    left=Image(left, affine_transform)
    nipy.save_image(left,outfname)
    
    return beta
def test_optimizer_monomodal_2d():
    r"""
    Classical Circle-To-C experiment for 2D Monomodal registration
    """
    fname_moving = "data/circle.png"
    fname_fixed = "data/C.png"
    nib_moving = plt.imread(fname_moving)
    nib_fixed = plt.imread(fname_fixed)
    moving = nib_moving[:, :, 0].astype(np.float64)
    fixed = nib_fixed[:, :, 1].astype(np.float64)
    moving = np.copy(moving, order="C")
    fixed = np.copy(fixed, order="C")
    moving = (moving - moving.min()) / (moving.max() - moving.min())
    fixed = (fixed - fixed.min()) / (fixed.max() - fixed.min())
    ################Configure and run the Optimizer#####################
    max_iter = [i for i in [25, 100, 100, 100]]
    similarity_metric = SSDMetric({"lambda": 5.0, "max_inner_iter": 50, "step_type": SSDMetric.GAUSS_SEIDEL_STEP})
    update_rule = UpdateRule.Composition()
    optimizer_parameters = {
        "max_iter": max_iter,
        "inversion_iter": 40,
        "inversion_tolerance": 1e-3,
        "report_status": True,
    }
    registration_optimizer = AsymmetricRegistrationOptimizer(
        fixed, moving, None, None, similarity_metric, update_rule, optimizer_parameters
    )
    registration_optimizer.optimize()
    #######################show results#################################
    displacement = registration_optimizer.get_forward()
    direct_inverse = registration_optimizer.get_backward()
    moving_to_fixed = np.array(tf.warp_image(moving, displacement))
    fixed_to_moving = np.array(tf.warp_image(fixed, direct_inverse))
    rcommon.overlayImages(moving_to_fixed, fixed, True)
    rcommon.overlayImages(fixed_to_moving, moving, True)
    direct_residual, stats = tf.compose_vector_fields(displacement, direct_inverse)
    direct_residual = np.array(direct_residual)
    rcommon.plotDiffeomorphism(displacement, direct_inverse, direct_residual, "inv-direct", 7)
def testIntersubjectRigidRegistration(fname0, fname1, level, outfname):
    nib_left = nib.load(fname0)
    nib_right = nib.load(fname1)
    left = nib_left.get_data().astype(np.double).squeeze()
    right = nib_right.get_data().astype(np.double).squeeze()
    leftPyramid = [i for i in rcommon.pyramid_gaussian_3D(left, level)]
    rightPyramid = [i for i in rcommon.pyramid_gaussian_3D(right, level)]
    plotSlicePyramidsAxial(leftPyramid, rightPyramid)
    print 'Estimation started.'
    beta = estimateRigidTransformationMultiscale3D(leftPyramid, rightPyramid)
    print 'Estimation finished.'
    rcommon.applyRigidTransformation3D(left, beta)
    sl = np.array(left.shape) // 2
    sr = np.array(right.shape) // 2
    rcommon.overlayImages(left[sl[0], :, :], leftPyramid[0][sr[0], :, :])
    rcommon.overlayImages(left[sl[0], :, :], right[sr[0], :, :])
    affine_transform = AffineTransform(
        'ijk', ['aligned-z=I->S', 'aligned-y=P->A', 'aligned-x=L->R'],
        np.eye(4))
    left = Image(left, affine_transform)
    nipy.save_image(left, outfname)

    return beta
Exemple #17
0
 def report_status(self):
     r'''
     Shows the overlaid input images
     '''
     if self.dim == 2:
         plt.figure()
         rcommon.overlayImages(self.movingq_means_field,
                               self.fixedq_means_field, False)
     else:
         fixed = self.fixed_image
         moving = self.moving_image
         shape_fixed = fixed.shape
         rcommon.overlayImages(moving[:, shape_fixed[1]//2, :],
                               fixed[:, shape_fixed[1]//2, :])
         rcommon.overlayImages(moving[shape_fixed[0]//2, :, :],
                               fixed[shape_fixed[0]//2, :, :])
         rcommon.overlayImages(moving[:, :, shape_fixed[2]//2],
                               fixed[:, :, shape_fixed[2]//2])
Exemple #18
0
 def report_status(self):
     r'''
     Shows the overlaid input images
     '''
     if self.dim == 2:
         plt.figure()
         rcommon.overlayImages(self.movingq_means_field,
                               self.fixedq_means_field, False)
     else:
         fixed = self.fixed_image
         moving = self.moving_image
         shape_fixed = fixed.shape
         rcommon.overlayImages(moving[:, shape_fixed[1] // 2, :],
                               fixed[:, shape_fixed[1] // 2, :])
         rcommon.overlayImages(moving[shape_fixed[0] // 2, :, :],
                               fixed[shape_fixed[0] // 2, :, :])
         rcommon.overlayImages(moving[:, :, shape_fixed[2] // 2],
                               fixed[:, :, shape_fixed[2] // 2])
Exemple #19
0
def estimateNewMonomodalSyNField2D(moving, fixed, fWarp, fInv, mWarp, mInv,
                                   lambdaParam, maxOuterIter):
    '''
    Warning: in the monomodal case, the parameter lambda must be significantly lower than in the multimodal case. Try lambdaParam=1,
    as opposed as lambdaParam=150 used in the multimodal case
    '''
    innerTolerance = 1e-4
    outerTolerance = 1e-3

    if (mWarp != None):
        totalM = mWarp
        totalMInv = mInv
    else:
        totalM = np.zeros(shape=(fixed.shape) + (2, ), dtype=np.float64)
        totalMInv = np.zeros(shape=(fixed.shape) + (2, ), dtype=np.float64)
    if (fWarp != None):
        totalF = fWarp
        totalFInv = fInv
    else:
        totalF = np.zeros(shape=(moving.shape) + (2, ), dtype=np.float64)
        totalFInv = np.zeros(shape=(moving.shape) + (2, ), dtype=np.float64)
    outerIter = 0
    framesToCapture = 5
    maxOuterIter = framesToCapture * (
        (maxOuterIter + framesToCapture - 1) / framesToCapture)
    itersPerCapture = maxOuterIter / framesToCapture
    plt.figure()
    while (outerIter < maxOuterIter):
        outerIter += 1
        print 'Outer iter:', outerIter
        wmoving = np.array(tf.warp_image(moving, totalMInv))
        wfixed = np.array(tf.warp_image(fixed, totalFInv))
        if ((outerIter == 1) or (outerIter % itersPerCapture == 0)):
            plt.subplot(1, framesToCapture + 1,
                        1 + outerIter / itersPerCapture)
            rcommon.overlayImages(wmoving, wfixed, False)
            plt.title('Iter:' + str(outerIter - 1))
        #Compute forward update
        sigmaField = np.ones_like(wmoving, dtype=np.float64)
        deltaField = wfixed - wmoving
        movingGradient = np.empty(shape=(wmoving.shape) + (2, ),
                                  dtype=np.float64)
        movingGradient[:, :, 0], movingGradient[:, :, 1] = sp.gradient(wmoving)
        maxVariation = 1 + innerTolerance
        innerIter = 0
        fw = np.zeros(shape=(fixed.shape) + (2, ), dtype=np.float64)
        maxInnerIter = 1000
        while ((maxVariation > innerTolerance) and (innerIter < maxInnerIter)):
            innerIter += 1
            maxVariation = tf.iterateDisplacementField2DCYTHON(
                deltaField, sigmaField, movingGradient, lambdaParam, fw, None)
        #fw*=0.5
        totalF, stats = tf.compose_vector_fields(fw, totalF)
        totalF = np.array(totalF)
        meanDispF = np.mean(np.abs(fw))
        #Compute backward field
        sigmaField = np.ones_like(wfixed, dtype=np.float64)
        deltaField = wmoving - wfixed
        fixedGradient = np.empty(shape=(wfixed.shape) + (2, ),
                                 dtype=np.float64)
        fixedGradient[:, :, 0], fixedGradient[:, :, 1] = sp.gradient(wfixed)
        maxVariation = 1 + innerTolerance
        innerIter = 0
        mw = np.zeros(shape=(fixed.shape) + (2, ), dtype=np.float64)
        maxInnerIter = 1000
        while ((maxVariation > innerTolerance) and (innerIter < maxInnerIter)):
            innerIter += 1
            maxVariation = tf.iterateDisplacementField2DCYTHON(
                deltaField, sigmaField, fixedGradient, lambdaParam, mw, None)
        #mw*=0.5
        totalM, stats = tf.compose_vector_fields(mw, totalM)
        totalM = np.array(totalM)
        meanDispM = np.mean(np.abs(mw))
        totalFInv = np.array(
            tf.invert_vector_field_fixed_point(totalF, None, 20, 1e-3, None))
        totalMInv = np.array(
            tf.invert_vector_field_fixed_point(totalM, None, 20, 1e-3, None))
        totalF = np.array(
            tf.invert_vector_field_fixed_point(totalFInv, None, 20, 1e-3,
                                               None))
        totalM = np.array(
            tf.invert_vector_field_fixed_point(totalMInv, None, 20, 1e-3,
                                               None))
        #        totalFInv=np.array(tf.invert_vector_field(totalF, 0.75, 100, 1e-6))
        #        totalMInv=np.array(tf.invert_vector_field(totalM, 0.75, 100, 1e-6))
        #        totalF=np.array(tf.invert_vector_field(totalFInv, 0.75, 100, 1e-6))
        #        totalM=np.array(tf.invert_vector_field(totalMInv, 0.75, 100, 1e-6))
        if (meanDispM + meanDispF < 2 * outerTolerance):
            break
    print "Iter: ", innerIter, "Mean lateral displacement:", 0.5 * (
        meanDispM + meanDispF), "Max variation:", maxVariation
    return totalF, totalFInv, totalM, totalMInv
def test_optimizer_multimodal_2d(lambda_param):
    r'''
    Registers one of the mid-slices (axial, coronal or sagital) of each input
    volume (the volumes are expected to be from diferent modalities and
    should already be affine-registered, for example Brainweb t1 vs t2)
    '''
    fname_moving = 'data/t2/IBSR_t2template_to_01.nii.gz'
    fname_fixed = 'data/t1/IBSR_template_to_01.nii.gz'
#    fnameMoving = 'data/circle.png'
#    fnameFixed = 'data/C.png'
    nifti = True
    if nifti:
        nib_moving = nib.load(fname_moving)
        nib_fixed = nib.load(fname_fixed)
        moving = nib_moving.get_data().squeeze().astype(np.float64)
        fixed = nib_fixed.get_data().squeeze().astype(np.float64)
        moving = np.copy(moving, order = 'C')
        fixed = np.copy(fixed, order = 'C')
        shape_moving = moving.shape
        shape_fixed = fixed.shape
        moving = moving[:, shape_moving[1]//2, :].copy()
        fixed = fixed[:, shape_fixed[1]//2, :].copy()
        moving = (moving-moving.min())/(moving.max()-moving.min())
        fixed = (fixed-fixed.min())/(fixed.max()-fixed.min())
    else:
        nib_moving = plt.imread(fname_moving)
        nib_fixed = plt.imread(fname_fixed)
        moving = nib_moving[:, :, 0].astype(np.float64)
        fixed = nib_fixed[:, :, 1].astype(np.float64)
        moving = np.copy(moving, order = 'C')
        fixed = np.copy(fixed, order = 'C')
        moving = (moving-moving.min())/(moving.max() - moving.min())
        fixed = (fixed-fixed.min())/(fixed.max() - fixed.min())
    max_iter = [i for i in [25, 50, 100]]
    similarity_metric = EMMetric(2, {'symmetric':True,
                               'lambda':lambda_param,
                               'stepType':SSDMetric.GAUSS_SEIDEL_STEP,
                               'q_levels':256,
                               'max_inner_iter':20,
                               'use_double_gradient':True,
                               'max_step_length':0.25})
    optimizer_parameters = {
        'max_iter':max_iter,
        'inversion_iter':20,
        'inversion_tolerance':1e-3,
        'report_status':True}
    update_rule = UpdateRule.Composition()
    print('Generating synthetic field...')
    #----apply synthetic deformation field to fixed image
    ground_truth = rcommon.createDeformationField2D_type2(fixed.shape[0],
                                              fixed.shape[1], 8)
    warped_fixed = rcommon.warpImage(fixed, ground_truth)
    print('Registering T2 (template) to deformed T1 (template)...')
    plt.figure()
    rcommon.overlayImages(warped_fixed, moving, False)
    registration_optimizer = SymmetricRegistrationOptimizer(warped_fixed,
                                                            moving,
                                                            None, None,
                                                            similarity_metric,
                                                            update_rule,
                                                            optimizer_parameters)
    registration_optimizer.optimize()
    #######################show results#################################
    displacement = registration_optimizer.get_forward()
    direct_inverse = registration_optimizer.get_backward()
    moving_to_fixed = np.array(tf.warp_image(moving, displacement))
    fixed_to_moving = np.array(tf.warp_image(warped_fixed, direct_inverse))
    rcommon.overlayImages(moving_to_fixed, fixed_to_moving, True)
    direct_residual, stats = tf.compose_vector_fields(displacement,
                                                     direct_inverse)
    direct_residual = np.array(direct_residual)
    rcommon.plotDiffeomorphism(displacement, direct_inverse, direct_residual,
                               'inv-direct', 7)

    residual = ((displacement-ground_truth))**2
    mean_displacement_error = np.sqrt(residual.sum(2)*(warped_fixed>0)).mean()
    stdev_displacement_error = np.sqrt(residual.sum(2)*(warped_fixed>0)).std()
    print('Mean displacement error: %0.6f (%0.6f)'%
        (mean_displacement_error, stdev_displacement_error))
def runArcesExperiment(rootDir, lambdaParam, maxOuterIter):
    #---Load displacement field---
    dxName=rootDir+'Vx.dat'
    dyName=rootDir+'Vy.dat'
    dx=np.loadtxt(dxName)
    dy=np.loadtxt(dyName)
    GT_in=np.ndarray(shape=dx.shape+(2,), dtype=np.float64)
    GT_in[...,0]=dy
    GT_in[...,1]=dx
    GT, GTinv=tf.vector_field_exponential(GT_in)
    GTres=tf.compose_vector_fields(GT, GTinv)
    #---Load input images---
    fnameT1=rootDir+'t1.jpg'
    fnameT2=rootDir+'t2.jpg'
    fnamePD=rootDir+'pd.jpg'
    fnameMask=rootDir+'Mascara.bmp'
    t1=plt.imread(fnameT1)[...,0].astype(np.float64)
    t2=plt.imread(fnameT2)[...,0].astype(np.float64)
    pd=plt.imread(fnamePD)[...,0].astype(np.float64)
    t1=(t1-t1.min())/(t1.max()-t1.min())
    t2=(t2-t2.min())/(t2.max()-t2.min())
    pd=(pd-pd.min())/(pd.max()-pd.min())
    mask=plt.imread(fnameMask).astype(np.float64)
    fixed=t1
    moving=t2
    maskMoving=mask>0
    maskFixed=mask>0
    fixed*=mask
    moving*=mask
    plt.figure()
    plt.subplot(1,4,1)
    plt.imshow(t1, cmap=plt.cm.gray)
    plt.title('Input T1')
    plt.subplot(1,4,2)
    plt.imshow(t2, cmap=plt.cm.gray)
    plt.title('Input T2')
    plt.subplot(1,4,3)
    plt.imshow(pd, cmap=plt.cm.gray)
    plt.title('Input PD')
    plt.subplot(1,4,4)
    plt.imshow(mask, cmap=plt.cm.gray)
    plt.title('Input Mask')
    #-------------------------
    warpedFixed=rcommon.warpImage(fixed,GT)
    print 'Registering T2 (template) to deformed T1 (template)...'
    level=3
    movingPyramid=[img for img in rcommon.pyramid_gaussian_2D(moving, level, maskMoving)]
    fixedPyramid=[img for img in rcommon.pyramid_gaussian_2D(warpedFixed, level, maskFixed)]
    plt.figure()
    plt.subplot(1,2,1)
    plt.imshow(moving, cmap=plt.cm.gray)
    plt.title('Moving')
    plt.subplot(1,2,2)
    plt.imshow(warpedFixed, cmap=plt.cm.gray)
    plt.title('Fixed')
    rcommon.plotOverlaidPyramids(movingPyramid, fixedPyramid)
    displacementList=[]
    displacement, inverse=estimateMultimodalDiffeomorphicField2DMultiScale(movingPyramid, fixedPyramid, lambdaParam, maxOuterIter, 0, displacementList)
    residual=tf.compose_vector_fields(displacement, inverse)
    warpPyramid=[rcommon.warpImage(movingPyramid[i], displacementList[i]) for i in range(level+1)]
    rcommon.plotOverlaidPyramids(warpPyramid, fixedPyramid)
    rcommon.overlayImages(warpPyramid[0], fixedPyramid[0])
    displacement[...,0]*=(maskFixed)
    displacement[...,1]*=(maskFixed)
    #----plot deformations---
    rcommon.plotDiffeomorphism(GT, GTinv, GTres, 7)
    rcommon.plotDiffeomorphism(displacement, inverse, residual, 7)
    #----statistics---
    nrm=np.sqrt(displacement[...,0]**2 + displacement[...,1]**2)
    nrm*=maskFixed
    maxNorm=np.max(nrm)
    residual=((displacement-GT))**2
    meanDisplacementError=np.sqrt(residual.sum(2)*(maskFixed)).mean()
    stdevDisplacementError=np.sqrt(residual.sum(2)*(maskFixed)).std()
    print 'Max global displacement: ', maxNorm
    print 'Mean displacement error: ', meanDisplacementError,'(',stdevDisplacementError,')'
Exemple #22
0
def testEstimateECQMMFMultimodalDeformationField2DMultiScale_synthetic():
    ##################parameters############
    maxGTDisplacement = 2
    maxPyramidLevel = 0
    lambdaMeasureField = 0.02
    lambdaDisplacement = 200
    mu = 0.001
    maxOuterIter = 20
    maxInnerIter = 50
    tolerance = 1e-5
    displacementList = []
    #######################################3
    #fname0='IBSR_01_to_02.nii.gz'
    #fname1='data/t1/IBSR18/IBSR_02/IBSR_02_ana_strip.nii.gz'
    fnameMoving = 'data/t2/t2_icbm_normal_1mm_pn0_rf0_peeled.nii.gz'
    fnameFixed = 'data/t1/t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz'
    nib_moving = nib.load(fnameMoving)
    nib_fixed = nib.load(fnameFixed)
    moving = nib_moving.get_data().squeeze().astype(np.float64)
    fixed = nib_fixed.get_data().squeeze().astype(np.float64)
    sm = moving.shape
    sf = fixed.shape
    #---coronal---
    moving = moving[:, sm[1] // 2, :].copy()
    fixed = fixed[:, sf[1] // 2, :].copy()
    moving = (moving - moving.min()) / (moving.max() - moving.min())
    fixed = (fixed - fixed.min()) / (fixed.max() - fixed.min())
    #----apply synthetic deformation field to fixed image
    GT = rcommon.createDeformationField_type2(fixed.shape[0], fixed.shape[1],
                                              maxGTDisplacement)
    fixed = rcommon.warpImage(fixed, GT)
    maskMoving = moving > 0
    maskFixed = fixed > 0
    movingPyramid = [
        img for img in rcommon.pyramid_gaussian_2D(moving, maxPyramidLevel,
                                                   maskMoving)
    ]
    fixedPyramid = [
        img for img in rcommon.pyramid_gaussian_2D(fixed, maxPyramidLevel,
                                                   maskFixed)
    ]
    plt.figure()
    plt.subplot(1, 2, 1)
    plt.imshow(moving, cmap=plt.cm.gray)
    plt.title('Moving')
    plt.subplot(1, 2, 2)
    plt.imshow(fixed, cmap=plt.cm.gray)
    plt.title('Fixed')
    rcommon.plotOverlaidPyramids(movingPyramid, fixedPyramid)
    displacement = estimateECQMMFMultimodalDeformationField2DMultiScale(
        fixedPyramid, movingPyramid, lambdaMeasureField, lambdaDisplacement,
        mu, maxOuterIter, maxInnerIter, tolerance, 0, displacementList)
    warpedPyramid = [
        rcommon.warpImage(movingPyramid[i], displacementList[i])
        for i in range(maxPyramidLevel + 1)
    ]
    rcommon.plotOverlaidPyramids(warpedPyramid, fixedPyramid)
    rcommon.overlayImages(warpedPyramid[0], fixedPyramid[0])
    rcommon.plotDeformationField(displacement)
    displacement[..., 0] *= (maskMoving + maskFixed)
    displacement[..., 1] *= (maskMoving + maskFixed)
    nrm = np.sqrt(displacement[..., 0]**2 + displacement[..., 1]**2)
    maxNorm = np.max(nrm)
    rcommon.plotDeformationField(displacement)
    residual = ((displacement - GT))**2
    meanDisplacementError = np.sqrt(
        residual.sum(2) * (maskMoving + maskFixed)).mean()
    stdevDisplacementError = np.sqrt(
        residual.sum(2) * (maskMoving + maskFixed)).std()
    print 'Max global displacement: ', maxNorm
    print 'Mean displacement error: ', meanDisplacementError, '(', stdevDisplacementError, ')'
Exemple #23
0
def estimateNewMonomodalSyNField2D(moving, fixed, fWarp, fInv, mWarp, mInv, lambdaParam, maxOuterIter):
    '''
    Warning: in the monomodal case, the parameter lambda must be significantly lower than in the multimodal case. Try lambdaParam=1,
    as opposed as lambdaParam=150 used in the multimodal case
    '''
    innerTolerance=1e-4
    outerTolerance=1e-3
    
    if(mWarp!=None):
        totalM=mWarp
        totalMInv=mInv
    else:
        totalM=np.zeros(shape=(fixed.shape)+(2,), dtype=np.float64)
        totalMInv=np.zeros(shape=(fixed.shape)+(2,), dtype=np.float64)
    if(fWarp!=None):
        totalF=fWarp
        totalFInv=fInv
    else:
        totalF=np.zeros(shape=(moving.shape)+(2,), dtype=np.float64)
        totalFInv=np.zeros(shape=(moving.shape)+(2,), dtype=np.float64)
    outerIter=0
    framesToCapture=5
    maxOuterIter=framesToCapture*((maxOuterIter+framesToCapture-1)/framesToCapture)
    itersPerCapture=maxOuterIter/framesToCapture
    plt.figure()
    while(outerIter<maxOuterIter):
        outerIter+=1
        print 'Outer iter:', outerIter
        wmoving=np.array(tf.warp_image(moving, totalMInv))
        wfixed=np.array(tf.warp_image(fixed, totalFInv))
        if((outerIter==1) or (outerIter%itersPerCapture==0)):
            plt.subplot(1,framesToCapture+1, 1+outerIter/itersPerCapture)
            rcommon.overlayImages(wmoving, wfixed, False)
            plt.title('Iter:'+str(outerIter-1))
        #Compute forward update
        sigmaField=np.ones_like(wmoving, dtype=np.float64)
        deltaField=wfixed-wmoving
        movingGradient    =np.empty(shape=(wmoving.shape)+(2,), dtype=np.float64)
        movingGradient[:,:,0], movingGradient[:,:,1]=sp.gradient(wmoving)
        maxVariation=1+innerTolerance
        innerIter=0
        fw     =np.zeros(shape=(fixed.shape)+(2,), dtype=np.float64)
        maxInnerIter=1000
        while((maxVariation>innerTolerance)and(innerIter<maxInnerIter)):
            innerIter+=1
            maxVariation=tf.iterateDisplacementField2DCYTHON(deltaField, sigmaField, movingGradient,  lambdaParam, fw, None)
        #fw*=0.5
        totalF, stats=tf.compose_vector_fields(fw, totalF)
        totalF=np.array(totalF);
        meanDispF=np.mean(np.abs(fw))
        #Compute backward field
        sigmaField=np.ones_like(wfixed, dtype=np.float64)
        deltaField=wmoving-wfixed
        fixedGradient    =np.empty(shape=(wfixed.shape)+(2,), dtype=np.float64)
        fixedGradient[:,:,0], fixedGradient[:,:,1]=sp.gradient(wfixed)
        maxVariation=1+innerTolerance
        innerIter=0
        mw     =np.zeros(shape=(fixed.shape)+(2,), dtype=np.float64)
        maxInnerIter=1000
        while((maxVariation>innerTolerance)and(innerIter<maxInnerIter)):
            innerIter+=1
            maxVariation=tf.iterateDisplacementField2DCYTHON(deltaField, sigmaField, fixedGradient,  lambdaParam, mw, None)
        #mw*=0.5
        totalM, stats=tf.compose_vector_fields(mw, totalM)
        totalM=np.array(totalM);
        meanDispM=np.mean(np.abs(mw))
        totalFInv=np.array(tf.invert_vector_field_fixed_point(totalF, None, 20, 1e-3, None))
        totalMInv=np.array(tf.invert_vector_field_fixed_point(totalM, None, 20, 1e-3, None))
        totalF=np.array(tf.invert_vector_field_fixed_point(totalFInv, None, 20, 1e-3, None))
        totalM=np.array(tf.invert_vector_field_fixed_point(totalMInv, None, 20, 1e-3, None))
#        totalFInv=np.array(tf.invert_vector_field(totalF, 0.75, 100, 1e-6))
#        totalMInv=np.array(tf.invert_vector_field(totalM, 0.75, 100, 1e-6))
#        totalF=np.array(tf.invert_vector_field(totalFInv, 0.75, 100, 1e-6))
#        totalM=np.array(tf.invert_vector_field(totalMInv, 0.75, 100, 1e-6))
        if(meanDispM+meanDispF<2*outerTolerance):
            break
    print "Iter: ",innerIter, "Mean lateral displacement:", 0.5*(meanDispM+meanDispF), "Max variation:",maxVariation
    return totalF, totalFInv, totalM, totalMInv
Exemple #24
0
 def report_status(self):
     plt.figure()
     rcommon.overlayImages(self.moving_image, self.fixed_image, False)
 def report_status(self):
     plt.figure()
     rcommon.overlayImages(self.moving_image, self.fixed_image, False)
Exemple #26
0
def test_optimizer_multimodal_2d(lambda_param):
    r'''
    Registers one of the mid-slices (axial, coronal or sagital) of each input
    volume (the volumes are expected to be from diferent modalities and
    should already be affine-registered, for example Brainweb t1 vs t2)
    '''
    fname_moving = 'data/t2/IBSR_t2template_to_01.nii.gz'
    fname_fixed = 'data/t1/IBSR_template_to_01.nii.gz'
    #    fnameMoving = 'data/circle.png'
    #    fnameFixed = 'data/C.png'
    nifti = True
    if nifti:
        nib_moving = nib.load(fname_moving)
        nib_fixed = nib.load(fname_fixed)
        moving = nib_moving.get_data().squeeze().astype(np.float64)
        fixed = nib_fixed.get_data().squeeze().astype(np.float64)
        moving = np.copy(moving, order='C')
        fixed = np.copy(fixed, order='C')
        shape_moving = moving.shape
        shape_fixed = fixed.shape
        moving = moving[:, shape_moving[1] // 2, :].copy()
        fixed = fixed[:, shape_fixed[1] // 2, :].copy()
        moving = (moving - moving.min()) / (moving.max() - moving.min())
        fixed = (fixed - fixed.min()) / (fixed.max() - fixed.min())
    else:
        nib_moving = plt.imread(fname_moving)
        nib_fixed = plt.imread(fname_fixed)
        moving = nib_moving[:, :, 0].astype(np.float64)
        fixed = nib_fixed[:, :, 1].astype(np.float64)
        moving = np.copy(moving, order='C')
        fixed = np.copy(fixed, order='C')
        moving = (moving - moving.min()) / (moving.max() - moving.min())
        fixed = (fixed - fixed.min()) / (fixed.max() - fixed.min())
    max_iter = [i for i in [25, 50, 100]]
    similarity_metric = EMMetric(
        2, {
            'symmetric': True,
            'lambda': lambda_param,
            'stepType': SSDMetric.GAUSS_SEIDEL_STEP,
            'q_levels': 256,
            'max_inner_iter': 20,
            'use_double_gradient': True,
            'max_step_length': 0.25
        })
    optimizer_parameters = {
        'max_iter': max_iter,
        'inversion_iter': 20,
        'inversion_tolerance': 1e-3,
        'report_status': True
    }
    update_rule = UpdateRule.Composition()
    print('Generating synthetic field...')
    #----apply synthetic deformation field to fixed image
    ground_truth = rcommon.createDeformationField2D_type2(
        fixed.shape[0], fixed.shape[1], 8)
    warped_fixed = rcommon.warpImage(fixed, ground_truth)
    print('Registering T2 (template) to deformed T1 (template)...')
    plt.figure()
    rcommon.overlayImages(warped_fixed, moving, False)
    registration_optimizer = SymmetricRegistrationOptimizer(
        warped_fixed, moving, None, None, similarity_metric, update_rule,
        optimizer_parameters)
    registration_optimizer.optimize()
    #######################show results#################################
    displacement = registration_optimizer.get_forward()
    direct_inverse = registration_optimizer.get_backward()
    moving_to_fixed = np.array(tf.warp_image(moving, displacement))
    fixed_to_moving = np.array(tf.warp_image(warped_fixed, direct_inverse))
    rcommon.overlayImages(moving_to_fixed, fixed_to_moving, True)
    direct_residual, stats = tf.compose_vector_fields(displacement,
                                                      direct_inverse)
    direct_residual = np.array(direct_residual)
    rcommon.plotDiffeomorphism(displacement, direct_inverse, direct_residual,
                               'inv-direct', 7)

    residual = ((displacement - ground_truth))**2
    mean_displacement_error = np.sqrt(residual.sum(2) *
                                      (warped_fixed > 0)).mean()
    stdev_displacement_error = np.sqrt(residual.sum(2) *
                                       (warped_fixed > 0)).std()
    print('Mean displacement error: %0.6f (%0.6f)' %
          (mean_displacement_error, stdev_displacement_error))
def runArcesExperiment(rootDir, lambdaParam, maxOuterIter):
    #---Load displacement field---
    dxName = rootDir + 'Vx.dat'
    dyName = rootDir + 'Vy.dat'
    dx = np.loadtxt(dxName)
    dy = np.loadtxt(dyName)
    GT_in = np.ndarray(shape=dx.shape + (2, ), dtype=np.float64)
    GT_in[..., 0] = dy
    GT_in[..., 1] = dx
    GT, GTinv = tf.vector_field_exponential(GT_in)
    GTres = tf.compose_vector_fields(GT, GTinv)
    #---Load input images---
    fnameT1 = rootDir + 't1.jpg'
    fnameT2 = rootDir + 't2.jpg'
    fnamePD = rootDir + 'pd.jpg'
    fnameMask = rootDir + 'Mascara.bmp'
    t1 = plt.imread(fnameT1)[..., 0].astype(np.float64)
    t2 = plt.imread(fnameT2)[..., 0].astype(np.float64)
    pd = plt.imread(fnamePD)[..., 0].astype(np.float64)
    t1 = (t1 - t1.min()) / (t1.max() - t1.min())
    t2 = (t2 - t2.min()) / (t2.max() - t2.min())
    pd = (pd - pd.min()) / (pd.max() - pd.min())
    mask = plt.imread(fnameMask).astype(np.float64)
    fixed = t1
    moving = t2
    maskMoving = mask > 0
    maskFixed = mask > 0
    fixed *= mask
    moving *= mask
    plt.figure()
    plt.subplot(1, 4, 1)
    plt.imshow(t1, cmap=plt.cm.gray)
    plt.title('Input T1')
    plt.subplot(1, 4, 2)
    plt.imshow(t2, cmap=plt.cm.gray)
    plt.title('Input T2')
    plt.subplot(1, 4, 3)
    plt.imshow(pd, cmap=plt.cm.gray)
    plt.title('Input PD')
    plt.subplot(1, 4, 4)
    plt.imshow(mask, cmap=plt.cm.gray)
    plt.title('Input Mask')
    #-------------------------
    warpedFixed = rcommon.warpImage(fixed, GT)
    print 'Registering T2 (template) to deformed T1 (template)...'
    level = 3
    movingPyramid = [
        img for img in rcommon.pyramid_gaussian_2D(moving, level, maskMoving)
    ]
    fixedPyramid = [
        img
        for img in rcommon.pyramid_gaussian_2D(warpedFixed, level, maskFixed)
    ]
    plt.figure()
    plt.subplot(1, 2, 1)
    plt.imshow(moving, cmap=plt.cm.gray)
    plt.title('Moving')
    plt.subplot(1, 2, 2)
    plt.imshow(warpedFixed, cmap=plt.cm.gray)
    plt.title('Fixed')
    rcommon.plotOverlaidPyramids(movingPyramid, fixedPyramid)
    displacementList = []
    displacement, inverse = estimateMultimodalDiffeomorphicField2DMultiScale(
        movingPyramid, fixedPyramid, lambdaParam, maxOuterIter, 0,
        displacementList)
    residual = tf.compose_vector_fields(displacement, inverse)
    warpPyramid = [
        rcommon.warpImage(movingPyramid[i], displacementList[i])
        for i in range(level + 1)
    ]
    rcommon.plotOverlaidPyramids(warpPyramid, fixedPyramid)
    rcommon.overlayImages(warpPyramid[0], fixedPyramid[0])
    displacement[..., 0] *= (maskFixed)
    displacement[..., 1] *= (maskFixed)
    #----plot deformations---
    rcommon.plotDiffeomorphism(GT, GTinv, GTres, 7)
    rcommon.plotDiffeomorphism(displacement, inverse, residual, 7)
    #----statistics---
    nrm = np.sqrt(displacement[..., 0]**2 + displacement[..., 1]**2)
    nrm *= maskFixed
    maxNorm = np.max(nrm)
    residual = ((displacement - GT))**2
    meanDisplacementError = np.sqrt(residual.sum(2) * (maskFixed)).mean()
    stdevDisplacementError = np.sqrt(residual.sum(2) * (maskFixed)).std()
    print 'Max global displacement: ', maxNorm
    print 'Mean displacement error: ', meanDisplacementError, '(', stdevDisplacementError, ')'
def test_optimizer_multimodal_2d(lambda_param):
    r"""
    Registers one of the mid-slices (axial, coronal or sagital) of each input
    volume (the volumes are expected to be from diferent modalities and
    should already be affine-registered, for example Brainweb t1 vs t2)
    """
    fname_moving = "data/t2/IBSR_t2template_to_01.nii.gz"
    fname_fixed = "data/t1/IBSR_template_to_01.nii.gz"
    #    fname_moving = 'data/circle.png'
    #    fname_fixed = 'data/C.png'
    nifti = True
    if nifti:
        nib_moving = nib.load(fname_moving)
        nib_fixed = nib.load(fname_fixed)
        moving = nib_moving.get_data().squeeze().astype(np.float64)
        fixed = nib_fixed.get_data().squeeze().astype(np.float64)
        moving = np.copy(moving, order="C")
        fixed = np.copy(fixed, order="C")
        moving_shape = moving.shape
        fixed_shape = fixed.shape
        moving = moving[:, moving_shape[1] // 2, :].copy()
        fixed = fixed[:, fixed_shape[1] // 2, :].copy()
        #        moving = histeq(moving)
        #        fixed = histeq(fixed)
        moving = (moving - moving.min()) / (moving.max() - moving.min())
        fixed = (fixed - fixed.min()) / (fixed.max() - fixed.min())
    else:
        nib_moving = plt.imread(fname_moving)
        nib_fixed = plt.imread(fname_fixed)
        moving = nib_moving[:, :, 0].astype(np.float64)
        fixed = nib_fixed[:, :, 1].astype(np.float64)
        moving = np.copy(moving, order="C")
        fixed = np.copy(fixed, order="C")
        moving = (moving - moving.min()) / (moving.max() - moving.min())
        fixed = (fixed - fixed.min()) / (fixed.max() - fixed.min())
    # max_iter = [i for i in [25,50,100,100]]
    max_iter = [i for i in [25, 50, 100]]
    similarity_metric = EMMetric(
        {
            "symmetric": True,
            "lambda": lambda_param,
            "step_type": SSDMetric.GAUSS_SEIDEL_STEP,
            "q_levels": 256,
            "max_inner_iter": 40,
            "use_double_gradient": True,
            "max_step_length": 0.25,
        }
    )
    optimizer_parameters = {
        "max_iter": max_iter,
        "inversion_iter": 40,
        "inversion_tolerance": 1e-3,
        "report_status": True,
    }
    update_rule = UpdateRule.Composition()
    print "Generating synthetic field..."
    # ----apply synthetic deformation field to fixed image
    ground_truth = rcommon.createDeformationField2D_type2(fixed.shape[0], fixed.shape[1], 8)
    warped_fixed = rcommon.warpImage(fixed, ground_truth)
    print "Registering T2 (template) to deformed T1 (template)..."
    plt.figure()
    rcommon.overlayImages(warped_fixed, moving, False)
    registration_optimizer = AsymmetricRegistrationOptimizer(
        warped_fixed, moving, None, None, similarity_metric, update_rule, optimizer_parameters
    )
    registration_optimizer.optimize()
    #######################show results#################################
    displacement = registration_optimizer.get_forward()
    direct_inverse = registration_optimizer.get_backward()
    moving_to_fixed = np.array(tf.warp_image(moving, displacement))
    fixed_to_moving = np.array(tf.warp_image(warped_fixed, direct_inverse))
    rcommon.overlayImages(moving_to_fixed, fixed_to_moving, True)
    direct_residual, stats = tf.compose_vector_fields(displacement, direct_inverse)
    direct_residual = np.array(direct_residual)
    rcommon.plotDiffeomorphism(displacement, direct_inverse, direct_residual, "inv-direct", 7)

    residual = ((displacement - ground_truth)) ** 2
    mean_error = np.sqrt(residual.sum(2) * (warped_fixed > 0)).mean()
    stdev_error = np.sqrt(residual.sum(2) * (warped_fixed > 0)).std()
    print "Mean displacement error: ", mean_error, "(", stdev_error, ")"
Exemple #29
0
def showRegistrationResultMidSlices(fnameMoving, fnameFixed, fnameAffine=None):
    '''    
    showRegistrationResultMidSlices('IBSR_01_ana_strip.nii.gz', 't1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', 'IBSR_01_ana_strip_t1_icbm_normal_1mm_pn0_rf0_peeledAffine.txt')
    showRegistrationResultMidSlices('warpedDiff_IBSR_01_ana_strip_t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', 't1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', None)
    
    
    showRegistrationResultMidSlices('warpedDiff_IBSR_01_ana_strip_IBSR_02_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_02/IBSR_02_ana_strip.nii.gz', None)
    showRegistrationResultMidSlices('warpedDiff_IBSR_01_segTRI_ana_IBSR_02_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_02/IBSR_02_segTRI_ana.nii.gz', None)
    ##Worst pair:
        showRegistrationResultMidSlices('warpedDiff_IBSR_16_segTRI_ana_IBSR_12_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_12/IBSR_12_segTRI_ana.nii.gz', None)
        
        showRegistrationResultMidSlices('/opt/registration/data/t1/IBSR18/IBSR_16/IBSR_16_segTRI_ana.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_12/IBSR_12_segTRI_ana.nii.gz', None)
        showRegistrationResultMidSlices('/opt/registration/data/t1/IBSR18/IBSR_16/IBSR_16_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_12/IBSR_12_ana_strip.nii.gz', None)
        showRegistrationResultMidSlices('warpedAffine_IBSR_16_segTRI_ana_IBSR_12_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_12/IBSR_12_segTRI_ana.nii.gz', None)
        showRegistrationResultMidSlices('warpedDiff_IBSR_16_ana_strip_IBSR_12_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_12/IBSR_12_ana_strip.nii.gz', None)
        showRegistrationResultMidSlices('warpedAffine_IBSR_16_ana_strip_IBSR_12_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_12/IBSR_12_ana_strip.nii.gz', None)
        
        showRegistrationResultMidSlices('/opt/registration/data/t1/IBSR18/IBSR_10/IBSR_10_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_16/IBSR_16_ana_strip.nii.gz', None)
        showRegistrationResultMidSlices('warpedAffine_IBSR_10_ana_strip_IBSR_16_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_16/IBSR_16_ana_strip.nii.gz', None)
        
        showRegistrationResultMidSlices('warpedAffine_IBSR_16_ana_strip_IBSR_10_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_10/IBSR_10_ana_strip.nii.gz', None)
        showRegistrationResultMidSlices('warpedDiff_IBSR_16_ana_strip_IBSR_10_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_10/IBSR_10_ana_strip.nii.gz', None)
        showRegistrationResultMidSlices('warpedDiff_IBSR_01_ana_strip_IBSR_08_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_08/IBSR_08_ana_strip.nii.gz', None)
        showRegistrationResultMidSlices('/opt/registration/data/t1/IBSR18/IBSR_01/IBSR_01_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_08/IBSR_08_ana_strip.nii.gz', None)
        showRegistrationResultMidSlices('warpedDiff_IBSR_13_ana_strip_IBSR_10_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_10/IBSR_10_ana_strip.nii.gz', None)
        showRegistrationResultMidSlices('warpedAffine_IBSR_13_ana_strip_IBSR_10_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_10/IBSR_10_ana_strip.nii.gz', None)
        showRegistrationResultMidSlices('/opt/registration/data/t1/IBSR18/IBSR_13/IBSR_13_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_10/IBSR_10_ana_strip.nii.gz', None)
        
        showRegistrationResultMidSlices('warpedDiff_IBSR_01_ana_strip_IBSR_02_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_10/IBSR_10_ana_strip.nii.gz', None)
        
        showRegistrationResultMidSlices('warpedAffine_IBSR_16_seg_ana_IBSR_10_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_10/IBSR_10_seg_ana.nii.gz', None)
        showRegistrationResultMidSlices('/opt/registration/data/t1/IBSR18/IBSR_16/IBSR_16_seg_ana.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_10/IBSR_10_seg_ana.nii.gz', None)
        
        showRegistrationResultMidSlices('/opt/registration/data/t1/IBSR18/IBSR_01/IBSR_01_segTRI_fill_ana.nii.gz', 'warpedAffine_IBSR_10_segTRI_fill_ana_IBSR_01_ana_strip.nii.gz', None)
        
        showRegistrationResultMidSlices('warpedDiff_IBSR_07_ana_strip_IBSR_17_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_17/IBSR_17_ana_strip.nii.gz', None)
        showRegistrationResultMidSlices('/opt/registration/data/t1/IBSR18/IBSR_07/IBSR_07_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_17/IBSR_17_ana_strip.nii.gz', None)
        
        showRegistrationResultMidSlices('warpedDiff_IBSR_06_ana_strip_IBSR_17_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_17/IBSR_17_ana_strip.nii.gz', None)
        showRegistrationResultMidSlices('warpedDiff_IBSR_07_ana_strip_IBSR_12_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_12/IBSR_12_ana_strip.nii.gz', None)
        
        showRegistrationResultMidSlices('warpedDiff_IBSR_15_ana_strip_IBSR_10_ana_strip.nii.gz', '/opt/registration/data/t1/IBSR18/IBSR_10/IBSR_10_ana_strip.nii.gz', None)
        showRegistrationResultMidSlices('warpedDiff_IBSR_01_ana_strip_t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', 't1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', None)
        showRegistrationResultMidSlices('warpedDiff_IBSR_01_segTRI_fill_ana_t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', 'data/phantom_1.0mm_normal_crisp.rawb.nii.gz', None)
        
        showRegistrationResultMidSlices('data/t1/t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', 'data/phantom_1.0mm_normal_crisp_peeled.nii.gz', None)
        showRegistrationResultMidSlices('data/t2/t2_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', 'data/phantom_1.0mm_normal_crisp_peeled.nii.gz', None)
        showRegistrationResultMidSlices('warpedDiff_IBSR_16_ana_strip_t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', 'data/t1/t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', None)
        showRegistrationResultMidSlices('warpedAffine_IBSR_16_ana_strip_t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', 'data/t1/t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', None)
        showRegistrationResultMidSlices('test16.nii.gz', 'data/t1/t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', None)
        
        showRegistrationResultMidSlices('data/t1/t1_icbm_normal_1mm_pn0_rf0.rawb_peeled.nii.gz', 'data/t1/t1_icbm_normal_1mm_pn0_rf0.rawb_peeled.nii.gz', None)
        showRegistrationResultMidSlices('warpedAffine_IBSR_15_ana_strip_t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', 'data/t1/t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', None)
        showRegistrationResultMidSlices('warpedDiff_IBSR_15_ana_strip_t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', 'data/t1/t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', None)
        
        showRegistrationResultMidSlices('warpedAffine_IBSR_01_ana_strip_t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', 'data/t1/t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', None)
        showRegistrationResultMidSlices('warpedDiff_IBSR_01_ana_strip_t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', 'data/t1/t1_icbm_normal_1mm_pn0_rf0_peeled.nii.gz', None)
        
        
    '''
    
    if(fnameAffine==None):
        T=np.eye(4)
    else:
        T=rcommon.readAntsAffine(fnameAffine)
    print 'T:',T
    fixed=nib.load(fnameFixed)
    F=fixed.get_affine()
    print 'F:',F
    fixed=fixed.get_data().squeeze().astype(np.float64)
    moving=nib.load(fnameMoving)
    M=moving.get_affine()
    print 'M:',M
    moving=moving.get_data().squeeze().astype(np.float64)
    initAffine=np.linalg.inv(M).dot(T.dot(F))
    
    fixed=np.copy(fixed, order='C')
    moving=np.copy(moving, order='C')
    warped=np.array(tf.warp_volume_affine(moving, np.array(fixed.shape).astype(np.int32), initAffine))
    sh=warped.shape
    rcommon.overlayImages(warped[sh[0]//2,:,:], fixed[sh[0]//2,:,:])
    rcommon.overlayImages(warped[:,sh[1]//2,:], fixed[:,sh[1]//2,:])
    rcommon.overlayImages(warped[:,:,sh[2]//2], fixed[:,:,sh[2]//2])