angular_continuous_assign (Continuous angular assignment)

Collaboration diagram for angular_continuous_assign (Continuous angular assignment):

Classes
class	ProgAngularContinuousAssign
struct	cstregistrationStruct

Functions
double	CSTSplineAssignment (MultidimArray< double > &ReDFTVolume, MultidimArray< double > &ImDFTVolume, MultidimArray< double > &image, MultidimArray< double > &weight, Matrix1D< double > &pose_parameters, int max_no_iter=60)

Detailed Description

Function Documentation

CSTSplineAssignment()

double CSTSplineAssignment	(	MultidimArray< double > &	ReDFTVolume,
		MultidimArray< double > &	ImDFTVolume,
		MultidimArray< double > &	image,
		MultidimArray< double > &	weight,
		Matrix1D< double > &	pose_parameters,
		int	max_no_iter = 60
	)

Assign pose parameters for 1 image. The weight must be an image of the size of the input image with the appropriate weighting in frequency (normally a gaussian). The pose parameters at the input must have the initial guess of the pose. At the output they contain the parameters estimated by CST Spline Assignment. The maximum number of iterations controls the optimization process.

Definition at line 256 of file angular_continuous_assign.cpp.

{
    // Build the parameter structure .........................................
    cstregistrationStruct Data;

    // Set the Volume input
    Data.ReDftVolume    = MULTIDIM_ARRAY(ReDFTVolume);
    Data.nx_ReDftVolume = XSIZE(ReDFTVolume);
    Data.ny_ReDftVolume = YSIZE(ReDFTVolume);
    Data.nz_ReDftVolume = ZSIZE(ReDFTVolume);

    Data.ImDftVolume    = MULTIDIM_ARRAY(ImDFTVolume);
    Data.nx_ImDftVolume = XSIZE(ImDFTVolume);
    Data.ny_ImDftVolume = YSIZE(ImDFTVolume);
    Data.nz_ImDftVolume = ZSIZE(ImDFTVolume);

    // Perform the DFT of the input image
    int Status;
    MultidimArray<double> realImg(image), imagImg;
    CenterFFT(realImg, false);
    imagImg.resize(image);
    VolumeDftRealToRealImaginary(MULTIDIM_ARRAY(realImg),
                                 MULTIDIM_ARRAY(imagImg), XSIZE(image), YSIZE(image), 1, &Status);
    CenterFFT(realImg, true);
    CenterFFT(imagImg, true);

    // Set the Image input
    Data.ReDftImage     = MULTIDIM_ARRAY(realImg);
    Data.nx_ReDftImage  = XSIZE(realImg);
    Data.ny_ReDftImage  = YSIZE(realImg);

    Data.ImDftImage     = MULTIDIM_ARRAY(imagImg);
    Data.nx_ImDftImage  = XSIZE(imagImg);
    Data.ny_ImDftImage  = YSIZE(imagImg);

    // Set the weight input
    Data.Weight         = MULTIDIM_ARRAY(weight);
    Data.nx_Weight      = XSIZE(weight);
    Data.ny_Weight      = YSIZE(weight);

    // Set the sampling rates
    Matrix1D<double> sampling_rate(3);
    sampling_rate.initConstant(1);
    Data.VoxelSize      = MATRIX1D_ARRAY(sampling_rate);
    Data.nx_VoxelSize   = 3;
    Data.PixelSize      = MATRIX1D_ARRAY(sampling_rate);
    Data.nx_PixelSize   = 2;

    // Set the initial pose parameters
    Data.Parameters     = MATRIX1D_ARRAY(pose_parameters);
    Data.nx_Parameters  = 5;

    // Set the final pose parameters.
    Matrix2D<double> output_pose(5, max_no_iter + 1);
    Data.OutputParameters = MATRIX2D_ARRAY(output_pose);
    Data.nx_OutputParameters = max_no_iter + 1;
    Data.ny_OutputParameters = 5;

    // Set performance parameters
    Matrix1D<double> Cost, TimePerIter, Failures;
    Cost.initZeros(max_no_iter + 1);
    TimePerIter.initZeros(max_no_iter + 1);
    Failures.initZeros(max_no_iter + 1);
    long             NumberIterPerformed, NumberSuccPerformed,
    NumberFailPerformed;
    Data.Cost             = MATRIX1D_ARRAY(Cost);
    Data.nx_Cost          = max_no_iter + 1;
    Data.TimePerIter      = MATRIX1D_ARRAY(TimePerIter);
    Data.nx_TimePerIter   = max_no_iter + 1;
    Data.NumberIterPerformed = &NumberIterPerformed;
    Data.NumberSuccPerformed = &NumberSuccPerformed;
    Data.NumberFailPerformed = &NumberFailPerformed;
    Data.Failures            = MATRIX1D_ARRAY(Failures);
    Data.nx_Failures         = max_no_iter + 1;

    // Set the parameters for the extracted central slice
    MultidimArray<double> dftProj(2, YSIZE(image), XSIZE(image));
    Data.dftProj          = MULTIDIM_ARRAY(dftProj);
    Data.nx_dftProj       = XSIZE(image);
    Data.ny_dftProj       = YSIZE(image);
    Data.nz_dftProj       = 2;

    // Set the optimizer parameters
    Data.ScaleLambda      = 2;
    Data.LambdaInitial    = 1000;
    Data.MaxNoIter        = max_no_iter;
    Data.MaxNoFailure     = (long)(0.3 * max_no_iter);
    Data.SatisfNoSuccess  = (long)(0.7 * max_no_iter);
    ;
    Data.MakeDesiredProj  = 0;
    Data.ToleranceAngle   = 0.0;
    Data.ToleranceShift   = 0.0;

    // Call Slavica's routine ...............................................
    Status = cstregistration(&Data);

    // Retrieve results .....................................................
    // Skip last iterations if they are failures
    double retval;
    if (Status != ERROR)
    {
        long last_iteration_performed = *(Data.NumberIterPerformed) + 1;
        while (Failures(last_iteration_performed - 1) > 0.0)
            last_iteration_performed--;

        // Get the pose parameters
        pose_parameters(0) = RAD2DEG(output_pose(0, last_iteration_performed - 1));
        pose_parameters(1) = RAD2DEG(output_pose(1, last_iteration_performed - 1));
        pose_parameters(2) = RAD2DEG(output_pose(2, last_iteration_performed - 1));
        pose_parameters(3) = output_pose(3, last_iteration_performed - 1);
        pose_parameters(4) = output_pose(4, last_iteration_performed - 1);

        // Get the cost
        retval = Cost(last_iteration_performed - 1);
    }
    else
    {
        retval = -1;
        std::cout << "There is a problem with one image, angles not assigned\n";
    }

    // Return
    return retval;
}