SplatCloud.hh

/*===========================================================================*\
*                                                                            *
*                              OpenFlipper                                   *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
*                                                                            *
\*===========================================================================*/



//================================================================
//
//  CLASS SplatCloud
//
//    SplatCloud stores the actual data for a SplatCloud.
//
//================================================================


#ifndef SPLATCLOUD_HH
#define SPLATCLOUD_HH


//== INCLUDES ====================================================


#include <OpenFlipper/common/ObjectTypeDLLDefines.hh>

#include <typeinfo>
#include <string>
#include <map>
#include <vector>
#include <algorithm>

#include <ACG/Math/VectorT.hh>


//== CLASS DEFINITION ============================================


class OBJECTTYPEDLLEXPORT SplatCloud
{

  // == DECLARATIONS =====================================================

public:

  inline SplatCloud() : numSplats_( 0 )
  {
    resetPredefinedSplatPropertyPointers();
    resetPredefinedCloudPropertyPointers();
  }

  SplatCloud( const SplatCloud &_splatCloud );

  inline ~SplatCloud() { clear(); }

  inline SplatCloud &operator=( const SplatCloud &_splatCloud ) { SplatCloud temp( _splatCloud ); swap( temp ); return *this; }

  void clear();

  void swap( SplatCloud &_splatCloud );

  //----------------

  void clearSplats();

  //----------------

  void pushbackSplat();

  //----------------

  void resizeSplats( unsigned int _num );

  //----------------

  template <typename T> unsigned int eraseSplatsByIndex( const T &_indices );

  //----------------

  template <typename T> unsigned int eraseSplatsByFlag( const std::vector<T> &_flags );

  //----------------

  template <typename T> void cropSplats( const T &_indices );

  //----------------

  inline unsigned int numSplats() const { return numSplats_; }

  // == MEMBERS =====================================================

private:

  unsigned int numSplats_;

  //----------------------------------------------------------------



  // +------------------------+
  // |                        |
  // |   General Properties   |
  // |                        |
  // +------------------------+

  // == TYPEDEFS =====================================================

public:

  typedef std::string BasePropertyHandle;

  //----------------

  class SplatPropertyInterface
  {
    friend class SplatCloud; 
  public:
    virtual size_t               sizeOf()  const = 0; 
    virtual const std::type_info &typeId() const = 0; 
  private:
    virtual inline ~SplatPropertyInterface() { }       
    virtual SplatPropertyInterface *clone() const = 0; 
    virtual void clear()                                  = 0; 
    virtual void pushback()                               = 0; 
    virtual void resize( unsigned int _num )              = 0; 
    virtual void crop( const std::vector<int> &_indices ) = 0; 
  private:
    void operator=( const SplatPropertyInterface & ); 
  };

  //----------------

  class CloudPropertyInterface
  {
    friend class SplatCloud; 
  public:
    virtual size_t               sizeOf()  const = 0; 
    virtual const std::type_info &typeId() const = 0; 
  private:
    virtual inline ~CloudPropertyInterface() { }       
    virtual CloudPropertyInterface *clone() const = 0; 
  private:
    void operator=( const CloudPropertyInterface & ); 
  };

  //----------------

  class SplatPropertyMapEntry
  {
  public:
    SplatPropertyMapEntry()                                                   : property_( 0     ), numRequests_( 0    ) { } 
    SplatPropertyMapEntry( SplatPropertyInterface *_prop, unsigned int _num ) : property_( _prop ), numRequests_( _num ) { } 
  public:
    SplatPropertyInterface *property_;   
    unsigned int           numRequests_; 
  };

  //----------------

  class CloudPropertyMapEntry
  {
  public:
    CloudPropertyMapEntry()                                                   : property_( 0     ), numRequests_( 0    ) { } 
    CloudPropertyMapEntry( CloudPropertyInterface *_prop, unsigned int _num ) : property_( _prop ), numRequests_( _num ) { } 
  public:
    CloudPropertyInterface *property_;   
    unsigned int           numRequests_; 
  };

  //----------------

  typedef std::map<BasePropertyHandle, SplatPropertyMapEntry> SplatPropertyMap;

  //----------------

  typedef std::map<BasePropertyHandle, CloudPropertyMapEntry> CloudPropertyMap;

  //----------------

public:

  template <typename T>
  class PropertyHandleT : public BasePropertyHandle
  {
  public:
    explicit inline PropertyHandleT<T>( const BasePropertyHandle &_handle ) : BasePropertyHandle( _handle ) { } 
  };

  //----------------

  template <typename T>
  class SplatPropertyT : public SplatPropertyInterface
  {
    friend class SplatCloud; 
  public:
    typedef                      T                   Value;          
    typedef typename std::vector<T>::      reference      Reference; 
    typedef typename std::vector<T>::const_reference ConstReference; 
  public:
    explicit inline SplatPropertyT<T>( const PropertyHandleT<T> &_handle, unsigned int _num ) : data_( _num ) { } 
    inline      Reference data( int _idx )       { return data_[ _idx ]; } 
    inline ConstReference data( int _idx ) const { return data_[ _idx ]; } 
  public:
    virtual inline size_t               sizeOf()  const override { return sizeof( T ); } 
    virtual inline const std::type_info &typeId() const override { return typeid( T ); } 
  private:
    virtual inline ~SplatPropertyT<T>() { }                                                    
    virtual inline SplatPropertyT<T> *clone() const override { return new SplatPropertyT<T>( *this ); } 
    virtual inline void clear()                     override { std::vector<T>().swap( data_ ); } 
    virtual inline void pushback()                  override { data_.push_back( T() );         } 
    virtual inline void resize( unsigned int _num ) override { data_.resize( _num );           } 
    virtual        void crop( const std::vector<int> &_indices ) override;                       
  private:
    void operator=( const SplatPropertyT<T> & ); 
  private:
    std::vector<T> data_; 
  };

  //----------------

  template <typename T>
  class CloudPropertyT : public CloudPropertyInterface
  {
    friend class SplatCloud; 
  public:
    typedef       T   Value;          
    typedef       T &      Reference; 
    typedef const T & ConstReference; 
  public:
    explicit inline CloudPropertyT<T>( const PropertyHandleT<T> &_handle ) { } 
    inline      Reference data()       { return data_; } 
    inline ConstReference data() const { return data_; } 
  public:
    virtual inline size_t               sizeOf()  const override  { return sizeof( T ); } 
    virtual inline const std::type_info &typeId() const override { return typeid( T ); } 
  private:
    virtual inline ~CloudPropertyT<T>() { }                                                    
    virtual inline CloudPropertyT<T> *clone() const override { return new CloudPropertyT<T>( *this ); } 
  private:
    void operator=( const CloudPropertyT<T> & ); 
  private:
    T data_; 
  };

  //-- DECLARATIONS ------------------------------------------------

public:

  void clearSplatProperties();

  void clearCloudProperties();

  //----------------


  template <typename T>        SplatPropertyT<T> *requestSplatProperty( const PropertyHandleT<T> &_handle );
  template <typename T>        CloudPropertyT<T> *requestCloudProperty( const PropertyHandleT<T> &_handle );
  template <typename T> inline SplatPropertyT<T> *requestSplatProperty( const BasePropertyHandle &_handle ) { return requestSplatProperty( PropertyHandleT<T>( _handle ) ); }
  template <typename T> inline CloudPropertyT<T> *requestCloudProperty( const BasePropertyHandle &_handle ) { return requestCloudProperty( PropertyHandleT<T>( _handle ) ); }


  //----------------


  template <typename T>        SplatPropertyT<T> *releaseSplatProperty( const PropertyHandleT<T> &_handle );
  template <typename T>        CloudPropertyT<T> *releaseCloudProperty( const PropertyHandleT<T> &_handle );
  template <typename T> inline SplatPropertyT<T> *releaseSplatProperty( const BasePropertyHandle &_handle ) { return releaseSplatProperty( PropertyHandleT<T>( _handle ) ); }
  template <typename T> inline CloudPropertyT<T> *releaseCloudProperty( const BasePropertyHandle &_handle ) { return releaseCloudProperty( PropertyHandleT<T>( _handle ) ); }


  //----------------


  template <typename T>              SplatPropertyT<T> *getSplatProperty( const PropertyHandleT<T> &_handle );
  template <typename T>        const SplatPropertyT<T> *getSplatProperty( const PropertyHandleT<T> &_handle ) const;
  template <typename T>              CloudPropertyT<T> *getCloudProperty( const PropertyHandleT<T> &_handle );
  template <typename T>        const CloudPropertyT<T> *getCloudProperty( const PropertyHandleT<T> &_handle ) const;
  template <typename T> inline       SplatPropertyT<T> *getSplatProperty( const BasePropertyHandle &_handle )       { return getSplatProperty( PropertyHandleT<T>( _handle ) ); }
  template <typename T> inline const SplatPropertyT<T> *getSplatProperty( const BasePropertyHandle &_handle ) const { return getSplatProperty( PropertyHandleT<T>( _handle ) ); }
  template <typename T> inline       CloudPropertyT<T> *getCloudProperty( const BasePropertyHandle &_handle )       { return getCloudProperty( PropertyHandleT<T>( _handle ) ); }
  template <typename T> inline const CloudPropertyT<T> *getCloudProperty( const BasePropertyHandle &_handle ) const { return getCloudProperty( PropertyHandleT<T>( _handle ) ); }


  //----------------


  inline const SplatPropertyMap &splatProperties() const { return splatProperties_; }

  inline const CloudPropertyMap &cloudProperties() const { return cloudProperties_; }


  //----------------

private:

  void copySplatProperties( const SplatCloud &_splatCloud );

  void copyCloudProperties( const SplatCloud &_splatCloud );

  // == MEMBERS =====================================================

private:

  SplatPropertyMap splatProperties_;

  CloudPropertyMap cloudProperties_;

  //----------------------------------------------------------------



  // +---------------------------+
  // |                           |
  // |   Predefined Properties   |
  // |                           |
  // +---------------------------+

  // == TYPEDEFS =====================================================

public:

  typedef struct
  {
    int   cameraObjectId_; 
    int   featureIdx_;     
    float x_;              
    float y_;              
  } View;

  //----------------

  typedef ACG::Vec3f        Position;
  typedef ACG::Vec3uc       Color;
  typedef ACG::Vec3f        Normal;
  typedef float             Pointsize;
  typedef int               Index;
  typedef std::vector<View> Viewlist;
  typedef unsigned char     Selection; // Do *not* use bool to prevent further trouble because a std::vector<bool>::reference is *not* the same as a reference to bool.

  //----------------

  typedef std::vector<Position > PositionVector;
  typedef std::vector<Color    > ColorVector;
  typedef std::vector<Normal   > NormalVector;
  typedef std::vector<Pointsize> PointsizeVector;
  typedef std::vector<Index    > IndexVector;
  typedef std::vector<Viewlist > ViewlistVector;
  typedef std::vector<Selection> SelectionVector;

  //----------------

private:

  typedef PropertyHandleT<Position > PositionsHandle;
  typedef PropertyHandleT<Color    > ColorsHandle;
  typedef PropertyHandleT<Normal   > NormalsHandle;
  typedef PropertyHandleT<Pointsize> PointsizesHandle;
  typedef PropertyHandleT<Index    > IndicesHandle;
  typedef PropertyHandleT<Viewlist > ViewlistsHandle;
  typedef PropertyHandleT<Selection> SelectionsHandle;

  //-- DECLARATIONS ------------------------------------------------

public:


  inline bool requestPositions()  { positionsProperty_  = requestSplatProperty( POSITIONS_HANDLE  ); return (positionsProperty_  != 0); }
  inline bool requestColors()     { colorsProperty_     = requestSplatProperty( COLORS_HANDLE     ); return (colorsProperty_     != 0); }
  inline bool requestNormals()    { normalsProperty_    = requestSplatProperty( NORMALS_HANDLE    ); return (normalsProperty_    != 0); }
  inline bool requestPointsizes() { pointsizesProperty_ = requestSplatProperty( POINTSIZES_HANDLE ); return (pointsizesProperty_ != 0); }
  inline bool requestIndices()    { indicesProperty_    = requestSplatProperty( INDICES_HANDLE    ); return (indicesProperty_    != 0); }
  inline bool requestViewlists()  { viewlistsProperty_  = requestSplatProperty( VIEWLISTS_HANDLE  ); return (viewlistsProperty_  != 0); }
  inline bool requestSelections() { selectionsProperty_ = requestSplatProperty( SELECTIONS_HANDLE ); return (selectionsProperty_ != 0); }


  //----------------


  inline void releasePositions()  { positionsProperty_  = releaseSplatProperty( POSITIONS_HANDLE  ); }
  inline void releaseColors()     { colorsProperty_     = releaseSplatProperty( COLORS_HANDLE     ); }
  inline void releaseNormals()    { normalsProperty_    = releaseSplatProperty( NORMALS_HANDLE    ); }
  inline void releasePointsizes() { pointsizesProperty_ = releaseSplatProperty( POINTSIZES_HANDLE ); }
  inline void releaseIndices()    { indicesProperty_    = releaseSplatProperty( INDICES_HANDLE    ); }
  inline void releaseViewlists()  { viewlistsProperty_  = releaseSplatProperty( VIEWLISTS_HANDLE  ); }
  inline void releaseSelections() { selectionsProperty_ = releaseSplatProperty( SELECTIONS_HANDLE ); }


  //----------------


  inline bool hasPositions()  const { return (positionsProperty_  != 0); }
  inline bool hasColors()     const { return (colorsProperty_     != 0); }
  inline bool hasNormals()    const { return (normalsProperty_    != 0); }
  inline bool hasPointsizes() const { return (pointsizesProperty_ != 0); }
  inline bool hasIndices()    const { return (indicesProperty_    != 0); }
  inline bool hasViewlists()  const { return (viewlistsProperty_  != 0); }
  inline bool hasSelections() const { return (selectionsProperty_ != 0); }


  //----------------


  inline       Position  &positions ( int _idx )       { return positionsProperty_-> data( _idx ); }
  inline const Position  &positions ( int _idx ) const { return positionsProperty_-> data( _idx ); }
  inline       Color     &colors    ( int _idx )       { return colorsProperty_->    data( _idx ); }
  inline const Color     &colors    ( int _idx ) const { return colorsProperty_->    data( _idx ); }
  inline       Normal    &normals   ( int _idx )       { return normalsProperty_->   data( _idx ); }
  inline const Normal    &normals   ( int _idx ) const { return normalsProperty_->   data( _idx ); }
  inline       Pointsize &pointsizes( int _idx )       { return pointsizesProperty_->data( _idx ); }
  inline const Pointsize &pointsizes( int _idx ) const { return pointsizesProperty_->data( _idx ); }
  inline       Index     &indices   ( int _idx )       { return indicesProperty_->   data( _idx ); }
  inline const Index     &indices   ( int _idx ) const { return indicesProperty_->   data( _idx ); }
  inline       Viewlist  &viewlists ( int _idx )       { return viewlistsProperty_-> data( _idx ); }
  inline const Viewlist  &viewlists ( int _idx ) const { return viewlistsProperty_-> data( _idx ); }
  inline       Selection &selections( int _idx )       { return selectionsProperty_->data( _idx ); }
  inline const Selection &selections( int _idx ) const { return selectionsProperty_->data( _idx ); }


  //----------------

private:

  inline void resetPredefinedSplatPropertyPointers()
  {
    positionsProperty_  = 0;
    colorsProperty_     = 0;
    normalsProperty_    = 0;
    pointsizesProperty_ = 0;
    indicesProperty_    = 0;
    viewlistsProperty_  = 0;
    selectionsProperty_ = 0;
  }

  inline void resetPredefinedCloudPropertyPointers() { }

  inline void getPredefinedSplatPropertyPointers()
  {
    positionsProperty_  = getSplatProperty( POSITIONS_HANDLE  );
    colorsProperty_     = getSplatProperty( COLORS_HANDLE     );
    normalsProperty_    = getSplatProperty( NORMALS_HANDLE    );
    pointsizesProperty_ = getSplatProperty( POINTSIZES_HANDLE );
    indicesProperty_    = getSplatProperty( INDICES_HANDLE    );
    viewlistsProperty_  = getSplatProperty( VIEWLISTS_HANDLE  );
    selectionsProperty_ = getSplatProperty( SELECTIONS_HANDLE );
  }

  inline void getPredefinedCloudPropertyPointers() { }

  inline void swapPredefinedSplatPropertyPointers( SplatCloud &_splatCloud )
  {
    std::swap( positionsProperty_,  _splatCloud.positionsProperty_  );
    std::swap( colorsProperty_,     _splatCloud.colorsProperty_     );
    std::swap( normalsProperty_,    _splatCloud.normalsProperty_    );
    std::swap( pointsizesProperty_, _splatCloud.pointsizesProperty_ );
    std::swap( indicesProperty_,    _splatCloud.indicesProperty_    );
    std::swap( viewlistsProperty_,  _splatCloud.viewlistsProperty_  );
    std::swap( selectionsProperty_, _splatCloud.selectionsProperty_ );
  }

  inline void swapPredefinedCloudPropertyPointers( SplatCloud &_splatCloud ) { }

  //-- MEMBERS -----------------------------------------------------

private:

  SplatPropertyT<Position>  *positionsProperty_;
  SplatPropertyT<Color>     *colorsProperty_;
  SplatPropertyT<Normal>    *normalsProperty_;
  SplatPropertyT<Pointsize> *pointsizesProperty_;
  SplatPropertyT<Index>     *indicesProperty_;
  SplatPropertyT<Viewlist>  *viewlistsProperty_;
  SplatPropertyT<Selection> *selectionsProperty_;

  //----------------

  static const PositionsHandle  POSITIONS_HANDLE;
  static const ColorsHandle     COLORS_HANDLE;
  static const NormalsHandle    NORMALS_HANDLE;
  static const PointsizesHandle POINTSIZES_HANDLE;
  static const IndicesHandle    INDICES_HANDLE;
  static const ViewlistsHandle  VIEWLISTS_HANDLE;
  static const SelectionsHandle SELECTIONS_HANDLE;

  //----------------------------------------------------------------

};


//================================================================


#if defined(INCLUDE_TEMPLATES) && !defined(SPLATCLOUDT_CC)
#  include "SplatCloudT_impl.hh"
#endif


//================================================================


#endif // SPLATCLOUD_HH