하드웨어는 한 가지의 데이터를 단 한번만 말한다.

{
  "sourceId": "sensor-01",
  "distanceM": 1300.0,
  "value": 0.42,
  "eventTime": "2026-09-01T10:15:30+09:00"
}

기준점에서 1,300m 떨어진 위치에서 이벤트 발생

위도: ?
경도: ?
주변 설명: ?

거리축
0m ───── 500m ───── 1,000m ───── 1,500m
│         │           │             │
지도상의 기준점과 경로 좌표를 연결

public long createEvent(EventRequest request) {
    GeoPoint point = resolver.resolve(request.routeId(), request.distanceM());

    return eventRepository.insert(
        request,
        point.latitude(),
        point.longitude()
    );
}

public record SensorEvent(
    long id,
    String routeId,
    double distanceM,
    double value,
    Instant eventTime
) {}

이벤트 저장
  └─ routeId, distanceM, value, eventTime

이벤트 조회
  └─ 최신 기준점 조회
  └─ distanceM으로 좌표 계산
  └─ 지도 응답에 latitude, longitude 추가

CREATE TABLE route_reference_point (
    id                    bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
    route_id              varchar(100) NOT NULL,
    distance_m            double precision NOT NULL,
    latitude              double precision,
    longitude             double precision,
    description           varchar(200),
    reference_kind        varchar(30) NOT NULL,
    distance_source       varchar(30) NOT NULL,
    coordinate_source     varchar(30) NOT NULL,
    created_at            timestamp NOT NULL,
    updated_at            timestamp NOT NULL
);

일반 이벤트 데이터
  └─ 센서 값과 시간

위치 기준 데이터
  └─ 좌표, 주소, 경로 형상

P.distance = 1,000m
Q.distance = 1,600m
D.distance = 1,300m

ratio = (D - P.distance) / (Q.distance - P.distance)

latitude  = P.latitude  + (Q.latitude  - P.latitude)  × ratio
longitude = P.longitude + (Q.longitude - P.longitude) × ratio

public record GeoPoint(double latitude, double longitude) {}

public record ReferencePoint(
    double distanceM,
    Double latitude,
    Double longitude
) {}

public static GeoPoint interpolate(
    ReferencePoint previous,
    ReferencePoint next,
    double distanceM
) {
    if (previous.latitude() == null || previous.longitude() == null
        || next.latitude() == null || next.longitude() == null) {
        return null;
    }

    double span = next.distanceM() - previous.distanceM();
    if (span < 0) {
        return null;
    }
    if (span == 0) {
        return new GeoPoint(previous.latitude(), previous.longitude());
    }

    double ratio = (distanceM - previous.distanceM()) / span;
    return new GeoPoint(
        previous.latitude()
            + (next.latitude() - previous.latitude()) * ratio,
        previous.longitude()
            + (next.longitude() - previous.longitude()) * ratio
    );
}

ratio = 0    → previous 위치
ratio = 0.5  → 두 점의 중간
ratio = 1    → next 위치

기준점 ───────────── 기준점
          실제 경로는 굴곡

두 끝점만 사용하면 실제 경로와 지도상의 직선이 달라진다.

public final class GeoDistance {

    private static final double EARTH_RADIUS_M = 6_371_000.0;

    private GeoDistance() {}

    public static double haversine(
        double lat1,
        double lon1,
        double lat2,
        double lon2
    ) {
        double phi1 = Math.toRadians(lat1);
        double phi2 = Math.toRadians(lat2);
        double deltaPhi = Math.toRadians(lat2 - lat1);
        double deltaLambda = Math.toRadians(lon2 - lon1);

        double a = Math.sin(deltaPhi / 2) * Math.sin(deltaPhi / 2)
            + Math.cos(phi1) * Math.cos(phi2)
            * Math.sin(deltaLambda / 2) * Math.sin(deltaLambda / 2);

        return 2 * EARTH_RADIUS_M * Math.asin(Math.sqrt(a));
    }
}

A.distance = 1,000m
B.distance = 1,600m

A에서 B까지 지도 경로 길이 = 500m

X.distance = 1,000 + (1,600 - 1,000) × 0.4
           = 1,240m

pathRatio = A에서 X까지의 폴리라인 길이 / A에서 B까지의 폴리라인 길이
distanceX = A.distance + (B.distance - A.distance) × pathRatio

void recalculateDerivedDistances(List<ReferencePoint> points) {
    List<Integer> anchors = new ArrayList<>();

    for (int i = 0; i < points.size(); i++) {
        if (isMeasuredDistance(points.get(i))) {
            anchors.add(i);
        }
    }

    for (int pair = 0; pair < anchors.size() - 1; pair++) {
        int start = anchors.get(pair);
        int end = anchors.get(pair + 1);

        double pathTotal = pathLength(points, start, end);
        if (pathTotal <= 0) {
            continue;
        }

        double startDistance = points.get(start).distanceM();
        double distanceSpan = points.get(end).distanceM() - startDistance;
        double pathSoFar = 0;

        for (int i = start + 1; i < end; i++) {
            pathSoFar += segmentLength(points.get(i - 1), points.get(i));
            double ratio = pathSoFar / pathTotal;
            double derivedDistance = startDistance + distanceSpan * ratio;

            updateDerivedDistance(
                points.get(i),
                roundToTenth(derivedDistance)
            );
        }
    }
}

이벤트 N개 × 기준점 질의 여러 번

public final class PositionResolver {

    private final ReferencePointRepository repository;

    public EventPosition resolveOne(String routeId, double distanceM) {
        return EventPosition.from(
            repository.findPrevious(routeId, distanceM),
            repository.findNext(routeId, distanceM),
            repository.findNearestDescription(routeId, distanceM),
            distanceM
        );
    }

    public RoutePositionIndex loadIndex(String routeId) {
        return new RoutePositionIndex(repository.findAll(routeId));
    }
}

Map<String, List<SensorEvent>> eventsByRoute = events.stream()
    .filter(event -> event.distanceM() >= 0)
    .collect(Collectors.groupingBy(SensorEvent::routeId));

eventsByRoute.forEach((routeId, routeEvents) -> {
    RoutePositionIndex index = resolver.loadIndex(routeId);

    for (SensorEvent event : routeEvents) {
        eventPositions.put(
            event.id(),
            index.resolve(event.distanceM())
        );
    }
});

SELECT *
FROM route_reference_point
WHERE route_id = :routeId
  AND description IS NOT NULL
ORDER BY
    ABS(distance_m - :distanceM),
    distance_m,
    id
LIMIT 1;

ReferencePoint nearest(double distanceM) {
    ReferencePoint best = null;
    double bestGap = Double.MAX_VALUE;

    for (ReferencePoint point : points) {
        double gap = Math.abs(point.distanceM() - distanceM);

        if (gap < bestGap) {
            best = point;
            bestGap = gap;
        }
    }

    return best;
}

@Test
void indexAndQueryChooseTheSamePosition() {
    EventPosition fromQuery =
        queryResolver.resolveOne("route-a", 150.0);

    EventPosition fromIndex = indexResolver
        .loadIndex("route-a")
        .resolve(150.0);

    assertThat(fromIndex).isEqualTo(fromQuery);
}

비율 = 측정 거리 차이 / 폴리라인 경로 길이

Optional<String> validateLengthConstraint(
    ReferencePoint neighbour,
    double distanceM,
    double latitude,
    double longitude
) {
    double groundDistance = GeoDistance.haversine(
        neighbour.latitude(),
        neighbour.longitude(),
        latitude,
        longitude
    );
    double routeDistance = Math.abs(
        distanceM - neighbour.distanceM()
    );

    if (groundDistance <= routeDistance + TOLERANCE_M) {
        return Optional.empty();
    }

    return Optional.of(
        "좌표 사이의 직선거리가 거리축의 차이보다 큽니다. "
            + "거리와 좌표를 확인하세요."
    );
}

public static int findNearestSegment(
    List<GeoPoint> vertices,
    double latitude,
    double longitude
) {
    if (vertices.size() < 2) {
        return -1;
    }

    int bestIndex = 0;
    double bestOffset = Double.MAX_VALUE;

    double metersPerLon = 111_320.0
        * Math.cos(Math.toRadians(latitude));
    double metersPerLat = 110_540.0;

    for (int i = 0; i < vertices.size() - 1; i++) {
        GeoPoint from = vertices.get(i);
        GeoPoint to = vertices.get(i + 1);

        double ax = (from.longitude() - longitude) * metersPerLon;
        double ay = (from.latitude() - latitude) * metersPerLat;
        double bx = (to.longitude() - longitude) * metersPerLon;
        double by = (to.latitude() - latitude) * metersPerLat;

        double vx = bx - ax;
        double vy = by - ay;
        double lengthSquared = vx * vx + vy * vy;

        double t = lengthSquared == 0
            ? 0
            : Math.max(
                0,
                Math.min(1, -(ax * vx + ay * vy) / lengthSquared)
            );

        double offset = Math.hypot(ax + t * vx, ay + t * vy);
        if (offset < bestOffset) {
            bestOffset = offset;
            bestIndex = i;
        }
    }

    return bestIndex;
}

입력한 거리 순서와 지도상의 위치 순서가 다릅니다.
저장하면 경로가 해당 지점에서 뒤로 꺾일 수 있습니다.
좌표와 거리값을 확인한 뒤 다시 저장하세요.

-- 위험한 방식
WHERE has_coordinates = TRUE
  AND is_route_vertex = TRUE

WHERE latitude IS NOT NULL
  AND longitude IS NOT NULL

12.04m → 12.0m
12.05m → 12.1m

List<ReferencePoint> candidates =
    repository.findLocated(routeId).stream()
        .filter(point ->
            excludedId == null || point.id() != excludedId
        )
        .toList();

if (point.distanceSource() == DistanceSource.DERIVED) {
    updateDerivedDistance(point);
}

boolean distanceChanged =
    Math.abs(oldDistance - newDistance) >= 0.05;
boolean hasCoordinates =
    latitude != null && longitude != null;

if (distanceChanged && hasCoordinates) {
    recalculateDerivedDistances(routeId);
}