Method Solve

src/Tracker/ShortPathCalculator.cpp:18–68

\brief SPBipart::Solve \param costMatrix \param N \param M \param assignment \param maxCost

/// \param maxCost
///
void SPBipart::Solve(const distMatrix_t& costMatrix, size_t colsTracks, size_t rowsRegions, assignments_t& assignmentT2R, track_t maxCost)
{
    //std::cout << "SPBipart::Solve: colsTracks = " << colsTracks << ", rowsRegions = " << rowsRegions << std::endl;

    MyGraph G;
    G.make_directed();

    std::vector<GTL::node> nodes(colsTracks + rowsRegions);

    for (size_t i = 0; i < nodes.size(); ++i)
    {
        nodes[i] = G.new_node();
    }

	GTL::edge_map<int> weights(G, 100);
    for (size_t i = 0; i < colsTracks; ++i)
    {
        bool hasZeroEdge = false;

        for (size_t j = 0; j < rowsRegions; ++j)
        {
            track_t currCost = costMatrix[i + j * colsTracks];

			GTL::edge e = G.new_edge(nodes[i], nodes[colsTracks + j]);

            if (currCost < m_settings.m_distThres)
            {
                int weight = static_cast<int>(maxCost - currCost + 1);
                G.set_edge_weight(e, weight);
                weights[e] = weight;
            }
            else
            {
                if (!hasZeroEdge)
                {
                    G.set_edge_weight(e, 0);
                    weights[e] = 0;
                }
                hasZeroEdge = true;
            }
        }
    }

	GTL::edges_t L = MAX_WEIGHT_BIPARTITE_MATCHING(G, weights);
    for (GTL::edges_t::iterator it = L.begin(); it != L.end(); ++it)
    {
        GTL::node a = it->source();
        GTL::node b = it->target();
        assignmentT2R[b.id()] = static_cast<assignments_t::value_type>(a.id() - colsTracks);
    }
}

///
void SPLAPJV::Solve(const distMatrix_t& costMatrix, size_t colsTracks, size_t rowsRegions, assignments_t& assignmentT2R, track_t /*maxCost*/)