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;
    }
}
void
do_pgr_driving_distance(
        pgr_edge_t  *data_edges, size_t total_edges,
        int64_t     start_vertex,
        float8      distance,
        bool        directedFlag,
        General_path_element_t **ret_path, size_t *path_count,
        char                   **err_msg) {
    std::ostringstream log;
    try {
        // if it already has values there will be a leak
        // call with pointing to NULL
        *ret_path = NULL;

        log << "NOTICE: Started processing pgr_drivingDistance for 1 start_vid\n";
        // in c code this should have been checked:
        //  1) start_vertex is in the data_edges  DONE

        graphType gType = directedFlag? DIRECTED: UNDIRECTED;
        const auto initial_size = total_edges;

        Path path;


        if (directedFlag) {
            log << "NOTICE: Processing Directed graph\n";
            Pgr_base_graph< DirectedGraph > digraph(gType, initial_size);
            digraph.graph_insert_data(data_edges, total_edges);
            pgr_drivingDistance(digraph, path, start_vertex, distance);
        } else {
            log << "NOTICE: Processing Undirected graph\n";
            Pgr_base_graph< UndirectedGraph > undigraph(gType, initial_size);
            undigraph.graph_insert_data(data_edges, total_edges);
            pgr_drivingDistance(undigraph, path, start_vertex, distance);
        }

        log << "Returning number of tuples" << path.size() << "\n";
        if (path.empty()) {
            log << "NOTICE: it should have at least the one for it self";
            *err_msg = strdup(log.str().c_str());
            *ret_path = noResult(path_count, (*ret_path));
            return;
        }

        log << "NOTICE: Calculating the number of tuples \n";
        auto count = path.size();

        log << "NOTICE Count: " << count << " tuples\n";

        *ret_path = get_memory(count, (*ret_path));

        size_t sequence = 0;
        path.get_pg_dd_path(ret_path, sequence);
        *path_count = count;

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

        return;
    } catch ( ... ) {
        log << "NOTICE: unknown exception cought";
        *err_msg = strdup(log.str().c_str());
        *ret_path = noResult(path_count, (*ret_path));
        return;
    }
}
Beispiel #3
0
void process_drivingDistance(G &graph, const std::vector<std::string> &tokens) {
      std::string::size_type sz;
      if (tokens[1].compare("from") != 0) {
        std::cout << "missing 'from' kewyword\n";
        return;
      }

      std::vector< int64_t > sources;
      unsigned int i_ptr = 2;

      for ( ; i_ptr < tokens.size(); ++i_ptr) {
          if (tokens[i_ptr].compare("dist") == 0) break;
          try {
            uint64_t start_vertex(stol(tokens[i_ptr], &sz));
            sources.push_back(start_vertex);
          } catch(...) {
            break;
          }
      }

      if (i_ptr == tokens.size() || tokens[i_ptr].compare("dist") != 0) {
        std::cout << "drivDist: 'dist' kewyword not found\n";
        return;
      }

      if (sources.size() == 0) {
        std::cout << "drivDist: No start value found\n";
        return;
      }

      ++i_ptr;
      if (i_ptr == tokens.size()) {
        std::cout << " 'distance' value not found\n";
        return;
      }

      double distance = stod(tokens[i_ptr], &sz);

      ++i_ptr;
      bool equiCost(false);
      if (i_ptr != tokens.size()) {
        if (tokens[i_ptr].compare("equi") != 0) {
          std::cout << " Unknown keyword '" << tokens[i_ptr] << "' found\n";
          return;
        } else {
          equiCost = true;
        }
      }

      std::cout << "found " << sources.size() << "starting locations\n";
      Pgr_dijkstra< G > fn_dijkstra;

      if (sources.size() == 1) {
        std::cout << "Performing pgr_DrivingDistance for single source\n";
        Path path;
        pgr_drivingDistance(graph, path, sources[0], distance);
        std::cout << "\t\t\tTHE OPUTPUT\n";
        std::cout << "seq\tfrom\tnode\tedge\tcost\n";
        path.print_path();
      } else {
        std::deque< Path >  paths;
        pgr_drivingDistance(graph, paths, sources, distance);
        if (equiCost == false) {
          std::cout << "Performing pgr_DrivingDistance for multiple sources\n";
          std::cout << "\t\t\tTHE OPUTPUT\n";
          std::cout << "seq\tfrom\tnode\tedge\tcost\n";
          for (const auto &path :  paths) {
            if (sizeof(path) == 0) return;  // no solution found
            path.print_path();
          }
        } else {
          std::cout << "Performing pgr_DrivingDistance for multiple sources with equi-cost\n";
          Path path = equi_cost(paths);
          std::cout << "\t\t\tTHE EquiCost OPUTPUT\n";
          std::cout << "seq\tfrom\tnode\tedge\tcost\n";
          path.print_path();
        }
      }
}