ophPointCloud.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 __ophPointCloud_h
#define __ophPointCloud_h


#include "ophGen.h"

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

/* Bitmap File Definition*/
#define OPH_Bitsperpixel 8 //24 // 3byte=24 
#define OPH_Planes 1
#define OPH_Compression 0
#define OPH_Xpixelpermeter 0x130B //2835 , 72 DPI
#define OPH_Ypixelpermeter 0x130B //2835 , 72 DPI
#define OPH_Pixel 0xFF

using namespace oph;



class GEN_DLL ophPointCloud : public ophGen
{
public:
    enum PC_DIFF_FLAG : int8_t {
        PC_DIFF_RS = 0x00,
        PC_DIFF_FRESNEL = 0x01
    };
    explicit ophPointCloud(void);
    explicit ophPointCloud(const char*, const char* cfg_file);
protected:
    virtual ~ophPointCloud(void);

public:
    inline void setScale(Real sx, Real sy, Real sz) { pc_config_.scale.v[0] = sx; pc_config_.scale.v[1] = sy; pc_config_.scale.v[2] = sz; }
    inline void setDistance(Real distance) { pc_config_.distance = distance; }
    inline void setFilterShapeFlag(int8_t* fsf) { pc_config_.filter_shape_flag = fsf; }
    inline void setFilterWidth(Real wx, Real wy) { pc_config_.filter_width.v[0] = wx; pc_config_.filter_width.v[1] = wy; }
    inline void setFocalLength(Real lens_in, Real lens_out, Real lens_eye_piece) { pc_config_.focal_length_lens_in = lens_in; pc_config_.focal_length_lens_out = lens_out; pc_config_.focal_length_lens_eye_piece = lens_eye_piece; }
    inline void setTiltAngle(Real ax, Real ay) { pc_config_.tilt_angle.v[0] = ax; pc_config_.tilt_angle.v[1] = ay; }
    
    inline void setPointCloudModel(Vertex* vertex)
    {
        if (pc_data_.n_points < 1) return;

        if (pc_data_.vertices != nullptr) delete[] pc_data_.vertices;
        pc_data_.vertices = new Vertex[pc_data_.n_points];
        memcpy(pc_data_.vertices, vertex, sizeof(Vertex) * pc_data_.n_points);
    }

    inline void setNumberOfPoints(ulonglong n_points) { pc_data_.n_points = n_points; }

    inline void getScale(vec3& scale) { scale = pc_config_.scale; }
    inline Real getDistance(void) { return pc_config_.distance; }
    inline int8_t* getFilterShapeFlag(void) { return pc_config_.filter_shape_flag; }
    inline void getFilterWidth(vec2& filterwidth) { filterwidth = pc_config_.filter_width; }
    inline void getFocalLength(Real* lens_in, Real* lens_out, Real* lens_eye_piece) {
        if (lens_in != nullptr) *lens_in = pc_config_.focal_length_lens_in;
        if (lens_out != nullptr) *lens_out = pc_config_.focal_length_lens_out;
        if (lens_eye_piece != nullptr) *lens_eye_piece = pc_config_.focal_length_lens_eye_piece;
    }
    inline void getTiltAngle(vec2& tiltangle) { tiltangle = pc_config_.tilt_angle; }


    inline Vertex* getPointCloudModel() { return pc_data_.vertices; }
    inline ulonglong getNumberOfPoints() { return pc_data_.n_points; }

public:
    bool isCPU() { return m_mode & MODE_GPU ? false : true; }

    int loadPointCloud(const char* pc_file);

    bool readConfig(const char* cfg_file);

    Real generateHologram(uint diff_flag = PC_DIFF_RS);
    void encodeHologram(vec2 band_limit = vec2(0.8, 0.5), vec2 spectrum_shift = vec2(0.0, 0.5));

    virtual void encoding(unsigned int ENCODE_FLAG, unsigned int SSB_PASSBAND);
    virtual void encoding(unsigned int ENCODE_FLAG);

    void setViewingWindow(bool is_ViewingWindow);

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

    void genCghPointCloudGPU(uint diff_flag);
    void ophFree(void);

    bool is_ViewingWindow;
    uint m_nProgress;
    OphPointCloudConfig pc_config_;
    OphPointCloudData   pc_data_;
};

#endif // !__ophPointCloud_h