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)
    {
    }
    explicit Factors3D(double x = 1, double y = 1, double z = 1) {…}
  };
  struct Factors3D {…};
 
  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
  };
  enum class PointCloudFlags {…};
 
  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 PointCloudFileFormat {…};

  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 PointCloudLayout {…};

  enum class DownSampleMode
  {
    DownsampleByFactor = CExports::CVC3DDownsampleByFactor,

    RemoveRandomly = CExports::CVC3DRemoveRandomly
  };
  enum class DownSampleMode {…};

  enum class SensorPixelPosition
  {
    Absolute = CExports::CVC3DSPP_Absolute,

    Relative = CExports::CVC3DSPP_Relative
  };
  enum class SensorPixelPosition {…};

  enum class SensorPixelsMirrored
  {
    None = CExports::CVC3DSPM_None,

    X = CExports::CVC3DSPM_X,

    Y = CExports::CVC3DSPM_Y,

    XY = CExports::CVC3DSPM_XY
  };
  enum class SensorPixelsMirrored {…};

  enum class CropRange
  { 
    CropWithinRange = CExports::CVC3DC_CropWithinRange,

    CropOutsideRange = CExports::CVC3DC_CropOutsideRange
  };
  enum class CropRange {…};

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

  enum class GapFillingMethod
  {
    LinearInterpolation = 0
  };
  enum class GapFillingMethod {…};

  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)
    {
    }
    GapFillingOptions(double backgroundValue, int maxWidth, int maxHeight, GapFillingMethod method) {…}
  };
  struct GapFillingOptions {…};
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb