#include <projection.h>

Collaboration diagram for ParametersProjectionTomography:

Public Member Functions
	ParametersProjectionTomography ()

void	read (const FileName &fn_proj_param)

void	defineParams (XmippProgram *program)

void	readParams (XmippProgram *program)

void	calculateProjectionAngles (Projection &P, double angle, double inplaneRot, const Matrix1D< double > &sinplane)

Public Attributes
FileName	fnPhantom

FileName	fnRoot
	Root filename (used for a stack) More...

FileName	fnOut
	Output filename (used for a singleProjection) More...

bool	singleProjection
	Only project a single image. More...

int	starting
	First projection number. By default, 1. More...

std::string	fn_projection_extension
	Extension for projection filenames. This is optional. More...

int	proj_Xdim
	Projection Xdim. More...

int	proj_Ydim
	Projection Ydim. More...

bool	only_create_angles
	Only create angles, do not project. More...

bool	show_angles

double	axisRot
	Rotational angle of the tilt axis. More...

double	axisTilt
	Tilt angle of the tilt axis. More...

Matrix1D< double >	raxis
	Offset of the tilt axis. More...

double	tilt0
	Minimum tilt around this axis. More...

double	tiltF
	Maximum tilt around this axis. More...

double	tiltStep
	Step in tilt. More...

double	Npixel_avg
	Bias to be applied to each pixel grey value */. More...

double	Npixel_dev
	Standard deviation of the noise to be added to each pixel grey value. More...

double	Ncenter_avg
	Bias to apply to the image center. More...

double	Ncenter_dev
	Standard deviation of the image center. More...

double	Nangle_avg
	Bias to apply to the angles. More...

double	Nangle_dev
	Standard deviation of the angles. More...

Detailed Description

Projecting parameters. This class reads a set of projection parameters in a file (see xmipp_project_tomography for more information about the file structure) and extract the useful information from it.

Definition at line 58 of file projection.h.

Constructor & Destructor Documentation

◆ ParametersProjectionTomography()

ParametersProjectionTomography::ParametersProjectionTomography ( )

Definition at line 50 of file projection.cpp.

 {
     proj_Xdim = 0;
     proj_Ydim = 0;
 
     axisRot = 0;
     axisTilt = 0;
     raxis.initZeros(3);
 
     tilt0    = 0;
     tiltF    = 0;
     tiltStep = 0;
 
     Nangle_dev = 0;
     Nangle_avg = 0;
 
     Npixel_dev = 0;
     Npixel_avg = 0;
 
     Ncenter_dev = 0;
     Ncenter_avg = 0;
 }

Member Function Documentation

◆ calculateProjectionAngles()

void ParametersProjectionTomography::calculateProjectionAngles	(	Projection &	P,
		double	angle,
		double	inplaneRot,
		const Matrix1D< double > &	sinplane
	)

Calculate the Euler angles and X-Y shifts from the tilt axis direction and tilt angle.

As, usually, the tomographic rotation angle is the tilt angle, we are forcing to keep the sign of the resulting tilt angle coincides the sign of the incoming angle

Definition at line 277 of file projection.cpp.

 {
     // Find Euler rotation matrix
     Matrix1D<double> axis;
     Euler_direction(axisRot,axisTilt,0,axis);
     Matrix2D<double> Raxis;
     Matrix2D<double> Rinplane;
     rotation3DMatrix(angle,axis,Raxis,false);
     rotation3DMatrix(inplaneRot,'Z',Rinplane,false);
     double rot;
     double tilt;
     double psi;
     Euler_matrix2angles(Rinplane*Raxis, rot, tilt, psi);
 
 
     if (angle * tilt < 0)
         Euler_another_set(rot, tilt, psi, rot, tilt, psi);
 
     rot  = realWRAP(rot,-180,180);
     if (XMIPP_EQUAL_ZERO(rot))
         rot = 0.;
     tilt = realWRAP(tilt,-180,180);
     if (XMIPP_EQUAL_ZERO(tilt))
         tilt = 0.;
     psi  = realWRAP(psi,-180,180);
     if (XMIPP_EQUAL_ZERO(psi))
         psi = 0.;
 
     P.setAngles(rot, tilt, psi);
 
     // Find displacement because of axis offset and inplane shift
     Matrix1D<double> roffset = Rinplane*(raxis-Raxis*raxis) + sinplane;
 
     P.setShifts(XX(roffset), YY(roffset), ZZ(roffset));
 
 #ifdef DEBUG
 
     std::cout << "axisRot=" << axisRot << " axisTilt=" << axisTilt
     << " axis=" << axis.transpose() << std::endl
     << "angle=" << angle << std::endl
     << "Raxis\n" << Raxis
     << "Rinplane\n" << Rinplane
     << "Raxis*Rinplane\n" << Raxis*Rinplane
     << "rot=" << rot << " tilt=" << tilt << " psi=" << psi
     << std::endl;
     Matrix2D<double> E;
     Euler_angles2matrix(rot,tilt,psi,E);
     std::cout << "E\n" << E << std::endl;
 #endif
 }

◆ defineParams()

void ParametersProjectionTomography::defineParams ( XmippProgram * program )

Definition at line 74 of file projection.cpp.

 {
     program->addParamsLine(" -i <volume_file>        : Volume file to be projected.");
     program->addParamsLine(" alias --input;");
     program->addParamsLine("   --oroot <rootname>    : Output rootname");
     program->addParamsLine("      requires --params;");
     program->addParamsLine("or -o <image_file>       : Output image");
     program->addParamsLine(" alias --output;");
     program->addParamsLine("      requires --angles;");
     program->addParamsLine("== Generating a set of projections == ");
     program->addParamsLine(" [--params <parameters_file>]         : File containing projection parameters");
     program->addParamsLine("                                    : Check the manual for a description of the parameters");
     program->addParamsLine("      requires --oroot;");
     program->addParamsLine("== Generating a single projection == ");
     program->addParamsLine(" [--angles <tilt> <axisRot=90> <axisTilt=90>]  : Tilt angle for a single projection.");
     program->addParamsLine("                                              : (axisRot, axisTilt) is the direction of the rotation axis." );
     program->addParamsLine("   requires -o;");
     program->addParamsLine("==+ Global projection options== ");
     program->addParamsLine("[--show_angles]          : Print angles value for each projection.");
     program->addParamsLine("[--only_create_angles]   : Projections are not calculated, only the angles values.");
 }

◆ read()

void ParametersProjectionTomography::read ( const FileName & fn_proj_param )

Read projection parameters from a file.

Definition at line 129 of file projection.cpp.

 {
     if (fn_proj_param.isMetaData())
     {
         MetaDataVec MD;
         size_t objId;
         MD.read(fn_proj_param);
         objId = MD.firstRowId();
         //        MD.getValue(MDL_PRJ_VOL, fnPhantom, objId);
         std::vector<double> vecD;
         MD.getValue(MDL_PRJ_DIMENSIONS, vecD, objId);
         proj_Xdim = (int)vecD[0];
         proj_Ydim = (int)vecD[1];
         MD.getValue(MDL_ANGLE_ROT, axisRot, objId);
         MD.getValue(MDL_ANGLE_TILT, axisTilt, objId);
 
         raxis.resize(3);
         if (!MD.getValue(MDL_SHIFT_X, XX(raxis), objId))
             XX(raxis) = 0;
         if (!MD.getValue(MDL_SHIFT_Y, YY(raxis), objId))
             YY(raxis) = 0;
         if (!MD.getValue(MDL_SHIFT_Z, ZZ(raxis), objId))
             ZZ(raxis) = 0;
 
         MD.getValue(MDL_PRJ_TILT_RANGE, vecD, objId);
         tilt0    = vecD[0];
         tiltF    = vecD[1];
         tiltStep = vecD[2];
 
         if (MD.getValue(MDL_NOISE_ANGLES, vecD, objId))
         {
             Nangle_dev = vecD[0];
             Nangle_avg = (vecD.size()>1)? vecD[1]: 0;
         }
         else
             Nangle_dev = Nangle_avg = 0;
 
         if (MD.getValue(MDL_NOISE_PIXEL_LEVEL, vecD, objId))
         {
             Npixel_dev = vecD[0];
             Npixel_avg = (vecD.size()>1)? vecD[1]: 0;
         }
         else
             Npixel_dev = Npixel_avg = 0;
 
         if (MD.getValue(MDL_NOISE_PARTICLE_COORD, vecD, objId))
         {
             Ncenter_dev = vecD[0];
             Ncenter_avg = (vecD.size()>1)? vecD[1]: 0;
         }
         else
             Ncenter_dev = Ncenter_avg = 0;
     }
     else
     {
         FILE    *fh_param;
         char    line[201];
         int     lineNo = 0;
         char    *auxstr;
 
         if ((fh_param = fopen(fn_proj_param.c_str(), "r")) == nullptr)
             REPORT_ERROR(ERR_IO_NOTOPEN,
                          (std::string)"ParametersProjectionTomography::read: There is a problem "
                          "opening the file " + fn_proj_param);
         while (fgets(line, 200, fh_param) != nullptr)
         {
             if (line[0] == 0)
                 continue;
             if (line[0] == '#')
                 continue;
             if (line[0] == '\n')
                 continue;
             switch (lineNo)
             {
             case 0:
                 fnPhantom = firstWord(line);
                 lineNo = 1;
                 break;
             case 1:
                 fnOut =
                     firstWord(line);
                 // Next two parameters are optional
                 auxstr = nextToken();
                 if (auxstr != nullptr)
                     starting =
                         textToInteger(auxstr);
                 fn_projection_extension = nextToken();
                 lineNo = 2;
                 break;
             case 2:
                 proj_Xdim = textToInteger(firstToken(line));
                 proj_Ydim = textToInteger(nextToken());
                 lineNo = 3;
                 break;
             case 3:
                 axisRot = textToFloat(firstToken(line));
                 axisTilt = textToFloat(nextToken());
                 lineNo = 4;
                 break;
             case 4:
                 raxis.resize(3);
                 XX(raxis) = textToFloat(firstToken(line));
                 YY(raxis) = textToFloat(nextToken());
                 ZZ(raxis) = textToFloat(nextToken());
                 lineNo = 5;
                 break;
             case 5:
                 tilt0 = textToFloat(firstToken(line));
                 tiltF = textToFloat(nextToken());
                 tiltStep = textToFloat(nextToken());
                 lineNo = 6;
                 break;
             case 6:
                 Nangle_dev = textToFloat(firstWord(line));
                 auxstr = nextToken();
                 if (auxstr != nullptr)
                     Nangle_avg = textToFloat(auxstr);
                 else
                     Nangle_avg = 0;
                 lineNo = 7;
                 break;
             case 7:
                 Npixel_dev = textToFloat(firstWord(line));
                 auxstr = nextToken();
                 if (auxstr != nullptr)
                     Npixel_avg = textToFloat(auxstr);
                 else
                     Npixel_avg = 0;
                 lineNo = 8;
                 break;
             case 8:
                 Ncenter_dev = textToFloat(firstWord(line));
                 auxstr = nextToken();
                 if (auxstr != nullptr)
                     Ncenter_avg = textToFloat(auxstr);
                 else
                     Ncenter_avg = 0;
                 lineNo = 9;
                 break;
             } /* switch end */
         } /* while end */
         if (lineNo != 9)
             REPORT_ERROR(ERR_ARG_MISSING, (std::string)"ParametersProjectionTomography::read: I "
                          "couldn't read all parameters from file " + fn_proj_param);
         fclose(fh_param);
     }
 }

◆ readParams()

void ParametersProjectionTomography::readParams ( XmippProgram * program )

Definition at line 97 of file projection.cpp.

 {
     fnPhantom = program->getParam("-i");
 
     singleProjection = program->checkParam("-o");
 
     if (!singleProjection)
     {
         fnRoot = program->getParam("--oroot");
         read(program->getParam("--params"));
     }
     else
     {
         fnOut = program->getParam("-o");
 
         tilt0 = tiltF = program->getDoubleParam("--angles",0);
         tiltStep = 1;
 
         axisRot = program->getDoubleParam("--angles",1);
         axisTilt = program->getDoubleParam("--angles",2);
 
         Image<char> volTemp;
         volTemp.read(fnPhantom, HEADER);
         proj_Xdim = XSIZE(VOLMATRIX(volTemp));
         proj_Ydim = YSIZE(VOLMATRIX(volTemp));
     }
 
     show_angles = program->checkParam("--show_angles");
     only_create_angles = program->checkParam("--only_create_angles");
 }

Member Data Documentation

◆ axisRot

double ParametersProjectionTomography::axisRot

Rotational angle of the tilt axis.

Definition at line 86 of file projection.h.

◆ axisTilt

double ParametersProjectionTomography::axisTilt

Tilt angle of the tilt axis.

Definition at line 88 of file projection.h.

◆ fn_projection_extension

std::string ParametersProjectionTomography::fn_projection_extension

Extension for projection filenames. This is optional.

Definition at line 73 of file projection.h.

◆ fnOut

FileName ParametersProjectionTomography::fnOut

Output filename (used for a singleProjection)

Definition at line 67 of file projection.h.

◆ fnPhantom

FileName ParametersProjectionTomography::fnPhantom

Phantom filename. It must be a Xmipp volume.

Definition at line 63 of file projection.h.

◆ fnRoot

FileName ParametersProjectionTomography::fnRoot

Root filename (used for a stack)

Definition at line 65 of file projection.h.

◆ Nangle_avg

double ParametersProjectionTomography::Nangle_avg

Bias to apply to the angles.

Definition at line 109 of file projection.h.

◆ Nangle_dev

double ParametersProjectionTomography::Nangle_dev

Standard deviation of the angles.

Definition at line 111 of file projection.h.

◆ Ncenter_avg

double ParametersProjectionTomography::Ncenter_avg

Bias to apply to the image center.

Definition at line 104 of file projection.h.

◆ Ncenter_dev

double ParametersProjectionTomography::Ncenter_dev

Standard deviation of the image center.

Definition at line 106 of file projection.h.

◆ Npixel_avg

double ParametersProjectionTomography::Npixel_avg

Bias to be applied to each pixel grey value */.

Definition at line 99 of file projection.h.

◆ Npixel_dev

double ParametersProjectionTomography::Npixel_dev

Standard deviation of the noise to be added to each pixel grey value.

Definition at line 101 of file projection.h.

◆ only_create_angles

bool ParametersProjectionTomography::only_create_angles

Only create angles, do not project.

Definition at line 81 of file projection.h.

◆ proj_Xdim

int ParametersProjectionTomography::proj_Xdim

Projection Xdim.

Definition at line 76 of file projection.h.

◆ proj_Ydim

int ParametersProjectionTomography::proj_Ydim

Projection Ydim.

Definition at line 78 of file projection.h.

◆ raxis

Matrix1D<double> ParametersProjectionTomography::raxis

Offset of the tilt axis.

Definition at line 90 of file projection.h.

◆ show_angles

bool ParametersProjectionTomography::show_angles

Definition at line 83 of file projection.h.

◆ singleProjection

bool ParametersProjectionTomography::singleProjection

Only project a single image.

Definition at line 69 of file projection.h.

◆ starting

int ParametersProjectionTomography::starting

First projection number. By default, 1.

Definition at line 71 of file projection.h.

◆ tilt0

double ParametersProjectionTomography::tilt0

Minimum tilt around this axis.

Definition at line 92 of file projection.h.

◆ tiltF

double ParametersProjectionTomography::tiltF

Maximum tilt around this axis.

Definition at line 94 of file projection.h.

◆ tiltStep

double ParametersProjectionTomography::tiltStep

Step in tilt.

Definition at line 96 of file projection.h.

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

xmipp/libraries/data/projection.h
xmipp/libraries/data/projection.cpp

Public Member Functions

Public Attributes