Virtual whiteboard for sketching hand-drawn like diagrams
feat: add approximate elements in bbox detection (#6727)
Ared5e3f436dc52
diff --git a/src/element/Hyperlink.tsx b/src/element/Hyperlink.tsxindex 720f17824a..0e20661c3d 100644--- a/src/element/Hyperlink.tsx+++ b/src/element/Hyperlink.tsx@@ -392,7 +392,7 @@ export const getLinkHandleFromCoords = ([x1, y1, x2, y2]: Bounds,angle: number,appState: Pick<UIAppState, "zoom">,-): [x: number, y: number, width: number, height: number] => {+): Bounds => {const size = DEFAULT_LINK_SIZE;const linkWidth = size / appState.zoom.value;const linkHeight = size / appState.zoom.value;diff --git a/src/element/bounds.ts b/src/element/bounds.tsindex a94e1308d7..d0d0feba8d 100644--- a/src/element/bounds.ts+++ b/src/element/bounds.ts@@ -34,7 +34,12 @@ export type RectangleBox = {type MaybeQuadraticSolution = [number | null, number | null] | false;// x and y position of top left corner, x and y position of bottom right corner-export type Bounds = readonly [x1: number, y1: number, x2: number, y2: number];+export type Bounds = readonly [+ minX: number,+ minY: number,+ maxX: number,+ maxY: number,+];export class ElementBounds {private static boundsCache = new WeakMap<@@ -63,7 +68,7 @@ export class ElementBounds {}private static calculateBounds(element: ExcalidrawElement): Bounds {- let bounds: [number, number, number, number];+ let bounds: Bounds;const [x1, y1, x2, y2, cx, cy] = getElementAbsoluteCoords(element);@@ -387,7 +392,7 @@ const getCubicBezierCurveBound = (export const getMinMaxXYFromCurvePathOps = (ops: Op[],transformXY?: (x: number, y: number) => [number, number],-): [number, number, number, number] => {+): Bounds => {let currentP: Point = [0, 0];const { minX, minY, maxX, maxY } = ops.reduce(@@ -435,9 +440,9 @@ export const getMinMaxXYFromCurvePathOps = (return [minX, minY, maxX, maxY];};-const getBoundsFromPoints = (+export const getBoundsFromPoints = (points: ExcalidrawFreeDrawElement["points"],-): [number, number, number, number] => {+): Bounds => {let minX = Infinity;let minY = Infinity;let maxX = -Infinity;@@ -589,7 +594,7 @@ const getLinearElementRotatedBounds = (element: ExcalidrawLinearElement,cx: number,cy: number,-): [number, number, number, number] => {+): Bounds => {if (element.points.length < 2) {const [pointX, pointY] = element.points[0];const [x, y] = rotate(@@ -600,7 +605,7 @@ const getLinearElementRotatedBounds = (element.angle,);- let coords: [number, number, number, number] = [x, y, x, y];+ let coords: Bounds = [x, y, x, y];const boundTextElement = getBoundTextElement(element);if (boundTextElement) {const coordsWithBoundText = LinearElementEditor.getMinMaxXYWithBoundText(@@ -625,12 +630,7 @@ const getLinearElementRotatedBounds = (const transformXY = (x: number, y: number) =>rotate(element.x + x, element.y + y, cx, cy, element.angle);const res = getMinMaxXYFromCurvePathOps(ops, transformXY);- let coords: [number, number, number, number] = [- res[0],- res[1],- res[2],- res[3],- ];+ let coords: Bounds = [res[0], res[1], res[2], res[3]];const boundTextElement = getBoundTextElement(element);if (boundTextElement) {const coordsWithBoundText = LinearElementEditor.getMinMaxXYWithBoundText(@@ -692,7 +692,7 @@ export const getResizedElementAbsoluteCoords = (nextWidth: number,nextHeight: number,normalizePoints: boolean,-): [number, number, number, number] => {+): Bounds => {if (!(isLinearElement(element) || isFreeDrawElement(element))) {return [element.x,@@ -709,7 +709,7 @@ export const getResizedElementAbsoluteCoords = (normalizePoints,);- let bounds: [number, number, number, number];+ let bounds: Bounds;if (isFreeDrawElement(element)) {// Free Draw@@ -740,7 +740,7 @@ export const getResizedElementAbsoluteCoords = (export const getElementPointsCoords = (element: ExcalidrawLinearElement,points: readonly (readonly [number, number])[],-): [number, number, number, number] => {+): Bounds => {// This might be computationally heaveyconst gen = rough.generator();const curve =diff --git a/src/element/linearElementEditor.ts b/src/element/linearElementEditor.tsindex adc5aafc40..9ee490b393 100644--- a/src/element/linearElementEditor.ts+++ b/src/element/linearElementEditor.ts@@ -21,6 +21,7 @@ import {} from "../math";import { getElementAbsoluteCoords, getLockedLinearCursorAlignSize } from ".";import {+ Bounds,getCurvePathOps,getElementPointsCoords,getMinMaxXYFromCurvePathOps,@@ -1316,7 +1317,7 @@ export class LinearElementEditor {static getMinMaxXYWithBoundText = (element: ExcalidrawLinearElement,- elementBounds: [number, number, number, number],+ elementBounds: Bounds,boundTextElement: ExcalidrawTextElementWithContainer,): [number, number, number, number, number, number] => {let [x1, y1, x2, y2] = elementBounds;diff --git a/src/element/resizeTest.ts b/src/element/resizeTest.tsindex a3447208f8..9947a60825 100644--- a/src/element/resizeTest.ts+++ b/src/element/resizeTest.ts@@ -13,6 +13,7 @@ import {MaybeTransformHandleType,} from "./transformHandles";import { AppState, Zoom } from "../types";+import { Bounds } from "./bounds";const isInsideTransformHandle = (transformHandle: TransformHandle,@@ -87,7 +88,7 @@ export const getElementWithTransformHandleType = (};export const getTransformHandleTypeFromCoords = (- [x1, y1, x2, y2]: readonly [number, number, number, number],+ [x1, y1, x2, y2]: Bounds,scenePointerX: number,scenePointerY: number,zoom: Zoom,diff --git a/src/element/transformHandles.ts b/src/element/transformHandles.tsindex 1d2ccdcae8..9ad49c5b01 100644--- a/src/element/transformHandles.ts+++ b/src/element/transformHandles.ts@@ -4,7 +4,7 @@ import {PointerType,} from "./types";-import { getElementAbsoluteCoords } from "./bounds";+import { Bounds, getElementAbsoluteCoords } from "./bounds";import { rotate } from "../math";import { InteractiveCanvasAppState, Zoom } from "../types";import { isTextElement } from ".";@@ -23,7 +23,7 @@ export type TransformHandleDirection =export type TransformHandleType = TransformHandleDirection | "rotation";-export type TransformHandle = [number, number, number, number];+export type TransformHandle = Bounds;export type TransformHandles = Partial<{[T in TransformHandleType]: TransformHandle;}>;diff --git a/src/frame.ts b/src/frame.tsindex 4d77572c96..0e7bc93a00 100644--- a/src/frame.ts+++ b/src/frame.ts@@ -22,6 +22,7 @@ import { isFrameElement } from "./element";import { getElementsInGroup, selectGroupsFromGivenElements } from "./groups";import Scene, { ExcalidrawElementsIncludingDeleted } from "./scene/Scene";import { getElementLineSegments } from "./element/bounds";+import { doLineSegmentsIntersect } from "./packages/utils";// --------------------------- Frame State ------------------------------------export const bindElementsToFramesAfterDuplication = (@@ -55,130 +56,21 @@ export const bindElementsToFramesAfterDuplication = (}};-// --------------------------- Frame Geometry ----------------------------------class Point {- x: number;- y: number;-- constructor(x: number, y: number) {- this.x = x;- this.y = y;- }-}--class LineSegment {- first: Point;- second: Point;-- constructor(pointA: Point, pointB: Point) {- this.first = pointA;- this.second = pointB;- }-- public getBoundingBox(): [Point, Point] {- return [- new Point(- Math.min(this.first.x, this.second.x),- Math.min(this.first.y, this.second.y),- ),- new Point(- Math.max(this.first.x, this.second.x),- Math.max(this.first.y, this.second.y),- ),- ];- }-}--// https://martin-thoma.com/how-to-check-if-two-line-segments-intersect/-class FrameGeometry {- private static EPSILON = 0.000001;-- private static crossProduct(a: Point, b: Point) {- return a.x * b.y - b.x * a.y;- }-- private static doBoundingBoxesIntersect(- a: [Point, Point],- b: [Point, Point],- ) {- return (- a[0].x <= b[1].x &&- a[1].x >= b[0].x &&- a[0].y <= b[1].y &&- a[1].y >= b[0].y- );- }-- private static isPointOnLine(a: LineSegment, b: Point) {- const aTmp = new LineSegment(- new Point(0, 0),- new Point(a.second.x - a.first.x, a.second.y - a.first.y),- );- const bTmp = new Point(b.x - a.first.x, b.y - a.first.y);- const r = this.crossProduct(aTmp.second, bTmp);- return Math.abs(r) < this.EPSILON;- }-- private static isPointRightOfLine(a: LineSegment, b: Point) {- const aTmp = new LineSegment(- new Point(0, 0),- new Point(a.second.x - a.first.x, a.second.y - a.first.y),- );- const bTmp = new Point(b.x - a.first.x, b.y - a.first.y);- return this.crossProduct(aTmp.second, bTmp) < 0;- }-- private static lineSegmentTouchesOrCrossesLine(- a: LineSegment,- b: LineSegment,- ) {- return (- this.isPointOnLine(a, b.first) ||- this.isPointOnLine(a, b.second) ||- (this.isPointRightOfLine(a, b.first)- ? !this.isPointRightOfLine(a, b.second)- : this.isPointRightOfLine(a, b.second))- );- }-- private static doLineSegmentsIntersect(- a: [readonly [number, number], readonly [number, number]],- b: [readonly [number, number], readonly [number, number]],- ) {- const aSegment = new LineSegment(- new Point(a[0][0], a[0][1]),- new Point(a[1][0], a[1][1]),- );- const bSegment = new LineSegment(- new Point(b[0][0], b[0][1]),- new Point(b[1][0], b[1][1]),- );-- const box1 = aSegment.getBoundingBox();- const box2 = bSegment.getBoundingBox();- return (- this.doBoundingBoxesIntersect(box1, box2) &&- this.lineSegmentTouchesOrCrossesLine(aSegment, bSegment) &&- this.lineSegmentTouchesOrCrossesLine(bSegment, aSegment)- );- }-- public static isElementIntersectingFrame(- element: ExcalidrawElement,- frame: ExcalidrawFrameElement,- ) {- const frameLineSegments = getElementLineSegments(frame);+export function isElementIntersectingFrame(+ element: ExcalidrawElement,+ frame: ExcalidrawFrameElement,+) {+ const frameLineSegments = getElementLineSegments(frame);- const elementLineSegments = getElementLineSegments(element);+ const elementLineSegments = getElementLineSegments(element);- const intersecting = frameLineSegments.some((frameLineSegment) =>- elementLineSegments.some((elementLineSegment) =>- this.doLineSegmentsIntersect(frameLineSegment, elementLineSegment),- ),- );+ const intersecting = frameLineSegments.some((frameLineSegment) =>+ elementLineSegments.some((elementLineSegment) =>+ doLineSegmentsIntersect(frameLineSegment, elementLineSegment),+ ),+ );- return intersecting;- }+ return intersecting;}export const getElementsCompletelyInFrame = (@@ -206,10 +98,7 @@ export const isElementContainingFrame = (export const getElementsIntersectingFrame = (elements: readonly ExcalidrawElement[],frame: ExcalidrawFrameElement,-) =>- elements.filter((element) =>- FrameGeometry.isElementIntersectingFrame(element, frame),- );+) => elements.filter((element) => isElementIntersectingFrame(element, frame));export const elementsAreInFrameBounds = (elements: readonly ExcalidrawElement[],@@ -235,7 +124,7 @@ export const elementOverlapsWithFrame = () => {return (elementsAreInFrameBounds([element], frame) ||- FrameGeometry.isElementIntersectingFrame(element, frame) ||+ isElementIntersectingFrame(element, frame) ||isElementContainingFrame([frame], element, frame));};@@ -272,7 +161,7 @@ export const groupsAreAtLeastIntersectingTheFrame = (return !!elementsInGroup.find((element) =>elementsAreInFrameBounds([element], frame) ||- FrameGeometry.isElementIntersectingFrame(element, frame),+ isElementIntersectingFrame(element, frame),);};@@ -293,7 +182,7 @@ export const groupsAreCompletelyOutOfFrame = (elementsInGroup.find((element) =>elementsAreInFrameBounds([element], frame) ||- FrameGeometry.isElementIntersectingFrame(element, frame),+ isElementIntersectingFrame(element, frame),) === undefined);};@@ -353,7 +242,7 @@ export const getElementsInResizingFrame = ();for (const element of elementsNotCompletelyInFrame) {- if (!FrameGeometry.isElementIntersectingFrame(element, frame)) {+ if (!isElementIntersectingFrame(element, frame)) {if (element.groupIds.length === 0) {nextElementsInFrame.delete(element);}diff --git a/src/math.ts b/src/math.tsindex 376052095b..a56b97a72c 100644--- a/src/math.ts+++ b/src/math.ts@@ -505,3 +505,7 @@ export const rangeIntersection = (return null;};++export const isValueInRange = (value: number, min: number, max: number) => {+ return value >= min && value <= max;+};diff --git a/src/packages/bbox.ts b/src/packages/bbox.tsnew file mode 100644index 0000000000..91549c24a4--- /dev/null+++ b/src/packages/bbox.ts@@ -0,0 +1,65 @@+import { Bounds } from "../element/bounds";+import { Point } from "../types";++export type LineSegment = [Point, Point];++export function getBBox(line: LineSegment): Bounds {+ return [+ Math.min(line[0][0], line[1][0]),+ Math.min(line[0][1], line[1][1]),+ Math.max(line[0][0], line[1][0]),+ Math.max(line[0][1], line[1][1]),+ ];+}++export function crossProduct(a: Point, b: Point) {+ return a[0] * b[1] - b[0] * a[1];+}++export function doBBoxesIntersect(a: Bounds, b: Bounds) {+ return a[0] <= b[2] && a[2] >= b[0] && a[1] <= b[3] && a[3] >= b[1];+}++export function translate(a: Point, b: Point): Point {+ return [a[0] - b[0], a[1] - b[1]];+}++const EPSILON = 0.000001;++export function isPointOnLine(l: LineSegment, p: Point) {+ const p1 = translate(l[1], l[0]);+ const p2 = translate(p, l[0]);++ const r = crossProduct(p1, p2);++ return Math.abs(r) < EPSILON;+}++export function isPointRightOfLine(l: LineSegment, p: Point) {+ const p1 = translate(l[1], l[0]);+ const p2 = translate(p, l[0]);++ return crossProduct(p1, p2) < 0;+}++export function isLineSegmentTouchingOrCrossingLine(+ a: LineSegment,+ b: LineSegment,+) {+ return (+ isPointOnLine(a, b[0]) ||+ isPointOnLine(a, b[1]) ||+ (isPointRightOfLine(a, b[0])+ ? !isPointRightOfLine(a, b[1])+ : isPointRightOfLine(a, b[1]))+ );+}++// https://martin-thoma.com/how-to-check-if-two-line-segments-intersect/+export function doLineSegmentsIntersect(a: LineSegment, b: LineSegment) {+ return (+ doBBoxesIntersect(getBBox(a), getBBox(b)) &&+ isLineSegmentTouchingOrCrossingLine(a, b) &&+ isLineSegmentTouchingOrCrossingLine(b, a)+ );+}diff --git a/src/packages/excalidraw/CHANGELOG.md b/src/packages/excalidraw/CHANGELOG.mdindex 897960798c..3878a6811a 100644--- a/src/packages/excalidraw/CHANGELOG.md+++ b/src/packages/excalidraw/CHANGELOG.md@@ -15,8 +15,8 @@ Please add the latest change on the top under the correct section.### Features+- Export `elementsOverlappingBBox`, `isElementInsideBBox`, `elementPartiallyOverlapsWithOrContainsBBox` helpers for filtering/checking if elements within bounds. [#6727](https://github.com/excalidraw/excalidraw/pull/6727)- Regenerate ids by default when using transform api and also update bindings by 0.5px to avoid possible overlapping [#7195](https://github.com/excalidraw/excalidraw/pull/7195)-- Add `selected` prop for `MainMenu.Item` and `MainMenu.ItemCustom` components to indicate active state. [#7078](https://github.com/excalidraw/excalidraw/pull/7078)## 0.16.1 (2023-09-21)diff --git a/src/packages/excalidraw/index.tsx b/src/packages/excalidraw/index.tsxindex 901785f1cb..f0e9adc0b6 100644--- a/src/packages/excalidraw/index.tsx+++ b/src/packages/excalidraw/index.tsx@@ -254,3 +254,9 @@ export { DefaultSidebar } from "../../components/DefaultSidebar";export { normalizeLink } from "../../data/url";export { convertToExcalidrawElements } from "../../data/transform";++export {+ elementsOverlappingBBox,+ isElementInsideBBox,+ elementPartiallyOverlapsWithOrContainsBBox,+} from "../withinBounds";diff --git a/src/packages/utils.ts b/src/packages/utils.tsindex 8e55a1a051..2d896ed3cd 100644--- a/src/packages/utils.ts+++ b/src/packages/utils.ts@@ -229,6 +229,12 @@ export const exportToClipboard = async (}};+export * from "./bbox";+export {+ elementsOverlappingBBox,+ isElementInsideBBox,+ elementPartiallyOverlapsWithOrContainsBBox,+} from "./withinBounds";export { serializeAsJSON, serializeLibraryAsJSON } from "../data/json";export {loadFromBlob,diff --git a/src/packages/withinBounds.test.ts b/src/packages/withinBounds.test.tsnew file mode 100644index 0000000000..be301f8710--- /dev/null+++ b/src/packages/withinBounds.test.ts@@ -0,0 +1,262 @@+import { Bounds } from "../element/bounds";+import { API } from "../tests/helpers/api";+import {+ elementPartiallyOverlapsWithOrContainsBBox,+ elementsOverlappingBBox,+ isElementInsideBBox,+} from "./withinBounds";++const makeElement = (x: number, y: number, width: number, height: number) =>+ API.createElement({+ type: "rectangle",+ x,+ y,+ width,+ height,+ });++const makeBBox = (+ minX: number,+ minY: number,+ maxX: number,+ maxY: number,+): Bounds => [minX, minY, maxX, maxY];++describe("isElementInsideBBox()", () => {+ it("should return true if element is fully inside", () => {+ const bbox = makeBBox(0, 0, 100, 100);++ // bbox contains element+ expect(isElementInsideBBox(makeElement(0, 0, 100, 100), bbox)).toBe(true);+ expect(isElementInsideBBox(makeElement(10, 10, 90, 90), bbox)).toBe(true);+ });++ it("should return false if element is only partially overlapping", () => {+ const bbox = makeBBox(0, 0, 100, 100);++ // element contains bbox+ expect(isElementInsideBBox(makeElement(-10, -10, 110, 110), bbox)).toBe(+ false,+ );++ // element overlaps bbox from top-left+ expect(isElementInsideBBox(makeElement(-10, -10, 100, 100), bbox)).toBe(+ false,+ );+ // element overlaps bbox from top-right+ expect(isElementInsideBBox(makeElement(90, -10, 100, 100), bbox)).toBe(+ false,+ );+ // element overlaps bbox from bottom-left+ expect(isElementInsideBBox(makeElement(-10, 90, 100, 100), bbox)).toBe(+ false,+ );+ // element overlaps bbox from bottom-right+ expect(isElementInsideBBox(makeElement(90, 90, 100, 100), bbox)).toBe(+ false,+ );+ });++ it("should return false if element outside", () => {+ const bbox = makeBBox(0, 0, 100, 100);++ // outside diagonally+ expect(isElementInsideBBox(makeElement(110, 110, 100, 100), bbox)).toBe(+ false,+ );++ // outside on the left+ expect(isElementInsideBBox(makeElement(-110, 10, 50, 50), bbox)).toBe(+ false,+ );+ // outside on the right+ expect(isElementInsideBBox(makeElement(110, 10, 50, 50), bbox)).toBe(false);+ // outside on the top+ expect(isElementInsideBBox(makeElement(10, -110, 50, 50), bbox)).toBe(+ false,+ );+ // outside on the bottom+ expect(isElementInsideBBox(makeElement(10, 110, 50, 50), bbox)).toBe(false);+ });++ it("should return true if bbox contains element and flag enabled", () => {+ const bbox = makeBBox(0, 0, 100, 100);++ // element contains bbox+ expect(+ isElementInsideBBox(makeElement(-10, -10, 110, 110), bbox, true),+ ).toBe(true);++ // bbox contains element+ expect(isElementInsideBBox(makeElement(0, 0, 100, 100), bbox)).toBe(true);+ expect(isElementInsideBBox(makeElement(10, 10, 90, 90), bbox)).toBe(true);+ });+});++describe("elementPartiallyOverlapsWithOrContainsBBox()", () => {+ it("should return true if element overlaps, is inside, or contains", () => {+ const bbox = makeBBox(0, 0, 100, 100);++ // bbox contains element+ expect(+ elementPartiallyOverlapsWithOrContainsBBox(+ makeElement(0, 0, 100, 100),+ bbox,+ ),+ ).toBe(true);+ expect(+ elementPartiallyOverlapsWithOrContainsBBox(+ makeElement(10, 10, 90, 90),+ bbox,+ ),+ ).toBe(true);++ // element contains bbox+ expect(+ elementPartiallyOverlapsWithOrContainsBBox(+ makeElement(-10, -10, 110, 110),+ bbox,+ ),+ ).toBe(true);++ // element overlaps bbox from top-left+ expect(+ elementPartiallyOverlapsWithOrContainsBBox(+ makeElement(-10, -10, 100, 100),+ bbox,+ ),+ ).toBe(true);+ // element overlaps bbox from top-right+ expect(+ elementPartiallyOverlapsWithOrContainsBBox(+ makeElement(90, -10, 100, 100),+ bbox,+ ),+ ).toBe(true);+ // element overlaps bbox from bottom-left+ expect(+ elementPartiallyOverlapsWithOrContainsBBox(+ makeElement(-10, 90, 100, 100),+ bbox,+ ),+ ).toBe(true);+ // element overlaps bbox from bottom-right+ expect(+ elementPartiallyOverlapsWithOrContainsBBox(+ makeElement(90, 90, 100, 100),+ bbox,+ ),+ ).toBe(true);+ });++ it("should return false if element does not overlap", () => {+ const bbox = makeBBox(0, 0, 100, 100);++ // outside diagonally+ expect(+ elementPartiallyOverlapsWithOrContainsBBox(+ makeElement(110, 110, 100, 100),+ bbox,+ ),+ ).toBe(false);++ // outside on the left+ expect(+ elementPartiallyOverlapsWithOrContainsBBox(+ makeElement(-110, 10, 50, 50),+ bbox,+ ),+ ).toBe(false);+ // outside on the right+ expect(+ elementPartiallyOverlapsWithOrContainsBBox(+ makeElement(110, 10, 50, 50),+ bbox,+ ),+ ).toBe(false);+ // outside on the top+ expect(+ elementPartiallyOverlapsWithOrContainsBBox(+ makeElement(10, -110, 50, 50),+ bbox,+ ),+ ).toBe(false);+ // outside on the bottom+ expect(+ elementPartiallyOverlapsWithOrContainsBBox(+ makeElement(10, 110, 50, 50),+ bbox,+ ),+ ).toBe(false);+ });+});++describe("elementsOverlappingBBox()", () => {+ it("should return elements that overlap bbox", () => {+ const bbox = makeBBox(0, 0, 100, 100);++ const rectOutside = makeElement(110, 110, 100, 100);+ const rectInside = makeElement(10, 10, 90, 90);+ const rectContainingBBox = makeElement(-10, -10, 110, 110);+ const rectOverlappingTopLeft = makeElement(-10, -10, 50, 50);++ expect(+ elementsOverlappingBBox({+ bounds: bbox,+ type: "overlap",+ elements: [+ rectOutside,+ rectInside,+ rectContainingBBox,+ rectOverlappingTopLeft,+ ],+ }),+ ).toEqual([rectInside, rectContainingBBox, rectOverlappingTopLeft]);+ });++ it("should return elements inside/containing bbox", () => {+ const bbox = makeBBox(0, 0, 100, 100);++ const rectOutside = makeElement(110, 110, 100, 100);+ const rectInside = makeElement(10, 10, 90, 90);+ const rectContainingBBox = makeElement(-10, -10, 110, 110);+ const rectOverlappingTopLeft = makeElement(-10, -10, 50, 50);++ expect(+ elementsOverlappingBBox({+ bounds: bbox,+ type: "contain",+ elements: [+ rectOutside,+ rectInside,+ rectContainingBBox,+ rectOverlappingTopLeft,+ ],+ }),+ ).toEqual([rectInside, rectContainingBBox]);+ });++ it("should return elements inside bbox", () => {+ const bbox = makeBBox(0, 0, 100, 100);++ const rectOutside = makeElement(110, 110, 100, 100);+ const rectInside = makeElement(10, 10, 90, 90);+ const rectContainingBBox = makeElement(-10, -10, 110, 110);+ const rectOverlappingTopLeft = makeElement(-10, -10, 50, 50);++ expect(+ elementsOverlappingBBox({+ bounds: bbox,+ type: "inside",+ elements: [+ rectOutside,+ rectInside,+ rectContainingBBox,+ rectOverlappingTopLeft,+ ],+ }),+ ).toEqual([rectInside]);+ });++ // TODO test linear, freedraw, and diamond element types (+rotated)+});diff --git a/src/packages/withinBounds.ts b/src/packages/withinBounds.tsnew file mode 100644index 0000000000..75ea10b721--- /dev/null+++ b/src/packages/withinBounds.ts@@ -0,0 +1,206 @@+import type {+ ExcalidrawElement,+ ExcalidrawFreeDrawElement,+ ExcalidrawLinearElement,+ NonDeletedExcalidrawElement,+} from "../element/types";+import {+ isArrowElement,+ isFreeDrawElement,+ isLinearElement,+ isTextElement,+} from "../element/typeChecks";+import { isValueInRange, rotatePoint } from "../math";+import type { Point } from "../types";+import { Bounds } from "../element/bounds";++type Element = NonDeletedExcalidrawElement;+type Elements = readonly NonDeletedExcalidrawElement[];++type Points = readonly Point[];++/** @returns vertices relative to element's top-left [0,0] position */+const getNonLinearElementRelativePoints = (+ element: Exclude<+ Element,+ ExcalidrawLinearElement | ExcalidrawFreeDrawElement+ >,+): [TopLeft: Point, TopRight: Point, BottomRight: Point, BottomLeft: Point] => {+ if (element.type === "diamond") {+ return [+ [element.width / 2, 0],+ [element.width, element.height / 2],+ [element.width / 2, element.height],+ [0, element.height / 2],+ ];+ }+ return [+ [0, 0],+ [0 + element.width, 0],+ [0 + element.width, element.height],+ [0, element.height],+ ];+};++/** @returns vertices relative to element's top-left [0,0] position */+const getElementRelativePoints = (element: ExcalidrawElement): Points => {+ if (isLinearElement(element) || isFreeDrawElement(element)) {+ return element.points;+ }+ return getNonLinearElementRelativePoints(element);+};++const getMinMaxPoints = (points: Points) => {+ const ret = points.reduce(+ (limits, [x, y]) => {+ limits.minY = Math.min(limits.minY, y);+ limits.minX = Math.min(limits.minX, x);++ limits.maxX = Math.max(limits.maxX, x);+ limits.maxY = Math.max(limits.maxY, y);++ return limits;+ },+ {+ minX: Infinity,+ minY: Infinity,+ maxX: -Infinity,+ maxY: -Infinity,+ cx: 0,+ cy: 0,+ },+ );++ ret.cx = (ret.maxX + ret.minX) / 2;+ ret.cy = (ret.maxY + ret.minY) / 2;++ return ret;+};++const getRotatedBBox = (element: Element): Bounds => {+ const points = getElementRelativePoints(element);++ const { cx, cy } = getMinMaxPoints(points);+ const centerPoint: Point = [cx, cy];++ const rotatedPoints = points.map((point) =>+ rotatePoint([point[0], point[1]], centerPoint, element.angle),+ );+ const { minX, minY, maxX, maxY } = getMinMaxPoints(rotatedPoints);++ return [+ minX + element.x,+ minY + element.y,+ maxX + element.x,+ maxY + element.y,+ ];+};++export const isElementInsideBBox = (+ element: Element,+ bbox: Bounds,+ eitherDirection = false,+): boolean => {+ const elementBBox = getRotatedBBox(element);++ const elementInsideBbox =+ bbox[0] <= elementBBox[0] &&+ bbox[2] >= elementBBox[2] &&+ bbox[1] <= elementBBox[1] &&+ bbox[3] >= elementBBox[3];++ if (!eitherDirection) {+ return elementInsideBbox;+ }++ if (elementInsideBbox) {+ return true;+ }++ return (+ elementBBox[0] <= bbox[0] &&+ elementBBox[2] >= bbox[2] &&+ elementBBox[1] <= bbox[1] &&+ elementBBox[3] >= bbox[3]+ );+};++export const elementPartiallyOverlapsWithOrContainsBBox = (+ element: Element,+ bbox: Bounds,+): boolean => {+ const elementBBox = getRotatedBBox(element);++ return (+ (isValueInRange(elementBBox[0], bbox[0], bbox[2]) ||+ isValueInRange(bbox[0], elementBBox[0], elementBBox[2])) &&+ (isValueInRange(elementBBox[1], bbox[1], bbox[3]) ||+ isValueInRange(bbox[1], elementBBox[1], elementBBox[3]))+ );+};++export const elementsOverlappingBBox = ({+ elements,+ bounds,+ type,+ errorMargin = 0,+}: {+ elements: Elements;+ bounds: Bounds;+ /** safety offset. Defaults to 0. */+ errorMargin?: number;+ /**+ * - overlap: elements overlapping or inside bounds+ * - contain: elements inside bounds or bounds inside elements+ * - inside: elements inside bounds+ **/+ type: "overlap" | "contain" | "inside";+}) => {+ const adjustedBBox: Bounds = [+ bounds[0] - errorMargin,+ bounds[1] - errorMargin,+ bounds[2] + errorMargin,+ bounds[3] + errorMargin,+ ];++ const includedElementSet = new Set<string>();++ for (const element of elements) {+ if (includedElementSet.has(element.id)) {+ continue;+ }++ const isOverlaping =+ type === "overlap"+ ? elementPartiallyOverlapsWithOrContainsBBox(element, adjustedBBox)+ : type === "inside"+ ? isElementInsideBBox(element, adjustedBBox)+ : isElementInsideBBox(element, adjustedBBox, true);++ if (isOverlaping) {+ includedElementSet.add(element.id);++ if (element.boundElements) {+ for (const boundElement of element.boundElements) {+ includedElementSet.add(boundElement.id);+ }+ }++ if (isTextElement(element) && element.containerId) {+ includedElementSet.add(element.containerId);+ }++ if (isArrowElement(element)) {+ if (element.startBinding) {+ includedElementSet.add(element.startBinding.elementId);+ }++ if (element.endBinding) {+ includedElementSet.add(element.endBinding?.elementId);+ }+ }+ }+ }++ return elements.filter((element) => includedElementSet.has(element.id));+};diff --git a/src/scene/export.ts b/src/scene/export.tsindex ca838f0530..b94dc27c4e 100644--- a/src/scene/export.ts+++ b/src/scene/export.ts@@ -1,6 +1,10 @@import rough from "roughjs/bin/rough";import { NonDeletedExcalidrawElement } from "../element/types";-import { getCommonBounds, getElementAbsoluteCoords } from "../element/bounds";+import {+ Bounds,+ getCommonBounds,+ getElementAbsoluteCoords,+} from "../element/bounds";import { renderSceneToSvg, renderStaticScene } from "../renderer/renderScene";import { distance, isOnlyExportingSingleFrame } from "../utils";import { AppState, BinaryFiles } from "../types";@@ -221,7 +225,7 @@ export const exportToSvg = async (const getCanvasSize = (elements: readonly NonDeletedExcalidrawElement[],exportPadding: number,-): [number, number, number, number] => {+): Bounds => {// we should decide if we are exporting the whole canvas// if so, we are not clipping elements in the frame// and therefore, we should not do anything special