Options
All
  • Public
  • Public/Protected
  • All
Menu

Class DPolygon

Hierarchy

  • DPolygon

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Properties

holes

holes: DPolygon[] = []

properties

properties: Record<string, any> = {}

Static CAP_FLAT

CAP_FLAT: number = CAP_FLAT

Specifies a flat line buffer end cap style.

Static CAP_ROUND

CAP_ROUND: number = CAP_ROUND

Specifies a round line buffer end cap style.

Static CAP_SQUARE

CAP_SQUARE: number = CAP_SQUARE

Specifies a square line buffer end cap style.

Static WKT_LINESTRING

WKT_LINESTRING: string = 'LINESTRING'

Static WKT_POLYGON

WKT_POLYGON: string = 'POLYGON'

Accessors

area

  • get area(): number

center

clockWise

closed

  • get closed(): boolean

convex

dX

  • get dX(): number

  • Difference between maxX and minX. Equal width (w)

    Returns number

dY

  • get dY(): number

  • Difference between maxY and minY. Equal height (h)

    Returns number

deintersection

extend

filledDeintersection

first

fullLength

  • get fullLength(): number

fullLengthLatLon

  • get fullLengthLatLon(): number

  • Get length of line string. For big distances in lat/lon.

    Returns number

growingPiecesGenerator

h

  • get h(): number

  • Difference between maxY and minY. Equal ΔY (dY)

    Returns number

innerCenter

isClockwise

  • get isClockwise(): boolean

  • Check polygon direction

    For normal Cartesian coordinate system. The reason that's worth mentioning is that some common contexts, like HTML5 canvas, use an inverted Y-axis. Then the rule has to be flipped: if the area is negative, the curve is clockwise.

    Returns boolean

last

leftTop

length

  • get length(): number

maxPoint

maxX

  • get maxX(): number

maxY

  • get maxY(): number

minAreaRectangle

minPoint

minX

  • get minX(): number

minY

  • get minY(): number

noHoles

perimeter

  • get perimeter(): number

perimeterLatLon

  • get perimeterLatLon(): number

  • Get perimeter. For big distances in lat/lon.

    Returns number

points

rightBottom

second

size

valid

  • get valid(): boolean

  • Check if polygon contain more than three points

    Returns boolean

w

  • get w(): number

  • Difference between maxX and minX. Equal ΔX (dX)

    Returns number

Methods

add

approximation

at

bezier

buffer

  • buffer(v: number, quadrantSegments?: number, type?: number): DPolygon

  • Parameters

    • v: number
    • quadrantSegments: number = 64
    • type: number = DPolygon.CAP_ROUND

    Returns DPolygon

clearPolygonOnCanvas

  • clearPolygonOnCanvas(canvas: HTMLCanvasElement | OffscreenCanvas): void

  • Parameters

    • canvas: HTMLCanvasElement | OffscreenCanvas

    Returns void

clone

close

contain

  • contain(p: DPoint, isBorderInside?: boolean): boolean

  • Check if contain point

    Parameters

    • p: DPoint
    • isBorderInside: boolean = false

    Returns boolean

divideToPieces

  • divideToPieces(piecesCount: number, withAltitude?: boolean): DPolygon

  • Divide line string to pieces by length

    Parameters

    • piecesCount: number
    • withAltitude: boolean = false

    Returns DPolygon

drawPolygonOnCanvas

  • drawPolygonOnCanvas(canvas: HTMLCanvasElement | OffscreenCanvas, fillColor?: string, strokeColor?: string, shadowColor?: string, lineWidth?: number, steps?: number): DPolygon

  • Parameters

    • canvas: HTMLCanvasElement | OffscreenCanvas
    • Optional fillColor: string
    • Optional strokeColor: string
    • Optional shadowColor: string
    • lineWidth: number = 1
    • steps: number = ...

    Returns DPolygon

equal

fastHas

  • fastHas(__namedParameters: DPoint): boolean

filter

findIndex

  • findIndex(p: DPoint): number
  • findIndex(f: ((p: DPoint) => boolean)): number
  • findIndex(f: ((p: DPoint, index: number) => boolean)): number

getTrianglesPointIndexes

  • getTrianglesPointIndexes(): number[]

  • Divide polygon to triangles and return points indexes

    Returns number[]

getValue

  • getValue(): string

has

hasSimpleIntersection

  • hasSimpleIntersection(p: DPolygon): boolean

insertAfter

  • insertAfter(index: number, ...points: DPoint[]): void

intersection

  • intersection(l: DLine, includeOnly?: boolean): DPoint[]

loop

map

mapArray

  • mapArray<T>(f: ((r: DPoint) => T)): T[]
  • mapArray<T>(f: ((r: DPoint, index: number) => T)): T[]

nextStart

onBorder

open

pop

prepareToFastSearch

  • prepareToFastSearch(): void

push

  • push(...args: DPoint[]): number

reduce

  • reduce<T>(f: ((a: T, p: DPoint) => T), v: T): T
  • reduce<T>(f: ((a: T, p: DPoint, index: number) => T), v: T): T

  • Type Parameters

    • T

    Parameters

    Returns T

  • Type Parameters

    • T

    Parameters

    • f: ((a: T, p: DPoint, index: number) => T)
        • (a: T, p: DPoint, index: number): T

        • Parameters

          Returns T

    • v: T

    Returns T

removeDuplicates

removePart

  • removePart(index: number, count: number): DPoint[]

reverse

same

  • Check is polygons are same. They can be with different directions and different start points.

    Parameters

    Returns boolean

setCenter

setGrowingHeight

  • setGrowingHeight(from: number, to: number): DPolygon

setProperties

  • setProperties(v: Record<string, any> | SetterFunction<Record<string, any>>): DPolygon

shift

sideBuffers

  • Return left and right buffers of polyline. With same direction as original line.

    For canvas: [left, right]

    For normal Cartesian coordinate system: [right, left]

    Parameters

    • v: number
    • quadrantSegments: number = 64

    Returns [DPolygon, DPolygon]

simpleDifference

simpleInclude

  • simpleInclude(p: DPoint): boolean

simpleIntersection

simpleUnion

smartUnion

sort

toArrayOfCoords

  • toArrayOfCoords(format?: string): DCoord[]

toGeoJSON

  • toGeoJSON(format?: string): LineString | Polygon

  • Parameters

    • format: string = DGeo.parseFormat

    Returns LineString | Polygon

toGeoJSONFeature

  • toGeoJSONFeature(format?: string): Feature<LineString | Polygon, GeoJsonProperties>

  • Parameters

    • format: string = DGeo.parseFormat

    Returns Feature<LineString | Polygon, GeoJsonProperties>

toString

  • toString(): string

toTriangles

toWKT

  • toWKT(type?: string, withZ?: boolean): string

  • Parameters

    • type: string = DPolygon.WKT_POLYGON
    • withZ: boolean = false

    Returns string

unshift

  • unshift(...args: DPoint[]): number

Static arrayOfTrianglesToVertices

  • arrayOfTrianglesToVertices(triangles: DPolygon[], height?: number): number[]

  • Transform array of triangles to Three.JS vertices

    const geometry = new THREE.BufferGeometry();
    // create a simple square shape. We duplicate the top left and bottom right
    // vertices because each vertex needs to appear once per triangle.
    const vertices = new Float32Array( DPolygon.arrayOfTrianglesToVertices(triangles, 10) );

    // itemSize = 3 because there are 3 values (components) per vertex
    geometry.setAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
    const material = new THREE.MeshBasicMaterial( { color: 0xff0000 } );
    mesh = new THREE.Mesh( geometry, material );

    scene.add( mesh );

    Parameters

    • triangles: DPolygon[]
    • Optional height: number

    Returns number[]

Static createSquareBySize

Static minAreaRectangleDirection

  • minAreaRectangleDirection(poly: DPolygon): number

  • Get min area rectangle direction

    Parameters

    • poly: DPolygon

      should be minAreaRectangle

    Returns number

Static minAreaRectangleSize

Static parse

  • parse(a: LatLng[], format?: string): DPolygon
  • parse(a: number[][], format?: string): DPolygon
  • parse(a: DCoord[], format?: string): DPolygon
  • parse(a: XYZ[], format?: string): DPolygon
  • parse(a: Geometry | FeatureCollection<LineString | Polygon, GeoJsonProperties> | Feature<Geometry, GeoJsonProperties>, format?: string): DPolygon | DeepArray<DPolygon>

Static parseFromWKT

Static toDash

Static toGeoJSONFeatureCollection

  • toGeoJSONFeatureCollection(polygons: DPolygon[], format?: string): FeatureCollection<LineString | Polygon, GeoJsonProperties>

  • Parameters

    • polygons: DPolygon[]
    • format: string = DGeo.parseFormat

    Returns FeatureCollection<LineString | Polygon, GeoJsonProperties>

Generated using TypeDoc