第16章 - 线性参考系统

if (! (linearGeom instanceof Lineal))
    throw new IllegalArgumentException("Lineal geometry is required");

public class LinearLocation implements Comparable {
    private int componentIndex;     // 第几个线部件（MultiLineString 的下标）
    private int segmentIndex;       // 部件内第几段（顶点 i → i+1）
    private double segmentFraction; // 段内比例 [0, 1]
}

private void normalize() {
    if (segmentFraction < 0.0) segmentFraction = 0.0;
    if (segmentFraction > 1.0) segmentFraction = 1.0;
    if (componentIndex < 0) {
        componentIndex = 0;
        segmentIndex = 0;
        segmentFraction = 0.0;
    }
    if (segmentIndex < 0) {
        segmentIndex = 0;
        segmentFraction = 0.0;
    }
    if (segmentFraction == 1.0) {
        segmentFraction = 0.0;
        segmentIndex += 1;
    }
}

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.linearref.LinearLocation;
import org.locationtech.jts.linearref.LocationIndexedLine;

public class LinearLocationDemo {
    public static void main(String[] args) throws Exception {
        Geometry line = new WKTReader().read(
            "LINESTRING (0 0, 10 0, 20 0, 30 0)");
        LocationIndexedLine indexedLine = new LocationIndexedLine(line);

        LinearLocation l0 = indexedLine.indexOf(new Coordinate(0, 0));
        LinearLocation l5 = indexedLine.indexOf(new Coordinate(5, 0));
        LinearLocation l10 = indexedLine.indexOf(new Coordinate(10, 0));
        LinearLocation l25 = indexedLine.indexOf(new Coordinate(25, 0));

        System.out.println("l0=" + l0);
        System.out.println("l5=" + l5);
        System.out.println("l10=" + l10);
        System.out.println("l25=" + l25);
        System.out.println("l5 与 l0 同段=" + l5.isOnSameSegment(l0));
        System.out.println("l5 与 l10 同段=" + l5.isOnSameSegment(l10));
        System.out.println("l5 坐标=" + l5.getCoordinate(line));
        System.out.println("l10 是顶点=" + l10.isVertex());
        System.out.println("l5 在 l10 之前=" + (l5.compareTo(l10) < 0));
        System.out.println("截取 l5~l25=" + indexedLine.extractLine(l5, l25));
    }
}

public class LengthIndexedLine {
    public LengthIndexedLine(Geometry linearGeom);
    public double getStartIndex();   // 恒为 0
    public double getEndIndex();     // linearGeom.getLength()
    public boolean isValidIndex(double index);
    public double clampIndex(double index);
}

public double indexOf(Coordinate pt);          // 最近位置的里程
public double project(Coordinate pt);          // 与 indexOf 完全相同（别名）
public double indexOfAfter(Coordinate pt, double minIndex);  // 里程 >= minIndex 的最近位置

public Coordinate extractPoint(double index);
public Coordinate extractPoint(double index, double offsetDistance);

// LINESTRING (0 0, 20 20)，方向从左下到右上
LengthIndexedLine line = new LengthIndexedLine(
    new WKTReader().read("LINESTRING (0 0, 20 20)"));
System.out.println(line.extractPoint(0, 1));    // (-0.7071, 0.7071) 左侧
System.out.println(line.extractPoint(0, -1));   // (0.7071, -0.7071) 右侧

public Geometry extractLine(double startIndex, double endIndex);

Geometry line = new WKTReader().read(
    "MULTILINESTRING ((0 0, 10 0), (20 0, 25 0, 30 0))");
LengthIndexedLine lil = new LengthIndexedLine(line);
System.out.println(lil.extractLine(-9, -1));
System.out.println(lil.extractLine(-100, 100));
System.out.println(lil.extractLine(10, -1));

public double[] indicesOf(Geometry subLine);

Geometry route = new WKTReader().read(
    "MULTILINESTRING ((0 0, 10 0), (20 0, 25 0, 30 0))");
Geometry sub = new WKTReader().read(
    "MULTILINESTRING ((1 0, 10 0), (20 0, 25 0))");
LengthIndexedLine lil = new LengthIndexedLine(route);
double[] idx = lil.indicesOf(sub);
System.out.println(java.util.Arrays.toString(idx));   // [1.0, 15.0]

import java.util.Arrays;

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.linearref.LengthIndexedLine;

public class LengthIndexedLineDemo {
    public static void main(String[] args) throws Exception {
        WKTReader reader = new WKTReader();
        Geometry line = reader.read("LINESTRING (0 0, 10 0, 10 10)");
        LengthIndexedLine lil = new LengthIndexedLine(line);

        System.out.println("总长=" + line.getLength()
            + ", start=" + lil.getStartIndex() + ", end=" + lil.getEndIndex());
        System.out.println("project(5,5)=" + lil.project(new Coordinate(5, 5)));
        System.out.println("project(15,5)=" + lil.project(new Coordinate(15, 5)));
        System.out.println("extractPoint(5)=" + lil.extractPoint(5));
        System.out.println("extractPoint(15)=" + lil.extractPoint(15));
        System.out.println("extractLine(5,15)=" + lil.extractLine(5, 15));
        System.out.println("extractLine(15,5)=" + lil.extractLine(15, 5));

        Geometry sub = reader.read("LINESTRING (2 0, 10 5)");
        System.out.println("indicesOf=" + Arrays.toString(lil.indicesOf(sub)));
        System.out.println("isValid(-1)=" + lil.isValidIndex(-1)
            + ", clamp(-1)=" + lil.clampIndex(-1));
    }
}

public class LocationIndexedLine {
    public LocationIndexedLine(Geometry linearGeom);
    public Coordinate extractPoint(LinearLocation index);
    public Coordinate extractPoint(LinearLocation index, double offsetDistance);
    public Geometry extractLine(LinearLocation startIndex, LinearLocation endIndex);
    public LinearLocation indexOf(Coordinate pt);
    public LinearLocation project(Coordinate pt);
    public LinearLocation indexOfAfter(Coordinate pt, LinearLocation minIndex);
    public LinearLocation[] indicesOf(Geometry subLine);
    public LinearLocation getStartIndex();
    public LinearLocation getEndIndex();
    public boolean isValidIndex(LinearLocation index);
    public LinearLocation clampIndex(LinearLocation index);
}

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.linearref.LinearLocation;
import org.locationtech.jts.linearref.LocationIndexedLine;

public class LocationIndexedLineDemo {
    public static void main(String[] args) throws Exception {
        Geometry line = new WKTReader().read(
            "LINESTRING (0 0, 10 0, 20 0, 30 0)");
        LocationIndexedLine indexedLine = new LocationIndexedLine(line);

        LinearLocation start = indexedLine.getStartIndex();
        LinearLocation end = indexedLine.getEndIndex();
        System.out.println("start=" + start + ", end=" + end);

        LinearLocation l5 = indexedLine.indexOf(new Coordinate(5, 0));
        LinearLocation l10 = indexedLine.indexOf(new Coordinate(10, 0));
        System.out.println("位置(5,0)=" + l5 + ", 坐标=" + indexedLine.extractPoint(l5));

        // 位置偏移：左侧 2 个单位
        System.out.println("左侧偏移=" + indexedLine.extractPoint(l5, 2.0));

        // 截取到终点
        System.out.println("截取 5 到终点=" + indexedLine.extractLine(l5, end));

        // 越界位置 clamp
        LinearLocation beyond = new LinearLocation(0, 99, 0.0);
        System.out.println("越界=" + beyond + ", clamp 后=" + indexedLine.clampIndex(beyond));
        System.out.println("isValid(越界)=" + indexedLine.isValidIndex(beyond));
    }
}

LengthIndexedLine lil = new LengthIndexedLine(line);
LocationIndexedLine loc = new LocationIndexedLine(line);

// 长度 -> 位置
double chainage = 1234.5;
LinearLocation location = LengthLocationMap.getLocation(line, chainage);
// 位置 -> 长度
double back = LengthLocationMap.getLength(line, location);
System.out.println(chainage + " -> " + location + " -> " + back);

LengthIndexedLine lil = new LengthIndexedLine(
    new WKTReader().read("LINESTRING (0 0, 100 0)"));
System.out.println(lil.extractPoint(1234.5));   // (100.0, 0.0, NaN)

public class LengthLocationMap {
    public static LinearLocation getLocation(Geometry linearGeom, double length);
    public static LinearLocation getLocation(Geometry linearGeom, double length, boolean resolveLower);
    public static double getLength(Geometry linearGeom, LinearLocation loc);

    public LinearLocation getLocation(double length);
    public LinearLocation getLocation(double length, boolean resolveLower);
    public double getLength(LinearLocation loc);
}

Geometry line = reader.read(
    "MULTILINESTRING ((0 0, 10 0), (20 0, 25 0, 30 0))");
LengthLocationMap map = new LengthLocationMap(line);
System.out.println("loc@0=" + map.getLocation(0));
System.out.println("loc@10=" + map.getLocation(10));
System.out.println("loc@10(resolveLower=false)=" + map.getLocation(10, false));
System.out.println("loc@25=" + map.getLocation(25));
System.out.println("loc@-5=" + map.getLocation(-5));
System.out.println("length(loc@15)=" + map.getLength(map.getLocation(15)));

public class LinearIterator {
    public LinearIterator(Geometry linear);
    public LinearIterator(Geometry linear, LinearLocation start);
    public LinearIterator(Geometry linearGeom, int componentIndex, int vertexIndex);

    public boolean hasNext();
    public void next();
    public boolean isEndOfLine();
    public int getComponentIndex();
    public int getVertexIndex();
    public LineString getLine();
    public Coordinate getSegmentStart();
    public Coordinate getSegmentEnd();   // 部件终点时返回 null
}

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.linearref.LinearIterator;

public class LinearIteratorDemo {
    public static void main(String[] args) throws Exception {
        Geometry line = new WKTReader().read(
            "MULTILINESTRING ((0 0, 10 0), (20 0, 30 0))");
        LinearIterator it = new LinearIterator(line);
        while (it.hasNext()) {
            if (it.isEndOfLine()) {
                System.out.println("部件终点 comp=" + it.getComponentIndex()
                    + " vertex=" + it.getVertexIndex());
            } else {
                Coordinate p0 = it.getSegmentStart();
                Coordinate p1 = it.getSegmentEnd();
                System.out.println("段 comp=" + it.getComponentIndex()
                    + " v=" + it.getVertexIndex() + " " + p0 + "->" + p1);
            }
            it.next();
        }
    }
}

import java.util.ArrayList;
import java.util.List;

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.linearref.LinearIterator;

public class SegmentStatsDemo {
    public static void main(String[] args) throws Exception {
        Geometry line = new WKTReader().read(
            "MULTILINESTRING ((0 0, 10 0, 10 10), (30 0, 40 0))");
        LinearIterator it = new LinearIterator(line);

        double total = 0;
        int segmentCount = 0;
        List<Double> lengths = new ArrayList<Double>();
        while (it.hasNext()) {
            if (!it.isEndOfLine()) {
                double len = it.getSegmentStart().distance(it.getSegmentEnd());
                total += len;
                segmentCount++;
                lengths.add(len);
            }
            it.next();
        }
        System.out.println("段数=" + segmentCount + ", 总长=" + total);
        System.out.println("各段长度=" + lengths);
        System.out.println("geometry.length=" + line.getLength());
    }
}

class ExtractLineByLocation {
    public static Geometry extract(Geometry line, LinearLocation start, LinearLocation end);
    public Geometry extract(LinearLocation start, LinearLocation end) {
        if (end.compareTo(start) < 0) {
            return reverse(computeLinear(end, start));  // 反向截取
        }
        return computeLinear(start, end);
    }
}

double[] idx = lil.indicesOf(subLine);
Geometry candidate = lil.extractLine(idx[0], idx[1]);
boolean consistent = candidate.equalsExact(subLine.norm(), 1e-6)
    || candidate.norm().equalsExact(subLine.norm(), 1e-6);
System.out.println("子线一致=" + consistent);

import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.linearref.LengthIndexedLine;

public class ExtractLineDemo {
    public static void main(String[] args) throws Exception {
        WKTReader reader = new WKTReader();
        Geometry route = reader.read("LINESTRING (0 0, 10 0, 10 10, 20 10)");
        LengthIndexedLine lil = new LengthIndexedLine(route);

        System.out.println("全长=" + lil.getEndIndex());
        System.out.println("0~5=" + lil.extractLine(0, 5));
        System.out.println("5~15=" + lil.extractLine(5, 15));
        System.out.println("15~5=" + lil.extractLine(15, 5));
        System.out.println("10~10=" + lil.extractLine(10, 10));

        Geometry sub = reader.read("LINESTRING (12 0, 12 6)");
        double[] idx = lil.indicesOf(sub);
        System.out.println("子线里程=" + java.util.Arrays.toString(idx));
    }
}

public class LinearGeometryBuilder {
    public LinearGeometryBuilder(GeometryFactory geomFact);
    public void setIgnoreInvalidLines(boolean ignoreInvalidLines);
    public void setFixInvalidLines(boolean fixInvalidLines);
    public void add(Coordinate pt);                       // 允许重复点
    public void add(Coordinate pt, boolean allowRepeatedPoints);
    public void endLine();
    public Coordinate getLastCoordinate();
    public Geometry getGeometry();
}

import java.util.ArrayList;
import java.util.List;

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.linearref.LengthIndexedLine;
import org.locationtech.jts.linearref.LinearGeometryBuilder;

public class StationPointsDemo {
    public static void main(String[] args) throws Exception {
        Geometry route = new WKTReader().read("LINESTRING (0 0, 10 0, 20 0)");
        LengthIndexedLine lil = new LengthIndexedLine(route);
        GeometryFactory gf = new GeometryFactory();

        // 每 5 个单位一个点
        List<Coordinate> points = new ArrayList<Coordinate>();
        for (double d = 0; d <= lil.getEndIndex(); d += 5.0) {
            points.add(lil.extractPoint(d));
        }
        System.out.println("点数=" + points.size());
        System.out.println("点=" + points);

        // 用 LinearGeometryBuilder 沿线构造折线（含偏移）
        LinearGeometryBuilder builder = new LinearGeometryBuilder(gf);
        builder.add(lil.extractPoint(0));
        builder.add(lil.extractPoint(10));
        builder.add(lil.extractPoint(20));
        System.out.println("构造线=" + builder.getGeometry());
    }
}

import java.util.ArrayList;
import java.util.List;

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.linearref.LinearIterator;

public class DensifyByDistance {
    /** 沿线每 interval 距离取一个点，包含起点与终点 */
    public static List<Coordinate> sample(Geometry line, double interval) {
        List<Coordinate> result = new ArrayList<Coordinate>();
        LinearIterator it = new LinearIterator(line);
        double next = 0.0;          // 下一个采样点的里程
        double walked = 0.0;        // 已累计里程

        while (it.hasNext()) {
            if (!it.isEndOfLine()) {
                Coordinate p0 = it.getSegmentStart();
                Coordinate p1 = it.getSegmentEnd();
                double segLen = p0.distance(p1);
                while (next <= walked + segLen + 1e-12) {
                    if (segLen == 0) break;
                    double frac = (next - walked) / segLen;
                    result.add(new Coordinate(
                        p0.x + (p1.x - p0.x) * frac,
                        p0.y + (p1.y - p0.y) * frac));
                    next += interval;
                }
                walked += segLen;
            }
            it.next();
        }
        return result;
    }

    public static void main(String[] args) throws Exception {
        Geometry line = new WKTReader().read("LINESTRING (0 0, 10 0, 10 10)");
        System.out.println(sample(line, 4.0));
    }
}

// 不推荐：沿急弯偏移会自交
for (double d = 0; d <= lil.getEndIndex(); d += 1.0) {
    builder.add(lil.extractPoint(d, 10.0));
}

// 推荐：用 OffsetCurve（第 10 章）
Geometry offset = org.locationtech.jts.operation.buffer.OffsetCurve.getCurve(line, 10.0);

public final class Chainage {
    private Chainage() { }

    /** 米 -> 桩号，例如 12345.6 -> "K12+345.60" */
    public static String format(double metres) {
        if (Double.isNaN(metres)) return "K?";
        if (metres < 0) return "-" + format(-metres);
        long km = (long) Math.floor(metres / 1000.0);
        double rest = metres - km * 1000.0;
        return String.format("K%d+%06.2f", km, rest);
    }

    /** 桩号 -> 米，例如 "K12+345.60" -> 12345.6 */
    public static double parse(String chainage) {
        String s = chainage.trim().toUpperCase();
        if (!s.startsWith("K")) {
            throw new IllegalArgumentException("桩号必须以 K 开头: " + chainage);
        }
        int plus = s.indexOf('+');
        if (plus < 0) {
            throw new IllegalArgumentException("桩号缺少 +: " + chainage);
        }
        double km = Double.parseDouble(s.substring(1, plus));
        double m = Double.parseDouble(s.substring(plus + 1));
        return km * 1000.0 + m;
    }

    public static void main(String[] args) {
        System.out.println(format(12345.6));      // K12+345.60
        System.out.println(format(0));            // K0+000.00
        System.out.println(format(999.99));       // K0+999.99
        System.out.println(format(1234567.89));   // K1234+567.89
        System.out.println(parse("K12+345.60"));  // 12345.6
    }
}

import java.util.ArrayList;
import java.util.List;

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.geom.Point;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.linearref.LengthIndexedLine;

public class EventLocator {
    static final class Event {
        final String id;
        final double chainage;   // 米
        Event(String id, double chainage) {
            this.id = id;
            this.chainage = chainage;
        }
    }

    public static void main(String[] args) throws Exception {
        Geometry route = new WKTReader().read(
            "LINESTRING (0 0, 100 0, 100 100, 200 100)");
        LengthIndexedLine lil = new LengthIndexedLine(route);
        GeometryFactory gf = new GeometryFactory();

        List<Event> events = new ArrayList<Event>();
        events.add(new Event("桥梁-1", 150));
        events.add(new Event("事故-1", 250));
        events.add(new Event("服务区-1", 400));

        System.out.println("路线总长=" + lil.getEndIndex());
        for (Event e : events) {
            boolean valid = lil.isValidIndex(e.chainage);
            double clamped = lil.clampIndex(e.chainage);
            Point p = gf.createPoint(lil.extractPoint(clamped));
            System.out.println(e.id + " 桩号=" + e.chainage
                + " 有效=" + valid + " 坐标=" + p);
        }
    }
}

import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.linearref.LengthIndexedLine;

public class IntervalEventDemo {
    public static void main(String[] args) throws Exception {
        Geometry route = new WKTReader().read("LINESTRING (0 0, 100 0, 100 100)");
        LengthIndexedLine lil = new LengthIndexedLine(route);

        double[][] intervals = { {0, 100}, {150, 250}, {50, 180} };
        for (double[] iv : intervals) {
            Geometry seg = lil.extractLine(iv[0], iv[1]);
            System.out.println("区间 " + iv[0] + "~" + iv[1]
                + " 长度=" + seg.getLength() + " 几何=" + seg);
        }
    }
}

import java.util.ArrayList;
import java.util.List;

import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.linearref.LengthIndexedLine;

public class BucketStatsDemo {
    public static void main(String[] args) throws Exception {
        Geometry route = new WKTReader().read("LINESTRING (0 0, 1000 0)");
        LengthIndexedLine lil = new LengthIndexedLine(route);
        double routeLen = lil.getEndIndex();

        // 事件里程（米）
        double[] eventMeasures = {120, 380, 499.9, 500, 501, 760, 1200};
        double bucketSize = 500.0;   // 每 500 米一个统计区间

        int bucketCount = (int) Math.ceil(routeLen / bucketSize);
        int[] counts = new int[bucketCount];
        List<String> outOfRange = new ArrayList<String>();

        for (double m : eventMeasures) {
            if (!lil.isValidIndex(m)) {
                outOfRange.add(String.valueOf(m));
                continue;
            }
            // 边界归属：左闭右开 [start, end)
            int bucket = (int) Math.floor(m / bucketSize);
            if (bucket >= bucketCount) bucket = bucketCount - 1;
            counts[bucket]++;
        }

        for (int i = 0; i < bucketCount; i++) {
            double start = i * bucketSize;
            double end = Math.min((i + 1) * bucketSize, routeLen);
            System.out.println("区间 " + (int) start + "~" + (int) end
                + " 事件数=" + counts[i]);
        }
        System.out.println("越界事件=" + outOfRange);
    }
}

// 旧里程 -> 旧坐标 -> 新里程（简化版，未处理改线段）
Geometry oldRoute = reader.read(oldWkt);
Geometry newRoute = reader.read(newWkt);
LengthIndexedLine oldLine = new LengthIndexedLine(oldRoute);
LengthIndexedLine newLine = new LengthIndexedLine(newRoute);

double oldMeasure = 1200;
Coordinate p = oldLine.extractPoint(oldMeasure);
double newMeasure = newLine.project(p);
System.out.println("旧桩号 " + oldMeasure + " -> 新桩号 " + newMeasure);

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.linearref.LengthIndexedLine;

public class HighwayStations {
    public static void main(String[] args) throws Exception {
        Geometry route = new WKTReader().read(
            "LINESTRING (0 0, 800 0, 1000 200, 1600 200, 1600 500)");
        LengthIndexedLine lil = new LengthIndexedLine(route);
        System.out.printf("全长=%.3f%n", lil.getEndIndex());

        // 每公里桩号 + 两座桥
        double[] chainages = {0, 450, 1000, 1350, lil.getEndIndex()};
        for (double m : chainages) {
            Coordinate c = lil.extractPoint(m);
            System.out.printf("里程 %.3f -> (%.3f, %.3f)%n", m, c.x, c.y);
        }

        // 分段长度，用于核对总长
        for (int i = 1; i < route.getNumPoints(); i++) {
            double d = route.getCoordinateN(i - 1)
                .distance(route.getCoordinateN(i));
            System.out.printf("段 %d 长=%.3f%n", i - 1, d);
        }
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.linearref.LengthIndexedLine;

public class PipelineSegments {
    public static void main(String[] args) throws Exception {
        Geometry pipeline = new WKTReader().read(
            "LINESTRING (0 0, 300 0, 300 400, 700 400)");
        LengthIndexedLine lil = new LengthIndexedLine(pipeline);
        double total = lil.getEndIndex();

        // 阀室桩号（米），必须排序并补上起终点
        List<Double> valves = new ArrayList<Double>();
        Collections.addAll(valves, 0.0, 520.0, 900.0, total);
        Collections.sort(valves);

        double sum = 0;
        for (int i = 0; i < valves.size() - 1; i++) {
            double a = valves.get(i);
            double b = valves.get(i + 1);
            Geometry seg = lil.extractLine(a, b);
            sum += seg.getLength();
            System.out.printf("段 %d: %.1f~%.1f 长度=%.1f%n",
                i + 1, a, b, seg.getLength());
        }
        System.out.printf("分段长度和=%.1f, 总管长=%.1f%n", sum, total);
    }
}

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.io.WKTReader;
import org.locationtech.jts.linearref.LengthIndexedLine;

public class RiverCrossSection {
    public static void main(String[] args) throws Exception {
        Geometry river = new WKTReader().read(
            "LINESTRING (0 0, 200 100, 400 100, 600 250)");
        LengthIndexedLine lil = new LengthIndexedLine(river);
        System.out.println("河道中心线长=" + lil.getEndIndex());

        double[] sections = {150, 420, 700};
        for (double m : sections) {
            if (!lil.isValidIndex(m)) {
                System.out.println("断面桩号 " + m + " 超出河道中心线范围");
                continue;
            }
            Coordinate center = lil.extractPoint(m);
            Coordinate left = lil.extractPoint(m, 30);
            Coordinate right = lil.extractPoint(m, -30);
            System.out.printf(
                "断面 %.0f: 中心(%.2f, %.2f) 左岸(%.2f, %.2f) 右岸(%.2f, %.2f)%n",
                m, center.x, center.y, left.x, left.y, right.x, right.y);
        }
    }
}

double a = lil.extractPoint(0).distance(lil.extractPoint(10));
double b = 10.0;
System.out.println(a == b);                   // 可能是 false
System.out.println(Math.abs(a - b) < 1e-9);   // 正确做法