ophTriMesh.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 __ophTriMesh_h
#define __ophTriMesh_h

#include "ophGen.h"
#include <cufft.h>

//Build Option : Multi Core Processing (OpenMP)
#ifdef _OPENMP
#include <omp.h>
#endif
using namespace oph;

struct geometric {
    Real glRot[9] = { 0, };
    Real glShift[3] = { 0, };
    Real loRot[4] = { 0, };
};

struct TextMap {
    Complex<Real>* pattern;
    ivec2 dim;
    Real period;
    Real freq;
};




class GEN_DLL ophTri : public ophGen
{
public:
    explicit ophTri(void);

protected:
    virtual ~ophTri(void) {}

public:
    void setObjSize(vec3 in) { objSize = in; }
    void setObjShift(vec3 in) { context_.shift[_X] = in[_X]; context_.shift[_Y] = in[_Y]; context_.shift[_Z] = in[_Z]; }
    void setCarrierWave(Real in1, Real in2, Real in3) { carrierWave[_X] = in1; carrierWave[_Y] = in2; carrierWave[_Z] = in3; }
    void setIllumination(vec3 in) { illumination = in; }
    void setIllumination(Real inx, Real iny, Real inz) { illumination = { inx, iny, inz }; }
    void setShadingType(int in) { SHADING_TYPE = in; }

    void setRandPhase(bool in) { randPhase = in; }
    void setOcclusion(bool in) { occlusion = in; }
    void setTextureMapping(bool in) { textureMapping = in; }
    void setTextureImgDim(int dim1, int dim2) { texture.dim[0] = dim1; texture.dim[1] = dim2; }
    void setTexturePeriod(Real in) { texture.period = in; }

    ulonglong getNumMesh() { return meshData->n_faces; }


    //Real* getMeshData() { return triMeshArray; }
    Face* getMeshData() { return triMeshArray; }
    Complex<Real>* getAngularSpectrum() { return angularSpectrum; }
    //Real* getScaledMeshData() { return scaledMeshData; }
    Face* getScaledMeshData() { return scaledMeshData; }

    const vec3& getObjSize(void) { return objSize; }
    const vec3& getObjShift(void) { return context_.shift; }
    const vec3& getIllumination(void) { return illumination; }
    //const Real& getFieldLens(void) { return fieldLength; }

public:
    bool readConfig(const char* fname);

    bool loadMeshData(const char* fileName, const char* ext);

    //void objScaleShift();
    //void objScaleShift(vec3 objSize_, vector<Real> objShift_);
    //void objScaleShift(vec3 objSize_, vec3 objShift_);

    enum SHADING_FLAG { SHADING_FLAT, SHADING_CONTINUOUS };

    void loadTexturePattern(const char* fileName, const char* ext);

    virtual void encoding(unsigned int ENCODE_FLAG);


    Real generateHologram(uint SHADING_FLAG);

    void reconTest(const char* fname);

    void triTimeMultiplexing(char* dirName, uint ENCODE_METHOD, Real cenFx, Real cenFy, Real rangeFx, Real rangeFy, Real stepFx, Real stepFy);

    void setViewingWindow(bool is_ViewingWindow);

    uint* getProgress() { return &m_nProgress; }
private:

    // Inner functions

    void initializeAS();
    void prepareMeshData();
    void objSort(bool isAscending);
    bool checkValidity(vec3 no);
    bool findGeometricalRelations(Face mesh, vec3 no, geometric& geom);

    void calGlobalFrequency(Point* frequency, Real lambda);
    bool calFrequencyTerm(Point* frequency, Point* fl, Real* freqTermX, Real* freqTermY, geometric& geom, Real lambda);
    bool calFrequencyTerm(Real** frequency, Real** fl, Real* freqTermX, Real* freqTermY, geometric& geom);
    void refAS_Flat(vec3 na, Point* frequency, Face mesh, Real* freqTermX, Real* freqTermY, geometric& geom, Real lambda);
    void refASInner_flat(Real* freqTermX, Real* freqTermY);
    bool refAS_Continuous(uint n, Real* freqTermX, Real* freqTermY);
    bool generateAS(uint SHADING_FLAG);
    bool findNormals(uint SHADING_FLAG);
    bool refToGlobal(Complex<Real> *dst, Point* frequency, Point* fl, geometric& geom);
    bool refToGlobal(Real** frequency, Real** fl, geometric& geom);
    
    bool loadMeshText(const char* fileName);

    void initialize_GPU();
    void generateAS_GPU(uint SHADING_FLAG);
    //void refAS_GPU(int idx, MeshKernelConfig* config, geometric &geometric);

    // correct the output scale of the  ophGen::conv_fft2 
    void conv_fft2_scale(Complex<Real>* src1, Complex<Real>* src2, Complex<Real>* dst, ivec2 size);
private:
    Face* scaledMeshData;                   

    //  Inner global parameters
    vec3* no;
    vec3* na;
    vec3* nv;

    Complex<Real>* angularSpectrum;         
    Complex<Real>* refAS;

    Complex<Real>* rearAS;
    Complex<Real>* convol;

    Complex<Real>* phaseTerm;

    bool is_ViewingWindow;

    OphMeshData* meshData;                  
    Real* tempFreqTermX;
    Real* tempFreqTermY;

    // calGlobalFrequency()
    Real dfx, dfy;

    // findNormals()


    // findGeometricalRelations()
    Real mesh_local[9] = { 0.0 };
    Real th, ph;
    Real temp;


    // calFrequencyTerm()
    Real k, kk;
    Real* flxShifted;
    Real* flyShifted;
    Real det;
    Real* invLoRot;


    // refAS_Flat() , refAS_Continuous()

    Complex<Real> refTerm1;
    Complex<Real> refTerm2;
    Complex<Real> refTerm3;



    vec3 av;


    Complex<Real>* textFFT;
    Real textFreqX;
    Real textFreqY;
    Complex<Real> refTemp;
    uint m_nProgress;
    const char* meshDataFileName;

    //* triMeshArray;                       /// Original triangular mesh array (N*9)
    Face* triMeshArray;                     

    //Real fieldLength;
    vec3 objSize;                           

    Real carrierWave[3] = { 0,0,1 };        
    vec3 illumination;                      
    int SHADING_TYPE;                       

    bool randPhase;
    bool occlusion;
    bool textureMapping;
    TextMap texture;
    bool TM = false;
    int idxCarr, idxCarrFx, idxCarrFy;
    cufftDoubleComplex* angularSpectrum_GPU;
    cufftDoubleComplex* ffttemp;

    cudaStream_t    streamTriMesh;

};



#endif