Prog_Sampling_Parameters Class Reference

#include <precompute_sampling.h>

Collaboration diagram for Prog_Sampling_Parameters:

Public Member Functions
	Prog_Sampling_Parameters ()
void	read (int argc, const char **argv)
void	usage ()
void	show ()
void	run ()
void	get_sym_vectors (std::vector< Matrix1D< double > > &sym_points)

Public Attributes
Sampling	mysampling
double	sampling
double	neighborhood
std::string	sampling_file_root
FileName	fn_sym
int	symmetry
int	sym_order
double	max_tilt_angle
double	min_tilt_angle

Detailed Description

Parameter class for the PDB Phantom program

Definition at line 40 of file precompute_sampling.h.

Constructor & Destructor Documentation

Prog_Sampling_Parameters()

Prog_Sampling_Parameters::Prog_Sampling_Parameters

(

)

Empty constructor

sampling object 1 by default

Definition at line 30 of file precompute_sampling.cpp.

{
    mysampling.setSampling(1);
}

Member Function Documentation

get_sym_vectors()

void Prog_Sampling_Parameters::get_sym_vectors

(

std::vector< Matrix1D< double > > &

sym_points

)

get all directions related by symmetry to (1,0,0)

read()

void Prog_Sampling_Parameters::read	(	int	argc,
		const char **	argv
	)

Read from a command line. An exception might be thrown by any of the internal conversions, this would mean that there is an error in the command line and you might show a usage message.

Definition at line 38 of file precompute_sampling.cpp.

{
    sampling_file_root = getParameter(argc, argv, "-o");
    fn_sym = getParameter(argc, argv, "-sym");
    //symmetry = getParameter(argc, argv, "-symmetry", "cn");
    //sym_order = textToInteger(getParameter(argc, argv, "-sym_order", "1"));
    sampling = textToFloat(getParameter(argc, argv, "-sampling_rate", "5"));
    neighborhood = textToFloat(getParameter(argc, argv, "-neighborhood", "1"));
    max_tilt_angle = textToFloat(getParameter(argc, argv, "-max_tilt_angle","0"));
    min_tilt_angle = textToFloat(getParameter(argc, argv, "-min_tilt_angle","180"));
}

run()

void Prog_Sampling_Parameters::run

(

)

Run.

Definition at line 89 of file precompute_sampling.cpp.

{
    show();
    mysampling.setSampling(sampling);
    mysampling.setNeighborhoodRadius(neighborhood);
    mysampling.computeSamplingPoints(false,max_tilt_angle,min_tilt_angle);
    //mysampling.computeSamplingPoints(false);
    mysampling.SL.isSymmetryGroup(fn_sym, symmetry, sym_order);
    mysampling.removeRedundantPoints(symmetry, sym_order);
    mysampling.createAsymUnitFile(sampling_file_root);
    //mysampling.computeNeighbors();
    //#define DEBUG6
#ifdef DEBUG6
    for (int i = 0; i < mysampling.no_redundant_sampling_points_vector.size(); i++)
    {
        std::cout << mysampling.no_redundant_sampling_points_vector[i].transpose() << " 1.1 2.2222 " << std::endl;
        //std::cout << mysampling.no_redundant_sampling_points_angles[i].transpose() << " 1.21 1 " << std::endl;
    }
#endif
#undef DEBUG6
    //#define DEBUG6
#ifdef DEBUG6
    {   /* for sphere coverage only R is important.
                  for psi L and R are important
                */
        double rot,  tilt,  psi;
        double rotp, tiltp, psip;
        Matrix1D<double>  row(3);
        Matrix2D<double>  L(4, 4), R(4, 4);
        //std::cerr << "mysampling.SL.SymsNo():" << mysampling.SL.SymsNo() << std::endl;
        for (int i = 0; i < mysampling.no_redundant_sampling_points_vector.size(); i++)
        {
            if (i == 50)
            {
                rot = XX(mysampling.no_redundant_sampling_points_angles[i]);
                tilt = YY(mysampling.no_redundant_sampling_points_angles[i]);
                psi = ZZ(mysampling.no_redundant_sampling_points_angles[i]);
                std::cerr << 1 << " " << 3 << " " << rot << " " << tilt << " " << psi << std::endl;
                //std::cerr << mysampling.no_redundant_sampling_points_vector[i].transpose() << " 1 1" << std::endl;
            }
            for (int isym = 0; isym < mysampling.SL.SymsNo(); isym++)
            {
                //std::cerr << L << R << std::endl;
                mysampling.SL.get_matrices(isym, L, R);
                R.resize(3, 3); // as only the relative orientation
                row = R * mysampling.no_redundant_sampling_points_vector[i];
                std::cout << row.transpose() << " 1 " << isym + 2 << std::endl;
                if (i == 50)
                {
                    //std::cerr << row.transpose() << " 1 " << isym +2 << std::endl;
                    L.resize(3, 3); // Erase last row and column
                    //std::cerr << L << R << std::endl;
                    Euler_apply_transf(L, R, rot, tilt, psi, rotp, tiltp, psip);
                    Euler_direction(rotp, tiltp, psip, row);
                    std::cerr << isym + 2 << " " << 3 << " " << rotp << " " << tiltp << " " << psip << std::endl;
                }
            }
        }
    }
#endif
#undef DEBUG6
    //#define DEBUG6
#ifdef DEBUG6
    for (int i = 0;
         i < mysampling.sampling_points_vector.size();
         i++)
        std::cout  <<  mysampling.sampling_points_vector[i].transpose()  << " 1 1 " << std::endl;
#endif
#undef DEBUG6
    //#define DEBUG6
#ifdef DEBUG6
    for (int i = 0; i < mysampling.no_redundant_sampling_points_vector.size();i++)
    {
        std::cout  << mysampling.no_redundant_sampling_points_vector[i].transpose() << " 1.2 3 " << std::endl;
        for (int j = 0; j < mysampling.my_neighbors[i].size();j++)
            std::cout  <<
            mysampling.no_redundant_sampling_points_vector[mysampling.my_neighbors[i][j]].transpose()
            << " 1.1 2 " << std::endl;
    }
#endif
#undef DEBUG6
}

show()

void Prog_Sampling_Parameters::show

(

)

Show parameters.

Definition at line 73 of file precompute_sampling.cpp.

{
    std::cout
    << "Sampling rate:      " << sampling    << std::endl
    << "output files root:  " << sampling_file_root << std::endl
    << "symmetry group:            " << fn_sym << std::endl
    //<< "symmetry order:     " << sym_order << std::endl
    << "neighborhood:       " << neighborhood << std::endl
    << "max_tilt_angle:     " << max_tilt_angle << std::endl
    << "min_tilt_angle:     " << min_tilt_angle << std::endl
    ;
}

usage()

void Prog_Sampling_Parameters::usage

(

)

Usage message. This function shows the way of introdustd::cing this parameters.

Definition at line 51 of file precompute_sampling.cpp.

{
    std::cerr << "precompute_sampling\n"
    << "   -o root_file_name           : Root for output files\n"
    << "  [-sym cn]   :One of the 17 possible symmetries in\n"
    << "                                single particle electronmicroscopy\n"
    << "                                i.e.  ci, cs, cn, cnv, cnh, sn, dn, dnv, dnh, t, td, th, o, oh, i, ih\n"
    << "                               : where n may change from 1 to 99\n"
    << "  [-sampling_rate 5]           : Distance in degrees between sampling points\n"
    << "  [-neighborhood 1]            : A sampling point is neighbor if closer than this value in degrees\n"
    << "  [-max_tilt_angle <t=0>]      : maximum tilt angle in degrees\n"
    << "  [-min_tilt_angle <t=-180>]   : minimum tilt angle in degrees\n"
    << "\n"
    << "Example of use: Sample at 2degres and compute neighboor at "
    << " 5 degrees for c6 symmetry\n"
    << "   xmipp_precompute_sampling -o out -sym c6 "
    << " -sampling_rate 2 -neighborhood 5 -max_tilt_angle 70 "
    << " -min_tilt_angle 50 \n"
    ;
}

Member Data Documentation

fn_sym

FileName Prog_Sampling_Parameters::fn_sym

Symmetry. One of the 17 possible symmetries in single particle electron microscopy. See details at url Possible values are: c1, ci, cs, cn, cnv, cnh, sn, dn, dnv, dnh, t, td, th, o, oh, i, ih

Definition at line 61 of file precompute_sampling.h.

max_tilt_angle

double Prog_Sampling_Parameters::max_tilt_angle

fil vector with symmetry axis maximun tilt angle

Definition at line 73 of file precompute_sampling.h.

min_tilt_angle

double Prog_Sampling_Parameters::min_tilt_angle

minimum tilt angle

Definition at line 76 of file precompute_sampling.h.

mysampling

Sampling Prog_Sampling_Parameters::mysampling

sampling object

Definition at line 44 of file precompute_sampling.h.

neighborhood

double Prog_Sampling_Parameters::neighborhood

A sampling point is neighbor if closer than this value in degrees

Definition at line 50 of file precompute_sampling.h.

sampling

double Prog_Sampling_Parameters::sampling

Sampling rate. Distance between sampling points in degrees

Definition at line 47 of file precompute_sampling.h.

sampling_file_root

std::string Prog_Sampling_Parameters::sampling_file_root

root for output files

Definition at line 54 of file precompute_sampling.h.

sym_order

int Prog_Sampling_Parameters::sym_order

For infinite groups symmetry order

Definition at line 67 of file precompute_sampling.h.

symmetry

int Prog_Sampling_Parameters::symmetry

1-17 symmetry grouips

Definition at line 64 of file precompute_sampling.h.

---

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

• xmipp/libraries/reconstruction/precompute_sampling.h
• xmipp/libraries/reconstruction/precompute_sampling.cpp