Openholo.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 __Openholo_h
#define __Openholo_h

#include "Base.h"
#include "include.h"
#include "vec.h"
#include "ivec.h"
#include "fftw3.h"
#include "ImgCodecOhc.h"

using namespace oph;

struct OPH_DLL ResolutionConfig
{
    int double_pnX;
    int double_pnY;
    int pnX;
    int pnY;
    int half_pnX;
    int half_pnY;
    long long int size;
    long long int half_size;
    long long int double_size;

    ResolutionConfig() {
        this->pnX = 0;
        this->pnY = 0;
        this->half_pnX = 0;
        this->half_pnY = 0;
        this->double_pnX = 01;
        this->double_pnY = 01;
        this->size = 0;
        this->half_size = 0;
        this->double_size = 0;
    }

    ResolutionConfig(const ivec2& pixel_number) {
        this->pnX = pixel_number[_X];
        this->pnY = pixel_number[_Y];
        this->half_pnX = pnX >> 1;
        this->half_pnY = pnY >> 1;
        this->double_pnX = pnX << 1;
        this->double_pnY = pnY << 1;
        this->size = pnX * pnY;
        this->half_size = size >> 2;
        this->double_size = size << 2;
    }
};

struct OPH_DLL OphConfig
{
    bool            bUseDP;                     // use double precision
    ivec2           pixel_number;               // SLM_PIXEL_NUMBER_X & SLM_PIXEL_NUMBER_Y
    ivec2           offset;                     // start offset
    vec2            pixel_pitch;                // SLM_PIXEL_PITCH_X & SLM_PIXEL_PITCH_Y
    vec3            shift;                      // shift
    Real            k;                          // 2 * PI / lambda(wavelength)
    vec2            ss;                         // pn * pp
    uint            waveNum;                    // wave num
    Real*           wave_length;                // wave length

    //basic constructor
    OphConfig() {
        this->bUseDP = true;
        this->pixel_number = ivec2();
        this->offset = ivec2();
        this->pixel_pitch = vec2();
        this->shift = vec3();
        this->k = 0;
        this->ss = vec2();
        this->waveNum = 0;
        this->wave_length = 0;
    }
};

struct OPH_DLL ImageConfig
{
    bool        rotate;                         // rotat
    bool        merge;                          // merge
    int         flip;                           // flip


    //basic constructor
    ImageConfig() {
        this->rotate = false;
        this->merge = false;
        this->flip = 0;
    }
};



class OPH_DLL Openholo : public Base{

public:
    explicit Openholo(void);

protected:
    virtual ~Openholo(void) = 0;

protected:
    bool checkExtension(const char* fname, const char* ext);

public:
    virtual bool saveAsImg(const char* fname, uint8_t bitsperpixel, uchar* src, int width, int height);

    virtual uchar* loadAsImg(const char* fname);

    virtual bool saveAsOhc(const char *fname);


    virtual bool loadAsOhc(const char *fname);

    
    inline Complex<Real>** getComplexField(void) { return complex_H; }
    
    
    OphConfig& getContext(void) { return context_; }

    ImageConfig& getImageConfig() { return imgCfg; }

    inline void setPixelNumber(ivec2 n) { 
        context_.pixel_number[_X] = n[_X]; context_.pixel_number[_Y] = n[_Y];
        context_.ss = context_.pixel_number * context_.pixel_pitch;
    }
    inline void setPixelNumber(int width, int height) { 
        context_.pixel_number[_X] = width; context_.pixel_number[_Y] = height;
        context_.ss = context_.pixel_number * context_.pixel_pitch;
    }

    inline void setPixelPitch(vec2 p) { 
        context_.pixel_pitch[_X] = p[_X]; context_.pixel_pitch[_Y] = p[_Y];
        context_.ss = context_.pixel_number * context_.pixel_pitch;
    }
    inline void setPixelPitch(Real pitchX, Real pitchY) { 
        context_.pixel_pitch[_X] = pitchX; context_.pixel_pitch[_Y] = pitchY;
        context_.ss = context_.pixel_number * context_.pixel_pitch;
    }
    
    inline void setWaveLength(Real w, const uint idx = 0) { context_.wave_length[idx] = w; }

    void setWaveNum(int num);

    inline void setOffset(ivec2 offset) { context_.offset[_X] = offset[_X]; context_.offset[_Y] = offset[_Y]; }

    void setImageMerge(bool merge) { imgCfg.merge = merge; }

    void setImageRotate(bool rotate) { imgCfg.rotate = rotate; }

    void setImageFlip(int flip) { imgCfg.flip = flip; }

    void setMaxThreadNum(int num);

    int getMaxThreadNum();

    bool mergeColor(int idx, int width, int height, uchar *src, uchar *dst);

    bool separateColor(int idx, int width, int height, uchar *src, uchar *dst);

protected:

    bool loadAsImgUpSideDown(const char* fname, uchar* dst);

    bool getImgSize(int& w, int& h, int& bytesperpixel, const char* fname);

    void imgScaleBilinear(uchar* src, uchar* dst, int w, int h, int neww, int newh, int channels = 1);

    void convertToFormatGray8(uchar* src, uchar* dst, int w, int h, int bytesperpixel);
    
    void fft1(int n, Complex<Real>* in, int sign = OPH_FORWARD, uint flag = OPH_ESTIMATE);
    
    void fft2(ivec2 n, Complex<Real>* in, int sign = OPH_FORWARD, uint flag = OPH_ESTIMATE);
    void fft3(ivec3 n, Complex<Real>* in, int sign = OPH_FORWARD, uint flag = OPH_ESTIMATE);

    void fftExecute(Complex<Real>* out, bool bReverse = false);

    void fftFree(void);

    void fftInit2D(ivec2 size, int sign, unsigned int flag);

    void fft2(Complex<Real>* src, Complex<Real>* dst, int nx, int ny, int type, bool bNormalized = false);

    void fftShift(int nx, int ny, Complex<Real>* input, Complex<Real>* output);


protected:
    virtual void ophFree(void);

private:
    fftw_plan plan_fwd, plan_bwd;
    fftw_complex *fft_in, *fft_out;
    int pnx, pny, pnz;
    int fft_sign;
protected:
    OphConfig context_;
    ResolutionConfig resCfg;
    ImageConfig imgCfg;

    Complex<Real>** complex_H;
protected:
    ImgEncoderOhc* OHC_encoder;
    ImgDecoderOhc* OHC_decoder;

protected:
    inline void setPixelNumberOHC(const ivec2 pixel_number) 
        { OHC_encoder->setNumOfPixel(pixel_number); }

    inline void setPixelPitchOHC(const vec2 pixel_pitch)
        { OHC_encoder->setPixelPitch(pixel_pitch); }

    inline void setWavelengthOHC(const Real wavelength, const LenUnit wavelength_unit)
        { OHC_encoder->setWavelength(wavelength, wavelength_unit); }

    inline void setWaveLengthNumOHC(const uint wavelength_num)
        { OHC_encoder->setNumOfWavlen(wavelength_num); }

    inline void setColorTypeOHC(const ColorType color_type)
        { OHC_encoder->setColorType(color_type); }

    inline void setColorArrangeOHC(const ColorArran color_arrange)
        { OHC_encoder->setColorArrange(color_arrange);  }

    inline  void setWaveLengthUnitOHC(const LenUnit length_unit)
        { OHC_encoder->setUnitOfWavlen(length_unit);    }

    inline  void setFieldEncodingOHC(const FldStore field_store, const FldCodeType field_code_type)
        { OHC_encoder->setFieldEncoding(field_store, field_code_type); }

    inline  void setPhaseEncodingOHC(const BPhaseCode phase_code, const vec2 phase_code_range)
        { OHC_encoder->setPhaseEncoding(phase_code, phase_code_range); }
    inline void addWaveLengthNComplexFieldDataOHC(const Real wavelength, const OphComplexField& complex_field)
        { OHC_encoder->addWavelengthNComplexFieldData(wavelength, complex_field); }

    inline void addWaveLengthOHC(const Real wavelength)
        { OHC_encoder->addWavelength(wavelength); }

    inline void addComplexFieldDataOHC(const OphComplexField& complex_field)
        { OHC_encoder->addComplexFieldData(complex_field); }

    inline void getPixelNumberOHC(ivec2& pixel_number)
        { pixel_number = OHC_decoder->getNumOfPixel(); }

    inline void getPixelPitchOHC(vec2& pixel_pitch)
        { pixel_pitch = OHC_decoder->getPixelPitch(); }

    inline void getWavelengthOHC(vector<Real>& wavelength)
        { OHC_decoder->getWavelength(wavelength); }

    inline void getWaveLengthNumOHC(uint& wavelength_num)
        { wavelength_num = OHC_decoder->getNumOfWavlen(); }

    inline void getColorTypeOHC(ColorType& color_type)
        { color_type = OHC_decoder->getColorType(); }

    inline void getColorArrangeOHC(ColorArran& color_arrange)
        { color_arrange = OHC_decoder->getColorArrange(); }

    inline  void getWaveLengthUnitOHC(LenUnit& length_unit)
        { length_unit = OHC_decoder->getUnitOfWavlen(); }

    inline void getComplexFieldDataOHC(Complex<Real>** cmplx, uint wavelen_idx)
        { OHC_decoder->getComplexFieldData(cmplx, wavelen_idx); }

    inline void getComplexFieldDataOHC(OphComplexField& cmplx, uint wavelen_idx)
        { OHC_decoder->getComplexFieldData(cmplx, wavelen_idx); }   
};

#endif // !__Openholo_h