1#@!#!123s

��JFIF�� 1#@!#!123s
: / usr / include / boost / graph /
Filename : boykov_kolmogorov_max_flow.hpp
back
//  Copyright (c) 2006, Stephan Diederich
//
//  This code may be used under either of the following two licences:
//
//    Permission is hereby granted, free of charge, to any person
//    obtaining a copy of this software and associated documentation
//    files (the "Software"), to deal in the Software without
//    restriction, including without limitation the rights to use,
//    copy, modify, merge, publish, distribute, sublicense, and/or
//    sell copies of the Software, and to permit persons to whom the
//    Software is furnished to do so, subject to the following
//    conditions:
//
//    The above copyright notice and this permission notice shall be
//    included in all copies or substantial portions of the Software.
//
//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
//    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
//    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
//    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
//    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
//    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
//    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
//    OTHER DEALINGS IN THE SOFTWARE. OF SUCH DAMAGE.
//
//  Or:
//
//    Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//    http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_BOYKOV_KOLMOGOROV_MAX_FLOW_HPP
#define BOOST_BOYKOV_KOLMOGOROV_MAX_FLOW_HPP

#include <boost/config.hpp>
#include <boost/assert.hpp>
#include <vector>
#include <list>
#include <utility>
#include <iosfwd>
#include <algorithm> // for std::min and std::max

#include <boost/pending/queue.hpp>
#include <boost/limits.hpp>
#include <boost/property_map/property_map.hpp>
#include <boost/none_t.hpp>
#include <boost/graph/graph_concepts.hpp>
#include <boost/graph/named_function_params.hpp>
#include <boost/graph/lookup_edge.hpp>
#include <boost/concept/assert.hpp>

// The algorithm impelemented here is described in:
//
// Boykov, Y., Kolmogorov, V. "An Experimental Comparison of Min-Cut/Max-Flow
// Algorithms for Energy Minimization in Vision", In IEEE Transactions on
// Pattern Analysis and Machine Intelligence, vol. 26, no. 9, pp. 1124-1137,
// Sep 2004.
//
// For further reading, also see:
//
// Kolmogorov, V. "Graph Based Algorithms for Scene Reconstruction from Two or
// More Views". PhD thesis, Cornell University, Sep 2003.

namespace boost
{

namespace detail
{

    template < class Graph, class EdgeCapacityMap,
        class ResidualCapacityEdgeMap, class ReverseEdgeMap,
        class PredecessorMap, class ColorMap, class DistanceMap,
        class IndexMap >
    class bk_max_flow
    {
        typedef
            typename property_traits< EdgeCapacityMap >::value_type tEdgeVal;
        typedef graph_traits< Graph > tGraphTraits;
        typedef typename tGraphTraits::vertex_iterator vertex_iterator;
        typedef typename tGraphTraits::vertex_descriptor vertex_descriptor;
        typedef typename tGraphTraits::edge_descriptor edge_descriptor;
        typedef typename tGraphTraits::edge_iterator edge_iterator;
        typedef typename tGraphTraits::out_edge_iterator out_edge_iterator;
        typedef boost::queue< vertex_descriptor >
            tQueue; // queue of vertices, used in adoption-stage
        typedef typename property_traits< ColorMap >::value_type tColorValue;
        typedef color_traits< tColorValue > tColorTraits;
        typedef
            typename property_traits< DistanceMap >::value_type tDistanceVal;

    public:
        bk_max_flow(Graph& g, EdgeCapacityMap cap, ResidualCapacityEdgeMap res,
            ReverseEdgeMap rev, PredecessorMap pre, ColorMap color,
            DistanceMap dist, IndexMap idx, vertex_descriptor src,
            vertex_descriptor sink)
        : m_g(g)
        , m_index_map(idx)
        , m_cap_map(cap)
        , m_res_cap_map(res)
        , m_rev_edge_map(rev)
        , m_pre_map(pre)
        , m_tree_map(color)
        , m_dist_map(dist)
        , m_source(src)
        , m_sink(sink)
        , m_active_nodes()
        , m_in_active_list_vec(num_vertices(g), false)
        , m_in_active_list_map(make_iterator_property_map(
              m_in_active_list_vec.begin(), m_index_map))
        , m_has_parent_vec(num_vertices(g), false)
        , m_has_parent_map(
              make_iterator_property_map(m_has_parent_vec.begin(), m_index_map))
        , m_time_vec(num_vertices(g), 0)
        , m_time_map(
              make_iterator_property_map(m_time_vec.begin(), m_index_map))
        , m_flow(0)
        , m_time(1)
        , m_last_grow_vertex(graph_traits< Graph >::null_vertex())
        {
            // initialize the color-map with gray-values
            vertex_iterator vi, v_end;
            for (boost::tie(vi, v_end) = vertices(m_g); vi != v_end; ++vi)
            {
                set_tree(*vi, tColorTraits::gray());
            }
            // Initialize flow to zero which means initializing
            // the residual capacity equal to the capacity
            edge_iterator ei, e_end;
            for (boost::tie(ei, e_end) = edges(m_g); ei != e_end; ++ei)
            {
                put(m_res_cap_map, *ei, get(m_cap_map, *ei));
                BOOST_ASSERT(get(m_rev_edge_map, get(m_rev_edge_map, *ei))
                    == *ei); // check if the reverse edge map is build up
                             // properly
            }
            // init the search trees with the two terminals
            set_tree(m_source, tColorTraits::black());
            set_tree(m_sink, tColorTraits::white());
            put(m_time_map, m_source, 1);
            put(m_time_map, m_sink, 1);
        }

        tEdgeVal max_flow()
        {
            // augment direct paths from SOURCE->SINK and SOURCE->VERTEX->SINK
            augment_direct_paths();
            // start the main-loop
            while (true)
            {
                bool path_found;
                edge_descriptor connecting_edge;
                boost::tie(connecting_edge, path_found)
                    = grow(); // find a path from source to sink
                if (!path_found)
                {
                    // we're finished, no more paths were found
                    break;
                }
                ++m_time;
                augment(connecting_edge); // augment that path
                adopt(); // rebuild search tree structure
            }
            return m_flow;
        }

        // the complete class is protected, as we want access to members in
        // derived test-class (see test/boykov_kolmogorov_max_flow_test.cpp)
    protected:
        void augment_direct_paths()
        {
            // in a first step, we augment all direct paths from
            // source->NODE->sink and additionally paths from source->sink. This
            // improves especially graphcuts for segmentation, as most of the
            // nodes have source/sink connects but shouldn't have an impact on
            // other maxflow problems (this is done in grow() anyway)
            out_edge_iterator ei, e_end;
            for (boost::tie(ei, e_end) = out_edges(m_source, m_g); ei != e_end;
                 ++ei)
            {
                edge_descriptor from_source = *ei;
                vertex_descriptor current_node = target(from_source, m_g);
                if (current_node == m_sink)
                {
                    tEdgeVal cap = get(m_res_cap_map, from_source);
                    put(m_res_cap_map, from_source, 0);
                    m_flow += cap;
                    continue;
                }
                edge_descriptor to_sink;
                bool is_there;
                boost::tie(to_sink, is_there)
                    = lookup_edge(current_node, m_sink, m_g);
                if (is_there)
                {
                    tEdgeVal cap_from_source = get(m_res_cap_map, from_source);
                    tEdgeVal cap_to_sink = get(m_res_cap_map, to_sink);
                    if (cap_from_source > cap_to_sink)
                    {
                        set_tree(current_node, tColorTraits::black());
                        add_active_node(current_node);
                        set_edge_to_parent(current_node, from_source);
                        put(m_dist_map, current_node, 1);
                        put(m_time_map, current_node, 1);
                        // add stuff to flow and update residuals. we dont need
                        // to update reverse_edges, as incoming/outgoing edges
                        // to/from source/sink don't count for max-flow
                        put(m_res_cap_map, from_source,
                            get(m_res_cap_map, from_source) - cap_to_sink);
                        put(m_res_cap_map, to_sink, 0);
                        m_flow += cap_to_sink;
                    }
                    else if (cap_to_sink > 0)
                    {
                        set_tree(current_node, tColorTraits::white());
                        add_active_node(current_node);
                        set_edge_to_parent(current_node, to_sink);
                        put(m_dist_map, current_node, 1);
                        put(m_time_map, current_node, 1);
                        // add stuff to flow and update residuals. we dont need
                        // to update reverse_edges, as incoming/outgoing edges
                        // to/from source/sink don't count for max-flow
                        put(m_res_cap_map, to_sink,
                            get(m_res_cap_map, to_sink) - cap_from_source);
                        put(m_res_cap_map, from_source, 0);
                        m_flow += cap_from_source;
                    }
                }
                else if (get(m_res_cap_map, from_source))
                {
                    // there is no sink connect, so we can't augment this path,
                    // but to avoid adding m_source to the active nodes, we just
                    // activate this node and set the approciate things
                    set_tree(current_node, tColorTraits::black());
                    set_edge_to_parent(current_node, from_source);
                    put(m_dist_map, current_node, 1);
                    put(m_time_map, current_node, 1);
                    add_active_node(current_node);
                }
            }
            for (boost::tie(ei, e_end) = out_edges(m_sink, m_g); ei != e_end;
                 ++ei)
            {
                edge_descriptor to_sink = get(m_rev_edge_map, *ei);
                vertex_descriptor current_node = source(to_sink, m_g);
                if (get(m_res_cap_map, to_sink))
                {
                    set_tree(current_node, tColorTraits::white());
                    set_edge_to_parent(current_node, to_sink);
                    put(m_dist_map, current_node, 1);
                    put(m_time_map, current_node, 1);
                    add_active_node(current_node);
                }
            }
        }

        /**
         * Returns a pair of an edge and a boolean. if the bool is true, the
         * edge is a connection of a found path from s->t , read "the link" and
         * source(returnVal, m_g) is the end of the path found in the
         * source-tree target(returnVal, m_g) is the beginning of the path found
         * in the sink-tree
         */
        std::pair< edge_descriptor, bool > grow()
        {
            BOOST_ASSERT(m_orphans.empty());
            vertex_descriptor current_node;
            while ((current_node = get_next_active_node())
                != graph_traits< Graph >::null_vertex())
            { // if there is one
                BOOST_ASSERT(get_tree(current_node) != tColorTraits::gray()
                    && (has_parent(current_node) || current_node == m_source
                        || current_node == m_sink));

                if (get_tree(current_node) == tColorTraits::black())
                {
                    // source tree growing
                    out_edge_iterator ei, e_end;
                    if (current_node != m_last_grow_vertex)
                    {
                        m_last_grow_vertex = current_node;
                        boost::tie(m_last_grow_edge_it, m_last_grow_edge_end)
                            = out_edges(current_node, m_g);
                    }
                    for (; m_last_grow_edge_it != m_last_grow_edge_end;
                         ++m_last_grow_edge_it)
                    {
                        edge_descriptor out_edge = *m_last_grow_edge_it;
                        if (get(m_res_cap_map, out_edge) > 0)
                        { // check if we have capacity left on this edge
                            vertex_descriptor other_node
                                = target(out_edge, m_g);
                            if (get_tree(other_node) == tColorTraits::gray())
                            { // it's a free node
                                set_tree(other_node,
                                    tColorTraits::black()); // aquire other node
                                                            // to our search
                                                            // tree
                                set_edge_to_parent(
                                    other_node, out_edge); // set us as parent
                                put(m_dist_map, other_node,
                                    get(m_dist_map, current_node)
                                        + 1); // and update the
                                              // distance-heuristic
                                put(m_time_map, other_node,
                                    get(m_time_map, current_node));
                                add_active_node(other_node);
                            }
                            else if (get_tree(other_node)
                                == tColorTraits::black())
                            {
                                // we do this to get shorter paths. check if we
                                // are nearer to the source as its parent is
                                if (is_closer_to_terminal(
                                        current_node, other_node))
                                {
                                    set_edge_to_parent(other_node, out_edge);
                                    put(m_dist_map, other_node,
                                        get(m_dist_map, current_node) + 1);
                                    put(m_time_map, other_node,
                                        get(m_time_map, current_node));
                                }
                            }
                            else
                            {
                                BOOST_ASSERT(get_tree(other_node)
                                    == tColorTraits::white());
                                // kewl, found a path from one to the other
                                // search tree, return
                                // the connecting edge in src->sink dir
                                return std::make_pair(out_edge, true);
                            }
                        }
                    } // for all out-edges
                } // source-tree-growing
                else
                {
                    BOOST_ASSERT(
                        get_tree(current_node) == tColorTraits::white());
                    out_edge_iterator ei, e_end;
                    if (current_node != m_last_grow_vertex)
                    {
                        m_last_grow_vertex = current_node;
                        boost::tie(m_last_grow_edge_it, m_last_grow_edge_end)
                            = out_edges(current_node, m_g);
                    }
                    for (; m_last_grow_edge_it != m_last_grow_edge_end;
                         ++m_last_grow_edge_it)
                    {
                        edge_descriptor in_edge
                            = get(m_rev_edge_map, *m_last_grow_edge_it);
                        if (get(m_res_cap_map, in_edge) > 0)
                        { // check if there is capacity left
                            vertex_descriptor other_node = source(in_edge, m_g);
                            if (get_tree(other_node) == tColorTraits::gray())
                            { // it's a free node
                                set_tree(other_node,
                                    tColorTraits::white()); // aquire that node
                                                            // to our search
                                                            // tree
                                set_edge_to_parent(
                                    other_node, in_edge); // set us as parent
                                add_active_node(
                                    other_node); // activate that node
                                put(m_dist_map, other_node,
                                    get(m_dist_map, current_node)
                                        + 1); // set its distance
                                put(m_time_map, other_node,
                                    get(m_time_map, current_node)); // and time
                            }
                            else if (get_tree(other_node)
                                == tColorTraits::white())
                            {
                                if (is_closer_to_terminal(
                                        current_node, other_node))
                                {
                                    // we are closer to the sink than its parent
                                    // is, so we "adopt" him
                                    set_edge_to_parent(other_node, in_edge);
                                    put(m_dist_map, other_node,
                                        get(m_dist_map, current_node) + 1);
                                    put(m_time_map, other_node,
                                        get(m_time_map, current_node));
                                }
                            }
                            else
                            {
                                BOOST_ASSERT(get_tree(other_node)
                                    == tColorTraits::black());
                                // kewl, found a path from one to the other
                                // search tree,
                                // return the connecting edge in src->sink dir
                                return std::make_pair(in_edge, true);
                            }
                        }
                    } // for all out-edges
                } // sink-tree growing

                // all edges of that node are processed, and no more paths were
                // found.
                // remove if from the front of the active queue
                finish_node(current_node);
            } // while active_nodes not empty

            // no active nodes anymore and no path found, we're done
            return std::make_pair(edge_descriptor(), false);
        }

        /**
         * augments path from s->t and updates residual graph
         * source(e, m_g) is the end of the path found in the source-tree
         * target(e, m_g) is the beginning of the path found in the sink-tree
         * this phase generates orphans on satured edges, if the attached verts
         * are from different search-trees orphans are ordered in distance to
         * sink/source. first the farest from the source are front_inserted into
         * the orphans list, and after that the sink-tree-orphans are
         * front_inserted. when going to adoption stage the orphans are
         * popped_front, and so we process the nearest verts to the terminals
         * first
         */
        void augment(edge_descriptor e)
        {
            BOOST_ASSERT(get_tree(target(e, m_g)) == tColorTraits::white());
            BOOST_ASSERT(get_tree(source(e, m_g)) == tColorTraits::black());
            BOOST_ASSERT(m_orphans.empty());

            const tEdgeVal bottleneck = find_bottleneck(e);
            // now we push the found flow through the path
            // for each edge we saturate we have to look for the verts that
            // belong to that edge, one of them becomes an orphans now process
            // the connecting edge
            put(m_res_cap_map, e, get(m_res_cap_map, e) - bottleneck);
            BOOST_ASSERT(get(m_res_cap_map, e) >= 0);
            put(m_res_cap_map, get(m_rev_edge_map, e),
                get(m_res_cap_map, get(m_rev_edge_map, e)) + bottleneck);

            // now we follow the path back to the source
            vertex_descriptor current_node = source(e, m_g);
            while (current_node != m_source)
            {
                edge_descriptor pred = get_edge_to_parent(current_node);
                put(m_res_cap_map, pred, get(m_res_cap_map, pred) - bottleneck);
                BOOST_ASSERT(get(m_res_cap_map, pred) >= 0);
                put(m_res_cap_map, get(m_rev_edge_map, pred),
                    get(m_res_cap_map, get(m_rev_edge_map, pred)) + bottleneck);
                if (get(m_res_cap_map, pred) == 0)
                {
                    set_no_parent(current_node);
                    m_orphans.push_front(current_node);
                }
                current_node = source(pred, m_g);
            }
            // then go forward in the sink-tree
            current_node = target(e, m_g);
            while (current_node != m_sink)
            {
                edge_descriptor pred = get_edge_to_parent(current_node);
                put(m_res_cap_map, pred, get(m_res_cap_map, pred) - bottleneck);
                BOOST_ASSERT(get(m_res_cap_map, pred) >= 0);
                put(m_res_cap_map, get(m_rev_edge_map, pred),
                    get(m_res_cap_map, get(m_rev_edge_map, pred)) + bottleneck);
                if (get(m_res_cap_map, pred) == 0)
                {
                    set_no_parent(current_node);
                    m_orphans.push_front(current_node);
                }
                current_node = target(pred, m_g);
            }
            // and add it to the max-flow
            m_flow += bottleneck;
        }

        /**
         * returns the bottleneck of a s->t path (end_of_path is last vertex in
         * source-tree, begin_of_path is first vertex in sink-tree)
         */
        inline tEdgeVal find_bottleneck(edge_descriptor e)
        {
            BOOST_USING_STD_MIN();
            tEdgeVal minimum_cap = get(m_res_cap_map, e);
            vertex_descriptor current_node = source(e, m_g);
            // first go back in the source tree
            while (current_node != m_source)
            {
                edge_descriptor pred = get_edge_to_parent(current_node);
                minimum_cap = min BOOST_PREVENT_MACRO_SUBSTITUTION(
                    minimum_cap, get(m_res_cap_map, pred));
                current_node = source(pred, m_g);
            }
            // then go forward in the sink-tree
            current_node = target(e, m_g);
            while (current_node != m_sink)
            {
                edge_descriptor pred = get_edge_to_parent(current_node);
                minimum_cap = min BOOST_PREVENT_MACRO_SUBSTITUTION(
                    minimum_cap, get(m_res_cap_map, pred));
                current_node = target(pred, m_g);
            }
            return minimum_cap;
        }

        /**
         * rebuild search trees
         * empty the queue of orphans, and find new parents for them or just
         * drop them from the search trees
         */
        void adopt()
        {
            while (!m_orphans.empty() || !m_child_orphans.empty())
            {
                vertex_descriptor current_node;
                if (m_child_orphans.empty())
                {
                    // get the next orphan from the main-queue  and remove it
                    current_node = m_orphans.front();
                    m_orphans.pop_front();
                }
                else
                {
                    current_node = m_child_orphans.front();
                    m_child_orphans.pop();
                }
                if (get_tree(current_node) == tColorTraits::black())
                {
                    // we're in the source-tree
                    tDistanceVal min_distance
                        = (std::numeric_limits< tDistanceVal >::max)();
                    edge_descriptor new_parent_edge;
                    out_edge_iterator ei, e_end;
                    for (boost::tie(ei, e_end) = out_edges(current_node, m_g);
                         ei != e_end; ++ei)
                    {
                        const edge_descriptor in_edge
                            = get(m_rev_edge_map, *ei);
                        BOOST_ASSERT(target(in_edge, m_g)
                            == current_node); // we should be the target of this
                                              // edge
                        if (get(m_res_cap_map, in_edge) > 0)
                        {
                            vertex_descriptor other_node = source(in_edge, m_g);
                            if (get_tree(other_node) == tColorTraits::black()
                                && has_source_connect(other_node))
                            {
                                if (get(m_dist_map, other_node) < min_distance)
                                {
                                    min_distance = get(m_dist_map, other_node);
                                    new_parent_edge = in_edge;
                                }
                            }
                        }
                    }
                    if (min_distance
                        != (std::numeric_limits< tDistanceVal >::max)())
                    {
                        set_edge_to_parent(current_node, new_parent_edge);
                        put(m_dist_map, current_node, min_distance + 1);
                        put(m_time_map, current_node, m_time);
                    }
                    else
                    {
                        put(m_time_map, current_node, 0);
                        for (boost::tie(ei, e_end)
                             = out_edges(current_node, m_g);
                             ei != e_end; ++ei)
                        {
                            edge_descriptor in_edge = get(m_rev_edge_map, *ei);
                            vertex_descriptor other_node = source(in_edge, m_g);
                            if (get_tree(other_node) == tColorTraits::black()
                                && other_node != m_source)
                            {
                                if (get(m_res_cap_map, in_edge) > 0)
                                {
                                    add_active_node(other_node);
                                }
                                if (has_parent(other_node)
                                    && source(
                                           get_edge_to_parent(other_node), m_g)
                                        == current_node)
                                {
                                    // we are the parent of that node
                                    // it has to find a new parent, too
                                    set_no_parent(other_node);
                                    m_child_orphans.push(other_node);
                                }
                            }
                        }
                        set_tree(current_node, tColorTraits::gray());
                    } // no parent found
                } // source-tree-adoption
                else
                {
                    // now we should be in the sink-tree, check that...
                    BOOST_ASSERT(
                        get_tree(current_node) == tColorTraits::white());
                    out_edge_iterator ei, e_end;
                    edge_descriptor new_parent_edge;
                    tDistanceVal min_distance
                        = (std::numeric_limits< tDistanceVal >::max)();
                    for (boost::tie(ei, e_end) = out_edges(current_node, m_g);
                         ei != e_end; ++ei)
                    {
                        const edge_descriptor out_edge = *ei;
                        if (get(m_res_cap_map, out_edge) > 0)
                        {
                            const vertex_descriptor other_node
                                = target(out_edge, m_g);
                            if (get_tree(other_node) == tColorTraits::white()
                                && has_sink_connect(other_node))
                                if (get(m_dist_map, other_node) < min_distance)
                                {
                                    min_distance = get(m_dist_map, other_node);
                                    new_parent_edge = out_edge;
                                }
                        }
                    }
                    if (min_distance
                        != (std::numeric_limits< tDistanceVal >::max)())
                    {
                        set_edge_to_parent(current_node, new_parent_edge);
                        put(m_dist_map, current_node, min_distance + 1);
                        put(m_time_map, current_node, m_time);
                    }
                    else
                    {
                        put(m_time_map, current_node, 0);
                        for (boost::tie(ei, e_end)
                             = out_edges(current_node, m_g);
                             ei != e_end; ++ei)
                        {
                            const edge_descriptor out_edge = *ei;
                            const vertex_descriptor other_node
                                = target(out_edge, m_g);
                            if (get_tree(other_node) == tColorTraits::white()
                                && other_node != m_sink)
                            {
                                if (get(m_res_cap_map, out_edge) > 0)
                                {
                                    add_active_node(other_node);
                                }
                                if (has_parent(other_node)
                                    && target(
                                           get_edge_to_parent(other_node), m_g)
                                        == current_node)
                                {
                                    // we were it's parent, so it has to find a
                                    // new one, too
                                    set_no_parent(other_node);
                                    m_child_orphans.push(other_node);
                                }
                            }
                        }
                        set_tree(current_node, tColorTraits::gray());
                    } // no parent found
                } // sink-tree adoption
            } // while !orphans.empty()
        } // adopt

        /**
         * return next active vertex if there is one, otherwise a null_vertex
         */
        inline vertex_descriptor get_next_active_node()
        {
            while (true)
            {
                if (m_active_nodes.empty())
                    return graph_traits< Graph >::null_vertex();
                vertex_descriptor v = m_active_nodes.front();

                // if it has no parent, this node can't be active (if its not
                // source or sink)
                if (!has_parent(v) && v != m_source && v != m_sink)
                {
                    m_active_nodes.pop();
                    put(m_in_active_list_map, v, false);
                }
                else
                {
                    BOOST_ASSERT(get_tree(v) == tColorTraits::black()
                        || get_tree(v) == tColorTraits::white());
                    return v;
                }
            }
        }

        /**
         * adds v as an active vertex, but only if its not in the list already
         */
        inline void add_active_node(vertex_descriptor v)
        {
            BOOST_ASSERT(get_tree(v) != tColorTraits::gray());
            if (get(m_in_active_list_map, v))
            {
                if (m_last_grow_vertex == v)
                {
                    m_last_grow_vertex = graph_traits< Graph >::null_vertex();
                }
                return;
            }
            else
            {
                put(m_in_active_list_map, v, true);
                m_active_nodes.push(v);
            }
        }

        /**
         * finish_node removes a node from the front of the active queue (its
         * called in grow phase, if no more paths can be found using this node)
         */
        inline void finish_node(vertex_descriptor v)
        {
            BOOST_ASSERT(m_active_nodes.front() == v);
            m_active_nodes.pop();
            put(m_in_active_list_map, v, false);
            m_last_grow_vertex = graph_traits< Graph >::null_vertex();
        }

        /**
         * removes a vertex from the queue of active nodes (actually this does
         * nothing, but checks if this node has no parent edge, as this is the
         * criteria for being no more active)
         */
        inline void remove_active_node(vertex_descriptor v)
        {
            BOOST_ASSERT(!has_parent(v));
        }

        /**
         * returns the search tree of v; tColorValue::black() for source tree,
         * white() for sink tree, gray() for no tree
         */
        inline tColorValue get_tree(vertex_descriptor v) const
        {
            return get(m_tree_map, v);
        }

        /**
         * sets search tree of v; tColorValue::black() for source tree, white()
         * for sink tree, gray() for no tree
         */
        inline void set_tree(vertex_descriptor v, tColorValue t)
        {
            put(m_tree_map, v, t);
        }

        /**
         * returns edge to parent vertex of v;
         */
        inline edge_descriptor get_edge_to_parent(vertex_descriptor v) const
        {
            return get(m_pre_map, v);
        }

        /**
         * returns true if the edge stored in m_pre_map[v] is a valid entry
         */
        inline bool has_parent(vertex_descriptor v) const
        {
            return get(m_has_parent_map, v);
        }

        /**
         * sets edge to parent vertex of v;
         */
        inline void set_edge_to_parent(
            vertex_descriptor v, edge_descriptor f_edge_to_parent)
        {
            BOOST_ASSERT(get(m_res_cap_map, f_edge_to_parent) > 0);
            put(m_pre_map, v, f_edge_to_parent);
            put(m_has_parent_map, v, true);
        }

        /**
         * removes the edge to parent of v (this is done by invalidating the
         * entry an additional map)
         */
        inline void set_no_parent(vertex_descriptor v)
        {
            put(m_has_parent_map, v, false);
        }

        /**
         * checks if vertex v has a connect to the sink-vertex (@var m_sink)
         * @param v the vertex which is checked
         * @return true if a path to the sink was found, false if not
         */
        inline bool has_sink_connect(vertex_descriptor v)
        {
            tDistanceVal current_distance = 0;
            vertex_descriptor current_vertex = v;
            while (true)
            {
                if (get(m_time_map, current_vertex) == m_time)
                {
                    // we found a node which was already checked this round. use
                    // it for distance calculations
                    current_distance += get(m_dist_map, current_vertex);
                    break;
                }
                if (current_vertex == m_sink)
                {
                    put(m_time_map, m_sink, m_time);
                    break;
                }
                if (has_parent(current_vertex))
                {
                    // it has a parent, so get it
                    current_vertex
                        = target(get_edge_to_parent(current_vertex), m_g);
                    ++current_distance;
                }
                else
                {
                    // no path found
                    return false;
                }
            }
            current_vertex = v;
            while (get(m_time_map, current_vertex) != m_time)
            {
                put(m_dist_map, current_vertex, current_distance);
                --current_distance;
                put(m_time_map, current_vertex, m_time);
                current_vertex
                    = target(get_edge_to_parent(current_vertex), m_g);
            }
            return true;
        }

        /**
         * checks if vertex v has a connect to the source-vertex (@var m_source)
         * @param v the vertex which is checked
         * @return true if a path to the source was found, false if not
         */
        inline bool has_source_connect(vertex_descriptor v)
        {
            tDistanceVal current_distance = 0;
            vertex_descriptor current_vertex = v;
            while (true)
            {
                if (get(m_time_map, current_vertex) == m_time)
                {
                    // we found a node which was already checked this round. use
                    // it for distance calculations
                    current_distance += get(m_dist_map, current_vertex);
                    break;
                }
                if (current_vertex == m_source)
                {
                    put(m_time_map, m_source, m_time);
                    break;
                }
                if (has_parent(current_vertex))
                {
                    // it has a parent, so get it
                    current_vertex
                        = source(get_edge_to_parent(current_vertex), m_g);
                    ++current_distance;
                }
                else
                {
                    // no path found
                    return false;
                }
            }
            current_vertex = v;
            while (get(m_time_map, current_vertex) != m_time)
            {
                put(m_dist_map, current_vertex, current_distance);
                --current_distance;
                put(m_time_map, current_vertex, m_time);
                current_vertex
                    = source(get_edge_to_parent(current_vertex), m_g);
            }
            return true;
        }

        /**
         * returns true, if p is closer to a terminal than q
         */
        inline bool is_closer_to_terminal(
            vertex_descriptor p, vertex_descriptor q)
        {
            // checks the timestamps first, to build no cycles, and after that
            // the real distance
            return (get(m_time_map, q) <= get(m_time_map, p)
                && get(m_dist_map, q) > get(m_dist_map, p) + 1);
        }

        ////////
        // member vars
        ////////
        Graph& m_g;
        IndexMap m_index_map;
        EdgeCapacityMap m_cap_map;
        ResidualCapacityEdgeMap m_res_cap_map;
        ReverseEdgeMap m_rev_edge_map;
        PredecessorMap m_pre_map; // stores paths found in the growth stage
        ColorMap m_tree_map; // maps each vertex into one of the two search tree
                             // or none (gray())
        DistanceMap m_dist_map; // stores distance to source/sink nodes
        vertex_descriptor m_source;
        vertex_descriptor m_sink;

        tQueue m_active_nodes;
        std::vector< bool > m_in_active_list_vec;
        iterator_property_map< std::vector< bool >::iterator, IndexMap >
            m_in_active_list_map;

        std::list< vertex_descriptor > m_orphans;
        tQueue m_child_orphans; // we use a second queuqe for child orphans, as
                                // they are FIFO processed

        std::vector< bool > m_has_parent_vec;
        iterator_property_map< std::vector< bool >::iterator, IndexMap >
            m_has_parent_map;

        std::vector< long > m_time_vec; // timestamp of each node, used for
                                        // sink/source-path calculations
        iterator_property_map< std::vector< long >::iterator, IndexMap >
            m_time_map;
        tEdgeVal m_flow;
        long m_time;
        vertex_descriptor m_last_grow_vertex;
        out_edge_iterator m_last_grow_edge_it;
        out_edge_iterator m_last_grow_edge_end;
    };

} // namespace boost::detail

/**
 * non-named-parameter version, given everything
 * this is the catch all version
 */
template < class Graph, class CapacityEdgeMap, class ResidualCapacityEdgeMap,
    class ReverseEdgeMap, class PredecessorMap, class ColorMap,
    class DistanceMap, class IndexMap >
typename property_traits< CapacityEdgeMap >::value_type
boykov_kolmogorov_max_flow(Graph& g, CapacityEdgeMap cap,
    ResidualCapacityEdgeMap res_cap, ReverseEdgeMap rev_map,
    PredecessorMap pre_map, ColorMap color, DistanceMap dist, IndexMap idx,
    typename graph_traits< Graph >::vertex_descriptor src,
    typename graph_traits< Graph >::vertex_descriptor sink)
{
    typedef typename graph_traits< Graph >::vertex_descriptor vertex_descriptor;
    typedef typename graph_traits< Graph >::edge_descriptor edge_descriptor;

    // as this method is the last one before we instantiate the solver, we do
    // the concept checks here
    BOOST_CONCEPT_ASSERT(
        (VertexListGraphConcept< Graph >)); // to have vertices(),
                                            // num_vertices(),
    BOOST_CONCEPT_ASSERT((EdgeListGraphConcept< Graph >)); // to have edges()
    BOOST_CONCEPT_ASSERT(
        (IncidenceGraphConcept< Graph >)); // to have source(), target() and
                                           // out_edges()
    BOOST_CONCEPT_ASSERT((ReadablePropertyMapConcept< CapacityEdgeMap,
        edge_descriptor >)); // read flow-values from edges
    BOOST_CONCEPT_ASSERT((ReadWritePropertyMapConcept< ResidualCapacityEdgeMap,
        edge_descriptor >)); // write flow-values to residuals
    BOOST_CONCEPT_ASSERT((ReadablePropertyMapConcept< ReverseEdgeMap,
        edge_descriptor >)); // read out reverse edges
    BOOST_CONCEPT_ASSERT((ReadWritePropertyMapConcept< PredecessorMap,
        vertex_descriptor >)); // store predecessor there
    BOOST_CONCEPT_ASSERT((ReadWritePropertyMapConcept< ColorMap,
        vertex_descriptor >)); // write corresponding tree
    BOOST_CONCEPT_ASSERT((ReadWritePropertyMapConcept< DistanceMap,
        vertex_descriptor >)); // write distance to source/sink
    BOOST_CONCEPT_ASSERT((ReadablePropertyMapConcept< IndexMap,
        vertex_descriptor >)); // get index 0...|V|-1
    BOOST_ASSERT(num_vertices(g) >= 2 && src != sink);

    detail::bk_max_flow< Graph, CapacityEdgeMap, ResidualCapacityEdgeMap,
        ReverseEdgeMap, PredecessorMap, ColorMap, DistanceMap, IndexMap >
        algo(g, cap, res_cap, rev_map, pre_map, color, dist, idx, src, sink);

    return algo.max_flow();
}

/**
 * non-named-parameter version, given capacity, residucal_capacity,
 * reverse_edges, and an index map.
 */
template < class Graph, class CapacityEdgeMap, class ResidualCapacityEdgeMap,
    class ReverseEdgeMap, class IndexMap >
typename property_traits< CapacityEdgeMap >::value_type
boykov_kolmogorov_max_flow(Graph& g, CapacityEdgeMap cap,
    ResidualCapacityEdgeMap res_cap, ReverseEdgeMap rev, IndexMap idx,
    typename graph_traits< Graph >::vertex_descriptor src,
    typename graph_traits< Graph >::vertex_descriptor sink)
{
    typename graph_traits< Graph >::vertices_size_type n_verts
        = num_vertices(g);
    std::vector< typename graph_traits< Graph >::edge_descriptor >
        predecessor_vec(n_verts);
    std::vector< default_color_type > color_vec(n_verts);
    std::vector< typename graph_traits< Graph >::vertices_size_type >
        distance_vec(n_verts);
    return boykov_kolmogorov_max_flow(g, cap, res_cap, rev,
        make_iterator_property_map(predecessor_vec.begin(), idx),
        make_iterator_property_map(color_vec.begin(), idx),
        make_iterator_property_map(distance_vec.begin(), idx), idx, src, sink);
}

/**
 * non-named-parameter version, some given: capacity, residual_capacity,
 * reverse_edges, color_map and an index map. Use this if you are interested in
 * the minimum cut, as the color map provides that info.
 */
template < class Graph, class CapacityEdgeMap, class ResidualCapacityEdgeMap,
    class ReverseEdgeMap, class ColorMap, class IndexMap >
typename property_traits< CapacityEdgeMap >::value_type
boykov_kolmogorov_max_flow(Graph& g, CapacityEdgeMap cap,
    ResidualCapacityEdgeMap res_cap, ReverseEdgeMap rev, ColorMap color,
    IndexMap idx, typename graph_traits< Graph >::vertex_descriptor src,
    typename graph_traits< Graph >::vertex_descriptor sink)
{
    typename graph_traits< Graph >::vertices_size_type n_verts
        = num_vertices(g);
    std::vector< typename graph_traits< Graph >::edge_descriptor >
        predecessor_vec(n_verts);
    std::vector< typename graph_traits< Graph >::vertices_size_type >
        distance_vec(n_verts);
    return boykov_kolmogorov_max_flow(g, cap, res_cap, rev,
        make_iterator_property_map(predecessor_vec.begin(), idx), color,
        make_iterator_property_map(distance_vec.begin(), idx), idx, src, sink);
}

/**
 * named-parameter version, some given
 */
template < class Graph, class P, class T, class R >
typename property_traits<
    typename property_map< Graph, edge_capacity_t >::const_type >::value_type
boykov_kolmogorov_max_flow(Graph& g,
    typename graph_traits< Graph >::vertex_descriptor src,
    typename graph_traits< Graph >::vertex_descriptor sink,
    const bgl_named_params< P, T, R >& params)
{
    return boykov_kolmogorov_max_flow(g,
        choose_const_pmap(get_param(params, edge_capacity), g, edge_capacity),
        choose_pmap(get_param(params, edge_residual_capacity), g,
            edge_residual_capacity),
        choose_const_pmap(get_param(params, edge_reverse), g, edge_reverse),
        choose_pmap(
            get_param(params, vertex_predecessor), g, vertex_predecessor),
        choose_pmap(get_param(params, vertex_color), g, vertex_color),
        choose_pmap(get_param(params, vertex_distance), g, vertex_distance),
        choose_const_pmap(get_param(params, vertex_index), g, vertex_index),
        src, sink);
}

/**
 * named-parameter version, none given
 */
template < class Graph >
typename property_traits<
    typename property_map< Graph, edge_capacity_t >::const_type >::value_type
boykov_kolmogorov_max_flow(Graph& g,
    typename graph_traits< Graph >::vertex_descriptor src,
    typename graph_traits< Graph >::vertex_descriptor sink)
{
    bgl_named_params< int, buffer_param_t > params(0); // bogus empty param
    return boykov_kolmogorov_max_flow(g, src, sink, params);
}

} // namespace boost

#endif // BOOST_BOYKOV_KOLMOGOROV_MAX_FLOW_HPP