mlPCLObjectPtrsContainer.h

Go to the documentation of this file.

// Copyright (c) Fraunhofer MEVIS, Germany. All rights reserved.
// **InsertLicense** code author="Wolf Spindler"
//----------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------
#pragma once
 
#include "MLPCLSupportSystem.h"
#include <mlPCLTypes.h>
 
ML_START_NAMESPACE
  
struct MLPCLSUPPORT_EXPORT MLPCLObjectPtrsContainer {
 
  // Adapt this if a new PCL point type is integrated in the MeVisLab binding.
  MLPointCloudXYZPtr          pointCloudXYZ;
 
  MLPointCloudXYZLNormalPtr   pointCloudXYZLNormal;
 
  MLPointCloudXYZRGBNormalPtr pointCloudXYZRGBNormal;
 
  MLPointCloudXYZINormalPtr   pointCloudXYZINormal;
 
  MLPolygonMeshPtr            polygonMesh;
  
  MLPCLObjectPtrsContainer();
 
  // Adapt this if a new PCL point type is integrated in the MeVisLab binding.
  MLPCLObjectPtrsContainer(MLPointCloudXYZPtr          pcPtr);
  MLPCLObjectPtrsContainer(MLPointCloudXYZLNormalPtr   pcPtr);
  MLPCLObjectPtrsContainer(MLPointCloudXYZRGBNormalPtr pcPtr);
  MLPCLObjectPtrsContainer(MLPointCloudXYZINormalPtr   pcPtr);
  MLPCLObjectPtrsContainer(MLPolygonMeshPtr            pMeshPtr);
 
  // Adapt this if a new PCL point type is integrated in the MeVisLab binding.
  void setPCLObjectPointer(MLPointCloudXYZPtr          pcPtr);
  void setPCLObjectPointer(MLPointCloudXYZLNormalPtr   pcPtr);
  void setPCLObjectPointer(MLPointCloudXYZRGBNormalPtr pcPtr);
  void setPCLObjectPointer(MLPointCloudXYZINormalPtr   pcPtr);
  void setPCLObjectPointer(MLPolygonMeshPtr            pMeshPtr);
 
  // Adapt this if a new PCL point type is integrated in the MeVisLab binding.
  inline void getPCLObjectPointer(MLPointCloudXYZPtr          &pcPtr) const { pcPtr = pointCloudXYZ         ; }; 
  inline void getPCLObjectPointer(MLPointCloudXYZLNormalPtr   &pcPtr) const { pcPtr = pointCloudXYZLNormal  ; }; 
  inline void getPCLObjectPointer(MLPointCloudXYZRGBNormalPtr &pcPtr) const { pcPtr = pointCloudXYZRGBNormal; }; 
  inline void getPCLObjectPointer(MLPointCloudXYZINormalPtr   &pcPtr) const { pcPtr = pointCloudXYZINormal  ; }; 
  
  // Adapt this if a new PCL point type is integrated in the MeVisLab binding.
  void clearPCLObjectPointers();
  
  // Adapt this if a new PCL point type is integrated in the MeVisLab binding.
  bool hasValidPointCloudPointer() const;
  
  bool hasValidPolygonMeshPointer() const;
  
  bool hasValidPCLObjectPointer() const;
  
  // Adapt this if a new PCL point type is integrated in the MeVisLab binding.
  std::string getScalarMemberValueAsString(size_t pointIdx, size_t memberIdx) const;
 
  // Adapt this if a new PCL point type is integrated in the MeVisLab binding.
  std::string getScalarMemberNameAsString(size_t memberIdx) const;
};
  
// Adapt this if a new PCL point type is integrated in the MeVisLab binding.
#define ML_IMPLEMENT_FOR_SUPPORTED_POINT_TYPES(CODE, PTR_CONTAINER, FUNC, MULTI_PURPOSE_ARG) \
  CODE(PTR_CONTAINER, pointCloudXYZ         , FUNC, MULTI_PURPOSE_ARG) \
  CODE(PTR_CONTAINER, pointCloudXYZLNormal  , FUNC, MULTI_PURPOSE_ARG) \
  CODE(PTR_CONTAINER, pointCloudXYZRGBNormal, FUNC, MULTI_PURPOSE_ARG) \
  CODE(PTR_CONTAINER, pointCloudXYZINormal  , FUNC, MULTI_PURPOSE_ARG)
 
// Includes dedicated implementations for the macros defined below.
#include <mlPCLTypesPrivate.h>  
 
 
 
 
#define ML_IMPLEMENT_FOR_SUPPORTED_POINT_TYPES_0(FUNC, POINT_CLOUD_POINTERS) \
{ ML_IMPLEMENT_FOR_SUPPORTED_POINT_TYPES(_CODE_FOR_0_ARGS, POINT_CLOUD_POINTERS, FUNC, ML_EMPTY_PARAM) } 
 
 
 
 
#define ML_IMPLEMENT_FOR_SUPPORTED_POINT_TYPES_0_CONST_REF(FUNC, POINT_CLOUD_POINTERS) \
{ ML_IMPLEMENT_FOR_SUPPORTED_POINT_TYPES(_CODE_FOR_0_ARGS_CONST_REF, POINT_CLOUD_POINTERS, FUNC, ML_EMPTY_PARAM) }
 
 
 
 
#define ML_IMPLEMENT_FOR_SUPPORTED_POINT_TYPES_0_AND_CALL_FOR_SELECTED_TYPE(FUNC, POINT_CLOUD_POINTERS, ENUM_SELECTOR) \
{ ML_IMPLEMENT_FOR_SUPPORTED_POINT_TYPES(_CODE_FOR_0_ARGS_AND_CALL_FOR_SELECTED_TYPE, POINT_CLOUD_POINTERS, FUNC, ENUM_SELECTOR) }
 
 
 
 
#define ML_IMPLEMENT_FOR_SUPPORTED_POINT_TYPE_COMBINATIONS(FUNC, POINT_CLOUD_POINTERS1, POINT_CLOUD_POINTERS2) \
{ \
  ML_IMPLEMENT_FOR_SUPPORTED_POINT_TYPES(_ML_IMPLEMENT_FOR_SUPPORTED_POINT_TYPE_COMBINATIONS, POINT_CLOUD_POINTERS1, FUNC, POINT_CLOUD_POINTERS2) \
}
 
 
 
#define ML_IMPLEMENT_FOR_SUPPORTED_POINT_TYPE_COMBINATIONS_CONST_REF(FUNC, POINT_CLOUD_POINTERS1, POINT_CLOUD_POINTERS2) \
{ \
  ML_IMPLEMENT_FOR_SUPPORTED_POINT_TYPES(_ML_IMPLEMENT_FOR_SUPPORTED_POINT_TYPE_COMBINATIONS_CONST_REF, POINT_CLOUD_POINTERS1, FUNC, POINT_CLOUD_POINTERS2) \
}
 
 
 
 
// Adapt this if a new PCL point type is integrated in the MeVisLab binding.
template <class MODULE_TYPE>
inline std::string callSameTyped_filterT(MODULE_TYPE &mod,
                                         const std::string &successfullCalledFilterMessage="",
                                         const std::string &noValidPointCloudMessage="No input point clouds",
                                         const std::string &noInput1PointCloudMessage="No input 1 point cloud",
                                         const std::string &noInput2PointCloudMessage="No input 2 point cloud",
                                         const std::string &differentPointCloudMessage="Input point clouds do not have same point type")
{
  std::string statusString = "";
  MLPCLObjectPtrsContainer inputPointCloudPtrs1 = mod.getInputPCLObjectPtrsContainer(0);
  MLPCLObjectPtrsContainer inputPointCloudPtrs2 = mod.getInputPCLObjectPtrsContainer(1);
  if        (inputPointCloudPtrs1.pointCloudXYZ        &&     inputPointCloudPtrs2.pointCloudXYZ){
    mod._filterT(inputPointCloudPtrs1.pointCloudXYZ,          inputPointCloudPtrs2.pointCloudXYZ);
    statusString = successfullCalledFilterMessage;
  }
  else if (inputPointCloudPtrs1.pointCloudXYZINormal   &&     inputPointCloudPtrs2.pointCloudXYZINormal){
    mod._filterT(inputPointCloudPtrs1.pointCloudXYZINormal,   inputPointCloudPtrs2.pointCloudXYZINormal);
    statusString = successfullCalledFilterMessage;
  }
  else if (inputPointCloudPtrs1.pointCloudXYZLNormal   &&     inputPointCloudPtrs2.pointCloudXYZLNormal){
    mod._filterT(inputPointCloudPtrs1.pointCloudXYZLNormal,   inputPointCloudPtrs2.pointCloudXYZLNormal);
    statusString = successfullCalledFilterMessage;
  }
  else if (inputPointCloudPtrs1.pointCloudXYZRGBNormal &&     inputPointCloudPtrs2.pointCloudXYZRGBNormal){
    mod._filterT(inputPointCloudPtrs1.pointCloudXYZRGBNormal, inputPointCloudPtrs2.pointCloudXYZRGBNormal);
    statusString = successfullCalledFilterMessage;
  }
  else if (!inputPointCloudPtrs1.hasValidPointCloudPointer() && !inputPointCloudPtrs2.hasValidPointCloudPointer()){
    statusString = noValidPointCloudMessage;
  }
  else if (!inputPointCloudPtrs1.hasValidPointCloudPointer()){
    statusString = noInput1PointCloudMessage;
  }
  else if (!inputPointCloudPtrs2.hasValidPointCloudPointer()){
    statusString = noInput2PointCloudMessage;
  }
  else if (inputPointCloudPtrs1.hasValidPointCloudPointer() && inputPointCloudPtrs2.hasValidPointCloudPointer()){
    statusString = differentPointCloudMessage;
  }
  return statusString;
}
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
#if PCL_VERSION_COMPARE(<, 1, 12, 0)
template <typename POINT_CLOUD_TYPE>
inline typename boost::shared_ptr<const POINT_CLOUD_TYPE> PCLMakeLocalNonDeletingSharedConstPtr(const POINT_CLOUD_TYPE &pntCloud)
{
  typename boost::shared_ptr<const POINT_CLOUD_TYPE> ptr(&pntCloud, _MLPCLNoObjectDeleter<POINT_CLOUD_TYPE>);
  return ptr;
}
#else
template <typename POINT_CLOUD_TYPE>
inline typename std::shared_ptr<const POINT_CLOUD_TYPE> PCLMakeLocalNonDeletingSharedConstPtr(const POINT_CLOUD_TYPE &pntCloud)
{
  typename std::shared_ptr<const POINT_CLOUD_TYPE> ptr(&pntCloud, _MLPCLNoObjectDeleter<POINT_CLOUD_TYPE>);
  return ptr;
}
#endif
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
#define ML_PCL_TEST_INTERFACE_NO_OVERRIDE(BASE_OBJECT_NAME) \
public:\
  virtual inline void selfTestPCLBaseClass(bool alsoCallDestroyClass=false) \
  { \
    PCLBaseObject::_checkRuntimeInterfaceResults(getClassTypeId(), \
                                                 getTypeId(), \
                                                 getTypeIdName(), \
                                                 alsoCallDestroyClass); \
  }
  
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
#define ML_PCL_TEST_INTERFACE(BASE_OBJECT_NAME) \
public:\
  inline void selfTestPCLBaseClass(bool alsoCallDestroyClass=false) override \
  { \
    PCLBaseObject::_checkRuntimeInterfaceResults(getClassTypeId(), \
                                                 getTypeId(), \
                                                 getTypeIdName(), \
                                                 alsoCallDestroyClass); \
  }
  
ML_END_NAMESPACE