SegmenterRegionGrowingFunctions.h

Go to the documentation of this file.

/*  Copyright (C) 2015 National Institute For Space Research (INPE) - Brazil.

    This file is part of the TerraLib - a Framework for building GIS enabled applications.

    TerraLib 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.

    TerraLib 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 Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with TerraLib. See COPYING. If not, write to
    TerraLib Team at <terralib-team@terralib.org>.
 */

/*!
  \file terralib/rp/SegmenterRegionGrowingfunctions.h
  \brief Useful functions for Region Growing segmentation.
 */

#ifndef __TERRALIB_RP_INTERNAL_SEGMENTERREGIONGROWINGFUNCTIONS_H
#define __TERRALIB_RP_INTERNAL_SEGMENTERREGIONGROWINGFUNCTIONS_H

#include "Matrix.h"
#include "SegmenterIdsManager.h"
#include "SegmenterRegionGrowingMerger.h"
#include "SegmenterRegionGrowingSegment.h"
#include "SegmenterSegmentsBlock.h"
#include "../common/progress/TaskProgress.h"

#include <cstring>

namespace te
{
  namespace rp
  {
    namespace rg
    {
      /*!
        \brief Definition for segments ids matrix type.
      */
      typedef Matrix< SegmenterSegmentsBlock::SegmentIdDataType >
      SegmentsIdsMatrixT;

      /*!
        \brief Iteration counter type.
      */
      typedef unsigned short int IterationCounterType;

      /*!
        \brief Mean Strategy feature type.
      */
      typedef float MeanFeatureType;
      
      /*!
        \brief Baatz Strategy feature type.
      */
      typedef float BaatzFeatureType;
      
      /*!
        \brief Export the segments IDs to a tif file.
        \param segmentsIds The output segment ids container.
        \param normto8bits If true, a 8 bits file will be generated.
        \param fileName The output tif file name.
      */
      void exportSegs2Tif( const SegmentsIdsMatrixT& segmentsIds,
                           bool normto8bits, const std::string& fileName );

      /*!
        \brief Returns the number of active segments.
        \param actSegsListHeadPtr A pointer the the active segments list head.
        \return Returns the number of active segments.
      */
      template< typename FeatureDataTypeT >
      unsigned long int getActiveSegmentsNumber( SegmenterRegionGrowingSegment< FeatureDataTypeT >* const actSegsListHeadPtr )
      {
        unsigned long int returnValue = 0;
      
        SegmenterRegionGrowingSegment< FeatureDataTypeT >* currSegPtr = actSegsListHeadPtr;
      
        while( currSegPtr ) {
          ++returnValue;
          currSegPtr = currSegPtr->m_nextActiveSegment;
        }

        return returnValue;
      }

      /*!
        \brief Locatie the minimim dissimilarity neighbor segment.
        \param segPtr Target segment pointer
        \param merger Merger instance refecence.
        \param minDissimilarityNeighborPtr Found neighbor semgnet pointer or null pointer if not found.
        \param minDissimilarityValue The found dissimilarity value.
        \param auxMergeDataPtr1 A pointer to a valid input merge data object.
        \param auxMergeDataPtr2 A pointer to a second valid input merge data object.
        \param minDissimilarityMergeDataPtr This pointer will be set to point to one of the given auxiliary merge data updated with the current minimum forward segment parameters.
      */
      template< typename FeatureDataTypeT >
      void findMinDissimilaryNeighbor(
        SegmenterRegionGrowingSegment< FeatureDataTypeT > const * const segPtr,
        const SegmenterRegionGrowingMerger< FeatureDataTypeT >& merger,
        SegmenterRegionGrowingMergeData* const auxMergeDataPtr1,
        SegmenterRegionGrowingMergeData* const auxMergeDataPtr2,
        SegmenterRegionGrowingSegment< FeatureDataTypeT >** minDissimilarityNeighborPtr,
        DissimilarityTypeT& minDissimilarityValue,
        SegmenterRegionGrowingMergeData** minDissimilarityMergeDataPtr )
      {
        assert( segPtr );
        assert( minDissimilarityNeighborPtr );
        assert( minDissimilarityMergeDataPtr );

        (*minDissimilarityNeighborPtr) = 0;
        *minDissimilarityMergeDataPtr = 0;
        minDissimilarityValue = std::numeric_limits< DissimilarityTypeT >::max();

        const unsigned int& neighborSegmentsSize = segPtr->m_neighborSegmentsSize;
        SegmenterRegionGrowingSegment< FeatureDataTypeT >* auxNeighborSegPtr = 0;
        DissimilarityTypeT currentDissimilarityValue = 0;
        SegmenterRegionGrowingMergeData* currentTempMergeDataPtr = auxMergeDataPtr1;

        for( unsigned int neighborSegIdx = 0 ; neighborSegIdx < neighborSegmentsSize ;
          ++neighborSegIdx )
        {
          auxNeighborSegPtr = segPtr->m_neighborSegments[
            neighborSegIdx ];

          if( auxNeighborSegPtr != 0 )
          {
            currentDissimilarityValue = merger.getDissimilarity( segPtr,
              auxNeighborSegPtr, currentTempMergeDataPtr );

            if( currentDissimilarityValue < minDissimilarityValue )
            {
              minDissimilarityValue = currentDissimilarityValue;
              (*minDissimilarityNeighborPtr) = auxNeighborSegPtr;
              (*minDissimilarityMergeDataPtr) = currentTempMergeDataPtr;

              if( currentTempMergeDataPtr == auxMergeDataPtr1 )
              {
                currentTempMergeDataPtr = auxMergeDataPtr2;
              }
              else
              {
                currentTempMergeDataPtr = auxMergeDataPtr1;
              }
            }
          }
        }
      }

      /*!
        \brief Merge segment 2 into segment 1.
        \param segmentsIds Segments ids container.
        \param merger The merger instance to use.
        \param actSegsListHeadPtr A pointer the the active segments list head.
        \param minMergesIterationThreshold Stop itarating when the number of merges drops below this value (Range 0-100);
        \note Segment 1 merge iteration will not be updated
        \note Segment 2 will be disabled at the end of merge process and all its neighbors pointers deleted.
      */
      template< typename FeatureDataTypeT >
      void merge2Segments(
        SegmenterRegionGrowingSegment< FeatureDataTypeT >* segPtr1,
        SegmenterRegionGrowingSegment< FeatureDataTypeT >* segPtr2,
        SegmenterRegionGrowingMergeData const * const mergeDataPtr,
        SegmentsIdsMatrixT& segmentsIds,
        SegmenterRegionGrowingMerger< FeatureDataTypeT >& merger,
        SegmenterRegionGrowingSegment< FeatureDataTypeT >** actSegsListHeadPtrPtr )
      {
        assert( segPtr1 );
        assert( segPtr2 );
        assert( actSegsListHeadPtrPtr );

        // features

        merger.mergeFeatures( segPtr1, segPtr2, mergeDataPtr );

        // updating the segments Ids container matrix

        const unsigned int& segmentsLineBound = segPtr2->m_yBound;
        const unsigned int& segmentColStart = segPtr2->m_xStart;
        const unsigned int& segmentColBound = segPtr2->m_xBound;
        const SegmenterSegmentsBlock::SegmentIdDataType& segment1Id = segPtr1->m_id;
        const SegmenterSegmentsBlock::SegmentIdDataType& segment2Id = segPtr2->m_id;
        SegmenterSegmentsBlock::SegmentIdDataType* segmentsIdsLinePtr = 0;
        unsigned int segmentCol = 0;

        for( unsigned int segmentsLine = segPtr2->m_yStart ;
             segmentsLine < segmentsLineBound ; ++segmentsLine )
        {
          segmentsIdsLinePtr = segmentsIds[ segmentsLine ];

          for( segmentCol = segmentColStart ; segmentCol < segmentColBound ;
            ++segmentCol )
          {
            if(
                segmentsIdsLinePtr[ segmentCol ]
                ==
                segment2Id
              )
            {
              segmentsIdsLinePtr[ segmentCol ] = segment1Id;
            }
          }
        }

        // updating segment 1 basic attributes

        segPtr1->m_size += segPtr2->m_size;

        segPtr1->m_xStart = std::min(
          segPtr1->m_xStart,
          segPtr2->m_xStart );
        segPtr1->m_xBound = std::max(
          segPtr1->m_xBound,
          segPtr2->m_xBound );

        segPtr1->m_yStart = std::min(
          segPtr1->m_yStart,
          segPtr2->m_yStart );
        segPtr1->m_yBound = std::max(
          segPtr1->m_yBound,
          segPtr2->m_yBound );

        segPtr1->removeNeighborSegmentPtr( segPtr2 );

        // updating the segment 2 neighborhood segments
        // with the current segment

        const unsigned int& neighborSegmentsSize = segPtr2->m_neighborSegmentsSize;
        SegmenterRegionGrowingSegment< FeatureDataTypeT >* neighborSegPtr = 0;

        for( unsigned int neighborSegIdx = 0 ; neighborSegIdx < neighborSegmentsSize;
             ++neighborSegIdx )
        {
          neighborSegPtr = segPtr2->m_neighborSegments[ neighborSegIdx ];

          if(
             (
               neighborSegPtr != 0
             )
             &&
             (
               neighborSegPtr != segPtr1 )
             )
          {
            // adding segment 2 neighborhood segments to the
            // segment 1, if it is not already there

            segPtr1->addNeighborSegmentPtr( neighborSegPtr );

            // removing the merged segment reference from its neighbor
            // list
            neighborSegPtr->removeNeighborSegmentPtr( segPtr2 );

            // adding the segment 1 into segment 2 neighbor
            // neighborhood segments list, if it is not already there

            neighborSegPtr->addNeighborSegmentPtr( segPtr1 );
          }
        }

        // disabling the  merged segment
        // The merged segment id will be given back to ids manager

        if( segPtr2 == (*actSegsListHeadPtrPtr) )
        {
          (*actSegsListHeadPtrPtr) = (*actSegsListHeadPtrPtr)->m_nextActiveSegment;

          if( (*actSegsListHeadPtrPtr) ) (*actSegsListHeadPtrPtr)->m_prevActiveSegment = 0;
        }
        else
        {
          if( segPtr2->m_prevActiveSegment )
          {
            segPtr2->m_prevActiveSegment->m_nextActiveSegment =
              segPtr2->m_nextActiveSegment;
          }

          if( segPtr2->m_nextActiveSegment )
          {
            segPtr2->m_nextActiveSegment->m_prevActiveSegment =
              segPtr2->m_prevActiveSegment;
          }
        }

        segPtr2->disable();

        segPtr2->removeAllNeighborSegmentsPtrs();
      }

      /*!
        \brief Merge too small segments to its closer neighbor.
        \param maximumSegmentSize Only merge segments with sizes smaller than this value.
        \param segmentsIds Segments ids container.
        \param segmenterIdsManager A segments ids manager to acquire unique segments ids.
        \param merger The merger instance to use.
        \param globalMergeIterationsCounter A reference to a iteration number counter (this variable will be only incremented, never zeroed. It never must be reset. ).
        \param actSegsListHeadPtr A pointer the the active segments list head.
      */
      template< typename FeatureDataTypeT >
      void mergeTooSmallSegments( const unsigned int maximumSegmentSize,
        SegmentsIdsMatrixT& segmentsIds,
        SegmenterIdsManager& segmenterIdsManager,
        SegmenterRegionGrowingMerger< FeatureDataTypeT >& merger,
        IterationCounterType& globalMergeIterationsCounter,
        SegmenterRegionGrowingSegment< FeatureDataTypeT >** actSegsListHeadPtrPtr )
      {
        TERP_TRUE_OR_THROW( actSegsListHeadPtrPtr != 0,
          "Invalid active segments list header pointer" );

        if( (*actSegsListHeadPtrPtr) == 0 ) return;

        // Globals

        unsigned long int iterationMergedSegmentsNumber = 0;
        SegmenterRegionGrowingSegment< FeatureDataTypeT >* minBackwardDissimilaritySegmentPtr = 0;
        DissimilarityTypeT minBackwardDissimilarityValue = 0;
        SegmenterRegionGrowingSegment< FeatureDataTypeT >* currActSegPtr =
          (*actSegsListHeadPtrPtr);
        SegmenterRegionGrowingSegment< FeatureDataTypeT >* nextActSegPtr = 0;

        // Merge data

        SegmenterRegionGrowingMergeData* backwardDissimilarityMergeDataPtr = 0;

        merger.createMergeData( &backwardDissimilarityMergeDataPtr );
        std::unique_ptr< SegmenterRegionGrowingMergeData >
          backwardDissimilarityAuxMergeDataPtr1(
          backwardDissimilarityMergeDataPtr );

        merger.createMergeData( &backwardDissimilarityMergeDataPtr );
        std::unique_ptr< SegmenterRegionGrowingMergeData >
          backwardDissimilarityAuxMergeDataPtr2(
          backwardDissimilarityMergeDataPtr );

        // Main iterations loop

        do
        {
          currActSegPtr = (*actSegsListHeadPtrPtr);

          // Updating the merger state
          merger.update( *actSegsListHeadPtrPtr );

          iterationMergedSegmentsNumber = 0;

          // iterating over each segment
          do
          {
            if( currActSegPtr->m_size < maximumSegmentSize )
            {
              // finding the neighbor segment with minimum dissimilary value
              // related to the current segment

              findMinDissimilaryNeighbor( currActSegPtr,
                merger,
                backwardDissimilarityAuxMergeDataPtr1.get(),
                backwardDissimilarityAuxMergeDataPtr2.get(),
                &minBackwardDissimilaritySegmentPtr,
                minBackwardDissimilarityValue,
                &backwardDissimilarityMergeDataPtr );

              if( minBackwardDissimilaritySegmentPtr )
              {
                nextActSegPtr = currActSegPtr->m_nextActiveSegment;

                merge2Segments( minBackwardDissimilaritySegmentPtr, currActSegPtr,
                  backwardDissimilarityMergeDataPtr, segmentsIds,
                  merger, actSegsListHeadPtrPtr
                );

                minBackwardDissimilaritySegmentPtr->m_mergetIteration = globalMergeIterationsCounter;

                currActSegPtr = nextActSegPtr;

                ++iterationMergedSegmentsNumber;
              }
              else
              {
                currActSegPtr = currActSegPtr->m_nextActiveSegment;
              }
            }
            else
            {
              currActSegPtr = currActSegPtr->m_nextActiveSegment;
            }
          } while( currActSegPtr );

//           std::cout << std::endl << "Merging small segments -" <<
//             " globalMergeIterationsCounter:" <<
//             globalMergeIterationsCounter << " iterationMergedSegmentsNumber:"
//             << iterationMergedSegmentsNumber << std::endl;

          ++globalMergeIterationsCounter;
        } while( iterationMergedSegmentsNumber );
      }

      /*!
        \brief Merge segments following a maximum dissimilarity thresold.
        \param disimilarityThreshold Maximum dissimilarity threshold.
        \param enablelocalMutualBestFitting Enable/disable the use of mutual best fitting (two segments will be merged only if both have the mininum neighbor dissimilarity to each other).
        \param segmentsIds Segments ids container.
        \param segmenterIdsManager A segments ids manager to acquire unique segments ids.
        \param merger The merger instance to use.
        \param globalMergeIterationsCounter A reference to a iteration number counter (this variable will be only incremented, never zeroed. It never must be reset. ).
        \param sameItMergesThreshold Min percentual difference from one iteration to the next (in terms of merges number) to execute one iteration where multiple merges are allowed for the same segment or to increase the Similarity Threshold(valid ranged: 0 -> 100).
        \param segmentsSimIncreaseSteps The maximum number of steps to increment the disimilarity threshold value for the cases where no segment merge occurred - zero will disable segment similarity threshold increments.
        \param actSegsListHeadPtrPtr A pointer the the active segments list head.
        \param taskProgressPtr A pointer to a progress interface to check for user cancel or a null pointer (no pulse performed).
        \return true if OK, false on errors
      */
      template< typename FeatureDataTypeT >
      bool mergeSegments( const DissimilarityTypeT maxDisimilarityThreshold,
        const bool enablelocalMutualBestFitting,
        SegmentsIdsMatrixT& segmentsIds,
        SegmenterIdsManager& segmenterIdsManager,
        SegmenterRegionGrowingMerger< FeatureDataTypeT >& merger,
        IterationCounterType& globalMergeIterationsCounter,
        const double sameItMergesThreshold,
        const unsigned int segmentsSimIncreaseSteps,
        SegmenterRegionGrowingSegment< FeatureDataTypeT >** actSegsListHeadPtrPtr,
        te::common::TaskProgress* taskProgressPtr )
      {
        TERP_TRUE_OR_THROW( actSegsListHeadPtrPtr != 0,
          "Invalid active segments list header pointer" );

        if( (*actSegsListHeadPtrPtr) == 0 ) return true;

        // Globals

        const DissimilarityTypeT disimilarityThresholdStepValue =
          segmentsSimIncreaseSteps ? maxDisimilarityThreshold / segmentsSimIncreaseSteps
          : 0;

        unsigned long int maxAchievedMergesPerIteration = 0;
        unsigned long int currentIterationMergedSegmentsNumber = 0;
        SegmenterRegionGrowingSegment< FeatureDataTypeT >* currActSegPtr =
          (*actSegsListHeadPtrPtr);
        SegmenterRegionGrowingSegment< FeatureDataTypeT >* nextActSegPtr = 0;
        bool enableSameIterationMerges = false;
        DissimilarityTypeT currentDisimilarityThreshold =
          segmentsSimIncreaseSteps ? 0 : maxDisimilarityThreshold;
        IterationCounterType seqLowMergesItsNumber = 0;

        // forward variables

        SegmenterRegionGrowingSegment< FeatureDataTypeT >* minForwardDissimilaritySegmentPtr = 0;
        DissimilarityTypeT minForwardDissimilarityValue = 0;
        SegmenterRegionGrowingMergeData* minForwardDissimilarityMergeDataPtr = 0;


        SegmenterRegionGrowingMergeData* forwardDissimilarityAuxMergeDataHandler1NPtr = 0;
        merger.createMergeData( &forwardDissimilarityAuxMergeDataHandler1NPtr );
        std::unique_ptr< SegmenterRegionGrowingMergeData >
          forwardDissimilarityAuxMergeDataHandler1(
          forwardDissimilarityAuxMergeDataHandler1NPtr );

        SegmenterRegionGrowingMergeData* forwardDissimilarityAuxMergeDataHandler2NPtr = 0;
        merger.createMergeData( &forwardDissimilarityAuxMergeDataHandler2NPtr );
        std::unique_ptr< SegmenterRegionGrowingMergeData >
          forwardDissimilarityAuxMergeDataHandler2(
          forwardDissimilarityAuxMergeDataHandler2NPtr );

        // backward variables

        SegmenterRegionGrowingSegment< FeatureDataTypeT >* minBackwardDissimilaritySegmentPtr = 0;
        DissimilarityTypeT minBackwardDissimilarityValue = 0;

        SegmenterRegionGrowingMergeData* backwardDissimilarityMergeDataPtr = 0;

        merger.createMergeData( &backwardDissimilarityMergeDataPtr );
        std::unique_ptr< SegmenterRegionGrowingMergeData >
          backwardDissimilarityAuxMergeDataPtr1(
          backwardDissimilarityMergeDataPtr );

        merger.createMergeData( &backwardDissimilarityMergeDataPtr );
        std::unique_ptr< SegmenterRegionGrowingMergeData >
          backwardDissimilarityAuxMergeDataPtr2(
          backwardDissimilarityMergeDataPtr );

        // Main iterations loop

        do
        {
          currActSegPtr = (*actSegsListHeadPtrPtr);

          // Updating the merger state
          merger.update( *actSegsListHeadPtrPtr );

          currentIterationMergedSegmentsNumber = 0;

          // iterating over each segment
          do
          {
            nextActSegPtr = currActSegPtr->m_nextActiveSegment;

            if(
                ( currActSegPtr->m_mergetIteration < globalMergeIterationsCounter )
                ||
                enableSameIterationMerges
              )
            {
              currActSegPtr->m_mergetIteration = globalMergeIterationsCounter;

              // finding the neighbor segment with minimum dissimilary value
              // related to the current segment

              findMinDissimilaryNeighbor( currActSegPtr,
                merger,
                forwardDissimilarityAuxMergeDataHandler1NPtr,
                forwardDissimilarityAuxMergeDataHandler2NPtr,
                &minForwardDissimilaritySegmentPtr,
                minForwardDissimilarityValue,
                &minForwardDissimilarityMergeDataPtr );

              // if the min forward dissimilarity segment was found
              if(
                  ( minForwardDissimilaritySegmentPtr )
                  &&
                  ( minForwardDissimilarityValue <= currentDisimilarityThreshold )
                  &&
                  (
                    (
                      minForwardDissimilaritySegmentPtr->m_mergetIteration
                      <
                      globalMergeIterationsCounter
                    )
                    ||
                    enableSameIterationMerges
                  )
                )
              {
                if( enablelocalMutualBestFitting )
                {
                  findMinDissimilaryNeighbor( minForwardDissimilaritySegmentPtr,
                    merger,
                    backwardDissimilarityAuxMergeDataPtr1.get(),
                    backwardDissimilarityAuxMergeDataPtr2.get(),
                    &minBackwardDissimilaritySegmentPtr,
                    minBackwardDissimilarityValue,
                    &backwardDissimilarityMergeDataPtr );

                  if( minBackwardDissimilaritySegmentPtr != currActSegPtr )
                  {
                    minForwardDissimilaritySegmentPtr = 0;
                  }
                }

                if( minForwardDissimilaritySegmentPtr )
                {
                  minForwardDissimilaritySegmentPtr->m_mergetIteration =
                    globalMergeIterationsCounter;

                  if( currActSegPtr->m_size > minForwardDissimilaritySegmentPtr->m_size )
                  {
                    if( nextActSegPtr == minForwardDissimilaritySegmentPtr )
                    {
                      nextActSegPtr = minForwardDissimilaritySegmentPtr->m_nextActiveSegment;
                    }

                    merge2Segments( currActSegPtr, minForwardDissimilaritySegmentPtr,
                      minForwardDissimilarityMergeDataPtr, segmentsIds,
                      merger, actSegsListHeadPtrPtr
                    );
                  }
                  else
                  {
                    merge2Segments( minForwardDissimilaritySegmentPtr, currActSegPtr,
                      minForwardDissimilarityMergeDataPtr, segmentsIds,
                      merger, actSegsListHeadPtrPtr
                    );
                  }

                  ++currentIterationMergedSegmentsNumber;
                }
              }
            }

            // going to the next segment
            currActSegPtr = nextActSegPtr;

          } while( currActSegPtr );

          maxAchievedMergesPerIteration = std::max( currentIterationMergedSegmentsNumber,
            maxAchievedMergesPerIteration );

//           std::cout << std::endl << "Merging segments -"
//             << " maxAchievedMergesPerIteration:" << maxAchievedMergesPerIteration
//             << " currentIterationMergedSegmentsNumber:" << currentIterationMergedSegmentsNumber
//             << " currentDisimilarityThreshold:" << currentDisimilarityThreshold
//             << " enableSameIterationMerges:" << enableSameIterationMerges
//             << " globalMergeIterationsCounter:" << globalMergeIterationsCounter
//             << " seqLowMergesItsNumber:" << seqLowMergesItsNumber
//             << std::endl;

          if(
              ((double)currentIterationMergedSegmentsNumber)
              <
              (
               ((double)maxAchievedMergesPerIteration)
                *
                ( sameItMergesThreshold / 100.0 )
              )
            )
          {
            ++seqLowMergesItsNumber;
          }
          else
          {
            seqLowMergesItsNumber = 0;
          }

          enableSameIterationMerges = false;

          if( currentIterationMergedSegmentsNumber == 0 )
          {
            if( currentDisimilarityThreshold ==  maxDisimilarityThreshold )
            {
              break;
            }
            else
            {
              currentDisimilarityThreshold = std::min( maxDisimilarityThreshold,
                currentDisimilarityThreshold + disimilarityThresholdStepValue );

              maxAchievedMergesPerIteration = 0;
            }
          }
          else if( seqLowMergesItsNumber > 3 )
          {
            seqLowMergesItsNumber = 0;
            maxAchievedMergesPerIteration = 0;

            if( currentDisimilarityThreshold == maxDisimilarityThreshold )
            {
              enableSameIterationMerges = true;
            }
            else
            {
              currentDisimilarityThreshold = std::min( maxDisimilarityThreshold,
                currentDisimilarityThreshold + disimilarityThresholdStepValue );
            }
          }

          ++globalMergeIterationsCounter;

          if(
              taskProgressPtr
              &&
              ( ! taskProgressPtr->isActive() )
            )
          {
            return false;
          }

        } while( true );

        return true;
      }

    } // end namespace rg
  } // end namespace rp
} // end namespace te

#endif  // __TERRALIB_RP_INTERNAL_SEGMENTERREGIONGROWINGFUNCTIONS_H