HologramGenerator.h

Go to the documentation of this file.

/*
  @section setup How to Install a sample program
  After installing, user can execute the sample program without building the sources and installing Qt & Visual Studio.
  1. Download 'Setup.zip' file from the directory, 'Setup' - setup.exe & Setup.msi
  2. Upzip the zip file.
  3. Execute 'setup.exe'.
  4. Then, the setup process installs a sample program.
  5. User can specify the position that the program is installed.
  6. After finishing the installation, user can find an execution file, 'HologramDepthmap.exe' under the installed directory.
  7. To reinstall the program, first remove the installed program using control panel.
*/

#ifndef __Hologram_Generator_h
#define __Hologram_Generator_h

#include <graphics/vec.h>
#include <graphics/complex.h>
#include <QtCore/QDir>
#include <QtCore/QFile>
#include <QtGui/QImage>
#include <QtWidgets/qmessagebox.h>
#include <vector>
#include <cufft.h>
#include "Hologram/fftw3.h"

using namespace graphics;

struct HologramParams{
    
    double              field_lens;                 
    double              lambda;                     
    double              k;                          
    ivec2               pn;                         
    vec2                pp;                         
    vec2                ss;                         

    double              near_depthmap;              
    double              far_depthmap;               
    
    uint                num_of_depth;               

    std::vector<int>    render_depth;               
};

class HologramGenerator {

public:

    HologramGenerator();
    ~HologramGenerator();
    
    void setMode(bool isCPU);

    bool readConfig();

    void initialize();
    
    void GenerateHologram();

    void ReconstructImage();

    //void writeMatFileComplex(const char* fileName, Complex* val);                         
    //void writeMatFileDouble(const char* fileName, double * val);
    //bool readMatFileDouble(const char* fileName, double * val);

private:

    void init_CPU();   
    void init_GPU();
    bool ReadImageDepth(int ftr);
    bool prepare_inputdata_CPU(uchar* img, uchar* dimg);
    bool prepare_inputdata_GPU(uchar* img, uchar* dimg);
    void GetDepthValues();
    void change_depth_quan_CPU();
    void change_depth_quan_GPU();
    void TransformViewingWindow();
    void Calc_Holo_by_Depth(int frame);
    void Calc_Holo_CPU(int frame);
    void Calc_Holo_GPU(int frame);
    void Propagation_AngularSpectrum_CPU(Complex* input_u, double propagation_dist);
    void Propagation_AngularSpectrum_GPU(cufftDoubleComplex* input_u, double propagation_dist);
    void Encoding_Symmetrization(ivec2 sig_location);
    void encoding_CPU(int cropx1, int cropx2, int cropy1, int cropy2, ivec2 sig_location);
    void encoding_GPU(int cropx1, int cropx2, int cropy1, int cropy2, ivec2 sig_location);
    void Write_Result_image(int ftr);
    void get_rand_phase_value(Complex& rand_phase_val);
    void get_shift_phase_value(Complex& shift_phase_val, int idx, ivec2 sig_location);

    void fftwShift(Complex* src, Complex* dst, fftw_complex* in, fftw_complex* out, int nx, int ny, int type, bool bNomalized = false);
    void exponent_complex(Complex* val);
    void fftShift(int nx, int ny, Complex* input, Complex* output);

    //void writeIntensity_gray8_bmp(const char* fileName, int nx, int ny, double* intensity);
    //void writeIntensity_gray8_bmp(const char* fileName, int nx, int ny, Complex* complexvalue);
    //void writeIntensity_gray8_real_bmp(const char* fileName, int nx, int ny, Complex* complexvalue);
    //void writeImage_fromGPU(QString imgname, int pnx, int pny, cufftDoubleComplex* gpu_data);

    void Reconstruction(fftw_complex* in, fftw_complex* out);
    void Test_Propagation_to_Eye_Pupil(fftw_complex* in, fftw_complex* out);
    void Write_Simulation_image(int num, double val);
    void circshift(Complex* in, Complex* out, int shift_x, int shift_y, int nx, int ny);
private:

    bool                    isCPU_;                     

    unsigned char*          img_src_gpu_;               
    unsigned char*          dimg_src_gpu_;              
    double*                 depth_index_gpu_;           
    
    double*                 img_src_;                   
    double*                 dmap_src_;                  
    double*                 depth_index_;               
    int*                    alpha_map_;                 

    double*                 dmap_;                      
    
    double                  dstep_;                     
    std::vector<double>     dlevel_;                    
    std::vector<double>     dlevel_transform_;          
    
    Complex*                U_complex_;                 
    double*                 u255_fringe_;               

    HologramParams          params_;                    

    std::string             SOURCE_FOLDER;              
    std::string             IMAGE_PREFIX;               
    std::string             DEPTH_PREFIX;               
    std::string             RESULT_FOLDER;              
    std::string             RESULT_PREFIX;              
    bool                    FLAG_STATIC_IMAGE;          
    uint                    START_OF_FRAME_NUMBERING;   
    uint                    NUMBER_OF_FRAME;            
    uint                    NUMBER_OF_DIGIT_OF_FRAME_NUMBERING; 

    int                     Transform_Method_;          
    int                     Propagation_Method_;        
    int                     Encoding_Method_;           

    double                  WAVELENGTH;                 

    bool                    FLAG_CHANGE_DEPTH_QUANTIZATION; 
    uint                    DEFAULT_DEPTH_QUANTIZATION;     
    uint                    NUMBER_OF_DEPTH_QUANTIZATION;   
    bool                    RANDOM_PHASE;                   

    // for Simulation (reconstruction)
    //===================================================
    std::string             Simulation_Result_File_Prefix_; 
    int                     test_pixel_number_scale_;       
    vec2                    Pixel_pitch_xy_;                
    ivec2                   SLM_pixel_number_xy_;           
    double                  f_field_;                       
    double                  eye_length_;                    
    double                  eye_pupil_diameter_;            
    vec2                    eye_center_xy_;                 
    double                  focus_distance_;                
    int                     sim_type_;                      
    double                  sim_from_;                      
    double                  sim_to_;                        
    int                     sim_step_num_;                  
    double*                 sim_final_;                     
    Complex*                hh_complex_;                    

};


#endif