PointCloudObjectBase.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLGeom/src/ICLGeom/PointCloudObjectBase.h             **
** Module : ICLGeom                                                **
** Authors: Christof Elbrechter, Patrick Nobou, Andre Ueckermann   **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.LGPL **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#include <ICLUtils/CompatMacros.h>
#include <ICLUtils/Time.h>
#include <ICLGeom/SceneObject.h>
#include <ICLCore/DataSegment.h>
#include <ICLCore/ImgBase.h>
#include <map>

namespace icl{
  namespace geom{


    class ICLGeom_API PointCloudObjectBase : public SceneObject{
      utils::Time timestamp;

      protected:

      static float length(Vec d){
         float l = sqrt(d[0]*d[0]+d[1]*d[1]+d[2]*d[2]);
         return l;
      }

      GeomColor m_defaultPointColor;

      std::map<std::string,std::string> m_metaData;

      template<class T, int N>
      core::DataSegment<T,N> &error(const std::string &fname) {
        throw utils::ICLException("static feature "+fname+" is not supported by this PointCloudObjectBase instance");
        static core::DataSegment<T,N> dummy; return dummy;
      }

      core::DataSegmentBase &error_dyn(const std::string &featureName) {
        throw utils::ICLException("dynamic feature "+featureName+" is not supported by this PointCloudObjectBase instance");
        static core::DataSegmentBase dummy; return dummy;
      }

      virtual void drawNormalLines();

      bool useDrawNormalLines;
      float normalLineLength;
      int normalLineGranularity;

      bool useMasking;
      core::Img8u maskImage;
      bool useTriangulation;
      float maxDeltaValue;
      bool useTexturing;
      core::Img8u textureImage;
      core::DataSegment<float,2> textureCoordinates;

      //GLuint texName;//
      //int lastTextureWidth, lastTextureHeight;//


      public:

      enum FeatureType {
        Intensity,      
        Label,          
        Depth,          

        BGR,            
        BGRA,           
        BGRA32s,        

        // 4D vector components
        XYZ,            
        XYZH,           
        Normal,         
        RGBA32f,        

        NUM_FEATURES
      };


      PointCloudObjectBase():timestamp(utils::Time::null){
        setLockingEnabled(true);
        m_defaultPointColor = GeomColor(0,0.5,1,1);
        useDrawNormalLines=false;
        useMasking=false;
        useTriangulation=false;
        useTexturing=false;
        //glGenTextures(1,&texName);//
        //lastTextureWidth=0;//
        //lastTextureHeight=0;//

      }

      virtual void setTime(const utils::Time &t) { this->timestamp = t; }

      virtual const utils::Time &getTime() const { return this->timestamp; }

      virtual bool supports(FeatureType t) const = 0;


      virtual bool canAddFeature(FeatureType t) const { return false; }


      virtual void addFeature(FeatureType t) {
        throw utils::ICLException("unable to add given feature to point cloud");
      }

      virtual bool isOrganized() const = 0;

      virtual utils::Size getSize() const  = 0;

      virtual int getDim() const = 0;


      virtual void setSize(const utils::Size &size) = 0;

      inline void setDim(int dim){
        setSize(utils::Size(dim,-1));
      }

      virtual core::DataSegment<float,3> selectXYZ(){ return error<float,3>(__FUNCTION__);   }

      virtual core::DataSegment<float,4> selectXYZH(){ return  error<float,4>(__FUNCTION__);   }

      virtual core::DataSegment<float,1> selectIntensity(){   return error<float,1>(__FUNCTION__);   }

      virtual core::DataSegment<float,1> selectDepth(){   return error<float,1>(__FUNCTION__);   }

      virtual core::DataSegment<icl32s,1> selectLabel(){      return error<icl32s,1>(__FUNCTION__);  }

      virtual core::DataSegment<icl8u,3> selectBGR(){         return error<icl8u,3>(__FUNCTION__);   }

      virtual core::DataSegment<icl8u,4> selectBGRA(){        return error<icl8u,4>(__FUNCTION__);   }

      virtual core::DataSegment<icl32s,1> selectBGRA32s(){    return error<icl32s,1>(__FUNCTION__);   }


      virtual core::DataSegment<float,4> selectNormal(){      return error<float,4>(__FUNCTION__);   }

      virtual core::DataSegment<float,4> selectRGBA32f(){     return error<float,4>(__FUNCTION__);   }


      virtual core::DataSegmentBase select(const std::string &featureName) { return error_dyn(featureName); }

      // const select methds

      const core::DataSegment<float,3> selectXYZ() const { return const_cast<PointCloudObjectBase*>(this)->selectXYZ(); }

      const core::DataSegment<float,4> selectXYZH() const { return const_cast<PointCloudObjectBase*>(this)->selectXYZH(); }

      const core::DataSegment<float,1> selectIntensity() const { return const_cast<PointCloudObjectBase*>(this)->selectIntensity(); }

      const core::DataSegment<float,1> selectDepth() const { return const_cast<PointCloudObjectBase*>(this)->selectDepth(); }

      const core::DataSegment<icl32s,1> selectLabel() const { return const_cast<PointCloudObjectBase*>(this)->selectLabel(); }

      const core::DataSegment<icl8u,3> selectBGR() const { return const_cast<PointCloudObjectBase*>(this)->selectBGR(); }

      const core::DataSegment<icl8u,4> selectBGRA() const { return const_cast<PointCloudObjectBase*>(this)->selectBGRA(); }

      const core::DataSegment<icl32s,1> selectBGRA32s() const { return const_cast<PointCloudObjectBase*>(this)->selectBGRA32s(); }

      const core::DataSegment<float,4> selectNormal() const { return const_cast<PointCloudObjectBase*>(this)->selectNormal(); }

      const core::DataSegment<float,4> selectRGBA32f() const { return const_cast<PointCloudObjectBase*>(this)->selectRGBA32f(); }

      const core::DataSegmentBase select(const std::string &featureName) const {
        return const_cast<PointCloudObjectBase*>(this)->select(featureName);
      }


      void setColorsFromImage(const core::ImgBase &image) ;


      void extractColorsToImage(core::ImgBase &image, bool withAlpha=false) const ;

      void setDefaultVertexColor(const GeomColor &color);

      virtual GeomColor getDefaultVertexColor() const{ return m_defaultPointColor*255; }

      virtual std::vector<std::string> getSupportedDynamicFeatures() const {
        return std::vector<std::string>();
      }


      virtual void customRender();

      void setUseDrawNormalLines(bool use, float lineLength=40, int granularity=4);

      // set use masking (0 render, 1 dont render)
      void setUseMasking(bool use, core::Img8u &mask);

      //set use triangulation
      void setUseTriangulation(bool use, float maxDelta=50);

      //set texturing
      void setUseTexturing(bool use, core::Img8u &tex, core::DataSegment<float,2> texCoords);

      virtual PointCloudObjectBase *copy() const {
        return 0;
      }

      virtual void deepCopy(PointCloudObjectBase &dst) const;

      virtual bool equals(const PointCloudObjectBase &dst,
                          bool compareOnlySharedFeatures=false,
                          bool allowDifferentColorTypes=true,
                          float tollerance=1.0e-5) const;

      std::map<std::string,std::string> &getMetaData();

      const std::map<std::string,std::string> &getMetaData() const;

      const std::string &getMetaData(const std::string &key) const ;

      bool hasMetaData(const std::string &key) const;

      bool hasAnyMetaData() const;

      void setMetaData(const std::string &key, const std::string &value);

      void clearAllMetaData();

      void clearMetaData(const std::string &key);

      std::vector<std::string> getAllMetaDataEntries() const;
    };

    ICLGeom_API std::ostream &operator<<(std::ostream &s, const PointCloudObjectBase::FeatureType t);
  } // namespace geom
}