Data Generation and Grids

/**
 * Creates a PointGrid as a FeatureCollection of Point features.
 */
function pointGrid(
  bbox: BBox,
  cellSide: number,
  options?: { units?: Units; mask?: Feature<Polygon | MultiPolygon>; properties?: GeoJsonProperties }
): FeatureCollection<Point>;

/**
 * Creates a square grid as a FeatureCollection of Polygon features.
 */
function squareGrid(
  bbox: BBox,
  cellSide: number,
  options?: { units?: Units; mask?: Feature<Polygon | MultiPolygon>; properties?: GeoJsonProperties }
): FeatureCollection<Polygon>;

/**
 * Creates a hexagonal grid as a FeatureCollection of Polygon features.
 */
function hexGrid(
  bbox: BBox,
  cellSide: number,
  options?: { units?: Units; properties?: GeoJsonProperties; mask?: Feature<Polygon | MultiPolygon>; triangles?: boolean }
): FeatureCollection<Polygon>;

/**
 * Creates a triangular grid as a FeatureCollection of Polygon features.
 */
function triangleGrid(
  bbox: BBox,
  cellSide: number,
  options?: { units?: Units; properties?: GeoJsonProperties; mask?: Feature<Polygon | MultiPolygon> }
): FeatureCollection<Polygon>;

/**
 * Creates a rectangular grid as a FeatureCollection of Polygon features.
 */
function rectangleGrid(
  bbox: BBox,
  cellWidth: number,
  cellHeight: number,
  options?: { units?: Units; properties?: GeoJsonProperties; mask?: Feature<Polygon | MultiPolygon> }
): FeatureCollection<Polygon>;

import { pointGrid, squareGrid, hexGrid, triangleGrid, polygon } from "@turf/turf";

// Define study area
const bbox = [-95, 30, -85, 40]; // [west, south, east, north]

// Create different grid types
const points = pointGrid(bbox, 50, { units: 'miles' });
const squares = squareGrid(bbox, 50, { units: 'miles' });
const hexagons = hexGrid(bbox, 50, { units: 'miles' });
const triangles = triangleGrid(bbox, 50, { units: 'miles' });

// Create masked grid (only cells within polygon)
const mask = polygon([[[-90, 35], [-90, 38], [-88, 38], [-88, 35], [-90, 35]]]);
const maskedGrid = squareGrid(bbox, 25, { 
  units: 'miles', 
  mask: mask,
  properties: { type: 'grid_cell' }
});

console.log(`Point grid: ${points.features.length} points`);
console.log(`Square grid: ${squares.features.length} squares`);
console.log(`Masked grid: ${maskedGrid.features.length} squares`);

/**
 * Returns a random position within a bounding box.
 */
function randomPosition(bbox?: BBox): Position;

/**
 * Returns a FeatureCollection of random Point features.
 */
function randomPoint(
  count?: number,
  options?: { bbox?: BBox }
): FeatureCollection<Point>;

/**
 * Returns a FeatureCollection of random Polygon features.
 */
function randomPolygon(
  count?: number,
  options?: { bbox?: BBox; num_vertices?: number; max_radial_length?: number }
): FeatureCollection<Polygon>;

/**
 * Returns a FeatureCollection of random LineString features.
 */
function randomLineString(
  count?: number,
  options?: { bbox?: BBox; num_vertices?: number; max_length?: number; max_rotation?: number }
): FeatureCollection<LineString>;

import { randomPoint, randomPolygon, randomLineString, randomPosition } from "@turf/turf";

// Generate random features within bounds
const bbox = [-180, -90, 180, 90];

// Random points
const randomPoints = randomPoint(100, { bbox });

// Random polygons with custom parameters
const randomPolygons = randomPolygon(20, {
  bbox,
  num_vertices: 6,
  max_radial_length: 10
});

// Random lines
const randomLines = randomLineString(15, {
  bbox,
  num_vertices: 4,
  max_length: 100,
  max_rotation: Math.PI
});

// Single random position
const randomPos = randomPosition(bbox);

console.log(`Generated ${randomPoints.features.length} random points`);
console.log(`Generated ${randomPolygons.features.length} random polygons`);
console.log(`Random position: [${randomPos[0]}, ${randomPos[1]}]`);

/**
 * Takes a Point and calculates the great circle route to a second Point.
 */
function greatCircle(
  start: Coord,
  end: Coord,
  options?: { offset?: number; npoints?: number; properties?: GeoJsonProperties }
): FeatureCollection<LineString>;

/**
 * Creates a line arc between two points.
 */
function lineArc(
  center: Coord,
  radius: number,
  bearing1: number,
  bearing2: number,
  options?: { steps?: number; units?: Units }
): Feature<LineString>;

/**
 * Takes a center point and returns a square polygon.
 */
function square(
  center: Coord,
  sideLength: number,
  options?: { units?: Units; properties?: GeoJsonProperties }
): Feature<Polygon>;

import { greatCircle, lineArc, square, point } from "@turf/turf";

const start = point([-122, 48]);
const end = point([24, 60]);
const center = point([-75, 40]);

// Create great circle route
const route = greatCircle(start, end, { npoints: 100 });

// Create arc
const arc = lineArc(center, 50, 0, 90, { 
  units: 'kilometers',
  steps: 32
});

// Create square
const squareShape = square(center, 100, { 
  units: 'kilometers',
  properties: { type: 'square' }
});

console.log('Great circle route:', route);
console.log('Arc:', arc);
console.log('Square:', squareShape);

/**
 * Takes a line and returns a curved version by applying a Bezier spline algorithm.
 */
function bezierSpline<P>(
  line: Feature<LineString, P>,
  options?: { resolution?: number; sharpness?: number }
): Feature<LineString, P>;

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

// Create angular line
const line = lineString([
  [-76.091308, 18.427501],
  [-76.695556, 18.729501],
  [-76.552734, 19.40443],
  [-74.61914, 19.134789],
  [-73.652343, 20.07657],
  [-73.157958, 20.210656]
]);

// Create smooth spline
const spline = bezierSpline(line, {
  resolution: 10000,
  sharpness: 0.85
});

console.log('Original line points:', line.geometry.coordinates.length);
console.log('Spline points:', spline.geometry.coordinates.length);