HERE Map Content bindings

from here.platform import Platform
from here.geopandas_adapter import GeoPandasAdapter
from here.content.hmc2 import HMC
import pandas as pd
from here.platform.adapter import make_ref
from IPython.display import display, FileLink

platform = Platform()
hmc = HMC(platform, adapter=GeoPandasAdapter())


display(f"Catalog Id: {hmc.content.catalog_hrn} , Version:{hmc.content.version}")

def types_to_df(types):
    def to_record(kv):
        k, v = kv
        return {
            "Type": k,
            "Data Class": '.'.join([v.__module__, v.__qualname__]),
            "Index by partition": v.indexer.partition is not None,
            "Index by ID": v.indexer.identifier is not None,
            "Ref Types": ", ".join(v.indexer.refs.keys()) or None
        }
    return pd.DataFrame.from_records(map(to_record, types.items()), index="Type")

## Install HERE Map Widget for Jupyter. This is needed for using Here Maps  
#!pip install here-map-widget-for-jupyter

# Functions needed for using Here Maps
from ipyleaflet import GeoData
import here.geotiles.heretile as ht 
from ipyleaflet import Map
import geopandas as gpd
from shapely.geometry.polygon import Polygon
import os

# replace your API key here.
api_key = os.environ["LS_API_KEY"]

def plot_geometry(dataFrame, geo_column):
    geoDF = gpd.GeoDataFrame(dataFrame[dataFrame['location.geometry'] != None][[geo_column]].copy(), 
                             geometry=geo_column)
    center_point = geoDF[geo_column].centroid.head(1).values
    geoData = GeoData(geo_dataframe=geoDF, 
                    style={"strokeColor": "rgba(128,0,128,1)"},
                    hover_style={"strokeColor": "rgba(255,0,0,1)"},
                    name='geometry_layer')
    m = Map(
        api_key=api_key,
        center=[center_point.y[0], center_point.x[0]],
        zoom=12,
    )

    m.add_layer(geoData)
    return m



def plot_here_tiles(tile_ids):
    tiles = [Polygon(ht.get_boundary_ring(t)) for t in tile_ids]
    tiles_df = pd.DataFrame(tiles, columns=["geometry"])
    geoDF = gpd.GeoDataFrame(tiles_df, geometry='geometry')
    center_point = geoDF['geometry'].centroid.head(1).values
    geoData = GeoData(geo_dataframe=geoDF, style={"strokeColor": "rgba(128,0,128,1)"},
                      hover_style={"strokeColor": "rgba(255,0,0,1)"},
                      name='here_tiles')
    m = Map(
        api_key=api_key,
        center=[center_point.y[0], center_point.x[0]],
        zoom=12,
    )

    m.add_layer(geoData)
    return m 

def plot_multiple_geometry(geometries):
    geoData_1 = GeoData(geo_dataframe=geometries['Nodes'], 
                    style={"strokeColor": "rgba(128,0,128,1)"},
                    hover_style={"strokeColor": "rgba(255,0,0,1)"},
                    name='geometry_layer_1')
    geoData_2 = GeoData(geo_dataframe=geometries['Segments'], 
                    style={"strokeColor": "rgba(128,0,128,1)"},
                    hover_style={"strokeColor": "rgba(255,0,0,1)"},
                    name='geometry_layer_2')
    center_point = (geometries['Nodes'].set_crs(epsg=4328, allow_override=True)).centroid.head(1).values
    m = Map(
        api_key=api_key,
        center=[center_point.y[0], center_point.x[0]],
        zoom=12,
    )

    m.add_layer(geoData_1)
    m.add_layer(geoData_2)
    return m

tiles = ['23671200-25332448-25332461', '1469256839-1469256831']

street_names = hmc.street_names
types_to_df(street_names.object_types())

df = street_names.get(tiles, 'street')
df.head(2)

df = street_names.get(tiles, 'context')
df.head(2)

df = street_names.get(tiles, 'street_section')
df.head(2)

tiles = [23618502]

traffic_patterns = hmc.traffic_patterns
types_to_df(traffic_patterns.object_types())

traffic_pattern = traffic_patterns.get(tiles,"traffic_pattern")
traffic_pattern.head(2)

holiday_pattern = traffic_patterns.get(tiles,"holiday_pattern")
holiday_pattern.head(2)

### Construct a new Reference by giving partition and identifier.
traffic_pattern_ref = make_ref(23618502,"here:cm:segment:76770511")

traffic_pattern_attributes = traffic_patterns.get_referencing(
        23618502, "traffic_pattern", "first_segment", 
)
traffic_pattern_attributes.head(2)

holiday_pattern_attributes = traffic_patterns.get_referencing(
        23618502, "holiday_pattern", "first_segment", 
)
holiday_pattern_attributes.head(2)

tiles = [18011924]
sign_text = hmc.sign_text
types_to_df(sign_text.object_types())

display(sign_text.ref_types())

df = sign_text.get(tiles, "sign_attribute")
df.head(2)

df = sign_text.get_referencing(tiles, "sign_attribute", "segment")
df.head(2)

df = sign_text.get_referencing(tiles, "sign_attribute", "first_segment")
df.head(2)

admin_places = hmc.admin_places

types_to_df(admin_places.object_types())

admin_tiles = ["20000001", "20000001-20000002-20030132"]

df = admin_places.get(admin_tiles, "place")
df.head(2)

df = admin_places.get(admin_tiles, "context")
df.head(2)

admin_locations = hmc.admin_locations
types_to_df(admin_locations.object_types())

df = admin_locations.get(partition="21000001", object_type="location") 
df.head(2)

admin_place_profiles = hmc.admin_place_profiles

df = admin_place_profiles.get(partition = "21000001", object_type="admin_place_profile_attributes")
df.head(2)

### Construct a new Reference by giving partition and identifier.
ref = make_ref("21000001", "here:cm:namedplace:21000002")

admin_place_profiles.get_referencing(
        partition = "21000001", object_type="admin_place_profile_attributes", ref_type="place", referenced_obj=ref
)

admin_index = hmc.admin_index

types_to_df(admin_index.object_types())

country_partitions = ["FIN", "HND", "IRL"]
country_tiles = admin_index.get(country_partitions, "country")
country_tiles

## You can always use the `explode` function to convert a list in multiple rows.
country_tiles.explode("tile_id")

plot_here_tiles(country_tiles.loc["FIN"]["tile_id"])

plot_here_tiles(country_tiles.loc["IRL"]["tile_id"])

df = admin_index.get_referencing(country_partitions, "location", "location")
df.head(2)

environmental_zones = hmc.environmental_zones
types_to_df(environmental_zones.object_types())

environmental_zones.ref_types()

types_to_df(environmental_zones.object_types())

env_zones = environmental_zones.get("all", "zone")
env_zones.head(2)

### Construct a new Reference by giving partition and identifier.
location_ref = make_ref("23600686", "here:cm:carto-loc:1661293691")

env_zones = environmental_zones.get_referencing("all", "zone", "location", location_ref)
env_zones

topology_geometry = hmc.topology_geometry
types_to_df(topology_geometry.object_types())

topology_geometry.ref_types()

types_to_df(topology_geometry.object_types())

tiles =[19318110]

nodes = topology_geometry.get(tiles, "node")
nodes.head(2)

segments = topology_geometry.get(tiles, "segment")
segments.head(2)

geometries={"Nodes": nodes, "Segments": segments}
plot_multiple_geometry(geometries)

topology_attributes = hmc.topology_attributes

types_to_df(topology_attributes.object_types())

topology_attributes.ref_types()

types_to_df(topology_attributes.object_types())

tiles = [19318110]
df = topology_attributes.get(tiles, "functional_class")
df.head(2)

df = topology_attributes.get_referencing(tiles, "functional_class", "segment")
df.head(2)

df = topology_attributes.get_referencing(tiles, "iso_country_code", "segment")
df.head(2)

df = topology_attributes.get(tiles, "speed_limit")
df.head(2)

df = topology_attributes.get(tiles, "traffic_message_channel_code")
df.head(2)

df = topology_attributes.get(tiles, "restricted_driving_manoeuvre")
df.head(2)

df = topology_attributes.get(tiles, "travel_direction")
df.head(2)

df = topology_attributes.get([18403672], "environmental_zone_condition")
df.head(2)

df = topology_attributes.get_referencing(tiles, "restricted_driving_manoeuvre", "first_segment")
df.head(2)

df = topology_attributes.get(tiles, "traffic_signal")
df.head(2)

df = topology_attributes.get(tiles, "traffic_sign")
df.head(2)

df = topology_attributes.get_referencing(tiles, "traffic_sign", "first_segment")
df.head(2)

df = topology_attributes.get(tiles, "railway_crossing")
df.head(2)

df = topology_attributes.get_referencing(tiles, "railway_crossing", "segment")
df.head(2)

bicycle_attributes = hmc.bicycle_attributes
types_to_df(bicycle_attributes.object_types())

bicycle_attributes.ref_types()

types_to_df(bicycle_attributes.object_types())

tiles = [19318110]
df = bicycle_attributes.get_referencing(tiles, "bicycle_path", "segment")
df.head(2)

df = bicycle_attributes.get_referencing(tiles, "dedicated_bicycle_path", "segment")
df.head(2)

places_metadata = hmc.places_metadata
types_to_df(places_metadata.object_types())

places_metadata.get("all", "category_system")

df = places_metadata.get("all", "category")
df.head(2)

building_metadata = hmc.building_metadata
types_to_df(building_metadata.object_types())

building_metadata.get("all", "category_system")

df = building_metadata.get("all", "category")
df.head(2)

cartography_metadata = hmc.cartography_metadata
types_to_df(places_metadata.object_types())

cartography_metadata.get("all", "category_system")

df = cartography_metadata.get("all", "category")
df.head(2)

here_places = hmc.here_places
types_to_df(here_places.object_types())

df = here_places.get("19319399", "external_identifier")
df.head(2)

segment_admin_boundary = hmc.segment_admin_boundary
types_to_df(segment_admin_boundary.object_types())

df = segment_admin_boundary.get(17302684, "segment_admin_boundary")
df.head(2)

df = segment_admin_boundary.get(17302684, "segment_admin_boundary")
df.head(2)

### Construct a new Reference by giving partition and identifier.
segment_ref = make_ref("17302684", "here:cm:segment:499005300")

segment_admin_boundary_atts = segment_admin_boundary.get_referencing("17302684", "segment_admin_boundary", 
                                                       "segment", segment_ref)
segment_admin_boundary_atts.head(2)

### Construct a new Reference by giving partition and identifier.
place_ref = make_ref("23060936", "here:cm:namedplace:23060936")

place_admin_boundary_atts = segment_admin_boundary.get_referencing("17302684", "segment_admin_boundary", 
                                                       "place", place_ref)
place_admin_boundary_atts

ezc = hmc.environmental_zone_conditions
display(ezc)

types_to_df(ezc.object_types())

data_ezc = ezc.get(partition = 23618402, object_type = 'segment_to_environmental_zone')
data_ezc.head(2)

data_ezc.iloc[0]['zone.location_ref']

### Construct a new Reference by giving partition and identifier.
ref = make_ref(23618402, "here:cm:segment:92642459")

data = ezc.get_referencing(partition = 23618402, 
                           object_type = 'segment_to_environmental_zone', 
                           ref_type='segment',
                          referenced_obj=ref)
data

### Construct a new Reference by giving partition and identifier.
ref = make_ref(23618400, "here:cm:carto-loc:1415962522")

data = ezc.get_referencing(partition = 23618402, 
                           object_type = 'segment_to_environmental_zone', 
                           ref_type='location',
                          referenced_obj=ref)
data.head(2)

data_ezc.iloc[0]

segment_street_names = hmc.segment_street_names

segment_street = segment_street_names.get(["20371958","17434043"], "street_section")
segment_street.head(2)

segment_street = segment_street_names.get(["20371958","17434043"], "address_range")
segment_street.head(2)

adas_attributes = hmc.adas_attributes
partition_id = ['18508594','18608750']
types_to_df(adas_attributes.object_types())

curvature_heading_attribute = adas_attributes.get(partition_id, 'curvature_heading')
curvature_heading_attribute.head(2)

slope_attribute = adas_attributes.get(partition_id, 'slope')
slope_attribute.head(2)

elevation_attribute = adas_attributes.get(partition_id, 'elevation')
elevation_attribute.head(2)

link_accuracy_attribute = adas_attributes.get(partition_id, 'link_accuracy')
link_accuracy_attribute.head(2)

built_up_area_road_attribute = adas_attributes.get(partition_id, 'built_up_area_road')
built_up_area_road_attribute.head(2)

composite_road_attributes = hmc.composite_road_attributes
partition_id = ['23195507','23462802','23462789']
types_to_df(composite_road_attributes.object_types())

complex_object_attribute = composite_road_attributes.get(partition_id, 'complex_object_attribute')
complex_object_attribute

complex_intersection_attribute = composite_road_attributes.get(partition_id, 'complex_intersection_attribute')
complex_intersection_attribute

complex_road_attribute = composite_road_attributes.get(partition_id,'complex_road_attribute')
complex_road_attribute

url = os.path.abspath("")
notebook_name = 'hmc.ipynb'
notebook = FileLink(f"{url}/{notebook_name}", result_html_prefix="Click here to download: ")
display(notebook)