sampling.h

Go to the documentation of this file.

/***************************************************************************
 *
 * Authors:     Roberto Marabini
 *
 * Unidad de  Bioinformatica of Centro Nacional de Biotecnologia , CSIC
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 * 02111-1307  USA
 *
 *  All comments concerning this program package may be sent to the
 *  e-mail address 'xmipp@cnb.csic.es'
 ***************************************************************************/
/* This file contains functions related to the SAMPLING Transform */

#ifndef _SAMPLING1_HH
#define _SAMPLING1_HH
#include <vector>
#include "core/matrix1d.h"
#include "core/symmetries.h"

class MetaData;

#define cte_w 1.107149

class Sampling
{
public:
    struct Vertex
    {
        double rot;
        double tilt;
        double psi;
    };

    typedef std::vector<Vertex> Vect_angles;

    Vect_angles vertices_angles;

    std::vector <Matrix1D<double> > vertices_vectors;

    double sampling_rate_rad;

    double sampling_noise;

    size_t number_of_samples;

    size_t numberSamplesAsymmetricUnit;

    double neighborhood_radius_rad;

    double cos_neighborhood_radius;

    std::vector<std::vector<size_t> >  my_neighbors;

    std::vector<std::vector<size_t> >  my_exp_img_per_sampling_point;

#ifdef MYPSI

    std::vector<std::vector<double> > my_neighbors_psi;
#endif

    std::vector<std::vector<double> > my_cross_correlation;

    std::vector <Matrix1D<double> > sampling_points_vector;
    std::vector <Matrix1D<double> > sampling_points_angles;
    std::vector <Matrix2D<double> > R_repository;
    std::vector <Matrix2D<double> > L_repository;
    std::vector <Matrix1D<double> > exp_data_projection_direction_by_L_R;
    std::vector <FileName > exp_data_fileNames;
#ifdef MYPSI

    std::vector <double > exp_data_projection_direction_by_L_R_psi;
#endif

    std::vector <Matrix1D<double> > no_redundant_sampling_points_vector;
    std::vector <Matrix1D<double> > no_redundant_sampling_points_angles;
    std::vector <size_t> no_redundant_sampling_points_index;

    int verbose;

    Sampling();

    bool operator==(const Sampling& op) const;

    FileName symmetry_file;

    SymList  SL;

    void computeSamplingPoints(bool only_half_sphere = true,
                                 double max_tilt= 180,
                                 double min_tilt= 0);
    void fillEdge(const Matrix1D<double> &starting_point,
                const Matrix1D<double> &ending_point,
                std::vector <Matrix1D<double> > &edge_vector,
                   bool FLAG_END
                  );
    void fillDistance(const Matrix1D<double> &starting_point,
                       const Matrix1D<double> &ending_point,
                       std::vector <Matrix1D<double> > &edge_vector,
                       int number,
                       bool only_half_spheree,
                       double min_z= -10.,
                       double max_z= +10.
                      );
    void fillLRRepository(void);

    void setSampling(double sampling);

    void setNoise(double deviation, int my_seed=-1);

    void setNeighborhoodRadius(double neighborhood);

    /* eliminate redundant points,
        symmetry group, symmetry order */
    void removeRedundantPoints(const int symmetry, int sym_order);

    /* eliminate redundant points,
        symmetry group, symmetry order 
        This function first calls removeRedundantPoints,
        and then checks each point versus all others to calculate an angular distance
        If this distance is less than 0.8 times the angular sampling, the point is deleted
    */
    void removeRedundantPointsExhaustive(const int symmetry,
                                            int sym_order,
                                            bool only_half_sphere,
                                            double max_ang);

    /* sorting criteria for euler angles */
    int sortFunc(const Matrix1D<double> & a, const Matrix1D<double> & b);

    void createSymFile(const FileName &simFp,int  symmetry, int sym_order);

    void createAsymUnitFile(const FileName& docfilename);

    void computeNeighbors(bool only_winner=false);

    void saveSamplingFile(const FileName &fn_base, bool write_vectors = true, bool write_sampling_sphere = false);

    void readSamplingFile(const FileName &infilename,bool read_vectors=true, bool read_sampling_sphere = false);

    void removePointsFarAwayFromExperimentalData();

    void findClosestSamplingPoint(const MetaData &DFi,
                                     const FileName &output_file_root);

    void findClosestSamplingPoint(const FileName &FnexperimentalImages,
                                     const FileName &output_file_root);

    void findClosestExperimentalPoint();

    void fillExpDataProjectionDirectionByLR(const MetaData &DFi);

    void fillExpDataProjectionDirectionByLR(const FileName &FnexperimentalImages);
};
#endif