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