ophGen.h

Go to the documentation of this file.

/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install, copy or use the software.
//
//
//                           License Agreement
//                For Open Source Digital Holographic Library
//
// Openholo library is free software;
// you can redistribute it and/or modify it under the terms of the BSD 2-Clause license.
//
// Copyright (C) 2017-2024, Korea Electronics Technology Institute. All rights reserved.
// E-mail : contact.openholo@gmail.com
// Web : http://www.openholo.org
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//  1. Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//  2. Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the copyright holder or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// This software contains opensource software released under GNU Generic Public License,
// NVDIA Software License Agreement, or CUDA supplement to Software License Agreement.
// Check whether software you use contains licensed software.
//
//M*/

#ifndef __ophGen_h
#define __ophGen_h

#include "Openholo.h"

#ifdef _WIN64
#ifdef GEN_EXPORT
#define GEN_DLL __declspec(dllexport)
#else
#define GEN_DLL __declspec(dllimport)
#endif
#else
#ifdef GEN_EXPORT
#define GEN_DLL __attribute__((visibility("default")))
#else
#define GEN_DLL
#endif
#endif

struct OphPointCloudConfig;
struct OphPointCloudData;
struct OphDepthMapConfig;
struct OphMeshData;
struct OphWRPConfig;

class GEN_DLL ophGen : public Openholo
{
public:
    enum PRECISION {
        SINGLE,
        DOUBLE,
    };

    enum ENCODE_FLAG {
        ENCODE_PHASE,
        ENCODE_AMPLITUDE,
        ENCODE_REAL,
        ENCODE_IMAGINARY,
        ENCODE_SIMPLENI,
        ENCODE_BURCKHARDT,
        ENCODE_TWOPHASE,
        ENCODE_SSB,
        ENCODE_OFFSSB,
        ENCODE_SIMPLEBINARY,
        ENCODE_EDBINARY
    };

public:
    explicit ophGen(void);

protected:
    virtual ~ophGen(void) = 0;

public:
    Real** getEncodedBuffer(void) { return m_lpEncoded; }
    uchar** getNormalizedBuffer(void) { return m_lpNormalized; }

    void initialize(void);

    int loadPointCloud(const char* pc_file, OphPointCloudData *pc_data_);

    bool readConfig(const char* fname);

    void RS_Diffraction(Point src, Complex<Real> *dst, Real lambda, Real distance, Real amplitude);

    void Fresnel_Diffraction(Point src, Complex<Real> *dst, Real lambda, Real distance, Real amplitude);

    void Fresnel_FFT(Complex<Real> *src, Complex<Real> *dst, Real lambda, Real distance);


    void AngularSpectrumMethod(Complex<Real>* src, Complex<Real>* dst, Real lambda, Real distance);

    void conv_fft2(Complex<Real>* src1, Complex<Real>* src2, Complex<Real>* dst, ivec2 size);


    void normalize(void);

    bool save(const char* fname, uint8_t bitsperpixel = 8, uchar* src = nullptr, uint px = 0, uint py = 0);

    void* load(const char* fname);

    virtual bool loadAsOhc(const char *fname);

protected:
    bool save(const char* fname, uint8_t bitsperpixel, uint px, uint py, uint fnum, uchar* args ...);

    void resetBuffer();


public:
    void setPrecision(uint precision) { m_precision = precision; }
    uint getPrecision() { return m_precision; }

    void setEncodeMethod(unsigned int ENCODE_FLAG) { ENCODE_METHOD = ENCODE_FLAG; }

    //void encoding(unsigned int ENCODE_FLAG, Complex<Real>* holo = nullptr);
    void encoding(unsigned int ENCODE_FLAG);
    void encoding(unsigned int ENCODE_FLAG, Complex<Real>* holo, Real* encoded);
    //template<typename T>
    //void encoding(unsigned int ENCODE_FLAG, Complex<T>* holo = nullptr, T* encoded = nullptr);

    void encoding();
    /*
    * @brief    Encoding Functions
    * @details
    *    ENCODE_SSB     :   Single Side Band Encoding@n
    *    ENCODE_OFFSSB  :   Off-axis + Single Side Band Encoding@n
    * @param[in] ENCODE_FLAG encoding method.
    * @param[in] SSB_PASSBAND shift direction.
    * @param[in] holo buffer to encode.
    * @overload
    */
    virtual void encoding(unsigned int ENCODE_FLAG, unsigned int SSB_PASSBAND, Complex<Real>* holo = nullptr, Real* encoded = nullptr);
    enum SSB_PASSBAND { SSB_LEFT, SSB_RIGHT, SSB_TOP, SSB_BOTTOM };

    void encoding(unsigned int BIN_ENCODE_FLAG, unsigned int ENCODE_FLAG, Real threshold, Complex<Real>* holo = nullptr, Real* encoded = nullptr);

public:

    bool Shift(Real x, Real y);
    void waveCarry(Real carryingAngleX, Real carryingAngleY, Real distance);

    void waveCarry(Complex<Real>* src, Complex<Real>* dst, Real wavelength, int carryIdxX, int carryIdxY);
protected:
    ivec2                   m_vecEncodeSize;
    int                     ENCODE_METHOD;
    int                     SSB_PASSBAND;
    Real                    m_elapsedTime;
    Real**                  m_lpEncoded;
    uchar**                 m_lpNormalized;

private:
    uint                    m_nOldChannel;
    uint                    m_precision;

protected:
    Real                    m_dFieldLength;
    int                     m_nStream;
    unsigned int            m_mode;

public:
    void transVW(int nVertex, Vertex *dst, Vertex *src);
    void transVW(int nVertex, Real *dst, Real *src);
    int getStream() { return m_nStream; }
    Real getFieldLength() { return m_dFieldLength; }
    ivec2& getEncodeSize(void) { return m_vecEncodeSize; }

    void setResolution(ivec2 resolution);

    Real getElapsedTime() { return m_elapsedTime; };

protected:
    template <typename T>
    void RealPart(Complex<T>* holo, T* encoded, const int size);
    template <typename T>
    void ImaginaryPart(Complex<T>* holo, T* encoded, const int size);
    template <typename T>
    void Phase(Complex<T>* holo, T* encoded, const int size);
    template <typename T>
    void Amplitude(Complex<T>* holo, T* encoded, const int size);
    template <typename T>
    void TwoPhase(Complex<T>* holo, T* encoded, const int size);
    template <typename T>
    void Burckhardt(Complex<T>* holo, T* encoded, const int size);
    template <typename T>
    void SimpleNI(Complex<T>* holo, T* encoded, const int size);

    void singleSideBand(Complex<Real>* holo, Real* encoded, const ivec2 holosize, int passband);

    void freqShift(Complex<Real>* holo, Complex<Real>* encoded, const ivec2 holosize, int shift_x, int shift_y);


public:
    enum ED_WType { FLOYD_STEINBERG, SINGLE_RIGHT, SINGLE_DOWN, ITERATIVE_DESIGN };
    bool saveRefImages(char* fnameW, char* fnameWC, char* fnameAS, char* fnameSSB, char* fnameHP, char* fnameFreq, char* fnameReal, char* fnameBin, char* fnameReconBin, char* fnameReconErr, char* fnameReconNo);

protected:
    Complex<Real>* AS;
    Complex<Real>* normalized;
    Complex<Real>* fftTemp;
    Real* weight;
    Complex<Real>* weightC;
    Complex<Real>* freqW;
    Real* realEnc;
    Real* binary;
    Real* maskSSB;
    Real* maskHP;
    bool m_bRandomPhase;

    bool binaryErrorDiffusion(Complex<Real>* holo, Real* encoded, const ivec2 holosize, const int type, Real threshold);
    bool getWeightED(const ivec2 holosize, const int type, ivec2* pNw);
    bool shiftW(ivec2 holosize);
    void binarization(Complex<Real>* src, Real* dst, const int size, int ENCODE_FLAG, Real threshold);

    void CorrectionChromaticAberration(uchar* src, uchar* dst, int width, int height, int scaleFactor = 2);

    //public:
    //bool carrierWaveMultiplexingEncoding(char* dirName, uint ENCODE_METHOD, Real cenFxIdx, Real cenFyIdx, Real stepFx, Real stepFy, int nFx, int nFy);
    //bool carrierWaveMultiplexingEncoding(char* dirName, uint ENCODE_METHOD, uint PASSBAND, Real cenFxIdx, Real cenFyIdx, Real stepFx, Real stepFy, int nFx, int nFy);

    //protected:



public:
    void fresnelPropagation(Complex<Real>* in, Complex<Real>* out, Real distance, uint channel);
protected:
    void encodeSideBand(unsigned int passband);
    void encodeSideBand_CPU(int cropx1, int cropx2, int cropy1, int cropy2, ivec2 sig_location);

    void encodeSideBand_GPU(int cropx1, int cropx2, int cropy1, int cropy2, ivec2 sig_location);

    void getShiftPhaseValue(Complex<Real>& shift_phase_val, int idx, ivec2 sig_location);

    void GetRandomPhaseValue(Complex<Real>& rand_phase_val, bool rand_phase);

    void ScaleChange(Real *src, Real *dst, int nSize, Real scaleX, Real scaleY, Real scaleZ);
    void GetMaxMin(Real *src, int len, Real& max, Real& min);

public:
    void SetRandomPhase(bool bRandomPhase) { m_bRandomPhase = bRandomPhase; }

    bool GetRandomPhase() { return m_bRandomPhase; }
    void SetMode(unsigned int mode) { m_mode = mode; }
    unsigned int GetMode() { return m_mode; }



protected:

    virtual void ophFree(void);
};

struct GEN_DLL OphPointCloudConfig {
    vec3 scale;
    Real distance;
    int8_t* filter_shape_flag;
    vec2 filter_width;
    Real focal_length_lens_in;
    Real focal_length_lens_out;
    Real focal_length_lens_eye_piece;
    vec2 tilt_angle;

    OphPointCloudConfig()
        : scale(0.0, 0.0, 0.0), distance(0.0), filter_shape_flag(0), focal_length_lens_in(0.0), focal_length_lens_out(0.0), focal_length_lens_eye_piece(0.0), tilt_angle(0.0, 0.0)
    {}
};

struct GEN_DLL OphPointCloudData {
    ulonglong n_points;
    int n_colors;
    Vertex* vertices;

    OphPointCloudData() : n_points(0), n_colors(0), vertices(nullptr) {}
};

struct GEN_DLL OphDepthMapConfig {
    Real                fieldLength;
    Real                near_depthmap;
    Real                far_depthmap;
    uint                num_of_depth;
    vector<int>         render_depth;
    bool                change_depth_quantization;
    uint                default_depth_quantization;
    uint                num_of_depth_quantization;
    bool                random_phase;

    OphDepthMapConfig() :fieldLength(0.0), near_depthmap(0.0), far_depthmap(0.0), num_of_depth(0), change_depth_quantization(false)
    , default_depth_quantization(0), num_of_depth_quantization(0), random_phase(false) {}
};

struct GEN_DLL OphMeshData {
    ulonglong n_faces = 0;
    Face* faces;
    OphMeshData() : faces(nullptr) { n_faces = 0; }
};

struct GEN_DLL OphWRPConfig {
    Real fieldLength;
    vec3 scale;
    int num_wrp;
    Real wrp_location;
    Real propagation_distance;

    OphWRPConfig()
        : fieldLength(0.0), scale(0.0, 0.0, 0.0), num_wrp(0), wrp_location(0.0), propagation_distance(0.0)
    { }

    OphWRPConfig(Real _fieldLength, vec3 _scale, int _num_wrp, Real _wrp_location, Real _propagation_distance)
        : fieldLength(_fieldLength), scale(_scale), num_wrp(_num_wrp), wrp_location(_wrp_location), propagation_distance(_propagation_distance)
    { }
};

struct GEN_DLL OphIFTAConfig {
    Real                near_depthmap;
    Real                far_depthmap;
    int                 num_of_depth;

    int                 num_of_iteration;

    OphIFTAConfig() :near_depthmap(0), far_depthmap(0), num_of_depth(0), num_of_iteration(0) {}
    OphIFTAConfig(Real _near_depthmap, Real _far_depthmap, int _num_of_depth, int _num_of_iteration)
        :near_depthmap(_near_depthmap), far_depthmap(_far_depthmap), num_of_depth(_num_of_depth), num_of_iteration(_num_of_iteration) {}
};


#endif // !__ophGen_h