propagate_along_field.hh

Go to the documentation of this file.

/*
Copyright CEA (2014).
Copyright Université Paris XI (2014).
 
Contributor: Yann Leprince <yann.leprince@ylep.fr>.
 
This file is part of highres-cortex, a collection of software designed
to process high-resolution magnetic resonance images of the cerebral
cortex.
 
This software is governed by the CeCILL licence 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
licence 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 licence, 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 scientific
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 licence and that you accept its terms.
*/
 
#ifndef YL_PROPAGATE_ALONG_FIELD_HH
#define YL_PROPAGATE_ALONG_FIELD_HH
 
#include <boost/shared_ptr.hpp>
 
#include <cartodata/volume/volume.h>
#include <aims/vector/vector.h>
#include "field.hh"
 
namespace yl
{

class PropagateAlongField
{
public:
  explicit PropagateAlongField(const boost::shared_ptr<VectorField3d>& vector_field);
  PropagateAlongField(const carto::VolumeRef<float>& fieldx,
                      const carto::VolumeRef<float>& fieldy,
                      const carto::VolumeRef<float>& fieldz);
  virtual ~PropagateAlongField();

  void setVerbose(int verbosity=1);

  void setStep(float step);

  void setMaxIter(unsigned int max_iter);

  template<typename Tlabel>
  Tlabel
  ascend_until_nonzero(const Point3df &start_point,
                       const carto::VolumeRef<Tlabel> &seeds,
                       Tlabel ignore_label) const;

  template<typename Tlabel>
  carto::VolumeRef<Tlabel>
  propagate_regions(const carto::VolumeRef<Tlabel> &seeds,
                    Tlabel target_label=0) const;

  template<typename Tlabel>
  std::pair<carto::VolumeRef<Tlabel>, carto::VolumeRef<float> >
  propagate_regions_keeping_dests(const carto::VolumeRef<Tlabel> &seeds,
                                  Tlabel target_label=0) const;
 
 
  static const float default_step;
  static const unsigned int default_max_iter;

  template <class TVisitor, typename Tlabel>
  bool
  visitor_ascension(const Point3df &start_point,
                    const carto::VolumeRef<Tlabel> &seeds,
                    Tlabel ignore_label,
                    TVisitor& visitor) const;

  template <typename Tlabel>
  float
  integrate_field_along_advection(const Point3df &start_point,
                                  const carto::VolumeRef<Tlabel> &seeds,
                                  const boost::shared_ptr<ScalarField>& field,
                                  Tlabel ignore_label) const;
 

  class AbortedAdvection
  {
  };
 
  template<typename Tlabel>
  carto::VolumeRef<float>
  integrate_from_region(const carto::VolumeRef<Tlabel> &seeds,
                        const boost::shared_ptr<ScalarField>& field,
                        Tlabel target_label=0) const;
 
private:
  boost::shared_ptr<VectorField3d> m_vector_field;
  unsigned int m_max_iter;
  float m_step;
  int m_verbose;
 
  static const int debug_output = 0;
 
  template <template <typename> class ResultChooserTemplate, typename Tlabel>
  typename ResultChooserTemplate<Tlabel>::result_type
  internal_ascension(const Point3df &start_point,
                     const carto::VolumeRef<Tlabel> &seeds,
                     Tlabel ignore_label,
                     const ResultChooserTemplate<Tlabel>& result_chooser) const;
 
  template <class ResultChooser, typename Tlabel>
  typename ResultChooser::result_type
  internal_ascension(const Point3df &start_point,
                     const carto::VolumeRef<Tlabel> &seeds,
                     Tlabel ignore_label,
                     const ResultChooser& result_chooser) const;
 
  template<class ResultRecorder, typename Tlabel>
  void
  internal_propagation(const carto::VolumeRef<Tlabel> &seeds,
                       Tlabel target_label,
                       ResultRecorder& result_recorder) const;
};
 
} // namespace yl
 
#endif // !defined(YL_PROPAGATE_ALONG_FIELD_HH)