ophSig.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 __ophSig_h
#define __ophSig_h

#include "tinyxml2.h"
#include "Openholo.h"
#include "sys.h"



#ifdef SIG_EXPORT
#define SIG_DLL __declspec(dllexport)
#else
#define SIG_DLL __declspec(dllimport)
#endif

struct SIG_DLL ophSigConfig {
    int cols;
    int rows;
    Real_t width;
    Real_t height;
    Real_t NA;
    Real_t z;
    int wavelength_num;
    Real wavelength[3];
};













class SIG_DLL ophSig : public Openholo
{
protected:

    virtual ~ophSig(void) = default;

    virtual void ophFree(void);
    bool is_CPU;
    ophSigConfig _cfgSig;
    OphComplexField* ComplexH;
    fftw_plan bwd_plan, fwd_plan;

    //float _width;
    //float _height;

    //float _NA;
    //float _z;

    int _wavelength_num;

    /*float _angleX;
    float _angleY;
    float _redRate;*/
    Real_t _radius;
    Real_t* _foc;



    bool sigConvertOffaxis_CPU(Real angleX, Real angleY);
    bool sigConvertOffaxis_GPU(Real angleX, Real angleY);
    bool sigConvertHPO_CPU(Real depth, Real_t redRate);
    bool sigConvertHPO_GPU(Real depth, Real_t redRate);

    bool sigConvertCAC_CPU(double red, double green, double blue);
    bool sigConvertCAC_GPU(double red, double green, double blue);
    double sigGetParamAT_CPU();
    double sigGetParamAT_GPU();
    double sigGetParamSF_CPU(float zMax, float zMin, int sampN, float th);
    double sigGetParamSF_GPU(float zMax, float zMin, int sampN, float th);

    bool propagationHolo_CPU(float depth);
    bool propagationHolo_GPU(float depth);

    bool Color_propagationHolo_GPU(float depth);
public:
    explicit ophSig(void);
    bool load(const char *real, const char *imag);
    bool save(const char *real, const char *imag);
    bool save(const char *real);

    bool loadAsOhc(const char *fname);
    bool saveAsOhc(const char *fname);
    template<typename T>
    void linInterp(vector<T> &X, matrix<Complex<T>> &src, vector<T> &Xq, matrix<Complex<T>> &dst);
    template<typename T>
    vector<T> linspace(T first, T last, int len) {
        vector<Real> result(len);
        Real step = (last - first) / (len - 1);
        for (int i = 0; i < len; i++) { result[i] = first + i * step; }
        return result;
    }
    template<typename T>
    void absMat(matrix<Complex<T>>& src, matrix<T>& dst) {
        if (src.size != dst.size) {
            dst.resize(src.size[_X], src.size[_Y]);
        }
        for (int i = 0; i < src.size[_X]; i++)
        {
            for (int j = 0; j < src.size[_Y]; j++)
            {
                dst.mat[i][j] = sqrt(src.mat[i][j]._Val[_RE] * src.mat[i][j]._Val[_RE] + src.mat[i][j]._Val[_IM] * src.mat[i][j]._Val[_IM]);
            }
        }
    }
    template<typename T>
    void absMat(matrix<T>& src, matrix<T>& dst) {
        if (src.size != dst.size) {
            dst.resize(src.size[_X], src.size[_Y]);
        }
        for (int i = 0; i < src.size[_X]; i++)
        {
            for (int j = 0; j < src.size[_Y]; j++)
            {
                dst.mat[i][j] = abs(src.mat[i][j]);
            }
        }
    }
    template<typename T>
    void angleMat(matrix<Complex<T>>& src, matrix<T>& dst) {
        if (src.size != dst.size) {
            dst.resize(src.size[_X], src.size[_Y]);
        }
        for (int i = 0; i < src.size[_X]; i++)
        {
            for (int j = 0; j < src.size[_Y]; j++)
            {
                angle(src(i, j), dst(i, j));
            }
        }
    }
    template<typename T>
    void conjMat(matrix<Complex<T>>& src, matrix<Complex<T>>& dst) {
        if (src.size != dst.size) {
            dst.resize(src.size[_X], src.size[_Y]);
        }
        for (int i = 0; i < src.size[_X]; i++)
        {
            for (int j = 0; j < src.size[_Y]; j++)
            {
                dst(i, j) = src(i, j).conj();

            }
        }
    }
    template<typename T>
    void expMat(matrix<Complex<T>>& src, matrix<Complex<T>>& dst) {
        if (src.size != dst.size) {
            dst.resize(src.size[_X], src.size[_Y]);
        }
        for (int i = 0; i < src.size[_X]; i++)
        {
            for (int j = 0; j < src.size[_Y]; j++)
            {
                dst.mat[i][j]._Val[_RE] = exp(src.mat[i][j]._Val[_RE]) * cos(src.mat[i][j]._Val[_IM]);
                dst.mat[i][j]._Val[_IM] = exp(src.mat[i][j]._Val[_RE]) * sin(src.mat[i][j]._Val[_IM]);
            }
        }
    }
    template<typename T>
    void expMat(matrix<T>& src, matrix<T>& dst) {
        if (src.size != dst.size) {
            dst.resize(src.size[_X], src.size[_Y]);
        }
        for (int i = 0; i < src.size[_X]; i++)
        {
            for (int j = 0; j < src.size[_Y]; j++)
            {
                dst.mat[i][j] = exp(src.mat[i][j]);
            }
        }
    }
    template<typename T>
    void meanOfMat(matrix<T>& src, T &dst) {
        dst = 0;
        for (int i = 0; i < src.size[_X]; i++)
        {
            for (int j = 0; j < src.size[_Y]; j++)
            {
                dst += src(i, j);
            }
        }
        dst = dst / (src.size[_X] * src.size[_Y]);
    }
    Real maxOfMat(matrix<Real>& src) {
        Real max = MIN_REAL;
        for (int i = 0; i < src.size[_X]; i++)
        {
            for (int j = 0; j < src.size[_Y]; j++)
            {
                if (src(i, j) > max) max = src(i, j);
            }
        }
        return max;
    }
    Complex<Real> maxOfMat(matrix<Complex<Real>>& src) {
        Real max = MIN_REAL;
        for (int i = 0; i < src.size[_X]; i++)
        {
            for (int j = 0; j < src.size[_Y]; j++)
            {
                if (src(i, j)._Val[_RE] > max) max = src(i, j)._Val[_RE];
                //if (src(i, j)._Val[_IM] > max) max = src(i, j)._Val[_IM];
            }
        }
        return max;
    }
    //template<typename T>
    Real minOfMat(matrix<Real>& src) {
        Real min = MAX_REAL;
        for (int i = 0; i < src.size[_X]; i++)
        {
            for (int j = 0; j < src.size[_Y]; j++)
            {
                if (src(i, j) < min) min = src(i, j);
            }
        }
        return min;
    }
    Complex<Real> minOfMat(matrix<Complex<Real>>& src) {
        Real min = MAX_REAL;
        for (int i = 0; i < src.size[_X]; i++)
        {
            for (int j = 0; j < src.size[_Y]; j++)
            {
                if (src(i, j)._Val[_RE] < min) min = src(i, j)._Val[_RE];
            }
        }
        return min;
    }

    void ophSig::fftShift(matrix<Complex<Real>> &src, matrix<Complex<Real>> &dst)
    {
        if (src.size != dst.size) {
            dst.resize(src.size[_X], src.size[_Y]);
        }
        int xshift = src.size[_X] / 2;
        int yshift = src.size[_Y] / 2;
        for (int i = 0; i < src.size[_X]; i++)
        {
            int ii = (i + xshift) % src.size[_X];
            for (int j = 0; j < src.size[_Y]; j++)
            {
                int jj = (j + yshift) % src.size[_Y];
                dst.mat[ii][jj]._Val[_RE] = src.mat[i][j].real();
                dst.mat[ii][jj]._Val[_IM] = src.mat[i][j].imag();
            }
        }
    }

    template<typename T>
    void fft1(matrix<Complex<T>> &src, matrix<Complex<T>> &dst, int sign = OPH_FORWARD, uint flag = OPH_ESTIMATE);
    template<typename T>
    void fft2(matrix<Complex<T>> &src, matrix<Complex<T>> &dst, int sign = OPH_FORWARD, uint flag = OPH_ESTIMATE);
    bool readConfig(const char* fname);
    void Parameter_Set(int nx, int ny, double width, double height , double NA );
    void wavelength_Set(double wavelength);
    void focal_length_Set(double red , double green, double blue, double rad);
    void Data_output(uchar  *data, int pos ,int bitpixel);
    void Wavenumber_output(int &wavenumber);

    bool sigConvertOffaxis(Real angleX, Real angleY);
    bool cvtOffaxis_CPU(Real angleX, Real angleY);
    void cvtOffaxis_GPU(Real angleX, Real angleY);


    bool sigConvertHPO(Real depth, Real_t redRate);


    bool sigConvertCAC(double red, double green, double blue);

    bool propagationHolo(float depth);
    OphComplexField propagationHolo(OphComplexField complexH, float depth);

    double sigGetParamAT();

    double sigGetParamSF(float zMax, float zMin, int sampN, float th);

    void setMode(bool is_CPU);
    void cField2Buffer(matrix<Complex<Real>>& src, Complex<Real> **dst, int nx, int ny);

    void ColorField2Buffer(matrix<Complex<Real>>& src, Complex<Real> **dst, int nx, int ny);



    bool getComplexHFromPSDH(const char* fname0, const char* fname90, const char* fname180, const char* fname270);



    bool getComplexHFrom3ArbStepPSDH(const char* f0, const char* f1, const char* f2, const char* fOI, const char* fRI, int nIter);

};

#endif // !__ophSig_h