高レベルの API

ロケーション ライブラリの高レベルの API は 、さまざまな種類のパス・マッチャをインスタンス化する方法と 、以下のインターフェイスを使用してアルゴリズムを直接実装するためのファクトリメソッドを提供します。

  • ProximitySearch 座標からトポロジーセグメント（頂点）を検索します。
    ProximitySearches
  • DirectedGraph 効率的なデータ構造でトポロジをナビゲートします。
    グラフ
  • PropertyMap 道路、ナビゲーション、高度なナビゲーション、および ADAS 属性にアクセスします。
    PropertyMaps

設定中です

ライブラリは 、必要に応じて、アルゴリズムが必要とする Optimized Map for Location Library のマップタイルをダウンロードしてキャッシュします。

次のコードスニペットは、ロケーション ライブラリファクトリメソッドおよび optimizedMapカタログを さまざまな目的で使用する方法を示しています。

次のインポートはすべてのスニペットで共有されます。

Scala
Java
import com.here.platform.location.dataloader.core.Catalog
import com.here.platform.location.dataloader.core.caching.CacheManager
import com.here.platform.location.inmemory.graph.Vertex
import com.here.platform.location.dataloader.core.Catalog;
import com.here.platform.location.dataloader.core.caching.CacheManager;

次の例では optimizedMap 、カタログが cacheManager 初期化されていることを前提としています。

Scala
Java
import com.here.platform.location.dataloader.standalone.StandaloneCatalogFactory

val cacheManager = CacheManager.withLruCache()

val catalogFactory = new StandaloneCatalogFactory

try {
  val optimizedMap = catalogFactory.create(optimizedMapHRN, optimizedMapVersion)

  // your code that uses the Optimized Map catalog
  println(
    s"optimized map catalog initialized: ${optimizedMap.hrn}, version ${optimizedMap.version}")
} finally {
  catalogFactory.terminate()
}
import com.here.platform.location.dataloader.standalone.StandaloneCatalogFactory;
final CacheManager cacheManager = CacheManager.withLruCache();

final StandaloneCatalogFactory catalogFactory = new StandaloneCatalogFactory();

try {
  final Catalog optimizedMap = catalogFactory.create(optimizedMapHRN, optimizedMapVersion);

  // your code that uses the Optimized Map catalog
  System.out.format(
      "optimized map catalog initialized: %s, version %d",
      optimizedMap.hrn(), optimizedMap.version());

} finally {
  catalogFactory.terminate();
}

カタログおよびCacheManager の初期化方法の詳細については、「最適化されたマップ統合モジュール」および「データローダー」の項を参照してください。

パス \'83\'7d ネージャを作成します

記録された地理座標のシーケンスを道路トポロジグラフのパスに解決するには、パスマッチャーを使用します。 パスマッチャーは、各入力ポイントに最も近い可能性が高い道路上の位置、およびポイント間の最も可能性の高い接続（遷移）についての情報を返します。

パスの一致
図 1. パスの一致

注

プローブデータのデンスおよびスパーストレース

記録された地理座標のシーケンスは 、トレースまたはプローブトレースと呼ばれます。 パス・ \'83\'7d ッシャーは、デンス・トレースとスパース・トレースを区別します。 密なトレースは、地図内の道路セグメントの長さと比較して短い連続するプローブ間の距離によって特徴付けられます。 通常、 1 ～ 5 秒ごとに収集されたプローブは密度が高いと見なされます。

PathMatchers 工場を使用するには、次のインポートを含めます。

Scala
Java
import com.here.platform.location.core.geospatial.GeoCoordinate
import com.here.platform.location.core.mapmatching._
import com.here.platform.location.integration.optimizedmap.mapmatching.PathMatchers
import com.here.platform.location.core.geospatial.GeoCoordinate;
import com.here.platform.location.core.mapmatching.NoTransition;
import com.here.platform.location.core.mapmatching.javadsl.PathMatcher;
import com.here.platform.location.inmemory.graph.Vertex;
import com.here.platform.location.integration.optimizedmap.mapmatching.javadsl.PathMatchers;

パス \'83\'7d ネージャを作成するには、次のようなさまざまな方法を使用できます。

  • は unrestrictedPathMatcher 、走行制限から独立した結果を生成するマップマッチャーを作成し、高密度 GPS トレース（ 5 秒ごとに少なくとも 1 つのポイント）に適しています。

    Scala
    Java
    val unrestrictedPathMatcher: PathMatcher[GeoCoordinate, Vertex, NoTransition] =
  PathMatchers.unrestrictedPathMatcher(optimizedMap, cacheManager)
    final PathMatcher<GeoCoordinate, Vertex, NoTransition> unrestrictedPathMatcher =
    PathMatchers.unrestrictedPathMatcher(optimizedMap, cacheManager);

    は unrestrictedPathMatcher 、高密度プローブおよびすべての車両タイプについて、おそらく最もドライブされている経路に一致させる最も効果的な方法です。 運転によってこの経路をたどることは必ずしもできませんが、結果を使用して運転エラーについての警告を得ることができます。

    は unrestrictedPathMatcher 、連続するポイントが直接接続されたトポロジセグメントにない場合、切断を引き起こすことがあります。これは、遷移の計算にルーティングアルゴリズムを使用しないためです。

    unrestrictedPathMatcherWithTransitions この変数を使用すると、単純な最短パスアルゴリズムで点を再結合するための作業がより大きくなります。

  • は carPathMatcherWithTransitions 、ほとんどの車の運転制限を考慮しています。また、車およびスパースデータ用に特別に設定されたパスマッチャーですが、高密度データにも対応します。 たとえば、このパスマッチャーは roadAccess 、プロパティに従って車によってアクセス可能な頂点にのみ入力ポイントを照合します。

    carPathMatcherWithTransitionsは 、スパースデータのunrestrictedPathMatcherWithTransitions場合よりも適切に動作します。これは、道路アクセスおよび曲がる際の制約を考慮した最短パスアルゴリズムを使用して、ポイント間をルーティングするためです。 状況によっては、連続するポイントの距離が遠すぎると（オンロード距離が約 30 km を超える）、到達不能と見なさ Unknownれ、いずれかのポイントをマッチングできます。

    Scala
    Java
    val carPathMatcherWithTransitions: PathMatcher[GeoCoordinate, Vertex, Seq[Vertex]] =
  PathMatchers.carPathMatcherWithTransitions(optimizedMap, cacheManager)
    final PathMatcher<GeoCoordinate, Vertex, List<Vertex>> carPathMatcherWithTransitions =
    PathMatchers.carPathMatcherWithTransitions(optimizedMap, cacheManager);

    carPathMatcher この変数は似ていますが、高密度データにのみ適しています。高密度データでは、連続するプローブ間の距離がマップ内の頂点の長さと比較して短くなります。

    Scala
    Java
    val carPathMatcher: PathMatcher[GeoCoordinate, Vertex, NoTransition] =
  PathMatchers.carPathMatcher(optimizedMap, cacheManager)
    final PathMatcher<GeoCoordinate, Vertex, NoTransition> carPathMatcher =
    PathMatchers.carPathMatcher(optimizedMap, cacheManager);

注

パス・マッチャーの出力について詳しく は、 API ガイドを参照してください。

  • 高度なシナリオの場合 は、 HMPathMatcher を直接構築して、目的のパスマッチャーの依存関係を指定できます。

    Scala
    Java
    import com.here.platform.location.core.geospatial.{
  ElementProjection,
  GeoCoordinate,
  GreatCircleDistanceCalculator
}
import com.here.platform.location.core.mapmatching._
import com.here.platform.location.inmemory.geospatial.TileId
import com.here.platform.location.inmemory.graph.VertexIndex
import com.here.platform.location.integration.optimizedmap.graph.{
  Graphs,
  PropertyMaps,
  RoadAccess
}
import com.here.platform.location.integration.optimizedmap.mapmatching.{
  EmissionProbabilityStrategies,
  PathMatchers,
  TransitionProbabilityStrategies
}

val origin = GeoCoordinate(0, 0)
val originCandidate =
  IndexedSeq(OnRoad(ElementProjection(Vertex(TileId(1), VertexIndex(0)), origin, 0, 0.0)))

class CustomCandidateGenerator extends CandidateGenerator[GeoCoordinate, Vertex] {
  override def generate(observation: GeoCoordinate): IndexedSeq[MatchResult[Vertex]] =
    if (observation == origin) originCandidate else IndexedSeq.empty
}

val customPathMatcher: PathMatcher[GeoCoordinate, Vertex, Seq[Vertex]] =
  PathMatchers.newHMMPathMatcher(
    new CustomCandidateGenerator,
    EmissionProbabilityStrategies.usingDistance,
    TransitionProbabilityStrategies.directDistance(
      Graphs.from(optimizedMap, cacheManager),
      PropertyMaps.length(optimizedMap, cacheManager),
      PropertyMaps.roadAccess(optimizedMap, cacheManager, RoadAccess.Automobile),
      GreatCircleDistanceCalculator
    )
  )
    import com.here.platform.location.core.geospatial.ElementProjection;
import com.here.platform.location.core.geospatial.GeoCoordinate;
import com.here.platform.location.core.geospatial.GreatCircleDistanceCalculator;
import com.here.platform.location.core.mapmatching.MatchResult;
import com.here.platform.location.core.mapmatching.OnRoad;
import com.here.platform.location.core.mapmatching.javadsl.CandidateGenerator;
import com.here.platform.location.core.mapmatching.javadsl.PathMatcher;
import com.here.platform.location.inmemory.graph.Vertex;
import com.here.platform.location.integration.optimizedmap.graph.RoadAccess;
import com.here.platform.location.integration.optimizedmap.graph.javadsl.Graphs;
import com.here.platform.location.integration.optimizedmap.graph.javadsl.PropertyMaps;
import com.here.platform.location.integration.optimizedmap.mapmatching.javadsl.EmissionProbabilityStrategies;
import com.here.platform.location.integration.optimizedmap.mapmatching.javadsl.PathMatchers;
import com.here.platform.location.integration.optimizedmap.mapmatching.javadsl.TransitionProbabilityStrategies;
final GeoCoordinate origin = new GeoCoordinate(0, 0);
final List<MatchResult<Vertex>> originCandidate = new ArrayList<>();
originCandidate.add(new OnRoad<>(new ElementProjection<>(new Vertex(1, 0), origin, 0, 0.0)));

final CandidateGenerator<GeoCoordinate, Vertex> customCandidateGenerator =
    observation -> {
      if (observation.equals(origin)) return originCandidate;
      else return new ArrayList<>();
    };

final PathMatcher<GeoCoordinate, Vertex, List<Vertex>> customPathMatcher =
    PathMatchers.newHMMPathMatcher(
        customCandidateGenerator,
        EmissionProbabilityStrategies.usingDistance(),
        TransitionProbabilityStrategies.distanceWithTransitions(
            Graphs.from(optimizedMap, cacheManager),
            PropertyMaps.geometry(optimizedMap, cacheManager),
            PropertyMaps.length(optimizedMap, cacheManager),
            PropertyMaps.roadAccess(optimizedMap, cacheManager, RoadAccess.Automobile),
            GreatCircleDistanceCalculator.getInstance()));

現実の場所をルーティンググラフの頂点に関連付けるため に、 ProximitySearch では、マップ上の特定のポイントから一定の距離内にある頂点を検索できます。

Scala
Java
// Implicit GeoCoordinateOperations for com.here.schema.geometry.v2.geometry.Point
import com.here.platform.location.core.geospatial.{ElementProjection, ProximitySearch}
import com.here.platform.location.integration.heremapcontent.geospatial.Implicits._
import com.here.platform.location.integration.optimizedmap.geospatial.ProximitySearches

val brandenburgerTor = com.here.schema.geometry.v2.geometry.Point(52.516268, 13.377700)
val radiusInMeters = 1000.0
val proximitySearch: ProximitySearch[Vertex] =
  ProximitySearches.vertices(optimizedMap, cacheManager)

val vertices: Iterable[ElementProjection[Vertex]] =
  proximitySearch.search(brandenburgerTor, radiusInMeters)

val closestFewVertices = vertices.toSeq
  .sortBy(_.distanceInMeters)
  .take(5)
  .map(_.element)

println(s"The closest vertices within $radiusInMeters meters of")
println(brandenburgerTor)
println("are:")
closestFewVertices.foreach(println)
import com.here.platform.location.core.geospatial.ElementProjection;
import com.here.platform.location.core.geospatial.GeoCoordinate;
import com.here.platform.location.core.geospatial.javadsl.GeoCoordinateAdapter;
import com.here.platform.location.core.geospatial.javadsl.ProximitySearch;
import com.here.platform.location.inmemory.graph.Vertex;
import com.here.platform.location.integration.optimizedmap.geospatial.javadsl.ProximitySearches;
import com.here.schema.geometry.v2.GeometryOuterClass.Point;
final GeoCoordinateAdapter<Point> hereMapContentPointAdapter =
    new GeoCoordinateAdapter<Point>() {
      @Override
      public double getLatitude(final Point p) {
        return p.getLatitude();
      }

      @Override
      public double getLongitude(final Point p) {
        return p.getLongitude();
      }
    };

final Point brandenburgerTor =
    Point.newBuilder().setLatitude(52.516268).setLongitude(13.377700).build();

final double radiusInMeters = 1000.0;

final ProximitySearch<Point, Vertex> proximitySearch =
    ProximitySearches.vertices(optimizedMap, cacheManager, hereMapContentPointAdapter);

final Iterable<ElementProjection<Vertex>> vertices =
    proximitySearch.search(brandenburgerTor, radiusInMeters);

final List<ElementProjection<Vertex>> closestFewVertices =
    StreamSupport.stream(vertices.spliterator(), false)
        .sorted(Comparator.comparingDouble(ElementProjection::distanceInMeters))
        .limit(5)
        .collect(Collectors.toList());

System.out.format("The closest vertices within %f meters of %n", radiusInMeters);
System.out.format(
    "(%f, %f)%n", brandenburgerTor.getLatitude(), brandenburgerTor.getLongitude());
System.out.println("are:");
closestFewVertices.forEach(v -> System.out.format("%s%n", v));

最も近いポイントを取得する方法は、マップの一致を実行するための簡単ではありますが、高速な方法です。 次のコード スニペットは、最も近い結果に関する情報を取得する方法を示しています。

Scala
Java
val closest = vertices.toSeq.minBy(_.distanceInMeters)

println(
  s"The closest point is ${closest.nearest} " +
    s"on vertex ${closest.element} " +
    s"${closest.fraction * 100}% along its length. " +
    s"It is ${closest.distanceInMeters}m away from $brandenburgerTor.")
final ElementProjection<Vertex> closest =
    StreamSupport.stream(vertices.spliterator(), false)
        .min(Comparator.comparingDouble(ElementProjection::distanceInMeters))
        .get();

System.out.format(
    "The closest point is %s on vertex %s %f%% along its length. ",
    closest.nearest(), closest.element(), closest.fraction() * 100);
System.out.format("It is %fm away from %s.%n", closest.distanceInMeters(), brandenburgerTor);

Java および Scala 開発者のための HERE Workspace の例 には、 ProximitySearch を使用 してマップマッチングを実行するPointMatcherExampleというサンプルが含まれています。 この例は、location/scala/standaloneにあり ます（ Java で記述されたバージョンの場合location/java/standalone）。

注

より正確なマップマッチングを行う には、本格的なパスマッチャーを使用します。

頂点ごとに複数の結果があります

頂点のジオメトリは必ずしも線形ではないので 、場合によってはジオメトリの各セグメント ( 連続するポイントのペア間のセグメント ) について 1 つの ElementProjection を取得することがあります。 このような場合、次のコード スニペットは、形状の直線文字列のセグメントごとに 1 つずつ、同じ頂点の複数の投影を返します。

Scala
Java
import com.here.platform.location.core.geospatial.GeoCoordinate

val hairpinTurn = GeoCoordinate(46.55091, 11.81564)
val geometrySegmentProximitySearch: ProximitySearch[Vertex] =
  ProximitySearches.vertexGeometrySegments(optimizedMap, cacheManager)

val closestProjections: Iterable[ElementProjection[Vertex]] =
  geometrySegmentProximitySearch.search(hairpinTurn, 50 /* meters */ )

println(s"The projections on the geometry segments within 50 meters of")
println(hairpinTurn)
println("are:")
closestProjections.foreach(println)
final GeoCoordinate hairpinTurn = new GeoCoordinate(46.55091, 11.81564);
final ProximitySearch<GeoCoordinate, Vertex> geometrySegmentProximitySearch =
    ProximitySearches.vertexGeometrySegments(optimizedMap, cacheManager);

final Iterable<ElementProjection<Vertex>> closestProjections =
    geometrySegmentProximitySearch.search(hairpinTurn, 50 /* meters */);

System.out.format(
    "The projections on the geometry segments within 50 meters of %s %n", hairpinTurn);
System.out.println("are:");
closestProjections.forEach(System.out::println);

注

次の画像は、からの結果を示し ProximitySearches.verticesています。 検索では、各頂点に最も近い点のみが返されます。 頂点ごとに 1 つの結果

ProximitySearches.vertexGeometrySegments バリアントを使用すると、頂点ごとに複数の投影を取得できます。 形状セグメントごとに 1 つの結果

グラフ

グラフの抽象化を使用して、 HERE Map Content の道路トポロジおよびジオメトリをナビゲートできます。 グラフの各頂点は、ある方向の道路（トポロジセグメント）を表し 、各エッジは、「ルーティンググラフ」セクションで説明されているように、道路間の物理的な接続を表します。

次のコード スニペットでは 、 Optimized Map for Location Library のルーティンググラフレイヤーからデータを遅延的にロードするグラフを作成する方法を示します。

Scala
Java
import com.here.platform.location.core.graph.DirectedGraph
import com.here.platform.location.inmemory.graph.{Edge, Vertex}
import com.here.platform.location.integration.optimizedmap.graph.Graphs

val graph: DirectedGraph[Vertex, Edge] = Graphs.from(optimizedMap, cacheManager)
import com.here.platform.location.core.graph.javadsl.DirectedGraph;
import com.here.platform.location.inmemory.graph.Edge;
import com.here.platform.location.inmemory.graph.Vertex;
import com.here.platform.location.integration.optimizedmap.graph.javadsl.Graphs;
final DirectedGraph<Vertex, Edge> graph = Graphs.from(optimizedMap, cacheManager);

注

道路トポロジセグメントには、物理的な進行方向ごとに 1 つずつ、常に 2 つの頂点が関連付けられています。 PropertyMaps を使用して属性を収集し、決定を下すことが PropertyMaps.roadAccess できます。たとえば、以下で説明するように、さまざまな輸送モードの進行方向に関する情報を取得できます。

次のように、グラフの頂点の出力エッジとそのターゲット頂点を取得できます。

Scala
Java
val outDegree = graph.outDegree(vertex)
val neighbors: Iterable[Vertex] =
  graph.outEdgeIterator(vertex).map(graph.target).toIterable

println(s"The $vertex has $outDegree outgoing edges to the following vertices:")
println(neighbors)
final int outDegree = graph.getOutDegree(vertex);
final List<Vertex> neighbors = new ArrayList<>(outDegree);
graph.getOutEdgeIterator(vertex).forEachRemaining(edge -> neighbors.add(graph.getTarget(edge)));

System.out.format(
    "The %s has %d outgoing edges to the following vertices:%n", vertex, outDegree);

neighbors.forEach(v -> System.out.format("%s%n", v));

次の例は、道路トポロジを後方にナビゲートするためのグラフを作成する方法を示しています。

Scala
Java
val reversedGraph: DirectedGraph[Vertex, Edge] = Graphs.reversedFrom(optimizedMap, cacheManager)
final DirectedGraph<Vertex, Edge> reversedGraph =
    Graphs.reversedFrom(optimizedMap, cacheManager);

反転したグラフの詳細 については、 Graphs.reversedFrom メソッドのドキュメントを参照してください。

プロパティマップ

Scala
Java
import com.here.platform.location.core.graph.{
  PropertyMap,
  RangeBasedProperty,
  RangeBasedPropertyMap
}
import com.here.platform.location.integration.optimizedmap.graph.PropertyMaps
import com.here.platform.location.core.graph.javadsl.PropertyMap;
import com.here.platform.location.integration.optimizedmap.graph.javadsl.PropertyMaps;

ロケーション ライブラリでは、いくつかの使用例のプロパティマップを提供しています。

  • HERE Map Content 参照と Optimized Map for Location Library の頂点を変換します

    Scala
    Java
    import com.here.platform.location.integration.optimizedmap.geospatial.HereMapContentReference

val backwardMap: PropertyMap[Vertex, HereMapContentReference] =
  PropertyMaps.vertexToHereMapContentReference(optimizedMap, cacheManager)

val reference: HereMapContentReference = backwardMap(vertex)

val forwardMap: PropertyMap[HereMapContentReference, Vertex] =
  PropertyMaps.hereMapContentReferenceToVertex(optimizedMap, cacheManager)

assert(forwardMap(reference) == vertex)
    import com.here.platform.location.inmemory.graph.Vertex;
import com.here.platform.location.integration.optimizedmap.geospatial.HereMapContentReference;
final PropertyMap<Vertex, HereMapContentReference> backwardMap =
    PropertyMaps.vertexToHereMapContentReference(optimizedMap, cacheManager);

final HereMapContentReference reference = backwardMap.get(vertex);

final PropertyMap<HereMapContentReference, Vertex> forwardMap =
    PropertyMaps.hereMapContentReferenceToVertex(optimizedMap, cacheManager);

assert forwardMap.get(reference) == vertex;

  • 頂点に関連付けられている形状を取得します

    Scala
    Java
    import com.here.platform.location.inmemory.geospatial.PackedLineString

val geometryMap: PropertyMap[Vertex, PackedLineString] =
  PropertyMaps.geometry(optimizedMap, cacheManager)

val geometry: PackedLineString = geometryMap(vertex)
    import com.here.platform.location.core.geospatial.GeoCoordinate;
import com.here.platform.location.core.geospatial.javadsl.LineStringHolder;
import com.here.platform.location.core.graph.javadsl.PropertyMap;
import com.here.platform.location.inmemory.graph.Vertex;
import com.here.platform.location.integration.optimizedmap.graph.javadsl.PropertyMaps;

import java.util.List;
final PropertyMap<Vertex, LineStringHolder<GeoCoordinate>> geometryMap =
    PropertyMaps.geometry(optimizedMap, cacheManager);

final List<GeoCoordinate> geometry = geometryMap.get(vertex).getPoints();

  • 頂点の長さを取得します

    Scala
    Java
    val lengthMap: PropertyMap[Vertex, Double] =
  PropertyMaps.length(optimizedMap, cacheManager)

val length: Double = lengthMap(vertex)
    final PropertyMap<Vertex, Double> lengthMap = PropertyMaps.length(optimizedMap, cacheManager);

final double length = lengthMap.get(vertex);

  • 頂点上の位置が特定の車両タイプにアクセスできるかどうかを確認します

    Scala
    Java
    import com.here.platform.location.core.graph.RangeBasedProperty
import com.here.platform.location.integration.optimizedmap.graph.RoadAccess

val carAccessMap: RangeBasedPropertyMap[Vertex, Boolean] =
  PropertyMaps.roadAccess(optimizedMap, cacheManager, RoadAccess.Automobile)

val isAccessibleByCars: Option[RangeBasedProperty[Boolean]] = carAccessMap(vertex, offset = 0.5)
    import com.here.platform.location.core.graph.javadsl.RangeBasedProperty;
import com.here.platform.location.core.graph.javadsl.RangeBasedPropertyMap;
import com.here.platform.location.inmemory.graph.Vertex;
import com.here.platform.location.integration.optimizedmap.graph.RoadAccess;
import com.here.platform.location.integration.optimizedmap.graph.javadsl.PropertyMaps;

import java.util.Optional;
final RangeBasedPropertyMap<Vertex, Boolean> carAccessMap =
    PropertyMaps.roadAccess(optimizedMap, cacheManager, RoadAccess.Automobile);

final double offset = 0.5;
final Optional<RangeBasedProperty<Boolean>> isAccessibleByCars =
    carAccessMap.get(vertex, offset);

  • 通常、頂点を通過するトラフィックの速度を取得します（フリーフロー速度）

    Scala
    Java
    val freeFlowSpeedMap: RangeBasedPropertyMap[Vertex, Int] =
  PropertyMaps.freeFlowSpeed(optimizedMap, cacheManager)

val minimumFreeFlowSpeedKmh: Int = freeFlowSpeedMap(vertex).map(_.value).min
    import com.here.platform.location.core.graph.javadsl.RangeBasedProperty;
import com.here.platform.location.core.graph.javadsl.RangeBasedPropertyMap;
import com.here.platform.location.inmemory.graph.Vertex;
import com.here.platform.location.integration.optimizedmap.graph.javadsl.PropertyMaps;

import java.util.Collections;
import java.util.Comparator;
final RangeBasedPropertyMap<Vertex, Integer> freeFlowSpeedMap =
    PropertyMaps.freeFlowSpeed(optimizedMap, cacheManager);

final int minimumFreeFlowSpeedKmh =
    Collections.min(
            freeFlowSpeedMap.get(vertex), Comparator.comparing(RangeBasedProperty::value))
        .value();

  • 特定の車両タイプについて、特定の端部で示されている回転を制限するかどうかを指定します

    Scala
    Java
    import com.here.platform.location.inmemory.graph.Edge
import com.here.platform.location.integration.optimizedmap.graph.AccessRestriction

val carTurnRestrictionsMap: PropertyMap[Edge, Boolean] =
  PropertyMaps.turnRestrictions(optimizedMap, cacheManager, AccessRestriction.Automobile)

val isRestrictedForCars: Boolean = carTurnRestrictionsMap(edge)
    import com.here.platform.location.compilation.heremapcontent.javadsl.AttributeAccessor;
import com.here.platform.location.compilation.heremapcontent.javadsl.AttributeAccessors;
import com.here.platform.location.core.graph.javadsl.RangeBasedProperty;
import com.here.platform.location.core.graph.javadsl.RangeBasedPropertyMap;
import com.here.platform.location.inmemory.graph.Vertex;
import com.here.platform.location.integration.optimizedmap.graph.javadsl.PropertyMaps;
import com.here.schema.rib.v2.common_attributes.SpeedLimitAttribute;
import com.here.schema.rib.v2.navigation_attributes_partition.NavigationAttributesPartition;

import java.util.List;
// Note: use the factory method that corresponds to the HERE Map Content layer,
// for example `navigationAttribute` for compiling the attributes from 'navigation-attributes'
// layer:
final AttributeAccessor<NavigationAttributesPartition, Integer> speedLimitAccessor =
    AttributeAccessors.forHereMapContentSegmentAnchor(
        NavigationAttributesPartition::speedLimit, SpeedLimitAttribute::value);

final RangeBasedPropertyMap<Vertex, Integer> speedLimitMap =
    PropertyMaps.navigationAttribute(
        optimizedMap, "speed-limit", hereMapContent, cacheManager, speedLimitAccessor);
final List<RangeBasedProperty<Integer>> speedLimits = speedLimitMap.get(vertex);

  • などの道路属性を取得します

    Scala
    Java
    import com.here.platform.location.integration.optimizedmap.roadattributes._

val roadAttributes = PropertyMaps.RoadAttributes(optimizedMap, cacheManager)

val functionalClasses: Seq[RangeBasedProperty[FunctionalClass]] =
  roadAttributes.functionalClass(vertex)

val overpassUnderpasses: Seq[RangeBasedProperty[OverpassUnderpass]] =
  roadAttributes.overpassUnderpass(vertex)

val officialCountryCodes: Seq[RangeBasedProperty[OfficialCountryCode]] =
  roadAttributes.officialCountryCode(vertex)

val physicalAttributes: Seq[RangeBasedProperty[PhysicalAttribute]] =
  roadAttributes.physicalAttribute(vertex)

val roadClasses: Seq[RangeBasedProperty[RoadClass]] = roadAttributes.roadClass(vertex)

val specialTrafficAreaCategories: Seq[RangeBasedProperty[SpecialTrafficAreaCategory]] =
  roadAttributes.specialTrafficAreaCategory(vertex)

val userDefinedCountryCodes: Seq[RangeBasedProperty[UserDefinedCountryCode]] =
  roadAttributes.userDefinedCountryCode(vertex)
    import com.here.platform.location.core.graph.javadsl.RangeBasedProperty;
import com.here.platform.location.core.graph.javadsl.RangeBasedPropertyMap;
import com.here.platform.location.inmemory.graph.Vertex;
import com.here.platform.location.integration.optimizedmap.graph.javadsl.PropertyMaps;
import com.here.platform.location.integration.optimizedmap.roadattributes.*;

import java.util.List;
final PropertyMaps.RoadAttributes roadAttributes =
    new PropertyMaps.RoadAttributes(optimizedMap, cacheManager);

final RangeBasedPropertyMap<Vertex, FunctionalClass> functionalClass =
    roadAttributes.functionalClass();
final List<RangeBasedProperty<FunctionalClass>> functionalClasses = functionalClass.get(vertex);

final RangeBasedPropertyMap<Vertex, OverpassUnderpass> overpassUnderpass =
    roadAttributes.overpassUnderpass();
final List<RangeBasedProperty<OverpassUnderpass>> overpassUnderpasses =
    overpassUnderpass.get(vertex);

final RangeBasedPropertyMap<Vertex, OfficialCountryCode> officialCountryCode =
    roadAttributes.officialCountryCode();
final List<RangeBasedProperty<OfficialCountryCode>> officialCountryCodes =
    officialCountryCode.get(vertex);

final RangeBasedPropertyMap<Vertex, PhysicalAttribute> physicalAttribute =
    roadAttributes.physicalAttribute();
final List<RangeBasedProperty<PhysicalAttribute>> physicalAttributes =
    physicalAttribute.get(vertex);

final RangeBasedPropertyMap<Vertex, RoadClass> roadClass = roadAttributes.roadClass();
final List<RangeBasedProperty<RoadClass>> roadClasses = roadClass.get(vertex);

final RangeBasedPropertyMap<Vertex, SpecialTrafficAreaCategory> specialTrafficAreaCategory =
    roadAttributes.specialTrafficAreaCategory();
final List<RangeBasedProperty<SpecialTrafficAreaCategory>> specialTrafficAreaCategories =
    specialTrafficAreaCategory.get(vertex);
final List<RangeBasedProperty<UserDefinedCountryCode>> userDefinedCountryCodes =
    roadAttributes.userDefinedCountryCode().get(vertex);

  • などのナビゲーション属性を取得します

    Scala
    Java
    import com.here.platform.location.integration.optimizedmap.navigationattributes._

val navigationAttributes = PropertyMaps.NavigationAttributes(optimizedMap, cacheManager)

val intersectionInternalCategories: Seq[RangeBasedProperty[IntersectionInternalCategory]] =
  navigationAttributes.intersectionInternalCategory(vertex)
val laneCategories: Seq[RangeBasedProperty[LaneCategory]] =
  navigationAttributes.laneCategory(vertex)
val throughLaneCounts: Seq[RangeBasedProperty[Int]] =
  navigationAttributes.throughLaneCount(vertex)
val physicalLaneCounts: Seq[RangeBasedProperty[Int]] =
  navigationAttributes.physicalLaneCount(vertex)
val localRoads: Seq[RangeBasedProperty[LocalRoad]] =
  navigationAttributes.localRoad(vertex)
val roadUsages: Seq[RangeBasedProperty[RoadUsage]] =
  navigationAttributes.roadUsage(vertex)
val lowMobilities: Seq[RangeBasedProperty[LowMobility]] =
  navigationAttributes.lowMobility(vertex)
val roadDividers: Seq[RangeBasedProperty[RoadDivider]] =
  navigationAttributes.roadDivider(vertex)
val speedCategories: Seq[RangeBasedProperty[SpeedCategory]] =
  navigationAttributes.speedCategory(vertex)
val speedLimit: Seq[RangeBasedProperty[SpeedLimit]] =
  navigationAttributes.speedLimit(vertex)
val supplementalGeometries: Seq[RangeBasedProperty[SupplementalGeometry]] =
  navigationAttributes.supplementalGeometry(vertex)
val travelDirection: Seq[RangeBasedProperty[TravelDirection]] =
  navigationAttributes.travelDirection(vertex)
val urban: Seq[RangeBasedProperty[Boolean]] =
  navigationAttributes.urban(vertex)
val specialExplication: Option[SpecialExplication] =
  navigationAttributes.specialExplication(edge)
val throughRoute: Option[ThroughRoute] =
  navigationAttributes.throughRoute(edge)
val tmcCodes: Seq[RangeBasedProperty[Set[TrafficMessageChannelCode]]] =
  navigationAttributes.trafficMessageChannelCodes(vertex)
    import com.here.platform.location.core.graph.javadsl.PropertyMap;
import com.here.platform.location.core.graph.javadsl.RangeBasedProperty;
import com.here.platform.location.core.graph.javadsl.RangeBasedPropertyMap;
import com.here.platform.location.inmemory.graph.Edge;
import com.here.platform.location.inmemory.graph.Vertex;
import com.here.platform.location.integration.optimizedmap.commonattributes.SpeedLimit;
import com.here.platform.location.integration.optimizedmap.graph.javadsl.PropertyMaps;
import com.here.platform.location.integration.optimizedmap.navigationattributes.*;

import java.util.List;
import java.util.Optional;
import java.util.Set;
final PropertyMaps.NavigationAttributes navigationAttributes =
    new PropertyMaps.NavigationAttributes(optimizedMap, cacheManager);

final RangeBasedPropertyMap<Vertex, IntersectionInternalCategory> intersectionInternalCategory =
    navigationAttributes.intersectionInternalCategory();
final List<RangeBasedProperty<IntersectionInternalCategory>> intersectionInternalCategories =
    intersectionInternalCategory.get(vertex);

final RangeBasedPropertyMap<Vertex, LaneCategory> laneCategory =
    navigationAttributes.laneCategory();
final List<RangeBasedProperty<LaneCategory>> laneCategories = laneCategory.get(vertex);

final RangeBasedPropertyMap<Vertex, RoadUsage> roadUsage = navigationAttributes.roadUsage();
final List<RangeBasedProperty<RoadUsage>> roadUsages = roadUsage.get(vertex);

final RangeBasedPropertyMap<Vertex, Integer> throughLaneCount =
    navigationAttributes.throughLaneCount();
final List<RangeBasedProperty<Integer>> throughLaneCounts = throughLaneCount.get(vertex);

final RangeBasedPropertyMap<Vertex, Integer> physicalLaneCount =
    navigationAttributes.physicalLaneCount();
final List<RangeBasedProperty<Integer>> physicalLaneCounts = physicalLaneCount.get(vertex);

final RangeBasedPropertyMap<Vertex, LocalRoad> localRoad = navigationAttributes.localRoad();
final List<RangeBasedProperty<LocalRoad>> localRoads = localRoad.get(vertex);

final RangeBasedPropertyMap<Vertex, LowMobility> lowMobility =
    navigationAttributes.lowMobility();
final List<RangeBasedProperty<LowMobility>> lowMobilities = lowMobility.get(vertex);

final RangeBasedPropertyMap<Vertex, RoadDivider> roadDivider =
    navigationAttributes.roadDivider();
final List<RangeBasedProperty<RoadDivider>> roadDividers = roadDivider.get(vertex);

final RangeBasedPropertyMap<Vertex, SpeedCategory> speedCategory =
    navigationAttributes.speedCategory();
final List<RangeBasedProperty<SpeedCategory>> speedCategories = speedCategory.get(vertex);

final RangeBasedPropertyMap<Vertex, SpeedLimit> speedLimit = navigationAttributes.speedLimit();
final List<RangeBasedProperty<SpeedLimit>> speedLimits = speedLimit.get(vertex);

final RangeBasedPropertyMap<Vertex, SupplementalGeometry> supplementalGeometry =
    navigationAttributes.supplementalGeometry();
final List<RangeBasedProperty<SupplementalGeometry>> supplementalGeometries =
    supplementalGeometry.get(vertex);

final RangeBasedPropertyMap<Vertex, TravelDirection> travelDirection =
    navigationAttributes.travelDirection();
final List<RangeBasedProperty<TravelDirection>> travelDirections = travelDirection.get(vertex);

final RangeBasedPropertyMap<Vertex, Boolean> urban = navigationAttributes.urban();
final List<RangeBasedProperty<Boolean>> urbans = urban.get(vertex);

final PropertyMap<Edge, Optional<SpecialExplication>> specialExplication =
    navigationAttributes.specialExplication();
final Optional<SpecialExplication> specialExplications = specialExplication.get(edge);

final PropertyMap<Edge, Optional<ThroughRoute>> throughRoute =
    navigationAttributes.throughRoute();
final Optional<ThroughRoute> throughRoutes = throughRoute.get(edge);

final RangeBasedPropertyMap<Vertex, Set<TrafficMessageChannelCode>> trafficMessageChannelCodes =
    navigationAttributes.trafficMessageChannelCodes();
final List<RangeBasedProperty<Set<TrafficMessageChannelCode>>> tmcCodes =
    trafficMessageChannelCodes.get(vertex);

  • などの高度なナビゲーション属性を取得します

    Scala
    Java
    import com.here.platform.location.integration.optimizedmap.advancednavigationattributes._

val advancedNavigationAttributes =
  PropertyMaps.AdvancedNavigationAttributes(optimizedMap, cacheManager)

val railwayCrossings: Seq[PointBasedProperty[RailwayCrossing]] =
  advancedNavigationAttributes.railwayCrossing(vertex)

val speedLimit: Seq[RangeBasedProperty[SpeedLimit]] =
  advancedNavigationAttributes.speedLimit(vertex)

val gradeCategory: Seq[RangeBasedProperty[GradeCategory]] =
  advancedNavigationAttributes.gradeCategory(vertex)

val scenic: Seq[RangeBasedProperty[Scenic]] =
  advancedNavigationAttributes.scenic(vertex)
    import com.here.platform.location.core.graph.javadsl.PointBasedProperty;
import com.here.platform.location.core.graph.javadsl.PointBasedPropertyMap;
import com.here.platform.location.core.graph.javadsl.RangeBasedProperty;
import com.here.platform.location.core.graph.javadsl.RangeBasedPropertyMap;
import com.here.platform.location.inmemory.graph.Vertex;
import com.here.platform.location.integration.optimizedmap.advancednavigationattributes.GradeCategory;
import com.here.platform.location.integration.optimizedmap.advancednavigationattributes.RailwayCrossing;
import com.here.platform.location.integration.optimizedmap.advancednavigationattributes.Scenic;
import com.here.platform.location.integration.optimizedmap.commonattributes.SpeedLimit;
import com.here.platform.location.integration.optimizedmap.graph.javadsl.PropertyMaps;

import java.util.List;
final PropertyMaps.AdvancedNavigationAttributes advancedNavigationAttributes =
    new PropertyMaps.AdvancedNavigationAttributes(optimizedMap, cacheManager);

final PointBasedPropertyMap<Vertex, RailwayCrossing> railwayCrossing =
    advancedNavigationAttributes.railwayCrossing();
final List<PointBasedProperty<RailwayCrossing>> railwayCrossings = railwayCrossing.get(vertex);

final RangeBasedPropertyMap<Vertex, SpeedLimit> speedLimit =
    advancedNavigationAttributes.speedLimit();
final List<RangeBasedProperty<SpeedLimit>> speedLimits = speedLimit.get(vertex);

final RangeBasedPropertyMap<Vertex, GradeCategory> gradeCategory =
    advancedNavigationAttributes.gradeCategory();
final List<RangeBasedProperty<GradeCategory>> gradeCategories = gradeCategory.get(vertex);

final RangeBasedPropertyMap<Vertex, Scenic> scenic = advancedNavigationAttributes.scenic();
final List<RangeBasedProperty<Scenic>> scenics = scenic.get(vertex);

  • などの ADAS 属性を取得します

    Scala
    Java
    import com.here.platform.location.integration.optimizedmap.adasattributes._

val adasAttributes = PropertyMaps.AdasAttributes(optimizedMap, cacheManager)

val builtUpAreaRoad: Seq[RangeBasedProperty[BuiltUpAreaRoad]] =
  adasAttributes.builtUpAreaRoad(vertex)

val linkAccuracy: Seq[RangeBasedProperty[Int]] = adasAttributes.linkAccuracy(vertex)

val slope: Seq[PointBasedProperty[Slope]] = adasAttributes.slope(vertex)

val curvatureHeading: Seq[PointBasedProperty[CurvatureHeading]] =
  adasAttributes.curvatureHeading(vertex)

val edgeCurvatureHeading: Option[CurvatureHeading] =
  adasAttributes.edgeCurvatureHeading(edge)

val elevation: Seq[PointBasedProperty[Elevation]] =
  adasAttributes.elevation(vertex)
    import com.here.platform.location.core.graph.javadsl.*;
import com.here.platform.location.inmemory.graph.Edge;
import com.here.platform.location.inmemory.graph.Vertex;
import com.here.platform.location.integration.optimizedmap.adasattributes.BuiltUpAreaRoad;
import com.here.platform.location.integration.optimizedmap.adasattributes.CurvatureHeading;
import com.here.platform.location.integration.optimizedmap.adasattributes.Elevation;
import com.here.platform.location.integration.optimizedmap.adasattributes.Slope;
import com.here.platform.location.integration.optimizedmap.graph.javadsl.PropertyMaps;

import java.util.List;
import java.util.Optional;
final PropertyMaps.AdasAttributes adasAttributes =
    new PropertyMaps.AdasAttributes(optimizedMap, cacheManager);

final RangeBasedPropertyMap<Vertex, BuiltUpAreaRoad> builtUpAreaRoad =
    adasAttributes.builtUpAreaRoad();
final List<RangeBasedProperty<BuiltUpAreaRoad>> builtUpAreaRoads = builtUpAreaRoad.get(vertex);

final RangeBasedPropertyMap<Vertex, Integer> linkAccuracy = adasAttributes.linkAccuracy();
final List<RangeBasedProperty<Integer>> linkAccuracies = linkAccuracy.get(vertex);

final PointBasedPropertyMap<Vertex, Slope> slope = adasAttributes.slope();
final List<PointBasedProperty<Slope>> slopes = slope.get(vertex);

final PointBasedPropertyMap<Vertex, CurvatureHeading> curvatureHeading =
    adasAttributes.curvatureHeading();
final List<PointBasedProperty<CurvatureHeading>> curvatureHeadings =
    curvatureHeading.get(vertex);

final PropertyMap<Edge, Optional<CurvatureHeading>> edgeCurvatureHeading =
    adasAttributes.edgeCurvatureHeading();
final Optional<CurvatureHeading> edgeCurvatureHeadings = edgeCurvatureHeading.get(edge);

final PointBasedPropertyMap<Vertex, Elevation> elevation = adasAttributes.elevation();
final List<PointBasedProperty<Elevation>> elevations = elevation.get(vertex);

  • 頂点の HERE Map Content 属性の多くをオンザフライでコンパイルして取得します。 ロケーション ライブラリでは、セグメントのアンカータイプが「 Point 」、「 Single-Segment 」、および「 Multi-Segment 」の場合、その場でのセグメント属性のコンパイルがサポートされています。

    問題の属性のセグメントアンカーが重複していないことがわかっている場合は、次の API を使用してコンパイルできます。

    Scala
    Java
    // Note: use the factory method that corresponds to the HERE Map Content layer,
// for example `navigationAttribute` for compiling the attributes from 'navigation-attributes' layer:

import com.here.platform.location.compilation.heremapcontent.{
  AttributeAccessor,
  AttributeAccessors
}
import com.here.platform.location.core.graph.RangeBasedProperty
import com.here.schema.rib.v2.common_attributes.SpeedLimitAttribute
import com.here.schema.rib.v2.navigation_attributes_partition.NavigationAttributesPartition

val speedLimitAccessor: AttributeAccessor[NavigationAttributesPartition, Int] =
  AttributeAccessors
    .forHereMapContentSegmentAnchor[NavigationAttributesPartition, SpeedLimitAttribute, Int](
      _.speedLimit,
      _.value)

val speedLimitMap: RangeBasedPropertyMap[Vertex, Int] =
  PropertyMaps.navigationAttribute(
    optimizedMap,
    "speed-limit",
    hereMapContent,
    cacheManager,
    speedLimitAccessor
  )

val speedLimits: Seq[RangeBasedProperty[Int]] = speedLimitMap(vertex)
    import com.here.platform.location.compilation.heremapcontent.javadsl.AttributeAccessor;
import com.here.platform.location.compilation.heremapcontent.javadsl.AttributeAccessors;
import com.here.platform.location.core.graph.javadsl.RangeBasedProperty;
import com.here.platform.location.core.graph.javadsl.RangeBasedPropertyMap;
import com.here.platform.location.inmemory.graph.Vertex;
import com.here.platform.location.integration.optimizedmap.graph.javadsl.PropertyMaps;
import com.here.schema.rib.v2.common_attributes.SpeedLimitAttribute;
import com.here.schema.rib.v2.navigation_attributes_partition.NavigationAttributesPartition;

import java.util.List;
// Note: use the factory method that corresponds to the HERE Map Content layer,
// for example `navigationAttribute` for compiling the attributes from 'navigation-attributes'
// layer:
final AttributeAccessor<NavigationAttributesPartition, Integer> speedLimitAccessor =
    AttributeAccessors.forHereMapContentSegmentAnchor(
        NavigationAttributesPartition::speedLimit, SpeedLimitAttribute::value);

final RangeBasedPropertyMap<Vertex, Integer> speedLimitMap =
    PropertyMaps.navigationAttribute(
        optimizedMap, "speed-limit", hereMapContent, cacheManager, speedLimitAccessor);
final List<RangeBasedProperty<Integer>> speedLimits = speedLimitMap.get(vertex);

    範囲が重複している属性の場合は、別の方法を使用できます。

    Scala
    Java
    import com.here.platform.location.compilation.heremapcontent.{
  AttributeAccessor,
  AttributeAccessors
}
import com.here.platform.location.core.graph.RangeBasedProperty
import com.here.schema.rib.v2.advanced_navigation_attributes.SpecialSpeedSituationCondition
import com.here.schema.rib.v2.advanced_navigation_attributes_partition.AdvancedNavigationAttributesPartition

val specialSpeedLimitAccessor: AttributeAccessor[AdvancedNavigationAttributesPartition, Int] =
  AttributeAccessors
    .forHereMapContentSegmentAnchor[AdvancedNavigationAttributesPartition,
                                    SpecialSpeedSituationCondition,
                                    Int](_.specialSpeedSituation, _.specialSpeedLimit)

val specialSpeedLimitMap: PropertyMap[Vertex, Seq[RangeBasedProperty[Int]]] =
  PropertyMaps.overlappingRangeBasedProperty(
    optimizedMap,
    "special-speed-limit",
    cacheManager,
    HereMapContentLayers.AdvancedNavigationAttributes.tileLoader(hereMapContent, cacheManager),
    HereMapContentLayers.AdvancedNavigationAttributes.partitionResolver(optimizedMap,
                                                                        cacheManager),
    specialSpeedLimitAccessor
  )

val specialSpeedLimits: Seq[RangeBasedProperty[Int]] = specialSpeedLimitMap(vertex)
    import com.here.platform.location.compilation.heremapcontent.javadsl.AttributeAccessor;
import com.here.platform.location.compilation.heremapcontent.javadsl.AttributeAccessors;
import com.here.platform.location.core.graph.javadsl.PropertyMap;
import com.here.platform.location.core.graph.javadsl.RangeBasedProperty;
import com.here.platform.location.inmemory.graph.Vertex;
import com.here.platform.location.integration.heremapcontent.HereMapContentLayers;
import com.here.platform.location.integration.optimizedmap.graph.javadsl.PropertyMaps;
import com.here.schema.rib.v2.advanced_navigation_attributes.SpecialSpeedSituationCondition;
import com.here.schema.rib.v2.advanced_navigation_attributes_partition.AdvancedNavigationAttributesPartition;

import java.util.List;
final AttributeAccessor<AdvancedNavigationAttributesPartition, Integer>
    specialSpeedLimitAccessor =
        AttributeAccessors.forHereMapContentSegmentAnchor(
            AdvancedNavigationAttributesPartition::specialSpeedSituation,
            SpecialSpeedSituationCondition::specialSpeedLimit);

final PropertyMap<Vertex, List<RangeBasedProperty<Integer>>> specialSpeedLimitMap =
    PropertyMaps.overlappingRangeBasedProperty(
        optimizedMap,
        "special-speed-limit",
        cacheManager,
        HereMapContentLayers.AdvancedNavigationAttributes()
            .tileLoader(hereMapContent, cacheManager),
        HereMapContentLayers.AdvancedNavigationAttributes()
            .partitionResolver(optimizedMap, cacheManager),
        specialSpeedLimitAccessor);
final List<RangeBasedProperty<Integer>> specialSpeedLimits = specialSpeedLimitMap.get(vertex);

注

HERE Map Content レイヤーでは、一部の属性に、トポロジーセグメントの各セクションに一意の値が設定されています（レーン数や機能クラスなど）。 他の属性には、複数の重複する値が含まれている場合があります ( たとえば、同じ場所に複数の値がある時間依存属性が、異なる時間帯に適用されます ) 。 各場所に 1 つの値がある場合、属性は「重複しない」ものになります。また、同じ場所に複数の異なる値を設定できる場合、属性は「重複している」ものになります。

「」に一致する結果は 件です

    「」に一致する結果はありません