How to use earcut - 10 common examples

var _triangulate = function(contour, holes, dim) {
    // console.time('earcut');

    var faces = earcut(contour, holes, dim);
    var result = [];

    for (i = 0, il = faces.length; i < il; i += 3) {
      result.push(faces.slice(i, i + 3));
    }

    // console.timeEnd('earcut');

    return result;
  };

_triangulate(contour, holes, dim) {
    // console.time('earcut');

    var faces = earcut(contour, holes, dim);
    var result = [];

    for (i = 0, il = faces.length; i < il; i += 3) {
      result.push(faces.slice(i, i + 3));
    }

    // console.timeEnd('earcut');

    return result;
  }

}
            if (this.options['project']) {
                c = this.map.coordinateToPoint(new maptalks.Coordinate(data.vertices[i], data.vertices[i + 1]), targetZ);
                bottom.push(c.x, c.y, 0);
                top.push(c.x, c.y, height);
            } else {
                bottom.push(data.vertices[i], data.vertices[i + 1], 0);
                top.push(data.vertices[i], data.vertices[i + 1], height);
            }
        }
        data.vertices = bottom;
        let triangles = earcut(data.vertices, data.holes, dimension);
        if (triangles.length <= 2) {
            return;
        }
        const deviation = earcut.deviation(data.vertices, data.holes, dimension, triangles);
        if (Math.round(deviation * 1E3) / 1E3 !== 0) {
            if (console) {
                console.warn('Failed triangluation.');
            }
            return;
        }

        const count = bottom.length / dimension;

        const preCount = this.vertexArray.length / dimension;
        if (preCount > 0) {
            triangles = triangles.map(e => e + preCount);
        }
        // push bottom vertice
        maptalks.Util.pushIn(this.vertexArray, bottom);
        // push bottom elements

const data = earcut.flatten(vertice);

        if (this.options['project']) {
            const v = [];
            let c;
            for (let i = 0, l = data.vertices.length; i < l; i += 2) {
                c = this.map.coordinateToPoint(new maptalks.Coordinate(data.vertices[i], data.vertices[i + 1]), targetZ);
                v.push(c.x, c.y);
            }
            data.vertices = v;
        }
        let triangles = earcut(data.vertices, data.holes, 2);
        if (triangles.length <= 2) {
            return this;
        }
        const deviation = earcut.deviation(data.vertices, data.holes, 2, triangles);
        if (Math.round(deviation * 1E3) / 1E3 !== 0) {
            if (console) {
                console.warn('Failed triangluation.');
            }
            return this;
        }
        const count = this.vertexArray.length / 2;
        if (count > 0) {
            triangles = triangles.map(e => e + count);
        }
        maptalks.Util.pushIn(this.vertexArray, data.vertices);
        maptalks.Util.pushIn(this.elementArray, triangles);

        // 添加样式数据
        this._addTexCoords(data.vertices.length / 2, style);
        return this;

// TODO - fix this properly, this is not very elegant.. but it works for now.

    if (graphics_data.fill) {
        const color = hex2rgb(graphics_data.fill_color);
        const alpha = graphics_data.fill_alpha;

        const r = color[0] * alpha;
        const g = color[1] * alpha;
        const b = color[2] * alpha;

        const verts = webgl_data.points;
        const indices = webgl_data.indices;

        const vec_pos = verts.length / 6;

        const triangles = earcut(rect_points, null, 2);

        for (let i = 0, j = triangles.length; i < j; i += 3) {
            indices.push(triangles[i] + vec_pos);
            indices.push(triangles[i] + vec_pos);
            indices.push(triangles[i + 1] + vec_pos);
            indices.push(triangles[i + 2] + vec_pos);
            indices.push(triangles[i + 2] + vec_pos);
        }

        for (let i = 0, j = rect_points.length; i < j; i++) {
            verts.push(rect_points[i], rect_points[++i], r, g, b, alpha);
        }
    }

    if (graphics_data.line_width) {
        const temp_points = graphics_data.points;

function calculateSurfaceIndices(vertices, offset) {
  const stride = Polygon.getVertexCount(vertices);

  let holes = null;
  const holeCount = vertices.length - 1;

  if (holeCount) {
    holes = [];
    let vertexIndex = 0;
    for (let i = 0; i < holeCount; i++) {
      vertexIndex += vertices[i].length;
      holes[i] = vertexIndex;
    }
  }

  const indices = earcut(flatten(vertices, 3), holes, 3).map(index => index + offset);

  vertices.forEach(polygon => {
    const numVertices = polygon.length;

    // polygon sides
    for (let i = 0; i < numVertices - 1; i++) {
      drawSurfaceRectangle(indices, offset + i, stride);
    }

    offset += numVertices;
  });

  return indices;
}

export function getSurfaceIndices(complexPolygon) {
  // Prepare an array of hole indices as expected by earcut
  const holeIndices = getHoleIndices(complexPolygon);
  // Flatten the polygon as expected by earcut
  const verts = flattenVertices(complexPolygon, {dimensions: 2, result: []});
  // Let earcut triangulate the polygon
  return earcut(verts, holeIndices, 2);
}

function generateCap(top = true) {
    // !! using the 3d coords generates shapes with the wrong winding, connecting the outsides of the contour
    // so we derive the indexes from the lat,lng coordinates directly
    // let capIndices = earcut(top ? topVerts : bottomVerts, holes, 3);
    let capIndices = earcut(earcut.flatten(polygonGeoJson).vertices, holes, 2);

    !top && (capIndices = capIndices.map(v => v + numPoints)); // translate bottom indices

    return capIndices;
  }
}

if (i === l - 1) {
                if (this._equalCoord(data.vertices[i], data.vertices[0])) {
                    continue;
                }
            }
            if (this.options['project']) {
                c = this.map.coordinateToPoint(new maptalks.Coordinate(data.vertices[i], data.vertices[i + 1]), targetZ);
                bottom.push(c.x, c.y, 0);
                top.push(c.x, c.y, height);
            } else {
                bottom.push(data.vertices[i], data.vertices[i + 1], 0);
                top.push(data.vertices[i], data.vertices[i + 1], height);
            }
        }
        data.vertices = bottom;
        let triangles = earcut(data.vertices, data.holes, dimension);
        if (triangles.length <= 2) {
            return;
        }
        const deviation = earcut.deviation(data.vertices, data.holes, dimension, triangles);
        if (Math.round(deviation * 1E3) / 1E3 !== 0) {
            if (console) {
                console.warn('Failed triangluation.');
            }
            return;
        }

        const count = bottom.length / dimension;

        const preCount = this.vertexArray.length / dimension;
        if (preCount > 0) {
            triangles = triangles.map(e => e + preCount);

function processPolygon(coordinates) {
    var data = flattenCoords(coordinates);
    var dim = 2;
    var result = earcut(data.vertices, data.holes, dim);

    var features = [];
    var vertices = [];

    result.forEach(function (vert, i) {
        var index = result[i];
        vertices.push([data.vertices[index * dim], data.vertices[index * dim + 1]]);
    });

    for (var i = 0; i < vertices.length; i += 3) {
        var coords = vertices.slice(i, i + 3);
        coords.push(vertices[i]);
        features.push(polygon([coords]));
    }

    return features;