DataSegment.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/ICLCore/DataSegment.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.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 <ICLMath/FixedVector.h>
#include <ICLCore/CoreFunctions.h>
#include <ICLCore/DataSegmentBase.h>
#include <ICLUtils/ClippedCast.h>

namespace icl{
  namespace core{



    template<class T,int N>
    struct DataSegment : public DataSegmentBase{
      typedef math::FixedColVector<T,N> VectorType;

      inline DataSegment(T *data=0, size_t stride=0, size_t numElements=0, icl32s organizedWidth=-1):
      DataSegmentBase(data,stride,numElements,organizedWidth,icl::core::getDepth<T>(),N){}

      inline math::FixedColVector<T,N> &operator[](int idx) {
        return *reinterpret_cast<math::FixedColVector<T,N>*>(data +idx*stride);
      }

      inline const math::FixedColVector<T,N> &operator[](int idx) const{
        return const_cast<DataSegment<T,N> *>(this)->operator[](idx);
      }

      inline math::FixedColVector<T,N> &operator()(int x, int y) {
        return operator[](x + organizedWidth * y );
      }

      inline const math::FixedColVector<T,N> &operator()(int x, int y) const{
        return operator[](x + organizedWidth * y );
      }

      template<class OtherT>
      inline void deepCopy(DataSegment<OtherT,N> dst) const ;

      inline bool isPacked() const{
        return stride == sizeof(T)*N;
      }


      template<class OtherT>
      inline bool equals(DataSegment<OtherT,N> dst, float tollerance = 1.0e-5) const {
        if(getDim() != dst.getDim()) return false;
        if(isOrganized() != dst.isOrganized()) return false;
        if(isOrganized() && getSize() != dst.getSize()) return false;
        const int dim = getDim();
        for(int i=0;i<dim;++i){
          for(int j=0;j<N;++j){
            if(fabs((float)(operator[](i)[j] - dst[i][j])) > tollerance) return false;
          }
        }
        return true;
      }


      template<class Fill>
      inline void fillScalar(Fill scalarValue){
        const int dim = getDim();
        for(int i=0;i<dim;++i){
          for(int j=0;j<N;++j){
            operator[](i)[j] = scalarValue;
          }
        }
      }


      template<class Fill>
      inline void fill(Fill vecValue){
        const int dim = getDim();
        for(int i=0;i<dim;++i){
          operator[](i) = vecValue;
        }
      }


      static DataSegment<T,N> fromVector(std::vector<T> &v){
        return DataSegment<T,N>(v.data(), N*sizeof(T), v.size()/N);
      }


      static const DataSegment<T,N> fromVector(const std::vector<T> &v){
        return DataSegment<T,N>(v.data(), N*sizeof(T), v.size()/N);
      }

    };


    template<class T, class OtherT, int N>
    struct DataSegmentDeepCopyUtil{
      static void copy(const DataSegment<T,N> &src, DataSegment<OtherT,N> &dst){
        const int dim = src.getDim();
        const bool sp = src.isPacked(), dp = dst.isPacked();
        if(sp && dp){
          const T *s = (const T*)src.begin();
          T *d = (T*)dst.begin();
          std::transform(s,s+dim*N,d,icl::utils::clipped_cast<T,OtherT>);
        }else if(sp){
          const math::FixedColVector<T,N> *srcpacked = &src[0];
          for(int i=0;i<dim;++i){
            dst[i] = srcpacked[i];
          }
        }else if(dp){
          math::FixedColVector<OtherT,N> *dstpacked = &dst[0];
          for(int i=0;i<dim;++i){
            dstpacked[i] = src[i];
          }
        }else{
          for(int i=0;i<dim;++i){
            dst[i] = src[i];
          }
        }
      }
    };

    template<class T, int N>
    struct DataSegmentDeepCopyUtil<T,T,N>{
      static void copy(const DataSegment<T,N> &src, DataSegment<T,N> &dst){
        const int dim = src.getDim();
        const bool sp = src.isPacked(), dp = dst.isPacked();
        if(sp && dp){
          memcpy(dst.getDataPointer(),src.getDataPointer(),dim*sizeof(T)*N);
        }else if(sp){
          const math::FixedColVector<T,N> *srcpacked = &src[0];
          for(int i=0;i<dim;++i){
            dst[i] = srcpacked[i];
          }
        }else if(dp){
          math::FixedColVector<T,N> *dstpacked = &dst[0];
          for(int i=0;i<dim;++i){
            dstpacked[i] = src[i];
          }
        }else{
          for(int i=0;i<dim;++i){
            dst[i] = src[i];
          }
        }
      }
    };

    template<class T, int N> template<class OtherT>
    inline void DataSegment<T,N>::deepCopy(DataSegment<OtherT,N> dst) const {
      ICLASSERT_THROW(getDim() == dst.getDim(),
                      utils::ICLException("error in DataSegment::deepCopy "
                                          "(source and destination dim differ)"));
      DataSegmentDeepCopyUtil<T,OtherT,N>::copy(*this,dst);
    }



      template<class T>
      struct DataSegment<T,1> : public DataSegmentBase{
        typedef T VectorType;

        inline DataSegment(T *data=0, size_t stride=0, size_t numElements=0, icl32s organizedWidth=-1):
      DataSegmentBase(data,stride,numElements,organizedWidth,icl::core::getDepth<T>(),1){}

      inline T &operator[](int idx) {
        return *reinterpret_cast<T*>(data +idx*stride);
      }

      inline const T &operator[](int idx) const{
        return const_cast<DataSegment<T,1>*>(this)->operator[](idx);
      }

      inline T &operator()(int x, int y) {
        return operator[](x + organizedWidth * y );
      }

      inline const T &operator()(int x, int y) const{
        return operator[](x + organizedWidth * y );
      }

      template<class OtherT>
      inline void deepCopy(DataSegment<OtherT,1> dst) const {
        ICLASSERT_THROW(getDim() == dst.getDim(),
                        utils::ICLException("error in DataSegment::deepCopy "
                                            "(source and destination dim differ)"));
        const int dim = getDim();
        for(int i=0;i<dim;++i){
          dst[i] = operator[](i);
        }
      }
      template<class OtherT>
      inline bool equals(DataSegment<OtherT,1> dst, float tollerance = 1.0e-5) const {
        if(getDim() != dst.getDim()) return false;
        if(isOrganized() != dst.isOrganized()) return false;
        if(isOrganized() && getSize() != dst.getSize()) return false;
        const int dim = getDim();
        for(int i=0;i<dim;++i){
          if(fabs((float)(operator[](i) - dst[i])) > tollerance) return false;
        }
        return true;
      }


      template<class Fill>
      inline void fillScalar(Fill scalarValue){
        const int dim = getDim();
        for(int i=0;i<dim;++i){
          operator[](i) = scalarValue;
        }
      }

      template<class Fill>
      inline void fill(Fill vecValue){
        const int dim = getDim();
        for(int i=0;i<dim;++i){
          operator[](i) = vecValue;
        }
      }
    };

      template<class T, int N>
      const DataSegment<T,N> &DataSegmentBase::as() const{
        if(dataDepth != icl::core::getDepth<T>()) throw utils::ICLException("invalid cast of data segment (core::depth is wrong)");
        if(elemDim != N) throw utils::ICLException("invalid cast of data segment (dimension is wrong)");
        return (DataSegment<T,N> &)(*this);
      }

  } // namespace core
}