38 #ifndef VIGRA_NEW_MERGE_GRAPH_HXX
39 #define VIGRA_NEW_MERGE_GRAPH_HXX
43 #include "delegate/delegate.hxx"
53 #include "multi_array.hxx"
54 #include "tinyvector.hxx"
55 #include "multi_array.hxx"
57 #include "graph_maps.hxx"
58 #include "graph_item_impl.hxx"
59 #include "random_access_set.hxx"
60 #include "iteratorfacade.hxx"
65 namespace merge_graph_detail {
77 :
public ForwardIteratorFacade<
78 ConstRepIter<T>,T,true
83 ConstRepIter(
const IterablePartitionType & p,
const T cr)
96 friend class vigra::IteratorFacadeCoreAccess;
100 return partition_!=NULL && currentRep_==partition_->firstRep();
103 return partition_==NULL || currentRep_>partition_->lastRep();
106 bool equal(
const ConstRepIter & other)
const{
107 return (this->isEnd() && other.isEnd() ) || ((this->isEnd()==other.isEnd() ) && this->currentRep_==other.currentRep_);
111 if(partition_->jumpVec_[currentRep_].second==0){
115 currentRep_+=partition_->jumpVec_[currentRep_].second;
120 if(partition_->jumpVec_[currentRep_].first==0){
125 currentRep_-=partition_->jumpVec_[currentRep_].first;
129 const T & dereference()
const{
135 const IterablePartitionType * partition_;
147 class IterablePartition {
149 friend struct ConstRepIter<T>;
150 typedef T value_type;
151 typedef std::size_t SizeTType;
156 value_type
find(
const value_type&)
const;
157 value_type
find(value_type);
158 value_type numberOfElements()
const;
159 value_type numberOfSets()
const;
160 template<
class Iterator>
void elementLabeling(Iterator)
const;
161 template<
class Iterator>
void representatives(Iterator)
const;
162 void representativeLabeling(std::map<value_type, value_type>&)
const;
165 void reset(
const value_type&);
166 void merge(value_type, value_type);
168 value_type firstRep()
const{
171 value_type lastRep()
const{
174 typedef ConstRepIter<T> const_iterator;
176 const_iterator begin()
const{
178 return ConstRepIter<T>(*
this,firstRep_);
180 return ConstRepIter<T>(*
this,lastRep_+1);
182 const_iterator end()
const{
183 return ConstRepIter<T>(*
this,lastRep_+1);
187 const_iterator iteratorAt(
const value_type & rep)
const{
189 return ConstRepIter<T>(*
this,rep);
191 return ConstRepIter<T>(*
this,lastRep_+1);
194 bool isErased(
const value_type & value)
const{
195 return jumpVec_[value].first == -1 && jumpVec_[value].second == -1;
198 void eraseElement(
const value_type & value,
const bool reduceSize=
true){
199 const T notRep=value;
200 const T jumpMinus = jumpVec_[notRep].first;
201 const T jumpPlus = jumpVec_[notRep].second;
204 const T nextRep = notRep+jumpPlus;
206 jumpVec_[nextRep].first=0;
208 else if(jumpPlus==0){
210 const T prevRep = notRep-jumpMinus;
212 jumpVec_[prevRep].second=0;
216 const T nextRep = notRep+jumpPlus;
217 const T prevRep = notRep-jumpMinus;
218 jumpVec_[nextRep].first+=jumpVec_[notRep].first;
219 jumpVec_[prevRep].second+=jumpVec_[notRep].second;
224 jumpVec_[notRep].first =-1;
225 jumpVec_[notRep].second =-1;
229 std::vector<value_type> parents_;
230 std::vector<value_type> ranks_;
231 std::vector< std::pair< vigra::Int64, vigra::Int64> > jumpVec_;
232 value_type firstRep_;
234 value_type numberOfElements_;
235 value_type numberOfSets_;
246 template<
class GRAPH,
class ITEM>
247 struct MergeGraphItemHelper;
250 struct MergeGraphItemHelper<MG,typename MG::Edge>{
251 typedef typename MG::Graph Graph;
252 typedef typename MG::index_type index_type ;
253 typedef typename MG::Edge Item;
254 typedef typename Graph::Edge GraphItem;
255 typedef typename MG::EdgeIt ItemIt;
258 static index_type maxItemId(
const MG & g){
259 return g.maxEdgeId();
261 static index_type itemNum(
const MG & g){
265 static GraphItem itemToGraphItem(
const MG & g,
const Item & item){
266 const index_type
id = g.id(item);
267 return g.graph().edgeFromId(
id);
272 struct MergeGraphItemHelper<MG,typename MG::Node>{
273 typedef typename MG::Graph Graph;
274 typedef typename MG::index_type index_type ;
275 typedef typename MG::Node Item;
276 typedef typename Graph::Node GraphItem;
277 typedef typename MG::NodeIt ItemIt;
280 static index_type maxItemId(
const MG & g){
281 return g.maxNodeId();
283 static index_type itemNum(
const MG & g){
286 static GraphItem itemToGraphItem(
const MG & g,
const Item & item){
287 const index_type
id = g.id(item);
288 return g.graph().nodeFromId(
id);
293 template<
class MERGE_GRAPH>
294 class MergeGraphNodeIt
295 :
public ForwardIteratorFacade<MergeGraphNodeIt<MERGE_GRAPH>,typename MERGE_GRAPH::Node,true>{
297 typedef MERGE_GRAPH Graph;
298 typedef typename Graph::Node Node;
300 MergeGraphNodeIt(
const lemon::Invalid & invalid = lemon::INVALID)
306 MergeGraphNodeIt(
const Graph & g)
308 nodeIdIt_(g.nodeUfd_.begin()),
311 MergeGraphNodeIt(
const Graph & g,
const Node & node)
313 nodeIdIt_(g.nodeUfd_.iteratorAt(g.id(node))),
318 return graph_==NULL || nodeIdIt_==graph_->nodeUfd_.end();
321 return graph_!=NULL && nodeIdIt_==graph_->nodeUfd_.begin();
324 friend class vigra::IteratorFacadeCoreAccess;
327 bool equal(
const MergeGraphNodeIt<MERGE_GRAPH> & other)
const{
328 return (isEnd()&&other.isEnd()) || nodeIdIt_==other.nodeIdIt_;
330 void increment(){++nodeIdIt_;}
331 const Node & dereference()
const{
332 node_=Node(*nodeIdIt_);
336 const Graph * graph_;
337 typename Graph::NodeIdIt nodeIdIt_;
342 template<
class MERGE_GRAPH>
343 class MergeGraphEdgeIt
344 :
public ForwardIteratorFacade<MergeGraphEdgeIt<MERGE_GRAPH>,typename MERGE_GRAPH::Edge,true>{
346 typedef MERGE_GRAPH Graph;
347 typedef typename Graph::Edge Edge;
349 MergeGraphEdgeIt(
const lemon::Invalid & invalid = lemon::INVALID)
354 MergeGraphEdgeIt(
const Graph & g)
356 edgeIdIt_(g.edgeUfd_.begin()),
360 MergeGraphEdgeIt(
const Graph & g,
const Edge & node)
362 edgeIdIt_(g.edgeUfd_.iteratorAt(g.id(node))),
366 return graph_==NULL || edgeIdIt_==graph_->edgeUfd_.end();
369 return graph_!=NULL && edgeIdIt_==graph_->edgeUfd_.begin();
372 friend class vigra::IteratorFacadeCoreAccess;
375 bool equal(
const MergeGraphEdgeIt<MERGE_GRAPH> & other)
const{
376 return (isEnd()&&other.isEnd()) || edgeIdIt_==other.edgeIdIt_;
381 const Edge & dereference()
const{
382 edge_=Edge(*edgeIdIt_);
386 const Graph * graph_;
387 typename Graph::EdgeIdIt edgeIdIt_;
392 template<
class GRAPH>
393 class MergeGraphArcIt
394 :
public ForwardIteratorFacade<
395 MergeGraphArcIt<GRAPH>,typename GRAPH::Arc,true
400 typedef typename Graph::Arc Arc;
401 typedef typename Graph::Edge Edge;
402 typedef typename Graph::EdgeIt EdgeIt;
403 MergeGraphArcIt(
const lemon::Invalid invalid = lemon::INVALID )
410 MergeGraphArcIt(
const GRAPH & g )
414 veryEnd_( g.edgeNum()==0 ? true : false),
418 MergeGraphArcIt(
const GRAPH & g ,
const Arc & arc )
420 pos_(g,arc.edgeId()),
421 inFirstHalf_(g.id(arc)<=g.maxEdgeId()),
426 friend class vigra::IteratorFacadeCoreAccess;
428 return veryEnd_ || graph_==NULL;
432 return graph_!=NULL && veryEnd_==
false && pos_ == EdgeIt(*graph_);
438 if(pos_ == lemon::INVALID ) {
439 pos_ = EdgeIt(*graph_);
446 if(pos_ == lemon::INVALID){
454 bool equal(MergeGraphArcIt
const& other)
const{
457 isEnd()==other.isEnd() &&
458 inFirstHalf_==other.inFirstHalf_
460 (isEnd() || graph_==NULL || pos_==other.pos_ )
465 const Arc & dereference()
const {
467 arc_ = graph_->direct(*pos_,inFirstHalf_);
472 const GRAPH * graph_;
482 template<
class NODE,
class EDGE>
483 class MergeGraphCallbacks{
486 typedef delegate2<void ,const NODE & ,const NODE &> MergeNodeCallBackType;
487 typedef delegate2<void ,const EDGE & ,const EDGE &> MergeEdgeCallBackType;
488 typedef delegate1<void ,const EDGE &> EraseEdgeCallBackType;
490 MergeGraphCallbacks(){}
492 void registerMergeNodeCallBack(MergeNodeCallBackType f){
493 mergeNodeCallbacks_.push_back(f);
495 void registerMergeEdgeCallBack(MergeEdgeCallBackType f){
496 mergeEdgeCallbacks_.push_back(f);
498 void registerEraseEdgeCallBack(EraseEdgeCallBackType f){
499 eraseEdgeCallbacks_.push_back(f);
503 void callMergeNodeCallbacks(
const NODE & a,
const NODE & b){
504 for(
size_t i=0;i<mergeNodeCallbacks_.size();++i)
505 mergeNodeCallbacks_[i](a,b);
507 void callMergeEdgeCallbacks(
const EDGE & a,
const EDGE & b){
508 for(
size_t i=0;i<mergeEdgeCallbacks_.size();++i)
509 mergeEdgeCallbacks_[i](a,b);
511 void callEraseEdgeCallbacks(
const EDGE & a){
512 for(
size_t i=0;i<eraseEdgeCallbacks_.size();++i)
513 eraseEdgeCallbacks_[i](a);
516 std::vector<MergeNodeCallBackType> mergeNodeCallbacks_;
517 std::vector<MergeEdgeCallBackType> mergeEdgeCallbacks_;
518 std::vector<EraseEdgeCallBackType> eraseEdgeCallbacks_;
526 template<
class GRAPH>
528 :
public MergeGraphCallbacks<
529 detail::GenericNode<vigra::Int64> ,
530 detail::GenericEdge<vigra::Int64>
537 typedef IdType index_type;
541 typedef detail::GenericNode<index_type> Node;
542 typedef detail::GenericEdge<index_type> Edge;
543 typedef detail::GenericArc<index_type> Arc;
546 typedef typename Graph::Node GraphNode;
547 typedef typename Graph::Edge GraphEdge;
548 typedef typename Graph::Node GraphArc;
555 typedef detail::GenericNodeImpl<index_type,false > NodeStorage;
556 typedef detail::GenericEdgeImpl<index_type > EdgeStorage;
562 typedef std::map<vigra::UInt64 , std::vector<IdType> > DoubleMap;
564 typedef typename UfdType::const_iterator ConstUdfIter;
565 typedef ConstUdfIter EdgeIdIt;
566 typedef ConstUdfIter NodeIdIt;
567 typedef detail::NeighborNodeFilter<MergeGraphType> NnFilter;
568 typedef detail::IncEdgeFilter<MergeGraphType> IncFilter;
569 typedef detail::IsInFilter<MergeGraphType> InFlter;
570 typedef detail::IsOutFilter<MergeGraphType> OutFilter;
572 typedef MergeGraphNodeIt<MergeGraphType> NodeIt;
573 typedef MergeGraphEdgeIt<MergeGraphType> EdgeIt;
574 typedef MergeGraphArcIt<MergeGraphType> ArcIt;
575 typedef detail::GenericIncEdgeIt<MergeGraphType,NodeStorage,NnFilter > NeighborNodeIt;
576 typedef detail::GenericIncEdgeIt<MergeGraphType,NodeStorage,IncFilter > IncEdgeIt;
577 typedef detail::GenericIncEdgeIt<MergeGraphType,NodeStorage,InFlter > InArcIt;
578 typedef detail::GenericIncEdgeIt<MergeGraphType,NodeStorage,OutFilter > OutArcIt;
583 struct EdgeMap : DenseEdgeReferenceMap<MergeGraphType,T> {
584 EdgeMap(): DenseEdgeReferenceMap<MergeGraphType,T>(){
587 : DenseEdgeReferenceMap<MergeGraphType,T>(g){
590 : DenseEdgeReferenceMap<MergeGraphType,T>(g,val){
595 struct NodeMap : DenseNodeReferenceMap<MergeGraphType,T> {
596 NodeMap(): DenseNodeReferenceMap<MergeGraphType,T>(){
599 : DenseNodeReferenceMap<MergeGraphType,T>(g){
602 : DenseNodeReferenceMap<MergeGraphType,T>(g,val){
607 struct ArcMap : DenseArcReferenceMap<MergeGraphType,T> {
608 ArcMap(): DenseArcReferenceMap<MergeGraphType,T>(){
611 : DenseArcReferenceMap<MergeGraphType,T>(g){
614 : DenseArcReferenceMap<MergeGraphType,T>(g,val){
629 size_t edgeNum()
const;
630 size_t nodeNum()
const;
631 size_t arcNum()
const;
633 IdType maxEdgeId()
const;
634 IdType maxNodeId()
const;
635 IdType maxArcId()
const;
639 EdgeIdIt edgeIdsBegin()
const;
640 EdgeIdIt edgeIdsEnd()
const;
641 NodeIdIt nodeIdsBegin()
const;
642 NodeIdIt nodeIdsEnd()
const;
648 Edge edgeFromId(
const IdType index)
const;
649 Node nodeFromId(
const IdType index)
const;
650 Arc arcFromId(
const IdType index)
const;
657 bool hasEdgeId(
const IdType edgeIndex)
const;
658 bool hasNodeId(
const IdType nodeIndex)
const;
659 bool hasArcId(
const IdType arcId)
const{
660 return hasEdgeId(arcFromId(arcId).edgeId());
664 Edge findEdge(
const Node & a,
const Node & b)
const;
665 Arc findArc(
const Node & u,
const Node & v)
const;
668 IdType id(
const Edge &
edge)
const;
669 IdType id(
const Node & node)
const;
670 IdType id(
const Arc & arc)
const;
673 size_t degree(
const Node & node)
const;
677 Node u(
const Edge & edge)
const;
678 Node v(
const Edge & edge)
const;
680 Node source(
const Arc & arc)
const{
681 if(arc!=lemon::INVALID)
682 return direction(arc) ? u(Edge(arc)) : v(Edge(arc));
684 return Node(lemon::INVALID);
686 Node target(
const Arc & arc)
const{
687 if(arc!=lemon::INVALID)
688 return direction(arc) ? v(Edge(arc)) : u(Edge(arc));
690 return Node(lemon::INVALID);
695 IdType reprEdgeId(
const IdType edgeIndex)
const;
696 IdType reprNodeId(
const IdType nodeIndex)
const;
697 bool stateOfInitalEdge(
const IdType initalEdge)
const;
699 void contractEdge(
const Edge & edge);
702 Node oppositeNode(Node
const &n,
const Edge &e)
const {
703 const Node uNode = u(e);
704 const Node vNode = v(e);
705 if(
id(uNode)==
id(n)){
708 else if(
id(vNode)==
id(n)){
712 return Node(lemon::INVALID);
717 Arc direct(
const Edge & edge,
const bool forward)
const{
718 if(edge!=lemon::INVALID){
720 return Arc(
id(edge),
id(edge));
722 return Arc(
id(edge)+(maxEdgeId()+1),
id(edge));
725 return Arc(lemon::INVALID);
728 Arc direct(
const Edge & edge,
const Node & node)
const{
730 return direct(edge,
true);
731 else if(v(edge)==node)
732 return direct(edge,
false);
734 return Arc(lemon::INVALID);
737 bool direction(
const Arc & arc)
const{
738 return arc.id()==arc.edgeId();
743 GraphEdge reprGraphEdge(
const GraphEdge & edge)
const{
744 return graph_.edgeFromId(reprEdgeId(graph_.id(edge)));
746 GraphNode reprGraphNode(
const GraphNode & node)
const{
747 return graph_.nodeFromId(reprNodeId(graph_.id(node)));
751 Edge reprEdge(
const GraphEdge & edge)
const{
752 return edgeFromId(reprEdgeId(graph_.id(edge)));
754 Node reprNode(
const GraphNode & node)
const{
755 return nodeFromId(reprNodeId(graph_.id(node)));
758 const Graph & graph()
const{
761 const Graph & graph(){
766 Node inactiveEdgesNode(
const Edge edge)
const{
767 return reprNodeId(graphUId(
id(edge)));
769 size_t maxDegree()
const{
771 for(NodeIt it(*
this);it!=lemon::INVALID;++it){
772 std::max(md,
size_t( degree(*it) ) );
779 template<
class G,
class NIMPL,
class FILT>
780 friend class detail::GenericIncEdgeIt;
783 friend struct detail::NeighborNodeFilter;
785 friend struct detail::IncEdgeFilter;
787 friend struct detail::BackEdgeFilter;
789 friend struct detail::IsOutFilter;
791 friend struct detail::IsInFilter;
792 friend class MergeGraphNodeIt<MergeGraphType>;
793 friend class MergeGraphArcIt<MergeGraphType>;
794 friend class MergeGraphEdgeIt<MergeGraphType>;
796 Edge edgeFromIdUnsave(
const IdType index)
const;
798 index_type uId(
const index_type edgeId)
const;
799 index_type vId(
const index_type edgeId)
const;
800 index_type graphUId(
const index_type edgeId)
const;
801 index_type graphVId(
const index_type edgeId)
const;
804 const NodeStorage & nodeImpl(
const Node & node)
const{
805 return nodeVector_[id(node)];
807 NodeStorage & nodeImpl(
const Node & node){
808 return nodeVector_[id(node)];
812 const GRAPH & graph_;
819 std::vector< NodeStorage > nodeVector_;
821 size_t nDoubleEdges_;
822 std::vector<std::pair<index_type,index_type> > doubleEdges_;
826 template<
class GRAPH>
828 : MergeGraphCallbacks<Node,Edge >(),
832 nodeUfd_(graph.maxNodeId()+1),
833 edgeUfd_(graph.maxEdgeId()+1),
834 nodeVector_(graph.maxNodeId()+1),
836 doubleEdges_(graph_.edgeNum()/2 +1)
838 for(index_type possibleNodeId = 0 ; possibleNodeId <= graph_.maxNodeId(); ++possibleNodeId){
839 if(graph_.nodeFromId(possibleNodeId)==lemon::INVALID){
840 nodeUfd_.eraseElement(possibleNodeId);
843 nodeVector_[possibleNodeId].id_ = -1;
846 for(index_type possibleEdgeId = 0 ; possibleEdgeId <= graph_.maxEdgeId(); ++possibleEdgeId){
847 const GraphEdge possibleEdge(graph_.edgeFromId(possibleEdgeId));
848 if(possibleEdge==lemon::INVALID){
849 edgeUfd_.eraseElement(possibleEdgeId);
852 const index_type guid = graphUId(possibleEdgeId);
853 const index_type gvid = graphVId(possibleEdgeId);
854 nodeVector_[ guid ].insert(gvid,possibleEdgeId);
855 nodeVector_[ gvid ].insert(guid,possibleEdgeId);
863 template<
class GRAPH>
864 inline typename MergeGraphAdaptor<GRAPH>::Edge
865 MergeGraphAdaptor<GRAPH>::findEdge (
866 const typename MergeGraphAdaptor<GRAPH>::Node & a,
867 const typename MergeGraphAdaptor<GRAPH>::Node & b
871 std::pair<index_type,bool> res = nodeVector_[id(a)].findEdge(
id(b));
873 return Edge(res.first);
876 return Edge(lemon::INVALID);
879 template<
class GRAPH>
880 inline typename MergeGraphAdaptor<GRAPH>::Arc
881 MergeGraphAdaptor<GRAPH>::findArc (
882 const typename MergeGraphAdaptor<GRAPH>::Node & uNode,
883 const typename MergeGraphAdaptor<GRAPH>::Node & vNode
885 const Edge
edge = findEdge(uNode,vNode);
886 if(edge==lemon::INVALID)
887 return Arc(lemon::INVALID);
889 return direct(edge,u(edge)==uNode);
893 template<
class GRAPH>
894 inline typename MergeGraphAdaptor<GRAPH>::Node
895 MergeGraphAdaptor<GRAPH>::u(
const Edge & edge)
const{
896 return nodeFromId(uId(
id(edge)));
899 template<
class GRAPH>
900 inline typename MergeGraphAdaptor<GRAPH>::Node
901 MergeGraphAdaptor<GRAPH>::v(
const Edge & edge)
const{
902 return nodeFromId(vId(
id(edge)));
905 template<
class GRAPH>
906 inline typename MergeGraphAdaptor<GRAPH>::index_type
907 MergeGraphAdaptor<GRAPH>::uId(
const index_type edgeId)
const{
908 return reprNodeId(graphUId(edgeId));
911 template<
class GRAPH>
912 inline typename MergeGraphAdaptor<GRAPH>::index_type
913 MergeGraphAdaptor<GRAPH>::vId(
const index_type edgeId)
const{
914 return reprNodeId(graphVId(edgeId));
919 template<
class GRAPH>
920 inline typename MergeGraphAdaptor<GRAPH>::index_type
921 MergeGraphAdaptor<GRAPH>::graphUId(
const index_type edgeId)
const{
922 return graph_.id(graph_.u(graph_.edgeFromId(edgeId)));
925 template<
class GRAPH>
926 inline typename MergeGraphAdaptor<GRAPH>::index_type
927 MergeGraphAdaptor<GRAPH>::graphVId(
const index_type edgeId)
const{
928 return graph_.id(graph_.v(graph_.edgeFromId(edgeId)));
932 template<
class GRAPH>
933 inline typename MergeGraphAdaptor<GRAPH>::IdType
934 MergeGraphAdaptor<GRAPH>::maxEdgeId()
const {
935 return static_cast<index_type
>(edgeUfd_.lastRep());
937 template<
class GRAPH>
938 inline typename MergeGraphAdaptor<GRAPH>::IdType
939 MergeGraphAdaptor<GRAPH>::maxNodeId()
const {
940 return static_cast<index_type
>(nodeUfd_.lastRep());
943 template<
class GRAPH>
944 inline typename MergeGraphAdaptor<GRAPH>::IdType
945 MergeGraphAdaptor<GRAPH>::maxArcId()
const {
946 return maxEdgeId()*2 +1 ;
950 #ifndef DOXYGEN // doxygen doesn't understand this
952 template<
class GRAPH>
953 inline typename MergeGraphAdaptor<GRAPH>::IdType
954 MergeGraphAdaptor<GRAPH>::id(
955 const typename MergeGraphAdaptor<GRAPH>::Edge & edge
960 template<
class GRAPH>
961 inline typename MergeGraphAdaptor<GRAPH>::IdType
962 MergeGraphAdaptor<GRAPH>::id(
963 const typename MergeGraphAdaptor<GRAPH>::Node & node
968 template<
class GRAPH>
969 inline typename MergeGraphAdaptor<GRAPH>::IdType
970 MergeGraphAdaptor<GRAPH>::id(
971 const typename MergeGraphAdaptor<GRAPH>::Arc & arc
979 template<
class GRAPH>
981 MergeGraphAdaptor<GRAPH>::degree(
982 typename MergeGraphAdaptor<GRAPH>::Node
const & node
984 return static_cast<size_t>( nodeVector_[id(node)].edgeNum() );
989 template<
class GRAPH>
990 inline typename MergeGraphAdaptor<GRAPH>::EdgeIdIt
991 MergeGraphAdaptor<GRAPH>::edgeIdsBegin()
const{
992 return edgeUfd_.begin();
995 template<
class GRAPH>
996 inline typename MergeGraphAdaptor<GRAPH>::EdgeIdIt
997 MergeGraphAdaptor<GRAPH>::edgeIdsEnd()
const{
998 return edgeUfd_.end();
1002 template<
class GRAPH>
1003 inline typename MergeGraphAdaptor<GRAPH>::NodeIdIt
1004 MergeGraphAdaptor<GRAPH>::nodeIdsBegin()
const{
1005 return nodeUfd_.begin();
1008 template<
class GRAPH>
1009 inline typename MergeGraphAdaptor<GRAPH>::NodeIdIt
1010 MergeGraphAdaptor<GRAPH>::nodeIdsEnd()
const{
1011 return nodeUfd_.end();
1015 template<
class GRAPH>
1016 inline typename MergeGraphAdaptor<GRAPH>::Edge
1017 MergeGraphAdaptor<GRAPH>::edgeFromIdUnsave(
1018 const typename MergeGraphAdaptor<GRAPH>::IdType index
1023 template<
class GRAPH>
1024 inline typename MergeGraphAdaptor<GRAPH>::Edge
1025 MergeGraphAdaptor<GRAPH>::edgeFromId(
1026 const typename MergeGraphAdaptor<GRAPH>::IdType index
1028 if (hasEdgeId(index))
1031 return Edge(lemon::INVALID);
1034 template<
class GRAPH>
1035 inline typename MergeGraphAdaptor<GRAPH>::Node
1036 MergeGraphAdaptor<GRAPH>::nodeFromId(
1037 const typename MergeGraphAdaptor<GRAPH>::IdType index
1039 if(hasNodeId(index))
1042 return Node(lemon::INVALID);
1045 template<
class GRAPH>
1046 inline typename MergeGraphAdaptor<GRAPH>::Arc
1047 MergeGraphAdaptor<GRAPH>::arcFromId(
1048 const typename MergeGraphAdaptor<GRAPH>::IdType index
1050 if(index<=maxEdgeId( ))
1051 return Arc(index,index);
1053 return Arc(index, index-maxEdgeId() -1);
1056 template<
class GRAPH>
1058 MergeGraphAdaptor<GRAPH>::hasEdgeId(
1059 const typename MergeGraphAdaptor<GRAPH>::IdType edgeIndex
1061 if(edgeIndex<=maxEdgeId() && !edgeUfd_.isErased(edgeIndex)){
1062 const IdType reprEdgeIndex = reprEdgeId(edgeIndex);
1063 if(reprEdgeIndex!=edgeIndex){
1067 const index_type rnid0= uId(reprEdgeIndex);
1068 const index_type rnid1= vId(reprEdgeIndex);
1069 return rnid0!=rnid1;
1077 template<
class GRAPH>
1079 MergeGraphAdaptor<GRAPH>::hasNodeId(
1080 const typename MergeGraphAdaptor<GRAPH>::IdType nodeIndex
1083 return nodeIndex<=maxNodeId() && !nodeUfd_.isErased(nodeIndex) && nodeUfd_.find(nodeIndex)==nodeIndex;
1086 template<
class GRAPH>
1087 inline typename MergeGraphAdaptor<GRAPH>::IdType
1088 MergeGraphAdaptor<GRAPH>::reprEdgeId(
1089 const typename MergeGraphAdaptor<GRAPH>::IdType edgeIndex
1091 return edgeUfd_.find(edgeIndex);
1094 template<
class GRAPH>
1095 inline typename MergeGraphAdaptor<GRAPH>::IdType
1096 MergeGraphAdaptor<GRAPH>::reprNodeId(
1097 const typename MergeGraphAdaptor<GRAPH>::IdType nodeIndex
1099 return nodeUfd_.find(nodeIndex);
1102 template<
class GRAPH>
1103 inline bool MergeGraphAdaptor<GRAPH>::stateOfInitalEdge(
1104 const typename MergeGraphAdaptor<GRAPH>::IdType initalEdge
1106 const index_type rep = reprEdgeId(initalEdge);
1108 const index_type rnid0= reprNodeId( graphUId(initalEdge) );
1109 const index_type rnid1= reprNodeId( graphVId(initalEdge) );
1110 return rnid0!=rnid1;
1113 template<
class GRAPH>
1114 inline size_t MergeGraphAdaptor<GRAPH>::nodeNum()
const{
1115 return nodeUfd_.numberOfSets();
1118 template<
class GRAPH>
1119 inline size_t MergeGraphAdaptor<GRAPH>::arcNum()
const{
1123 template<
class GRAPH>
1124 inline size_t MergeGraphAdaptor<GRAPH>::edgeNum()
const{
1125 return edgeUfd_.numberOfSets();
1128 template<
class GRAPH>
1129 void MergeGraphAdaptor<GRAPH>::contractEdge(
1130 const typename MergeGraphAdaptor<GRAPH>::Edge & toDeleteEdge
1133 const index_type toDeleteEdgeIndex = id(toDeleteEdge);
1134 const index_type nodesIds[2]={id(u(toDeleteEdge)),id(v(toDeleteEdge))};
1137 nodeUfd_.merge(nodesIds[0],nodesIds[1]);
1138 const IdType newNodeRep = reprNodeId(nodesIds[0]);
1139 const IdType notNewNodeRep = (newNodeRep == nodesIds[0] ? nodesIds[1] : nodesIds[0] );
1141 typename NodeStorage::AdjIt iter=nodeVector_[notNewNodeRep].adjacencyBegin();
1142 typename NodeStorage::AdjIt end =nodeVector_[notNewNodeRep].adjacencyEnd();
1145 for(;iter!=end;++iter){
1146 const size_t adjToDeadNodeId = iter->nodeId();
1147 if(adjToDeadNodeId!=newNodeRep){
1151 std::pair<index_type,bool> found=nodeVector_[adjToDeadNodeId].findEdge(newNodeRep);
1155 edgeUfd_.merge(iter->edgeId(),found.first);
1157 const index_type edgeA = iter->edgeId();
1158 const index_type edgeB = found.first;
1159 const index_type edgeR = edgeUfd_.find(edgeA);
1160 const index_type edgeNR = edgeR==edgeA ? edgeB : edgeA;
1162 nodeVector_[adjToDeadNodeId].eraseFromAdjacency(notNewNodeRep);
1165 nodeVector_[adjToDeadNodeId].eraseFromAdjacency(newNodeRep);
1166 nodeVector_[adjToDeadNodeId].insert(newNodeRep,edgeR);
1169 nodeVector_[newNodeRep].eraseFromAdjacency(adjToDeadNodeId);
1170 nodeVector_[newNodeRep].insert(adjToDeadNodeId,edgeR);
1172 doubleEdges_[nDoubleEdges_]=std::pair<index_type,index_type>(edgeR,edgeNR );
1176 nodeVector_[adjToDeadNodeId].eraseFromAdjacency(notNewNodeRep);
1178 nodeVector_[adjToDeadNodeId].insert(newNodeRep,iter->edgeId());
1182 nodeVector_[newNodeRep].insert(adjToDeadNodeId,iter->edgeId());
1189 nodeVector_[newNodeRep].eraseFromAdjacency(notNewNodeRep);
1191 nodeVector_[notNewNodeRep].clear();
1193 edgeUfd_.eraseElement(toDeleteEdgeIndex);
1197 this->callMergeNodeCallbacks(Node(newNodeRep),Node(notNewNodeRep));
1200 for(
size_t de=0;de<nDoubleEdges_;++de){
1201 this->callMergeEdgeCallbacks(Edge(doubleEdges_[de].first),Edge(doubleEdges_[de].second));
1204 this->callEraseEdgeCallbacks(Edge(toDeleteEdgeIndex));
1211 namespace merge_graph_detail {
1220 numberOfElements_(0),
1232 const value_type& size
1234 : parents_(static_cast<SizeTType>(size)),
1235 ranks_(static_cast<SizeTType>(size)),
1236 jumpVec_(static_cast<SizeTType>(size)),
1238 lastRep_(static_cast<SizeTType>(size)-1),
1239 numberOfElements_(size),
1242 for(T j=0; j<size; ++j) {
1243 parents_[
static_cast<SizeTType
>(j)] = j;
1246 jumpVec_.front().first=0;
1247 jumpVec_.front().second=1;
1248 for(T j=1; j<size-1;++j){
1249 jumpVec_[j].first =1;
1250 jumpVec_[j].second=1;
1252 jumpVec_.back().first=1;
1253 jumpVec_.back().second=0;
1264 const value_type& size
1267 numberOfElements_ = size;
1268 numberOfSets_ = size;
1269 ranks_.resize(static_cast<SizeTType>(size));
1270 parents_.resize(static_cast<SizeTType>(size));
1271 jumpVec_.resize(static_cast<SizeTType>(size));
1273 lastRep_=
static_cast<SizeTType
>(size)-1;
1274 for(T j=0; j<size; ++j) {
1275 ranks_[
static_cast<SizeTType
>(j)] = 0;
1276 parents_[
static_cast<SizeTType
>(j)] = j;
1279 jumpVec_.front().first=0;
1280 jumpVec_.front().second=1;
1281 for(T j=1; j<size-1;++j){
1282 jumpVec_[j].first =1;
1283 jumpVec_[j].second=1;
1285 jumpVec_.back().first=1;
1286 jumpVec_.back().second=0;
1296 inline typename IterablePartition<T>::value_type
1299 const value_type& element
1303 value_type root = element;
1304 while(parents_[static_cast<SizeTType>(root)] != root) {
1305 root = parents_[
static_cast<SizeTType
>(root)];
1317 inline typename IterablePartition<T>::value_type
1324 value_type root = element;
1325 while(parents_[static_cast<SizeTType>(root)] != root) {
1326 root = parents_[
static_cast<SizeTType
>(root)];
1329 while(element != root) {
1330 value_type tmp = parents_[
static_cast<SizeTType
>(element)];
1331 parents_[
static_cast<SizeTType
>(element)] = root;
1346 value_type element1,
1351 element1 = find(element1);
1352 element2 = find(element2);
1353 if(element1!=element2){
1355 if(ranks_[static_cast<SizeTType>(element1)] < ranks_[static_cast<SizeTType>(element2)]) {
1356 parents_[
static_cast<SizeTType
>(element1)] = element2;
1361 else if(ranks_[static_cast<SizeTType>(element1)] > ranks_[
static_cast<SizeTType
>(element2)]) {
1362 parents_[
static_cast<SizeTType
>(element2)] = element1;
1367 else if(element1 != element2) {
1368 parents_[
static_cast<SizeTType
>(element2)] = element1;
1369 ++ranks_[
static_cast<SizeTType
>(element1)];
1374 this->eraseElement(notRep,
false);
1379 inline typename IterablePartition<T>::value_type
1382 return numberOfElements_;
1386 inline typename IterablePartition<T>::value_type
1387 IterablePartition<T>::numberOfSets()
const
1389 return numberOfSets_;
1393 inline bool operator == (
const ConstRepIter<T> & iter,
const lemon::Invalid & iv){
1394 return iter.isEnd();
1397 inline bool operator == (
const lemon::Invalid & iv ,
const ConstRepIter<T> & iter){
1398 return iter.isEnd();
1402 inline bool operator != (
const ConstRepIter<T> & iter,
const lemon::Invalid & iv){
1403 return !iter.isEnd();
1406 inline bool operator != (
const lemon::Invalid & iv ,
const ConstRepIter<T> & iter){
1407 return !iter.isEnd();
1418 #endif //VIGRA_NEW_MERGE_GRAPH_HXX