Line Processing

/**
 * Takes a line, a start Point, and a stop point and returns a subsection of the line in-between those points.
 */
function lineSlice(
  startPt: Coord,
  stopPt: Coord,
  line: Feature<LineString> | LineString
): Feature<LineString>;

/**
 * Takes a line and returns a subsection of the line between startDist and stopDist using distance along the line.
 */
function lineSliceAlong(
  line: Feature<LineString> | LineString,
  startDist: number,
  stopDist: number,
  options?: { units?: Units }
): Feature<LineString>;

/**
 * Creates a FeatureCollection of 2-vertex LineString segments from a LineString.
 */
function lineSegment<P>(
  geojson: FeatureCollection<LineString, P> | Feature<LineString, P> | LineString
): FeatureCollection<LineString, P>;

/**
 * Divides a LineString into chunks of a specified length.
 */
function lineChunk<P>(
  geojson: FeatureCollection<LineString, P> | Feature<LineString, P> | LineString,
  segmentLength: number,
  options?: { units?: Units; reverse?: boolean }
): FeatureCollection<LineString, P>;

import { lineSlice, lineSliceAlong, lineSegment, lineChunk, lineString, point } from "@turf/turf";

const line = lineString([
  [-77.031669, 38.878605],
  [-77.029609, 38.881946],
  [-77.020339, 38.884084],
  [-77.025661, 38.885821],
  [-77.021884, 38.889563],
  [-77.019824, 38.892368]
]);

// Slice between two points
const start = point([-77.029609, 38.881946]);
const stop = point([-77.021884, 38.889563]);
const sliced = lineSlice(start, stop, line);

// Slice by distance (1km to 3km along line)
const slicedByDistance = lineSliceAlong(line, 1, 3, { units: 'kilometers' });

// Break into segments
const segments = lineSegment(line);

// Break into chunks of specific length
const chunks = lineChunk(line, 0.5, { units: 'kilometers' });

console.log('Sliced line:', sliced);
console.log(`Line broken into ${segments.features.length} segments`);
console.log(`Line broken into ${chunks.features.length} chunks`);

/**
 * Split a LineString by another GeoJSON Feature.
 */
function lineSplit(
  line: FeatureCollection<LineString> | Feature<LineString> | LineString,
  splitter: FeatureCollection | Feature<any> | Geometry
): FeatureCollection<LineString>;

import { lineSplit, lineString, point, multiPoint } from "@turf/turf";

const line = lineString([
  [-95, 25], [-85, 25], [-75, 35], [-65, 35]
]);

// Split by single point
const splitPoint = point([-85, 25]);
const splitBySinglePoint = lineSplit(line, splitPoint);

// Split by multiple points
const splitPoints = multiPoint([
  [-85, 25], [-75, 35]
]);
const splitByMultiplePoints = lineSplit(line, splitPoints);

console.log(`Line split into ${splitBySinglePoint.features.length} segments by single point`);
console.log(`Line split into ${splitByMultiplePoints.features.length} segments by multiple points`);

/**
 * Takes a LineString or MultiLineString and returns a line offset by the specified distance.
 */
function lineOffset(
  geojson: Feature<LineString | MultiLineString> | LineString | MultiLineString,
  distance: number,
  options?: { units?: Units }
): FeatureCollection<LineString>;

import { lineOffset, lineString } from "@turf/turf";

const line = lineString([
  [-83, 30], [-84, 36], [-78, 41]
]);

// Create parallel lines
const offsetLeft = lineOffset(line, 2, { units: 'kilometers' });
const offsetRight = lineOffset(line, -2, { units: 'kilometers' });

console.log('Left offset:', offsetLeft);
console.log('Right offset:', offsetRight);

/**
 * Takes any LineString or Polygon GeoJSON and returns the intersecting point(s).
 */
function lineIntersect(
  line1: FeatureCollection | Feature<LineString | MultiLineString | Polygon | MultiPolygon> | LineString | MultiLineString | Polygon | MultiPolygon,
  line2: FeatureCollection | Feature<LineString | MultiLineString | Polygon | MultiPolygon> | LineString | MultiLineString | Polygon | MultiPolygon,
  options?: { removeDuplicates?: boolean }
): FeatureCollection<Point>;

import { lineIntersect, lineString } from "@turf/turf";

const line1 = lineString([
  [-126, -11], [-116, -10], [-102, -11], [-100, -17]
]);

const line2 = lineString([
  [-123, -17], [-119, -12], [-115, -16], [-105, -9]
]);

// Find intersection points
const intersections = lineIntersect(line1, line2);

console.log(`Found ${intersections.features.length} intersection points`);
intersections.features.forEach((point, i) => {
  console.log(`Intersection ${i + 1}:`, point.geometry.coordinates);
});

/**
 * Takes any LineString or Polygon and returns the overlapping lines between both features.
 */
function lineOverlap(
  line1: Feature<LineString | MultiLineString | Polygon | MultiPolygon> | LineString | MultiLineString | Polygon | MultiPolygon,
  line2: Feature<LineString | MultiLineString | Polygon | MultiPolygon> | LineString | MultiLineString | Polygon | MultiPolygon,
  options?: { tolerance?: number }
): FeatureCollection<LineString>;

import { lineOverlap, lineString } from "@turf/turf";

const line1 = lineString([
  [0, 0], [1, 1], [2, 2], [3, 3]
]);

const line2 = lineString([
  [1, 1], [2, 2], [3, 3], [4, 4]
]);

// Find overlapping segments
const overlaps = lineOverlap(line1, line2);

console.log(`Found ${overlaps.features.length} overlapping segments`);
overlaps.features.forEach(overlap => {
  console.log('Overlap:', overlap.geometry.coordinates);
});

/**
 * Converts a LineString to a Polygon.
 */
function lineToPolygon<P>(
  geojson: FeatureCollection<LineString, P> | Feature<LineString, P> | LineString,
  options?: { properties?: P; autoComplete?: boolean; orderCoords?: boolean }
): FeatureCollection<Polygon, P> | Feature<Polygon, P>;

/**
 * Converts a Polygon to a LineString or MultiLineString.
 */
function polygonToLine<P>(
  geojson: FeatureCollection<Polygon | MultiPolygon, P> | Feature<Polygon | MultiPolygon, P> | Polygon | MultiPolygon,
  options?: { properties?: P }
): FeatureCollection<LineString, P> | Feature<LineString | MultiLineString, P>;

import { lineToPolygon, polygonToLine, lineString, polygon } from "@turf/turf";

// Convert line to polygon (must be closed)
const closedLine = lineString([
  [0, 0], [1, 0], [1, 1], [0, 1], [0, 0]
]);

const poly = lineToPolygon(closedLine, { 
  properties: { converted: true },
  autoComplete: true 
});

// Convert polygon back to line
const originalPoly = polygon([
  [[0, 0], [0, 5], [5, 5], [5, 0], [0, 0]],
  [[1, 1], [1, 4], [4, 4], [4, 1], [1, 1]] // hole
]);

const lines = polygonToLine(originalPoly, {
  properties: { type: 'boundary' }
});

console.log('Line to polygon:', poly);
console.log('Polygon to lines:', lines);

/**
 * Returns kinks (self-intersections) in a LineString.
 */
function kinks<P>(
  geojson: FeatureCollection<LineString | MultiLineString, P> | Feature<LineString | MultiLineString, P> | LineString | MultiLineString
): FeatureCollection<Point, P>;

/**
 * Removes kinks from a Polygon.
 */
function unkinkPolygon<P>(
  geojson: FeatureCollection<Polygon | MultiPolygon, P> | Feature<Polygon | MultiPolygon, P> | Polygon | MultiPolygon
): FeatureCollection<Polygon, P>;

import { kinks, unkinkPolygon, lineString, polygon } from "@turf/turf";

// Find kinks in self-intersecting line
const selfIntersectingLine = lineString([
  [0, 0], [2, 2], [2, 0], [0, 2]
]);

const kinkPoints = kinks(selfIntersectingLine);

// Remove kinks from polygon
const kinkedPolygon = polygon([[
  [0, 0], [2, 2], [2, 0], [0, 2], [0, 0]
]]);

const unkinked = unkinkPolygon(kinkedPolygon);

console.log(`Found ${kinkPoints.features.length} kinks`);
console.log('Unkinked polygons:', unkinked.features.length);