Graph.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_GRAPH_GRAPH_H
#define ANA_GRAPH_GRAPH_H


#include <anatomist/mobject/MObject.h>
#include <anatomist/graph/attribAObject.h>
#include <anatomist/graph/AGraphIterator.h>
#include <anatomist/surface/glcomponent.h>
#include <graph/graph/graph.h>
#include <aims/data/data.h>


class QGraphProperties;

namespace anatomist
{

  class AGraphObject;

  class AGraph : public MObject, public GLComponent, public AttributedAObject
  {
  public:
    enum ColorMode
      {
        Normal, PropertyMap,
      };
    AGraph( Graph *dataGraph, const std::string & filename,
            bool init,
            const Point3d& labelDimension );
    AGraph( Graph *dataGraph, const std::string & filename,
            bool init = true,
            const Point3dl& labelDimension = Point3dl(64, 64, 64) );
    AGraph( carto::rc_ptr<Graph> dataGraph, const std::string & filename,
            bool init,
            const Point3d& labelDimension );
    AGraph( carto::rc_ptr<Graph> dataGraph, const std::string & filename,
            bool init = true,
            const Point3dl& labelDimension = Point3dl(64, 64, 64) );
    
    virtual ~AGraph();

    virtual AObject* clone( bool shallow = true );

    virtual int MType() const { return( AObject::GRAPH ); }
    virtual size_t size() const;
    virtual iterator begin();
    virtual const_iterator begin() const;
    virtual iterator end();
    virtual const_iterator end() const;
    virtual void insert( AObject * );
    virtual void insert( AObject* obj, std::string syntacticAtt );
    virtual void insert( const carto::shared_ptr<AObject> & obj,
                         std::string syntacticAtt = "fold" );
    void insert( AObject* obj, carto::GenericObject* vertex );
    virtual const_iterator find( const AObject * ) const;
    virtual void erase( iterator & );
    Graph* graph() const;
    void setGraph( carto::rc_ptr<Graph> );

    virtual bool render( PrimList &, const ViewState & );

    virtual void setGeomExtrema();
    virtual bool boundingBox( std::vector<float> & bmin,
                              std::vector<float> & bmax ) const;
    virtual bool boundingBox2D( std::vector<float> & bmin,
                                std::vector<float> & bmax ) const
    { return boundingBox( bmin, bmax ); }
    bool Is2DObject() { return(true); }
    bool Is3DObject() { return(true); }
    virtual AObject* objectAt( const std::vector<float> & pos, float tol = 0 );
    virtual void SetMaterial( const Material & mat );
    virtual bool shouldRemoveChildrenWithMe() const;

    virtual carto::GenericObject* attributed();
    virtual const carto::GenericObject* attributed() const;

    static AObject* LoadGraph( const std::string & filename,
                               carto::Object options=carto::none() );
    virtual bool save( const std::string & filename );
    virtual bool savable() const { return true; }
    void loadSubObjects( int mask );
    ColorMode colorMode() const;
    void setColorMode( ColorMode, bool update = true );
    int colorPropertyMask() const;
    void setColorPropertyMask( int, bool update = true );
    std::string colorProperty() const;
    void setColorProperty( const std::string &, bool update = true );
    void updateColors(void);

    static bool (*specialColorFunc)( AGraph* ag, AGraphObject* go,
                                     Material & mat );

    const carto::rc_ptr<std::map<std::string, std::vector<int> > >
    objAttColors() const;
    carto::rc_ptr<std::map<std::string, std::vector<int> > >
    objAttColors();
    void copyAttributes( const std::string & oldatt,
                         const std::string & newatt, bool removeOld = false,
                         bool dorels = false );
    std::string labelProperty( bool allowDefault = true ) const;
    void setLabelProperty( const std::string & prop );

    virtual std::vector<float> voxelSize() const;
    virtual void setVoxelSize( const std::vector<float> & vs );
    void clearLabelsVolume();
    void setLabelsVolumeDimension( unsigned dx, unsigned dy, unsigned dz );
    void setLabelsVolumeDimension( const Point3d & vd );
    void setLabelsVolumeDimension( const Point3dl & vd );
    Point3dl labelsVolumeDimension() const;
    AimsData<AObject *>& volumeOfLabels( int t = 0 ) ;
    virtual void createDefaultPalette( const std::string & name  );
    virtual void setPalette( const AObjectPalette & pal );
    void updateAfterAimsChange();

    virtual GLComponent* glAPI();
    virtual const GLComponent* glAPI() const;
    virtual const AObjectPalette* glPalette( unsigned tex = 0 ) const;
    virtual void setProperties( carto::Object options );
    std::set<std::string> mappableVertexProperties() const;
    std::set<std::string> mappableEdgeProperties() const;

  protected:
    void saveSubObjects( bool filenamechanged = false );
    virtual void fillVol( AimsData<AObject *> & vol, int t, float mx,
                          float my, float mz, float Mx, float My, float Mz );
    void recolor();
    void updateExtrema();

    typedef std::set<carto::shared_ptr<AObject> > datatype;

  private:
    friend class ::QGraphProperties;

    void initialize( const std::string & filename, bool init,
                     const Point3dl& labelDimension );

    struct Private;
    Private *d;
  };

}


namespace carto
{
  DECLARE_GENERIC_OBJECT_TYPE( anatomist::AGraph * )
}

#endif