กำลังรับข้อมูล
การรับข้อมูลตำแหน่งที่รวบรวมไว้ทำได้หลายวิธี ในที่นี้เราจะอธิบาย เทคนิคในการดึงข้อมูลเพื่อนำมาใช้กับคุณลักษณะสแนปไปยังถนนของ Roads API
GPX
GPX เป็นรูปแบบ XML แบบเปิดสำหรับการแชร์เส้นทาง เส้นทาง และจุดอ้างอิง ภาพที่ถ่ายโดยอุปกรณ์ GPS ตัวอย่างนี้ใช้โปรแกรมแยกวิเคราะห์ XmlPull โปรแกรมแยกวิเคราะห์ XML ขนาดเล็กสามารถใช้งานได้ทั้งในสภาพแวดล้อมของเซิร์ฟเวอร์ Java และโทรศัพท์มือถือ
/** * Parses the waypoint (wpt tags) data into native objects from a GPX stream. */ private List<LatLng> loadGpxData(XmlPullParser parser, InputStream gpxIn) throws XmlPullParserException, IOException { // We use a List<> as we need subList for paging later List<LatLng> latLngs = new ArrayList<>(); parser.setInput(gpxIn, null); parser.nextTag(); while (parser.next() != XmlPullParser.END_DOCUMENT) { if (parser.getEventType() != XmlPullParser.START_TAG) { continue; } if (parser.getName().equals("wpt")) { // Save the discovered latitude/longitude attributes in each <wpt>. latLngs.add(new LatLng( Double.valueOf(parser.getAttributeValue(null, "lat")), Double.valueOf(parser.getAttributeValue(null, "lon")))); } // Otherwise, skip irrelevant data } return latLngs; }
นี่เป็นข้อมูลดิบ GPX ที่โหลดลงบนแผนที่
บริการตำแหน่งของ Android
วิธีที่ดีที่สุดในการจับภาพข้อมูล GPS จากอุปกรณ์ Android จะแตกต่างกันไปโดยขึ้นอยู่กับ Use Case ดูคลาสการฝึกอบรมของ Android เกี่ยวกับตำแหน่งการรับตำแหน่ง การอัปเดตและตัวอย่างตำแหน่ง Google Play ใน GitHub
การประมวลผลเส้นทางยาว
เนื่องจากฟีเจอร์สแนปไปยังถนนจะอนุมานตำแหน่งโดยอิงตามเส้นทางแบบเต็ม คุณต้องระมัดระวังเมื่อประมวลผลเป็นเวลานาน แทนที่จะเป็นคะแนนแยกแต่ละคะแนน เส้นทาง (กล่าวคือ เส้นทางที่เกินขีดจำกัด 100 จุดต่อคำขอ)
หากต้องการให้คำขอแต่ละรายการเป็นเส้นทางยาวเส้นทางเดียว คุณควรใส่ ทับซ้อนกัน เช่น ประเด็นสุดท้ายจากคำขอก่อนหน้าถูกรวมไว้ด้วย เป็นจุดแรกของคำขอที่ตามมา จำนวนจุดที่ต้องรวมไว้ ขึ้นอยู่กับความถูกต้องของข้อมูล คุณควรใส่คะแนนเพิ่มอีก สำหรับคำขอที่มีความแม่นยำต่ำ
ตัวอย่างนี้ใช้ไคลเอ็นต์ Java สำหรับบริการ Google Maps เพื่อส่งคำขอแบบแบ่งหน้าและ จากนั้นจะรวมข้อมูลอีกครั้ง รวมถึงจุดประมาณ ลงในรายการที่ส่งคืน
/** * Snaps the points to their most likely position on roads using the Roads API. */ private List<SnappedPoint> snapToRoads(GeoApiContext context) throws Exception { List<SnappedPoint> snappedPoints = new ArrayList<>(); int offset = 0; while (offset < mCapturedLocations.size()) { // Calculate which points to include in this request. We can't exceed the API's // maximum and we want to ensure some overlap so the API can infer a good location for // the first few points in each request. if (offset > 0) { offset -= PAGINATION_OVERLAP; // Rewind to include some previous points. } int lowerBound = offset; int upperBound = Math.min(offset + PAGE_SIZE_LIMIT, mCapturedLocations.size()); // Get the data we need for this page. LatLng[] page = mCapturedLocations .subList(lowerBound, upperBound) .toArray(new LatLng[upperBound - lowerBound]); // Perform the request. Because we have interpolate=true, we will get extra data points // between our originally requested path. To ensure we can concatenate these points, we // only start adding once we've hit the first new point (that is, skip the overlap). SnappedPoint[] points = RoadsApi.snapToRoads(context, true, page).await(); boolean passedOverlap = false; for (SnappedPoint point : points) { if (offset == 0 || point.originalIndex >= PAGINATION_OVERLAP - 1) { passedOverlap = true; } if (passedOverlap) { snappedPoints.add(point); } } offset = upperBound; } return snappedPoints; }
นี่คือข้อมูลจากด้านบนหลังจากจับภาพคำขอถนน สีแดง เส้นเป็นข้อมูลดิบ และเส้นสีน้ำเงินคือข้อมูลที่สแนป
การใช้โควต้าอย่างมีประสิทธิภาพ
การตอบกลับคำขอสแนปไปยังถนนจะรวมรายการรหัสสถานที่
นั้นตรงกับจุดที่คุณให้ไว้ และอาจมีจุดเพิ่มเติมหากคุณ
ตั้งค่า interpolate=true
เพื่อให้ใช้โควต้าที่อนุญาตสำหรับคำขอขีดจำกัดความเร็วได้อย่างมีประสิทธิภาพ คุณควรค้นหาเฉพาะรหัสสถานที่ที่ไม่ซ้ำกันในคำขอ ตัวอย่างนี้ใช้ ไคลเอ็นต์ Java สำหรับบริการ Google Maps เพื่อค้นหาขีดจำกัดความเร็วจากรายการสถานที่ รหัส
/** * Retrieves speed limits for the previously-snapped points. This method is efficient in terms * of quota usage as it will only query for unique places. * * Note: Speed limit data is only available for requests using an API key enabled for a * Google Maps APIs Premium Plan license. */ private Map<String, SpeedLimit> getSpeedLimits(GeoApiContext context, List<SnappedPoint> points) throws Exception { Map<String, SpeedLimit> placeSpeeds = new HashMap<>(); // Pro tip: Save on quota by filtering to unique place IDs. for (SnappedPoint point : points) { placeSpeeds.put(point.placeId, null); } String[] uniquePlaceIds = placeSpeeds.keySet().toArray(new String[placeSpeeds.keySet().size()]); // Loop through the places, one page (API request) at a time. for (int i = 0; i < uniquePlaceIds.length; i += PAGE_SIZE_LIMIT) { String[] page = Arrays.copyOfRange(uniquePlaceIds, i, Math.min(i + PAGE_SIZE_LIMIT, uniquePlaceIds.length)); // Execute! SpeedLimit[] placeLimits = RoadsApi.speedLimits(context, page).await(); for (SpeedLimit sl : placeLimits) { placeSpeeds.put(sl.placeId, sl); } } return placeSpeeds; }
นี่เป็นข้อมูลจากด้านบนที่มีขีดจำกัดความเร็วซึ่งทำเครื่องหมายไว้ที่รหัสสถานที่แต่ละแห่งที่ไม่ซ้ำกัน
ทำงานร่วมกันด้วย API อื่นๆ
ข้อดีอย่างหนึ่งของการที่สามารถแสดงรหัสสถานที่ได้ในรูปสับเปลี่ยนถนน คือคุณสามารถใช้รหัสสถานที่ Google Maps Platform API ตัวอย่างนี้ใช้ไคลเอ็นต์ Java สำหรับบริการ Google Maps เพื่อระบุพิกัดทางภูมิศาสตร์ของสถานที่ซึ่งส่งคืนจากภาพถ่ายด้านบนเป็นคำขอเกี่ยวกับถนน
/** * Geocodes a snapped point using the place ID. */ private GeocodingResult geocodeSnappedPoint(GeoApiContext context, SnappedPoint point) throws Exception { GeocodingResult[] results = GeocodingApi.newRequest(context) .place(point.placeId) .await(); if (results.length > 0) { return results[0]; } return null; }
ที่นี่ เครื่องหมายจำกัดความเร็วจะมีคำอธิบายประกอบเป็นที่อยู่จาก Geocoding API
โค้ดตัวอย่าง
ข้อควรพิจารณา
โค้ดที่สนับสนุนบทความนี้พร้อมใช้งานในแอป Android แอปเดียวสำหรับ เพื่อการอธิบาย ในทางปฏิบัติ คุณไม่ควรเผยแพร่ฝั่งเซิร์ฟเวอร์ คีย์ API ในแอป Android เนื่องจากคีย์ของคุณไม่สามารถป้องกันการป้องกันที่ไม่ได้รับอนุญาต เข้าถึงจากบุคคลที่สาม แต่ในการทำให้คีย์ปลอดภัย คุณควรปรับใช้ โค้ดที่ใช้ API เป็นพร็อกซีฝั่งเซิร์ฟเวอร์และให้แอป Android ของคุณส่งคำขอ ผ่านพร็อกซี เพื่อให้แน่ใจว่าคำขอได้รับอนุญาต
ดาวน์โหลด
ดาวน์โหลดโค้ดจาก GitHub