Package com.here.platform.location.integration.optimizedmap.mapmatching.javadsl

Class PathMatchers

java.lang.Object
com.here.platform.location.integration.optimizedmap.mapmatching.javadsl.PathMatchers
public final class PathMatchers extends Object

  • Constructor Details

  • Method Details

    • newHMMPathMatcher

      public static <O, V, T> PathMatcher<O,V,T> newHMMPathMatcher(CandidateGenerator<O,V> cg, EmissionProbabilityStrategy<O,V> eps, TransitionProbabilityStrategy<O,V,T> tps)
      Creates an HMM path matcher from its components.

    • unrestrictedPathMatcherWithoutTransitions

      public <O extends GeoCoordinateHolder> PathMatcher<O,Vertex,NoTransition> unrestrictedPathMatcherWithoutTransitions()
      Creates an HMM path matcher that uses default parameters and doesn't take any restriction into consideration.

      The path matcher uses the `TransitionProbabilityStrategies.directDistance` to calculate the transition probabilities of the Hidden Markov Model. Therefore, this path matcher is not recommended for sparse input observations. For sparse input observations, consider using a path matcher created by `PathMatchers.unrestrictedPathMatcherWithTransitions` instead.

      Use this overload of the method when the geographical coordinate type implements GeoCoordinateHolder.

      Type Parameters:
      O - The type of observations expected by the path matcher

    • unrestrictedPathMatcherWithoutTransitions

      public <O> PathMatcher<O,Vertex,NoTransition> unrestrictedPathMatcherWithoutTransitions(GeoCoordinateAdapter<O> adapter)
      Creates an HMM path matcher that uses default parameters and doesn't take any restriction into consideration.

      The path matcher uses the `TransitionProbabilityStrategies.directDistance` to calculate the transition probabilities of the Hidden Markov Model. Therefore, this path matcher is not recommended for sparse input observations. For sparse input observations, consider using a path matcher created by `PathMatchers.unrestrictedPathMatcherWithTransitions` instead.

      Use this overload of the method when the geographical coordinate type does not implement GeoCoordinateHolder.

      Type Parameters:
      O - The type of observations expected by the path matcher
      Parameters:
      adapter - GeoCoordinateAdapter to extract latitude and longitude for O

    • unrestrictedPathMatcherWithTransitions

      public <O extends GeoCoordinateHolder> PathMatcher<O,Vertex,List<Vertex>> unrestrictedPathMatcherWithTransitions()
      Creates an HMM path matcher that uses default parameters and doesn't take any restriction into consideration, and that is suitable for sparse probes. However, if the observations are not close enough, they will be considered unreachable.

      The path matcher uses the DistanceTransitionProbabilityStrategy to calculate the transition probabilities of the Hidden Markov Model.

      Besides a sequence of MatchResults, this path matcher returns a list of transitions. A transition is a sequence of `com.here.platform.location.inmemory.graph.Vertex` objects that represents a path between `OnRoad` match results associated to two successive observations. A transition does not contain the two vertices referenced by the corresponding `OnRoad` match results.

      Consider the following example: 

       
  O1                   O2
  |                    |
  v                    v
 --V1--> --V2--> --V3-->

      The observation O1 is matched to vertex V1, and O2 to V3. Although V1 and V3 are not directly connected, the path matcher returns a transition from O1 to O2 that contains the intermediate vertices, V2 in this case.

      Internally, this method creates a PathMatcherWithFilter that uses a distance filter and a projecting interpolator to improve match results when consecutive points are close to one another.

      See also

      • PathMatcherWithFilter for more information about filtering and interpolation.
      • Filters.`distance` for a factory method to create a distance filter.
      • Interpolators.`projecting` for a factory method to create a projecting interpolator.
      Use this overload of the method when the geographical coordinate type implements GeoCoordinateHolder.
      Type Parameters:
      O - The type of observations expected by the path matcher

    • unrestrictedPathMatcherWithTransitions

      public <O> PathMatcher<O,Vertex,List<Vertex>> unrestrictedPathMatcherWithTransitions(GeoCoordinateAdapter<O> adapter)
      Creates an HMM path matcher that uses default parameters and doesn't take any restriction into consideration, and that is suitable for sparse probes. However, if the observations are not close enough, they will be considered unreachable.

      The path matcher uses the DistanceTransitionProbabilityStrategy to calculate the transition probabilities of the Hidden Markov Model.

      Besides a sequence of MatchResults, this path matcher returns a list of transitions. A transition is a sequence of `com.here.platform.location.inmemory.graph.Vertex` objects that represents a path between `OnRoad` match results associated to two successive observations. A transition does not contain the two vertices referenced by the corresponding `OnRoad` match results.

      Consider the following example: 

       
  O1                   O2
  |                    |
  v                    v
 --V1--> --V2--> --V3-->

      The observation O1 is matched to vertex V1, and O2 to V3. Although V1 and V3 are not directly connected, the path matcher returns a transition from O1 to O2 that contains the intermediate vertices, V2 in this case.

      Internally, this method creates a PathMatcherWithFilter that uses a distance filter and a projecting interpolator to improve match results when consecutive points are close to one another.

      See also

      • PathMatcherWithFilter for more information about filtering and interpolation.
      • Filters.`distance` for a factory method to create a distance filter.
      • Interpolators.`projecting` for a factory method to create a projecting interpolator.
      Use this overload of the method when the geographical coordinate type does not implement GeoCoordinateHolder.
      Type Parameters:
      O - The type of observations expected by the path matcher
      Parameters:
      adapter - GeoCoordinateAdapter to extract latitude and longitude for O

    • carPathMatcherWithoutTransitions

      public <O extends GeoCoordinateHolder> PathMatcher<O,Vertex,NoTransition> carPathMatcherWithoutTransitions()
      Creates an HMM path matcher that only matches to vertices that are accessible by cars.

      The path matcher uses the`TransitionProbabilityStrategies.directDistance` to calculate the transition probabilities of the Hidden Markov Model. Therefore, this path matcher is not recommended for sparse input observations. For sparse input observations, consider using a path matcher created by `PathMatchers.carPathMatcherWithTransitions` instead.

      Use this overload of the method when the geographical coordinate type implements GeoCoordinateHolder.

      Type Parameters:
      O - The type of observations expected by the path matcher

    • carPathMatcherWithoutTransitions

      public <O> PathMatcher<O,Vertex,NoTransition> carPathMatcherWithoutTransitions(GeoCoordinateAdapter<O> adapter)
      Creates an HMM path matcher that only matches to vertices that are accessible by cars.

      The path matcher uses the `TransitionProbabilityStrategies.directDistance` to calculate the transition probabilities of the Hidden Markov Model. Therefore, this path matcher is not recommended for sparse input observations. For sparse input observations, consider using a path matcher created by `PathMatchers.carPathMatcherWithTransitions` instead.

      Use this overload of the method when the geographical coordinate type does not implement GeoCoordinateHolder.

      Type Parameters:
      O - The type of observations expected by the path matcher
      Parameters:
      adapter - GeoCoordinateAdapter to extract latitude and longitude for O

    • carPathMatcherWithTransitions

      public <O extends GeoCoordinateHolder> PathMatcher<O,Vertex,List<Vertex>> carPathMatcherWithTransitions()
      Creates an HMM path matcher that only matches to vertices that are accessible to cars, and that is suitable for sparse probes. However, if the observations are not close enough, they will be considered unreachable.

      Besides a sequence of MatchResults, this path matcher returns a list of transitions. A transition is a sequence of `com.here.platform.location.inmemory.graph.Vertex` objects that represents a path between `OnRoad` match results associated to two successive observations. A transition does not contain the two vertices referenced by the corresponding `OnRoad` match results.

      Consider the following example: 

       
  O1                   O2
  |                    |
  v                    v
 --V1--> --V2--> --V3-->

      The observation O1 is matched to vertex V1, and O2 to V3. Although V1 and V3 are not directly connected, the path matcher returns a transition from O1 to O2 that contains the intermediate vertices, V2 in this case.

      Internally, this method creates a PathMatcherWithFilter that uses a distance filter and a projecting interpolator to improve match results when consecutive points are close to one another.

      See also

      • PathMatcherWithFilter for more information about filtering and interpolation.
      • Filters.`distance` for a factory method to create a distance filter.
      • Interpolators.`projecting` for a factory method to create a projecting interpolator.
      Use this overload of the method when the geographical coordinate type implements GeoCoordinateHolder.
      Type Parameters:
      O - The type of observations expected by the path matcher

    • carPathMatcherWithTransitions

      public <O> PathMatcher<O,Vertex,List<Vertex>> carPathMatcherWithTransitions(GeoCoordinateAdapter<O> adapter)
      Creates an HMM path matcher that only matches to vertices that are accessible to cars, and that is suitable for sparse probes. However, if the observations are not close enough, they will be considered unreachable.

      Besides a sequence of MatchResults, this path matcher returns a list of transitions. A transition is a sequence of `com.here.platform.location.inmemory.graph.Vertex` objects that represents a path between `OnRoad` match results associated to two successive observations. A transition does not contain the two vertices referenced by the corresponding `OnRoad` match results.

      Consider the following example: 

       
  O1                   O2
  |                    |
  v                    v
 --V1--> --V2--> --V3-->

      The observation O1 is matched to vertex V1, and O2 to V3. Although V1 and V3 are not directly connected, the path matcher returns a transition from O1 to O2 that contains the intermediate vertices, V2 in this case.

      Internally, this method creates a PathMatcherWithFilter that uses a distance filter and a projecting interpolator to improve match results when consecutive points are close to one another.

      See also

      • PathMatcherWithFilter for more information about filtering and interpolation.
      • Filters.`distance` for a factory method to create a distance filter.
      • Interpolators.`projecting` for a factory method to create a projecting interpolator.
      Use this overload of the method when the geographical coordinate type does not implement GeoCoordinateHolder.
      Type Parameters:
      O - The type of observations expected by the path matcher
      Parameters:
      adapter - GeoCoordinateAdapter to extract latitude and longitude for O

    • unrestrictedPathMatcherWithoutTransitions

      public static <O extends GeoCoordinateHolder> PathMatcher<O,Vertex,NoTransition> unrestrictedPathMatcherWithoutTransitions(UnrestrictedPathMatcherLayers unrestrictedPathMatcherLayers)
      Creates an HMM path matcher that uses default parameters and doesn't take any restriction into consideration.

      The path matcher uses the `TransitionProbabilityStrategies.directDistance` to calculate the transition probabilities of the Hidden Markov Model. Therefore, this path matcher is not recommended for sparse input observations. For sparse input observations, consider using a path matcher created by `PathMatchers.unrestrictedPathMatcherWithTransitions` instead.

      Use this overload of the method when the geographical coordinate type implements GeoCoordinateHolder.

      Type Parameters:
      O - The type of observations expected by the path matcher

    • unrestrictedPathMatcherWithoutTransitions

      public static <O> PathMatcher<O,Vertex,NoTransition> unrestrictedPathMatcherWithoutTransitions(UnrestrictedPathMatcherLayers unrestrictedPathMatcherLayers, GeoCoordinateAdapter<O> adapter)
      Creates an HMM path matcher that uses default parameters and doesn't take any restriction into consideration.

      The path matcher uses the `TransitionProbabilityStrategies.directDistance` to calculate the transition probabilities of the Hidden Markov Model. Therefore, this path matcher is not recommended for sparse input observations. For sparse input observations, consider using a path matcher created by `PathMatchers.unrestrictedPathMatcherWithTransitions` instead.

      Use this overload of the method when the geographical coordinate type does not implement GeoCoordinateHolder.

      Type Parameters:
      O - The type of observations expected by the path matcher
      Parameters:
      adapter - GeoCoordinateAdapter to extract latitude and longitude for O

    • unrestrictedPathMatcherWithTransitions

      public static <O extends GeoCoordinateHolder> PathMatcher<O,Vertex,List<Vertex>> unrestrictedPathMatcherWithTransitions(UnrestrictedPathMatcherLayers unrestrictedPathMatcherLayers)
      Creates an HMM path matcher that uses default parameters and doesn't take any restriction into consideration, and that is suitable for sparse probes. However, if the observations are not close enough, they will be considered unreachable.

      The path matcher uses the DistanceTransitionProbabilityStrategy to calculate the transition probabilities of the Hidden Markov Model.

      Besides a sequence of MatchResults, this path matcher returns a list of transitions. A transition is a sequence of `com.here.platform.location.inmemory.graph.Vertex` objects that represents a path between `OnRoad` match results associated to two successive observations. A transition does not contain the two vertices referenced by the corresponding `OnRoad` match results.

      Consider the following example: 

       
  O1                   O2
  |                    |
  v                    v
 --V1--> --V2--> --V3-->

      The observation O1 is matched to vertex V1, and O2 to V3. Although V1 and V3 are not directly connected, the path matcher returns a transition from O1 to O2 that contains the intermediate vertices, V2 in this case.

      Internally, this method creates a PathMatcherWithFilter that uses a distance filter and a projecting interpolator to improve match results when consecutive points are close to one another.

      See also

      • PathMatcherWithFilter for more information about filtering and interpolation.
      • Filters.`distance` for a factory method to create a distance filter.
      • Interpolators.`projecting` for a factory method to create a projecting interpolator.
      Use this overload of the method when the geographical coordinate type implements GeoCoordinateHolder.
      Type Parameters:
      O - The type of observations expected by the path matcher

    • unrestrictedPathMatcherWithTransitions

      public static <O> PathMatcher<O,Vertex,List<Vertex>> unrestrictedPathMatcherWithTransitions(UnrestrictedPathMatcherLayers unrestrictedPathMatcherLayers, GeoCoordinateAdapter<O> adapter)
      Creates an HMM path matcher that uses default parameters and doesn't take any restriction into consideration, and that is suitable for sparse probes. However, if the observations are not close enough, they will be considered unreachable.

      The path matcher uses the DistanceTransitionProbabilityStrategy to calculate the transition probabilities of the Hidden Markov Model.

      Besides a sequence of MatchResults, this path matcher returns a list of transitions. A transition is a sequence of `com.here.platform.location.inmemory.graph.Vertex` objects that represents a path between `OnRoad` match results associated to two successive observations. A transition does not contain the two vertices referenced by the corresponding `OnRoad` match results.

      Consider the following example: 

       
  O1                   O2
  |                    |
  v                    v
 --V1--> --V2--> --V3-->

      The observation O1 is matched to vertex V1, and O2 to V3. Although V1 and V3 are not directly connected, the path matcher returns a transition from O1 to O2 that contains the intermediate vertices, V2 in this case.

      Internally, this method creates a PathMatcherWithFilter that uses a distance filter and a projecting interpolator to improve match results when consecutive points are close to one another.

      See also

      • PathMatcherWithFilter for more information about filtering and interpolation.
      • Filters.`distance` for a factory method to create a distance filter.
      • Interpolators.`projecting` for a factory method to create a projecting interpolator.

      Use this overload of the method when the geographical coordinate type does not implement GeoCoordinateHolder.

      Type Parameters:
      O - The type of observations expected by the path matcher
      Parameters:
      adapter - GeoCoordinateAdapter to extract latitude and longitude for O

    • carPathMatcherWithoutTransitions

      public static <O extends GeoCoordinateHolder> PathMatcher<O,Vertex,NoTransition> carPathMatcherWithoutTransitions(CarPathMatcherLayers carPathMatcherLayers)
      Creates an HMM path matcher that only matches to vertices that are accessible by cars.

      The path matcher uses the `TransitionProbabilityStrategies.directDistance` to calculate the transition probabilities of the Hidden Markov Model. Therefore, this path matcher is not recommended for sparse input observations. For sparse input observations, consider using a path matcher created by `PathMatchers.carPathMatcherWithTransitions` instead.

      Use this overload of the method when the geographical coordinate type implements GeoCoordinateHolder.

      Type Parameters:
      O - The type of observations expected by the path matcher

    • carPathMatcherWithoutTransitions

      public static <O> PathMatcher<O,Vertex,NoTransition> carPathMatcherWithoutTransitions(CarPathMatcherLayers carPathMatcherLayers, GeoCoordinateAdapter<O> adapter)
      Creates an HMM path matcher that only matches to vertices that are accessible by cars.

      The path matcher uses the `TransitionProbabilityStrategies.directDistance` to calculate the transition probabilities of the Hidden Markov Model. Therefore, this path matcher is not recommended for sparse input observations. For sparse input observations, consider using a path matcher created by `PathMatchers.carPathMatcherWithTransitions` instead.

      Use this overload of the method when the geographical coordinate type does not implement GeoCoordinateHolder.

      Type Parameters:
      O - The type of observations expected by the path matcher
      Parameters:
      adapter - GeoCoordinateAdapter to extract latitude and longitude for O

    • carPathMatcherWithTransitions

      public static <O extends GeoCoordinateHolder> PathMatcher<O,Vertex,List<Vertex>> carPathMatcherWithTransitions(CarPathMatcherLayers carPathMatcherLayers)
      Creates an HMM path matcher that only matches to vertices that are accessible to cars, and that is suitable for sparse probes. However, if the observations are not close enough, they will be considered unreachable.

      Besides a sequence of MatchResults, this path matcher returns a list of transitions. A transition is a sequence of `com.here.platform.location.inmemory.graph.Vertex` objects that represents a path between `OnRoad` match results associated to two successive observations. A transition does not contain the two vertices referenced by the corresponding `OnRoad` match results.

      Consider the following example: 

       
  O1                   O2
  |                    |
  v                    v
 --V1--> --V2--> --V3-->

      The observation O1 is matched to vertex V1, and O2 to V3. Although V1 and V3 are not directly connected, the path matcher returns a transition from O1 to O2 that contains the intermediate vertices, V2 in this case.

      Internally, this method creates a PathMatcherWithFilter that uses a distance filter and a projecting interpolator to improve match results when consecutive points are close to one another.

      See also

      • PathMatcherWithFilter for more information about filtering and interpolation.
      • Filters.`distance` for a factory method to create a distance filter.
      • Interpolators.`projecting` for a factory method to create a projecting interpolator.
      Use this overload of the method when the geographical coordinate type implements GeoCoordinateHolder.
      Type Parameters:
      O - The type of observations expected by the path matcher

    • carPathMatcherWithTransitions

      public static <O> PathMatcher<O,Vertex,List<Vertex>> carPathMatcherWithTransitions(CarPathMatcherLayers carPathMatcherLayers, GeoCoordinateAdapter<O> adapter)
      Creates an HMM path matcher that only matches to vertices that are accessible to cars, and that is suitable for sparse probes. However, if the observations are not close enough, they will be considered unreachable.

      Besides a sequence of MatchResults, this path matcher returns a list of transitions. A transition is a sequence of `com.here.platform.location.inmemory.graph.Vertex` objects that represents a path between `OnRoad` match results associated to two successive observations. A transition does not contain the two vertices referenced by the corresponding `OnRoad` match results.

      Consider the following example: 

       
  O1                   O2
  |                    |
  v                    v
 --V1--> --V2--> --V3-->

      The observation O1 is matched to vertex V1, and O2 to V3. Although V1 and V3 are not directly connected, the path matcher returns a transition from O1 to O2 that contains the intermediate vertices, V2 in this case.

      Internally, this method creates a PathMatcherWithFilter that uses a distance filter and a projecting interpolator to improve match results when consecutive points are close to one another.

      See also

      • PathMatcherWithFilter for more information about filtering and interpolation.
      • Filters.`distance` for a factory method to create a distance filter.
      • Interpolators.`projecting` for a factory method to create a projecting interpolator.
      Use this overload of the method when the geographical coordinate type does not implement GeoCoordinateHolder.
      Type Parameters:
      O - The type of observations expected by the path matcher
      Parameters:
      adapter - GeoCoordinateAdapter to extract latitude and longitude for O

    • unrestrictedPathMatcher

      @Deprecated public static <O extends GeoCoordinateHolder> PathMatcher<O,Vertex,NoTransition> unrestrictedPathMatcher(Catalog optimizedMap, DataLoaderProvider cacheManager)
      Deprecated.
      Prefer new PathMatchers(optimizedMap).unrestrictedPathMatcherWithoutTransitions().
      Creates an HMM path matcher that uses default parameters and doesn't take any restriction into consideration.

      The path matcher uses the `TransitionProbabilityStrategies.directDistance` to calculate the transition probabilities of the Hidden Markov Model. Therefore, this path matcher is not recommended for sparse input observations. For sparse input observations, consider using a path matcher created by `PathMatchers.unrestrictedPathMatcherWithTransitions` instead.

      Use this overload of the method when the geographical coordinate type implements GeoCoordinateHolder.

      Type Parameters:
      O - The type of observations expected by the path matcher

    • unrestrictedPathMatcher

      @Deprecated public static <O> PathMatcher<O,Vertex,NoTransition> unrestrictedPathMatcher(Catalog optimizedMap, DataLoaderProvider cacheManager, GeoCoordinateAdapter<O> adapter)
      Deprecated.
      Prefer new PathMatchers(optimizedMap).unrestrictedPathMatcherWithoutTransitions(adapter).
      Creates an HMM path matcher that uses default parameters and doesn't take any restriction into consideration.

      The path matcher uses the `TransitionProbabilityStrategies.directDistance` to calculate the transition probabilities of the Hidden Markov Model. Therefore, this path matcher is not recommended for sparse input observations. For sparse input observations, consider using a path matcher created by `PathMatchers.unrestrictedPathMatcherWithTransitions` instead.

      Use this overload of the method when the geographical coordinate type does not implement GeoCoordinateHolder.

      Type Parameters:
      O - The type of observations expected by the path matcher
      Parameters:
      adapter - GeoCoordinateAdapter to extract latitude and longitude for O

    • unrestrictedPathMatcherWithTransitions

      @Deprecated public static <O extends GeoCoordinateHolder> PathMatcher<O,Vertex,List<Vertex>> unrestrictedPathMatcherWithTransitions(Catalog optimizedMap, DataLoaderProvider cacheManager)
      Deprecated.
      Prefer new PathMatchers(optimizedMap).unrestrictedPathMatcherWithTransitions().
      Creates an HMM path matcher that uses default parameters and doesn't take any restriction into consideration, and that is suitable for sparse probes. However, if the observations are not close enough, they will be considered unreachable.

      The path matcher uses the DistanceTransitionProbabilityStrategy to calculate the transition probabilities of the Hidden Markov Model.

      Besides a sequence of MatchResults, this path matcher returns a list of transitions. A transition is a sequence of `com.here.platform.location.inmemory.graph.Vertex` objects that represents a path between `OnRoad` match results associated to two successive observations. A transition does not contain the two vertices referenced by the corresponding `OnRoad` match results.

      Consider the following example: 

       
  O1                   O2
  |                    |
  v                    v
 --V1--> --V2--> --V3-->

      The observation O1 is matched to vertex V1, and O2 to V3. Although V1 and V3 are not directly connected, the path matcher returns a transition from O1 to O2 that contains the intermediate vertices, V2 in this case.

      Internally, this method creates a PathMatcherWithFilter that uses a distance filter and a projecting interpolator to improve match results when consecutive points are close to one another.

      See also

      • PathMatcherWithFilter for more information about filtering and interpolation.
      • Filters.`distance` for a factory method to create a distance filter.
      • Interpolators.`projecting` for a factory method to create a projecting interpolator.
      Use this overload of the method when the geographical coordinate type implements GeoCoordinateHolder.
      Type Parameters:
      O - The type of observations expected by the path matcher

    • unrestrictedPathMatcherWithTransitions

      @Deprecated public static <O> PathMatcher<O,Vertex,List<Vertex>> unrestrictedPathMatcherWithTransitions(Catalog optimizedMap, DataLoaderProvider cacheManager, GeoCoordinateAdapter<O> adapter)
      Deprecated.
      Prefer new PathMatchers(optimizedMap).unrestrictedPathMatcherWithTransitions(adapter).
      Creates an HMM path matcher that uses default parameters and doesn't take any restriction into consideration, and that is suitable for sparse probes. However, if the observations are not close enough, they will be considered unreachable.

      The path matcher uses the DistanceTransitionProbabilityStrategy to calculate the transition probabilities of the Hidden Markov Model.

      Besides a sequence of MatchResults, this path matcher returns a list of transitions. A transition is a sequence of `com.here.platform.location.inmemory.graph.Vertex` objects that represents a path between `OnRoad` match results associated to two successive observations. A transition does not contain the two vertices referenced by the corresponding `OnRoad` match results.

      Consider the following example: 

       
  O1                   O2
  |                    |
  v                    v
 --V1--> --V2--> --V3-->

      The observation O1 is matched to vertex V1, and O2 to V3. Although V1 and V3 are not directly connected, the path matcher returns a transition from O1 to O2 that contains the intermediate vertices, V2 in this case.

      Internally, this method creates a PathMatcherWithFilter that uses a distance filter and a projecting interpolator to improve match results when consecutive points are close to one another.

      See also

      • PathMatcherWithFilter for more information about filtering and interpolation.
      • Filters.`distance` for a factory method to create a distance filter.
      • Interpolators.`projecting` for a factory method to create a projecting interpolator.
      Use this overload of the method when the geographical coordinate type does not implement GeoCoordinateHolder.
      Type Parameters:
      O - The type of observations expected by the path matcher
      Parameters:
      adapter - GeoCoordinateAdapter to extract latitude and longitude for O

    • carPathMatcher

      @Deprecated public static <O extends GeoCoordinateHolder> PathMatcher<O,Vertex,NoTransition> carPathMatcher(Catalog optimizedMap, DataLoaderProvider cacheManager)
      Deprecated.
      Prefer new PathMatchers(optimizedMap).carPathMatcherWithoutTransitions().
      Creates an HMM path matcher that only matches to vertices that are accessible by cars.

      The path matcher uses the `TransitionProbabilityStrategies.directDistance` to calculate the transition probabilities of the Hidden Markov Model. Therefore, this path matcher is not recommended for sparse input observations. For sparse input observations, consider using a path matcher created by `PathMatchers.carPathMatcherWithTransitions` instead.

      Use this overload of the method when the geographical coordinate type implements GeoCoordinateHolder.

      Type Parameters:
      O - The type of observations expected by the path matcher

    • carPathMatcher

      @Deprecated public static <O> PathMatcher<O,Vertex,NoTransition> carPathMatcher(Catalog optimizedMap, DataLoaderProvider cacheManager, GeoCoordinateAdapter<O> adapter)
      Deprecated.
      Prefer new PathMatchers(optimizedMap).carPathMatcherWithoutTransitions(adapter).
      Creates an HMM path matcher that only matches to vertices that are accessible by cars.

      The path matcher uses the `TransitionProbabilityStrategies.directDistance` to calculate the transition probabilities of the Hidden Markov Model. Therefore, this path matcher is not recommended for sparse input observations. For sparse input observations, consider using a path matcher created by `PathMatchers.carPathMatcherWithTransitions` instead.

      Use this overload of the method when the geographical coordinate type does not implement GeoCoordinateHolder.

      Type Parameters:
      O - The type of observations expected by the path matcher
      Parameters:
      adapter - GeoCoordinateAdapter to extract latitude and longitude for O

    • carPathMatcherWithTransitions

      @Deprecated public static <O extends GeoCoordinateHolder> PathMatcher<O,Vertex,List<Vertex>> carPathMatcherWithTransitions(Catalog optimizedMap, DataLoaderProvider cacheManager)
      Deprecated.
      Prefer new PathMatchers(optimizedMap).carPathMatcherWithTransitions().
      Creates an HMM path matcher that only matches to vertices that are accessible to cars, and that is suitable for sparse probes. However, if the observations are not close enough, they will be considered unreachable.

      Besides a sequence of MatchResults, this path matcher returns a list of transitions. A transition is a sequence of `com.here.platform.location.inmemory.graph.Vertex` objects that represents a path between `OnRoad` match results associated to two successive observations. A transition does not contain the two vertices referenced by the corresponding `OnRoad` match results.

      Consider the following example: 

       
  O1                   O2
  |                    |
  v                    v
 --V1--> --V2--> --V3-->

      The observation O1 is matched to vertex V1, and O2 to V3. Although V1 and V3 are not directly connected, the path matcher returns a transition from O1 to O2 that contains the intermediate vertices, V2 in this case.

      Internally, this method creates a PathMatcherWithFilter that uses a distance filter and a projecting interpolator to improve match results when consecutive points are close to one another.

      See also

      • PathMatcherWithFilter for more information about filtering and interpolation.
      • Filters.`distance` for a factory method to create a distance filter.
      • Interpolators.`projecting` for a factory method to create a projecting interpolator.
      Use this overload of the method when the geographical coordinate type implements GeoCoordinateHolder.
      Type Parameters:
      O - The type of observations expected by the path matcher

    • carPathMatcherWithTransitions

      @Deprecated public static <O> PathMatcher<O,Vertex,List<Vertex>> carPathMatcherWithTransitions(Catalog optimizedMap, DataLoaderProvider cacheManager, GeoCoordinateAdapter<O> adapter)
      Deprecated.
      Prefer new PathMatchers(optimizedMap).carPathMatcherWithTransitions(adapter).
      Creates an HMM path matcher that only matches to vertices that are accessible to cars, and that is suitable for sparse probes. However, if the observations are not close enough, they will be considered unreachable.

      Besides a sequence of MatchResults, this path matcher returns a list of transitions. A transition is a sequence of `com.here.platform.location.inmemory.graph.Vertex` objects that represents a path between `OnRoad` match results associated to two successive observations. A transition does not contain the two vertices referenced by the corresponding `OnRoad` match results.

      Consider the following example: 

       
  O1                   O2
  |                    |
  v                    v
 --V1--> --V2--> --V3-->

      The observation O1 is matched to vertex V1, and O2 to V3. Although V1 and V3 are not directly connected, the path matcher returns a transition from O1 to O2 that contains the intermediate vertices, V2 in this case.

      Internally, this method creates a PathMatcherWithFilter that uses a distance filter and a projecting interpolator to improve match results when consecutive points are close to one another.

      See also

      • PathMatcherWithFilter for more information about filtering and interpolation.
      • Filters.`distance` for a factory method to create a distance filter.
      • Interpolators.`projecting` for a factory method to create a projecting interpolator.
      Use this overload of the method when the geographical coordinate type does not implement GeoCoordinateHolder.
      Type Parameters:
      O - The type of observations expected by the path matcher
      Parameters:
      adapter - GeoCoordinateAdapter to extract latitude and longitude for O