@mlightcad/cad-simple-viewer 1.8.0-preview.2 → 1.8.0-preview.4

package/lib/smartBlock/AcEdShapeMatcher.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Finds repeated copies of a group of shapes ("block instances") under a
+ * similarity transform: translation, rotation, optional uniform scale and
+ * optional mirroring.
+ *
+ * Pure geometry: shapes are described by {@link AcEdShapeFeature}s so the
+ * algorithm is testable without the data model.
+ */
+/** Plain 2D point or vector used by shape matching. */
+export interface AcEdPoint2d {
+    x: number;
+    y: number;
+}
+/** One shape to match. */
+export interface AcEdShapeFeature<Id = unknown> {
+    id: Id;
+    /**
+     * Shape class; only equal kinds match. Encode anything that must be
+     * identical here (e.g. `line`, `polyline:closed:4`).
+     */
+    kind: string;
+    /**
+     * Optional content label (the string of a text). Labels must be equal for
+     * two shapes to match unless {@link AcEdShapeMatchOptions.ignoreLabels} is
+     * set, which lets copies differ in their text (text variations).
+     */
+    label?: string;
+    /** Reference point that moves with the shape (midpoint, center, ...). */
+    center: AcEdPoint2d;
+    /** Characteristic length (line length, radius, perimeter, text height). */
+    size: number;
+    /**
+     * Characteristic points (end points, vertices, samples). Matching compares
+     * them as a set, so drawing direction does not matter. Rotation-invariant
+     * shapes (circles) may leave this empty.
+     */
+    points: AcEdPoint2d[];
+    /**
+     * Outline of the shape as a polyline, curves finely flattened; a closed
+     * outline repeats its first point at the end. When both shapes have one,
+     * they match when every outline vertex of each lies within tolerance of
+     * the other outline, however either was split into vertices or where a
+     * closed one starts. {@link points} then only orient the search.
+     */
+    path?: AcEdPoint2d[];
+}
+/** 2D affine map: `x' = a·x + c·y + e`, `y' = b·x + d·y + f`. */
+export interface AcEdAffine2d {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+}
+/** One found copy of the template. */
+export interface AcEdShapeMatch<Id = unknown> {
+    /** Maps template coordinates onto this copy. */
+    transform: AcEdAffine2d;
+    /** Rotation in radians. */
+    rotation: number;
+    /** Uniform scale. */
+    scale: number;
+    /** True when the copy is mirrored. */
+    mirrored: boolean;
+    /** Ids of the matched shapes, in template order. */
+    ids: Id[];
+}
+/** Tuning for {@link acedFindShapeMatches}. */
+export interface AcEdShapeMatchOptions<Id = unknown> {
+    /** Absolute tolerance. Default: 0.2 % of the template extent. */
+    tolerance?: number;
+    /** Accept rotated copies. Default `true`. */
+    allowRotation?: boolean;
+    /** Accept mirrored copies. Default `true`. */
+    allowMirror?: boolean;
+    /** Accept uniformly scaled copies. Default `false`. */
+    allowScale?: boolean;
+    /**
+     * Ignore {@link AcEdShapeFeature.label} differences so copies whose texts
+     * differ still match. Default `false`.
+     */
+    ignoreLabels?: boolean;
+    /**
+     * Extra check of a found copy, e.g. that it also carries matching texts.
+     * Returning `false` makes the search try the copy's other transforms
+     * (symmetric shapes have several) before giving up on it. Called at most
+     * once per accepted copy with `true`, so it may record state.
+     */
+    accept?: (match: AcEdShapeMatch<Id>) => boolean;
+    /**
+     * Reuses spatial indexes between searches over the same candidates (the
+     * same shapes, template shapes included). Only share a cache while the
+     * candidate set does not change.
+     */
+    gridCache?: AcEdShapeGridCache;
+}
+/**
+ * Opaque store of spatial indexes for {@link AcEdShapeMatchOptions.gridCache}.
+ * Create one per unchanged candidate set, e.g. per detection run.
+ */
+export declare class AcEdShapeGridCache {
+}
+/** Applies an affine map to a point. */
+export declare function acedApplyAffine2d(t: AcEdAffine2d, p: AcEdPoint2d): AcEdPoint2d;
+/**
+ * True when `from`, mapped by `t`, lands on `to` within `tol`: their
+ * outlines lie on each other when both have one ({@link AcEdShapeFeature.path}),
+ * otherwise their characteristic points coincide as sets. Center, size,
+ * kind and label are not checked here.
+ *
+ * @param from - Shape to map.
+ * @param to - Shape it should land on.
+ * @param t - Map from `from`'s coordinates to `to`'s.
+ * @param tol - Absolute tolerance in `to`'s coordinates.
+ */
+export declare function acedShapeLandsOn(from: AcEdShapeFeature, to: AcEdShapeFeature, t: AcEdAffine2d, tol: number): boolean;
+/**
+ * Finds copies of `template` among `candidates`.
+ *
+ * Each copy is located through an anchor pair that fixes the similarity
+ * transform:
+ *
+ * - Anchor 0 is the template shape whose kind is rarest among the
+ *   candidates (fewest seeds to try); among equals, the largest.
+ * - Anchor 1 is the shape whose center is farthest from anchor 0. When all
+ *   shapes share one center (a single polyline, concentric shapes), the
+ *   farthest characteristic point of anchor 0 fixes rotation and mirroring
+ *   instead; shapes without any orientation (circles) match by translation
+ *   (and scale) only.
+ *
+ * Every template shape must then land on a free candidate of the same kind,
+ * label, size and point set. Shapes are checked rarest kind first, so a
+ * wrong transform is rejected early. Matches never share shapes and never
+ * reuse template shapes.
+ *
+ * Cost is roughly `seeds × partners × template size` grid lookups, where
+ * seeds are the candidates of the first anchor kind; candidate grids are per
+ * kind so dense drawings do not slow down unrelated lookups.
+ *
+ * @param template - Shapes of one instance (at least one).
+ * @param candidates - Shapes to search, typically the rest of the drawing.
+ * @param options - Tolerance and allowed transform types.
+ */
+export declare function acedFindShapeMatches<Id>(template: AcEdShapeFeature<Id>[], candidates: AcEdShapeFeature<Id>[], options?: AcEdShapeMatchOptions<Id>): AcEdShapeMatch<Id>[];
+//# sourceMappingURL=AcEdShapeMatcher.d.ts.map

package/lib/smartBlock/AcEdShapeMatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcEdShapeMatcher.d.ts","sourceRoot":"","sources":["../../src/smartBlock/AcEdShapeMatcher.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,uDAAuD;AACvD,MAAM,WAAW,WAAW;IAC1B,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAUD,0BAA0B;AAC1B,MAAM,WAAW,gBAAgB,CAAC,EAAE,GAAG,OAAO;IAC5C,EAAE,EAAE,EAAE,CAAA;IACN;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,yEAAyE;IACzE,MAAM,EAAE,WAAW,CAAA;IACnB,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,MAAM,EAAE,WAAW,EAAE,CAAA;IACrB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,WAAW,EAAE,CAAA;CACrB;AAED,iEAAiE;AACjE,MAAM,WAAW,YAAY;IAC3B,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,sCAAsC;AACtC,MAAM,WAAW,cAAc,CAAC,EAAE,GAAG,OAAO;IAC1C,gDAAgD;IAChD,SAAS,EAAE,YAAY,CAAA;IACvB,2BAA2B;IAC3B,QAAQ,EAAE,MAAM,CAAA;IAChB,qBAAqB;IACrB,KAAK,EAAE,MAAM,CAAA;IACb,sCAAsC;IACtC,QAAQ,EAAE,OAAO,CAAA;IACjB,oDAAoD;IACpD,GAAG,EAAE,EAAE,EAAE,CAAA;CACV;AAED,+CAA+C;AAC/C,MAAM,WAAW,qBAAqB,CAAC,EAAE,GAAG,OAAO;IACjD,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,6CAA6C;IAC7C,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,8CAA8C;IAC9C,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,uDAAuD;IACvD,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,CAAC,EAAE,CAAC,KAAK,OAAO,CAAA;IAC/C;;;;OAIG;IACH,SAAS,CAAC,EAAE,kBAAkB,CAAA;CAC/B;AAED;;;GAGG;AACH,qBAAa,kBAAkB;CAAG;AAuBlC,wCAAwC;AACxC,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,WAAW,GACb,WAAW,CAEb;AA0ID;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,gBAAgB,EACtB,EAAE,EAAE,gBAAgB,EACpB,CAAC,EAAE,YAAY,EACf,GAAG,EAAE,MAAM,GACV,OAAO,CAWT;AA6DD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EACrC,QAAQ,EAAE,gBAAgB,CAAC,EAAE,CAAC,EAAE,EAChC,UAAU,EAAE,gBAAgB,CAAC,EAAE,CAAC,EAAE,EAClC,OAAO,GAAE,qBAAqB,CAAC,EAAE,CAAM,GACtC,cAAc,CAAC,EAAE,CAAC,EAAE,CAgNtB"}