core_3d.hpp

#pragma once


#include "namespace.hpp"
#include "global.hpp"

#include "_cexports/c_core_3d.h"

namespace Cvb
{

CVB_BEGIN_INLINE_NS


struct Factors3D
{
  double X;
  double Y;
  double Z;


  Factors3D(double x = 1, double y = 1, double z = 1)
    : X(x), Y(y), Z(z)
  {
  }
};


class PointCloud;
using PointCloudPtr = std::shared_ptr<PointCloud>;

class DensePointCloud;
using DensePointCloudPtr = std::shared_ptr<DensePointCloud>;

class SparsePointCloud;
using SparsePointCloudPtr = std::shared_ptr<SparsePointCloud>;

class Calibrator3D;
using Calibrator3DPtr = std::shared_ptr<Calibrator3D>;

class AtCalibrator3D;
using AtCalibrator3DPtr = std::shared_ptr<AtCalibrator3D>;

class FactorsCalibrator3D;
using FactorsCalibrator3DPtr = std::shared_ptr<FactorsCalibrator3D>;

class MatrixCalibrator3D;
using MatrixCalibrator3DPtr = std::shared_ptr<MatrixCalibrator3D>;

class PinholeCameraCalibrator3D;
using PinholeCameraCalibrator3DPtr = std::shared_ptr<PinholeCameraCalibrator3D>;

class LaserPlaneCalibrator3D;
using LaserPlaneCalibrator3DPtr = std::shared_ptr<LaserPlaneCalibrator3D>;

class LaserPlaneHomographyCalibrator3D;
using LaserPlaneHomographyCalibrator3DPtr = std::shared_ptr<LaserPlaneHomographyCalibrator3D>;

class LaserPlaneZigZagCalibrator3D;
using LaserPlaneZigZagCalibrator3DPtr = std::shared_ptr<LaserPlaneZigZagCalibrator3D>;

template <class T>
class Mesh;
template <class T>
using MeshPtr = std::shared_ptr<Mesh<T>>;

enum class PointCloudFlags
{
  Float     = CExports::CVC3DPCF_DTFloat,

  Double    = CExports::CVC3DPCF_DTDouble,

  XYZ         = CExports::CVC3DPCF_XYZ,

  XYZW        = CExports::CVC3DPCF_XYZW,

   XYZConfidence = CExports::CVC3DPCF_XYZConfidence,

  WithConfidence = CExports::CVC3DPCF_WithConfidence,

  NoExtrinsic = CExports::CVC3DPCF_NoExtrinsic,

  NoMeshIndices = CExports::CVC3DPCF_NoMeshIndices
};

inline PointCloudFlags operator|(PointCloudFlags a, PointCloudFlags b)
{
  return static_cast<PointCloudFlags>(static_cast<int>(a) | static_cast<int>(b));
}

enum PointCloudFileFormat
{
  Ascii = CExports::CVC3DPCFF_Ascii,

  Ply = CExports::CVC3DPCFF_Ply,

  Stl = CExports::CVC3DPCFF_Stl,

  /*
   * \brief Wavefront object file format.
   *
   * This format is usually specified by the filename extension: .obj
   * Only reading is supported.
   *
   * Loading mesh information is supported.  
   */
  WavefrontObj = CExports::CVC3DPCFF_WavefrontObj,

  Tiff = CExports::CVC3DPCFF_Tiff
};

enum class PointCloudLayout
{
  Invalid         = CExports::CVC3DPCL_Invalid,

  Linear          = CExports::CVC3DPCL_Linear,

  SeparatePlanar  = CExports::CVC3DPCL_SeparatePlanar,

  Planar          = CExports::CVC3DPCL_Planar,

  Interleaved     = CExports::CVC3DPCL_Interleaved
};

enum class DownSampleMode
{
  DownsampleByFactor  = CExports::CVC3DDownsampleByFactor,

  RemoveRandomly      = CExports::CVC3DRemoveRandomly
};

enum class SensorPixelPosition
{
  Absolute = CExports::CVC3DSPP_Absolute,

  Relative = CExports::CVC3DSPP_Relative
};

enum class SensorPixelsMirrored
{
  None = CExports::CVC3DSPM_None,

  X = CExports::CVC3DSPM_X,
  
  Y = CExports::CVC3DSPM_Y,

  XY = CExports::CVC3DSPM_XY
};

enum class CropRange
{  
  CropWithinRange = CExports::CVC3DC_CropWithinRange,

  CropOutsideRange = CExports::CVC3DC_CropOutsideRange
};

enum class CropDirection
{
  Below = 0,  
  Above = 1
};
CVB_END_INLINE_NS

}