C++ LatLng::getLat方法代码示例

 static double getPickupDistance_maxPickupConstr_route(Route * pRoute, Request * pRequest, int pickupOrder) {
     
     // ensure there are two existing pickups
     assert( pRoute->getPickupEvents()->size() == 2 );
     
     const time_t reqTime = pRequest->getReqTime();
             
     const Event * pDispatch = pRoute->getDispatchEvent();
     RouteEvent * pFirstSchedPick  = pRoute->getPickupEvents()->front();
     RouteEvent * pSecondSchedPick = pRoute->getPickupEvents()->back();
     
     // case 1: the request is to be the first pickup in the new route
     if ( pickupOrder == 1 ) {
         // 1.A the request occurs BEFORE the first sched pickup
         if( reqTime < pFirstSchedPick->getEventTime() ) {
             LatLng currLoc = Utility::estLocationByLinearProxy(reqTime, pDispatch->timeT, pDispatch->lat, pDispatch->lng, pFirstSchedPick->getEventTime(), pFirstSchedPick->getLat(), pFirstSchedPick->getLng());
             double distToCurrReq = Utility::computeGreatCircleDistance(currLoc.getLat(), currLoc.getLng(), pRequest->getActualPickupEvent()->lat, pRequest->getActualPickupEvent()->lng);
             return distToCurrReq;
         }
         // 1.B the request already occurred and request is in between first and second scheduled pickup
         else if( (pFirstSchedPick->getEventTime() <= reqTime) && (reqTime <= pSecondSchedPick->getEventTime()) ) {
             LatLng currLoc = Utility::estLocationByLinearProxy(reqTime, pFirstSchedPick->getEventTime(), pFirstSchedPick->getLat(), pFirstSchedPick->getLng(), pSecondSchedPick->getEventTime(), pSecondSchedPick->getLat(), pSecondSchedPick->getLng());
             double distToCurrReq = Utility::computeGreatCircleDistance(currLoc.getLat(), currLoc.getLng(), pRequest->getActualPickupEvent()->lat, pRequest->getActualPickupEvent()->lng);
             return distToCurrReq;
         }
     }
     
     // case 2: the request is not to be the first pickup in the new route
     else {
         // get prior pickup event
         RouteEvent * pPriorPickup = pRoute->getPickupEvents()->at(pickupOrder-2); // e.g. if the 2nd pickup, then the prior is the 1st pickup which is index 0
         
         // 2.A: the request occurs BEFORE the pickup of the prior event
         if( reqTime < pPriorPickup->getEventTime() ) {
             double distToCurrReq = Utility::computeGreatCircleDistance(pPriorPickup->getLat(), pPriorPickup->getLng(), pRequest->getActualPickupEvent()->lat, pRequest->getActualPickupEvent()->lng);
             return distToCurrReq;
         }
         
         // 2.B: the requests occurs AFTER pickup of the prior event
         else {
             RouteEvent * pNextEvent = (pickupOrder == 2) ? pRoute->getPickupEvents()->back() : pRoute->getDropoffEvents()->front();
             LatLng currLoc = Utility::estLocationByLinearProxy(reqTime, pPriorPickup->getEventTime(), pPriorPickup->getLat(), pPriorPickup->getLng(), pNextEvent->getEventTime(), pNextEvent->getLat(), pNextEvent->getLng());
             double distToCurrReq = Utility::computeGreatCircleDistance(currLoc.getLat(), currLoc.getLng(), pRequest->getActualPickupEvent()->lat, pRequest->getActualPickupEvent()->lng);
             return distToCurrReq;
         }
         
     }
     
     cout << "** unhandled case when checking for pickup distance to minion req **\n" << endl;
     exit(1);
     return 0.0;
 }

 static std::string convertToLatLngStr(const LatLng &loc, int prec) {
     std::string locStr = "";
     locStr += Utility::truncateDouble(loc.getLat(), prec);
     locStr += ",";
     locStr += Utility::truncateDouble(loc.getLng(), prec);
     return locStr;
 }    

 //static double getPickupDistanceAtTimeOfMinionRequest(Request * pRequest, OpenTrip * pOpenTrip) {
 static double getPickupDistanceAtTimeOfMinionRequest_maxPickupConstr(
         const time_t minionReqTime,         // request time
         const double minionPickupLat,       // request lat
         const double minionPickupLng,       // request lng
         const time_t masterPickupTime,      // previous event time
         const double masterPickupLat,       // previous event start lat
         const double masterPickupLng,       // previous event start lng
         const time_t masterDropoffTime,     // next event time
         const double masterDropLat,         // next event end lat
         const double masterDropLng,         // next event end lng
         const time_t masterDispatchTime,    // dispatch time
         const double masterDispatchLat,     // dispatch lat
         const double masterDispatchLng      // dispatch lng
         ) {
     
     // case 1: pickup has NOT occurred (non-extended)
     if( minionReqTime <= masterPickupTime ) {
         
         // pickup distance from current location to minion origin
         LatLng estMasterLocation = Utility::estLocationByLinearProxy(minionReqTime, masterDispatchTime, masterDispatchLat, masterDispatchLng, masterPickupTime, masterPickupLat, masterPickupLng);
         double pickupDistance_driverToMaster = Utility::computeGreatCircleDistance(estMasterLocation.getLat(), estMasterLocation.getLng(), masterPickupLat, masterPickupLng);
         
         // pickup distance from master to minion
         double pickupDistance_masterToMinion = Utility::computeGreatCircleDistance(masterPickupLat, masterPickupLng, minionPickupLat, minionPickupLng);
         
         double pickupDistance_total = pickupDistance_driverToMaster + pickupDistance_masterToMinion;
         return pickupDistance_total;
     }
     
     // case 2: pickup HAS occurred (extended)
     else {
         // estimate location     
         LatLng estLocAtTimeOfRequest = Utility::estLocationByLinearProxy(minionReqTime, masterPickupTime, masterPickupLat, masterPickupLng, masterDropoffTime, masterDropLat, masterDropLng);
         
         // pickup distance is 
         double pickupDistance = Utility::computeGreatCircleDistance(estLocAtTimeOfRequest.getLat(), estLocAtTimeOfRequest.getLng(), minionPickupLat, minionPickupLng);
         
         return pickupDistance;
     }                
 }

NearestEdgeInfo GraphStorage::GetNearestEdge(const LatLng &source, const double &radius) const
{
    // Get all nodes within a radius
    vector<int> nodes = kd_tree.RadiusSearch(source, radius);

    // Get all edges within that radius
    // We want to get a set of edges and avoid adding
    // the same A->B and B->A edge twice
    set<Edge, function<bool(const Edge &, const Edge &)>>
                edges(
                    // Custom compare function to avoid adding A->B and B->A edges twice
                    [](const Edge &e1, const Edge &e2)
                    {
                        const int x = min(e1.u, e1.v);
                        const int y = min(e2.u, e2.v);
                        if (x < y)
                            return true;
                        else if (y > x)
                            return false;
                        else
                            return max(e1.u, e1.v) < max(e2.u, e2.v);
                    }
                );

    // Fill in a set of (undirected) edges
    // For each node
    for (int i = 0; i < nodes.size(); ++i)
    {
        const int A = nodes[i];

        // For each edge that starts from this node
        for (int j = 0; j < adjacency_lists[A].size(); ++j)
        {
            const auto &e = adjacency_lists[A][j];
            if (e.is_startpoint) // only startpoints
            {
                const int B = e.v;
                if (e.edge_type == Edge::BACKWARD_EDGE)
                    edges.insert(Edge(B, A, e.w, e.edge_type));
                else
                    edges.insert(Edge(A, B, e.w, e.edge_type));
            }
        }
    }

    auto current_best = NearestEdgeInfo();

    if (edges.empty())
    {
        return current_best;
    }

    // Find nearest edge
    const double    source_lat    = source.getLat();
    const double    source_lng    = source.getLng();
    double          best_distance = numeric_limits<double>::max();
    for (const auto &e : edges)
    {
        double clamped_ratio;
        LatLng projected_point;

        tie(clamped_ratio, projected_point) = LatLng::ProjectOnSegment(source_lat, source_lng,
                                                                       coordinates[e.u], coordinates[e.v]);
        const double current_distance = LatLng::DistanceInMeters(source_lat, source_lng,
                                                                 projected_point.getLat(), projected_point.getLng());
        // Update nearest edge information
        if (current_distance < best_distance)
        {
            best_distance = current_distance;
            current_best  = NearestEdgeInfo(e, projected_point, clamped_ratio, true);
        }
    }
    return current_best;
}

 // compute pick up distance
 static double computePickupDistance_savingsConstr(
         const time_t masterETA, const double masterOrigLat, const double masterOrigLng, 
         const time_t masterETD, const double masterDestLat, const double masterDestLng, 
         const time_t minionReqTime, const double minionOrigLat, const double minionOrigLng, 
         int inclInitDistExtendedMatches
 ) {                
     double pickupDist = 0.0;
     
     bool isExtended = (masterETA <= minionReqTime);
     
     // case 1: non-extended match
     if( !isExtended ) {
         pickupDist = Utility::computeGreatCircleDistance(masterOrigLat, masterOrigLng, minionOrigLat, minionOrigLng);
     }
     
     // case 2: extended match
     else {
         // get the master location at time of minion request
         LatLng estLocAtMinReq = Utility::estLocationByLinearProxy(minionReqTime, masterETA, masterOrigLat, masterOrigLng, masterETD, masterDestLat, masterDestLng);
         
         // compute dist between master origin and curr location
         const double distFromOrigToCurrLoc = (inclInitDistExtendedMatches) ? Utility::computeGreatCircleDistance(masterOrigLat, masterOrigLng, estLocAtMinReq.getLat(), estLocAtMinReq.getLng()) : 0.0;
         
         // compute dist between curr location and minion origin
         const double distFromCurrLocToMinion = Utility::computeGreatCircleDistance(estLocAtMinReq.getLat(), estLocAtMinReq.getLng(), minionOrigLat, minionOrigLng);
         
         pickupDist = distFromOrigToCurrLoc + distFromCurrLocToMinion;               
     }
     
     return pickupDist;
 }