Öğretici: Azure Notebooks (Python) kullanarak elektrik ve yönlendirme

  • Makale
  • Okumak için 8 dakika

azure Haritalar, azure ile yerel olarak tümleştirilmiş jeo-uzamsal hizmet apı 'lerinin bir portföyüdür. Bu API 'Ler, geliştiricilerin, kuruluşların ve ISV 'Lerin konuma duyarlı uygulamalar, IoT, Mobility, lojistik ve varlık izleme çözümleri geliştirmesini sağlar.

Azure Haritalar REST apı 'leri, jeo-uzamsal veri analizi ve makine öğrenimi senaryolarını etkinleştirmek için Python ve R gibi dillerden çağrılabilir. Azure Haritalar, kullanıcıların çeşitli veri noktaları arasındaki rotaları hesaplamasını sağlayan güçlü bir yönlendirme apı 'leri kümesi sunar. Hesaplamalar, araç türü veya ulaşılabilir alan gibi çeşitli koşullara dayanır.

Bu öğreticide, elektrik araç pili düşük olan bir sürücünün yardımına kılavuzluk edersiniz. Sürücünün, aracın konumundan olası en yakın ücretlendirme istasyonunu bulması gerekir.

Bu öğreticide şunları yapacaksınız:

  • Bulutta Azure Notebooks bir Jupyter Notebook dosyası oluşturun ve çalıştırın.
  • Python 'da Azure Haritalar REST apı 'lerini çağırın.
  • Elektrik araç tüketiminin tüketim modeline göre erişilebilir bir Aralık arayın.
  • Erişilebilir Aralık veya ısovaone içindeki elektrik araç doldurma istasyonlarını arayın.
  • Bir haritada erişilebilir Aralık sınırı ve ücretlendirme istasyonlarını işleme.
  • Sürücü zamanına göre en yakın elektrik araç doldurma istasyonuna bir yol bulun ve görselleştirin.

Önkoşullar

  1. bir Azure Haritalar hesabı oluşturunve Gen 2 ya da S1 fiyatlandırma katmanını seçin.
  2. Birincil anahtar veya abonelik anahtarı olarak da bilinen birincil bir abonelik anahtarı alın.

azure Haritalar kimlik doğrulaması hakkında daha fazla bilgi için bkz. azure Haritalar kimlik doğrulamasını yönetme.

Azure Notebooks projesi oluşturma

Bu öğreticiyle birlikte izlemek için bir Azure Notebooks projesi oluşturmanız ve Jupyter Notebook dosyasını indirip çalıştırmanız gerekir. Jupyter Notebook dosyası, bu öğreticide senaryoyu uygulayan Python kodunu içerir. Bir Azure Notebooks projesi oluşturmak ve Jupyter Notebook belgeyi bu klasöre yüklemek için aşağıdaki adımları uygulayın:

  1. Azure Notebooks gidin ve oturum açın. Daha fazla bilgi için bkz. hızlı başlangıç: oturum açın ve bir kullanıcı kimliği ayarlayın.

  2. Ortak profil sayfanızın en üstünde Projelerim' nı seçin.

    Projelerim düğmesi

  3. Projelerim sayfasında yeni Project' yi seçin.

    yeni Project düğmesi

  4. yeni Project oluştur bölmesinde bir proje adı ve proje kimliği girin.

    yeni Project oluştur bölmesi

  5. Oluştur’u seçin.

  6. projeniz oluşturulduktan sonra bu Jupyter Notebook belge dosyasını Azure Haritalar Jupyter Notebook deposundanindirin.

  7. projelerim sayfasındaki projeler listesinde, projenizi seçin ve sonra Jupyter Notebook belge dosyasını karşıya yüklemek için Upload ' yi seçin.

    karşıya yükleme Jupyter Notebook

  8. dosyayı bilgisayarınızdan Upload ve ardından bitti' yi seçin.

  9. Karşıya yükleme başarıyla tamamlandıktan sonra, dosyanız proje sayfanızda görüntülenir. Dosyayı Jupyter Notebook olarak açmak için dosyaya çift tıklayın.

Jupyter Notebook dosyasında uygulanan işlevselliği anlamaya çalışın. Kodu, Jupyter Notebook dosyasında, tek seferde bir hücre olarak çalıştırın. Jupyter Notebook uygulamasının en üstündeki Çalıştır düğmesini seçerek kodu her hücrede çalıştırabilirsiniz.

Çalıştır düğmesi

Proje düzeyi paketleri 'ni yükler

Kodu Jupyter Notebook çalıştırmak için, aşağıdaki adımları uygulayarak paketleri proje düzeyine yüklersiniz:

  1. requirements.txt dosyasını Azure Haritalar Jupyter Notebook deposundanindirin ve ardından projenize yükleyin.

  2. proje panosunda Project Ayarlar' ni seçin.

  3. Project Ayarlar bölmesinde ortam sekmesini seçin ve ardından ekle' yi seçin.

  4. Ortam kurulum adımları altında şunları yapın: a. İlk açılan listede Requirements.txt' yi seçin.
    b. İkinci aşağı açılan listede requirements.txt dosyanızı seçin.
    c. Üçüncü açılan listede sürüm olarak Python sürüm 3,6 ' ı seçin.

  5. Kaydet’i seçin.

    Paketleri yükler

Gerekli modülleri ve çerçeveleri yükleme

Gerekli tüm modülleri ve çerçeveleri yüklemek için aşağıdaki betiği çalıştırın.

import time
import aiohttp
import urllib.parse
from IPython.display import Image, display

Erişilebilir Aralık sınırı iste

Bir paket teslim şirketi, Fleet ortamında bazı elektrik taşıtlar içerir. Gün boyunca, elektrik taşıtlarının ambara geri dönmek zorunda kalmadan yeniden ücretlendirilmelidir. Kalan tüm ücretler bir saatten daha az düşdüğünde, erişilebilir bir aralıktaki bir dizi ücretlendirme istasyonu arayın. Esas olarak, pil düşük bir ücret karşılığında bir ücretlendirme İstasyonu arar. Ve, bu ücretlendirme istasyonlarıyla ilgili sınır bilgilerini alırsınız.

Şirket ekonomisi ve hız dengelemesi gerektiren rotaları kullanmayı tercih ettiğinden, istenen routeType ekdir. aşağıdaki betik, Azure Haritalar yönlendirme hizmeti 'nin yol aralığı al apı 'sini çağırır. Bu, aracın tüketim modeli için parametreler kullanır. Daha sonra betiği, arabasının en fazla erişilebilir aralığını temsil eden geojson biçimindeki bir çokgen nesnesi oluşturma yanıtını ayrıştırır.

Elektrik Aracı 'nın erişilebilir aralığının sınırlarını öğrenmek için betiği aşağıdaki hücrede çalıştırın:

subscriptionKey = "Your Azure Maps key"
currentLocation = [34.028115,-118.5184279]
session = aiohttp.ClientSession()

# Parameters for the vehicle consumption model 
travelMode = "car"
vehicleEngineType = "electric"
currentChargeInkWh=45
maxChargeInkWh=80
timeBudgetInSec=550
routeType="eco"
constantSpeedConsumptionInkWhPerHundredkm="50,8.2:130,21.3"


# Get boundaries for the electric vehicle's reachable range.
routeRangeResponse = await (await session.get("https://atlas.microsoft.com/route/range/json?subscription-key={}&api-version=1.0&query={}&travelMode={}&vehicleEngineType={}&currentChargeInkWh={}&maxChargeInkWh={}&timeBudgetInSec={}&routeType={}&constantSpeedConsumptionInkWhPerHundredkm={}"
                                              .format(subscriptionKey,str(currentLocation[0])+","+str(currentLocation[1]),travelMode, vehicleEngineType, currentChargeInkWh, maxChargeInkWh, timeBudgetInSec, routeType, constantSpeedConsumptionInkWhPerHundredkm))).json()

polyBounds = routeRangeResponse["reachableRange"]["boundary"]

for i in range(len(polyBounds)):
    coordList = list(polyBounds[i].values())
    coordList[0], coordList[1] = coordList[1], coordList[0]
    polyBounds[i] = coordList

polyBounds.pop()
polyBounds.append(polyBounds[0])

boundsData = {
               "geometry": {
                 "type": "Polygon",
                 "coordinates": 
                   [
                      polyBounds
                   ]
                }
             }

Erişilebilir Aralık içinde elektrik araç doldurma istasyonlarını arayın

Elektrik Aracı için erişilebilir Aralık (ısovaone) belirledikten sonra, bu aralıktaki doldurma istasyonlarında arama yapabilirsiniz.

aşağıdaki betik, geometri apı 'sinin içinde Azure Haritalar Post aramasınıçağırır. Otomobilin en fazla erişilebilir aralığının sınırları dahilinde elektrik arabasının doldurma istasyonlarını arar. Sonra betik, yanıtı erişilebilir konumlar dizisine ayrıştırır.

Erişilebilir Aralık dahilinde elektrik araç doldurma istasyonlarını aramak için aşağıdaki betiği çalıştırın:

# Search for electric vehicle stations within reachable range.
searchPolyResponse = await (await session.post(url = "https://atlas.microsoft.com/search/geometry/json?subscription-key={}&api-version=1.0&query=electric vehicle station&idxSet=POI&limit=50".format(subscriptionKey), json = boundsData)).json() 

reachableLocations = []
for loc in range(len(searchPolyResponse["results"])):
                location = list(searchPolyResponse["results"][loc]["position"].values())
                location[0], location[1] = location[1], location[0]
                reachableLocations.append(location)

erişilebilir aralık ve doldurma noktalarını Azure Haritalar Data service 'e Upload

Bir haritada, elektrik taşısının maksimum erişilebilir aralığının miktarını ve sınırını görselleştirmek isteyeceksiniz. bunu yapmak için, sınır verilerini karşıya yükleyin ve istasyon verilerini Azure Haritalar data service 'e coğrafi json nesneleri olarak borçlandırın. veri Upload apı'sini kullanın.

Azure Haritalar data service 'e sınır ve ücretlendirme noktası verilerini yüklemek için aşağıdaki iki hücreyi çalıştırın:

rangeData = {
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "properties": {},
      "geometry": {
        "type": "Polygon",
        "coordinates": [
          polyBounds
        ]
      }
    }
  ]
}

# Upload the range data to Azure Maps Data service.
uploadRangeResponse = await session.post("https://us.atlas.microsoft.com/mapData?subscription-key={}&api-version=2.0&dataFormat=geojson".format(subscriptionKey), json = rangeData)

rangeUdidRequest = uploadRangeResponse.headers["Location"]+"&subscription-key={}".format(subscriptionKey)

while True:
    getRangeUdid = await (await session.get(rangeUdidRequest)).json()
    if 'udid' in getRangeUdid:
        break
    else:
        time.sleep(0.2)
rangeUdid = getRangeUdid["udid"]

poiData = {
    "type": "FeatureCollection",
    "features": [
      {
        "type": "Feature",
        "properties": {},
        "geometry": {
            "type": "MultiPoint",
            "coordinates": reachableLocations
        }
    }
  ]
}

# Upload the electric vehicle charging station data to Azure Maps Data service.
uploadPOIsResponse = await session.post("https://us.atlas.microsoft.com/mapData?subscription-key={}&api-version=2.0&dataFormat=geojson".format(subscriptionKey), json = poiData)

poiUdidRequest = uploadPOIsResponse.headers["Location"]+"&subscription-key={}".format(subscriptionKey)

while True:
    getPoiUdid = await (await session.get(poiUdidRequest)).json()
    if 'udid' in getPoiUdid:
        break
    else:
        time.sleep(0.2)
poiUdid = getPoiUdid["udid"]

Bir haritada doldurma istasyonlarını ve erişilebilir aralığı işleme

verileri veri hizmetine yükledikten sonra, Azure Haritalar Map ımage hizmetini al' ı çağırın. Bu hizmet, şu betiği çalıştırarak, statik eşleme görüntüsünde doldurma noktalarını ve en fazla erişilebilir sınırı işlemek için kullanılır:

# Get boundaries for the bounding box.
def getBounds(polyBounds):
    maxLon = max(map(lambda x: x[0], polyBounds))
    minLon = min(map(lambda x: x[0], polyBounds))

    maxLat = max(map(lambda x: x[1], polyBounds))
    minLat = min(map(lambda x: x[1], polyBounds))
    
    # Buffer the bounding box by 10 percent to account for the pixel size of pins at the ends of the route.
    lonBuffer = (maxLon-minLon)*0.1
    minLon -= lonBuffer
    maxLon += lonBuffer

    latBuffer = (maxLat-minLat)*0.1
    minLat -= latBuffer
    maxLat += latBuffer
    
    return [minLon, maxLon, minLat, maxLat]

minLon, maxLon, minLat, maxLat = getBounds(polyBounds)

path = "lcff3333|lw3|la0.80|fa0.35||udid-{}".format(rangeUdid)
pins = "custom|an15 53||udid-{}||https://raw.githubusercontent.com/Azure-Samples/AzureMapsCodeSamples/master/AzureMapsCodeSamples/Common/images/icons/ev_pin.png".format(poiUdid)

encodedPins = urllib.parse.quote(pins, safe='')

# Render the range and electric vehicle charging points on the map.
staticMapResponse =  await session.get("https://atlas.microsoft.com/map/static/png?api-version=1.0&subscription-key={}&pins={}&path={}&bbox={}&zoom=12".format(subscriptionKey,encodedPins,path,str(minLon)+", "+str(minLat)+", "+str(maxLon)+", "+str(maxLat)))

poiRangeMap = await staticMapResponse.content.read()

display(Image(poiRangeMap))

Konum aralığını gösteren bir harita

En iyi doldurma istasyonunu bulun

İlk olarak, erişilebilir aralıktaki tüm olası ücretlendirme istasyonlarını öğrenmek istersiniz. Daha sonra, en az bir süre içinde bunlardan hangilerinin ulaşılabileceğini bilmeniz gerekir.

aşağıdaki betik Azure Haritalar matris yönlendirme apı'sini çağırır. Belirtilen araç konumunu, seyahat süresini ve her bir doldurma istasyonunun uzaklığını döndürür. Sonraki hücredeki betik, zaman açısından en yakın erişilebilir doldurma istasyonunu bulma yanıtını ayrıştırır.

En az sürede erişilebilecek en yakın erişilebilir doldurma istasyonunu bulmak için betiği aşağıdaki hücrede çalıştırın:

locationData = {
            "origins": {
              "type": "MultiPoint",
              "coordinates": [[currentLocation[1],currentLocation[0]]]
            },
            "destinations": {
              "type": "MultiPoint",
              "coordinates": reachableLocations
            }
         }

# Get the travel time and distance to each specified charging station.
searchPolyRes = await (await session.post(url = "https://atlas.microsoft.com/route/matrix/json?subscription-key={}&api-version=1.0&routeType=shortest&waitForResults=true".format(subscriptionKey), json = locationData)).json()

distances = []
for dist in range(len(reachableLocations)):
    distances.append(searchPolyRes["matrix"][0][dist]["response"]["routeSummary"]["travelTimeInSeconds"])

minDistLoc = []
minDistIndex = distances.index(min(distances))
minDistLoc.extend([reachableLocations[minDistIndex][1], reachableLocations[minDistIndex][0]])
closestChargeLoc = ",".join(str(i) for i in minDistLoc)

En yakın doldurma istasyonuyla olan rotayı hesapla

En yakın ücretlendirme istasyonunu buldığınıza göre, elektrik ale's geçerli konumundan ücretlendirme istasyonuna ayrıntılı rotayı istemek için yol yönlerini al API 'sini çağırabilirsiniz.

Doldurma istasyonunun yolunu almak ve yolu temsil eden bir geojson nesnesi oluşturmak için yanıtı ayrıştırmak üzere betiği aşağıdaki hücrede çalıştırın:

# Get the route from the electric vehicle's current location to the closest charging station. 
routeResponse = await (await session.get("https://atlas.microsoft.com/route/directions/json?subscription-key={}&api-version=1.0&query={}:{}".format(subscriptionKey, str(currentLocation[0])+","+str(currentLocation[1]), closestChargeLoc))).json()

route = []
for loc in range(len(routeResponse["routes"][0]["legs"][0]["points"])):
                location = list(routeResponse["routes"][0]["legs"][0]["points"][loc].values())
                location[0], location[1] = location[1], location[0]
                route.append(location)

routeData = {
         "type": "LineString",
         "coordinates": route
     }

Rotayı görselleştirin

rotayı görselleştirmenize yardımcı olmak için önce Azure Haritalar data service 'e bir coğrafi json nesnesi olarak yol verilerini karşıya yüklersiniz. bunu yapmak için Azure Haritalar Data Upload apı'sini kullanın. Ardından, işleme hizmetini çağırın, harita görüntüsü API 'Sini alın, rotayı haritada oluşturup görselleştirin.

Haritada işlenen yolun bir görüntüsünü almak için aşağıdaki betiği çalıştırın:

# Upload the route data to Azure Maps Data service .
routeUploadRequest = await session.post("https://atlas.microsoft.com/mapData?subscription-key={}&api-version=2.0&dataFormat=geojson".format(subscriptionKey), json = routeData)

udidRequestURI = routeUploadRequest.headers["Location"]+"&subscription-key={}".format(subscriptionKey)

while True:
    udidRequest = await (await session.get(udidRequestURI)).json()
    if 'udid' in udidRequest:
        break
    else:
        time.sleep(0.2)

udid = udidRequest["udid"]

destination = route[-1]

destination[1], destination[0] = destination[0], destination[1]

path = "lc0f6dd9|lw6||udid-{}".format(udid)
pins = "default|codb1818||{} {}|{} {}".format(str(currentLocation[1]),str(currentLocation[0]),destination[1],destination[0])


# Get boundaries for the bounding box.
minLat, maxLat = (float(destination[0]),currentLocation[0]) if float(destination[0])<currentLocation[0] else (currentLocation[0], float(destination[0]))
minLon, maxLon = (float(destination[1]),currentLocation[1]) if float(destination[1])<currentLocation[1] else (currentLocation[1], float(destination[1]))

# Buffer the bounding box by 10 percent to account for the pixel size of pins at the ends of the route.
lonBuffer = (maxLon-minLon)*0.1
minLon -= lonBuffer
maxLon += lonBuffer

latBuffer = (maxLat-minLat)*0.1
minLat -= latBuffer
maxLat += latBuffer

# Render the route on the map.
staticMapResponse = await session.get("https://atlas.microsoft.com/map/static/png?api-version=1.0&subscription-key={}&&path={}&pins={}&bbox={}&zoom=16".format(subscriptionKey,path,pins,str(minLon)+", "+str(minLat)+", "+str(maxLon)+", "+str(maxLat)))

staticMapImage = await staticMapResponse.content.read()

await session.close()
display(Image(staticMapImage))

Yolu gösteren bir harita

bu öğreticide, azure Haritalar REST apı 'lerini doğrudan çağırmayı ve Python kullanarak azure Haritalar verilerini görselleştirmeyi öğrendiniz.

bu öğreticide kullanılan Azure Haritalar apı 'lerini araştırmak için bkz.:

Kaynakları temizleme

Temizleme gerektiren kaynak yok.

Sonraki adımlar

Azure Notebooks hakkında daha fazla bilgi edinmek için bkz.

Azure Notebooks