Esempi in C++ (Cpp) per s_start_vertices

Esempio n. 1

File: boost_interface_drivedist.cpp Progetto: DavidLiuGitHub/pgrouting

void
do_pgr_driving_many_to_dist(
        pgr_edge_t  *data_edges, size_t total_tuples,
        int64_t  *start_vertex, size_t s_len,
        float8 distance,
        bool directedFlag,
        bool equiCostFlag,
        General_path_element_t **ret_path, size_t *path_count,
        char ** err_msg) {
    try {
        graphType gType = directedFlag? DIRECTED: UNDIRECTED;
        const auto initial_size = total_tuples;

        std::deque< Path >paths;
        std::set< int64_t > s_start_vertices(start_vertex, start_vertex + s_len);
        std::vector< int64_t > start_vertices(s_start_vertices.begin(), s_start_vertices.end());

        if (directedFlag) {
            Pgr_base_graph< DirectedGraph > digraph(gType, initial_size);
            digraph.graph_insert_data(data_edges, total_tuples);
            pgr_drivingDistance(digraph, paths, start_vertices, distance, equiCostFlag);
        } else {
            Pgr_base_graph< UndirectedGraph > undigraph(gType, initial_size);
            undigraph.graph_insert_data(data_edges, total_tuples);
            pgr_drivingDistance(undigraph, paths, start_vertices, distance, equiCostFlag);
        }

        size_t count(count_tuples(paths));


        if (count == 0) {
            *err_msg = strdup("NOTICE: No return values was found");
            *ret_path = noResult(path_count, (*ret_path));
            return;
        }
        *ret_path = get_memory(count, (*ret_path));
        auto trueCount(collapse_paths(ret_path, paths));
        *path_count = trueCount;


#ifndef DEBUG
        *err_msg = strdup("OK");
#else
        *err_msg = strdup(log.str().c_str());
#endif
        return;

    } catch ( ... ) {
        *err_msg = strdup("Caught unknown expection!");
        *ret_path = noResult(path_count, (*ret_path));
        return;
    }
}

Esempio n. 2

int
do_pgr_many_to_one_withPoints(
        pgr_edge_t *edges, size_t total_edges,
        Point_on_edge_t *points_p, size_t total_points,
        pgr_edge_t *edges_of_points, size_t total_edges_of_points,
        int64_t *start_pidsArr, size_t size_start_pidsArr,
        int64_t end_vid,
        char driving_side,
        bool details,
        bool directed,
        bool only_cost,
        General_path_element_t **return_tuples, size_t *return_count,
        char ** err_msg) {
    std::ostringstream log;
    try {
        std::vector< Point_on_edge_t >
            points(points_p, points_p + total_points);

        int errcode = check_points(points, log);
        if (errcode) {
            /* Point(s) with same pid but different edge/fraction/side combination found */
            *err_msg = strdup(log.str().c_str());
            return errcode;
        }

        std::vector< pgr_edge_t >
            edges_to_modify(edges_of_points, edges_of_points + total_edges_of_points);

        std::vector< pgr_edge_t > new_edges;

        create_new_edges(
                points,
                edges_to_modify,
                driving_side,
                new_edges);


        std::set< int64_t > s_start_vertices(start_pidsArr, start_pidsArr + size_start_pidsArr);
        std::vector< int64_t > start_vertices(s_start_vertices.begin(), s_start_vertices.end());

        graphType gType = directed? DIRECTED: UNDIRECTED;

        std::deque< Path > paths;


        if (directed) {
            log << "Working with directed Graph\n";
            pgrouting::DirectedGraph digraph(gType);
            digraph.graph_insert_data(edges, total_edges);
            digraph.graph_insert_data(new_edges);
            pgr_dijkstra(digraph, paths, start_vertices, end_vid, only_cost);
        } else {
            log << "Working with Undirected Graph\n";
            pgrouting::UndirectedGraph undigraph(gType);
            undigraph.graph_insert_data(edges, total_edges);
            undigraph.graph_insert_data(new_edges);
            pgr_dijkstra(undigraph, paths, start_vertices, end_vid, only_cost);
        }

#if 0
        for (auto &path : paths) {
            adjust_pids(points, path);
        }
#endif
        if (!details) {
            for (auto &path : paths) {
                eliminate_details(path, edges_to_modify);
            }
        }

        /*
         * order paths based on the start_pid
         */
        std::sort(paths.begin(), paths.end(), [](const Path &a, const Path &b) {
                return a.start_id() < b.start_id();
                });

        size_t count(0);
        count = count_tuples(paths);


        if (count == 0) {
            (*return_tuples) = NULL;
            (*return_count) = 0;
            log <<
                "No paths found between Starting and any of the Ending vertices\n";
            *err_msg = strdup(log.str().c_str());
            return 0;
        }

        (*return_tuples) = pgr_alloc(count, (*return_tuples));
        log << "Converting a set of paths into the tuples\n";
        (*return_count) = (collapse_paths(return_tuples, paths));

#ifndef NDEBUG
        {
            std::ostringstream log;
            log << "OK";
            *err_msg = strdup(log.str().c_str());
        }

#else
        *err_msg = strdup(log.str().c_str());
#endif
        return 0;
    } catch ( ... ) {
        log << "Caught unknown exception!\n";
        *err_msg = strdup(log.str().c_str());
        return 1000;
    }
    return 0;
}