DGtal: DGtal::LatticeSetByIntervals< TSpace

#include <DGtal/kernel/LatticeSetByIntervals.h>

Inheritance diagram for DGtal::LatticeSetByIntervals< TSpace >:

Public Types
typedef TSpace	Space

using	Self = LatticeSetByIntervals< Space >

using	Point = typename Space::Point

using	Vector = typename Space::Vector

using	Integer = typename Space::Integer

using	PointRange = std::vector< Point >

using	Intervals = IntegralIntervals< Integer >

using	Interval = typename Intervals::Interval

using	Container = std::map< Point, Intervals >

using	RowIterator = typename Container::iterator

using	RowConstIterator = typename Container::const_iterator

using	LatticeSetByInterval = std::map< Point, Interval >

using	Size = std::size_t

using	size_type = Size

Public Member Functions
	BOOST_CONCEPT_ASSERT ((concepts::CSpace< TSpace >))

Standard services (construction, move, clear)
	LatticeSetByIntervals (Dimension axis=0)

	LatticeSetByIntervals (const Self &other)=default

	LatticeSetByIntervals (Self &&other)=default

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

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

template<typename PointIterator >
	LatticeSetByIntervals (PointIterator it, PointIterator itE, Dimension axis=0)

	LatticeSetByIntervals (const LatticeSetByInterval &aSet, Dimension axis)

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

void	setAxis (Dimension axis)

Dimension	axis () const

Container &	data ()

conversion services
PointRange	toPointRange () const

capacity services
bool	empty () const

Size	size () const

Size	max_size () const

modifier services
void	insert (Point p)

void	erase (Point p)

void	purge ()
	Eliminates rows that contains no element. More...

set operations
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

bool	includes (const Self &other) const

bool	equals (const Self &other) const

topology operations
Self	starOfPoints () const

Self	starOfCells () const

Self	skeletonOfCells () const

PointRange	extremaOfCells () const

Static Public Attributes
static const Dimension	dimension = Space::dimension

specific services (interval insertion, removal)
Dimension	myAxis
	The axis along which data is stacked in intervals. More...

Container	myData
	Associate to each point its sequences of intervals. More...

size_type	memory_usage () const noexcept

Intervals &	at (Point q)

void	reset (Point p)

Detailed Description

template<typename TSpace>
class DGtal::LatticeSetByIntervals< TSpace >

Aim:

Description of template class 'LatticeSetByIntervals'

A class that represents a set of lattice points using intervals along a given axis.

Template Parameters

TSpace any model of concepts::CSpace, for instance any SpaceND like Z2i::Space, Z3i::Space.

Definition at line 61 of file LatticeSetByIntervals.h.

Member Typedef Documentation

◆ Container

template<typename TSpace >

using DGtal::LatticeSetByIntervals< TSpace >::Container = std::map< Point, Intervals >

Definition at line 74 of file LatticeSetByIntervals.h.

◆ Integer

template<typename TSpace >

using DGtal::LatticeSetByIntervals< TSpace >::Integer = typename Space::Integer

Definition at line 70 of file LatticeSetByIntervals.h.

◆ Interval

template<typename TSpace >

using DGtal::LatticeSetByIntervals< TSpace >::Interval = typename Intervals::Interval

Definition at line 73 of file LatticeSetByIntervals.h.

◆ Intervals

template<typename TSpace >

using DGtal::LatticeSetByIntervals< TSpace >::Intervals = IntegralIntervals< Integer >

Definition at line 72 of file LatticeSetByIntervals.h.

◆ LatticeSetByInterval

template<typename TSpace >

using DGtal::LatticeSetByIntervals< TSpace >::LatticeSetByInterval = std::map< Point, Interval >

Definition at line 77 of file LatticeSetByIntervals.h.

◆ Point

template<typename TSpace >

using DGtal::LatticeSetByIntervals< TSpace >::Point = typename Space::Point

Definition at line 68 of file LatticeSetByIntervals.h.

◆ PointRange

template<typename TSpace >

using DGtal::LatticeSetByIntervals< TSpace >::PointRange = std::vector< Point >

Definition at line 71 of file LatticeSetByIntervals.h.

◆ RowConstIterator

template<typename TSpace >

using DGtal::LatticeSetByIntervals< TSpace >::RowConstIterator = typename Container::const_iterator

Definition at line 76 of file LatticeSetByIntervals.h.

◆ RowIterator

template<typename TSpace >

using DGtal::LatticeSetByIntervals< TSpace >::RowIterator = typename Container::iterator

Definition at line 75 of file LatticeSetByIntervals.h.

◆ Self

template<typename TSpace >

using DGtal::LatticeSetByIntervals< TSpace >::Self = LatticeSetByIntervals< Space >

Definition at line 67 of file LatticeSetByIntervals.h.

◆ Size

template<typename TSpace >

using DGtal::LatticeSetByIntervals< TSpace >::Size = std::size_t

Definition at line 78 of file LatticeSetByIntervals.h.

◆ size_type

template<typename TSpace >

using DGtal::LatticeSetByIntervals< TSpace >::size_type = Size

Definition at line 79 of file LatticeSetByIntervals.h.

◆ Space

template<typename TSpace >

typedef TSpace DGtal::LatticeSetByIntervals< TSpace >::Space

Definition at line 66 of file LatticeSetByIntervals.h.

◆ Vector

template<typename TSpace >

using DGtal::LatticeSetByIntervals< TSpace >::Vector = typename Space::Vector

Definition at line 69 of file LatticeSetByIntervals.h.

Constructor & Destructor Documentation

◆ LatticeSetByIntervals() [1/5]

template<typename TSpace >

DGtal::LatticeSetByIntervals< TSpace >::LatticeSetByIntervals ( Dimension axis = 0 )

inline

Constructor from axis.

Parameters

axis	the row axis chosen for stacking the points.

Definition at line 89 of file LatticeSetByIntervals.h.

90 : myAxis( axis ), myData() {}

DGtal::LatticeSetByIntervals::axis

Dimension axis() const

Definition: LatticeSetByIntervals.h:154

DGtal::LatticeSetByIntervals::myData

Container myData

Associate to each point its sequences of intervals.

Definition: LatticeSetByIntervals.h:664

DGtal::LatticeSetByIntervals::myAxis

Dimension myAxis

The axis along which data is stacked in intervals.

Definition: LatticeSetByIntervals.h:662

◆ LatticeSetByIntervals() [2/5]

template<typename TSpace >

DGtal::LatticeSetByIntervals< TSpace >::LatticeSetByIntervals ( const Self & other )

default

Copy constructor

Parameters

other any other object.

◆ LatticeSetByIntervals() [3/5]

template<typename TSpace >

DGtal::LatticeSetByIntervals< TSpace >::LatticeSetByIntervals ( Self && other )

default

Move constructor

Parameters

other any other object.

◆ LatticeSetByIntervals() [4/5]

template<typename TSpace >

template<typename PointIterator >

DGtal::LatticeSetByIntervals< TSpace >::LatticeSetByIntervals	(	PointIterator	it,
		PointIterator	itE,
		Dimension	axis = `0`
	)

inline

Constructor from range of points

Template Parameters

PointIterator any model of input iterator on points.

Parameters

it,itE	the range of point
axis	the row axis chosen for stacking the points.

Definition at line 115 of file LatticeSetByIntervals.h.

       : myAxis( axis )
     {
       for ( ; it != itE; ++it ) {
         Point   q = *it;
         Integer x = q[ axis ];
         q[ axis ] = 0;
         myData[ q ].insert( x );
       }
     }

References DGtal::LatticeSetByIntervals< TSpace >::axis(), and DGtal::LatticeSetByIntervals< TSpace >::myData.

◆ LatticeSetByIntervals() [5/5]

template<typename TSpace >

DGtal::LatticeSetByIntervals< TSpace >::LatticeSetByIntervals	(	const LatticeSetByInterval &	aSet,
		Dimension	axis
	)

inline

Constructor from lattice set of interval (often a lattice set representation for a polytope, since there is at most one interval per row).

Parameters

aSet	any lattice set represented by one interval per row.
axis	the row axis chosen for stacking the points in aSet.

Definition at line 132 of file LatticeSetByIntervals.h.

       : myAxis( axis )
     {
       for ( const auto& aRow : aSet )
         myData[ aRow.first ].data().push_back( aRow.second );
     }

References DGtal::LatticeSetByIntervals< TSpace >::myData.

Member Function Documentation

◆ add()

template<typename TSpace >

Self& DGtal::LatticeSetByIntervals< TSpace >::add ( const Self & other )

inline

Performs the union of set other with this object.

Parameters

other any intervals

Returns: a reference to this object

Precondition: other and 'this' should share the same axis: this->axis() == other.axis()

Definition at line 272 of file LatticeSetByIntervals.h.

     {
       if ( other.axis() != axis() )
         {
           trace.error() << "[LatticeSetByInterval::add] "
                         << "Both lattice sets should share the same axis: "
                         << axis() << " != " << other.axis() << std::endl;
           return *this;
         }
       for ( const auto& pV : other.myData )
         {
           const Point& p = pV.first;
           auto it = myData.find( p );
           if ( it != myData.end() )
             it->second.add( pV.second );
           else
             myData[ p ] = pV.second;
         }
       return *this;
     }

References DGtal::LatticeSetByIntervals< TSpace >::axis(), DGtal::Trace::error(), DGtal::LatticeSetByIntervals< TSpace >::myData, and DGtal::trace.

Referenced by DGtal::LatticeSetByIntervals< TSpace >::set_symmetric_difference(), and DGtal::LatticeSetByIntervals< TSpace >::set_union().

◆ at()

template<typename TSpace >

Intervals& DGtal::LatticeSetByIntervals< TSpace >::at ( Point q )

inline

Parameters

q any point

Returns: the integral intervals corresponding to lattice point coordinates along the row of axis myAxis and containing q.

Definition at line 642 of file LatticeSetByIntervals.h.

     {
       q[ myAxis ] = 0;
       return myData[ q ];
     }

◆ axis()

template<typename TSpace >

Dimension DGtal::LatticeSetByIntervals< TSpace >::axis ( ) const

inline

Returns: the main axis of projection

Definition at line 154 of file LatticeSetByIntervals.h.

155 { return myAxis; }

References DGtal::LatticeSetByIntervals< TSpace >::myAxis.

Referenced by DGtal::LatticeSetByIntervals< TSpace >::add(), DGtal::LatticeSetByIntervals< TSpace >::equals(), DGtal::LatticeSetByIntervals< TSpace >::includes(), DGtal::LatticeSetByIntervals< TSpace >::LatticeSetByIntervals(), DGtal::LatticeSetByIntervals< TSpace >::setAxis(), and DGtal::LatticeSetByIntervals< TSpace >::subtract().

◆ BOOST_CONCEPT_ASSERT()

template<typename TSpace >

DGtal::LatticeSetByIntervals< TSpace >::BOOST_CONCEPT_ASSERT ( (concepts::CSpace< TSpace >) )

◆ clear()

template<typename TSpace >

void DGtal::LatticeSetByIntervals< TSpace >::clear ( )

inline

Clears the data structure.

Definition at line 140 of file LatticeSetByIntervals.h.

140 { myData.clear(); }

References DGtal::LatticeSetByIntervals< TSpace >::myData.

◆ data()

template<typename TSpace >

Container& DGtal::LatticeSetByIntervals< TSpace >::data ( )

inline

Returns: a reference to the container

Definition at line 158 of file LatticeSetByIntervals.h.

158 { return myData; }

References DGtal::LatticeSetByIntervals< TSpace >::myData.

◆ empty()

template<typename TSpace >

bool DGtal::LatticeSetByIntervals< TSpace >::empty ( ) const

inline

Returns: 'true' iff this object represents the empty set.; Constant time operation.

Definition at line 194 of file LatticeSetByIntervals.h.

     {
       return myData.empty();
     }

References DGtal::LatticeSetByIntervals< TSpace >::myData.

◆ equals()

template<typename TSpace >

bool DGtal::LatticeSetByIntervals< TSpace >::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 398 of file LatticeSetByIntervals.h.

     {
       if ( other.axis() != axis() )
         {
           trace.error() << "[LatticeSetByInterval::subtract] "
                         << "Both lattice sets should share the same axis: "
                         << axis() << " != " << other.axis() << std::endl;
           return false;
         }
       if ( myData.size() != other.myData.size() ) return false;
       auto it = myData.cbegin();
       for ( const auto& I : other.myData )
         {
           if ( it->first != I.first )            return false;
           if ( ! it->second.equals( I.second ) ) return false;
           ++it;
         }
       return true;
     }

References DGtal::LatticeSetByIntervals< TSpace >::axis(), DGtal::Trace::error(), DGtal::LatticeSetByIntervals< TSpace >::myData, and DGtal::trace.

◆ erase()

template<typename TSpace >

void DGtal::LatticeSetByIntervals< TSpace >::erase ( Point p )

inline

Erases the point from the set.

Parameters

p	any point.

Definition at line 236 of file LatticeSetByIntervals.h.

     {
       Integer x   = p[ myAxis ];
       p[ myAxis ] = 0;
       auto it = myData.find( p );
       if ( it != myData.end() )
         {
           it->second.erase( x );
           if ( it->second.empty() )
             myData.erase( it ); // purge  element if it was the last in the row.
         }
     }

References DGtal::LatticeSetByIntervals< TSpace >::myAxis, and DGtal::LatticeSetByIntervals< TSpace >::myData.

◆ extremaOfCells()

template<typename TSpace >

PointRange DGtal::LatticeSetByIntervals< TSpace >::extremaOfCells ( ) const

inline

Returns: the range of points that contains the vertices of all the cells stored in this set.

Definition at line 550 of file LatticeSetByIntervals.h.

     {
       typedef std::vector< Integer > Coordinates;
       std::map< Point, Coordinates > E;
       // Now extracting vertices along axis direction.
       for ( const auto& pV : myData )
         {
           const Point&   p = pV.first;
           const auto&    V = pV.second;
           E[ p ] = V.extremaOfCells();
         }
       std::map< Point, Coordinates > next_E;
       for ( Dimension k = 0; k != dimension; k++ )
         {
           if ( k == myAxis ) continue;
           for ( const auto& pC : E )
             {
               const auto& p = pC.first;
               Point       q = p;
               q[ k ]        = q[ k ] >> 1;
               bool odd      = ( p[ k ] & 0x1 ) != 0;
               { // odd/even always copy 
                 auto it = next_E.find( q );
                 if ( it == next_E.end() ) next_E[ q ] = pC.second;
                 else
                   {
                     Coordinates F;
                     std::set_union( pC.second.cbegin(),  pC.second.cend(),
                                     it->second.cbegin(), it->second.cend(),
                                     std::back_inserter( F ) );
                     it->second = F;
                   }
               }
               if ( odd )
                 { // odd: must copy forward also
                   q[ k ] += 1;
                   auto it = next_E.find( q );
                   if ( it == next_E.end() ) next_E[ q ] = pC.second;
                   else
                     {
                       Coordinates F;
                       std::set_union( pC.second.cbegin(),  pC.second.cend(),
                                       it->second.cbegin(), it->second.cend(),
                                       std::back_inserter( F ) );
                       it->second = F;
                     }
                 }
             } // for ( const auto& pC : E )
           E.swap( next_E );
           next_E.clear();
         }
       // Build point range.
       PointRange R;
       for ( const auto& pC : E )
         {
           Point p = pC.first;
           for ( auto&& x : pC.second )
             {
               p[ myAxis ] = x;
               R.push_back( p );
             }
         }
       std::sort( R.begin(), R.end() );
       return R;
     }

References DGtal::LatticeSetByIntervals< TSpace >::dimension, DGtal::LatticeSetByIntervals< TSpace >::myAxis, and DGtal::LatticeSetByIntervals< TSpace >::myData.

◆ includes()

template<typename TSpace >

bool DGtal::LatticeSetByIntervals< TSpace >::includes ( const Self & other ) const

inline

Parameters

other any other lattice set represented by intervals

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

Precondition: other and 'this' should share the same axis: this->axis() == other.axis()

Definition at line 377 of file LatticeSetByIntervals.h.

     {
       if ( other.axis() != axis() )
         {
           trace.error() << "[LatticeSetByInterval::subtract] "
                         << "Both lattice sets should share the same axis: "
                         << axis() << " != " << other.axis() << std::endl;
           return false;
         }
       for ( const auto& pV : other.myData )
         {
           const Point& p = pV.first;
           const auto  it = myData.find( p );
           if ( it == myData.cend() )                return false;
           if ( ! it->second.includes( pV.second ) ) return false;
         }
       return true;
     }

References DGtal::LatticeSetByIntervals< TSpace >::axis(), DGtal::Trace::error(), DGtal::LatticeSetByIntervals< TSpace >::myData, and DGtal::trace.

◆ insert()

template<typename TSpace >

void DGtal::LatticeSetByIntervals< TSpace >::insert ( Point p )

inline

Inserts the point into the set.

Parameters

p	any point.

Definition at line 227 of file LatticeSetByIntervals.h.

     {
       Integer x   = p[ myAxis ];
       p[ myAxis ] = 0;
       myData[ p ].insert( x );
     }

References DGtal::LatticeSetByIntervals< TSpace >::myAxis, and DGtal::LatticeSetByIntervals< TSpace >::myData.

◆ max_size()

template<typename TSpace >

Size DGtal::LatticeSetByIntervals< TSpace >::max_size ( ) const

inline

Returns: the the maximum number of elements the container is able to hold due to system or library implementation limitations.

Definition at line 213 of file LatticeSetByIntervals.h.

     {
       return myData.max_size();
     }

References DGtal::LatticeSetByIntervals< TSpace >::myData.

◆ memory_usage()

template<typename TSpace >

size_type DGtal::LatticeSetByIntervals< TSpace >::memory_usage ( ) const

inlinenoexcept

Note: Specific to this data structure.

Returns: an evaluation of the memory usage of this data structure.

Definition at line 625 of file LatticeSetByIntervals.h.

     {
       size_type nb = 0;
       for ( const auto& pV : myData )
         {
           nb += sizeof( Interval )  * pV.second.capacity() + sizeof( void* );
           nb += sizeof( pV ) + sizeof( void* );
         }
       nb += sizeof( Self );
       return nb;
     }

◆ operator=() [1/2]

template<typename TSpace >

Self& DGtal::LatticeSetByIntervals< TSpace >::operator= ( const Self & other )

default

Assignment.

Parameters

other any other object.

Returns: a reference to this object

◆ operator=() [2/2]

template<typename TSpace >

Self& DGtal::LatticeSetByIntervals< TSpace >::operator= ( Self && other )

default

Move Assignment.

Parameters

other any other object.

Returns: a reference to this object

◆ purge()

template<typename TSpace >

void DGtal::LatticeSetByIntervals< TSpace >::purge ( )

inline

Eliminates rows that contains no element.

Definition at line 251 of file LatticeSetByIntervals.h.

     {
       for ( auto it = myData.begin(), itE = myData.end(); it != itE; )
         if ( it->second.empty() )
           it = myData.erase( it );
         else ++it;
     }

References DGtal::LatticeSetByIntervals< TSpace >::myData.

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

◆ reset()

template<typename TSpace >

void DGtal::LatticeSetByIntervals< TSpace >::reset ( Point p )

inline

Reset the intervals for a given point.

Parameters

p any point

Note: After this operation, there is no lattice point on the row containing point p.

Definition at line 653 of file LatticeSetByIntervals.h.

     {
       p[ myAxis ] = 0;
       auto it = myData.find( p );
       if ( it != myData.end() ) myData.erase( it );
     }

◆ set_difference()

template<typename TSpace >

Self DGtal::LatticeSetByIntervals< TSpace >::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.

Precondition: other and 'this' should share the same axis: this->axis() == other.axis()

Definition at line 337 of file LatticeSetByIntervals.h.

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

References DGtal::LatticeSetByIntervals< TSpace >::subtract().

◆ set_intersection()

template<typename TSpace >

Self DGtal::LatticeSetByIntervals< TSpace >::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.

Precondition: other and 'this' should share the same axis: this->axis() == other.axis()

Definition at line 350 of file LatticeSetByIntervals.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::LatticeSetByIntervals< TSpace >::set_symmetric_difference(), DGtal::LatticeSetByIntervals< TSpace >::set_union(), and DGtal::LatticeSetByIntervals< TSpace >::subtract().

◆ set_symmetric_difference()

template<typename TSpace >

Self DGtal::LatticeSetByIntervals< TSpace >::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.

Precondition: other and 'this' should share the same axis: this->axis() == other.axis()

Definition at line 363 of file LatticeSetByIntervals.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::LatticeSetByIntervals< TSpace >::add(), and DGtal::LatticeSetByIntervals< TSpace >::subtract().

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

◆ set_union()

template<typename TSpace >

Self DGtal::LatticeSetByIntervals< TSpace >::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.

Precondition: other and 'this' should share the same axis: this->axis() == other.axis()

Definition at line 324 of file LatticeSetByIntervals.h.

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

References DGtal::LatticeSetByIntervals< TSpace >::add().

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

◆ setAxis()

template<typename TSpace >

void DGtal::LatticeSetByIntervals< TSpace >::setAxis ( Dimension axis )

inline

Change the main axis of projection. If the object is not empty, it empties the object.

Parameters

axis	any valid integer between 0 and dimension (excluded)

Definition at line 147 of file LatticeSetByIntervals.h.

     {
       myData.clear();
       myAxis = axis;
     }

References DGtal::LatticeSetByIntervals< TSpace >::axis(), DGtal::LatticeSetByIntervals< TSpace >::myAxis, and DGtal::LatticeSetByIntervals< TSpace >::myData.

◆ size()

template<typename TSpace >

Size DGtal::LatticeSetByIntervals< TSpace >::size ( ) const

inline

Returns: the number of lattice points represented in this object.

Warning: The complexity is linear in the number of stored intervals.

Definition at line 202 of file LatticeSetByIntervals.h.

     {
       Size nb = 0;
       for ( const auto& pV : myData )
         nb += pV.second.size();
       return nb;
     }

References DGtal::LatticeSetByIntervals< TSpace >::myData.

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

◆ skeletonOfCells()

template<typename TSpace >

Self DGtal::LatticeSetByIntervals< TSpace >::skeletonOfCells ( ) const

inline

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

Returns: the skeleton of this set of cells, i.e. the smallest set of cells such that its star covers it.

Definition at line 495 of file LatticeSetByIntervals.h.

     {
       Self S( *this );
       // Now extracting implicitly its Skel
       for ( const auto& pV : myData )
         {
           const Point&   p = pV.first;
           const auto&    V = pV.second;
           for ( Dimension k = 0; k < dimension; k++ )
             {
               if ( k == myAxis ) continue;
               if ( ( p[ k ] & 0x1 ) != 0 ) continue; // if open along axis continue
               // if closed, check upper incident cells along direction k
               Point q = p;  q[ k ] -= 1;
               Point r = p;  r[ k ] += 1;
               auto itq = S.myData.find( q );
               if ( itq != S.myData.end() )
                 {
                   auto& W = itq->second;
                   W.subtract( V );
                 }
               auto itr = S.myData.find( r );
               if ( itr != S.myData.end() )
                 {
                   auto& W = itr->second;
                   W.subtract( V );
                 }
             }
         }
       // Extract skel along main axis
       for ( auto& value : S.myData )
         {
           auto & V = value.second;
           Intervals sub_to_V;
           for ( auto I : V.data() )
             {
               if ( ( I.first & 0x1 )  != 0 )
                 {
                   if ( I.first != I.second )
                     sub_to_V.data().push_back( Interval{ I.first, I.first } );
                   I.first  += 1;
                 }
               if ( ( I.second & 0x1 ) != 0 ) I.second -= 1;
               for ( auto x = I.first; x <= I.second; x += 2 )
                 sub_to_V.data().push_back( Interval{ x+1, x+1 } );
             }
           V.subtract( sub_to_V );
         }
       // Erase empty stacks
       S.purge();
       return S;
     }

References DGtal::IntegralIntervals< TInteger >::data(), DGtal::LatticeSetByIntervals< TSpace >::dimension, DGtal::LatticeSetByIntervals< TSpace >::myAxis, DGtal::LatticeSetByIntervals< TSpace >::myData, and DGtal::LatticeSetByIntervals< TSpace >::purge().

◆ starOfCells()

template<typename TSpace >

Self DGtal::LatticeSetByIntervals< TSpace >::starOfCells ( ) const

inline

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

Returns: the star of this set of cells, i.e. the smallest open cell complex containing it.

Definition at line 467 of file LatticeSetByIntervals.h.

     {
       Self C( *this );
       // First step, compute star along dimension a.
       for ( auto& pV : C.myData )
         pV.second = pV.second.starOfCells();
       // Second step, dilate along remaining directions
       for ( Dimension k = 0; k < dimension; k++ )
         {
           if ( k == myAxis ) continue;
           for ( const auto& value : C.myData )
             {
               Point    q = value.first;
               if ( q[ k ] & 0x1 ) continue;
               q[ k ]    -= 1;
               C.myData[ q ].add( value.second );
               q[ k ]    += 2;
               C.myData[ q ].add( value.second );
             }
         }
       return C;
     }

References DGtal::LatticeSetByIntervals< TSpace >::dimension, DGtal::LatticeSetByIntervals< TSpace >::myAxis, and DGtal::LatticeSetByIntervals< TSpace >::myData.

◆ starOfPoints()

template<typename TSpace >

Self DGtal::LatticeSetByIntervals< TSpace >::starOfPoints ( ) const

inline

Consider the set of integers as points, transform them into pointels in Khalimsky coordinates and build their star. Afterwards points represent cells with their Khalimsky coordinates (i.e. even along an axis means closed, odd along an axis means open). Concretely, points coordinates are multiplied by two, and all the incident points are added to this set.

Returns: the star of this set of points transformed to pointels, i.e. the smallest open cell complex containing it.

Definition at line 435 of file LatticeSetByIntervals.h.

     {
       Self C( myAxis );
       // First step, place points as pointels and insert their star along
       // dimension a.
       for ( auto& pV : myData )
         {
           const Point q = 2 * pV.first;
           C.myData[ q ] = pV.second.starOfPoints();
         }
       // Second step, dilate along remaining directions
       for ( Dimension k = 0; k < dimension; k++ )
         {
           if ( k == myAxis ) continue;
           for ( const auto& value : C.myData )
             {
               Point    q = value.first;
               if ( q[ k ] & 0x1 ) continue;
               q[ k ]    -= 1;
               C.myData[ q ].add( value.second );
               q[ k ]    += 2;
               C.myData[ q ].add( value.second );
             }
         }
       return C;
     }

References DGtal::LatticeSetByIntervals< TSpace >::dimension, DGtal::LatticeSetByIntervals< TSpace >::myAxis, and DGtal::LatticeSetByIntervals< TSpace >::myData.

◆ subtract()

template<typename TSpace >

Self& DGtal::LatticeSetByIntervals< TSpace >::subtract ( const Self & other )

inline

Subtract set other from this object.

Parameters

other any intervals

Returns: a reference to this object

Precondition: other and 'this' should share the same axis: this->axis() == other.axis()

Definition at line 299 of file LatticeSetByIntervals.h.

     {
       if ( other.axis() != axis() )
         {
           trace.error() << "[LatticeSetByInterval::subtract] "
                         << "Both lattice sets should share the same axis: "
                         << axis() << " != " << other.axis() << std::endl;
           return *this;
         }
       for ( const auto& pV : other.myData )
         {
           const Point& p = pV.first;
           auto it = myData.find( p );
           if ( it != myData.end() )
             it->second.subtract( pV.second );
         }
       return *this;
     }

References DGtal::LatticeSetByIntervals< TSpace >::axis(), DGtal::Trace::error(), DGtal::LatticeSetByIntervals< TSpace >::myData, and DGtal::trace.

Referenced by DGtal::LatticeSetByIntervals< TSpace >::set_difference(), DGtal::LatticeSetByIntervals< TSpace >::set_intersection(), and DGtal::LatticeSetByIntervals< TSpace >::set_symmetric_difference().

◆ toPointRange()

template<typename TSpace >

PointRange DGtal::LatticeSetByIntervals< TSpace >::toPointRange ( ) const

inline

Returns: the range of points stored in this lattice set.

Definition at line 168 of file LatticeSetByIntervals.h.

     {
       PointRange X;
       X.reserve( size() );
       for ( const auto& pV : myData )
         {
           auto p    = pV.first;
           auto iVec = pV.second.integerVector();
           for ( auto x : iVec )
             {
               p[ myAxis ] = x;
               X.push_back( p );
             }
         }
       return X;
     }

References DGtal::LatticeSetByIntervals< TSpace >::myAxis, DGtal::LatticeSetByIntervals< TSpace >::myData, and DGtal::LatticeSetByIntervals< TSpace >::size().

Field Documentation

◆ dimension

template<typename TSpace >

const Dimension DGtal::LatticeSetByIntervals< TSpace >::dimension = Space::dimension

static

Definition at line 80 of file LatticeSetByIntervals.h.

Referenced by DGtal::LatticeSetByIntervals< TSpace >::extremaOfCells(), DGtal::LatticeSetByIntervals< TSpace >::skeletonOfCells(), DGtal::LatticeSetByIntervals< TSpace >::starOfCells(), and DGtal::LatticeSetByIntervals< TSpace >::starOfPoints().

◆ myAxis

template<typename TSpace >

Dimension DGtal::LatticeSetByIntervals< TSpace >::myAxis

The axis along which data is stacked in intervals.

Definition at line 662 of file LatticeSetByIntervals.h.

Referenced by DGtal::LatticeSetByIntervals< TSpace >::axis(), DGtal::LatticeSetByIntervals< TSpace >::erase(), DGtal::LatticeSetByIntervals< TSpace >::extremaOfCells(), DGtal::LatticeSetByIntervals< TSpace >::insert(), DGtal::LatticeSetByIntervals< TSpace >::setAxis(), DGtal::LatticeSetByIntervals< TSpace >::skeletonOfCells(), DGtal::LatticeSetByIntervals< TSpace >::starOfCells(), DGtal::LatticeSetByIntervals< TSpace >::starOfPoints(), and DGtal::LatticeSetByIntervals< TSpace >::toPointRange().

◆ myData

template<typename TSpace >

Container DGtal::LatticeSetByIntervals< TSpace >::myData

Associate to each point its sequences of intervals.

Definition at line 664 of file LatticeSetByIntervals.h.

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

LatticeSetByIntervals.h

Public Types

Public Member Functions

Static Public Attributes

specific services (interval insertion, removal)

Detailed Description

template<typename TSpace> class DGtal::LatticeSetByIntervals< TSpace >

Member Typedef Documentation

◆ Container

◆ Integer

◆ Interval

◆ Intervals

◆ LatticeSetByInterval

◆ Point

◆ PointRange

◆ RowConstIterator

◆ RowIterator

◆ Self

◆ Size

◆ size_type

◆ Space

◆ Vector

Constructor & Destructor Documentation

◆ LatticeSetByIntervals() [1/5]

◆ LatticeSetByIntervals() [2/5]

◆ LatticeSetByIntervals() [3/5]

◆ LatticeSetByIntervals() [4/5]

◆ LatticeSetByIntervals() [5/5]

Member Function Documentation

◆ add()

◆ at()

◆ axis()

◆ BOOST_CONCEPT_ASSERT()

◆ clear()

◆ data()

◆ empty()

◆ equals()

◆ erase()

◆ extremaOfCells()

◆ includes()

◆ insert()

◆ max_size()

◆ memory_usage()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ purge()

◆ reset()

◆ set_difference()

◆ set_intersection()

◆ set_symmetric_difference()

◆ set_union()

◆ setAxis()

◆ size()

◆ skeletonOfCells()

◆ starOfCells()

◆ starOfPoints()

◆ subtract()

◆ toPointRange()

Field Documentation

◆ dimension

◆ myAxis

◆ myData

template<typename TSpace>
class DGtal::LatticeSetByIntervals< TSpace >