LambdaMST2D.ih

/**
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as
 *  published by the Free Software Foundation, either version 3 of the
 *  License, or  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 **/
 
/**
 * @file LambdaMST2D.ih
 * @author Kacper Pluta (\c kacper.pluta@esiee.fr )
 * Laboratoire d'Informatique Gaspard-Monge - LIGM, France
 *
 * @date 2014/10/03
 *
 * This file is part of the DGtal library.
 */
 
namespace DGtal
{
 
  template < typename TSpace, typename TSegmentation, typename Functor >
  inline
  LambdaMST2DEstimator< TSpace, TSegmentation, Functor >::LambdaMST2DEstimator() : dssSegments ( 0 ) {}
 
  template < typename TSpace, typename TSegmentation, typename Functor >
  inline
  void
  LambdaMST2DEstimator< TSpace, TSegmentation, Functor >::init ( ConstIterator itb, ConstIterator ite )
  {
    myBegin = itb;
    myEnd = ite;
  }
 
  template < typename TSpace, typename TSegmentation, typename Functor >
  inline
  void
  LambdaMST2DEstimator< TSpace, TSegmentation, Functor >::attach ( Alias<TSegmentation>  segmentComputer )
  {
    dssSegments = &segmentComputer;
  }
 
  template < typename TSpace, typename TSegmentation, typename Functor >
  inline
  bool
  LambdaMST2DEstimator< TSpace, TSegmentation, Functor >::isValid () const
  {
    return ( dssSegments != 0 );
  }
 
  template < typename TSpace, typename TSegmentation, typename Functor >
  inline
  typename TSpace::RealVector
  LambdaMST2DEstimator< TSpace, TSegmentation, Functor >::eval ( const Point & p )
  {
    assert ( dssSegments != 0 );
    typename TSegmentation::SegmentComputerIterator DSS = dssSegments->begin();
    typename TSegmentation::SegmentComputerIterator lastDSS = dssSegments->end();
    Value tangent, partial;
    for ( ; DSS != lastDSS; ++DSS )
    {
      if ( DSS->isInDSS ( p ) )
      {
        size_t pos = std::distance ( DSS.begin(), std::find ( DSS.begin(), DSS.end(), p ) ) + 1;
        size_t dssLen = std::distance ( DSS.begin(), DSS.end() ) + 1;
        SegmentComputer comp ( *DSS );
        partial = myFunctor ( comp, pos, dssLen );
        tangent += partial;
      }
    }
    if ( tangent.second != 0. )
      return tangent.first / tangent.second;
    else
      return tangent.first;
  }
 
  template < typename TSpace, typename TSegmentation, typename Functor >
  template <typename OutputIterator>
  inline
  OutputIterator
  LambdaMST2DEstimator< TSpace, TSegmentation, Functor >::eval ( ConstIterator itb, ConstIterator ite,
                                                                 OutputIterator result )
  {
    assert ( ( myBegin != myEnd ) && isValid ( ) && std::distance ( myBegin, itb ) >= 0 && std::distance ( myEnd, ite ) <= 0 && ( itb != ite ) );
    dssSegments->setSubRange ( itb, ite );
    std::vector < Value > outValues ( std::distance ( itb, ite ) );
    typename TSegmentation::SegmentComputerIterator DSS = dssSegments->begin();
    typename TSegmentation::SegmentComputerIterator lastDSS = dssSegments->end();
    for ( ; DSS != lastDSS; ++DSS )
    {
      size_t dssLen = std::distance ( DSS.begin(), DSS.end() );
      SegmentComputer comp ( *DSS );
      for ( unsigned int i = 0; i < dssLen; i++ )
        outValues[ std::distance ( itb, DSS.begin() ) + i ] += myFunctor ( comp, i + 1, dssLen + 1 );
    }
    accumulate ( outValues, result );
    return result;
  }
 
  template < typename TSpace, typename TSegmentation, typename Functor >
  template <typename OutputIterator>
  inline
  void
  LambdaMST2DEstimator< TSpace, TSegmentation, Functor >::accumulate ( std::vector < Value > & outValues, OutputIterator & result  )
  {
    for ( unsigned int i = 0; i < outValues.size(); i++ )
    {
      Value & tangent = outValues[i];
      if ( tangent.second != 0. )
        *result++ = ( tangent.first / tangent.second );
      else
        *result++ = tangent.first;
    }
  }
}