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;
 
 
  explicit 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
};
 
enum class GapFillingMethod
{
  LinearInterpolation = 0
};
 
struct GapFillingOptions
{
  double BackgroundValue;
  int MaxWidth;
  int MaxHeight;
  GapFillingMethod Method;
 
 
  GapFillingOptions(double backgroundValue, int maxWidth, int maxHeight, GapFillingMethod method)
    : BackgroundValue(backgroundValue)
    , MaxWidth(maxWidth)
    , MaxHeight(maxHeight)
    , Method(method)
  {
  }
};
 
CVB_END_INLINE_NS
 
}