Aim: More...

#include <DGtal/kernel/IntegralIntervals.h>

Public Types
typedef TInteger	Integer

using	Self = IntegralIntervals< Integer >

using	Interval = std::pair< Integer, Integer >

using	Container = std::vector< Interval >

using	Size = std::size_t

using	CIterator = typename Container::iterator

using	IntegerRange = std::vector< Integer >

Public Member Functions
	BOOST_CONCEPT_ASSERT ((concepts::CBoundedNumber< TInteger >))

	IntegralIntervals ()=default
	Default Constructor. More...

	IntegralIntervals (const Self &other)=default

	IntegralIntervals (Self &&other)=default

Self &	operator= (const Self &other)=default

Self &	operator= (Self &&other)=default

template<typename InputIterator >
	IntegralIntervals (InputIterator it, InputIterator itE)

void	clear ()
	Clears the data structure. More...

Container &	data ()

const Container &	data () const

bool	empty () const

Size	size () const

Size	capacity () const

bool	isConvex () const

std::set< Integer >	integerSet () const

std::vector< Integer >	integerVector () const

Size	count (Integer x) const

void	insert (Integer i)

void	insert (Integer f, Integer l)

void	insert (const Interval &I)

void	erase (Integer i)

void	erase (Integer f, Integer l)

void	erase (const Interval &I)

Self &	add (const Self &other)

Self &	subtract (const Self &other)

Self	set_union (const Self &other) const

Self	set_difference (const Self &other) const

Self	set_intersection (const Self &other) const

Self	set_symmetric_difference (const Self &other) const

Self	starOfPoints () const

Self	starOfCells () const

IntegerRange	extremaOfCells () const

bool	includes (const Self &other) const

bool	equals (const Self &other) const

void	selfDisplay (std::ostream &out) const

bool	isValid () const

Protected Member Functions
void	extend (CIterator it)

CIterator	lowerBound (Integer x)

Protected Attributes
Container	myData
	The sorted sequence of integral intervals. More...

Detailed Description

template<typename TInteger>
class DGtal::IntegralIntervals< TInteger >

Aim:

Description of template class 'IntegralIntervals'

A class that represents a set of integers using intervals. For instance the set X={-3,-2,0,1,2,4,7,8} is represented as the sorted vector ((-3,-2),(0,2),(4,4),(7,8)).

Inserting -1 into X induced the sorted vector ((-3,2),(4,4),(7,8)).

Template Parameters

TInteger any model of concepts::CBoundedNumber, for instance int, long, etc

Note: Useful to represent points of (especially convex) lattice polytopes or points of digital sets.

Definition at line 62 of file IntegralIntervals.h.

Member Typedef Documentation

◆ CIterator

template<typename TInteger >

using DGtal::IntegralIntervals< TInteger >::CIterator = typename Container::iterator

Definition at line 72 of file IntegralIntervals.h.

◆ Container

template<typename TInteger >

using DGtal::IntegralIntervals< TInteger >::Container = std::vector< Interval >

Definition at line 70 of file IntegralIntervals.h.

◆ Integer

template<typename TInteger >

typedef TInteger DGtal::IntegralIntervals< TInteger >::Integer

Definition at line 67 of file IntegralIntervals.h.

◆ IntegerRange

template<typename TInteger >

using DGtal::IntegralIntervals< TInteger >::IntegerRange = std::vector< Integer >

Definition at line 73 of file IntegralIntervals.h.

◆ Interval

template<typename TInteger >

using DGtal::IntegralIntervals< TInteger >::Interval = std::pair<Integer,Integer>

Definition at line 69 of file IntegralIntervals.h.

◆ Self

template<typename TInteger >

using DGtal::IntegralIntervals< TInteger >::Self = IntegralIntervals< Integer >

Definition at line 68 of file IntegralIntervals.h.

◆ Size

template<typename TInteger >

using DGtal::IntegralIntervals< TInteger >::Size = std::size_t

Definition at line 71 of file IntegralIntervals.h.

Constructor & Destructor Documentation

◆ IntegralIntervals() [1/4]

template<typename TInteger >

DGtal::IntegralIntervals< TInteger >::IntegralIntervals ( )

default

Default Constructor.

◆ IntegralIntervals() [2/4]

template<typename TInteger >

DGtal::IntegralIntervals< TInteger >::IntegralIntervals ( const Self & other )

default

Copy constructor

Parameters

other any other object.

◆ IntegralIntervals() [3/4]

template<typename TInteger >

DGtal::IntegralIntervals< TInteger >::IntegralIntervals ( Self && other )

default

Move constructor

Parameters

other any other object.

◆ IntegralIntervals() [4/4]

template<typename TInteger >

template<typename InputIterator >

DGtal::IntegralIntervals< TInteger >::IntegralIntervals	(	InputIterator	it,
		InputIterator	itE
	)

inline

Constructor from range

Template Parameters

InputIterator the type of forward iterator on a range of integer values.

Parameters

it,itE the range of integer values.

Definition at line 100 of file IntegralIntervals.h.

     {
       if ( it == itE ) return;
       Integer first = *it;
       Integer last  = *it;
       for ( ++it; it != itE; ++it )
         {
           Integer x = *it;
           if ( first <= x && x <= last ) continue;
           if ( x == last+1 )  { last = x;  continue; }
           if ( x == first-1 ) { first = x; continue; }
           insert( first, last );
           first = x;
           last  = x;
         }
       insert( first, last );
     }

References DGtal::IntegralIntervals< TInteger >::insert().

Member Function Documentation

◆ add()

template<typename TInteger >

Self& DGtal::IntegralIntervals< TInteger >::add ( const Self & other )

inline

Performs the union of set other with this object.

Parameters

other any intervals

Returns: a reference to this object

Definition at line 301 of file IntegralIntervals.h.

     {
       for ( const auto& I : other.myData )
         insert( I );
       return *this;
     }

References DGtal::IntegralIntervals< TInteger >::insert(), and DGtal::IntegralIntervals< TInteger >::myData.

Referenced by DGtal::IntegralIntervals< TInteger >::set_symmetric_difference(), and DGtal::IntegralIntervals< TInteger >::set_union().

◆ BOOST_CONCEPT_ASSERT()

template<typename TInteger >

DGtal::IntegralIntervals< TInteger >::BOOST_CONCEPT_ASSERT ( (concepts::CBoundedNumber< TInteger >) )

◆ capacity()

template<typename TInteger >

Size DGtal::IntegralIntervals< TInteger >::capacity ( ) const

inline

Returns: the current allocated space in the object container.

Definition at line 138 of file IntegralIntervals.h.

     {
       return myData.capacity();
     }

References DGtal::IntegralIntervals< TInteger >::myData.

◆ clear()

template<typename TInteger >

void DGtal::IntegralIntervals< TInteger >::clear ( )

inline

Clears the data structure.

Definition at line 119 of file IntegralIntervals.h.

119 { myData.clear(); }

References DGtal::IntegralIntervals< TInteger >::myData.

◆ count()

template<typename TInteger >

Size DGtal::IntegralIntervals< TInteger >::count ( Integer x ) const

inline

Parameters

x	any integer

Returns: the number of times the element x is in the set (either 0 or 1).

Definition at line 170 of file IntegralIntervals.h.

     {
       if ( empty() ) return 0;
       Size i = 0;
       Size j = myData.size() - 1;
       while ( i <= j )
         {
           const Size m = (i+j)/2;
           const Interval& I = myData[ m ]; // I = [a,...,b]
           if ( x < I.first ) // x < a
             {
               if ( m == 0 ) return 0;
               j = m - 1;
             }
           else if ( I.second < x ) // b < x
             i = m + 1;
           else // a <= x <= b
             return 1;
         }
       return 0;
     }

References DGtal::IntegralIntervals< TInteger >::empty(), and DGtal::IntegralIntervals< TInteger >::myData.

◆ data() [1/2]

template<typename TInteger >

Container& DGtal::IntegralIntervals< TInteger >::data ( )

inline

Returns: a reference to the current data

Definition at line 122 of file IntegralIntervals.h.

122 { return myData; }

References DGtal::IntegralIntervals< TInteger >::myData.

Referenced by DGtal::LatticeSetByIntervals< TSpace >::skeletonOfCells().

◆ data() [2/2]

template<typename TInteger >

const Container& DGtal::IntegralIntervals< TInteger >::data ( ) const

inline

Returns: a const reference to the current data

Definition at line 124 of file IntegralIntervals.h.

124 { return myData; }

References DGtal::IntegralIntervals< TInteger >::myData.

◆ empty()

template<typename TInteger >

bool DGtal::IntegralIntervals< TInteger >::empty ( ) const

inline

Returns: 'true' if the set contains no element

Definition at line 127 of file IntegralIntervals.h.

127 { return myData.empty(); }

References DGtal::IntegralIntervals< TInteger >::myData.

Referenced by DGtal::IntegralIntervals< TInteger >::count(), and DGtal::IntegralIntervals< TInteger >::lowerBound().

◆ equals()

template<typename TInteger >

bool DGtal::IntegralIntervals< TInteger >::equals ( const Self & other ) const

inline

Parameters

other any other integral set represented by intervals

Returns: 'true' iff this integer set equals the integer set other.

Definition at line 441 of file IntegralIntervals.h.

     {
       if ( myData.size() != other.myData.size() ) return false;
       auto it = myData.cbegin();
       for ( const auto& I : other.myData )
         {
           if ( it->first != I.first || it->second != I.second ) return false;
           ++it;
         }
       return true;
     }

References DGtal::IntegralIntervals< TInteger >::myData.

◆ erase() [1/3]

template<typename TInteger >

void DGtal::IntegralIntervals< TInteger >::erase ( const Interval & I )

inline

Erases the interval of integers from the sequence

Parameters

I	any valid interval (I.first <= I.second)

Definition at line 257 of file IntegralIntervals.h.

     {
       for ( std::size_t i = 0; i < myData.size(); )
         {
           Interval& J = myData[ i ];
           // I=[a,b], J=[a',b'], a <= b, a' <= b'
           if ( I.second < J.first )
             { break; } // b < a' : no further intersection
           if ( J.second < I.first )
             { ++i; continue; } // b' < a : no further intersection
           // a' <= b and a <= b'
           //       a ----------  b
           // a' ...............  a'
           //       b' ................. b'
           //
           // a' ..................... b' => a'..a-1       b+1..b'
           Interval K1( J.first, I.first - 1 );
           Interval K2( I.second + 1, J.second );
           bool K1_exist = K1.second >= K1.first;
           bool K2_exist = K2.second >= K2.first;
           if ( K1_exist && K2_exist )
             {
               myData[ i ] = K2;
               myData.insert( myData.begin() + i, K1 );
               break; // no further intersection possible
             }
           else if ( K1_exist )
             {
               myData[ i ] = K1; i++;
             }
           else if ( K2_exist )
             {
               myData[ i ] = K2; break;
             }
           else
             {
               myData.erase( myData.begin() + i );
             }
         }
     }

References DGtal::IntegralIntervals< TInteger >::myData.

◆ erase() [2/3]

template<typename TInteger >

void DGtal::IntegralIntervals< TInteger >::erase	(	Integer	f,
		Integer	l
	)

inline

Erases the interval of integers from the sequence

Parameters

f,l	any valid interval (f <= l)

Definition at line 250 of file IntegralIntervals.h.

     {
       erase( Interval( f, l ) );
     }

References DGtal::IntegralIntervals< TInteger >::erase().

◆ erase() [3/3]

template<typename TInteger >

void DGtal::IntegralIntervals< TInteger >::erase ( Integer i )

inline

Erases the integer i from the sequence

Parameters

i	any integer

Definition at line 244 of file IntegralIntervals.h.

     {
       erase( Interval( i, i ) );
     }

Referenced by DGtal::IntegralIntervals< TInteger >::erase(), and DGtal::IntegralIntervals< TInteger >::subtract().

◆ extend()

template<typename TInteger >

void DGtal::IntegralIntervals< TInteger >::extend ( CIterator it )

inlineprotected

At the given iterator position the current interval may overlap with the following ones. Merge them.

Parameters

it	any position

Definition at line 487 of file IntegralIntervals.h.

     {
       // std::cout  << "Extending" << std::endl;
       CIterator it_next = it; ++it_next;
       while ( it_next != myData.end() )
         {
           if ( it->second >= ( it_next->first - 1 ) )
             {
               it->second = std::max( it->second, it_next->second );
               ++it_next;
             }
           else break;
         }
       ++it;
       // std::cout  << "Erase from " << ( it - myData.begin() )
       //            << " to " << ( it_next - myData.begin() ) << std::endl;
       myData.erase( it, it_next );
     }

References max(), and DGtal::IntegralIntervals< TInteger >::myData.

Referenced by DGtal::IntegralIntervals< TInteger >::insert().

◆ extremaOfCells()

template<typename TInteger >

IntegerRange DGtal::IntegralIntervals< TInteger >::extremaOfCells ( ) const

inline

Returns: the range of points that contains the vertices of all the cells stored in this set. It is thus a range of integers.

Definition at line 409 of file IntegralIntervals.h.

     {
       IntegerRange C;
       for ( auto I : myData )
         {
           if ( ( I.first  & 0x1 ) != 0 ) I.first  -= 1;
           if ( ( I.second & 0x1 ) != 0 ) I.second += 1;
           for ( auto x = I.first; x <= I.second; x += 2 )
             C.push_back( x >> 1 ); // here x / 2 == x >> 1 since x is even
         }
       auto last = std::unique( C.begin(), C.end() );
       C.erase( last, C.end() );
       return C;
     }

References DGtal::IntegralIntervals< TInteger >::myData.

◆ includes()

template<typename TInteger >

bool DGtal::IntegralIntervals< TInteger >::includes ( const Self & other ) const

inline

Parameters

other any other integral set represented by intervals

Returns: 'true' iff this integer set includes the integer set other.

Definition at line 426 of file IntegralIntervals.h.

     {
       auto it = myData.cbegin();
       for ( const auto& I : other.myData )
         {
           // Find possible interval
           while ( it != myData.cend() && it->second < I.second ) ++it;
           if ( it == myData.cend() )  return false;
           if ( I.first < it->first ) return false;
         }
       return true;
     }

References DGtal::IntegralIntervals< TInteger >::myData.

◆ insert() [1/3]

template<typename TInteger >

void DGtal::IntegralIntervals< TInteger >::insert ( const Interval & I )

inline

Inserts the interval of integers into the sequence

Parameters

I	any valid interval (I.first <= I.second)

Definition at line 208 of file IntegralIntervals.h.

     {
       // Search position of first element.
       auto it = lowerBound( I.first );
       if ( it == myData.end() ) // if you reach the end, just add the interval
         {
           myData.push_back( I );
           if ( myData.size() >= 2 ) extend( myData.end() - 2 );
         }
       else if ( I.first < it->first )
         {
           // See if interval must merge with previous
           if ( it != myData.begin() )
             {
               auto it_prev = it; --it_prev;
               if ( I.first <= it_prev->second + 1 )
                 {
                   it_prev->second = I.second;
                   extend( it_prev );
                   return;
                 }
             }
           Size idx = it - myData.begin();
           // std::cout << "(Inserting " << idx << ")" << std::endl;;
           myData.insert( it, I );
           extend( myData.begin() + idx );
         }
       else // it->first <= I.first <= it->second
         {
           it->second = std::max( it->second, I.second );
           extend( it );
         }
     }

References DGtal::IntegralIntervals< TInteger >::extend(), DGtal::IntegralIntervals< TInteger >::lowerBound(), max(), and DGtal::IntegralIntervals< TInteger >::myData.

◆ insert() [2/3]

template<typename TInteger >

void DGtal::IntegralIntervals< TInteger >::insert	(	Integer	f,
		Integer	l
	)

inline

Inserts the interval of integers into the sequence

Parameters

f,l	any valid interval (f <= l)

Definition at line 201 of file IntegralIntervals.h.

     {
       insert( Interval( f, l ) );
     }

References DGtal::IntegralIntervals< TInteger >::insert().

◆ insert() [3/3]

template<typename TInteger >

void DGtal::IntegralIntervals< TInteger >::insert ( Integer i )

inline

Inserts the integer i into the sequence

Parameters

i	any integer

Definition at line 194 of file IntegralIntervals.h.

     {
       insert( Interval( i, i ) );
     }

Referenced by DGtal::IntegralIntervals< TInteger >::add(), DGtal::IntegralIntervals< TInteger >::insert(), DGtal::IntegralIntervals< TInteger >::IntegralIntervals(), and SCENARIO().

◆ integerSet()

template<typename TInteger >

std::set<Integer> DGtal::IntegralIntervals< TInteger >::integerSet ( ) const

inline

Returns: the set of integers

Definition at line 150 of file IntegralIntervals.h.

     {
       std::set<Integer> S;
       for ( const auto& I : myData )
         for ( Integer x = I.first; x <= I.second; x++ )
           S.insert( x );
       return S;
     }

References DGtal::IntegralIntervals< TInteger >::myData.

◆ integerVector()

template<typename TInteger >

std::vector<Integer> DGtal::IntegralIntervals< TInteger >::integerVector ( ) const

inline

Returns: the set of integers as a vector

Definition at line 159 of file IntegralIntervals.h.

     {
       std::vector<Integer> S;
       for ( const auto& I : myData )
         for ( Integer x = I.first; x <= I.second; x++ )
           S.push_back( x );
       return S;
     }

References DGtal::IntegralIntervals< TInteger >::myData.

◆ isConvex()

template<typename TInteger >

bool DGtal::IntegralIntervals< TInteger >::isConvex ( ) const

inline

Returns: 'true' if the set of integers is convex, i.e. empty or one interval.

Definition at line 144 of file IntegralIntervals.h.

     {
       return myData.size() <= 1;
     }

References DGtal::IntegralIntervals< TInteger >::myData.

◆ isValid()

template<typename TInteger >

bool DGtal::IntegralIntervals< TInteger >::isValid ( ) const

inline

Returns: 'true' iff the intervals are consistent and sorted.

Definition at line 469 of file IntegralIntervals.h.

     {
       for ( const auto& I : myData )
         if ( I.first > I.second ) return false;
       for ( Size i = 1; i < myData.size(); i++ )
         {
           if ( myData[i-1].second >= myData[i].first - 1 )
             return false;
         }
       return true;
     }

References DGtal::IntegralIntervals< TInteger >::myData.

◆ lowerBound()

template<typename TInteger >

CIterator DGtal::IntegralIntervals< TInteger >::lowerBound ( Integer x )

inlineprotected

Parameters

x	any integer

Returns: the iterator on the interval which is not before x, i.e. the interval containing x or, if it does not exist, the interval after.

Definition at line 511 of file IntegralIntervals.h.

     {
       // std::cout << "(lowerbound for " << x << ")" << std::endl;
       if ( empty() ) return myData.end();
       Size i = 0;
       Size j = myData.size() - 1;
       while ( i <= j )
         {
           const Size m = (i+j)/2;
           const Interval& I = myData[ m ]; // I = [a,...,b]
           if ( x < I.first ) // x < a
             {
               if ( m == 0 ) break;
               j = m - 1;
             }
           else if ( I.second < x ) // b < x
             i = m + 1;
           else // a <= x <= b
             return myData.begin() + m;
         }
       // std::cout << "(not found, return " << i <<  ")" << std::endl;
       return myData.begin() + i;
     }

References DGtal::IntegralIntervals< TInteger >::empty(), and DGtal::IntegralIntervals< TInteger >::myData.

Referenced by DGtal::IntegralIntervals< TInteger >::insert().

◆ operator=() [1/2]

template<typename TInteger >

Self& DGtal::IntegralIntervals< TInteger >::operator= ( const Self & other )

default

Assignment

Parameters

other any other object.

Returns: a reference to this object.

◆ operator=() [2/2]

template<typename TInteger >

Self& DGtal::IntegralIntervals< TInteger >::operator= ( Self && other )

default

Move assignment

Parameters

other any other object.

Returns: a reference to this object.

◆ selfDisplay()

template<typename TInteger >

void DGtal::IntegralIntervals< TInteger >::selfDisplay ( std::ostream & out ) const

inline

Writes/Displays the object on an output stream.

Parameters

out	the output stream where the object is written.

Definition at line 460 of file IntegralIntervals.h.

     {
       out << "[";
       for ( const auto& I : myData )
         out << " (" << I.first << "," << I.second << ")";
       out << " ]";
     }

References DGtal::IntegralIntervals< TInteger >::myData.

◆ set_difference()

template<typename TInteger >

Self DGtal::IntegralIntervals< TInteger >::set_difference ( const Self & other ) const

inline

Performs the set difference between this and other.

Parameters

other any other integral set represented by intervals

Returns: the set difference between this and other.

Definition at line 331 of file IntegralIntervals.h.

     {
       Self U = *this;
       U.subtract( other );
       return U;
     }

References DGtal::IntegralIntervals< TInteger >::subtract().

◆ set_intersection()

template<typename TInteger >

Self DGtal::IntegralIntervals< TInteger >::set_intersection ( const Self & other ) const

inline

Performs the set intersection between this and other.

Parameters

other any other integral set represented by intervals

Returns: the set difference between this and other.

Definition at line 341 of file IntegralIntervals.h.

     {
       Self A_plus_B  = set_union( other );
       Self A_delta_B = set_symmetric_difference( other );
       return A_plus_B.subtract( A_delta_B );
     }

References DGtal::IntegralIntervals< TInteger >::set_symmetric_difference(), DGtal::IntegralIntervals< TInteger >::set_union(), and DGtal::IntegralIntervals< TInteger >::subtract().

◆ set_symmetric_difference()

template<typename TInteger >

Self DGtal::IntegralIntervals< TInteger >::set_symmetric_difference ( const Self & other ) const

inline

Performs the set symmetric difference between this and other.

Parameters

other any other integral set represented by intervals

Returns: the set symmetric difference between this and other.

Definition at line 351 of file IntegralIntervals.h.

     {
       Self A_minus_B = *this;
       A_minus_B.subtract( other );
       Self B_minus_A = other;
       B_minus_A.subtract( *this );
       return A_minus_B.add( B_minus_A );
     }

References DGtal::IntegralIntervals< TInteger >::add(), and DGtal::IntegralIntervals< TInteger >::subtract().

Referenced by DGtal::IntegralIntervals< TInteger >::set_intersection().

◆ set_union()

template<typename TInteger >

Self DGtal::IntegralIntervals< TInteger >::set_union ( const Self & other ) const

inline

Performs the set union between this and other.

Parameters

other any other integral set represented by intervals

Returns: the set union between this and other.

Definition at line 321 of file IntegralIntervals.h.

     {
       Self U = *this;
       U.add( other );
       return U;
     }

References DGtal::IntegralIntervals< TInteger >::add().

Referenced by DGtal::IntegralIntervals< TInteger >::set_intersection().

◆ size()

template<typename TInteger >

Size DGtal::IntegralIntervals< TInteger >::size ( ) const

inline

Returns: the number of integers of the set.

Definition at line 130 of file IntegralIntervals.h.

     {
       Size nb = 0;
       for ( const auto& I : myData ) nb += 1 + I.second - I.first;
       return nb;
     }

References DGtal::IntegralIntervals< TInteger >::myData.

◆ starOfCells()

template<typename TInteger >

Self DGtal::IntegralIntervals< TInteger >::starOfCells ( ) const

inline

Consider the set of integers as cells represented by their Khalimsky coordinates, and build their star.

Returns: the star of these cells.

Definition at line 381 of file IntegralIntervals.h.

     {
       Self R( *this );
       for ( size_t i = 0; i < R.myData.size(); )
         {
           auto& I = R.myData[ i ];
           if ( ( I.first  & 0x1 ) == 0 ) I.first  -= 1;
           if ( ( I.second & 0x1 ) == 0 ) I.second += 1;
           // We have to be careful since extending this interval may
           // have reached the next interval.
           // We have to merge them in this case.
           i += 1;
           if ( i < R.myData.size() )
             {
               auto& Inext = R.myData[ i ];
               if ( Inext.first <= I.second+1 )
                 {
                   I.second = Inext.second;
                   R.myData.erase( R.myData.begin() + i );
                   i -= 1;
                 }
             }
         }
       return R;
     }

◆ starOfPoints()

template<typename TInteger >

Self DGtal::IntegralIntervals< TInteger >::starOfPoints ( ) const

inline

Consider the set of integers as points, transform them into pointels inn Khalimsky coordinates and build their star. All integers are multiplied by two. All doubled integers are completed with their immediately inferior and superior value.

Returns: the star of these points.

Definition at line 366 of file IntegralIntervals.h.

     {
       Self R( *this );
       for ( auto& I : R.myData )
         {
           I.first  = 2*I.first-1;
           I.second = 2*I.second+1;
         }
       return R;
     }

◆ subtract()

template<typename TInteger >

Self& DGtal::IntegralIntervals< TInteger >::subtract ( const Self & other )

inline

Subtract set other from this object.

Parameters

other any intervals

Returns: a reference to this object

Definition at line 311 of file IntegralIntervals.h.

     {
       for ( const auto& I : other.myData )
         erase( I );
       return *this;
     }

References DGtal::IntegralIntervals< TInteger >::erase(), and DGtal::IntegralIntervals< TInteger >::myData.

Referenced by DGtal::IntegralIntervals< TInteger >::set_difference(), DGtal::IntegralIntervals< TInteger >::set_intersection(), and DGtal::IntegralIntervals< TInteger >::set_symmetric_difference().

Field Documentation

◆ myData

template<typename TInteger >

Container DGtal::IntegralIntervals< TInteger >::myData

protected

The sorted sequence of integral intervals.

Definition at line 539 of file IntegralIntervals.h.

The documentation for this class was generated from the following file:

IntegralIntervals.h

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

template<typename TInteger> class DGtal::IntegralIntervals< TInteger >

Member Typedef Documentation

◆ CIterator

◆ Container

◆ Integer

◆ IntegerRange

◆ Interval

◆ Self

◆ Size

Constructor & Destructor Documentation

◆ IntegralIntervals() [1/4]

◆ IntegralIntervals() [2/4]

◆ IntegralIntervals() [3/4]

◆ IntegralIntervals() [4/4]

Member Function Documentation

◆ add()

◆ BOOST_CONCEPT_ASSERT()

◆ capacity()

◆ clear()

◆ count()

◆ data() [1/2]

◆ data() [2/2]

◆ empty()

◆ equals()

◆ erase() [1/3]

◆ erase() [2/3]

◆ erase() [3/3]

◆ extend()

◆ extremaOfCells()

◆ includes()

◆ insert() [1/3]

◆ insert() [2/3]

◆ insert() [3/3]

◆ integerSet()

◆ integerVector()

◆ isConvex()

◆ isValid()

◆ lowerBound()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ selfDisplay()

◆ set_difference()

◆ set_intersection()

◆ set_symmetric_difference()

◆ set_union()

◆ size()

◆ starOfCells()

◆ starOfPoints()

◆ subtract()

Field Documentation

◆ myData

template<typename TInteger>
class DGtal::IntegralIntervals< TInteger >