snake.cpp

  const Assignment *solution = routing.SolveWithParameters(searchParameters);
#ifdef SNAKE_SHOW_TIME
  delta = std::chrono::duration_cast<std::chrono::milliseconds>(
      std::chrono::high_resolution_clock::now() - start);
  cout << "Execution time routing.SolveWithParameters(): " << delta.count()
       << " ms" << endl;
#endif

  if (!solution || solution->Size() <= 1) {
    errorString = "Not able to solve the routing problem.";
    return false;
  }

  // Extract index list from solution.
  index = routing.Start(0);
  std::vector<size_t> route_idx;
  route_idx.push_back(manager.IndexToNode(index).value());
  while (!routing.IsEnd(index)) {
    index = solution->Value(routing.NextVar(index));
    route_idx.push_back(manager.IndexToNode(index).value());
  }

  // Helper Lambda.
  auto idx2Vertex = [&vertices](const std::vector<size_t> &idxArray,
                                std::vector<BoostPoint> &path) {
    for (auto idx : idxArray)
      path.push_back(vertices[idx]);
  };

  // Construct route.
  for (size_t i = 0; i < route_idx.size() - 1; ++i) {
    size_t idx0 = route_idx[i];
    size_t idx1 = route_idx[i + 1];
    const auto &info1 = transectInfoList[idx0];
    const auto &info2 = transectInfoList[idx1];
    if (info1.index == info2.index) { // same transect?
      if (!info1.front) {             // transect reversal needed?
        BoostLineString reversedTransect;
        const auto &t = transects[info1.index];
        for (auto it = t.end() - 1; it >= t.begin(); --it) {
          reversedTransect.push_back(*it);
        }
        transectsRouted.push_back(reversedTransect);
        for (auto it = reversedTransect.begin();
             it < reversedTransect.end() - 1; ++it) {
          route.push_back(*it);
        }
      } else {
        const auto &t = transects[info1.index];
        for (auto it = t.begin(); it < t.end() - 1; ++it) {
          route.push_back(*it);
        }
        transectsRouted.push_back(t);
      }
    } else {
      std::vector<size_t> idxList;
      shortestPathFromGraph(connectionGraph, idx0, idx1, idxList);
      if (i != route_idx.size() - 2) {
        idxList.pop_back();
      }
      idx2Vertex(idxList, route);
    }
  }
  return true;
}

} // namespace snake

bool boost::geometry::model::operator==(snake::BoostPoint p1,
                                        snake::BoostPoint p2) {
  return (p1.get<0>() == p2.get<0>()) && (p1.get<1>() == p2.get<1>());
}

bool boost::geometry::model::operator!=(snake::BoostPoint p1,
                                        snake::BoostPoint p2) {
  return !(p1 == p2);
}