ophCascadedPropagation.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*/
#pragma once
#ifndef _OphCascadedPropagation_h
#define _OphCascadedPropagation_h

#include "ophRec.h"

enum SourceType {IMG, OHC};

struct OphCascadedPropagationConfig {
    OphCascadedPropagationConfig()
        : num_colors(0),
        wavelengths{ 0.0, 0.0, 0.0 },
        dx(0.0),
        dy(0.0),
        nx(0),
        ny(0),
        field_lens_focal_length(0.0),
        dist_reconstruction_plane_to_pupil(0.0),
        dist_pupil_to_retina(0.0),
        pupil_diameter(0.0),
        nor(0.0)
        {}

    oph::uint num_colors;

    oph::vec3 wavelengths;

    Real dx;

    Real dy;

    oph::uint nx;

    oph::uint ny;

    Real field_lens_focal_length;

    Real dist_reconstruction_plane_to_pupil;

    Real dist_pupil_to_retina;

    Real pupil_diameter;

    Real nor;
};



class RECON_DLL ophCascadedPropagation : public ophRec {
    private:
        ophCascadedPropagation();

    public:
        ophCascadedPropagation(const wchar_t* configfilepath);

        ~ophCascadedPropagation();

        bool propagate();

        bool save(const wchar_t* pathname, uint8_t bitsperpixel);

        virtual bool saveAsOhc(const char *fname);

        virtual bool loadAsOhc(const char *fname);


    private:
        SourceType sourcetype_;

        OphCascadedPropagationConfig config_;

        vector<oph::Complex<Real>*> wavefield_SLM;

        vector<oph::Complex<Real>*> wavefield_pupil;

        vector<oph::Complex<Real>*> wavefield_retina;

        bool ready_to_propagate;

        wstring hologram_path;

        bool readConfig(const wchar_t* fname);

        bool allocateMem();

        void deallocateMem();

        bool loadInputImg(string hologram_path_str);

        oph::uchar* getIntensityfields(vector<oph::Complex<Real>*> wavefields);


    public:
        bool isReadyToPropagate() { return ready_to_propagate; }

        oph::uint getNumColors() { return config_.num_colors; }

        oph::vec3 getWavelengths() { return config_.wavelengths; }

        Real getPixelPitchX() { return config_.dx; }

        Real getPixelPitchY() { return config_.dy; }

        oph::uint getResX() { return config_.nx; }

        oph::uint getResY() { return config_.ny; }

        Real getFieldLensFocalLength() { return config_.field_lens_focal_length; }

        Real getDistObjectToPupil() { return config_.dist_reconstruction_plane_to_pupil; }

        Real getDistPupilToRetina() { return config_.dist_pupil_to_retina; }

        Real getPupilDiameter() { return config_.pupil_diameter; }

        Real getNor() { return config_.nor; }

        oph::Complex<Real>* getSlmWavefield(oph::uint id);

        oph::Complex<Real>* getPupilWavefield(oph::uint id);

        oph::Complex<Real>* getRetinaWavefield(oph::uint id);

        vector<oph::Complex<Real>*> getRetinaWavefieldAll();


        // setters
        //virtual bool SetSlmWavefield(Complex<Real>* srcHologram) = 0; // set input wavefield (for later use)
        //virtual bool SetSlmWavefield(ophGen& srcHologram) = 0; // set input wavefield (for later use)

        bool propagateSlmToPupil();

        bool propagatePupilToRetina();


    protected:
        virtual void ophFree(void);
};



// utilities
#define __FILENAME__ (strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__)
#define PRINT_ERROR(errorMsg)           { cout << "Error(" << __FILENAME__ << ":" << __LINE__ << "): " << ( errorMsg ) << endl; }

#endif