MObject.h

Go to the documentation of this file.

/* This software and supporting documentation are distributed by
 *     Institut Federatif de Recherche 49
 *     CEA/NeuroSpin, Batiment 145,
 *     91191 Gif-sur-Yvette cedex
 *     France
 *
 * This software is governed by the CeCILL-B license under
 * French law and abiding by the rules of distribution of free software.
 * You can  use, modify and/or redistribute the software under the
 * terms of the CeCILL-B license as circulated by CEA, CNRS
 * and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 *
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-B license and that you accept its terms.
 */
 
 
#ifndef ANA_MOBJECT_MOBJECT_H
#define ANA_MOBJECT_MOBJECT_H
 
#include <anatomist/object/Object.h>
 
 
namespace anatomist
{
  class ObjectListIterator;
  class const_ObjectListIterator;
  class ObjectVectorIterator;
  class const_ObjectVectorIterator;
  class AGraphIterator;
  class const_AGraphIterator;
  class Fusion2DIterator;
  class const_Fusion2DIterator;
  class Fusion3DIterator;
  class const_Fusion3DIterator;
  class ATexSurfaceIterator;
  class const_ATexSurfaceIterator;
  class Referential;
  class Geometry;

  class BaseIterator
  {
  public:
    virtual ~BaseIterator() {}
    virtual BaseIterator* clone() const = 0;
    bool operator == ( const BaseIterator & ) const;
    virtual bool operator != ( const BaseIterator & ) const;
    virtual bool operator != ( const ObjectListIterator & ) const
    { return( true ); }
    virtual bool operator != ( const const_ObjectListIterator & ) const
    { return( true ); }
    virtual bool operator != ( const ObjectVectorIterator & ) const
    { return( true ); }
    virtual bool operator != ( const const_ObjectVectorIterator & ) const
    { return( true ); }
    virtual bool operator != ( const AGraphIterator & ) const
    { return( true ); }
    virtual bool operator != ( const const_AGraphIterator & ) const
    { return( true ); }
    virtual bool operator != ( const Fusion2DIterator & ) const
    { return( true ); }
    virtual bool operator != ( const const_Fusion2DIterator & ) const
    { return( true ); }
    virtual bool operator != ( const Fusion3DIterator & ) const
    { return( true ); }
    virtual bool operator != ( const const_Fusion3DIterator & ) const
    { return( true ); }
    virtual bool operator != ( const ATexSurfaceIterator & ) const
    { return( true ); }
    virtual bool operator != ( const const_ATexSurfaceIterator & ) const
    { return( true ); }
    virtual AObject* operator * () const = 0;
    virtual BaseIterator & operator ++ () = 0;
    virtual BaseIterator & operator -- () = 0;
  };
 
 
  inline bool BaseIterator::operator == 
  ( const BaseIterator & x ) const
  {
    //cout << "BaseIterator::operator == ( const BaseIterator & x )\n";
    return( ! (operator != (x)) );
  }
 
 
  inline bool BaseIterator::operator != 
  ( const BaseIterator & i ) const
  {
    return( i.operator != ( *this )  );
  }
 

  class AIterator
  {
  public:
    AIterator();
    AIterator( const AIterator & );
    AIterator( BaseIterator * );
    ~AIterator();
 
    AIterator & operator = ( const AIterator & );
    bool operator == (const AIterator & ) const;
    bool operator != ( const AIterator & ) const;
    AIterator & operator ++();
    AIterator operator ++ ( int );
    AIterator & operator -- ();
    AIterator operator -- ( int );
    AObject *operator *() const;
    BaseIterator & subIterator() { return( *_iterator ); }

    typedef void datatype;
 
  protected:
    BaseIterator *_iterator;
  };
 
 
  inline AIterator::AIterator() 
    : _iterator( 0 )
  {
  }
 
 
  inline AIterator::AIterator( const AIterator & x )
    : _iterator( x._iterator->clone() )
  {
  }
 
 
  inline AIterator::AIterator( BaseIterator *i )
    : _iterator( i )
  {
  }
 
 
  inline AIterator::~AIterator()
  {
    if( _iterator ) delete _iterator;
  }
 
 
  inline AIterator & 
  AIterator::operator = ( const AIterator & i )
  {
    if( this == &i ) return( *this );
    if( _iterator ) delete _iterator;
    _iterator = i._iterator->clone();
    return( *this );
  }
 
 
  inline bool 
  AIterator::operator == ( const AIterator & i ) const
  {
    //cout << "AIterator::operator ==\n";
    return( *_iterator == *i._iterator );
  }
 
 
  inline bool 
  AIterator::operator != ( const AIterator & i ) const
  {
    return( *_iterator != *i._iterator );
  }
 
 
  inline AIterator & 
  AIterator::operator ++ ()
  {
    ++ *_iterator;
    return( *this );
  }
 
 
  inline AIterator 
  AIterator::operator ++ ( int )
  {
    AIterator tmp = _iterator->clone();
 
    ++ *_iterator;
    return( tmp );
  }
 
 
  inline AIterator & 
  AIterator::operator -- ()
  {
    -- *_iterator;
    return( *this );
  }
 
 
  inline AIterator
  AIterator::operator -- ( int )
  {
    AIterator tmp = _iterator->clone();
 
    -- *_iterator;
    return( tmp );
  }
 
 
  inline AObject *AIterator::operator * () const
  {
    return( **_iterator );
  }
 

  class MObject : public AObject
  {
  public:
 
    typedef AIterator iterator;
    typedef AIterator const_iterator;
 
    MObject();
    virtual ~MObject();
 
    virtual const MObject* mObjectAPI() const;
    virtual MObject* mObjectAPI();

    int isMultiObject() const { return( true ); }
    virtual int MType() const = 0;
    virtual void setReferential( Referential* ref );
    virtual void setReferentialInheritance( AObject* );

    virtual size_t size() const = 0;
    virtual iterator begin() = 0;
    virtual const_iterator begin() const = 0;
    virtual iterator end() = 0;
    virtual const_iterator end() const = 0;
    virtual void insert( AObject * ) = 0;
    virtual const_iterator find( const AObject * ) const = 0;
    virtual void erase( iterator & ) = 0;
    void eraseObject( AObject *obj );
 
    virtual float MinT() const;
    virtual float MaxT() const;
 
    virtual bool boundingBox2D( std::vector<float> & bmin,
                                std::vector<float> & bmax ) const;
 
    virtual std::vector<float> voxelSize() const;
    virtual bool boundingBox( std::vector<float> & bmin,
                              std::vector<float> & bmax ) const;


    virtual AObject* objectAt( const std::vector<float> & pos, float tol = 0 );
    virtual const AObject* nearestVertex( const std::vector<float> & pos,
                                          int *vertex, float *distance,
                                          float tol = -1,
                                          int *polygon = 0,
                                          bool tex_only = false,
                                          int target_poly = -1 ) const;
 


    virtual std::list<AObject *> renderedSubObjects( const ViewState & ) const;
    virtual bool render( PrimList &, const ViewState & );
    virtual bool renderingIsObserverDependent() const;
    virtual bool Is2DObject();
    virtual bool Is3DObject();
    virtual bool isTransparent() const;
 


    virtual void update(const Observable* observable, void* arg);
 
    virtual bool CanRemove( AObject *obj );
 

    virtual void setContentChanged() const;
    bool hasContentChanged() const;
    virtual void clearHasChangedFlags() const;
 
    virtual void SetMaterial( const Material & mat );
    virtual void setPalette( const AObjectPalette & pal );
    virtual bool shouldRemoveChildrenWithMe() const;
    virtual std::list<AObject *> generativeChildren() const;
 
  protected:
    virtual void _insertObject( AObject* o );
    virtual void _eraseObject( AObject* o );
    virtual void updateSubObjectReferential( const AObject* o );
    virtual void clearReferentialInheritance();
 
    mutable bool _contentHasChanged;
  };
 
 
  inline MObject::MObject() : AObject()
  {
    _contentHasChanged = false;
  }
 
 
  inline void MObject::eraseObject( AObject * obj )
  {
    iterator    i = find( obj );
    if( i != end() )
      {
        erase( i );
        _contentHasChanged = true;
        setChanged();
      }
    else
      {
        std::cout << "unable to erase object " << obj->name() 
                  << " from MObject "
                  << name() << " : object not found\n";
      }
  }
 
 
 
  inline bool MObject::CanRemove( AObject * ) 
  { 
    //   always allowed by default 
    return( true ); 
  }
 
}
 
 
#endif