@woosh/meep-engine 2.163.10 → 2.164.0

package/src/core/geom/2d/bvh/BVH2D.js

@@ -4,8 +4,8 @@ import { array_copy } from "../../../collection/array/array_copy.js";
 import { typed_array_copy } from "../../../collection/array/typed/typed_array_copy.js";
 import { max2 } from "../../../math/max2.js";
 import { min2 } from "../../../math/min2.js";
-import { aabb2_array_combine } from "../aabb/aabb2_array_combine.js";
-import { aabb2_compute_area } from "../aabb/aabb2_compute_area.js";
+import { aabb2_union_array } from "../aabb/aabb2_union_array.js";
+import { aabb2_area } from "../aabb/aabb2_area.js";
 
 
 export const COLUMN_PARENT = 4;
@@ -486,7 +486,7 @@ export class BVH2D {
         const x1 = float32[address + 2];
         const y1 = float32[address + 3];
 
-        return aabb2_compute_area(
+        return aabb2_area(
             x0, y0,
             x1, y1
         );
@@ -521,7 +521,7 @@ export class BVH2D {
         const y1 = max2(a_y1, b_y1);
 
 
-        return aabb2_compute_area(
+        return aabb2_area(
             x0, y0,
             x1, y1,
         );
@@ -541,7 +541,7 @@ export class BVH2D {
 
         const float32 = this.__data_float32;
 
-        aabb2_array_combine(
+        aabb2_union_array(
             float32,address_destination,
             float32,address_a,
             float32,address_b

package/src/core/geom/2d/circle/circle_compute_circle_intersection.d.ts

@@ -1,14 +1,7 @@
 /**
- *
- * @param {number[]} result
- * @param {number} result_offset
- * @param {number} a_center_x
- * @param {number} a_center_y
- * @param {number} a_radius
- * @param {number} b_center_x
- * @param {number} b_center_y
- * @param {number} b_radius
- * @returns {boolean} if intersection exists, false otherwise
+ * @deprecated Renamed to {@link circle_compute_intersection}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function circle_compute_circle_intersection(result: number[], result_offset: number, a_center_x: number, a_center_y: number, a_radius: number, b_center_x: number, b_center_y: number, b_radius: number): boolean;
+export const circle_compute_circle_intersection: typeof circle_compute_intersection;
+import { circle_compute_intersection } from "./circle_compute_intersection.js";
 //# sourceMappingURL=circle_compute_circle_intersection.d.ts.map

package/src/core/geom/2d/circle/circle_compute_circle_intersection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"circle_compute_circle_intersection.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/circle/circle_compute_circle_intersection.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,2DAVW,MAAM,EAAE,iBACR,MAAM,cACN,MAAM,cACN,MAAM,YACN,MAAM,cACN,MAAM,cACN,MAAM,YACN,MAAM,GACJ,OAAO,CAqDnB"}
+{"version":3,"file":"circle_compute_circle_intersection.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/circle/circle_compute_circle_intersection.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,oFAA8E;4CANlC,kCAAkC"}

package/src/core/geom/2d/circle/circle_compute_circle_intersection.js

@@ -1,64 +1,7 @@
-/**
- *
- * @param {number[]} result
- * @param {number} result_offset
- * @param {number} a_center_x
- * @param {number} a_center_y
- * @param {number} a_radius
- * @param {number} b_center_x
- * @param {number} b_center_y
- * @param {number} b_radius
- * @returns {boolean} if intersection exists, false otherwise
- */
-export function circle_compute_circle_intersection(
-    result,
-    result_offset,
-    a_center_x, a_center_y, a_radius,
-    b_center_x, b_center_y, b_radius
-) {
-
-    // see https://math.stackexchange.com/a/1033561
-
-    const abx = a_center_x - b_center_x;
-    const aby = a_center_y - b_center_y;
-
-    const d2 = abx * abx + aby * aby;
-
-    if (d2 === 0) {
-        // centers are at the same coordinate, no intersection possible except for full overlap
-        // Continuing would lead to division by 0, so we treat this as no-intersection
-        return false;
-    }
-
-    const d = Math.sqrt(d2);
-
-    if (d > a_radius + b_radius) {
-        // no intersection
-        return false;
-    }
-
-    if (d < Math.abs(a_radius - b_radius)) {
-        // one circle is fully within another
-        return false;
-    }
-
-    const a_radius2 = a_radius * a_radius;
-    const l = (a_radius2 - b_radius * b_radius + d * d) / (2 * d);
-    const h = Math.sqrt(a_radius2 - l * l)
-
-    const l_d = l / d;
-    const h_d = h / d;
-
-    const bax = b_center_x - a_center_x;
-    const bay = b_center_y - a_center_y;
-
-    // compute first root
-    result[result_offset] = l_d * bax + h_d * bay + a_center_x;
-    result[result_offset + 1] = l_d * bay - h_d * bax + a_center_y;
-
-    // second root
-    result[result_offset + 2] = l_d * bax - h_d * bay + a_center_x;
-    result[result_offset + 3] = l_d * bay + h_d * bax + a_center_y;
-
-    return true;
-}
+import { circle_compute_intersection } from "./circle_compute_intersection.js";
+
+/**
+ * @deprecated Renamed to {@link circle_compute_intersection}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const circle_compute_circle_intersection = circle_compute_intersection;

package/src/core/geom/2d/circle/circle_compute_circle_penetration.d.ts

@@ -1,12 +1,7 @@
 /**
- *
- * @param {number} ax Center of first circle
- * @param {number} ay Center of first circle
- * @param {number} ar Radius of first circle
- * @param {number} bx Center of second circle
- * @param {number} by Center of second circle
- * @param {number} br Radius of second circle
- * @returns {number} positive value means that there is penetration, negative means that circles are separated
+ * @deprecated Renamed to {@link circle_compute_penetration}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function circle_compute_circle_penetration(ax: number, ay: number, ar: number, bx: number, by: number, br: number): number;
+export const circle_compute_circle_penetration: typeof circle_compute_penetration;
+import { circle_compute_penetration } from "./circle_compute_penetration.js";
 //# sourceMappingURL=circle_compute_circle_penetration.d.ts.map

package/src/core/geom/2d/circle/circle_compute_circle_penetration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"circle_compute_circle_penetration.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/circle/circle_compute_circle_penetration.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,sDARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAuBlB"}
+{"version":3,"file":"circle_compute_circle_penetration.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/circle/circle_compute_circle_penetration.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,kFAA4E;2CANjC,iCAAiC"}

package/src/core/geom/2d/circle/circle_compute_circle_penetration.js

@@ -1,32 +1,7 @@
-/**
- *
- * @param {number} ax Center of first circle
- * @param {number} ay Center of first circle
- * @param {number} ar Radius of first circle
- * @param {number} bx Center of second circle
- * @param {number} by Center of second circle
- * @param {number} br Radius of second circle
- * @returns {number} positive value means that there is penetration, negative means that circles are separated
- */
-export function circle_compute_circle_penetration(
-    ax, ay, ar,
-    bx, by, br
-) {
-
-    const dx = bx - ax;
-    const dy = by - ax;
-
-    /**
-     * Compute distance between circle centers
-     * @type {number}
-     */
-    const distance = Math.sqrt(dx * dx + dy * dy);
-
-    /**
-     * Minimum distance between circle centers for them to not overlap
-     * @type {number}
-     */
-    const minSeparation = ar + br;
-
-    return minSeparation - distance;
-}
+import { circle_compute_penetration } from "./circle_compute_penetration.js";
+
+/**
+ * @deprecated Renamed to {@link circle_compute_penetration}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const circle_compute_circle_penetration = circle_compute_penetration;

package/src/core/geom/2d/circle/circle_compute_intersection.d.ts

@@ -0,0 +1,14 @@
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {number} a_center_x
+ * @param {number} a_center_y
+ * @param {number} a_radius
+ * @param {number} b_center_x
+ * @param {number} b_center_y
+ * @param {number} b_radius
+ * @returns {boolean} if intersection exists, false otherwise
+ */
+export function circle_compute_intersection(result: number[], result_offset: number, a_center_x: number, a_center_y: number, a_radius: number, b_center_x: number, b_center_y: number, b_radius: number): boolean;
+//# sourceMappingURL=circle_compute_intersection.d.ts.map

package/src/core/geom/2d/circle/circle_compute_intersection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circle_compute_intersection.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/circle/circle_compute_intersection.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,oDAVW,MAAM,EAAE,iBACR,MAAM,cACN,MAAM,cACN,MAAM,YACN,MAAM,cACN,MAAM,cACN,MAAM,YACN,MAAM,GACJ,OAAO,CAqDnB"}

package/src/core/geom/2d/circle/circle_compute_intersection.js

@@ -0,0 +1,64 @@
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {number} a_center_x
+ * @param {number} a_center_y
+ * @param {number} a_radius
+ * @param {number} b_center_x
+ * @param {number} b_center_y
+ * @param {number} b_radius
+ * @returns {boolean} if intersection exists, false otherwise
+ */
+export function circle_compute_intersection(
+    result,
+    result_offset,
+    a_center_x, a_center_y, a_radius,
+    b_center_x, b_center_y, b_radius
+) {
+
+    // see https://math.stackexchange.com/a/1033561
+
+    const abx = a_center_x - b_center_x;
+    const aby = a_center_y - b_center_y;
+
+    const d2 = abx * abx + aby * aby;
+
+    if (d2 === 0) {
+        // centers are at the same coordinate, no intersection possible except for full overlap
+        // Continuing would lead to division by 0, so we treat this as no-intersection
+        return false;
+    }
+
+    const d = Math.sqrt(d2);
+
+    if (d > a_radius + b_radius) {
+        // no intersection
+        return false;
+    }
+
+    if (d < Math.abs(a_radius - b_radius)) {
+        // one circle is fully within another
+        return false;
+    }
+
+    const a_radius2 = a_radius * a_radius;
+    const l = (a_radius2 - b_radius * b_radius + d * d) / (2 * d);
+    const h = Math.sqrt(a_radius2 - l * l)
+
+    const l_d = l / d;
+    const h_d = h / d;
+
+    const bax = b_center_x - a_center_x;
+    const bay = b_center_y - a_center_y;
+
+    // compute first root
+    result[result_offset] = l_d * bax + h_d * bay + a_center_x;
+    result[result_offset + 1] = l_d * bay - h_d * bax + a_center_y;
+
+    // second root
+    result[result_offset + 2] = l_d * bax - h_d * bay + a_center_x;
+    result[result_offset + 3] = l_d * bay + h_d * bax + a_center_y;
+
+    return true;
+}

package/src/core/geom/2d/circle/circle_compute_penetration.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {number} ax Center of first circle
+ * @param {number} ay Center of first circle
+ * @param {number} ar Radius of first circle
+ * @param {number} bx Center of second circle
+ * @param {number} by Center of second circle
+ * @param {number} br Radius of second circle
+ * @returns {number} positive value means that there is penetration, negative means that circles are separated
+ */
+export function circle_compute_penetration(ax: number, ay: number, ar: number, bx: number, by: number, br: number): number;
+//# sourceMappingURL=circle_compute_penetration.d.ts.map

package/src/core/geom/2d/circle/circle_compute_penetration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circle_compute_penetration.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/circle/circle_compute_penetration.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,+CARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAuBlB"}

package/src/core/geom/2d/circle/circle_compute_penetration.js

@@ -0,0 +1,32 @@
+/**
+ *
+ * @param {number} ax Center of first circle
+ * @param {number} ay Center of first circle
+ * @param {number} ar Radius of first circle
+ * @param {number} bx Center of second circle
+ * @param {number} by Center of second circle
+ * @param {number} br Radius of second circle
+ * @returns {number} positive value means that there is penetration, negative means that circles are separated
+ */
+export function circle_compute_penetration(
+    ax, ay, ar,
+    bx, by, br
+) {
+
+    const dx = bx - ax;
+    const dy = by - ay;
+
+    /**
+     * Compute distance between circle centers
+     * @type {number}
+     */
+    const distance = Math.sqrt(dx * dx + dy * dy);
+
+    /**
+     * Minimum distance between circle centers for them to not overlap
+     * @type {number}
+     */
+    const minSeparation = ar + br;
+
+    return minSeparation - distance;
+}

package/src/core/geom/2d/circle/circle_contains_point.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {number} cx Center of the circle
+ * @param {number} cy Center of the circle
+ * @param {number} cr Radius of the circle
+ * @param {number} px Point coordinate X
+ * @param {number} py Point coordinate Y
+ * @returns {boolean}
+ */
+export function circle_contains_point(cx: number, cy: number, cr: number, px: number, py: number): boolean;
+//# sourceMappingURL=circle_contains_point.d.ts.map

package/src/core/geom/2d/circle/circle_contains_point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circle_contains_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/circle/circle_contains_point.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,0CAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAMnB"}

package/src/core/geom/2d/circle/circle_contains_point.js

@@ -0,0 +1,16 @@
+import { v2_distance } from "../../vec2/v2_distance.js";
+
+/**
+ *
+ * @param {number} cx Center of the circle
+ * @param {number} cy Center of the circle
+ * @param {number} cr Radius of the circle
+ * @param {number} px Point coordinate X
+ * @param {number} py Point coordinate Y
+ * @returns {boolean}
+ */
+export function circle_contains_point(cx, cy, cr, px, py) {
+    const distance = v2_distance(cx, cy, px, py);
+
+    return distance < cr;
+}

package/src/core/geom/2d/circle/circle_intersects_point.d.ts

@@ -1,11 +1,7 @@
 /**
- *
- * @param {number} cx Center of the circle
- * @param {number} cy Center of the circle
- * @param {number} cr Radius of the circle
- * @param {number} px Point coordinate X
- * @param {number} py Point coordinate Y
- * @returns {boolean}
+ * @deprecated Renamed to {@link circle_contains_point}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function circle_intersects_point(cx: number, cy: number, cr: number, px: number, py: number): boolean;
+export const circle_intersects_point: typeof circle_contains_point;
+import { circle_contains_point } from "./circle_contains_point.js";
 //# sourceMappingURL=circle_intersects_point.d.ts.map

package/src/core/geom/2d/circle/circle_intersects_point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"circle_intersects_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/circle/circle_intersects_point.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,4CAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAMnB"}
+{"version":3,"file":"circle_intersects_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/circle/circle_intersects_point.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,mEAA6D;sCANvB,4BAA4B"}

package/src/core/geom/2d/circle/circle_intersects_point.js

@@ -1,16 +1,7 @@
-import { v2_distance } from "../../vec2/v2_distance.js";
-
-/**
- *
- * @param {number} cx Center of the circle
- * @param {number} cy Center of the circle
- * @param {number} cr Radius of the circle
- * @param {number} px Point coordinate X
- * @param {number} py Point coordinate Y
- * @returns {boolean}
- */
-export function circle_intersects_point(cx, cy, cr, px, py) {
-    const distance = v2_distance(cx, cx, px, py);
-
-    return distance < cr;
-}
+import { circle_contains_point } from "./circle_contains_point.js";
+
+/**
+ * @deprecated Renamed to {@link circle_contains_point}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const circle_intersects_point = circle_contains_point;

package/src/core/geom/2d/compute_polygon_area_2d.d.ts

@@ -1,8 +1,7 @@
 /**
- * Uses Green's Theorem to compute area of a 2d polygon
- * @param {number[]|Float32Array|Float64Array} points
- * @param {number} point_count
- * @returns {number}
+ * @deprecated Renamed to {@link polygon2_signed_area}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function compute_polygon_area_2d(points: number[] | Float32Array | Float64Array, point_count: number): number;
+export const compute_polygon_area_2d: typeof polygon2_signed_area;
+import { polygon2_signed_area } from "./polygon/polygon2_signed_area.js";
 //# sourceMappingURL=compute_polygon_area_2d.d.ts.map

package/src/core/geom/2d/compute_polygon_area_2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_polygon_area_2d.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/2d/compute_polygon_area_2d.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,gDAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,eAClC,MAAM,GACJ,MAAM,CA6BlB"}
+{"version":3,"file":"compute_polygon_area_2d.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/2d/compute_polygon_area_2d.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,kEAA4D;qCANvB,mCAAmC"}

package/src/core/geom/2d/compute_polygon_area_2d.js

@@ -1,34 +1,7 @@
-/**
- * Uses Green's Theorem to compute area of a 2d polygon
- * @param {number[]|Float32Array|Float64Array} points
- * @param {number} point_count
- * @returns {number}
- */
-export function compute_polygon_area_2d(points, point_count) {
-    let sum = 0;
-
-    for (let i = 0; i < point_count - 1; i++) {
-        const i2 = i * 2;
-
-        const x0 = points[i2];
-        const y0 = points[i2 + 1];
-
-        const x1 = points[i2 + 2];
-        const y1 = points[i2 + 3];
-
-        sum += x0 * y1 - y0 * x1;
-    }
-
-    const first_x = points[0];
-    const first_y = points[1];
-
-    const last_x = points[point_count * 2 - 2];
-    const last_y = points[point_count * 2 - 1];
-
-    if (first_x !== last_x || first_y !== last_y) {
-        // doesn't wrap around, let's close the loop ourselves
-        sum += last_x * first_y - last_y * first_x;
-    }
-
-    return sum * 0.5;
-}
+import { polygon2_signed_area } from "./polygon/polygon2_signed_area.js";
+
+/**
+ * @deprecated Renamed to {@link polygon2_signed_area}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const compute_polygon_area_2d = polygon2_signed_area;

package/src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_bruteforce.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Compute a bounding polygon with a fixed given number of vertices such that the area would be minimal
+ * Uses combinatorial sets of edges to find the subset, which when extending those edges produces poly with minimum area
+ * NOTE: very very slow as it's O(n^k) where n is number of edges and k is number of points on the desired bounding polygon
+ *
+ * @param {number[]|Float32Array} output result will be written here
+ * @param {number} output_offset offset into output array where to write the result
+ * @param {number} output_point_count number of points to comprise bounding polygon
+ * @param {number[]} input_points Points to be bounded, must be an ordered loop. Must form a convex hull
+ * @param {number} input_point_count number of points in the input to consider
+ * @returns {number} number of points added to the output
+ *
+ * @see 2014 "Implementation of linear minimum area enclosing triangle algorithm" Ovidiu Pârvu & David Gilbert
+ * @see https://github.com/MagnusTiberius/humus3/blob/9d43412d6e6be869e224817f0a966fe48a1af40f/Util/ConvexHull.cpp#L281
+ */
+export function convex_hull_fixed_count_2d_bruteforce(output: number[] | Float32Array, output_offset: number, output_point_count: number, input_points: number[], input_point_count: number): number;
+//# sourceMappingURL=convex_hull_fixed_count_2d_bruteforce.d.ts.map

package/src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_bruteforce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convex_hull_fixed_count_2d_bruteforce.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_bruteforce.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH,8DAVW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,sBACN,MAAM,gBACN,MAAM,EAAE,qBACR,MAAM,GACJ,MAAM,CA0IlB"}

package/src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_bruteforce.js

@@ -0,0 +1,156 @@
+//
+
+import { array_copy } from "../../../collection/array/array_copy.js";
+import { UintArrayForCount } from "../../../collection/array/typed/uint_array_for_count.js";
+import { polygon2_signed_area } from "../polygon/polygon2_signed_area.js";
+import { ray2_ray2_compute_intersection_array_2d } from "../line/ray2_ray2_compute_intersection_array_2d.js";
+
+/**
+ * Compute a bounding polygon with a fixed given number of vertices such that the area would be minimal
+ * Uses combinatorial sets of edges to find the subset, which when extending those edges produces poly with minimum area
+ * NOTE: very very slow as it's O(n^k) where n is number of edges and k is number of points on the desired bounding polygon
+ *
+ * @param {number[]|Float32Array} output result will be written here
+ * @param {number} output_offset offset into output array where to write the result
+ * @param {number} output_point_count number of points to comprise bounding polygon
+ * @param {number[]} input_points Points to be bounded, must be an ordered loop. Must form a convex hull
+ * @param {number} input_point_count number of points in the input to consider
+ * @returns {number} number of points added to the output
+ *
+ * @see 2014 "Implementation of linear minimum area enclosing triangle algorithm" Ovidiu Pârvu & David Gilbert
+ * @see https://github.com/MagnusTiberius/humus3/blob/9d43412d6e6be869e224817f0a966fe48a1af40f/Util/ConvexHull.cpp#L281
+ */
+export function convex_hull_fixed_count_2d_bruteforce(
+    output, output_offset, output_point_count,
+    input_points, input_point_count
+) {
+
+    if (output_point_count >= input_point_count) {
+        // special case, input polygon is smaller or equal to in cardinality to what's desired
+        array_copy(input_points, 0, output, output_offset, input_point_count * 2);
+
+        return input_point_count;
+    }
+
+    /*
+    The following code iterated k-size sets of elements in the set of edges
+    @see https://stackoverflow.com/questions/29910312/algorithm-to-get-all-the-combinations-of-size-n-from-an-array-java
+    @see https://en.wikipedia.org/wiki/Combination
+     */
+
+    const edge_count = input_point_count;
+    const k = output_point_count;
+
+    const ArrayConstructor = UintArrayForCount(k);
+
+    /**
+     *
+     * @type {number[]}
+     */
+    const s = new ArrayConstructor(k);
+
+    let combos = 0;
+    let combos_valid = 0;
+
+    const intersections = new Float64Array(k * 2);
+    let best_area = Infinity;
+
+    /**
+     *
+     * @param {number[]|Uint16Array} subset
+     */
+    function process_combination(subset) {
+        combos++;
+
+        for (let i = 0; i < k; i++) {
+            // pick point indices to represent a line
+            const i0 = subset[i];
+            const i1 = subset[(i + 1) % k];
+
+            const i0_2 = i0 << 1;
+
+            const a0x = input_points[i0_2];
+            const a0y = input_points[i0_2 + 1];
+
+            const a1 = (i0 + 1) % input_point_count;
+
+            const a1_2 = a1 << 1;
+
+            const a1x = input_points[a1_2];
+            const a1y = input_points[a1_2 + 1];
+
+            const i1_2 = i1 << 1;
+
+            const b0x = input_points[i1_2];
+            const b0y = input_points[i1_2 + 1];
+
+            const b1 = (i1 + 1) % input_point_count;
+
+            const b1_2 = b1 << 1;
+
+            const b1x = input_points[b1_2];
+            const b1y = input_points[b1_2 + 1];
+
+            const a_dir_x = a1x - a0x;
+            const a_dir_y = a1y - a0y;
+
+            const b_dir_x = b1x - b0x;
+            const b_dir_y = b1y - b0y;
+
+            if (!ray2_ray2_compute_intersection_array_2d(
+                intersections, i << 1,
+                a0x, a0y, a_dir_x, a_dir_y,
+                b0x, b0y, b_dir_x, b_dir_y
+            )) {
+                // invalid combination, edges do not meet
+                return;
+            }
+        }
+
+        // we got intersection points, lets compute area
+        const area = polygon2_signed_area(intersections, k);
+
+        if (area < best_area) {
+            array_copy(intersections, 0, output, output_offset, k << 1);
+            best_area = area;
+        }
+
+        combos_valid++;
+    }
+
+
+    for (let i = 0; (s[i] = i) < k - 1; i++) {
+        // populate initial set
+    }
+
+    process_combination(s);
+
+    for (; ;) {
+        let i;
+
+        for (i = k - 1; i >= 0 && s[i] === edge_count - k + i; i--) {
+            // find position of item that can be incremented
+        }
+
+        if (i < 0) {
+            break;
+        }
+
+        s[i]++; // increment this item
+
+        for (++i; i < k; i++) {
+            // fill up remaining items
+            s[i] = s[i - 1] + 1;
+        }
+
+        process_combination(s);
+    }
+
+    // console.log(`combinations:  ${combos}, valid: ${combos_valid} (${(combos_valid * 100 / combos).toFixed(2)}%)`);
+    if(combos_valid === 0){
+        // no valid combinations
+        return 0;
+    }
+
+    return output_point_count;
+}