GraphHopper Distance Matrix: Triển khai Routing Engine

# Tạo thư mục chứa dữ liệu (Create a data directory)
mkdir -p ./graphhopper-data

# Khởi chạy container GraphHopper — tự động tải bản đồ OSM Việt Nam
docker run -d \
  --name graphhopper \
  -p 8989:8989 \
  -v $(pwd)/graphhopper-data:/data \
  israelhikingmap/graphhopper:latest \
  --url https://download.geofabrik.de/asia/vietnam-latest.osm.pbf \
  --host 0.0.0.0

# Theo dõi log — quá trình xử lý đồ thị lần đầu mất khoảng 5-15 phút
docker logs -f graphhopper

# Gửi yêu cầu tính toán ma trận 3×3 cho 3 địa điểm tại TP.HCM
curl -X POST http://localhost:8989/matrix \
  -H "Content-Type: application/json" \
  -d '{
    "points": [
      [106.7011, 10.7712],
      [106.7100, 10.7780],
      [106.6980, 10.7650]
    ],
    "profile": "car",
    "out_arrays": ["times", "distances"],
    "fail_fast": false
  }'

{
  "times": [[0, 320, 185], [315, 0, 410], [180, 405, 0]],
  "distances": [[0, 2100, 1350], [2050, 0, 2900], [1300, 2880, 0]],
  "info": {"took": 12, "copyrights": ["OpenStreetMap contributors"]}
}

import requests
from dataclasses import dataclass
from typing import Optional

@dataclass
class Location:
    lat: float
    lng: float
    label: Optional[str] = None

@dataclass
class DistanceMatrix:
    durations: list[list[int]]   # tính theo giây (seconds), ma trận N×N
    distances: list[list[int]]   # tính theo mét (meters), ma trận N×N

class GraphHopperClient:
    """
    Python client cho GraphHopper Distance Matrix API đạt chuẩn Production-ready.
    Tự động xử lý định dạng [lng, lat], quản lý lỗi và hỗ trợ cơ chế thử lại (retries).
    """

    def __init__(self, base_url: str = "http://localhost:8989", profile: str = "car"):
        self.base_url = base_url.rstrip("/")
        self.profile = profile
        self.session = requests.Session()
        self.session.headers.update({"Content-Type": "application/json"})

    def get_matrix(self, locations: list[Location], timeout: int = 30) -> DistanceMatrix:
        """
        Tính toán ma trận khoảng cách N×N cho danh sách các địa điểm truyền vào.

        Tham số (Args):
            locations: Danh sách đối tượng Location (chứa lat/lng).
            timeout:   Thời gian chờ tối đa cho HTTP request (tính theo giây).

        Kết quả (Returns):
            Đối tượng DistanceMatrix chứa 'durations' (giây) và 'distances' (mét).

        Ngoại lệ (Raises):
            requests.HTTPError: Xảy ra khi GraphHopper trả về lỗi HTTP.
            ValueError: Xảy ra nếu danh sách truyền vào có ít hơn 2 địa điểm.
        """
        if len(locations) < 2:
            raise ValueError("Cần tối thiểu 2 địa điểm để tính toán ma trận khoảng cách.")

        # Cẩn thận: GraphHopper ăn theo chuẩn [lng, lat] — định dạng GeoJSON
        points = [[loc.lng, loc.lat] for loc in locations]

        payload = {
            "points": points,
            "profile": self.profile,
            "out_arrays": ["times", "distances"],
            "fail_fast": False,   # Trả về kết quả cho các cặp hợp lệ ngay cả khi có cặp không tìm được đường đi
        }

        response = self.session.post(
            f"{self.base_url}/matrix",
            json=payload,
            timeout=timeout
        )
        response.raise_for_status()
        data = response.json()

        return DistanceMatrix(
            durations=data["times"],
            distances=data["distances"],
        )


# --- Khúc rải múa trình diễn cách xài (Usage example) ---

client = GraphHopperClient(base_url="http://localhost:8989", profile="car")

locations = [
    Location(lat=10.7712, lng=106.7011, label="Kho hàng (Warehouse)"),
    Location(lat=10.7780, lng=106.7100, label="Khách C (Customer A)"),
    Location(lat=10.7650, lng=106.6980, label="Khách B (Customer B)"),
]

matrix = client.get_matrix(locations)

# In ma trận thời gian di chuyển (Print duration matrix)
for i, from_loc in enumerate(locations):
    for j, to_loc in enumerate(locations):
        if i != j:
            duration_min = matrix.durations[i][j] // 60
            distance_km = matrix.distances[i][j] / 1000
            print(f"{from_loc.label} → {to_loc.label}: tốn {duration_min}min, khoảng {distance_km:.1f}km")

# Cấu hình mặc định cho xe ô tô (car)
curl -X POST http://localhost:8989/matrix \
  -d '{"points": [[106.7011, 10.7712], [106.7100, 10.7780]], "profile": "car", "out_arrays": ["times", "distances"]}'

# Cấu hình cho xe máy (motorcycle)
curl -X POST http://localhost:8989/matrix \
  -d '{"points": [[106.7011, 10.7712], [106.7100, 10.7780]], "profile": "motorcycle", "out_arrays": ["times", "distances"]}'

# Cấu hình cho xe đạp (bike)
curl -X POST http://localhost:8989/matrix \
  -d '{"points": [[106.7011, 10.7712], [106.7100, 10.7780]], "profile": "bike", "out_arrays": ["times", "distances"]}'

# Cấu hình cho người đi bộ (foot)
curl -X POST http://localhost:8989/matrix \
  -d '{"points": [[106.7011, 10.7712], [106.7100, 10.7780]], "profile": "foot", "out_arrays": ["times", "distances"]}'

{
  "points": [[106.7011, 10.7712], [106.7100, 10.7780]],
  "profile": "car",
  "out_arrays": ["times", "distances"],
  "custom_model": {
    "speed": [
      {
        "if": "road_class == MOTORWAY",
        "limit_to": 90
      },
      {
        "if": "road_environment == TUNNEL",
        "multiply_by": 0
      }
    ],
    "priority": [
      {
        "if": "max_weight < 10",
        "multiply_by": 0
      },
      {
        "if": "road_class == RESIDENTIAL",
        "multiply_by": 0.3
      }
    ]
  }
}

{
  "custom_model": {
    "priority": [
      {
        "if": "toll == ALL",
        "multiply_by": 0
      }
    ]
  }
}

import com.graphhopper.GraphHopper;
import com.graphhopper.GraphHopperConfig;
import com.graphhopper.config.CHProfile;
import com.graphhopper.config.Profile;
import com.graphhopper.routing.matrix.MatrixResult;

public class EmbeddedGraphHopperMatrix {

    private final GraphHopper hopper;

    public EmbeddedGraphHopperMatrix(String osmFile, String graphLocation) {
        GraphHopperConfig config = new GraphHopperConfig();
        config.putObject("graph.location", graphLocation);

        this.hopper = new GraphHopper();
        this.hopper.setOSMFile(osmFile);
        this.hopper.setGraphHopperLocation(graphLocation);
        this.hopper.setProfiles(
            new Profile("car").setVehicle("car").setWeighting("fastest"),
            new Profile("truck").setVehicle("car").setWeighting("custom")
        );
        this.hopper.getCHPreparationHandler()
            .setCHProfiles(new CHProfile("car"));
        this.hopper.importOrLoad();
    }

    // Phương thức tiện ích sử dụng GHMatrixAPI cho các tính toán N×N
    // Tham khảo chi tiết tại: https://github.com/graphhopper/graphhopper/tree/master/web-api
    public void shutdown() {
        hopper.close();
    }
}

import h3
import json
import redis
from graphhopper_client import GraphHopperClient, Location, DistanceMatrix

class CachedDistanceMatrix:
    """
    Tầng Caching cho GraphHopper Distance Matrix dựa trên chỉ mục H3 và Redis.
    Tỷ lệ cache hit có thể đạt trên 90% khi hệ thống vận hành ổn định.
    """

    H3_RESOLUTION = 9        # Mỗi ô H3 có bán kính ~174m (tương đương một khối nhà phố)
    CACHE_TTL_DAYS = 30      # Dữ liệu đường xá ít thay đổi nên lưu cache 30 ngày

    def __init__(self, gh_client: GraphHopperClient, redis_client: redis.Redis):
        self.gh = gh_client
        self.redis = redis_client

    def _h3_key(self, loc_a: Location, loc_b: Location) -> str:
        """Tạo cache key chuẩn hóa từ hai H3 cell ID."""
        cell_a = h3.latlng_to_cell(loc_a.lat, loc_a.lng, self.H3_RESOLUTION)
        cell_b = h3.latlng_to_cell(loc_b.lat, loc_b.lng, self.H3_RESOLUTION)
        # Sắp xếp hai cell ID để đảm bảo tính đối xứng (cặp A->B và B->A dùng chung một cache key)
        return f"gh:matrix:{min(cell_a, cell_b)}:{max(cell_a, cell_b)}"

    def get_pair(self, origin: Location, dest: Location) -> dict:
        """
        Lấy thông tin khoảng cách và thời gian cho một cặp địa điểm từ Redis cache.
        Kết quả (Returns): {"duration_s": int, "distance_m": int}
        """
        cache_key = self._h3_key(origin, dest)
        cached = self.redis.get(cache_key)

        if cached:
            return json.loads(cached)

        # Khi cache miss: gọi GraphHopper API để tính toán
        matrix = self.gh.get_matrix([origin, dest])
        result = {
            "duration_s": matrix.durations[0][1],
            "distance_m": matrix.distances[0][1],
        }

        self.redis.setex(
            cache_key,
            self.CACHE_TTL_DAYS * 86400,
            json.dumps(result)
        )
        return result

    def get_matrix_cached(self, locations: list[Location]) -> DistanceMatrix:
        """
        Lấy ma trận N×N bằng cách kết hợp dữ liệu từ Redis cache và gọi GraphHopper cho các cặp bị miss.
        """
        n = len(locations)
        durations = [[0] * n for _ in range(n)]
        distances = [[0] * n for _ in range(n)]
        missing_pairs = []

        # Kiểm tra cache cho tất cả các cặp địa điểm
        cache_keys = {}
        for i in range(n):
            for j in range(n):
                if i == j:
                    continue
                key = self._h3_key(locations[i], locations[j])
                cached = self.redis.get(key)
                if cached:
                    data = json.loads(cached)
                    durations[i][j] = data["duration_s"]
                    distances[i][j] = data["distance_m"]
                else:
                    missing_pairs.append((i, j))

        if missing_pairs:
            # Gửi request tính toán các cặp bị thiếu qua GraphHopper
            missing_locs = list({idx for pair in missing_pairs for idx in pair})
            loc_subset = [locations[i] for i in missing_locs]
            sub_matrix = self.gh.get_matrix(loc_subset)

            idx_map = {orig_idx: sub_idx for sub_idx, orig_idx in enumerate(missing_locs)}

            for i, j in missing_pairs:
                si, sj = idx_map[i], idx_map[j]
                dur = sub_matrix.durations[si][sj]
                dist = sub_matrix.distances[si][sj]
                durations[i][j] = dur
                distances[i][j] = dist

                # Lưu thông tin tính được vào Redis cache
                key = self._h3_key(locations[i], locations[j])
                self.redis.setex(
                    key,
                    self.CACHE_TTL_DAYS * 86400,
                    json.dumps({"duration_s": dur, "distance_m": dist})
                )

        return DistanceMatrix(durations=durations, distances=distances)

package matrix

import (
	"context"
	"encoding/json"
	"fmt"
	"time"

	"github.com/redis/go-redis/v9"
	"github.com/uber/h3-go/v4"
)

type Location struct {
	Lat float64 `json:"lat"`
	Lng float64 `json:"lng"`
}

type CachedMatrix struct {
	gh    *GraphHopperClient
	redis *redis.Client
}

func (c *CachedMatrix) h3Key(a, b Location) string {
	cellA := h3.LatLngToCell(h3.NewLatLng(a.Lat, a.Lng), 9)
	cellB := h3.LatLngToCell(h3.NewLatLng(b.Lat, b.Lng), 9)

	minCell, maxCell := cellA, cellB
	if cellB < cellA {
		minCell, maxCell = cellB, cellA
	}
	return fmt.Sprintf("gh:matrix:%x:%x", minCell, maxCell)
}

func (c *CachedMatrix) GetPair(ctx context.Context, origin, dest Location) (map[string]int, error) {
	key := c.h3Key(origin, dest)
	cached, err := c.redis.Get(ctx, key).Result()
	if err == nil {
		var result map[string]int
		json.Unmarshal([]byte(cached), &result)
		return result, nil
	}

	// Xử lý khi miss cache, gọi fallback tới API HTTP của GraphHopper
	matrix, err := c.gh.GetMatrix([]Location{origin, dest})
	if err != nil {
		return nil, err
	}
	
	result := map[string]int{
		"duration_s": matrix.Durations[0][1],
		"distance_m": matrix.Distances[0][1],
	}

	data, _ := json.Marshal(result)
	c.redis.SetEx(ctx, key, data, 30*24*time.Hour)
	return result, nil
}