TiltPairAligner Class Reference

#include <micrograph.h>

Collaboration diagram for TiltPairAligner:

Public Member Functions
	TiltPairAligner ()
	Empty constructor. More...
void	clear ()
	Clear set of coordinates. More...
void	addCoordinatePair (int _muX, int _muY, int _mtX, int _mtY)
	Add coordinates pair. More...
void	adjustPassingMatrix (int _muX, int _muY, int _mtX, int _mtY)
	Adjust passing matrix. More...
void	calculatePassingMatrix ()
	Calculate passing matrix. More...
void	passToTilted (int _muX, int _muY, int &_mtX, int &_mtY)
	Pass to tilted. More...
void	passToUntilted (int _mtX, int _mtY, int &_muX, int &_muY)
	Pass to untilted. More...
void	computeGamma ()
	Compute gamma. More...
void	computeAngles (double &ualpha, double &talpha, double &ogamma)

Public Attributes
std::vector< int >	coordU
	Untilted coordinates. More...
std::vector< int >	coordT
	Tilted coordinates. More...
Matrix2D< double >	Au
Matrix2D< double >	Bt
Matrix2D< double >	Put
Matrix2D< double >	Ptu
int	Nu
double	gamma
double	alpha_u
double	alpha_t
Matrix1D< double >	m
	Auxiliary vector. More...
Matrix2D< double >	pair_E

Detailed Description

Class for aligning two tilted micrographs

Definition at line 548 of file micrograph.h.

Constructor & Destructor Documentation

TiltPairAligner()

TiltPairAligner::TiltPairAligner

(

)

Empty constructor.

Definition at line 593 of file micrograph.cpp.

{
    clear();
}

Member Function Documentation

addCoordinatePair()

void TiltPairAligner::addCoordinatePair	(	int	_muX,
		int	_muY,
		int	_mtX,
		int	_mtY
	)

Add coordinates pair.

Definition at line 612 of file micrograph.cpp.

{
    coordU.push_back(_muX);
    coordU.push_back(_muY);
    coordT.push_back(_mtX);
    coordT.push_back(_mtY);
    Nu++; // Number of particles

#ifdef _DEBUG

    std::cout << "Adding point U(" << U.X << "," << U.Y << ") T(" << T.X << ","
    << T.Y << ")\n";
    std::cout << "A at input" << Au << "B at input" << Bt;
#endif
    // Adjust untilted dependent matrix
    MAT_ELEM(Au,0, 0) += _muX * _muX;
    MAT_ELEM(Au,0, 1) += _muX * _muY;
    MAT_ELEM(Au,0, 2) += _muX;
    MAT_ELEM(Au,1, 0) = MAT_ELEM(Au,0, 1);
    MAT_ELEM(Au,1, 1) += _muY * _muY;
    MAT_ELEM(Au,1, 2) += _muY;
    MAT_ELEM(Au,2, 0) = MAT_ELEM(Au,0, 2);
    MAT_ELEM(Au,2, 1) = MAT_ELEM(Au,1, 2);
    MAT_ELEM(Au,2, 2) = Nu;

    // Adjust tilted dependent matrix
    MAT_ELEM(Bt,0, 0) += _mtX * _muX;
    MAT_ELEM(Bt,0, 1) += _mtY * _muX;
    MAT_ELEM(Bt,0, 2) = MAT_ELEM(Au,0, 2);
    MAT_ELEM(Bt,1, 0) += _mtX * _muY;
    MAT_ELEM(Bt,1, 1) += _mtY * _muY;
    MAT_ELEM(Bt,1, 2) = MAT_ELEM(Au,1, 2);
    MAT_ELEM(Bt,2, 0) += _mtX;
    MAT_ELEM(Bt,2, 1) += _mtY;
    MAT_ELEM(Bt,2, 2) = MAT_ELEM(Au,2, 2);

#ifdef _DEBUG

    std::cout << "A at output" << Au << "B at output" << Bt;
#endif


}

adjustPassingMatrix()

void TiltPairAligner::adjustPassingMatrix	(	int	_muX,
		int	_muY,
		int	_mtX,
		int	_mtY
	)

Adjust passing matrix.

Definition at line 658 of file micrograph.cpp.

{
    addCoordinatePair(_muX, _muY, _mtX, _mtY);
    calculatePassingMatrix();
}

calculatePassingMatrix()

void TiltPairAligner::calculatePassingMatrix

(

)

Calculate passing matrix.

Definition at line 665 of file micrograph.cpp.

{
    if (Nu > 3)
    {
        solve(Au, Bt, Put);
        Put = Put.transpose();
        Ptu = Put.inv();
    }
}

clear()

void TiltPairAligner::clear

(

)

Clear set of coordinates.

Definition at line 598 of file micrograph.cpp.

{
    coordU.clear();
    coordT.clear();
    Au.clear();
    Bt.clear();
    Put.clear();
    Ptu.clear();
    Au.initZeros(3, 3);
    Bt.initZeros(3, 3);
    Nu = 0;
    m.resizeNoCopy(3);
}

computeAngles()

void TiltPairAligner::computeAngles	(	double &	ualpha,
		double &	talpha,
		double &	ogamma
	)

Compute alphas. Make sure of calling computeGamma before calling this function.

Definition at line 802 of file micrograph.cpp.

{
    alpha_u = alpha_t = 0;
    Matrix1D<double> angles(3);
    angles.initZeros();
    double fitness;
    int iter;

    // Coarse search
    double *aux = angles.adaptForNumericalRecipes();
    double best_alpha_u = 0;
    double best_alpha_t = 0;
    double best_fit = 1e8;
    aux[3] = gamma;
    for (aux[1] = 0; aux[1] < 180; aux[1] += 5)
        for (aux[2] = 0; aux[2] < 180; aux[2] += 5)
        {
            double fit = matrix_fitness(aux, this);
            if (fit < best_fit)
            {
                best_fit = fit;
                best_alpha_u = aux[1];
                best_alpha_t = aux[2];
            }
        }
    angles.killAdaptationForNumericalRecipes(aux);
    angles(0) = best_alpha_u;
    angles(1) = best_alpha_t;
    angles(2) = gamma;

    // Fine search
    Matrix1D<double> steps(3);
    steps.initConstant(1);
    powellOptimizer(angles, 1, 3, &matrix_fitness, this, 0.001, fitness, iter,
                    steps, false);
    alpha_u = angles(0);
    alpha_t = angles(1);
    gamma = angles(2);

    ualpha = alpha_u;
    talpha = alpha_t;
    ogamma = gamma;
}

computeGamma()

void TiltPairAligner::computeGamma

(

)

Compute gamma.

Definition at line 717 of file micrograph.cpp.

{
constexpr int  TRIANGLE_NO =  15000;
constexpr int  MIN_AREA =        15;
constexpr int  MAX_AREA =    250000;
    gamma = 0;
    Matrix1D<int> iju(2); // From i to j in untilted
    Matrix1D<int> iku(2); // From i to j in untilted
    Matrix1D<int> ijt(2); // From i to j in untilted
    Matrix1D<int> ikt(2); // From i to j in untilted
    // From i to k in untilted
    // From i to j in tilted
    // From i to k in tilted
    int triang = 0; // Number of triangles considered
    int i;
    int j;
    int k;
    int counter1;
    counter1 = 0;
    randomize_random_generator();
    long noCombinations;
    noCombinations = Nu * (Nu - 1) * (Nu - 2) / 6;
    while (triang < TRIANGLE_NO && counter1 < noCombinations)
    {
        counter1++;
        i = (int)round(rnd_unif(0, Nu - 1));
        j = (int)round(rnd_unif(0, Nu - 1));
        k = (int)round(rnd_unif(0, Nu - 1));

        // Compute area of triangle in untilted micrograph
        VECTOR_R2(iju, coordU[j] - coordU[i], coordU[j+1] - coordU[i+1]);
        VECTOR_R2(iku, coordU[k] - coordU[i], coordU[k+1] - coordU[i+1]);
        double untilted_area = fabs(dotProduct(iju, iku)/*/2*/);
        if (untilted_area < MIN_AREA
           )
            continue; // For numerical stability

        // Compute area of the same triangle in the tilted micrograph
        VECTOR_R2(ijt, coordT[j] - coordT[i], coordT[j+1] - coordT[i+1]);
        VECTOR_R2(ikt, coordT[k] - coordT[i], coordT[k+1] - coordT[i+1]);
        double tilted_area = fabs(dotProduct(ijt, ikt)/*/2*/);
        if (tilted_area < MIN_AREA
           )
            continue; // For numerical stability
        if (tilted_area > MAX_AREA
           )
            continue; // micrograph are not perfect
        // sheets so avoid
        // very far away particles

        // Now we know that tilted_area=untilted_area*cos(gamma)
        if (tilted_area > untilted_area)
            continue; // There are user errors
        // In the point selection
        gamma += acos(tilted_area / untilted_area);
        triang++;
    }
    if (0 == triang) {
        REPORT_ERROR(ERR_NUMERICAL, "triang is zero (0), which would lead to division by zero");
    }
    gamma /= triang;
    gamma = RAD2DEG(gamma);
    if (triang < 100)
        std::cout << "Not many particles, tilt angle may not be accurate"
        << std::endl;
}

passToTilted()

void TiltPairAligner::passToTilted	(	int	_muX,
		int	_muY,
		int &	_mtX,
		int &	_mtY
	)

Pass to tilted.

Definition at line 676 of file micrograph.cpp.

{


    if (Nu > 3)
    {
        SPEED_UP_temps012;
        VECTOR_R3(m, _muX, _muY, 1);
        M3x3_BY_V3x1(m, Put, m);

        _mtX = (int) XX(m);
        _mtY = (int) YY(m);
    }
    else
    {
        _mtX = _muX;
        _mtY = _muY;
    }

}

passToUntilted()

void TiltPairAligner::passToUntilted	(	int	_mtX,
		int	_mtY,
		int &	_muX,
		int &	_muY
	)

Pass to untilted.

Definition at line 698 of file micrograph.cpp.

{
    if (Nu > 3)
    {
        SPEED_UP_temps012;

        VECTOR_R3(m, _mtX, _mtY, 1);
        M3x3_BY_V3x1(m, Ptu, m);
        _muX = (int) XX(m);
        _muY = (int) YY(m);
    }
    else
    {
        _muX = _mtX;
        _muY = _mtY;
    }
}

Member Data Documentation

alpha_t

double TiltPairAligner::alpha_t

Definition at line 593 of file micrograph.h.

alpha_u

double TiltPairAligner::alpha_u

Definition at line 592 of file micrograph.h.

Au

Matrix2D<double> TiltPairAligner::Au

Definition at line 586 of file micrograph.h.

Bt

Matrix2D<double> TiltPairAligner::Bt

Definition at line 587 of file micrograph.h.

coordT

std::vector<int> TiltPairAligner::coordT

Tilted coordinates.

Definition at line 554 of file micrograph.h.

coordU

std::vector<int> TiltPairAligner::coordU

Untilted coordinates.

Definition at line 552 of file micrograph.h.

gamma

double TiltPairAligner::gamma

Definition at line 591 of file micrograph.h.

m

Matrix1D<double> TiltPairAligner::m

Auxiliary vector.

Definition at line 595 of file micrograph.h.

Nu

int TiltPairAligner::Nu

Definition at line 590 of file micrograph.h.

pair_E

Matrix2D<double> TiltPairAligner::pair_E

Definition at line 596 of file micrograph.h.

Ptu

Matrix2D<double> TiltPairAligner::Ptu

Definition at line 589 of file micrograph.h.

Put

Matrix2D<double> TiltPairAligner::Put

Definition at line 588 of file micrograph.h.

---

The documentation for this class was generated from the following files:

• xmipp/libraries/data/micrograph.h
• xmipp/libraries/data/micrograph.cpp