image_parser.hpp

#ifndef IMAGE_PARSER_HPP
#define IMAGE_PARSER_HPP

#include "executable.hpp"
#include "my_mkl.hpp"

class Bild;
class palette;


class abstract_image_parser: public loadable_Object
{
public:
    typedef STD_TR1::shared_ptr<abstract_image_parser> ref;
    typedef STD_TR1::shared_ptr<const abstract_image_parser> const_ref;

    ~abstract_image_parser() throw() {};

    void process_image( MPI_Comm comm,
            const Bild& b,
            const std::string& file_id);

//    struct process{
//  process( const Bild& bb, const std::string& s):
//      b(bb), name(s){};
//
//  void operator()( const STD_TR1::shared_ptr<abstract_image_parser>& p)
//      { p->process_image(b,name);}
//    private:
//  process();
//  
//  const Bild& b;
//  std::string name;
//    };

private:
    virtual void process_image_( MPI_Comm comm,
                 const Bild&, 
                 const std::string&) = 0;
};


class image_manipulator: public abstract_image_parser
{
public: 
    ~image_manipulator() throw() {};
private:
    STD_TR1::shared_ptr< std::list< STD_TR1::shared_ptr<abstract_image_parser> > >
       processors;

    void process_image_( MPI_Comm comm,
             const Bild&,
             const std::string&);

    virtual std::unique_ptr<Bild> altered_image_( const Bild& ) = 0;

    void init();

    virtual const char* filename_addition_() const = 0;

    virtual void init_manipulator_() = 0;
};


class Crop_image: public image_manipulator
{
public:
    ~Crop_image() throw() {};

private:
    double x_min, x_max, y_min, y_max;

    const char* name() const { return "crop_image";};
    
    const char* filename_addition_() const { return "cropped";};

    std::unique_ptr<Bild> altered_image_( const Bild& );
    
    void init_manipulator_();
};


class Blur_image: public image_manipulator
{
public:
    ~Blur_image() throw() {};

private:
    int radius;

    const char* name() const { return "blur_image";};
    
    const char* filename_addition_() const { return "blured";};

    std::unique_ptr<Bild> altered_image_( const Bild& );
    
    void init_manipulator_();
};


class EraseBorder_image: public image_manipulator
{
public:
    ~EraseBorder_image() throw() {};

private:
    int border;
    int radius;
    bool rectangular;
    bool renorm;

    void erase_rectangular(Bild& fb);
    void erase_circular(Bild& fb);
    void renorm_image(Bild& fb);

    const char* name() const { return "erase_border_image";};
    
    const char* filename_addition_() const { return "erasedborder";};

    std::unique_ptr<Bild> altered_image_( const Bild& );
    
    void init_manipulator_();
};


class participation_ratio_processor: public abstract_image_parser
{
public:
    ~participation_ratio_processor() throw() {};

private:
    int nx_min;
    int nx_max;

    const char* name() const { return "PPR_image";};
    void init();
    virtual void process_image_( MPI_Comm,
                 const Bild&, 
                 const std::string&);
};


class spread_processor: public abstract_image_parser
{
public:
    ~spread_processor() throw() {};

private:
    int nx_min;
    int nx_max;

    const char* name() const { return "spread_image";};
    void init();
    virtual void process_image_( MPI_Comm,
                 const Bild&, 
                 const std::string&);
};


class ascii_image_processor: public abstract_image_parser
{
public:    
    ~ascii_image_processor() throw() {};
private:
    char fill_char;

    bool write_imag;

    const char* name() const { return "ascii_image";};
    void init();

    void process_image_( MPI_Comm,
             const Bild& b, 
                         const std::string& filen );

    bool check_state_id( const Bild& b);

};

class sum_image_processor: public abstract_image_parser{
public:
    ~sum_image_processor() throw() {};
    
    const Bild& get_current_image() const;

    void reset_current_image();

    void synchronize_threads(MPI_Comm);

    size_t count() const { return c;};

    typedef STD_TR1::shared_ptr<sum_image_processor> ref;
    typedef STD_TR1::shared_ptr<const sum_image_processor> const_ref;

private:
    std::vector<complex>::iterator start;
    std::vector<complex>::iterator end;

    std::vector<complex> coeffs;

    int do_absolute;

    size_t c;

    std::unique_ptr<Bild> data;

    const char* name() const { return "sum_images";};

    void init();

    void process_image_( MPI_Comm,
             const Bild& b,
             const std::string& filen );
};

class sum_image_writer: public executable_Object{
public:
    ~sum_image_writer() throw() {};

private:

    sum_image_processor::ref sip;


    STD_TR1::shared_ptr< std::list< abstract_image_parser::ref > >
                         my_image_parsers;


    const char* name() const { return "sum_image_writer";};
    void init();

    void setup_data_();
    
    void reinit_param(const std::string& param_name);

    void perform_(MPI_Comm comm);

    void post_process_(MPI_Comm comm);
};


class subtract_image_processor: public abstract_image_parser{
public:
    ~subtract_image_processor() throw() {};
    
    const Bild& get_current_image() const;

    void reset_current_image();

    size_t count() const { return c;};

    typedef STD_TR1::shared_ptr<subtract_image_processor> ref;
    typedef STD_TR1::shared_ptr<const subtract_image_processor> const_ref;

private:
    std::vector<complex>::iterator start;
    std::vector<complex>::iterator end;

    int c;

    double prop;

    int p_one,p_two;

    std::unique_ptr<Bild> final;

    const char* name() const { return "subtract_images";};

    void init();

    void process_image_( MPI_Comm,
             const Bild& b,
             const std::string& filen );
};

class subtract_image_writer: public executable_Object{
public:
    ~subtract_image_writer() throw() {};

private:

    subtract_image_processor::ref sip;

    STD_TR1::shared_ptr< std::list< STD_TR1::shared_ptr< abstract_image_parser> > >
         my_image_parsers;

    const char* name() const { return "subtract_image_writer";};
    void init();

    void setup_data_();
    
    void reinit_param(const std::string& param_name);

    void perform_(MPI_Comm comm);

    void post_process_(MPI_Comm);
};


class average_image_processor: public abstract_image_parser
{
public:    
    ~average_image_processor() throw() {};
private:

    bool x_cut;
    double min_y;
    double max_y;
    double min_x;
    double max_x;

    const char* name() const { return "average_image";};
    void init();

    void process_image_( MPI_Comm,
             const Bild& b, 
                         const std::string& filen );

    void make_x_cut(std::ofstream& ofs,
                    const Bild& b) const;
    void make_y_cut(std::ofstream& ofs,
                    const Bild& b) const;

};



class cut_image_processor: public abstract_image_parser
{
public:    
    ~cut_image_processor() throw() {};
private:

    bool x_cut;
    double cut;
    int mittel;  //the program takes the average of several cuts. mittel is the number of cuts taken for the average

    const char* name() const { return "cut_image";};
    void init();

    void process_image_( MPI_Comm,
             const Bild& b, 
             const std::string& filen );

    void make_x_cut(std::ofstream& ofs,
            const Bild& b) const;
    void make_y_cut(std::ofstream& ofs,
            const Bild& b) const;

};


class current_image_processor: public abstract_image_parser
{
public:    
    ~current_image_processor() throw() {};
private:


    const char* name() const { return "current_image";};
    void init();

    void process_image_( MPI_Comm,
             const Bild& b, 
             const std::string& filen );

};

class corrogation_image_processor: public abstract_image_parser
{
private:
    double min_border;

    const char* name() const { return "corrogation_image";};
    void init();

    void process_image_( MPI_Comm,
             const Bild& b, 
             const std::string& filen );
};

class correlation_image_processor: public abstract_image_parser
{
private:

    double norm;

    const char* name() const { return "correlation_image";};
    void init();

    void correlate(int, int, complex*, const Bild&) const;

    void process_image_( MPI_Comm,
             const Bild& b, 
             const std::string& filen );
};

class collect_image_processor: public abstract_image_parser{
public:
    ~collect_image_processor() throw() {};
    
    const Bild& get_image(size_t i) const;

    void reset_images();

    void synchronize_threads(MPI_Comm);

    size_t count() const { return size;};

    typedef STD_TR1::shared_ptr<collect_image_processor> ref;
    typedef STD_TR1::shared_ptr<const collect_image_processor> const_ref;
  typedef std::vector<  STD_TR1::shared_ptr<Bild> >::iterator iterator;

    iterator begin(){ return data.begin();}
    iterator end() { return data.end(); }

private:
    size_t size;

    std::vector< STD_TR1::shared_ptr<Bild> >  data;

    const char* name() const { return "collect_images";};

    void init();
    void process_image_( MPI_Comm,
             const Bild& b,
             const std::string& filen );
};

 class normalize_image_by_maximum: public image_manipulator{
public:
   ~normalize_image_by_maximum() throw() {};
  
private: 
   bool mark_max;
   std::vector<double> normalizations;
   int low_x,high_x;
   int low_y,high_y;
   const char * name() const { return "normalize_image_by_maximum";};
   void init_manipulator_();
   std::unique_ptr<Bild> altered_image_( const Bild& b );
   const char* filename_addition_() const { return "maxnorm";}; 
 };



class project_images: public executable_Object{
public:
  ~project_images() throw() {};
  
private:
  collect_image_processor::ref targets;
  collect_image_processor::ref basis;
  collect_image_processor::ref biorthogonal_basis;
  std::vector< std::vector<complex> > coefficients;
  size_t image_n;
  size_t basis_n;

  const char* name() const {return "project_images";};
  void init();
  void setup_data_();
  void reinit_param(const std::string& param_name);
  void perform_(MPI_Comm comm);
  void post_process_(MPI_Comm comm);
};

#endif