docfile.h

Go to the documentation of this file.

/***************************************************************************
* 
* Authors:     Carlos Oscar S. Sorzano (coss@cnb.csic.es)
*
* 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'
***************************************************************************/

#ifndef DOCFILE_H
#define DOCFILE_H

#include <vector>
#include <string>

#include <core/args.h>
#include <core/matrix1d.h>
#include <core/matrix2d.h>
#include <core/xmipp_image.h>
#include <core/metadata_vec.h>

// Forward declaration
class DocFile;



class DocLine
{
public:
    typedef enum
    {
        NOT_CONSIDERED = -1,
        NOT_ASSIGNED = 0,
        DATALINE = 1,
        COMMENT = 2
    } Line_Type;

private:
    Line_Type line_type;
    std::string text; 
    int key; //< key of this line
    std::vector< double > data; 

    friend class DocFile; 

public:


    DocLine() : line_type(NOT_ASSIGNED)
    {}



    double& operator[](size_t i);

    double operator[](size_t i) const;

    void set(size_t i, double val);

    void set(const Matrix1D< double >& v);



    std::string get_text()
    {
        return text;
    }

    int get_key() const
    {
        return key;
    }

    int get_no_components() const
    {
        if (line_type == DATALINE)
            return data.size();
        else
            return -1;
    }

    void clear();

    int Is_comment()
    {
        return line_type == COMMENT;
    }

    int Is_data()
    {
        return line_type == DATALINE;
    }

    void set_type(Line_Type _line_type)
    {
        line_type = _line_type;
    }

    friend std::ostream& operator<<(std::ostream& o, const DocLine& DL);

    void read(std::istream& i);
};

class DocFile
{
    FileName fn_doc; 
    std::vector< DocLine > m; 
    int no_lines; 
    int first_key; 
    std::vector< DocLine >::iterator current_line; 

    // Function to locate a given key within the docfile
    std::vector< DocLine >::iterator find(int _key);

public:


    DocFile(): fn_doc(""), no_lines(0), first_key(1)
    {
        current_line = m.begin();
    }

    DocFile(const FileName& doc_name)
    {
        first_key = 1;
        read(doc_name);
    }

    void clear();

    void reserve(int N)
    {
        m.reserve(N);
        current_line = m.begin();
    }



    DocFile& operator=(const Matrix2D< double >& A);

    friend std::ostream& operator<<(std::ostream& o, const DocFile& DF);

    void show_line(std::ostream& o, int key = -1);

    void debug();



    void read(const FileName& _name, int overrinding = 1);

    void append(const FileName &_name)
    {
        read(_name, 0);
    }

    void write(const FileName& _name = "");



    void go_beginning()
    {
        current_line = m.begin();
    }

    void go_first_data_line()
    {
        go_beginning();
        adjust_to_data_line();
    }

    void adjust_to_data_line();

    void next()
    {
        if (current_line != m.end())
            current_line++;
    }

    void previous()
    {
        if (current_line != m.begin())
            current_line--;
    }

    void next_data_line()
    {
        jump(1);
    }

    void jump(int how_many);

    void search(int _key)
    {
        current_line = find(_key);
    }

    int search_comment(std::string comment);

    int remove_multiple_strings(std::string pattern);

    void get_selfile(MetaData& SF);

    void locate(int _key);

    int eof()
    {
        return current_line == m.end();
    }



    std::string name() const
    {
        return fn_doc;
    }

    int exists(int _key)
    {
        return find(_key) != m.end();
    }

    int getColNumberFromHeader(const char * pattern);

        
    int FirstLine_colNumber();

    int dataLineNo() const
    {
        return no_lines;
    }

    int LineNo() const
    {
        return m.size();
    }

    int get_last_key();

    int get_current_key()
    {
        return (*current_line).key;
    }

    int FirstKey() const
    {
        return first_key;
    }

    void set_FirstKey(int _first_key)
    {
        first_key = _first_key;
    }

    int get_current_valNo() const
    {
        return (*current_line).data.size();
    }

    double operator()(int i) const
    {
        return (*current_line)[i];
    }

    double operator()(int _key, int i);

    void get_angles(int _key,
                    double& rot,
                    double& tilt,
                    double& psi,
                    const std::string& ang1,
                    const std::string& ang2,
                    const std::string& ang3);

    void get_angles1(int _key,
                     double& rot,
                     double& tilt,
                     double& psi,
                     const std::string& ang1,
                     const std::string& ang2,
                     const std::string& ang3);

    void get_angles2(int _key,
                     double& rot,
                     double& tilt,
                     double& psi,
                     const std::string& ang1,
                     const std::string& ang2,
                     const std::string& ang3);

    void set_angles(int _key,
                    double rot,
                    double tilt,
                    double psi,
                    const std::string& ang1,
                    const std::string& ang2,
                    const std::string& ang3);

    void get_image(int key, Image<double> &I, bool apply_geo=false);

    FileName get_imagename(int key);

    void set(int i, double val);

    void set(int _key, int i, double val);

    DocLine get_current_line()
    {
        return *current_line;
    }



    void renum();

    void remove(int _key0, int _keyF = -1);

    void remove_current();

    int insert_data_line(int no_lines_to_insert = 1);

    int insert_data_line(const Matrix1D< double >& v);

    void insert_comment(std::string comment);

    int insert_line(const DocLine& DL);

    int append_data_line(int no_lines_to_append = 1);

    int append_data_line(const Matrix1D< double >& v);

    int append_angles(double rot,
                      double tilt,
                      double psi,
                      const std::string& ang1,
                      const std::string& ang2,
                      const std::string& ang3);

    int append_angles(double rot,
                      double tilt,
                      double psi,
                      double rot1,
                      double tilt1,
                      double psi1,
                      const std::string& ang1,
                      const std::string& ang2,
                      const std::string& ang3);

    int append_angles(double rot,
                      double tilt,
                      double psi,
                      double rot1,
                      double tilt1,
                      double psi1,
                      double rot2,
                      double tilt2,
                      double psi2,
                      const std::string& ang1,
                      const std::string& ang2,
                      const std::string& ang3);

    void append_comment(const std::string& comment);

    int append_line(DocLine& DL);

    void clean_comments();



    DocFile randomize();

    void perturb_column(int col, double sigma);

#define DOCMERGE_KEEP_OLD 1
#define DOCMERGE_KEEP_NEW 2
#define DOCMERGE_SUM_COLUMN 3
#define DOCMERGE_ERROR 4

    void merge(const FileName& name, int mode=DOCMERGE_KEEP_OLD, int sumcol=5);

    void merge(DocFile& DF, int mode=DOCMERGE_KEEP_OLD, int sumcol=5);

    DocFile random_discard(int N);

    Matrix1D< double > col(int _col);

    Matrix1D< double > row(int _key);

    void setCol(int _col, Matrix1D< double >& v);
};



int read_Euler_document_file(FileName fn,
                             std::string ang1,
                             std::string ang2,
                             std::string ang3,
                             DocFile& DF);

void select_images(DocFile& DF,
                   MetaData& SF,
                   int col,
                   bool en_limit0,
                   double limit0,
                   bool en_limitF,
                   double limitF);

void get_subset_docfile(DocFile& DFin,
            MetaData& SF,
            DocFile& DFout);

#endif