pipeline.h

Go to the documentation of this file.

/****************************************************************************************
 * SCYLLARUS : C++ HYPERSPECTRAL PROCESSING LIBRARY
 * pipeline.h - Hyperspectral Image processing pipeline helper object
 *
 * This computer code is subject to copyright:
 * (c) National ICT Australia Limited (NICTA) 2013-2014 All Rights Reserved.
 *
 * Jeremy Oorloff, National ICT Australia (NICTA)
 *
 ***************************************************************************************/

#ifndef PIPELINE_H_
#define PIPELINE_H_

#include <armadillo>
#include <memory>
#include <iso646.h>

#include "input/input.h"
#include "input/data_input.h"
#include "output/output.h"
#include "spectral_library.h"
#include "illuminant.h"
#include "dichromatic.h"
#include "material.h"
#include "scylver.h"

namespace scyl
{

class pipeline
{


public:

    pipeline();                                         // For pipeline with no input or output object

    pipeline(std::shared_ptr<scyl::input>  input);    // Use a pipeline with a pre-constructed input object

    pipeline(std::shared_ptr<scyl::output> output);   // Use a pipeline with a pre-constructed output object

    pipeline(std::shared_ptr<scyl::input>  input,
             std::shared_ptr<scyl::output> output);   // Use a pipeline with a pre-constructed input and output object

    virtual ~pipeline();

    // Process functions (overall and individual steps)

    void process(bool clear=true);

    void process_recover_illuminant(bool clear=true);

    void process_recover_dichromatic_parameters();

    void process_recover_materials();

    void process_recover_endmembers();

    void process_classification(scyl::CLASSIFICATION_METHOD method=scyl::CLASSIFICATION_SAM);

    void process_analysis(bool reflectance=true);

    // Cleaning functions

    void clear_results(bool reflectance=false);

    void clear_illuminant_results();

    void clear_dichromatic_results();

    void clear_material_results();

    void clean_input(bool reflectance=false);



    void save(std::string filename);

    // Image manipulation routines (for I)

    void crop(int x0, int y0, int x1, int y1, bool reflectance=false);

    void remove_bands(arma::uvec remove, bool reflectance=false);

    void resize(int height, int width, bool reflectance=false);

    void align_bands();

    void filter(scyl::FILTER_METHOD method=scyl::FILTER_WIENER, int size=5, bool reflectance=false);

    // Setters and Getters

    void set_input(std::shared_ptr<scyl::input> in);
    std::shared_ptr<scyl::input> input();

    void set_output(std::shared_ptr<scyl::output> in);
    std::shared_ptr<scyl::output> output();

    void set_spectral_library(const std::shared_ptr<scyl::spectral_library> in);
    std::shared_ptr<scyl::spectral_library> spectral_library();


    void        set_I(const arma::fcube & in, const arma::fvec & wavelengths, bool   clean=true);
    arma::fcube I() const;
    const arma::fcube * I_ptr() const;

    void        set_illuminant(const arma::fvec & in);
    arma::fvec  illuminant() const;

    void        set_wavelengths(const arma::fvec & in);
    arma::fvec  wavelengths() const;

    void        set_k(const arma::fmat & in);
    arma::fmat  k() const;

    void        set_g(const arma::fmat & in);
    arma::fmat  g() const;

    void        set_k_factor(const float & in);
    float       k_factor() const;

    void        set_s(const arma::fcube & in, const arma::fvec & wavelengths, bool   clean=true);
    arma::fcube s() const;
    const arma::fcube * s_ptr() const;

    void        set_patches(const arma::umat & in);
    arma::umat  patches() const;

    void        set_material_elements(const arma::fmat & in);
    arma::fmat  material_elements() const;

    void        set_material_element_abundances(const arma::fcube & in);
    arma::fcube material_element_abundances() const;

    void        set_material_element_abundance_indexes(const arma::ucube & in);
    arma::ucube material_element_abundance_indexes() const;

    void        set_material_map(const arma::umat & in);
    arma::umat  material_map() const;

    void        set_endmember_abundances(const arma::fmat & in);
    arma::fmat  endmember_abundances() const;

    void        set_endmember_abundance_indexes(const arma::umat & in);
    arma::umat  endmember_abundance_indexes() const;

    void        set_classification_abundances(const arma::fcube & in);
    arma::fcube classification_abundances() const;

    void        set_classification_indexes(const arma::ucube & in);
    arma::ucube classification_indexes() const;

    void        set_analysis_components(const arma::fcube & in);
    arma::fcube analysis_components()  const;

    void        set_analysis_values(const arma::fvec & in);
    arma::fvec  analysis_values() const;

    // Properties Setters and Getters

    int height() const;
    int width()  const;
    int bands()  const;

    bool endmember_indexed() const;

    bool is_filtered() const;

    void  set_illuminant_method(scyl::ILLUMINANT_METHOD in);
    scyl::ILLUMINANT_METHOD  illuminant_method() const;

    void  set_dichromatic_method(scyl::DICHROMATIC_METHOD in);
    scyl::DICHROMATIC_METHOD  dichromatic_method() const;

    void  set_debug_level(int in);
    int   debug_level() const;

    void  set_illuminant_recovery_alpha(float in);
    float illuminant_recovery_alpha() const;

    void  set_illuminant_patch_size(int in);
    int   illuminant_patch_size() const;

    void  set_illuminant_fast_50(bool in);
    bool   illuminant_fast_50() const;

    void  set_dichromatic_neighbourhood_size(int in);
    int   dichromatic_neighbourhood_size() const;

    void  set_dichromatic_gray_threshold(int in);
    int   dichromatic_gray_threshold() const;

    void  set_material_method(scyl::MATERIAL_METHOD in);
    scyl::MATERIAL_METHOD material_method() const;

    void  set_material_max_clusters(int in);
    int   material_max_clusters() const;

    void  set_material_temperature_max(float in);
    float material_temperature_max() const;

    void  set_material_temperature_min(float in);
    float material_temperature_min() const;

    void  set_material_cooling_rate(float in);
    float material_cooling_rate() const;

    void  set_material_split_threshold(float in);
    float material_split_threshold() const;

    void  set_material_subsample(float in);
    float material_subsample() const;

    void  set_abundance_num_materials(int in);
    int   abundance_num_materials() const;

    void  set_analysis_num(int in);
    int   analysis_num() const;

    void  set_nurbs_save_as(bool in);
    bool  nurbs_save_as() const;

    void  set_nurbs_degree(int in);
    int   nurbs_degree() const;

    void  set_nurbs_iterations(int in);
    int   nurbs_iterations() const;

    void  set_nurbs_knot_threshold(int in);
    int   nurbs_knot_threshold() const;

    void  set_nurbs_alpha(float in);
    float nurbs_alpha() const;


private:

    // Member Variables

    std::shared_ptr<scyl::input>  m_input;                      
    std::shared_ptr<scyl::output> m_output;                     
    bool             m_use_input;                               

    bool             m_use_output;                              

    arma::fcube      m_I;                                       

    arma::fvec       m_illuminant;                              

    arma::fvec       m_wavelengths;                             
    arma::fmat       m_k;                                       

    arma::fmat       m_g;                                       

    float            m_k_factor;                                

    arma::fcube      m_s;                                       

    arma::fmat       m_material_elements;                       
    arma::fcube      m_material_element_abundances;             
    arma::ucube      m_material_element_abundance_indexes;      
    arma::umat       m_material_map;                            
    std::shared_ptr<scyl::spectral_library> m_spectral_library; 
    arma::fmat       m_endmember_abundances;                    
    arma::umat       m_endmember_abundance_indexes;             

    arma::fcube      m_classification_abundances;               
    arma::ucube      m_classification_indexes;                  
    arma::fcube      m_analysis_components;                     
    arma::fvec       m_analysis_values;                         

    // General Properties

    unsigned int m_height;                                      
    unsigned int m_width;                                       
    unsigned int m_bands;                                       

    int m_debug_level;                                          

    // Illuminant Recovery Properties

    scyl::ILLUMINANT_METHOD  m_illuminant_method;               
    scyl::illuminant_options m_illuminant_options;              

    // Dichromatic Parameter Recovery Properties

    scyl::DICHROMATIC_METHOD m_dichromatic_method;              
    int                      m_dichromatic_neighbourhood_size;  
    int                      m_dichromatic_gray_threshold;      


    // Material Recovery Parameters

    scyl::MATERIAL_METHOD m_material_method;                    
    scyl::material_options m_material_options;                  

    // Generate Abundances Parameters

    int                   m_abundance_num_materials;            
    int                   m_analysis_num;                       

    // NURBS Parameters

    bool                  m_nurbs_save_as;                      
    int                   m_nurbs_degree;                       
    int                   m_nurbs_iterations;                   
    int                   m_nurbs_knot_threshold;               
    float                 m_nurbs_alpha;                        

    // Flags

    bool                  m_filtered;                           
};
}
#endif /* PIPELINE_H_ */