selfile.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 SELFILE_H
#define SELFILE_H

#include <string>
#include <vector>

#include <core/xmipp_funcs.h>
#include <core/xmipp_image.h>

// Forward declaration
class SelFile;



class SelLine
{
public:
    typedef enum
    {
        DISCARDED = -1,
        ACTIVE = 1
    } Label;

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

private:
    Line_Type line_type;
    std::string text;
    Label label;
    int number;

    friend class SelFile;

public:
    SelLine() : line_type(NOT_ASSIGNED)
    {}

    void assign(const SelLine& line);

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

    short get_label()
    {
        return label;
    }

    int get_number()
    {
        return number;
    }

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

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

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

    void set_number(int n)
    {
        number = n;
    }

    friend bool operator<(const SelLine& l1, const SelLine& l2);

    friend SelFile compare(SelFile& SF1, SelFile& SF2, const int mode);
    friend std::vector< SelLine >::iterator find(std::vector< SelLine >& text,
            const std::string& img_name);

    friend std::ostream& operator<<(std::ostream& o, const SelLine& line);

    friend std::istream& operator>>(std::istream& i, SelLine& lin);
};

class SelFile
{
    // Filename of the .sel
    FileName fn_sel;

    // The whole file is inside
    std::vector< SelLine > text_line;

    // Number of valid images
    int no_imgs;

    // Pointer to current line
    std::vector< SelLine >::iterator current_line;

    // Find a specific image name in a list of sellines
    std::vector< SelLine >::iterator find(const std::string& img_name);

    // Move the current_line to the next line with this label
    void adjust_to_label(SelLine::Label label);
public:


    SelFile();

    SelFile(const FileName &name)
    {
        read(name);
    }

    void reserve(int n)
    {
        text_line.reserve(n);
        current_line = text_line.begin();
    }

    void clear();



    void assign(const SelFile& sel);

    friend std::ostream& operator<<(std::ostream& o, const SelFile& sel);



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

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

    void merge(const FileName& name);

    void merge(SelFile& sel);

    SelFile operator+(SelFile& sel);

    void split_in_two(SelFile& sel1, SelFile& sel2);

    void split_in_N(int N, std::vector< SelFile >& parts);

    void mpi_select_part(int rank, int size, int& num_img_tot);

    void mpi_select_part2(int rank, int size, int& num_img_tot,int mpi_job_size);

    void chooseSubset(int firstImage, int lastImage, SelFile &SFsubset);

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



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

    void go_first_ACTIVE()
    {
        go_beginning();
        adjust_to_label(SelLine::ACTIVE);
    }

    const std::string& operator()(int i)
    {
        return text_line[i].text;
    }

    const std::string& NextImg(SelLine::Label label = SelLine::ACTIVE);

    void next()
    {
        current_line++;
    }

    void jump(int count, SelLine::Label label = SelLine::ACTIVE);

    bool jump_lines(int count);

    void search(const std::string& img_name)
    {
        current_line = find(img_name);
    }

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



    FileName name() const
    {
        return fn_sel;
    }

    int Is_ACTIVE() const
    {
        return current_line->Is_data() &&
               current_line->get_label() == SelLine::ACTIVE;
    }

    int Is_DISCARDED() const
    {
        return current_line->Is_data() &&
               current_line->get_label() == SelLine::DISCARDED;
    }

    int Is_COMMENT() const
    {
        return current_line->Is_comment();
    }

    const SelLine& current()
    {
        return *current_line;
    }

    void get_current(SelLine& _SL)
    {
        _SL = current();
    }

    int exists(const std::string& img_name)
    {
        return find(img_name) != text_line.end();
    }

    int ImgNo(SelLine::Label label = SelLine::ACTIVE) const;

    int LineNo();

    void ImgSize(int& Ydim, int& Xdim);

    FileName FileExtension();

    int MaxFileNameLength();

    const std::string get_current_file();

    SelLine get_current_line()
    {
        return *current_line;
    }

    const std::string get_file_number(int i);



    void remove(const std::string& img_name);

    void remove_current();

    void set(const std::string& img_name, SelLine::Label label);

    void set_current(SelLine::Label label);

    void set_current_filename(const FileName& fn_new);

    void insert(const std::string& img_name, SelLine::Label label = SelLine::ACTIVE);

    void insert(const SelLine& _selline);

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

    void clean();

    void clean_comments();



    SelFile sort_by_filenames();

    SelFile randomize();

    SelFile randomSubset(int subsetN, bool withReplacement=true);

    SelFile random_discard(int N);

    friend SelFile compare(SelFile& SF1, SelFile& SF2, const int mode);
};
#endif