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                     **
**                                                                 **
**                                                                 **
** 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.GPL  **
** 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 <ICLGeom/SceneObject.h>
#include <ICLGeom/DataSegment.h>
#include <ICLCore/ImgBase.h>
#include <map>

namespace icl{
  namespace geom{
  

    class PointCloudObjectBase : public SceneObject{
      protected:
      
      GeomColor m_defaultPointColor;
      
      std::map<std::string,std::string> m_metaData;
      
      template<class T, int N>
      DataSegment<T,N> &error(const std::string &fname) throw (utils::ICLException){
        throw utils::ICLException("static feature "+fname+" is not supported by this PointCloudObjectBase instance");
        static DataSegment<T,N> dummy; return dummy;
      }
  
      DataSegmentBase &error_dyn(const std::string &featureName) throw (utils::ICLException){
        throw utils::ICLException("dynamic feature "+featureName+" is not supported by this PointCloudObjectBase instance");
        static DataSegmentBase dummy; return dummy;
      }
      
      virtual void drawNormalLines();
      
      bool useDrawNormalLines;
      float normalLineLength;
      int normalLineGranularity;
  
      public:
  
      enum FeatureType {
        Intensity,      
        Label,          
  
        BGR,            
        BGRA,           
        BGRA32s,        
  
        // 4D vector components
        XYZ,            
        XYZH,           
        Normal,         
        RGBA32f,        
  
        NUM_FEATURES
      };
  

      PointCloudObjectBase(){
        setLockingEnabled(true);
        m_defaultPointColor = GeomColor(0,0.5,1,1);
        useDrawNormalLines=false;
      }
  
      virtual bool supports(FeatureType t) const = 0;
  
      virtual bool isOrganized() const = 0;
  
      virtual utils::Size getSize() const throw (utils::ICLException) = 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 DataSegment<float,3> selectXYZ(){ return error<float,3>(__FUNCTION__);   }
      
      virtual DataSegment<float,4> selectXYZH(){ return  error<float,4>(__FUNCTION__);   }
      
      virtual DataSegment<float,1> selectIntensity(){   return error<float,1>(__FUNCTION__);   }
  
      virtual DataSegment<icl32s,1> selectLabel(){      return error<icl32s,1>(__FUNCTION__);  }
  
      virtual DataSegment<icl8u,3> selectBGR(){         return error<icl8u,3>(__FUNCTION__);   }
  
      virtual DataSegment<icl8u,4> selectBGRA(){        return error<icl8u,4>(__FUNCTION__);   }
  
      virtual DataSegment<icl32s,1> selectBGRA32s(){    return error<icl32s,1>(__FUNCTION__);   }
  

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


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

      const DataSegment<float,3> selectXYZ() const { return const_cast<PointCloudObjectBase*>(this)->selectXYZ(); }
      
      const DataSegment<float,4> selectXYZH() const { return const_cast<PointCloudObjectBase*>(this)->selectXYZH(); }
  
      const DataSegment<float,1> selectIntensity() const { return const_cast<PointCloudObjectBase*>(this)->selectIntensity(); }
      
      const DataSegment<icl32s,1> selectLabel() const { return const_cast<PointCloudObjectBase*>(this)->selectLabel(); }

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

      const DataSegment<icl8u,4> selectBGRA() const { return const_cast<PointCloudObjectBase*>(this)->selectBGRA(); }
  
      const DataSegment<icl32s,1> selectBGRA32s() const { return const_cast<PointCloudObjectBase*>(this)->selectBGRA32s(); }
      
      const DataSegment<float,4> selectNormal() const { return const_cast<PointCloudObjectBase*>(this)->selectNormal(); }
      
      const DataSegment<float,4> selectRGBA32f() const { return const_cast<PointCloudObjectBase*>(this)->selectRGBA32f(); }
  
      const DataSegmentBase select(const std::string &featureName) const { 
        return const_cast<PointCloudObjectBase*>(this)->select(featureName); 
      }
      

      void setColorsFromImage(const core::ImgBase &image) throw (utils::ICLException);


      void extractColorsToImage(core::ImgBase &image, bool withAlpha=false) const throw (utils::ICLException);
      
      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);
      
      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 throw (utils::ICLException);
  
      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;
    };
  
    std::ostream &operator<<(std::ostream &s, const PointCloudObjectBase::FeatureType t);
  } // namespace geom
}