foldgraphattributes.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 AIMS_FOLDGRAPH_FOLDGRAPHATTRIBUTES
#define AIMS_FOLDGRAPH_FOLDGRAPHATTRIBUTES
 
#include <cartodata/volume/volume.h>
#include <aims/mesh/mesher.h>
 
class Graph;
 
namespace aims
{
  class AffineTransformation3d;
  template <typename T> class BucketMap;
 
  class FoldGraphAttributes
  {
  public:
    FoldGraphAttributes( const carto::rc_ptr<carto::Volume<int16_t> > & skel,
                         Graph & graph,
                         const AffineTransformation3d *
                           talairachAffineTransformation3d = 0,
                         int16_t inside = 0, int16_t outside = 11, 
                         bool withmeshes = true,
                         const std::vector<int> & graphversion
                             = std::vector<int>() );
    void cleanup();
    void doAll();
 
    void makeMeshes();
    void makeGlobalAttributes();
    void makeSimpleSurfaceAttributes();
    void makeJunctionAttributes();
    void makePliDePassageAttributes();
    void makeCorticalRelationAttributes();
    void makeSummaryGlobalAttributes();
 
    carto::VolumeRef<int16_t> &getDepth();
    const carto::VolumeRef<int16_t> &getDepth() const;
    carto::VolumeRef<int16_t> &getNDepth();
    const carto::VolumeRef<int16_t> &getNDepth() const;
    carto::VolumeRef<float> &getBrainDepth();
    carto::VolumeRef<float> &getBrainDepthGradX();
    carto::VolumeRef<float> &getBrainDepthGradY();
    carto::VolumeRef<float> &getBrainDepthGradZ();
    const carto::VolumeRef<float> &getBrainDepth() const;
    const carto::VolumeRef<float> &getBrainDepthGradX() const;
    const carto::VolumeRef<float> &getBrainDepthGradY() const;
    const carto::VolumeRef<float> &getBrainDepthGradZ() const;
    carto::VolumeRef<float> &getDilatedDepth();
    carto::VolumeRef<float> &getDilatedDepthGradX();
    carto::VolumeRef<float> &getDilatedDepthGradY();
    carto::VolumeRef<float> &getDilatedDepthGradZ();
    const carto::VolumeRef<float> &getDilatedDepth() const;
    const carto::VolumeRef<float> &getDilatedDepthGradX() const;
    const carto::VolumeRef<float> &getDilatedDepthGradY() const;
    const carto::VolumeRef<float> &getDilatedDepthGradZ() const;
    float getDepthfactor() const;
    void prepareDepthMap();
    void prepareBrainDepthMap();
    carto::VolumeRef<int16_t> rebuildCorticalRelations();
    std::vector<int> graphVersion() const;
    void thickness( const BucketMap<float> & midinterfaceDistances,
                    const carto::VolumeRef<int16_t> voronoi );
    void greyAndCSFVolumes( const carto::VolumeRef<int16_t> gw,
                            const carto::VolumeRef<int16_t> voronoi );
    void setMaxThreads( int mt );
    int maxThreads() const { return _maxthreads; }
    Mesher & mesher() { return _mesher; }
 
  private:
    class DistanceMapThreadContext;
    friend class DistanceMapThreadContext;
 
    void prepareNativeDepthMap();
    void prepareNormalizedDepthMap(
      const carto::rc_ptr<carto::Volume<int16_t> > & th );
    void prepareDilatedDepthMap(
      const carto::rc_ptr<carto::Volume<int16_t> > & th );
    void prepareGradientX();
    void prepareGradientY();
    void prepareGradientZ();
    void prepareBrainGradientX();
    void prepareBrainGradientY();
    void prepareBrainGradientZ();
 
    carto::VolumeRef<int16_t>   _skel;
    Graph               & _graph;
    int16_t             _inside;
    int16_t             _outside;
    const AffineTransformation3d        *_motion;
    carto::VolumeRef<int16_t>   _depth;
    carto::VolumeRef<int16_t>   _ndepth;
    carto::VolumeRef<float>     _braindepthmap;
    carto::VolumeRef<float>     _braindepthmap_gradX;
    carto::VolumeRef<float>     _braindepthmap_gradY;
    carto::VolumeRef<float>     _braindepthmap_gradZ;
    carto::VolumeRef<float>     _dilated_depthmap;
    carto::VolumeRef<float>     _dilated_depthmap_gradX;
    carto::VolumeRef<float>     _dilated_depthmap_gradY;
    carto::VolumeRef<float>     _dilated_depthmap_gradZ;
    bool                _domeshes;
    std::vector<int>    _graphversion;
    int                 _maxthreads;
    Mesher              _mesher;
  };
 
}
 
#endif