EmbreeTargetShape.h

Go to the documentation of this file.

#ifndef EmbreeTargetShape_h
#define EmbreeTargetShape_h
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <QString>
 
// Embree includes
#include <embree3/rtcore.h>
#include <embree3/rtcore_ray.h>
 
// PointCloudLibrary includes
#include <pcl/io/auto_io.h>
#include <pcl/point_types.h>
#include <pcl/PolygonMesh.h>
 
//  WARNING
//  The following undefes macros set in pcl. They conflict with ISIS's macros.
//  If pcl tries to use these macros you will get compilation errors.
//    - JAM
#undef DEG2RAD
#undef RAD2DEG
 
#include "FileName.h"
#include "LinearAlgebra.h"
 
namespace Isis {
 
 
  class Pvl;
 
  struct RTCMultiHitRay : RTCRayHit {
    RTCMultiHitRay();
    RTCMultiHitRay(const std::vector<double> &origin,
                   const std::vector<double> &direction);
    RTCMultiHitRay(LinearAlgebra::Vector origin, 
                   LinearAlgebra::Vector direction);
 
// These are the inheritted members from RTCRay
//   float    org;    //!< Ray origin
//   float    dir;    //!< Ray direction
//   float    tnear;  //!< Start of ray segment
//   float    tfar;   //!< End of ray segment
//   float    time;   //!< Time of this ray for motion blur.
//   unsigned mask;   //!< used to mask out objects during traversal
//   float    Ng;     //!< Geometric normal.
//   float    u;      //!< Barycentric u coordinate of hit
//   float    v;      //!< Barycentric v coordinate of hit
//   unsigned geomID; //!< geometry ID
//   unsigned primID; //!< primitive ID
//   unsigned instID; //!< instance ID
 
    // ray extensions
    // we remember up to 16 hits to ignore duplicate hits
    unsigned hitGeomIDs[16]; 
    unsigned hitPrimIDs[16]; 
    float    hitUs[16];      
    float    hitVs[16];      
    int      lastHit;        
  };
 
 
  struct RTCOcclusionRay : RTCRayHit {
    RTCOcclusionRay();
    RTCOcclusionRay(const std::vector<double> &origin,
                   const std::vector<double> &direction);
    RTCOcclusionRay(LinearAlgebra::Vector origin, 
                   LinearAlgebra::Vector direction);
 
// These are the inheritted members from RTCRay
//   float    org;    //!< Ray origin
//   float    dir;    //!< Ray direction
//   float    tnear;  //!< Start of ray segment
//   float    tfar;   //!< End of ray segment
//   float    time;   //!< Time of this ray for motion blur.
//   unsigned mask;   //!< used to mask out objects during traversal
//   float    Ng;     //!< Geometric normal.
//   float    u;      //!< Barycentric u coordinate of hit
//   float    v;      //!< Barycentric v coordinate of hit
//   unsigned geomID; //!< geometry ID
//   unsigned primID; //!< primitive ID
//   unsigned instID; //!< instance ID
 
    // ray extensions
    int lastHit;            
    unsigned ignorePrimID; 
  };
 
 
  struct RayHitInformation {
    RayHitInformation();
    RayHitInformation(LinearAlgebra::Vector &location, LinearAlgebra::Vector &normal, int primID);
 
    LinearAlgebra::Vector intersection;  
    LinearAlgebra::Vector surfaceNormal; 
    int primID; 
  };
 
 
  class EmbreeTargetShape {
    public:
 
      EmbreeTargetShape();
      EmbreeTargetShape(pcl::PolygonMesh::Ptr mesh, const QString &name = "");
      EmbreeTargetShape(const QString &dem, const Pvl *conf = 0);
      virtual ~EmbreeTargetShape();
 
      QString name() const;
      bool isValid() const;
 
      int numberOfPolygons() const;
      int numberOfVertices() const;
      RTCBounds sceneBounds() const;
      double maximumSceneDistance() const;
 
      void intersectRay(RTCMultiHitRay &ray);
      bool isOccluded(RTCOcclusionRay &ray);
 
      RayHitInformation getHitInformation(RTCMultiHitRay &ray, int hitIndex);
 
      static void multiHitFilter(const RTCFilterFunctionNArguments *args);
      static void occlusionFilter(const RTCFilterFunctionNArguments *args);
 
    protected:
      pcl::PolygonMesh::Ptr readDSK(FileName file);
      pcl::PolygonMesh::Ptr readPC(FileName file);
      void initMesh(pcl::PolygonMesh::Ptr mesh);
      void addVertices(int geomID);
      void addIndices(int geomID);
 
    private:
      struct Vertex {
        float x; 
        float y; 
        float z; 
        float a; 
      };
 
      struct Triangle {
        int v0; 
        int v1; 
        int v2; 
      };
 
      QString                        m_name;   
      pcl::PolygonMesh::Ptr          m_mesh;   
      pcl::PointCloud<pcl::PointXYZ> m_cloud;  
      RTCDevice                      m_device; 
      RTCScene                       m_scene;  
  };
 
} // namespace Isis
 
#endif