Add function to convert RenderFeature to Feature

src/ol/format/MVT.js

@@ -19,7 +19,7 @@ import RenderFeature from '../render/Feature.js';
 import Units from '../proj/Units.js';
 import {assert} from '../asserts.js';
 import {get} from '../proj.js';
-import {linearRingIsClockwise} from '../geom/flat/orient.js';
+import {inflateEnds} from '../geom/flat/orient.js';
 
 /**
  * @typedef {Object} Options
@@ -185,8 +185,8 @@ class MVT extends FeatureFormat {
 
     values[this.layerName_] = rawFeature.layer.name;
 
-    const flatCoordinates = [];
-    const ends = [];
+    const flatCoordinates = /** @type {Array<number>} */ ([]);
+    const ends = /** @type {Array<number>} */ ([]);
     this.readRawGeometry_(pbf, rawFeature, flatCoordinates, ends);
 
     const geometryType = getGeometryType(type, ends.length);
@@ -203,28 +203,11 @@ class MVT extends FeatureFormat {
     } else {
       let geom;
       if (geometryType == GeometryType.POLYGON) {
-        const endss = [];
-        let offset = 0;
-        let prevEndIndex = 0;
-        for (let i = 0, ii = ends.length; i < ii; ++i) {
-          const end = ends[i];
-          // classifies an array of rings into polygons with outer rings and holes
-          if (!linearRingIsClockwise(flatCoordinates, offset, end, 2)) {
-            endss.push(ends.slice(prevEndIndex, i + 1));
-          } else {
-            if (endss.length === 0) {
-              continue;
-            }
-            endss[endss.length - 1].push(ends[prevEndIndex]);
-          }
-          prevEndIndex = i + 1;
-          offset = end;
-        }
-        if (endss.length > 1) {
-          geom = new MultiPolygon(flatCoordinates, GeometryLayout.XY, endss);
-        } else {
-          geom = new Polygon(flatCoordinates, GeometryLayout.XY, ends);
-        }
+        const endss = inflateEnds(flatCoordinates, ends);
+        geom =
+          endss.length > 1
+            ? new MultiPolygon(flatCoordinates, GeometryLayout.XY, endss)
+            : new Polygon(flatCoordinates, GeometryLayout.XY, ends);
       } else {
         geom =
           geometryType === GeometryType.POINT

src/ol/geom/flat/orient.js

@@ -178,3 +178,31 @@ export function orientLinearRingsArray(
   }
   return offset;
 }
+
+/**
+ * Return a two-dimensional endss
+ * @param {Array<number>} flatCoordinates Flat coordinates
+ * @param {Array<number>} ends Linear ring end indexes
+ * @return {Array<Array<number>>} Two dimensional endss array that can
+ * be used to contruct a MultiPolygon
+ */
+export function inflateEnds(flatCoordinates, ends) {
+  const endss = [];
+  let offset = 0;
+  let prevEndIndex = 0;
+  for (let i = 0, ii = ends.length; i < ii; ++i) {
+    const end = ends[i];
+    // classifies an array of rings into polygons with outer rings and holes
+    if (!linearRingIsClockwise(flatCoordinates, offset, end, 2)) {
+      endss.push(ends.slice(prevEndIndex, i + 1));
+    } else {
+      if (endss.length === 0) {
+        continue;
+      }
+      endss[endss.length - 1].push(ends[prevEndIndex]);
+    }
+    prevEndIndex = i + 1;
+    offset = end;
+  }
+  return endss;
+}

src/ol/render/Feature.js

@@ -1,7 +1,17 @@
 /**
  * @module ol/render/Feature
  */
+import Feature from '../Feature.js';
+import GeometryLayout from '../geom/GeometryLayout.js';
 import GeometryType from '../geom/GeometryType.js';
+import {
+  LineString,
+  MultiLineString,
+  MultiPoint,
+  MultiPolygon,
+  Point,
+  Polygon,
+} from '../geom.js';
 import {
   compose as composeTransform,
   create as createTransform,
@@ -18,6 +28,7 @@ import {
   getInteriorPointsOfMultiArray,
 } from '../geom/flat/interiorpoint.js';
 import {get as getProjection} from '../proj.js';
+import {inflateEnds} from '../geom/flat/orient.js';
 import {interpolatePoint} from '../geom/flat/interpolate.js';
 import {linearRingss as linearRingssCenter} from '../geom/flat/center.js';
 import {transform2D} from '../geom/flat/transform.js';
@@ -326,4 +337,76 @@ RenderFeature.prototype.getEndss = RenderFeature.prototype.getEnds;
 RenderFeature.prototype.getFlatCoordinates =
   RenderFeature.prototype.getOrientedFlatCoordinates;
 
+/**
+ * Create a geometry from an `ol/render/Feature`
+ * @param {RenderFeature} renderFeature
+ * Render Feature
+ * @return {Point|MultiPoint|LineString|MultiLineString|Polygon|MultiPolygon}
+ * New geometry instance.
+ * @api
+ */
+export function toGeometry(renderFeature) {
+  const geometryType = renderFeature.getType();
+  switch (geometryType) {
+    case GeometryType.POINT:
+      return new Point(renderFeature.getFlatCoordinates());
+    case GeometryType.MULTI_POINT:
+      return new MultiPoint(
+        renderFeature.getFlatCoordinates(),
+        GeometryLayout.XY
+      );
+    case GeometryType.LINE_STRING:
+      return new LineString(
+        renderFeature.getFlatCoordinates(),
+        GeometryLayout.XY
+      );
+    case GeometryType.MULTI_LINE_STRING:
+      return new MultiLineString(
+        renderFeature.getFlatCoordinates(),
+        GeometryLayout.XY,
+        /** @type {Array<number>} */ (renderFeature.getEnds())
+      );
+    case GeometryType.POLYGON:
+      const flatCoordinates = renderFeature.getFlatCoordinates();
+      const ends = /** @type {Array<number>} */ (renderFeature.getEnds());
+      const endss = inflateEnds(flatCoordinates, ends);
+      return endss.length > 1
+        ? new MultiPolygon(flatCoordinates, GeometryLayout.XY, endss)
+        : new Polygon(flatCoordinates, GeometryLayout.XY, ends);
+    case GeometryType.MULTI_POLYGON:
+      return new MultiPolygon(
+        renderFeature.getFlatCoordinates(),
+        GeometryLayout.XY,
+        /** @type {Array<Array<number>>} */ (renderFeature.getEndss())
+      );
+    default:
+      throw new Error('Invalid geometry type:' + geometryType);
+  }
+}
+
+/**
+ * Create an `ol/Feature` from an `ol/render/Feature`
+ * @param {RenderFeature} renderFeature RenderFeature
+ * @param {string} [opt_geometryName='geometry'] Geometry name to use
+ * when creating the Feature.
+ * @return {Feature} Newly constructed `ol/Feature` with properties,
+ * geometry, and id copied over.
+ * @api
+ */
+export function toFeature(renderFeature, opt_geometryName) {
+  const id = renderFeature.getId();
+  const geometry = toGeometry(renderFeature);
+  const properties = renderFeature.getProperties();
+  const feature = new Feature();
+  if (opt_geometryName !== undefined) {
+    feature.setGeometryName(opt_geometryName);
+  }
+  feature.setGeometry(geometry);
+  if (id !== undefined) {
+    feature.setId(id);
+  }
+  feature.setProperties(properties, true);
+  return feature;
+}
+
 export default RenderFeature;