1 #ifndef VIGRA_NODE_IMPL_HXX
2 #define VIGRA_NODE_IMPL_HXX
7 #include "algorithm.hxx"
8 #include "tinyvector.hxx"
9 #include "random_access_set.hxx"
10 #include "iteratorfacade.hxx"
41 struct NeighborNodeFilter{
42 typedef typename GRAPH::Node ResultType;
43 typedef typename GRAPH::NodeStorage::AdjacencyElement AdjacencyElement;
47 const AdjacencyElement &,
48 const typename GRAPH::index_type
54 static ResultType transform(
56 const AdjacencyElement & adj,
57 const typename GRAPH::index_type
59 return g.nodeFromId(adj.nodeId());
62 static const bool IsFilter = false ;
67 typedef typename GRAPH::Edge ResultType;
68 typedef typename GRAPH::NodeStorage::AdjacencyElement AdjacencyElement;
72 const AdjacencyElement &,
73 const typename GRAPH::index_type
78 static ResultType transform(
80 const AdjacencyElement & adj,
81 const typename GRAPH::index_type
83 return g.edgeFromId(adj.edgeId());
86 static const bool IsFilter = false ;
90 struct BackEdgeFilter{
91 typedef typename GRAPH::Edge ResultType;
92 typedef typename GRAPH::NodeStorage::AdjacencyElement AdjacencyElement;
96 const AdjacencyElement & adj,
97 const typename GRAPH::index_type ownNodeId
99 return adj.nodeId() < ownNodeId;
102 static ResultType transform(
104 const AdjacencyElement & adj,
105 const typename GRAPH::index_type
107 return g.edgeFromId(adj.edgeId());
110 static const bool IsFilter = true ;
112 template<
class GRAPH>
113 struct IsBackOutFilter{
114 typedef typename GRAPH::Arc ResultType;
115 typedef typename GRAPH::NodeStorage::AdjacencyElement AdjacencyElement;
119 const AdjacencyElement & adj,
120 const typename GRAPH::index_type ownNodeId
122 return adj.nodeId() < ownNodeId;
124 static ResultType transform(
126 const AdjacencyElement & adj,
127 const typename GRAPH::index_type ownNodeId
129 return g.direct(g.edgeFromId(adj.edgeId()) ,g.nodeFromId(ownNodeId));
132 static const bool IsFilter = true ;
134 template<
class GRAPH>
136 typedef typename GRAPH::Arc ResultType;
137 typedef typename GRAPH::NodeStorage::AdjacencyElement AdjacencyElement;
141 const AdjacencyElement &,
142 const typename GRAPH::index_type
146 static ResultType transform(
148 const AdjacencyElement & adj,
149 const typename GRAPH::index_type ownNodeId
151 return g.direct(g.edgeFromId(adj.edgeId()) ,g.nodeFromId(ownNodeId));
154 static const bool IsFilter = false ;
159 template<
class GRAPH>
161 typedef typename GRAPH::Arc ResultType;
162 typedef typename GRAPH::NodeStorage::AdjacencyElement AdjacencyElement;
166 const AdjacencyElement &,
167 const typename GRAPH::index_type
171 ResultType
static transform(
173 const AdjacencyElement & adj,
174 const typename GRAPH::index_type
176 return g.direct(g.edgeFromId(adj.edgeId()) ,g.nodeFromId(adj.nodeId()));
178 static const bool IsFilter = false ;
181 template<
class GRAPH,
class NODE_IMPL,
class FILTER>
182 class GenericIncEdgeIt
183 :
public ForwardIteratorFacade<
184 GenericIncEdgeIt<GRAPH,NODE_IMPL,FILTER>,
185 typename FILTER::ResultType,true
191 typedef typename Graph::index_type index_type;
192 typedef typename Graph::NodeIt NodeIt;
193 typedef typename Graph::Edge Edge;
194 typedef typename Graph::Node Node;
195 typedef typename FILTER::ResultType ResultItem;
199 GenericIncEdgeIt(
const lemon::Invalid & = lemon::INVALID)
204 resultItem_(lemon::INVALID){
207 GenericIncEdgeIt(
const Graph & g ,
const NodeIt & nodeIt)
208 : nodeImpl_(&g.nodeImpl(*nodeIt)),
210 ownNodeId_(g.id(*nodeIt)),
211 adjIter_(g.nodeImpl(*nodeIt).adjacencyBegin()),
212 resultItem_(lemon::INVALID){
214 if(FILTER::IsFilter){
215 while(adjIter_!=nodeImpl_->adjacencyEnd() && !FILTER::valid(*graph_,*adjIter_,ownNodeId_) ) {
222 GenericIncEdgeIt(
const Graph & g ,
const Node & node)
223 : nodeImpl_(&g.nodeImpl(node)),
225 ownNodeId_(g.id(node)),
226 adjIter_(g.nodeImpl(node).adjacencyBegin()),
227 resultItem_(lemon::INVALID){
229 if(FILTER::IsFilter){
230 while(adjIter_!=nodeImpl_->adjacencyEnd() && !FILTER::valid(*graph_,*adjIter_,ownNodeId_) ) {
237 friend class vigra::IteratorFacadeCoreAccess;
239 typedef NODE_IMPL NodeImpl;
240 typedef typename NodeImpl::AdjIt AdjIt;
243 return (nodeImpl_==NULL || adjIter_==nodeImpl_->adjacencyEnd());
246 return (nodeImpl_!=NULL && adjIter_==nodeImpl_->adjacencyBegin());
248 bool equal(
const GenericIncEdgeIt<GRAPH,NODE_IMPL,FILTER> & other)
const{
249 if(isEnd() && other.isEnd()){
252 else if (isEnd() != other.isEnd()){
256 return adjIter_==other.adjIter_;
262 if(FILTER::IsFilter){
263 while(adjIter_!=nodeImpl_->adjacencyEnd() && !FILTER::valid(*graph_,*adjIter_,ownNodeId_)){
271 const ResultItem & dereference()
const{
272 resultItem_ = FILTER::transform(*graph_,*adjIter_,ownNodeId_);
277 const NODE_IMPL * nodeImpl_;
278 const GRAPH * graph_;
279 const index_type ownNodeId_;
281 mutable ResultItem resultItem_;
293 Adjacency(
const Value nodeId,
const Value edgeId)
298 Value nodeId()
const{
304 Value edgeId()
const{
310 bool operator<(const Adjacency<Value> & other)
const{
311 return nodeId_ < other.nodeId_;
323 template<
class INDEX_TYPE,
bool USE_STL_SET>
324 class GenericNodeImpl{
327 typedef INDEX_TYPE index_type;
328 typedef Adjacency<index_type> AdjacencyElement;
329 typedef std::set<AdjacencyElement > StdSetType;
330 typedef RandomAccessSet<AdjacencyElement > RandAccessSet;
331 typedef typename IfBool<USE_STL_SET,StdSetType,RandAccessSet>::type SetType;
333 typedef typename SetType::const_iterator AdjIt;
336 GenericNodeImpl(
const lemon::Invalid =lemon::INVALID)
340 GenericNodeImpl(
const index_type
id)
344 size_t numberOfEdges()
const{
return adjacency_.size();}
345 size_t edgeNum()
const{
return adjacency_.size();}
346 size_t num_edges()
const{
return adjacency_.size();}
351 void merge(
const GenericNodeImpl & other){
352 adjacency_.insert(other.adjacency_.begin(),other.adjacency_.end());
355 void setId(
const index_type
id){
359 std::pair<index_type,bool> findEdge(
const index_type nodeId)
const{
360 AdjIt iter = adjacency_.find(AdjacencyElement(nodeId,0));
361 if(iter==adjacency_.end()){
362 return std::pair<index_type,bool>(-1,
false);
365 return std::pair<index_type,bool>(iter->edgeId(),
true);
371 void insert(
const index_type nodeId,
const index_type edgeId){
372 adjacency_.insert(AdjacencyElement(nodeId,edgeId));
375 AdjIt adjacencyBegin()
const{
376 return adjacency_.begin();
378 AdjIt adjacencyEnd()
const{
379 return adjacency_.end();
383 index_type id()
const{
388 void eraseFromAdjacency(
const index_type nodeId){
390 adjacency_.erase(AdjacencyElement(nodeId,0));
402 template<
class INDEX_TYPE>
403 class GenericEdgeImpl
407 typedef INDEX_TYPE index_type;
409 GenericEdgeImpl(
const lemon::Invalid =lemon::INVALID)
413 GenericEdgeImpl(
const index_type u,
const index_type v,
const index_type
id)
418 index_type u()
const{
return this->
operator[](0);}
419 index_type v()
const{
return this->
operator[](1);}
420 index_type id()
const{
return this->
operator[](2);}
425 template<
class INDEX_TYPE>
428 template<
class INDEX_TYPE>
431 typedef INDEX_TYPE index_type;
433 GenericArc(
const lemon::Invalid & = lemon::INVALID)
443 const index_type edgeId = static_cast<index_type>(-1)
449 index_type id()
const{
return id_;}
450 index_type edgeId()
const{
return edgeId_;}
452 operator GenericEdge<INDEX_TYPE> ()
const{
453 return GenericEdge<INDEX_TYPE>(edgeId());
456 bool operator == (
const GenericArc<INDEX_TYPE> & other )
const{
457 return id_ == other.id_;
459 bool operator != (
const GenericArc<INDEX_TYPE> & other )
const{
460 return id_ != other.id_;
462 bool operator < (const GenericArc<INDEX_TYPE> & other )
const{
463 return id_ < other.id_;
465 bool operator > (
const GenericArc<INDEX_TYPE> & other )
const{
466 return id_ > other.id_;
476 template<
class INDEX_TYPE>
479 typedef INDEX_TYPE index_type;
481 GenericEdge(
const lemon::Invalid & = lemon::INVALID)
486 GenericEdge(
const index_type
id )
491 GenericEdge(
const GenericArc<INDEX_TYPE> & arc)
496 bool operator == (
const GenericEdge<INDEX_TYPE> & other )
const{
497 return id_ == other.id_;
499 bool operator != (
const GenericEdge<INDEX_TYPE> & other )
const{
500 return id_ != other.id_;
502 bool operator < (const GenericEdge<INDEX_TYPE> & other )
const{
503 return id_ < other.id_;
505 bool operator > (
const GenericEdge<INDEX_TYPE> & other )
const{
506 return id_ > other.id_;
508 bool operator <= (const GenericEdge<INDEX_TYPE> & other )
const{
509 return id_ <= other.id_;
511 bool operator >= (
const GenericEdge<INDEX_TYPE> & other )
const{
512 return id_ >= other.id_;
516 index_type id()
const{
return id_;}
522 template<
class INDEX_TYPE>
525 typedef INDEX_TYPE index_type;
527 GenericNode(
const lemon::Invalid & = lemon::INVALID)
532 GenericNode(
const index_type
id )
536 bool operator == (
const GenericNode<INDEX_TYPE> & other )
const{
537 return id_ == other.id_;
539 bool operator != (
const GenericNode<INDEX_TYPE> & other )
const{
540 return id_ != other.id_;
542 bool operator < (const GenericNode<INDEX_TYPE> & other )
const{
543 return id_ < other.id_;
545 bool operator > (
const GenericNode<INDEX_TYPE> & other )
const{
546 return id_ > other.id_;
549 index_type id()
const{
return id_;}
559 template<
class INDEX_TYPE>
560 ostream & operator<<(ostream & o, vigra::detail::GenericNode<INDEX_TYPE>
const & n)
562 o <<
"Node(" << n.id() <<
")";
566 template<
class INDEX_TYPE>
567 ostream & operator<<(ostream & o, vigra::detail::GenericEdge<INDEX_TYPE>
const & e)
569 o <<
"Edge(" << e.id() <<
")";
575 #endif // VIGRA_NODE_IMPL_HXX
vigra::GridGraph< N, DirectedTag >::edges_size_type num_edges(vigra::GridGraph< N, DirectedTag > const &g)
Return the number of edges in graph g (API: boost).
Definition: multi_gridgraph.hxx:2976
TinyVector(value_type const &initial)
Definition: tinyvector.hxx:1031
bool operator!=(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
not equal
Definition: fftw3.hxx:841
bool operator==(FFTWComplex< R > const &a, const FFTWComplex< R > &b)
equal
Definition: fftw3.hxx:825
Class for fixed size vectors.This class contains an array of size SIZE of the specified VALUETYPE...
Definition: accessor.hxx:940
bool operator>=(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
greater or equal
Definition: fixedpoint.hxx:539
bool operator>(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r)
greater
Definition: fixedpoint.hxx:530
reference operator[](difference_type i)
Definition: tinyvector.hxx:845