Virtual whiteboard for sketching hand-drawn like diagrams
refactor: update collision from ga to vector geometry (#7636)
Ryan Dibbdcd30a7330
diff --git a/packages/excalidraw/actions/actionFinalize.tsx b/packages/excalidraw/actions/actionFinalize.tsxindex a5f228f0f0..88ff366b64 100644--- a/packages/excalidraw/actions/actionFinalize.tsx+++ b/packages/excalidraw/actions/actionFinalize.tsx@@ -8,7 +8,6 @@ import { register } from "./register";import { mutateElement } from "../element/mutateElement";import { isPathALoop } from "../math";import { LinearElementEditor } from "../element/linearElementEditor";-import Scene from "../scene/Scene";import {maybeBindLinearElement,bindOrUnbindLinearElement,@@ -21,12 +20,9 @@ export const actionFinalize = register({name: "finalize",label: "",trackEvent: false,- perform: (- elements,- appState,- _,- { interactiveCanvas, focusContainer, scene },- ) => {+ perform: (elements, appState, _, app) => {+ const { interactiveCanvas, focusContainer, scene } = app;+const elementsMap = scene.getNonDeletedElementsMap();if (appState.editingLinearElement) {@@ -131,13 +127,7 @@ export const actionFinalize = register({-1,arrayToMap(elements),);- maybeBindLinearElement(- multiPointElement,- appState,- Scene.getScene(multiPointElement)!,- { x, y },- elementsMap,- );+ maybeBindLinearElement(multiPointElement, appState, { x, y }, app);}}diff --git a/packages/excalidraw/actions/actionFlip.ts b/packages/excalidraw/actions/actionFlip.tsindex be5e1a7aaf..d821b200d9 100644--- a/packages/excalidraw/actions/actionFlip.ts+++ b/packages/excalidraw/actions/actionFlip.ts@@ -7,7 +7,7 @@ import {NonDeletedSceneElementsMap,} from "../element/types";import { resizeMultipleElements } from "../element/resizeElements";-import { AppState } from "../types";+import { AppClassProperties, AppState } from "../types";import { arrayToMap } from "../utils";import { CODES, KEYS } from "../keys";import { getCommonBoundingBox } from "../element/bounds";@@ -32,6 +32,7 @@ export const actionFlipHorizontal = register({app.scene.getNonDeletedElementsMap(),appState,"horizontal",+ app,),appState,app,@@ -56,6 +57,7 @@ export const actionFlipVertical = register({app.scene.getNonDeletedElementsMap(),appState,"vertical",+ app,),appState,app,@@ -73,6 +75,7 @@ const flipSelectedElements = (elementsMap: NonDeletedSceneElementsMap,appState: Readonly<AppState>,flipDirection: "horizontal" | "vertical",+ app: AppClassProperties,) => {const selectedElements = getSelectedElements(getNonDeletedElements(elements),@@ -89,6 +92,7 @@ const flipSelectedElements = (elementsMap,appState,flipDirection,+ app,);const updatedElementsMap = arrayToMap(updatedElements);@@ -104,6 +108,7 @@ const flipElements = (elementsMap: NonDeletedSceneElementsMap,appState: AppState,flipDirection: "horizontal" | "vertical",+ app: AppClassProperties,): ExcalidrawElement[] => {const { minX, minY, maxX, maxY } = getCommonBoundingBox(selectedElements);@@ -118,7 +123,7 @@ const flipElements = ();isBindingEnabled(appState)- ? bindOrUnbindSelectedElements(selectedElements, elements, elementsMap)+ ? bindOrUnbindSelectedElements(selectedElements, app): unbindLinearElements(selectedElements, elementsMap);return selectedElements;diff --git a/packages/excalidraw/components/App.tsx b/packages/excalidraw/components/App.tsxindex b33e04850e..cd99fb6141 100644--- a/packages/excalidraw/components/App.tsx+++ b/packages/excalidraw/components/App.tsx@@ -107,8 +107,6 @@ import {getResizeOffsetXY,getLockedLinearCursorAlignSize,getTransformHandleTypeFromCoords,- hitTest,- isHittingElementBoundingBoxWithoutHittingElement,isInvisiblySmallElement,isNonDeletedElement,isTextElement,@@ -119,6 +117,7 @@ import {transformElements,updateTextElement,redrawTextBoundingBox,+ getElementAbsoluteCoords,} from "../element";import {bindOrUnbindLinearElement,@@ -162,6 +161,7 @@ import {isIframeElement,isIframeLikeElement,isMagicFrameElement,+ isTextBindableContainer,} from "../element/typeChecks";import {ExcalidrawBindableElement,@@ -212,7 +212,6 @@ import {} from "../math";import {calculateScrollCenter,- getElementsAtPosition,getElementsWithinSelection,getNormalizedZoom,getSelectedElements,@@ -223,6 +222,15 @@ import Scene from "../scene/Scene";import { RenderInteractiveSceneCallback, ScrollBars } from "../scene/types";import { getStateForZoom } from "../scene/zoom";import { findShapeByKey } from "../shapes";+import {+ GeometricShape,+ getClosedCurveShape,+ getCurveShape,+ getEllipseShape,+ getFreedrawShape,+ getPolygonShape,+} from "../../utils/geometry/shape";+import { isPointInShape } from "../../utils/collision";import {AppClassProperties,AppProps,@@ -318,11 +326,9 @@ import {getContainerElement,getDefaultLineHeight,getLineHeightInPx,- getTextBindableContainerAtPosition,isMeasureTextSupported,isValidTextContainer,} from "../element/textElement";-import { isHittingElementNotConsideringBoundingBox } from "../element/collision";import {showHyperlinkTooltip,hideHyperlinkToolip,@@ -407,6 +413,13 @@ import { AnimatedTrail } from "../animated-trail";import { LaserTrails } from "../laser-trails";import { withBatchedUpdates, withBatchedUpdatesThrottled } from "../reactUtils";import { getRenderOpacity } from "../renderer/renderElement";+import {+ hitElementBoundText,+ hitElementBoundingBox,+ hitElementBoundingBoxOnly,+ hitElementItself,+ shouldTestInside,+} from "../element/collision";import { textWysiwyg } from "../element/textWysiwyg";import { isOverScrollBars } from "../scene/scrollbars";import {@@ -2757,7 +2770,6 @@ class App extends React.Component<AppProps, AppState> {maybeBindLinearElement(multiElement,this.state,- this.scene,tupleToCoors(LinearElementEditor.getPointAtIndexGlobalCoordinates(multiElement,@@ -2765,7 +2777,7 @@ class App extends React.Component<AppProps, AppState> {elementsMap,),),- elementsMap,+ this,);}this.history.record(this.state, elements);@@ -4048,11 +4060,7 @@ class App extends React.Component<AppProps, AppState> {const selectedElements = this.scene.getSelectedElements(this.state);const elementsMap = this.scene.getNonDeletedElementsMap();isBindingEnabled(this.state)- ? bindOrUnbindSelectedElements(- selectedElements,- this.scene.getNonDeletedElements(),- elementsMap,- )+ ? bindOrUnbindSelectedElements(selectedElements, this): unbindLinearElements(selectedElements, elementsMap);this.setState({ suggestedBindings: [] });}@@ -4355,12 +4363,87 @@ class App extends React.Component<AppProps, AppState> {return null;}+ /**+ * get the pure geometric shape of an excalidraw element+ * which is then used for hit detection+ */+ public getElementShape(element: ExcalidrawElement): GeometricShape {+ switch (element.type) {+ case "rectangle":+ case "diamond":+ case "frame":+ case "magicframe":+ case "embeddable":+ case "image":+ case "iframe":+ case "text":+ case "selection":+ return getPolygonShape(element);+ case "arrow":+ case "line": {+ const roughShape =+ ShapeCache.get(element)?.[0] ??+ ShapeCache.generateElementShape(element, null)[0];+ const [, , , , cx, cy] = getElementAbsoluteCoords(+ element,+ this.scene.getNonDeletedElementsMap(),+ );++ return shouldTestInside(element)+ ? getClosedCurveShape(+ roughShape,+ [element.x, element.y],+ element.angle,+ [cx, cy],+ )+ : getCurveShape(roughShape, [element.x, element.y], element.angle, [+ cx,+ cy,+ ]);+ }++ case "ellipse":+ return getEllipseShape(element);++ case "freedraw": {+ const [, , , , cx, cy] = getElementAbsoluteCoords(+ element,+ this.scene.getNonDeletedElementsMap(),+ );+ return getFreedrawShape(element, [cx, cy], shouldTestInside(element));+ }+ }+ }++ private getBoundTextShape(element: ExcalidrawElement): GeometricShape | null {+ const boundTextElement = getBoundTextElement(+ element,+ this.scene.getNonDeletedElementsMap(),+ );++ if (boundTextElement) {+ if (element.type === "arrow") {+ return this.getElementShape({+ ...boundTextElement,+ // arrow's bound text accurate position is not stored in the element's property+ // but rather calculated and returned from the following static method+ ...LinearElementEditor.getBoundTextElementPosition(+ element,+ boundTextElement,+ this.scene.getNonDeletedElementsMap(),+ ),+ });+ }+ return this.getElementShape(boundTextElement);+ }++ return null;+ }+private getElementAtPosition(x: number,y: number,opts?: {- /** if true, returns the first selected element (with highest z-index)- of all hit elements */preferSelected?: boolean;includeBoundTextElement?: boolean;includeLockedElements?: boolean;@@ -4372,6 +4455,7 @@ class App extends React.Component<AppProps, AppState> {opts?.includeBoundTextElement,opts?.includeLockedElements,);+if (allHitElements.length > 1) {if (opts?.preferSelected) {for (let index = allHitElements.length - 1; index > -1; index--) {@@ -4382,22 +4466,20 @@ class App extends React.Component<AppProps, AppState> {}const elementWithHighestZIndex =allHitElements[allHitElements.length - 1];+// If we're hitting element with highest z-index only on its bounding box// while also hitting other element figure, the latter should be considered.- return isHittingElementBoundingBoxWithoutHittingElement(- elementWithHighestZIndex,- this.state,- this.frameNameBoundsCache,- x,- y,- this.scene.getNonDeletedElementsMap(),+ return isPointInShape(+ [x, y],+ this.getElementShape(elementWithHighestZIndex),)- ? allHitElements[allHitElements.length - 2]- : elementWithHighestZIndex;+ ? elementWithHighestZIndex+ : allHitElements[allHitElements.length - 2];}if (allHitElements.length === 1) {return allHitElements[0];}+return null;}@@ -4407,7 +4489,11 @@ class App extends React.Component<AppProps, AppState> {includeBoundTextElement: boolean = false,includeLockedElements: boolean = false,): NonDeleted<ExcalidrawElement>[] {- const elements =+ const iframeLikes: ExcalidrawIframeElement[] = [];++ const elementsMap = this.scene.getNonDeletedElementsMap();++ const elements = (includeBoundTextElement && includeLockedElements? this.scene.getNonDeletedElements(): this.scene@@ -4417,29 +4503,120 @@ class App extends React.Component<AppProps, AppState> {(includeLockedElements || !element.locked) &&(includeBoundTextElement ||!(isTextElement(element) && element.containerId)),- );+ )+ )+ .filter((el) => this.hitElement(x, y, el))+ .filter((element) => {+ // hitting a frame's element from outside the frame is not considered a hit+ const containingFrame = getContainingFrame(element, elementsMap);+ return containingFrame &&+ this.state.frameRendering.enabled &&+ this.state.frameRendering.clip+ ? isCursorInFrame({ x, y }, containingFrame, elementsMap)+ : true;+ })+ .filter((el) => {+ // The parameter elements comes ordered from lower z-index to higher.+ // We want to preserve that order on the returned array.+ // Exception being embeddables which should be on top of everything else in+ // terms of hit testing.+ if (isIframeElement(el)) {+ iframeLikes.push(el);+ return false;+ }+ return true;+ })+ .concat(iframeLikes) as NonDeleted<ExcalidrawElement>[];- const elementsMap = this.scene.getNonDeletedElementsMap();- return getElementsAtPosition(elements, (element) =>- hitTest(- element,- this.state,- this.frameNameBoundsCache,+ return elements;+ }++ private getHitThreshold() {+ return 10 / this.state.zoom.value;+ }++ private hitElement(+ x: number,+ y: number,+ element: ExcalidrawElement,+ considerBoundingBox = true,+ ) {+ // if the element is selected, then hit test is done against its bounding box+ if (+ considerBoundingBox &&+ this.state.selectedElementIds[element.id] &&+ shouldShowBoundingBox([element], this.state)+ ) {+ return hitElementBoundingBox(x,y,- elementsMap,- ),- ).filter((element) => {- // hitting a frame's element from outside the frame is not considered a hit- const containingFrame = getContainingFrame(element, elementsMap);- return containingFrame &&- this.state.frameRendering.enabled &&- this.state.frameRendering.clip- ? isCursorInFrame({ x, y }, containingFrame, elementsMap)- : true;+ element,+ this.scene.getNonDeletedElementsMap(),+ this.getHitThreshold(),+ );+ }++ // take bound text element into consideration for hit collision as well+ const hitBoundTextOfElement = hitElementBoundText(+ x,+ y,+ this.getBoundTextShape(element),+ );+ if (hitBoundTextOfElement) {+ return true;+ }++ return hitElementItself({+ x,+ y,+ element,+ shape: this.getElementShape(element),+ threshold: this.getHitThreshold(),+ frameNameBound: isFrameLikeElement(element)+ ? this.frameNameBoundsCache.get(element)+ : null,});}+ private getTextBindableContainerAtPosition(x: number, y: number) {+ const elements = this.scene.getNonDeletedElements();+ const selectedElements = this.scene.getSelectedElements(this.state);+ if (selectedElements.length === 1) {+ return isTextBindableContainer(selectedElements[0], false)+ ? selectedElements[0]+ : null;+ }+ let hitElement = null;+ // We need to do hit testing from front (end of the array) to back (beginning of the array)+ for (let index = elements.length - 1; index >= 0; --index) {+ if (elements[index].isDeleted) {+ continue;+ }+ const [x1, y1, x2, y2] = getElementAbsoluteCoords(+ elements[index],+ this.scene.getNonDeletedElementsMap(),+ );+ if (+ isArrowElement(elements[index]) &&+ hitElementItself({+ x,+ y,+ element: elements[index],+ shape: this.getElementShape(elements[index]),+ threshold: this.getHitThreshold(),+ })+ ) {+ hitElement = elements[index];+ break;+ } else if (x1 < x && x < x2 && y1 < y && y < y2) {+ hitElement = elements[index];+ break;+ }+ }++ return isTextBindableContainer(hitElement, false) ? hitElement : null;+ }+private startTextEditing = ({sceneX,sceneY,@@ -4667,25 +4844,19 @@ class App extends React.Component<AppProps, AppState> {return;}- const container = getTextBindableContainerAtPosition(- this.scene.getNonDeletedElements(),- this.state,- sceneX,- sceneY,- this.scene.getNonDeletedElementsMap(),- );+ const container = this.getTextBindableContainerAtPosition(sceneX, sceneY);if (container) {if (hasBoundTextElement(container) ||!isTransparent(container.backgroundColor) ||- isHittingElementNotConsideringBoundingBox(- container,- this.state,- this.frameNameBoundsCache,- [sceneX, sceneY],- this.scene.getNonDeletedElementsMap(),- )+ hitElementItself({+ x: sceneX,+ y: sceneY,+ element: container,+ shape: this.getElementShape(container),+ threshold: this.getHitThreshold(),+ })) {const midPoint = getContainerCenter(container,@@ -5281,7 +5452,7 @@ class App extends React.Component<AppProps, AppState> {scenePointer.x,scenePointer.y,);- const threshold = 10 / this.state.zoom.value;+ const threshold = this.getHitThreshold();const point = { ...pointerDownState.lastCoords };let samplingInterval = 0;while (samplingInterval <= distance) {@@ -5346,7 +5517,6 @@ class App extends React.Component<AppProps, AppState> {linearElementEditor.elementId,elementsMap,);- const boundTextElement = getBoundTextElement(element, elementsMap);if (!element) {return;@@ -5355,13 +5525,12 @@ class App extends React.Component<AppProps, AppState> {let hoverPointIndex = -1;let segmentMidPointHoveredCoords = null;if (- isHittingElementNotConsideringBoundingBox(+ hitElementItself({+ x: scenePointerX,+ y: scenePointerY,element,- this.state,- this.frameNameBoundsCache,- [scenePointerX, scenePointerY],- elementsMap,- )+ shape: this.getElementShape(element),+ })) {hoverPointIndex = LinearElementEditor.getPointIndexUnderCursor(element,@@ -5383,29 +5552,7 @@ class App extends React.Component<AppProps, AppState> {} else {setCursor(this.interactiveCanvas, CURSOR_TYPE.MOVE);}- } else if (- shouldShowBoundingBox([element], this.state) &&- isHittingElementBoundingBoxWithoutHittingElement(- element,- this.state,- this.frameNameBoundsCache,- scenePointerX,- scenePointerY,- elementsMap,- )- ) {- setCursor(this.interactiveCanvas, CURSOR_TYPE.MOVE);- } else if (- boundTextElement &&- hitTest(- boundTextElement,- this.state,- this.frameNameBoundsCache,- scenePointerX,- scenePointerY,- this.scene.getNonDeletedElementsMap(),- )- ) {+ } else if (this.hitElement(scenePointerX, scenePointerY, element)) {setCursor(this.interactiveCanvas, CURSOR_TYPE.MOVE);}@@ -6159,8 +6306,7 @@ class App extends React.Component<AppProps, AppState> {this.history,pointerDownState.origin,linearElementEditor,- this.scene.getNonDeletedElements(),- elementsMap,+ this,);if (ret.hitElement) {pointerDownState.hit.element = ret.hitElement;@@ -6383,7 +6529,7 @@ class App extends React.Component<AppProps, AppState> {}// How many pixels off the shape boundary we still consider a hit- const threshold = 10 / this.state.zoom.value;+ const threshold = this.getHitThreshold();const [x1, y1, x2, y2] = getCommonBounds(selectedElements);return (point.x > x1 - threshold &&@@ -6411,13 +6557,7 @@ class App extends React.Component<AppProps, AppState> {});// FIXME- let container = getTextBindableContainerAtPosition(- this.scene.getNonDeletedElements(),- this.state,- sceneX,- sceneY,- this.scene.getNonDeletedElementsMap(),- );+ let container = this.getTextBindableContainerAtPosition(sceneX, sceneY);if (hasBoundTextElement(element)) {container = element as ExcalidrawTextContainer;@@ -6497,8 +6637,7 @@ class App extends React.Component<AppProps, AppState> {const boundElement = getHoveredElementForBinding(pointerDownState.origin,- this.scene.getNonDeletedElements(),- this.scene.getNonDeletedElementsMap(),+ this,);this.scene.addNewElement(element);this.setState({@@ -6766,8 +6905,7 @@ class App extends React.Component<AppProps, AppState> {});const boundElement = getHoveredElementForBinding(pointerDownState.origin,- this.scene.getNonDeletedElements(),- this.scene.getNonDeletedElementsMap(),+ this,);this.scene.addNewElement(element);@@ -7551,7 +7689,6 @@ class App extends React.Component<AppProps, AppState> {? this.state.editingElement: null,snapLines: updateStable(prevState.snapLines, []),-originSnapOffset: null,}));@@ -7578,8 +7715,7 @@ class App extends React.Component<AppProps, AppState> {childEvent,this.state.editingLinearElement,this.state,- this.scene.getNonDeletedElements(),- elementsMap,+ this,);if (editingLinearElement !== this.state.editingLinearElement) {this.setState({@@ -7603,8 +7739,7 @@ class App extends React.Component<AppProps, AppState> {childEvent,this.state.selectedLinearElement,this.state,- this.scene.getNonDeletedElements(),- elementsMap,+ this,);const { startBindingElement, endBindingElement } =@@ -7753,9 +7888,8 @@ class App extends React.Component<AppProps, AppState> {maybeBindLinearElement(draggingElement,this.state,- this.scene,pointerCoords,- elementsMap,+ this,);}this.setState({ suggestedBindings: [], startBoundElement: null });@@ -8207,16 +8341,24 @@ class App extends React.Component<AppProps, AppState> {}if (+ // not dragged!pointerDownState.drag.hasOccurred &&+ // not resized!this.state.isResizing &&+ // only hitting the bounding box of the previous hit element((hitElement &&- isHittingElementBoundingBoxWithoutHittingElement(- hitElement,- this.state,- this.frameNameBoundsCache,- pointerDownState.origin.x,- pointerDownState.origin.y,- this.scene.getNonDeletedElementsMap(),+ hitElementBoundingBoxOnly(+ {+ x: pointerDownState.origin.x,+ y: pointerDownState.origin.y,+ element: hitElement,+ shape: this.getElementShape(hitElement),+ threshold: this.getHitThreshold(),+ frameNameBound: isFrameLikeElement(hitElement)+ ? this.frameNameBoundsCache.get(hitElement)+ : null,+ },+ elementsMap,)) ||(!hitElement &&pointerDownState.hit.hasHitCommonBoundingBoxOfSelectedElements))@@ -8232,6 +8374,8 @@ class App extends React.Component<AppProps, AppState> {activeEmbeddable: null,});}+ // reset cursor+ setCursor(this.interactiveCanvas, CURSOR_TYPE.AUTO);return;}@@ -8267,11 +8411,10 @@ class App extends React.Component<AppProps, AppState> {isBindingEnabled(this.state)? bindOrUnbindSelectedElements(this.scene.getSelectedElements(this.state),- this.scene.getNonDeletedElements(),- elementsMap,+ this,): unbindLinearElements(- this.scene.getSelectedElements(this.state),+ this.scene.getNonDeletedElements(),elementsMap,);}@@ -8758,8 +8901,7 @@ class App extends React.Component<AppProps, AppState> {}): void => {const hoveredBindableElement = getHoveredElementForBinding(pointerCoords,- this.scene.getNonDeletedElements(),- this.scene.getNonDeletedElementsMap(),+ this,);this.setState({suggestedBindings:@@ -8786,8 +8928,7 @@ class App extends React.Component<AppProps, AppState> {(acc: NonDeleted<ExcalidrawBindableElement>[], coords) => {const hoveredBindableElement = getHoveredElementForBinding(coords,- this.scene.getNonDeletedElements(),- this.scene.getNonDeletedElementsMap(),+ this,);if (hoveredBindableElement != null &&@@ -8815,8 +8956,7 @@ class App extends React.Component<AppProps, AppState> {}const suggestedBindings = getEligibleElementsForBinding(selectedElements,- this.scene.getNonDeletedElements(),- this.scene.getNonDeletedElementsMap(),+ this,);this.setState({ suggestedBindings });}diff --git a/packages/excalidraw/components/hyperlink/Hyperlink.tsx b/packages/excalidraw/components/hyperlink/Hyperlink.tsxindex 779305416f..932673ff15 100644--- a/packages/excalidraw/components/hyperlink/Hyperlink.tsx+++ b/packages/excalidraw/components/hyperlink/Hyperlink.tsx@@ -26,9 +26,9 @@ import clsx from "clsx";import { KEYS } from "../../keys";import { EVENT, HYPERLINK_TOOLTIP_DELAY } from "../../constants";import { getElementAbsoluteCoords } from "../../element/bounds";-import { getTooltipDiv, updateTooltipPosition } from "../Tooltip";+import { getTooltipDiv, updateTooltipPosition } from "../../components/Tooltip";import { getSelectedElements } from "../../scene";-import { isPointHittingElementBoundingBox } from "../../element/collision";+import { hitElementBoundingBox } from "../../element/collision";import { isLocalLink, normalizeLink } from "../../data/url";import "./Hyperlink.scss";@@ -425,15 +425,7 @@ const shouldHideLinkPopup = (const threshold = 15 / appState.zoom.value;// hitbox to prevent hiding when hovered in element bounding box- if (- isPointHittingElementBoundingBox(- element,- elementsMap,- [sceneX, sceneY],- threshold,- null,- )- ) {+ if (hitElementBoundingBox(sceneX, sceneY, element, elementsMap)) {return false;}const [x1, y1, x2] = getElementAbsoluteCoords(element, elementsMap);diff --git a/packages/excalidraw/components/hyperlink/helpers.ts b/packages/excalidraw/components/hyperlink/helpers.tsindex 9b7da3d767..92b8e3cd4f 100644--- a/packages/excalidraw/components/hyperlink/helpers.ts+++ b/packages/excalidraw/components/hyperlink/helpers.ts@@ -1,6 +1,6 @@import { MIME_TYPES } from "../../constants";import { Bounds, getElementAbsoluteCoords } from "../../element/bounds";-import { isPointHittingElementBoundingBox } from "../../element/collision";+import { hitElementBoundingBox } from "../../element/collision";import { ElementsMap, NonDeletedExcalidrawElement } from "../../element/types";import { rotate } from "../../math";import { DEFAULT_LINK_SIZE } from "../../renderer/renderElement";@@ -75,17 +75,10 @@ export const isPointHittingLink = (if (!element.link || appState.selectedElementIds[element.id]) {return false;}- const threshold = 4 / appState.zoom.value;if (!isMobile &&appState.viewModeEnabled &&- isPointHittingElementBoundingBox(- element,- elementsMap,- [x, y],- threshold,- null,- )+ hitElementBoundingBox(x, y, element, elementsMap)) {return true;}diff --git a/packages/excalidraw/element/binding.ts b/packages/excalidraw/element/binding.tsindex 8d3959bc7c..97f3ad25ab 100644--- a/packages/excalidraw/element/binding.ts+++ b/packages/excalidraw/element/binding.ts@@ -1,28 +1,37 @@+import * as GA from "../ga";+import * as GAPoint from "../gapoints";+import * as GADirection from "../gadirections";+import * as GALine from "../galines";+import * as GATransform from "../gatransforms";+import {- ExcalidrawLinearElement,ExcalidrawBindableElement,+ ExcalidrawElement,+ ExcalidrawRectangleElement,+ ExcalidrawDiamondElement,+ ExcalidrawTextElement,+ ExcalidrawEllipseElement,+ ExcalidrawFreeDrawElement,+ ExcalidrawImageElement,+ ExcalidrawFrameLikeElement,+ ExcalidrawIframeLikeElement,NonDeleted,- NonDeletedExcalidrawElement,+ ExcalidrawLinearElement,PointBinding,- ExcalidrawElement,+ NonDeletedExcalidrawElement,ElementsMap,NonDeletedSceneElementsMap,} from "./types";++import { getElementAbsoluteCoords } from "./bounds";+import { AppClassProperties, AppState, Point } from "../types";+import { isPointOnShape } from "../../utils/collision";import { getElementAtPosition } from "../scene";-import { AppState } from "../types";import {isBindableElement,isBindingElement,isLinearElement,} from "./typeChecks";-import {- bindingBorderTest,- distanceToBindableElement,- maxBindingGap,- determineFocusDistance,- intersectElementWithLine,- determineFocusPoint,-} from "./collision";import { mutateElement } from "./mutateElement";import Scene from "../scene/Scene";import { LinearElementEditor } from "./linearElementEditor";@@ -152,29 +161,22 @@ const bindOrUnbindLinearElementEdge = (export const bindOrUnbindSelectedElements = (selectedElements: NonDeleted<ExcalidrawElement>[],- elements: readonly ExcalidrawElement[],- elementsMap: NonDeletedSceneElementsMap,+ app: AppClassProperties,): void => {selectedElements.forEach((selectedElement) => {if (isBindingElement(selectedElement)) {bindOrUnbindLinearElement(selectedElement,- getElligibleElementForBindingElement(- selectedElement,- "start",- elements,- elementsMap,- ),- getElligibleElementForBindingElement(- selectedElement,- "end",- elements,- elementsMap,- ),- elementsMap,+ getElligibleElementForBindingElement(selectedElement, "start", app),+ getElligibleElementForBindingElement(selectedElement, "end", app),+ app.scene.getNonDeletedElementsMap(),);} else if (isBindableElement(selectedElement)) {- maybeBindBindableElement(selectedElement, elementsMap);+ maybeBindBindableElement(+ selectedElement,+ app.scene.getNonDeletedElementsMap(),+ app,+ );}});};@@ -182,40 +184,34 @@ export const bindOrUnbindSelectedElements = (const maybeBindBindableElement = (bindableElement: NonDeleted<ExcalidrawBindableElement>,elementsMap: NonDeletedSceneElementsMap,+ app: AppClassProperties,): void => {- getElligibleElementsForBindableElementAndWhere(- bindableElement,- elementsMap,- ).forEach(([linearElement, where]) =>- bindOrUnbindLinearElement(- linearElement,- where === "end" ? "keep" : bindableElement,- where === "start" ? "keep" : bindableElement,- elementsMap,- ),+ getElligibleElementsForBindableElementAndWhere(bindableElement, app).forEach(+ ([linearElement, where]) =>+ bindOrUnbindLinearElement(+ linearElement,+ where === "end" ? "keep" : bindableElement,+ where === "start" ? "keep" : bindableElement,+ elementsMap,+ ),);};export const maybeBindLinearElement = (linearElement: NonDeleted<ExcalidrawLinearElement>,appState: AppState,- scene: Scene,pointerCoords: { x: number; y: number },- elementsMap: NonDeletedSceneElementsMap,+ app: AppClassProperties,): void => {if (appState.startBoundElement != null) {bindLinearElement(linearElement,appState.startBoundElement,"start",- elementsMap,+ app.scene.getNonDeletedElementsMap(),);}- const hoveredElement = getHoveredElementForBinding(- pointerCoords,- scene.getNonDeletedElements(),- elementsMap,- );+ const hoveredElement = getHoveredElementForBinding(pointerCoords, app);if (hoveredElement != null &&!isLinearElementSimpleAndAlreadyBoundOnOppositeEdge(@@ -224,7 +220,12 @@ export const maybeBindLinearElement = ("end",)) {- bindLinearElement(linearElement, hoveredElement, "end", elementsMap);+ bindLinearElement(+ linearElement,+ hoveredElement,+ "end",+ app.scene.getNonDeletedElementsMap(),+ );}};@@ -283,7 +284,7 @@ export const isLinearElementSimpleAndAlreadyBound = (};export const unbindLinearElements = (- elements: NonDeleted<ExcalidrawElement>[],+ elements: readonly NonDeleted<ExcalidrawElement>[],elementsMap: NonDeletedSceneElementsMap,): void => {elements.forEach((element) => {@@ -311,14 +312,13 @@ export const getHoveredElementForBinding = (x: number;y: number;},- elements: readonly NonDeletedExcalidrawElement[],- elementsMap: NonDeletedSceneElementsMap,+ app: AppClassProperties,): NonDeleted<ExcalidrawBindableElement> | null => {const hoveredElement = getElementAtPosition(- elements,+ app.scene.getNonDeletedElements(),(element) =>isBindableElement(element, false) &&- bindingBorderTest(element, pointerCoords, elementsMap),+ bindingBorderTest(element, pointerCoords, app),);return hoveredElement as NonDeleted<ExcalidrawBindableElement> | null;};@@ -547,23 +547,21 @@ const maybeCalculateNewGapWhenScaling = (// TODO: this is a bottleneck, optimiseexport const getEligibleElementsForBinding = (selectedElements: NonDeleted<ExcalidrawElement>[],- elements: readonly ExcalidrawElement[],- elementsMap: NonDeletedSceneElementsMap,+ app: AppClassProperties,): SuggestedBinding[] => {const includedElementIds = new Set(selectedElements.map(({ id }) => id));return selectedElements.flatMap((selectedElement) =>isBindingElement(selectedElement, false)? (getElligibleElementsForBindingElement(selectedElement as NonDeleted<ExcalidrawLinearElement>,- elements,- elementsMap,+ app,).filter((element) => !includedElementIds.has(element.id),) as SuggestedBinding[]): isBindableElement(selectedElement, false)? getElligibleElementsForBindableElementAndWhere(selectedElement,- elementsMap,+ app,).filter((binding) => !includedElementIds.has(binding[0].id)): [],);@@ -571,22 +569,11 @@ export const getEligibleElementsForBinding = (const getElligibleElementsForBindingElement = (linearElement: NonDeleted<ExcalidrawLinearElement>,- elements: readonly ExcalidrawElement[],- elementsMap: NonDeletedSceneElementsMap,+ app: AppClassProperties,): NonDeleted<ExcalidrawBindableElement>[] => {return [- getElligibleElementForBindingElement(- linearElement,- "start",- elements,- elementsMap,- ),- getElligibleElementForBindingElement(- linearElement,- "end",- elements,- elementsMap,- ),+ getElligibleElementForBindingElement(linearElement, "start", app),+ getElligibleElementForBindingElement(linearElement, "end", app),].filter((element): element is NonDeleted<ExcalidrawBindableElement> =>element != null,@@ -596,13 +583,15 @@ const getElligibleElementsForBindingElement = (const getElligibleElementForBindingElement = (linearElement: NonDeleted<ExcalidrawLinearElement>,startOrEnd: "start" | "end",- elements: readonly ExcalidrawElement[],- elementsMap: NonDeletedSceneElementsMap,+ app: AppClassProperties,): NonDeleted<ExcalidrawBindableElement> | null => {return getHoveredElementForBinding(- getLinearElementEdgeCoors(linearElement, startOrEnd, elementsMap),- elements,- elementsMap,+ getLinearElementEdgeCoors(+ linearElement,+ startOrEnd,+ app.scene.getNonDeletedElementsMap(),+ ),+ app,);};@@ -623,7 +612,7 @@ const getLinearElementEdgeCoors = (const getElligibleElementsForBindableElementAndWhere = (bindableElement: NonDeleted<ExcalidrawBindableElement>,- elementsMap: NonDeletedSceneElementsMap,+ app: AppClassProperties,): SuggestedPointBinding[] => {const scene = Scene.getScene(bindableElement)!;return scene@@ -636,13 +625,15 @@ const getElligibleElementsForBindableElementAndWhere = (element,"start",bindableElement,- elementsMap,+ scene.getNonDeletedElementsMap(),+ app,);const canBindEnd = isLinearElementEligibleForNewBindingByBindable(element,"end",bindableElement,- elementsMap,+ scene.getNonDeletedElementsMap(),+ app,);if (!canBindStart && !canBindEnd) {return null;@@ -661,6 +652,7 @@ const isLinearElementEligibleForNewBindingByBindable = (startOrEnd: "start" | "end",bindableElement: NonDeleted<ExcalidrawBindableElement>,elementsMap: NonDeletedSceneElementsMap,+ app: AppClassProperties,): boolean => {const existingBinding =linearElement[startOrEnd === "start" ? "startBinding" : "endBinding"];@@ -674,7 +666,7 @@ const isLinearElementEligibleForNewBindingByBindable = (bindingBorderTest(bindableElement,getLinearElementEdgeCoors(linearElement, startOrEnd, elementsMap),- elementsMap,+ app,));};@@ -846,3 +838,547 @@ const newBoundElementsAfterDeletion = (}return boundElements.filter((ele) => !deletedElementIds.has(ele.id));};++export const bindingBorderTest = (+ element: NonDeleted<ExcalidrawBindableElement>,+ { x, y }: { x: number; y: number },+ app: AppClassProperties,+): boolean => {+ const threshold = maxBindingGap(element, element.width, element.height);+ const shape = app.getElementShape(element);+ return isPointOnShape([x, y], shape, threshold);+};++export const maxBindingGap = (+ element: ExcalidrawElement,+ elementWidth: number,+ elementHeight: number,+): number => {+ // Aligns diamonds with rectangles+ const shapeRatio = element.type === "diamond" ? 1 / Math.sqrt(2) : 1;+ const smallerDimension = shapeRatio * Math.min(elementWidth, elementHeight);+ // We make the bindable boundary bigger for bigger elements+ return Math.max(16, Math.min(0.25 * smallerDimension, 32));+};++export const distanceToBindableElement = (+ element: ExcalidrawBindableElement,+ point: Point,+ elementsMap: ElementsMap,+): number => {+ switch (element.type) {+ case "rectangle":+ case "image":+ case "text":+ case "iframe":+ case "embeddable":+ case "frame":+ case "magicframe":+ return distanceToRectangle(element, point, elementsMap);+ case "diamond":+ return distanceToDiamond(element, point, elementsMap);+ case "ellipse":+ return distanceToEllipse(element, point, elementsMap);+ }+};++const distanceToRectangle = (+ element:+ | ExcalidrawRectangleElement+ | ExcalidrawTextElement+ | ExcalidrawFreeDrawElement+ | ExcalidrawImageElement+ | ExcalidrawIframeLikeElement+ | ExcalidrawFrameLikeElement,+ point: Point,+ elementsMap: ElementsMap,+): number => {+ const [, pointRel, hwidth, hheight] = pointRelativeToElement(+ element,+ point,+ elementsMap,+ );+ return Math.max(+ GAPoint.distanceToLine(pointRel, GALine.equation(0, 1, -hheight)),+ GAPoint.distanceToLine(pointRel, GALine.equation(1, 0, -hwidth)),+ );+};++const distanceToDiamond = (+ element: ExcalidrawDiamondElement,+ point: Point,+ elementsMap: ElementsMap,+): number => {+ const [, pointRel, hwidth, hheight] = pointRelativeToElement(+ element,+ point,+ elementsMap,+ );+ const side = GALine.equation(hheight, hwidth, -hheight * hwidth);+ return GAPoint.distanceToLine(pointRel, side);+};++export const distanceToEllipse = (+ element: ExcalidrawEllipseElement,+ point: Point,+ elementsMap: ElementsMap,+): number => {+ const [pointRel, tangent] = ellipseParamsForTest(element, point, elementsMap);+ return -GALine.sign(tangent) * GAPoint.distanceToLine(pointRel, tangent);+};++const ellipseParamsForTest = (+ element: ExcalidrawEllipseElement,+ point: Point,+ elementsMap: ElementsMap,+): [GA.Point, GA.Line] => {+ const [, pointRel, hwidth, hheight] = pointRelativeToElement(+ element,+ point,+ elementsMap,+ );+ const [px, py] = GAPoint.toTuple(pointRel);++ // We're working in positive quadrant, so start with `t = 45deg`, `tx=cos(t)`+ let tx = 0.707;+ let ty = 0.707;++ const a = hwidth;+ const b = hheight;++ // This is a numerical method to find the params tx, ty at which+ // the ellipse has the closest point to the given point+ [0, 1, 2, 3].forEach((_) => {+ const xx = a * tx;+ const yy = b * ty;++ const ex = ((a * a - b * b) * tx ** 3) / a;+ const ey = ((b * b - a * a) * ty ** 3) / b;++ const rx = xx - ex;+ const ry = yy - ey;++ const qx = px - ex;+ const qy = py - ey;++ const r = Math.hypot(ry, rx);+ const q = Math.hypot(qy, qx);++ tx = Math.min(1, Math.max(0, ((qx * r) / q + ex) / a));+ ty = Math.min(1, Math.max(0, ((qy * r) / q + ey) / b));+ const t = Math.hypot(ty, tx);+ tx /= t;+ ty /= t;+ });++ const closestPoint = GA.point(a * tx, b * ty);++ const tangent = GALine.orthogonalThrough(pointRel, closestPoint);+ return [pointRel, tangent];+};++// Returns:+// 1. the point relative to the elements (x, y) position+// 2. the point relative to the element's center with positive (x, y)+// 3. half element width+// 4. half element height+//+// Note that for linear elements the (x, y) position is not at the+// top right corner of their boundary.+//+// Rectangles, diamonds and ellipses are symmetrical over axes,+// and other elements have a rectangular boundary,+// so we only need to perform hit tests for the positive quadrant.+const pointRelativeToElement = (+ element: ExcalidrawElement,+ pointTuple: Point,+ elementsMap: ElementsMap,+): [GA.Point, GA.Point, number, number] => {+ const point = GAPoint.from(pointTuple);+ const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);+ const center = coordsCenter(x1, y1, x2, y2);+ // GA has angle orientation opposite to `rotate`+ const rotate = GATransform.rotation(center, element.angle);+ const pointRotated = GATransform.apply(rotate, point);+ const pointRelToCenter = GA.sub(pointRotated, GADirection.from(center));+ const pointRelToCenterAbs = GAPoint.abs(pointRelToCenter);+ const elementPos = GA.offset(element.x, element.y);+ const pointRelToPos = GA.sub(pointRotated, elementPos);+ const halfWidth = (x2 - x1) / 2;+ const halfHeight = (y2 - y1) / 2;+ return [pointRelToPos, pointRelToCenterAbs, halfWidth, halfHeight];+};++const relativizationToElementCenter = (+ element: ExcalidrawElement,+ elementsMap: ElementsMap,+): GA.Transform => {+ const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);+ const center = coordsCenter(x1, y1, x2, y2);+ // GA has angle orientation opposite to `rotate`+ const rotate = GATransform.rotation(center, element.angle);+ const translate = GA.reverse(+ GATransform.translation(GADirection.from(center)),+ );+ return GATransform.compose(rotate, translate);+};++const coordsCenter = (+ x1: number,+ y1: number,+ x2: number,+ y2: number,+): GA.Point => {+ return GA.point((x1 + x2) / 2, (y1 + y2) / 2);+};++// The focus distance is the oriented ratio between the size of+// the `element` and the "focus image" of the element on which+// all focus points lie, so it's a number between -1 and 1.+// The line going through `a` and `b` is a tangent to the "focus image"+// of the element.+export const determineFocusDistance = (+ element: ExcalidrawBindableElement,+ // Point on the line, in absolute coordinates+ a: Point,+ // Another point on the line, in absolute coordinates (closer to element)+ b: Point,+ elementsMap: ElementsMap,+): number => {+ const relateToCenter = relativizationToElementCenter(element, elementsMap);+ const aRel = GATransform.apply(relateToCenter, GAPoint.from(a));+ const bRel = GATransform.apply(relateToCenter, GAPoint.from(b));+ const line = GALine.through(aRel, bRel);+ const q = element.height / element.width;+ const hwidth = element.width / 2;+ const hheight = element.height / 2;+ const n = line[2];+ const m = line[3];+ const c = line[1];+ const mabs = Math.abs(m);+ const nabs = Math.abs(n);+ let ret;+ switch (element.type) {+ case "rectangle":+ case "image":+ case "text":+ case "iframe":+ case "embeddable":+ case "frame":+ case "magicframe":+ ret = c / (hwidth * (nabs + q * mabs));+ break;+ case "diamond":+ ret = mabs < nabs ? c / (nabs * hwidth) : c / (mabs * hheight);+ break;+ case "ellipse":+ ret = c / (hwidth * Math.sqrt(n ** 2 + q ** 2 * m ** 2));+ break;+ }+ return ret || 0;+};++export const determineFocusPoint = (+ element: ExcalidrawBindableElement,+ // The oriented, relative distance from the center of `element` of the+ // returned focusPoint+ focus: number,+ adjecentPoint: Point,+ elementsMap: ElementsMap,+): Point => {+ if (focus === 0) {+ const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);+ const center = coordsCenter(x1, y1, x2, y2);+ return GAPoint.toTuple(center);+ }+ const relateToCenter = relativizationToElementCenter(element, elementsMap);+ const adjecentPointRel = GATransform.apply(+ relateToCenter,+ GAPoint.from(adjecentPoint),+ );+ const reverseRelateToCenter = GA.reverse(relateToCenter);+ let point;+ switch (element.type) {+ case "rectangle":+ case "image":+ case "text":+ case "diamond":+ case "iframe":+ case "embeddable":+ case "frame":+ case "magicframe":+ point = findFocusPointForRectangulars(element, focus, adjecentPointRel);+ break;+ case "ellipse":+ point = findFocusPointForEllipse(element, focus, adjecentPointRel);+ break;+ }+ return GAPoint.toTuple(GATransform.apply(reverseRelateToCenter, point));+};++// Returns 2 or 0 intersection points between line going through `a` and `b`+// and the `element`, in ascending order of distance from `a`.+export const intersectElementWithLine = (+ element: ExcalidrawBindableElement,+ // Point on the line, in absolute coordinates+ a: Point,+ // Another point on the line, in absolute coordinates+ b: Point,+ // If given, the element is inflated by this value+ gap: number = 0,+ elementsMap: ElementsMap,+): Point[] => {+ const relateToCenter = relativizationToElementCenter(element, elementsMap);+ const aRel = GATransform.apply(relateToCenter, GAPoint.from(a));+ const bRel = GATransform.apply(relateToCenter, GAPoint.from(b));+ const line = GALine.through(aRel, bRel);+ const reverseRelateToCenter = GA.reverse(relateToCenter);+ const intersections = getSortedElementLineIntersections(+ element,+ line,+ aRel,+ gap,+ );+ return intersections.map((point) =>+ GAPoint.toTuple(GATransform.apply(reverseRelateToCenter, point)),+ );+};++const getSortedElementLineIntersections = (+ element: ExcalidrawBindableElement,+ // Relative to element center+ line: GA.Line,+ // Relative to element center+ nearPoint: GA.Point,+ gap: number = 0,+): GA.Point[] => {+ let intersections: GA.Point[];+ switch (element.type) {+ case "rectangle":+ case "image":+ case "text":+ case "diamond":+ case "iframe":+ case "embeddable":+ case "frame":+ case "magicframe":+ const corners = getCorners(element);+ intersections = corners+ .flatMap((point, i) => {+ const edge: [GA.Point, GA.Point] = [point, corners[(i + 1) % 4]];+ return intersectSegment(line, offsetSegment(edge, gap));+ })+ .concat(+ corners.flatMap((point) => getCircleIntersections(point, gap, line)),+ );+ break;+ case "ellipse":+ intersections = getEllipseIntersections(element, gap, line);+ break;+ }+ if (intersections.length < 2) {+ // Ignore the "edge" case of only intersecting with a single corner+ return [];+ }+ const sortedIntersections = intersections.sort(+ (i1, i2) =>+ GAPoint.distance(i1, nearPoint) - GAPoint.distance(i2, nearPoint),+ );+ return [+ sortedIntersections[0],+ sortedIntersections[sortedIntersections.length - 1],+ ];+};++const getCorners = (+ element:+ | ExcalidrawRectangleElement+ | ExcalidrawImageElement+ | ExcalidrawDiamondElement+ | ExcalidrawTextElement+ | ExcalidrawIframeLikeElement+ | ExcalidrawFrameLikeElement,+ scale: number = 1,+): GA.Point[] => {+ const hx = (scale * element.width) / 2;+ const hy = (scale * element.height) / 2;+ switch (element.type) {+ case "rectangle":+ case "image":+ case "text":+ case "iframe":+ case "embeddable":+ case "frame":+ case "magicframe":+ return [+ GA.point(hx, hy),+ GA.point(hx, -hy),+ GA.point(-hx, -hy),+ GA.point(-hx, hy),+ ];+ case "diamond":+ return [+ GA.point(0, hy),+ GA.point(hx, 0),+ GA.point(0, -hy),+ GA.point(-hx, 0),+ ];+ }+};++// Returns intersection of `line` with `segment`, with `segment` moved by+// `gap` in its polar direction.+// If intersection coincides with second segment point returns empty array.+const intersectSegment = (+ line: GA.Line,+ segment: [GA.Point, GA.Point],+): GA.Point[] => {+ const [a, b] = segment;+ const aDist = GAPoint.distanceToLine(a, line);+ const bDist = GAPoint.distanceToLine(b, line);+ if (aDist * bDist >= 0) {+ // The intersection is outside segment `(a, b)`+ return [];+ }+ return [GAPoint.intersect(line, GALine.through(a, b))];+};++const offsetSegment = (+ segment: [GA.Point, GA.Point],+ distance: number,+): [GA.Point, GA.Point] => {+ const [a, b] = segment;+ const offset = GATransform.translationOrthogonal(+ GADirection.fromTo(a, b),+ distance,+ );+ return [GATransform.apply(offset, a), GATransform.apply(offset, b)];+};++const getEllipseIntersections = (+ element: ExcalidrawEllipseElement,+ gap: number,+ line: GA.Line,+): GA.Point[] => {+ const a = element.width / 2 + gap;+ const b = element.height / 2 + gap;+ const m = line[2];+ const n = line[3];+ const c = line[1];+ const squares = a * a * m * m + b * b * n * n;+ const discr = squares - c * c;+ if (squares === 0 || discr <= 0) {+ return [];+ }+ const discrRoot = Math.sqrt(discr);+ const xn = -a * a * m * c;+ const yn = -b * b * n * c;+ return [+ GA.point(+ (xn + a * b * n * discrRoot) / squares,+ (yn - a * b * m * discrRoot) / squares,+ ),+ GA.point(+ (xn - a * b * n * discrRoot) / squares,+ (yn + a * b * m * discrRoot) / squares,+ ),+ ];+};++export const getCircleIntersections = (+ center: GA.Point,+ radius: number,+ line: GA.Line,+): GA.Point[] => {+ if (radius === 0) {+ return GAPoint.distanceToLine(line, center) === 0 ? [center] : [];+ }+ const m = line[2];+ const n = line[3];+ const c = line[1];+ const [a, b] = GAPoint.toTuple(center);+ const r = radius;+ const squares = m * m + n * n;+ const discr = r * r * squares - (m * a + n * b + c) ** 2;+ if (squares === 0 || discr <= 0) {+ return [];+ }+ const discrRoot = Math.sqrt(discr);+ const xn = a * n * n - b * m * n - m * c;+ const yn = b * m * m - a * m * n - n * c;++ return [+ GA.point((xn + n * discrRoot) / squares, (yn - m * discrRoot) / squares),+ GA.point((xn - n * discrRoot) / squares, (yn + m * discrRoot) / squares),+ ];+};++// The focus point is the tangent point of the "focus image" of the+// `element`, where the tangent goes through `point`.+export const findFocusPointForEllipse = (+ ellipse: ExcalidrawEllipseElement,+ // Between -1 and 1 (not 0) the relative size of the "focus image" of+ // the element on which the focus point lies+ relativeDistance: number,+ // The point for which we're trying to find the focus point, relative+ // to the ellipse center.+ point: GA.Point,+): GA.Point => {+ const relativeDistanceAbs = Math.abs(relativeDistance);+ const a = (ellipse.width * relativeDistanceAbs) / 2;+ const b = (ellipse.height * relativeDistanceAbs) / 2;++ const orientation = Math.sign(relativeDistance);+ const [px, pyo] = GAPoint.toTuple(point);++ // The calculation below can't handle py = 0+ const py = pyo === 0 ? 0.0001 : pyo;++ const squares = px ** 2 * b ** 2 + py ** 2 * a ** 2;+ // Tangent mx + ny + 1 = 0+ const m =+ (-px * b ** 2 ++ orientation * py * Math.sqrt(Math.max(0, squares - a ** 2 * b ** 2))) /+ squares;++ let n = (-m * px - 1) / py;++ if (n === 0) {+ // if zero {-0, 0}, fall back to a same-sign value in the similar range+ n = (Object.is(n, -0) ? -1 : 1) * 0.01;+ }++ const x = -(a ** 2 * m) / (n ** 2 * b ** 2 + m ** 2 * a ** 2);+ return GA.point(x, (-m * x - 1) / n);+};++export const findFocusPointForRectangulars = (+ element:+ | ExcalidrawRectangleElement+ | ExcalidrawImageElement+ | ExcalidrawDiamondElement+ | ExcalidrawTextElement+ | ExcalidrawIframeLikeElement+ | ExcalidrawFrameLikeElement,+ // Between -1 and 1 for how far away should the focus point be relative+ // to the size of the element. Sign determines orientation.+ relativeDistance: number,+ // The point for which we're trying to find the focus point, relative+ // to the element center.+ point: GA.Point,+): GA.Point => {+ const relativeDistanceAbs = Math.abs(relativeDistance);+ const orientation = Math.sign(relativeDistance);+ const corners = getCorners(element, relativeDistanceAbs);++ let maxDistance = 0;+ let tangentPoint: null | GA.Point = null;+ corners.forEach((corner) => {+ const distance = orientation * GALine.through(point, corner)[1];+ if (distance > maxDistance) {+ maxDistance = distance;+ tangentPoint = corner;+ }+ });+ return tangentPoint!;+};diff --git a/packages/excalidraw/element/bounds.ts b/packages/excalidraw/element/bounds.tsindex e7c6f7fb3d..6d98087bae 100644--- a/packages/excalidraw/element/bounds.ts+++ b/packages/excalidraw/element/bounds.ts@@ -299,13 +299,6 @@ export const getRectangleBoxAbsoluteCoords = (boxSceneCoords: RectangleBox) => {];};-export const pointRelativeTo = (- element: ExcalidrawElement,- absoluteCoords: Point,-): Point => {- return [absoluteCoords[0] - element.x, absoluteCoords[1] - element.y];-};-export const getDiamondPoints = (element: ExcalidrawElement) => {// Here we add +1 to avoid these numbers to be 0// otherwise rough.js will throw an error complaining about itdiff --git a/packages/excalidraw/element/collision.ts b/packages/excalidraw/element/collision.tsindex ff5a139de0..df3d9c9281 100644--- a/packages/excalidraw/element/collision.ts+++ b/packages/excalidraw/element/collision.ts@@ -1,1170 +1,111 @@-import * as GA from "../ga";-import * as GAPoint from "../gapoints";-import * as GADirection from "../gadirections";-import * as GALine from "../galines";-import * as GATransform from "../gatransforms";+import { isPathALoop, isPointWithinBounds } from "../math";import {- distance2d,- rotatePoint,- isPathALoop,- isPointInPolygon,- rotate,-} from "../math";-import { pointsOnBezierCurves } from "points-on-curve";--import {- NonDeletedExcalidrawElement,- ExcalidrawBindableElement,+ ElementsMap,ExcalidrawElement,ExcalidrawRectangleElement,- ExcalidrawDiamondElement,- ExcalidrawTextElement,- ExcalidrawEllipseElement,- NonDeleted,- ExcalidrawFreeDrawElement,- ExcalidrawImageElement,- ExcalidrawLinearElement,- StrokeRoundness,- ExcalidrawFrameLikeElement,- ExcalidrawIframeLikeElement,- ElementsMap,} from "./types";+import { getElementBounds } from "./bounds";+import { FrameNameBounds } from "../types";import {- getElementAbsoluteCoords,- getCurvePathOps,- getRectangleBoxAbsoluteCoords,- RectangleBox,-} from "./bounds";-import { FrameNameBoundsCache, Point } from "../types";-import { Drawable } from "roughjs/bin/core";-import { AppState } from "../types";+ Polygon,+ GeometricShape,+ getPolygonShape,+} from "../../utils/geometry/shape";+import { isPointInShape, isPointOnShape } from "../../utils/collision";+import { isTransparent } from "../utils";import {hasBoundTextElement,- isFrameLikeElement,isIframeLikeElement,isImageElement,+ isTextElement,} from "./typeChecks";-import { isTextElement } from ".";-import { isTransparent } from "../utils";-import { shouldShowBoundingBox } from "./transformHandles";-import { getBoundTextElement } from "./textElement";-import { Mutable } from "../utility-types";-import { ShapeCache } from "../scene/ShapeCache";-const isElementDraggableFromInside = (- element: NonDeletedExcalidrawElement,-): boolean => {+export const shouldTestInside = (element: ExcalidrawElement) => {if (element.type === "arrow") {return false;}- if (element.type === "freedraw") {- return true;- }const isDraggableFromInside =!isTransparent(element.backgroundColor) ||hasBoundTextElement(element) ||- isIframeLikeElement(element);+ isIframeLikeElement(element) ||+ isTextElement(element);+if (element.type === "line") {return isDraggableFromInside && isPathALoop(element.points);}- return isDraggableFromInside || isImageElement(element);-};--export const hitTest = (- element: NonDeletedExcalidrawElement,- appState: AppState,- frameNameBoundsCache: FrameNameBoundsCache,- x: number,- y: number,- elementsMap: ElementsMap,-): boolean => {- // How many pixels off the shape boundary we still consider a hit- const threshold = 10 / appState.zoom.value;- const point: Point = [x, y];-- if (- isElementSelected(appState, element) &&- shouldShowBoundingBox([element], appState)- ) {- return isPointHittingElementBoundingBox(- element,- elementsMap,- point,- threshold,- frameNameBoundsCache,- );- }-- const boundTextElement = getBoundTextElement(element, elementsMap);- if (boundTextElement) {- const isHittingBoundTextElement = hitTest(- boundTextElement,- appState,- frameNameBoundsCache,- x,- y,- elementsMap,- );- if (isHittingBoundTextElement) {- return true;- }- }- return isHittingElementNotConsideringBoundingBox(- element,- appState,- frameNameBoundsCache,- point,- elementsMap,- );-};-export const isHittingElementBoundingBoxWithoutHittingElement = (- element: NonDeletedExcalidrawElement,- appState: AppState,- frameNameBoundsCache: FrameNameBoundsCache,- x: number,- y: number,- elementsMap: ElementsMap,-): boolean => {- const threshold = 10 / appState.zoom.value;-- // So that bound text element hit is considered within bounding box of container even if its outside actual bounding box of element- // eg for linear elements text can be outside the element bounding box- const boundTextElement = getBoundTextElement(element, elementsMap);- if (- boundTextElement &&- hitTest(boundTextElement, appState, frameNameBoundsCache, x, y, elementsMap)- ) {- return false;+ if (element.type === "freedraw") {+ return isDraggableFromInside && isPathALoop(element.points);}- return (- !isHittingElementNotConsideringBoundingBox(- element,- appState,- frameNameBoundsCache,- [x, y],- elementsMap,- ) &&- isPointHittingElementBoundingBox(- element,- elementsMap,- [x, y],- threshold,- frameNameBoundsCache,- )- );-};--export const isHittingElementNotConsideringBoundingBox = (- element: NonDeletedExcalidrawElement,- appState: AppState,- frameNameBoundsCache: FrameNameBoundsCache | null,- point: Point,- elementsMap: ElementsMap,-): boolean => {- const threshold = 10 / appState.zoom.value;- const check = isTextElement(element)- ? isStrictlyInside- : isElementDraggableFromInside(element)- ? isInsideCheck- : isNearCheck;- return hitTestPointAgainstElement({- element,- elementsMap,- point,- threshold,- check,- frameNameBoundsCache,- });+ return isDraggableFromInside || isImageElement(element);};-const isElementSelected = (- appState: AppState,- element: NonDeleted<ExcalidrawElement>,-) => appState.selectedElementIds[element.id];--export const isPointHittingElementBoundingBox = (- element: NonDeleted<ExcalidrawElement>,- elementsMap: ElementsMap,- [x, y]: Point,- threshold: number,- frameNameBoundsCache: FrameNameBoundsCache | null,-) => {- // frames needs be checked differently so as to be able to drag it- // by its frame, whether it has been selected or not- // this logic here is not ideal- // TODO: refactor it later...- if (isFrameLikeElement(element)) {- return hitTestPointAgainstElement({- element,- elementsMap,- point: [x, y],- threshold,- check: isInsideCheck,- frameNameBoundsCache,+export type HitTestArgs = {+ x: number;+ y: number;+ element: ExcalidrawElement;+ shape: GeometricShape;+ threshold?: number;+ frameNameBound?: FrameNameBounds | null;+};++export const hitElementItself = ({+ x,+ y,+ element,+ shape,+ threshold = 10,+ frameNameBound = null,+}: HitTestArgs) => {+ let hit = shouldTestInside(element)+ ? isPointInShape([x, y], shape)+ : isPointOnShape([x, y], shape, threshold);++ // hit test against a frame's name+ if (!hit && frameNameBound) {+ hit = isPointInShape([x, y], {+ type: "polygon",+ data: getPolygonShape(frameNameBound as ExcalidrawRectangleElement)+ .data as Polygon,});}- const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);- const elementCenterX = (x1 + x2) / 2;- const elementCenterY = (y1 + y2) / 2;- // reverse rotate to take element's angle into account.- const [rotatedX, rotatedY] = rotate(- x,- y,- elementCenterX,- elementCenterY,- -element.angle,- );-- return (- rotatedX > x1 - threshold &&- rotatedX < x2 + threshold &&- rotatedY > y1 - threshold &&- rotatedY < y2 + threshold- );-};--export const bindingBorderTest = (- element: NonDeleted<ExcalidrawBindableElement>,- { x, y }: { x: number; y: number },- elementsMap: ElementsMap,-): boolean => {- const threshold = maxBindingGap(element, element.width, element.height);- const check = isOutsideCheck;- const point: Point = [x, y];- return hitTestPointAgainstElement({- element,- elementsMap,- point,- threshold,- check,- frameNameBoundsCache: null,- });-};--export const maxBindingGap = (- element: ExcalidrawElement,- elementWidth: number,- elementHeight: number,-): number => {- // Aligns diamonds with rectangles- const shapeRatio = element.type === "diamond" ? 1 / Math.sqrt(2) : 1;- const smallerDimension = shapeRatio * Math.min(elementWidth, elementHeight);- // We make the bindable boundary bigger for bigger elements- return Math.max(16, Math.min(0.25 * smallerDimension, 32));-};--type HitTestArgs = {- element: NonDeletedExcalidrawElement;- elementsMap: ElementsMap;- point: Point;- threshold: number;- check: (distance: number, threshold: number) => boolean;- frameNameBoundsCache: FrameNameBoundsCache | null;-};--const hitTestPointAgainstElement = (args: HitTestArgs): boolean => {- switch (args.element.type) {- case "rectangle":- case "iframe":- case "embeddable":- case "image":- case "text":- case "diamond":- case "ellipse":- const distance = distanceToBindableElement(- args.element,- args.point,- args.elementsMap,- );- return args.check(distance, args.threshold);- case "freedraw": {- if (- !args.check(- distanceToRectangle(args.element, args.point, args.elementsMap),- args.threshold,- )- ) {- return false;- }-- return hitTestFreeDrawElement(- args.element,- args.point,- args.threshold,- args.elementsMap,- );- }- case "arrow":- case "line":- return hitTestLinear(args);- case "selection":- console.warn(- "This should not happen, we need to investigate why it does.",- );- return false;- case "frame":- case "magicframe": {- // check distance to frame element first- if (- args.check(- distanceToBindableElement(args.element, args.point, args.elementsMap),- args.threshold,- )- ) {- return true;- }-- const frameNameBounds = args.frameNameBoundsCache?.get(args.element);-- if (frameNameBounds) {- return args.check(- distanceToRectangleBox(frameNameBounds, args.point),- args.threshold,- );- }- return false;- }- }-};--export const distanceToBindableElement = (- element: ExcalidrawBindableElement,- point: Point,- elementsMap: ElementsMap,-): number => {- switch (element.type) {- case "rectangle":- case "image":- case "text":- case "iframe":- case "embeddable":- case "frame":- case "magicframe":- return distanceToRectangle(element, point, elementsMap);- case "diamond":- return distanceToDiamond(element, point, elementsMap);- case "ellipse":- return distanceToEllipse(element, point, elementsMap);- }-};--const isStrictlyInside = (distance: number, threshold: number): boolean => {- return distance < 0;-};--const isInsideCheck = (distance: number, threshold: number): boolean => {- return distance < threshold;-};--const isNearCheck = (distance: number, threshold: number): boolean => {- return Math.abs(distance) < threshold;-};--const isOutsideCheck = (distance: number, threshold: number): boolean => {- return 0 <= distance && distance < threshold;-};--const distanceToRectangle = (- element:- | ExcalidrawRectangleElement- | ExcalidrawTextElement- | ExcalidrawFreeDrawElement- | ExcalidrawImageElement- | ExcalidrawIframeLikeElement- | ExcalidrawFrameLikeElement,- point: Point,- elementsMap: ElementsMap,-): number => {- const [, pointRel, hwidth, hheight] = pointRelativeToElement(- element,- point,- elementsMap,- );- return Math.max(- GAPoint.distanceToLine(pointRel, GALine.equation(0, 1, -hheight)),- GAPoint.distanceToLine(pointRel, GALine.equation(1, 0, -hwidth)),- );-};--const distanceToRectangleBox = (box: RectangleBox, point: Point): number => {- const [, pointRel, hwidth, hheight] = pointRelativeToDivElement(point, box);- return Math.max(- GAPoint.distanceToLine(pointRel, GALine.equation(0, 1, -hheight)),- GAPoint.distanceToLine(pointRel, GALine.equation(1, 0, -hwidth)),- );-};--const distanceToDiamond = (- element: ExcalidrawDiamondElement,- point: Point,- elementsMap: ElementsMap,-): number => {- const [, pointRel, hwidth, hheight] = pointRelativeToElement(- element,- point,- elementsMap,- );- const side = GALine.equation(hheight, hwidth, -hheight * hwidth);- return GAPoint.distanceToLine(pointRel, side);-};--const distanceToEllipse = (- element: ExcalidrawEllipseElement,- point: Point,- elementsMap: ElementsMap,-): number => {- const [pointRel, tangent] = ellipseParamsForTest(element, point, elementsMap);- return -GALine.sign(tangent) * GAPoint.distanceToLine(pointRel, tangent);-};--const ellipseParamsForTest = (- element: ExcalidrawEllipseElement,- point: Point,- elementsMap: ElementsMap,-): [GA.Point, GA.Line] => {- const [, pointRel, hwidth, hheight] = pointRelativeToElement(- element,- point,- elementsMap,- );- const [px, py] = GAPoint.toTuple(pointRel);-- // We're working in positive quadrant, so start with `t = 45deg`, `tx=cos(t)`- let tx = 0.707;- let ty = 0.707;-- const a = hwidth;- const b = hheight;-- // This is a numerical method to find the params tx, ty at which- // the ellipse has the closest point to the given point- [0, 1, 2, 3].forEach((_) => {- const xx = a * tx;- const yy = b * ty;-- const ex = ((a * a - b * b) * tx ** 3) / a;- const ey = ((b * b - a * a) * ty ** 3) / b;-- const rx = xx - ex;- const ry = yy - ey;-- const qx = px - ex;- const qy = py - ey;-- const r = Math.hypot(ry, rx);- const q = Math.hypot(qy, qx);-- tx = Math.min(1, Math.max(0, ((qx * r) / q + ex) / a));- ty = Math.min(1, Math.max(0, ((qy * r) / q + ey) / b));- const t = Math.hypot(ty, tx);- tx /= t;- ty /= t;- });-- const closestPoint = GA.point(a * tx, b * ty);-- const tangent = GALine.orthogonalThrough(pointRel, closestPoint);- return [pointRel, tangent];-};--const hitTestFreeDrawElement = (- element: ExcalidrawFreeDrawElement,- point: Point,- threshold: number,- elementsMap: ElementsMap,-): boolean => {- // Check point-distance-to-line-segment for every segment in the- // element's points (its input points, not its outline points).- // This is... okay? It's plenty fast, but the GA library may- // have a faster option.-- let x: number;- let y: number;-- if (element.angle === 0) {- x = point[0] - element.x;- y = point[1] - element.y;- } else {- // Counter-rotate the point around center before testing- const [minX, minY, maxX, maxY] = getElementAbsoluteCoords(- element,- elementsMap,- );- const rotatedPoint = rotatePoint(- point,- [minX + (maxX - minX) / 2, minY + (maxY - minY) / 2],- -element.angle,- );- x = rotatedPoint[0] - element.x;- y = rotatedPoint[1] - element.y;- }-- let [A, B] = element.points;- let P: readonly [number, number];-- // For freedraw dots- if (- distance2d(A[0], A[1], x, y) < threshold ||- distance2d(B[0], B[1], x, y) < threshold- ) {- return true;- }-- // For freedraw lines- for (let i = 0; i < element.points.length; i++) {- const delta = [B[0] - A[0], B[1] - A[1]];- const length = Math.hypot(delta[1], delta[0]);-- const U = [delta[0] / length, delta[1] / length];- const C = [x - A[0], y - A[1]];- const d = (C[0] * U[0] + C[1] * U[1]) / Math.hypot(U[1], U[0]);- P = [A[0] + U[0] * d, A[1] + U[1] * d];-- const da = distance2d(P[0], P[1], A[0], A[1]);- const db = distance2d(P[0], P[1], B[0], B[1]);-- P = db < da && da > length ? B : da < db && db > length ? A : P;-- if (Math.hypot(y - P[1], x - P[0]) < threshold) {- return true;- }-- A = B;- B = element.points[i + 1];- }-- const shape = ShapeCache.get(element);-- // for filled freedraw shapes, support- // selecting from inside- if (shape && shape.sets.length) {- return element.fillStyle === "solid"- ? hitTestCurveInside(shape, x, y, "round")- : hitTestRoughShape(shape, x, y, threshold);- }-- return false;-};--const hitTestLinear = (args: HitTestArgs): boolean => {- const { element, threshold } = args;- if (!ShapeCache.get(element)) {- return false;- }-- const [point, pointAbs, hwidth, hheight] = pointRelativeToElement(- args.element,- args.point,- args.elementsMap,- );- const side1 = GALine.equation(0, 1, -hheight);- const side2 = GALine.equation(1, 0, -hwidth);- if (- !isInsideCheck(GAPoint.distanceToLine(pointAbs, side1), threshold) ||- !isInsideCheck(GAPoint.distanceToLine(pointAbs, side2), threshold)- ) {- return false;- }- const [relX, relY] = GAPoint.toTuple(point);-- const shape = ShapeCache.get(element as ExcalidrawLinearElement);-- if (!shape) {- return false;- }-- if (args.check === isInsideCheck) {- const hit = shape.some((subshape) =>- hitTestCurveInside(- subshape,- relX,- relY,- element.roundness ? "round" : "sharp",- ),- );- if (hit) {- return true;- }- }-- // hit test all "subshapes" of the linear element- return shape.some((subshape) =>- hitTestRoughShape(subshape, relX, relY, threshold),- );-};--// Returns:-// 1. the point relative to the elements (x, y) position-// 2. the point relative to the element's center with positive (x, y)-// 3. half element width-// 4. half element height-//-// Note that for linear elements the (x, y) position is not at the-// top right corner of their boundary.-//-// Rectangles, diamonds and ellipses are symmetrical over axes,-// and other elements have a rectangular boundary,-// so we only need to perform hit tests for the positive quadrant.-const pointRelativeToElement = (- element: ExcalidrawElement,- pointTuple: Point,- elementsMap: ElementsMap,-): [GA.Point, GA.Point, number, number] => {- const point = GAPoint.from(pointTuple);- const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);- const center = coordsCenter(x1, y1, x2, y2);- // GA has angle orientation opposite to `rotate`- const rotate = GATransform.rotation(center, element.angle);- const pointRotated = GATransform.apply(rotate, point);- const pointRelToCenter = GA.sub(pointRotated, GADirection.from(center));- const pointRelToCenterAbs = GAPoint.abs(pointRelToCenter);- const elementPos = GA.offset(element.x, element.y);- const pointRelToPos = GA.sub(pointRotated, elementPos);- const halfWidth = (x2 - x1) / 2;- const halfHeight = (y2 - y1) / 2;- return [pointRelToPos, pointRelToCenterAbs, halfWidth, halfHeight];-};--const pointRelativeToDivElement = (- pointTuple: Point,- rectangle: RectangleBox,-): [GA.Point, GA.Point, number, number] => {- const point = GAPoint.from(pointTuple);- const [x1, y1, x2, y2] = getRectangleBoxAbsoluteCoords(rectangle);- const center = coordsCenter(x1, y1, x2, y2);- const rotate = GATransform.rotation(center, rectangle.angle);- const pointRotated = GATransform.apply(rotate, point);- const pointRelToCenter = GA.sub(pointRotated, GADirection.from(center));- const pointRelToCenterAbs = GAPoint.abs(pointRelToCenter);- const elementPos = GA.offset(rectangle.x, rectangle.y);- const pointRelToPos = GA.sub(pointRotated, elementPos);- const halfWidth = (x2 - x1) / 2;- const halfHeight = (y2 - y1) / 2;- return [pointRelToPos, pointRelToCenterAbs, halfWidth, halfHeight];+ return hit;};-// Returns point in absolute coordinates-export const pointInAbsoluteCoords = (- element: ExcalidrawElement,- elementsMap: ElementsMap,- // Point relative to the element position- point: Point,-): Point => {- const [x, y] = point;- const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);- const cx = (x2 - x1) / 2;- const cy = (y2 - y1) / 2;- const [rotatedX, rotatedY] = rotate(x, y, cx, cy, element.angle);- return [element.x + rotatedX, element.y + rotatedY];-};--const relativizationToElementCenter = (+export const hitElementBoundingBox = (+ x: number,+ y: number,element: ExcalidrawElement,elementsMap: ElementsMap,-): GA.Transform => {- const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);- const center = coordsCenter(x1, y1, x2, y2);- // GA has angle orientation opposite to `rotate`- const rotate = GATransform.rotation(center, element.angle);- const translate = GA.reverse(- GATransform.translation(GADirection.from(center)),- );- return GATransform.compose(rotate, translate);-};--const coordsCenter = (- x1: number,- y1: number,- x2: number,- y2: number,-): GA.Point => {- return GA.point((x1 + x2) / 2, (y1 + y2) / 2);-};--// The focus distance is the oriented ratio between the size of-// the `element` and the "focus image" of the element on which-// all focus points lie, so it's a number between -1 and 1.-// The line going through `a` and `b` is a tangent to the "focus image"-// of the element.-export const determineFocusDistance = (- element: ExcalidrawBindableElement,-- // Point on the line, in absolute coordinates- a: Point,- // Another point on the line, in absolute coordinates (closer to element)- b: Point,- elementsMap: ElementsMap,-): number => {- const relateToCenter = relativizationToElementCenter(element, elementsMap);- const aRel = GATransform.apply(relateToCenter, GAPoint.from(a));- const bRel = GATransform.apply(relateToCenter, GAPoint.from(b));- const line = GALine.through(aRel, bRel);- const q = element.height / element.width;- const hwidth = element.width / 2;- const hheight = element.height / 2;- const n = line[2];- const m = line[3];- const c = line[1];- const mabs = Math.abs(m);- const nabs = Math.abs(n);- let ret;- switch (element.type) {- case "rectangle":- case "image":- case "text":- case "iframe":- case "embeddable":- case "frame":- case "magicframe":- ret = c / (hwidth * (nabs + q * mabs));- break;- case "diamond":- ret = mabs < nabs ? c / (nabs * hwidth) : c / (mabs * hheight);- break;- case "ellipse":- ret = c / (hwidth * Math.sqrt(n ** 2 + q ** 2 * m ** 2));- break;- }- return ret || 0;-};--export const determineFocusPoint = (- element: ExcalidrawBindableElement,- // The oriented, relative distance from the center of `element` of the- // returned focusPoint- focus: number,- adjecentPoint: Point,- elementsMap: ElementsMap,-): Point => {- if (focus === 0) {- const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);- const center = coordsCenter(x1, y1, x2, y2);- return GAPoint.toTuple(center);- }- const relateToCenter = relativizationToElementCenter(element, elementsMap);- const adjecentPointRel = GATransform.apply(- relateToCenter,- GAPoint.from(adjecentPoint),- );- const reverseRelateToCenter = GA.reverse(relateToCenter);- let point;- switch (element.type) {- case "rectangle":- case "image":- case "text":- case "diamond":- case "iframe":- case "embeddable":- case "frame":- case "magicframe":- point = findFocusPointForRectangulars(element, focus, adjecentPointRel);- break;- case "ellipse":- point = findFocusPointForEllipse(element, focus, adjecentPointRel);- break;- }- return GAPoint.toTuple(GATransform.apply(reverseRelateToCenter, point));-};--// Returns 2 or 0 intersection points between line going through `a` and `b`-// and the `element`, in ascending order of distance from `a`.-export const intersectElementWithLine = (- element: ExcalidrawBindableElement,-- // Point on the line, in absolute coordinates- a: Point,- // Another point on the line, in absolute coordinates- b: Point,- // If given, the element is inflated by this value- gap: number = 0,- elementsMap: ElementsMap,-): Point[] => {- const relateToCenter = relativizationToElementCenter(element, elementsMap);- const aRel = GATransform.apply(relateToCenter, GAPoint.from(a));- const bRel = GATransform.apply(relateToCenter, GAPoint.from(b));- const line = GALine.through(aRel, bRel);- const reverseRelateToCenter = GA.reverse(relateToCenter);- const intersections = getSortedElementLineIntersections(- element,- line,- aRel,- gap,- );- return intersections.map((point) =>- GAPoint.toTuple(GATransform.apply(reverseRelateToCenter, point)),- );-};--const getSortedElementLineIntersections = (- element: ExcalidrawBindableElement,- // Relative to element center- line: GA.Line,- // Relative to element center- nearPoint: GA.Point,- gap: number = 0,-): GA.Point[] => {- let intersections: GA.Point[];- switch (element.type) {- case "rectangle":- case "image":- case "text":- case "diamond":- case "iframe":- case "embeddable":- case "frame":- case "magicframe":- const corners = getCorners(element);- intersections = corners- .flatMap((point, i) => {- const edge: [GA.Point, GA.Point] = [point, corners[(i + 1) % 4]];- return intersectSegment(line, offsetSegment(edge, gap));- })- .concat(- corners.flatMap((point) => getCircleIntersections(point, gap, line)),- );- break;- case "ellipse":- intersections = getEllipseIntersections(element, gap, line);- break;- }- if (intersections.length < 2) {- // Ignore the "edge" case of only intersecting with a single corner- return [];- }- const sortedIntersections = intersections.sort(- (i1, i2) =>- GAPoint.distance(i1, nearPoint) - GAPoint.distance(i2, nearPoint),- );- return [- sortedIntersections[0],- sortedIntersections[sortedIntersections.length - 1],- ];-};--const getCorners = (- element:- | ExcalidrawRectangleElement- | ExcalidrawImageElement- | ExcalidrawDiamondElement- | ExcalidrawTextElement- | ExcalidrawIframeLikeElement- | ExcalidrawFrameLikeElement,- scale: number = 1,-): GA.Point[] => {- const hx = (scale * element.width) / 2;- const hy = (scale * element.height) / 2;- switch (element.type) {- case "rectangle":- case "image":- case "text":- case "iframe":- case "embeddable":- case "frame":- case "magicframe":- return [- GA.point(hx, hy),- GA.point(hx, -hy),- GA.point(-hx, -hy),- GA.point(-hx, hy),- ];- case "diamond":- return [- GA.point(0, hy),- GA.point(hx, 0),- GA.point(0, -hy),- GA.point(-hx, 0),- ];- }-};--// Returns intersection of `line` with `segment`, with `segment` moved by-// `gap` in its polar direction.-// If intersection coincides with second segment point returns empty array.-const intersectSegment = (- line: GA.Line,- segment: [GA.Point, GA.Point],-): GA.Point[] => {- const [a, b] = segment;- const aDist = GAPoint.distanceToLine(a, line);- const bDist = GAPoint.distanceToLine(b, line);- if (aDist * bDist >= 0) {- // The intersection is outside segment `(a, b)`- return [];- }- return [GAPoint.intersect(line, GALine.through(a, b))];-};--const offsetSegment = (- segment: [GA.Point, GA.Point],- distance: number,-): [GA.Point, GA.Point] => {- const [a, b] = segment;- const offset = GATransform.translationOrthogonal(- GADirection.fromTo(a, b),- distance,- );- return [GATransform.apply(offset, a), GATransform.apply(offset, b)];-};--const getEllipseIntersections = (- element: ExcalidrawEllipseElement,- gap: number,- line: GA.Line,-): GA.Point[] => {- const a = element.width / 2 + gap;- const b = element.height / 2 + gap;- const m = line[2];- const n = line[3];- const c = line[1];- const squares = a * a * m * m + b * b * n * n;- const discr = squares - c * c;- if (squares === 0 || discr <= 0) {- return [];- }- const discrRoot = Math.sqrt(discr);- const xn = -a * a * m * c;- const yn = -b * b * n * c;- return [- GA.point(- (xn + a * b * n * discrRoot) / squares,- (yn - a * b * m * discrRoot) / squares,- ),- GA.point(- (xn - a * b * n * discrRoot) / squares,- (yn + a * b * m * discrRoot) / squares,- ),- ];-};--export const getCircleIntersections = (- center: GA.Point,- radius: number,- line: GA.Line,-): GA.Point[] => {- if (radius === 0) {- return GAPoint.distanceToLine(line, center) === 0 ? [center] : [];- }- const m = line[2];- const n = line[3];- const c = line[1];- const [a, b] = GAPoint.toTuple(center);- const r = radius;- const squares = m * m + n * n;- const discr = r * r * squares - (m * a + n * b + c) ** 2;- if (squares === 0 || discr <= 0) {- return [];- }- const discrRoot = Math.sqrt(discr);- const xn = a * n * n - b * m * n - m * c;- const yn = b * m * m - a * m * n - n * c;-- return [- GA.point((xn + n * discrRoot) / squares, (yn - m * discrRoot) / squares),- GA.point((xn - n * discrRoot) / squares, (yn + m * discrRoot) / squares),- ];-};--// The focus point is the tangent point of the "focus image" of the-// `element`, where the tangent goes through `point`.-export const findFocusPointForEllipse = (- ellipse: ExcalidrawEllipseElement,- // Between -1 and 1 (not 0) the relative size of the "focus image" of- // the element on which the focus point lies- relativeDistance: number,- // The point for which we're trying to find the focus point, relative- // to the ellipse center.- point: GA.Point,-): GA.Point => {- const relativeDistanceAbs = Math.abs(relativeDistance);- const a = (ellipse.width * relativeDistanceAbs) / 2;- const b = (ellipse.height * relativeDistanceAbs) / 2;-- const orientation = Math.sign(relativeDistance);- const [px, pyo] = GAPoint.toTuple(point);-- // The calculation below can't handle py = 0- const py = pyo === 0 ? 0.0001 : pyo;-- const squares = px ** 2 * b ** 2 + py ** 2 * a ** 2;- // Tangent mx + ny + 1 = 0- const m =- (-px * b ** 2 +- orientation * py * Math.sqrt(Math.max(0, squares - a ** 2 * b ** 2))) /- squares;-- let n = (-m * px - 1) / py;-- if (n === 0) {- // if zero {-0, 0}, fall back to a same-sign value in the similar range- n = (Object.is(n, -0) ? -1 : 1) * 0.01;- }-- const x = -(a ** 2 * m) / (n ** 2 * b ** 2 + m ** 2 * a ** 2);- return GA.point(x, (-m * x - 1) / n);-};--export const findFocusPointForRectangulars = (- element:- | ExcalidrawRectangleElement- | ExcalidrawImageElement- | ExcalidrawDiamondElement- | ExcalidrawTextElement- | ExcalidrawIframeLikeElement- | ExcalidrawFrameLikeElement,- // Between -1 and 1 for how far away should the focus point be relative- // to the size of the element. Sign determines orientation.- relativeDistance: number,- // The point for which we're trying to find the focus point, relative- // to the element center.- point: GA.Point,-): GA.Point => {- const relativeDistanceAbs = Math.abs(relativeDistance);- const orientation = Math.sign(relativeDistance);- const corners = getCorners(element, relativeDistanceAbs);-- let maxDistance = 0;- let tangentPoint: null | GA.Point = null;- corners.forEach((corner) => {- const distance = orientation * GALine.through(point, corner)[1];- if (distance > maxDistance) {- maxDistance = distance;- tangentPoint = corner;- }- });- return tangentPoint!;-};--const pointInBezierEquation = (- p0: Point,- p1: Point,- p2: Point,- p3: Point,- [mx, my]: Point,- lineThreshold: number,+ tolerance = 0,) => {- // B(t) = p0 * (1-t)^3 + 3p1 * t * (1-t)^2 + 3p2 * t^2 * (1-t) + p3 * t^3- const equation = (t: number, idx: number) =>- Math.pow(1 - t, 3) * p3[idx] +- 3 * t * Math.pow(1 - t, 2) * p2[idx] +- 3 * Math.pow(t, 2) * (1 - t) * p1[idx] +- p0[idx] * Math.pow(t, 3);-- // go through t in increments of 0.01- let t = 0;- while (t <= 1.0) {- const tx = equation(t, 0);- const ty = equation(t, 1);-- const diff = Math.sqrt(Math.pow(tx - mx, 2) + Math.pow(ty - my, 2));-- if (diff < lineThreshold) {- return true;- }-- t += 0.01;- }-- return false;+ let [x1, y1, x2, y2] = getElementBounds(element, elementsMap);+ x1 -= tolerance;+ y1 -= tolerance;+ x2 += tolerance;+ y2 += tolerance;+ return isPointWithinBounds([x1, y1], [x, y], [x2, y2]);};-const hitTestCurveInside = (- drawable: Drawable,- x: number,- y: number,- roundness: StrokeRoundness,+export const hitElementBoundingBoxOnly = (+ hitArgs: HitTestArgs,+ elementsMap: ElementsMap,) => {- const ops = getCurvePathOps(drawable);- const points: Mutable<Point>[] = [];- let odd = false; // select one line out of double lines- for (const operation of ops) {- if (operation.op === "move") {- odd = !odd;- if (odd) {- points.push([operation.data[0], operation.data[1]]);- }- } else if (operation.op === "bcurveTo") {- if (odd) {- points.push([operation.data[0], operation.data[1]]);- points.push([operation.data[2], operation.data[3]]);- points.push([operation.data[4], operation.data[5]]);- }- } else if (operation.op === "lineTo") {- if (odd) {- points.push([operation.data[0], operation.data[1]]);- }- }- }- if (points.length >= 4) {- if (roundness === "sharp") {- return isPointInPolygon(points, x, y);- }- const polygonPoints = pointsOnBezierCurves(points, 10, 5);- return isPointInPolygon(polygonPoints, x, y);- }- return false;+ return (+ !hitElementItself(hitArgs) &&+ hitElementBoundingBox(hitArgs.x, hitArgs.y, hitArgs.element, elementsMap)+ );};-const hitTestRoughShape = (- drawable: Drawable,+export const hitElementBoundText = (x: number,y: number,- lineThreshold: number,+ textShape: GeometricShape | null,) => {- // read operations from first opSet- const ops = getCurvePathOps(drawable);-- // set start position as (0,0) just in case- // move operation does not exist (unlikely but it is worth safekeeping it)- let currentP: Point = [0, 0];-- return ops.some(({ op, data }, idx) => {- // There are only four operation types:- // move, bcurveTo, lineTo, and curveTo- if (op === "move") {- // change starting point- currentP = data as unknown as Point;- // move operation does not draw anything; so, it always- // returns false- } else if (op === "bcurveTo") {- // create points from bezier curve- // bezier curve stores data as a flattened array of three positions- // [x1, y1, x2, y2, x3, y3]- const p1 = [data[0], data[1]] as Point;- const p2 = [data[2], data[3]] as Point;- const p3 = [data[4], data[5]] as Point;-- const p0 = currentP;- currentP = p3;-- // check if points are on the curve- // cubic bezier curves require four parameters- // the first parameter is the last stored position (p0)- const retVal = pointInBezierEquation(- p0,- p1,- p2,- p3,- [x, y],- lineThreshold,- );-- // set end point of bezier curve as the new starting point for- // upcoming operations as each operation is based on the last drawn- // position of the previous operation- return retVal;- } else if (op === "lineTo") {- return hitTestCurveInside(drawable, x, y, "sharp");- } else if (op === "qcurveTo") {- // TODO: Implement this- console.warn("qcurveTo is not implemented yet");- }-- return false;- });+ return textShape && isPointInShape([x, y], textShape);};diff --git a/packages/excalidraw/element/index.ts b/packages/excalidraw/element/index.tsindex 7e9769d832..e7d699dae3 100644--- a/packages/excalidraw/element/index.ts+++ b/packages/excalidraw/element/index.ts@@ -29,10 +29,6 @@ export {getTransformHandlesFromCoords,getTransformHandles,} from "./transformHandles";-export {- hitTest,- isHittingElementBoundingBoxWithoutHittingElement,-} from "./collision";export {resizeTest,getCursorForResizingElement,diff --git a/packages/excalidraw/element/linearElementEditor.ts b/packages/excalidraw/element/linearElementEditor.tsindex d493f1fbdf..29fa65c35f 100644--- a/packages/excalidraw/element/linearElementEditor.ts+++ b/packages/excalidraw/element/linearElementEditor.ts@@ -6,7 +6,6 @@ import {ExcalidrawBindableElement,ExcalidrawTextElementWithContainer,ElementsMap,- NonDeletedExcalidrawElement,NonDeletedSceneElementsMap,} from "./types";import {@@ -34,6 +33,7 @@ import {AppState,PointerCoords,InteractiveCanvasAppState,+ AppClassProperties,} from "../types";import { mutateElement } from "./mutateElement";import History from "../history";@@ -334,9 +334,10 @@ export class LinearElementEditor {event: PointerEvent,editingLinearElement: LinearElementEditor,appState: AppState,- elements: readonly NonDeletedExcalidrawElement[],- elementsMap: NonDeletedSceneElementsMap,+ app: AppClassProperties,): LinearElementEditor {+ const elementsMap = app.scene.getNonDeletedElementsMap();+const { elementId, selectedPointsIndices, isDragging, pointerDownState } =editingLinearElement;const element = LinearElementEditor.getElement(elementId, elementsMap);@@ -380,8 +381,7 @@ export class LinearElementEditor {elementsMap,),),- elements,- elementsMap,+ app,): null;@@ -645,13 +645,14 @@ export class LinearElementEditor {history: History,scenePointer: { x: number; y: number },linearElementEditor: LinearElementEditor,- elements: readonly NonDeletedExcalidrawElement[],- elementsMap: NonDeletedSceneElementsMap,+ app: AppClassProperties,): {didAddPoint: boolean;hitElement: NonDeleted<ExcalidrawElement> | null;linearElementEditor: LinearElementEditor | null;} {+ const elementsMap = app.scene.getNonDeletedElementsMap();+const ret: ReturnType<typeof LinearElementEditor["handlePointerDown"]> = {didAddPoint: false,hitElement: null,@@ -714,11 +715,7 @@ export class LinearElementEditor {},selectedPointsIndices: [element.points.length - 1],lastUncommittedPoint: null,- endBindingElement: getHoveredElementForBinding(- scenePointer,- elements,- elementsMap,- ),+ endBindingElement: getHoveredElementForBinding(scenePointer, app),};ret.didAddPoint = true;diff --git a/packages/excalidraw/element/textElement.ts b/packages/excalidraw/element/textElement.tsindex b54cc1c8ed..6f45561f81 100644--- a/packages/excalidraw/element/textElement.ts+++ b/packages/excalidraw/element/textElement.ts@@ -26,16 +26,11 @@ import { isTextElement } from ".";import { isBoundToContainer, isArrowElement } from "./typeChecks";import { LinearElementEditor } from "./linearElementEditor";import { AppState } from "../types";-import { isTextBindableContainer } from "./typeChecks";-import { getElementAbsoluteCoords } from ".";-import { getSelectedElements } from "../scene";-import { isHittingElementNotConsideringBoundingBox } from "./collision";--import { ExtractSetType, MakeBrand } from "../utility-types";import {resetOriginalContainerCache,updateOriginalContainerCache,} from "./containerCache";+import { ExtractSetType, MakeBrand } from "../utility-types";export const normalizeText = (text: string) => {return (@@ -771,50 +766,6 @@ export const suppportsHorizontalAlign = (});};-export const getTextBindableContainerAtPosition = (- elements: readonly ExcalidrawElement[],- appState: AppState,- x: number,- y: number,- elementsMap: ElementsMap,-): ExcalidrawTextContainer | null => {- const selectedElements = getSelectedElements(elements, appState);- if (selectedElements.length === 1) {- return isTextBindableContainer(selectedElements[0], false)- ? selectedElements[0]- : null;- }- let hitElement = null;- // We need to to hit testing from front (end of the array) to back (beginning of the array)- for (let index = elements.length - 1; index >= 0; --index) {- if (elements[index].isDeleted) {- continue;- }- const [x1, y1, x2, y2] = getElementAbsoluteCoords(- elements[index],- elementsMap,- );- if (- isArrowElement(elements[index]) &&- isHittingElementNotConsideringBoundingBox(- elements[index],- appState,- null,- [x, y],- elementsMap,- )- ) {- hitElement = elements[index];- break;- } else if (x1 < x && x < x2 && y1 < y && y < y2) {- hitElement = elements[index];- break;- }- }-- return isTextBindableContainer(hitElement, false) ? hitElement : null;-};-const VALID_CONTAINER_TYPES = new Set(["rectangle","ellipse",diff --git a/packages/excalidraw/renderer/interactiveScene.ts b/packages/excalidraw/renderer/interactiveScene.tsindex 0fd814e890..b1855cfe8b 100644--- a/packages/excalidraw/renderer/interactiveScene.ts+++ b/packages/excalidraw/renderer/interactiveScene.ts@@ -34,8 +34,11 @@ import { DEFAULT_TRANSFORM_HANDLE_SPACING, FRAME_STYLE } from "../constants";import { renderSnaps } from "../renderer/renderSnaps";-import { maxBindingGap } from "../element/collision";-import { SuggestedBinding, SuggestedPointBinding } from "../element/binding";+import {+ maxBindingGap,+ SuggestedBinding,+ SuggestedPointBinding,+} from "../element/binding";import { LinearElementEditor } from "../element/linearElementEditor";import {bootstrapCanvas,diff --git a/packages/excalidraw/tests/__snapshots__/contextmenu.test.tsx.snap b/packages/excalidraw/tests/__snapshots__/contextmenu.test.tsx.snapindex f493dbe6ba..42b796d2d2 100644--- a/packages/excalidraw/tests/__snapshots__/contextmenu.test.tsx.snap+++ b/packages/excalidraw/tests/__snapshots__/contextmenu.test.tsx.snap@@ -2294,14 +2294,14 @@ exports[`contextMenu element > selecting 'Delete' in context menu deletes elemen"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 3,- "versionNonce": 1116226695,+ "versionNonce": 2019559783,"width": 20,"x": -10,"y": 0,@@ -2354,14 +2354,14 @@ exports[`contextMenu element > selecting 'Delete' in context menu deletes elemen"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -2396,14 +2396,14 @@ exports[`contextMenu element > selecting 'Delete' in context menu deletes elemen"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 3,- "versionNonce": 1116226695,+ "versionNonce": 2019559783,"width": 20,"x": -10,"y": 0,@@ -2540,14 +2540,14 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -2573,14 +2573,14 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates"roundness": {"type": 3,},- "seed": 1116226695,+ "seed": 2019559783,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": 0,"y": 10,@@ -2633,14 +2633,14 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -2677,14 +2677,14 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -2707,14 +2707,14 @@ exports[`contextMenu element > selecting 'Duplicate' in context menu duplicates"roundness": {"type": 3,},- "seed": 1116226695,+ "seed": 2019559783,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": 0,"y": 10,@@ -2858,14 +2858,14 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 3,- "versionNonce": 1505387817,+ "versionNonce": 400692809,"width": 20,"x": -10,"y": 0,@@ -2893,14 +2893,14 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group"roundness": {"type": 3,},- "seed": 1116226695,+ "seed": 2019559783,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 3,- "versionNonce": 23633383,+ "versionNonce": 1604849351,"width": 20,"x": 20,"y": 30,@@ -2953,14 +2953,14 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -2997,14 +2997,14 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -3027,14 +3027,14 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group"roundness": {"type": 3,},- "seed": 1116226695,+ "seed": 2019559783,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 238820263,+ "versionNonce": 1116226695,"width": 20,"x": 20,"y": 30,@@ -3076,14 +3076,14 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 3,- "versionNonce": 1505387817,+ "versionNonce": 400692809,"width": 20,"x": -10,"y": 0,@@ -3108,14 +3108,14 @@ exports[`contextMenu element > selecting 'Group selection' in context menu group"roundness": {"type": 3,},- "seed": 1116226695,+ "seed": 2019559783,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 3,- "versionNonce": 23633383,+ "versionNonce": 1604849351,"width": 20,"x": 20,"y": 30,@@ -3254,14 +3254,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#e03131","strokeStyle": "dotted","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 3,- "versionNonce": 640725609,+ "versionNonce": 1315507081,"width": 20,"x": -10,"y": 0,@@ -3287,14 +3287,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 760410951,+ "seed": 747212839,"strokeColor": "#e03131","strokeStyle": "dotted","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 8,- "versionNonce": 1315507081,+ "versionNonce": 1006504105,"width": 20,"x": 20,"y": 30,@@ -3347,14 +3347,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -3391,14 +3391,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -3421,14 +3421,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 1116226695,+ "seed": 2019559783,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 238820263,+ "versionNonce": 1116226695,"width": 20,"x": 20,"y": 30,@@ -3465,14 +3465,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -3495,14 +3495,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 1116226695,+ "seed": 2019559783,"strokeColor": "#e03131","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 3,- "versionNonce": 1604849351,+ "versionNonce": 238820263,"width": 20,"x": 20,"y": 30,@@ -3539,14 +3539,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -3569,14 +3569,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 1116226695,+ "seed": 2019559783,"strokeColor": "#e03131","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 4,- "versionNonce": 23633383,+ "versionNonce": 1604849351,"width": 20,"x": 20,"y": 30,@@ -3613,14 +3613,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -3643,14 +3643,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 1116226695,+ "seed": 2019559783,"strokeColor": "#e03131","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 5,- "versionNonce": 915032327,+ "versionNonce": 23633383,"width": 20,"x": 20,"y": 30,@@ -3687,14 +3687,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -3717,14 +3717,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 1116226695,+ "seed": 2019559783,"strokeColor": "#e03131","strokeStyle": "dotted","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 6,- "versionNonce": 747212839,+ "versionNonce": 915032327,"width": 20,"x": 20,"y": 30,@@ -3761,14 +3761,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -3791,14 +3791,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 760410951,+ "seed": 747212839,"strokeColor": "#e03131","strokeStyle": "dotted","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 7,- "versionNonce": 1006504105,+ "versionNonce": 1723083209,"width": 20,"x": 20,"y": 30,@@ -3835,14 +3835,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -3865,14 +3865,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 760410951,+ "seed": 747212839,"strokeColor": "#e03131","strokeStyle": "dotted","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 8,- "versionNonce": 1315507081,+ "versionNonce": 1006504105,"width": 20,"x": 20,"y": 30,@@ -3909,14 +3909,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#e03131","strokeStyle": "dotted","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 3,- "versionNonce": 640725609,+ "versionNonce": 1315507081,"width": 20,"x": -10,"y": 0,@@ -3939,14 +3939,14 @@ exports[`contextMenu element > selecting 'Paste styles' in context menu pastes s"roundness": {"type": 3,},- "seed": 760410951,+ "seed": 747212839,"strokeColor": "#e03131","strokeStyle": "dotted","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 8,- "versionNonce": 1315507081,+ "versionNonce": 1006504105,"width": 20,"x": 20,"y": 30,@@ -4468,14 +4468,14 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el"roundness": {"type": 3,},- "seed": 1116226695,+ "seed": 2019559783,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 3,- "versionNonce": 1604849351,+ "versionNonce": 238820263,"width": 20,"x": 20,"y": 30,@@ -4501,14 +4501,14 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -4561,14 +4561,14 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -4605,14 +4605,14 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -4635,14 +4635,14 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el"roundness": {"type": 3,},- "seed": 1116226695,+ "seed": 2019559783,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 238820263,+ "versionNonce": 1116226695,"width": 20,"x": 20,"y": 30,@@ -4679,14 +4679,14 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el"roundness": {"type": 3,},- "seed": 1116226695,+ "seed": 2019559783,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 3,- "versionNonce": 1604849351,+ "versionNonce": 238820263,"width": 20,"x": 20,"y": 30,@@ -4709,14 +4709,14 @@ exports[`contextMenu element > selecting 'Send to back' in context menu sends el"roundness": {"type": 3,},- "seed": 449462985,+ "seed": 1278240551,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 2019559783,+ "versionNonce": 453191,"width": 20,"x": -10,"y": 0,@@ -6115,14 +6115,14 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi"roundness": {"type": 3,},- "seed": 453191,+ "seed": 449462985,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 1116226695,+ "versionNonce": 2019559783,"width": 10,"x": -10,"y": 0,@@ -6148,14 +6148,14 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi"roundness": {"type": 3,},- "seed": 238820263,+ "seed": 1116226695,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 1604849351,+ "versionNonce": 238820263,"width": 10,"x": 10,"y": 0,@@ -6208,14 +6208,14 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi"roundness": {"type": 3,},- "seed": 453191,+ "seed": 449462985,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 1116226695,+ "versionNonce": 2019559783,"width": 10,"x": -10,"y": 0,@@ -6252,14 +6252,14 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi"roundness": {"type": 3,},- "seed": 453191,+ "seed": 449462985,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 1116226695,+ "versionNonce": 2019559783,"width": 10,"x": -10,"y": 0,@@ -6282,14 +6282,14 @@ exports[`contextMenu element > shows 'Group selection' in context menu for multi"roundness": {"type": 3,},- "seed": 238820263,+ "seed": 1116226695,"strokeColor": "#1e1e1e","strokeStyle": "solid","strokeWidth": 2,"type": "rectangle","updated": 1,"version": 2,- "versionNonce": 1604849351,+ "versionNonce": 238820263,"width": 10,"x": 10,"y": 0,diff --git a/packages/excalidraw/tests/helpers/ui.ts b/packages/excalidraw/tests/helpers/ui.tsindex c03b889df4..ec0a743536 100644--- a/packages/excalidraw/tests/helpers/ui.ts+++ b/packages/excalidraw/tests/helpers/ui.ts@@ -287,9 +287,16 @@ const transform = (keyboardModifiers: KeyboardModifiers = {},) => {const elements = Array.isArray(element) ? element : [element];- mouse.select(elements);+ h.setState({+ selectedElementIds: elements.reduce(+ (acc, e) => ({+ ...acc,+ [e.id]: true,+ }),+ {},+ ),+ });let handleCoords: TransformHandle | undefined;-if (elements.length === 1) {handleCoords = getTransformHandles(elements[0],diff --git a/packages/excalidraw/tests/linearElementEditor.test.tsx b/packages/excalidraw/tests/linearElementEditor.test.tsxindex 551b794792..51bc70a4a5 100644--- a/packages/excalidraw/tests/linearElementEditor.test.tsx+++ b/packages/excalidraw/tests/linearElementEditor.test.tsx@@ -321,9 +321,9 @@ describe("Test Linear Elements", () => {fireEvent.click(screen.getByTitle("Round"));expect(renderInteractiveScene.mock.calls.length).toMatchInlineSnapshot(- `10`,+ `9`,);- expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`8`);+ expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`7`);const midPointsWithRoundEdge = LinearElementEditor.getEditorMidPoints(h.elements[0] as ExcalidrawLinearElement,@@ -379,9 +379,9 @@ describe("Test Linear Elements", () => {drag(startPoint, endPoint);expect(renderInteractiveScene.mock.calls.length).toMatchInlineSnapshot(- `13`,+ `12`,);- expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`9`);+ expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`8`);expect([line.x, line.y]).toEqual([points[0][0] + deltaX,@@ -441,9 +441,9 @@ describe("Test Linear Elements", () => {]);expect(renderInteractiveScene.mock.calls.length).toMatchInlineSnapshot(- `17`,+ `16`,);- expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`9`);+ expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`8`);expect(line.points.length).toEqual(5);@@ -492,9 +492,9 @@ describe("Test Linear Elements", () => {drag(hitCoords, [hitCoords[0] - delta, hitCoords[1] - delta]);expect(renderInteractiveScene.mock.calls.length).toMatchInlineSnapshot(- `13`,+ `12`,);- expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`8`);+ expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`7`);const newPoints = LinearElementEditor.getPointsGlobalCoordinates(line,@@ -533,9 +533,9 @@ describe("Test Linear Elements", () => {drag(hitCoords, [hitCoords[0] + delta, hitCoords[1] + delta]);expect(renderInteractiveScene.mock.calls.length).toMatchInlineSnapshot(- `13`,+ `12`,);- expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`8`);+ expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`7`);const newPoints = LinearElementEditor.getPointsGlobalCoordinates(line,@@ -581,9 +581,9 @@ describe("Test Linear Elements", () => {deletePoint(points[2]);expect(line.points.length).toEqual(3);expect(renderInteractiveScene.mock.calls.length).toMatchInlineSnapshot(- `19`,+ `18`,);- expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`9`);+ expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`8`);const newMidPoints = LinearElementEditor.getEditorMidPoints(line,@@ -631,9 +631,9 @@ describe("Test Linear Elements", () => {lastSegmentMidpoint[1] + delta,]);expect(renderInteractiveScene.mock.calls.length).toMatchInlineSnapshot(- `17`,+ `16`,);- expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`9`);+ expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`8`);expect(line.points.length).toEqual(5);expect((h.elements[0] as ExcalidrawLinearElement).points)@@ -729,9 +729,9 @@ describe("Test Linear Elements", () => {drag(hitCoords, [hitCoords[0] + delta, hitCoords[1] + delta]);expect(renderInteractiveScene.mock.calls.length).toMatchInlineSnapshot(- `13`,+ `12`,);- expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`8`);+ expect(renderStaticScene.mock.calls.length).toMatchInlineSnapshot(`7`);const newPoints = LinearElementEditor.getPointsGlobalCoordinates(line,diff --git a/packages/excalidraw/types.ts b/packages/excalidraw/types.tsindex 2c66eec4cf..01e582a8d9 100644--- a/packages/excalidraw/types.ts+++ b/packages/excalidraw/types.ts@@ -586,6 +586,7 @@ export type AppClassProperties = {setOpenDialog: App["setOpenDialog"];insertEmbeddableElement: App["insertEmbeddableElement"];onMagicframeToolSelect: App["onMagicframeToolSelect"];+ getElementShape: App["getElementShape"];getName: App["getName"];};@@ -722,7 +723,7 @@ export type Device = Readonly<{isTouchScreen: boolean;}>;-type FrameNameBounds = {+export type FrameNameBounds = {x: number;y: number;width: number;diff --git a/packages/utils/collision.ts b/packages/utils/collision.tsnew file mode 100644index 0000000000..777ba962ad--- /dev/null+++ b/packages/utils/collision.ts@@ -0,0 +1,66 @@+import { Point, Polygon, GeometricShape } from "./geometry/shape";+import {+ pointInEllipse,+ pointInPolygon,+ pointOnCurve,+ pointOnEllipse,+ pointOnLine,+ pointOnPolycurve,+ pointOnPolygon,+ pointOnPolyline,+ close,+} from "./geometry/geometry";++// check if the given point is considered on the given shape's border+export const isPointOnShape = (+ point: Point,+ shape: GeometricShape,+ tolerance = 0,+) => {+ // get the distance from the given point to the given element+ // check if the distance is within the given epsilon range+ switch (shape.type) {+ case "polygon":+ return pointOnPolygon(point, shape.data, tolerance);+ case "ellipse":+ return pointOnEllipse(point, shape.data, tolerance);+ case "line":+ return pointOnLine(point, shape.data, tolerance);+ case "polyline":+ return pointOnPolyline(point, shape.data, tolerance);+ case "curve":+ return pointOnCurve(point, shape.data, tolerance);+ case "polycurve":+ return pointOnPolycurve(point, shape.data, tolerance);+ default:+ throw Error(`shape ${shape} is not implemented`);+ }+};++// check if the given point is considered inside the element's border+export const isPointInShape = (point: Point, shape: GeometricShape) => {+ switch (shape.type) {+ case "polygon":+ return pointInPolygon(point, shape.data);+ case "line":+ return false;+ case "curve":+ return false;+ case "ellipse":+ return pointInEllipse(point, shape.data);+ case "polyline": {+ const polygon = close(shape.data.flat()) as Polygon;+ return pointInPolygon(point, polygon);+ }+ case "polycurve": {+ return false;+ }+ default:+ throw Error(`shape ${shape} is not implemented`);+ }+};++// check if the given element is in the given bounds+export const isPointInBounds = (point: Point, bounds: Polygon) => {+ return pointInPolygon(point, bounds);+};diff --git a/packages/utils/geometry/geometry.test.ts b/packages/utils/geometry/geometry.test.tsnew file mode 100644index 0000000000..a0103deee1--- /dev/null+++ b/packages/utils/geometry/geometry.test.ts@@ -0,0 +1,249 @@+import {+ lineIntersectsLine,+ lineRotate,+ pointInEllipse,+ pointInPolygon,+ pointLeftofLine,+ pointOnCurve,+ pointOnEllipse,+ pointOnLine,+ pointOnPolygon,+ pointOnPolyline,+ pointRightofLine,+ pointRotate,+} from "./geometry";+import { Curve, Ellipse, Line, Point, Polygon, Polyline } from "./shape";++describe("point and line", () => {+ const line: Line = [+ [1, 0],+ [1, 2],+ ];++ it("point on left or right of line", () => {+ expect(pointLeftofLine([0, 1], line)).toBe(true);+ expect(pointLeftofLine([1, 1], line)).toBe(false);+ expect(pointLeftofLine([2, 1], line)).toBe(false);++ expect(pointRightofLine([0, 1], line)).toBe(false);+ expect(pointRightofLine([1, 1], line)).toBe(false);+ expect(pointRightofLine([2, 1], line)).toBe(true);+ });++ it("point on the line", () => {+ expect(pointOnLine([0, 1], line)).toBe(false);+ expect(pointOnLine([1, 1], line, 0)).toBe(true);+ expect(pointOnLine([2, 1], line)).toBe(false);+ });+});++describe("point and polylines", () => {+ const polyline: Polyline = [+ [+ [1, 0],+ [1, 2],+ ],+ [+ [1, 2],+ [2, 2],+ ],+ [+ [2, 2],+ [2, 1],+ ],+ [+ [2, 1],+ [3, 1],+ ],+ ];++ it("point on the line", () => {+ expect(pointOnPolyline([1, 0], polyline)).toBe(true);+ expect(pointOnPolyline([1, 2], polyline)).toBe(true);+ expect(pointOnPolyline([2, 2], polyline)).toBe(true);+ expect(pointOnPolyline([2, 1], polyline)).toBe(true);+ expect(pointOnPolyline([3, 1], polyline)).toBe(true);++ expect(pointOnPolyline([1, 1], polyline)).toBe(true);+ expect(pointOnPolyline([2, 1.5], polyline)).toBe(true);+ expect(pointOnPolyline([2.5, 1], polyline)).toBe(true);++ expect(pointOnPolyline([0, 1], polyline)).toBe(false);+ expect(pointOnPolyline([2.1, 1.5], polyline)).toBe(false);+ });++ it("point on the line with rotation", () => {+ const truePoints = [+ [1, 0],+ [1, 2],+ [2, 2],+ [2, 1],+ [3, 1],+ ] as Point[];++ truePoints.forEach((point) => {+ const rotation = Math.random() * 360;+ const rotatedPoint = pointRotate(point, rotation);+ const rotatedPolyline: Polyline = polyline.map((line) =>+ lineRotate(line, rotation, [0, 0]),+ );+ expect(pointOnPolyline(rotatedPoint, rotatedPolyline)).toBe(true);+ });++ const falsePoints = [+ [0, 1],+ [2.1, 1.5],+ ] as Point[];++ falsePoints.forEach((point) => {+ const rotation = Math.random() * 360;+ const rotatedPoint = pointRotate(point, rotation);+ const rotatedPolyline: Polyline = polyline.map((line) =>+ lineRotate(line, rotation, [0, 0]),+ );+ expect(pointOnPolyline(rotatedPoint, rotatedPolyline)).toBe(false);+ });+ });+});++describe("point and polygon", () => {+ const polygon: Polygon = [+ [10, 10],+ [50, 10],+ [50, 50],+ [10, 50],+ ];++ it("point on polygon", () => {+ expect(pointOnPolygon([30, 10], polygon)).toBe(true);+ expect(pointOnPolygon([50, 30], polygon)).toBe(true);+ expect(pointOnPolygon([30, 50], polygon)).toBe(true);+ expect(pointOnPolygon([10, 30], polygon)).toBe(true);+ expect(pointOnPolygon([30, 30], polygon)).toBe(false);+ expect(pointOnPolygon([30, 70], polygon)).toBe(false);+ });++ it("point in polygon", () => {+ const polygon: Polygon = [+ [0, 0],+ [2, 0],+ [2, 2],+ [0, 2],+ ];+ expect(pointInPolygon([1, 1], polygon)).toBe(true);+ expect(pointInPolygon([3, 3], polygon)).toBe(false);+ });+});++describe("point and curve", () => {+ const curve: Curve = [+ [1.4, 1.65],+ [1.9, 7.9],+ [5.9, 1.65],+ [6.44, 4.84],+ ];++ it("point on curve", () => {+ expect(pointOnCurve(curve[0], curve)).toBe(true);+ expect(pointOnCurve(curve[3], curve)).toBe(true);++ expect(pointOnCurve([2, 4], curve, 0.1)).toBe(true);+ expect(pointOnCurve([4, 4.4], curve, 0.1)).toBe(true);+ expect(pointOnCurve([5.6, 3.85], curve, 0.1)).toBe(true);++ expect(pointOnCurve([5.6, 4], curve, 0.1)).toBe(false);+ expect(pointOnCurve(curve[1], curve, 0.1)).toBe(false);+ expect(pointOnCurve(curve[2], curve, 0.1)).toBe(false);+ });+});++describe("point and ellipse", () => {+ const ellipse: Ellipse = {+ center: [0, 0],+ angle: 0,+ halfWidth: 2,+ halfHeight: 1,+ };++ it("point on ellipse", () => {+ [+ [0, 1],+ [0, -1],+ [2, 0],+ [-2, 0],+ ].forEach((point) => {+ expect(pointOnEllipse(point as Point, ellipse)).toBe(true);+ });+ expect(pointOnEllipse([-1.4, 0.7], ellipse, 0.1)).toBe(true);+ expect(pointOnEllipse([-1.4, 0.71], ellipse, 0.01)).toBe(true);++ expect(pointOnEllipse([1.4, 0.7], ellipse, 0.1)).toBe(true);+ expect(pointOnEllipse([1.4, 0.71], ellipse, 0.01)).toBe(true);++ expect(pointOnEllipse([1, -0.86], ellipse, 0.1)).toBe(true);+ expect(pointOnEllipse([1, -0.86], ellipse, 0.01)).toBe(true);++ expect(pointOnEllipse([-1, -0.86], ellipse, 0.1)).toBe(true);+ expect(pointOnEllipse([-1, -0.86], ellipse, 0.01)).toBe(true);++ expect(pointOnEllipse([-1, 0.8], ellipse)).toBe(false);+ expect(pointOnEllipse([1, -0.8], ellipse)).toBe(false);+ });++ it("point in ellipse", () => {+ [+ [0, 1],+ [0, -1],+ [2, 0],+ [-2, 0],+ ].forEach((point) => {+ expect(pointInEllipse(point as Point, ellipse)).toBe(true);+ });++ expect(pointInEllipse([-1, 0.8], ellipse)).toBe(true);+ expect(pointInEllipse([1, -0.8], ellipse)).toBe(true);++ expect(pointInEllipse([-1, 1], ellipse)).toBe(false);+ expect(pointInEllipse([-1.4, 0.8], ellipse)).toBe(false);+ });+});++describe("line and line", () => {+ const lineA: Line = [+ [1, 4],+ [3, 4],+ ];+ const lineB: Line = [+ [2, 1],+ [2, 7],+ ];+ const lineC: Line = [+ [1, 8],+ [3, 8],+ ];+ const lineD: Line = [+ [1, 8],+ [3, 8],+ ];+ const lineE: Line = [+ [1, 9],+ [3, 9],+ ];+ const lineF: Line = [+ [1, 2],+ [3, 4],+ ];+ const lineG: Line = [+ [0, 1],+ [2, 3],+ ];++ it("intersection", () => {+ expect(lineIntersectsLine(lineA, lineB)).toBe(true);+ expect(lineIntersectsLine(lineA, lineC)).toBe(false);+ expect(lineIntersectsLine(lineB, lineC)).toBe(false);+ expect(lineIntersectsLine(lineC, lineD)).toBe(true);+ expect(lineIntersectsLine(lineE, lineD)).toBe(false);+ expect(lineIntersectsLine(lineF, lineG)).toBe(true);+ });+});diff --git a/packages/utils/geometry/geometry.ts b/packages/utils/geometry/geometry.tsnew file mode 100644index 0000000000..000f33a239--- /dev/null+++ b/packages/utils/geometry/geometry.ts@@ -0,0 +1,956 @@+import { distance2d } from "../../excalidraw/math";+import {+ Point,+ Line,+ Polygon,+ Curve,+ Ellipse,+ Polycurve,+ Polyline,+} from "./shape";++const DEFAULT_THRESHOLD = 10e-5;++/**+ * utils+ */++// the two vectors are ao and bo+export const cross = (a: Point, b: Point, o: Point) => {+ return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);+};++export const isClosed = (polygon: Polygon) => {+ const first = polygon[0];+ const last = polygon[polygon.length - 1];+ return first[0] === last[0] && first[1] === last[1];+};++export const close = (polygon: Polygon) => {+ return isClosed(polygon) ? polygon : [...polygon, polygon[0]];+};++/**+ * angles+ */++// convert radians to degress+export const angleToDegrees = (angle: number) => {+ return (angle * 180) / Math.PI;+};++// convert degrees to radians+export const angleToRadians = (angle: number) => {+ return (angle / 180) * Math.PI;+};++// return the angle of reflection given an angle of incidence and a surface angle in degrees+export const angleReflect = (incidenceAngle: number, surfaceAngle: number) => {+ const a = surfaceAngle * 2 - incidenceAngle;+ return a >= 360 ? a - 360 : a < 0 ? a + 360 : a;+};++/**+ * points+ */++const rotate = (point: Point, angle: number): Point => {+ return [+ point[0] * Math.cos(angle) - point[1] * Math.sin(angle),+ point[0] * Math.sin(angle) + point[1] * Math.cos(angle),+ ];+};++const isOrigin = (point: Point) => {+ return point[0] === 0 && point[1] === 0;+};++// rotate a given point about a given origin at the given angle+export const pointRotate = (+ point: Point,+ angle: number,+ origin?: Point,+): Point => {+ const r = angleToRadians(angle);++ if (!origin || isOrigin(origin)) {+ return rotate(point, r);+ }+ return rotate(point.map((c, i) => c - origin[i]) as Point, r).map(+ (c, i) => c + origin[i],+ ) as Point;+};++// translate a point by an angle (in degrees) and distance+export const pointTranslate = (point: Point, angle = 0, distance = 0) => {+ const r = angleToRadians(angle);+ return [+ point[0] + distance * Math.cos(r),+ point[1] + distance * Math.sin(r),+ ] as Point;+};++export const pointInverse = (point: Point) => {+ return [-point[0], -point[1]] as Point;+};++export const pointAdd = (pointA: Point, pointB: Point): Point => {+ return [pointA[0] + pointB[0], pointA[1] + pointB[1]];+};++export const distanceToPoint = (p1: Point, p2: Point) => {+ return distance2d(...p1, ...p2);+};++/**+ * lines+ */++// return the angle of a line, in degrees+export const lineAngle = (line: Line) => {+ return angleToDegrees(+ Math.atan2(line[1][1] - line[0][1], line[1][0] - line[0][0]),+ );+};++// get the distance between the endpoints of a line segment+export const lineLength = (line: Line) => {+ return Math.sqrt(+ Math.pow(line[1][0] - line[0][0], 2) + Math.pow(line[1][1] - line[0][1], 2),+ );+};++// get the midpoint of a line segment+export const lineMidpoint = (line: Line) => {+ return [+ (line[0][0] + line[1][0]) / 2,+ (line[0][1] + line[1][1]) / 2,+ ] as Point;+};++// return the coordinates resulting from rotating the given line about an origin by an angle in degrees+// note that when the origin is not given, the midpoint of the given line is used as the origin+export const lineRotate = (line: Line, angle: number, origin?: Point): Line => {+ return line.map((point) =>+ pointRotate(point, angle, origin || lineMidpoint(line)),+ ) as Line;+};++// returns the coordinates resulting from translating a line by an angle in degrees and a distance.+export const lineTranslate = (line: Line, angle: number, distance: number) => {+ return line.map((point) => pointTranslate(point, angle, distance));+};++export const lineInterpolate = (line: Line, clamp = false) => {+ const [[x1, y1], [x2, y2]] = line;+ return (t: number) => {+ const t0 = clamp ? (t < 0 ? 0 : t > 1 ? 1 : t) : t;+ return [(x2 - x1) * t0 + x1, (y2 - y1) * t0 + y1] as Point;+ };+};++/**+ * curves+ */+function clone(p: Point): Point {+ return [...p] as Point;+}++export const curveToBezier = (+ pointsIn: readonly Point[],+ curveTightness = 0,+): Point[] => {+ const len = pointsIn.length;+ if (len < 3) {+ throw new Error("A curve must have at least three points.");+ }+ const out: Point[] = [];+ if (len === 3) {+ out.push(+ clone(pointsIn[0]),+ clone(pointsIn[1]),+ clone(pointsIn[2]),+ clone(pointsIn[2]),+ );+ } else {+ const points: Point[] = [];+ points.push(pointsIn[0], pointsIn[0]);+ for (let i = 1; i < pointsIn.length; i++) {+ points.push(pointsIn[i]);+ if (i === pointsIn.length - 1) {+ points.push(pointsIn[i]);+ }+ }+ const b: Point[] = [];+ const s = 1 - curveTightness;+ out.push(clone(points[0]));+ for (let i = 1; i + 2 < points.length; i++) {+ const cachedVertArray = points[i];+ b[0] = [cachedVertArray[0], cachedVertArray[1]];+ b[1] = [+ cachedVertArray[0] + (s * points[i + 1][0] - s * points[i - 1][0]) / 6,+ cachedVertArray[1] + (s * points[i + 1][1] - s * points[i - 1][1]) / 6,+ ];+ b[2] = [+ points[i + 1][0] + (s * points[i][0] - s * points[i + 2][0]) / 6,+ points[i + 1][1] + (s * points[i][1] - s * points[i + 2][1]) / 6,+ ];+ b[3] = [points[i + 1][0], points[i + 1][1]];+ out.push(b[1], b[2], b[3]);+ }+ }+ return out;+};++export const curveRotate = (curve: Curve, angle: number, origin: Point) => {+ return curve.map((p) => pointRotate(p, angle, origin));+};++export const cubicBezierPoint = (t: number, controlPoints: Curve): Point => {+ const [p0, p1, p2, p3] = controlPoints;++ const x =+ Math.pow(1 - t, 3) * p0[0] ++ 3 * Math.pow(1 - t, 2) * t * p1[0] ++ 3 * (1 - t) * Math.pow(t, 2) * p2[0] ++ Math.pow(t, 3) * p3[0];++ const y =+ Math.pow(1 - t, 3) * p0[1] ++ 3 * Math.pow(1 - t, 2) * t * p1[1] ++ 3 * (1 - t) * Math.pow(t, 2) * p2[1] ++ Math.pow(t, 3) * p3[1];++ return [x, y];+};++const solveCubicEquation = (a: number, b: number, c: number, d: number) => {+ // This function solves the cubic equation ax^3 + bx^2 + cx + d = 0+ const roots: number[] = [];++ const discriminant =+ 18 * a * b * c * d -+ 4 * Math.pow(b, 3) * d ++ Math.pow(b, 2) * Math.pow(c, 2) -+ 4 * a * Math.pow(c, 3) -+ 27 * Math.pow(a, 2) * Math.pow(d, 2);++ if (discriminant >= 0) {+ const C = Math.cbrt((discriminant + Math.sqrt(discriminant)) / 2);+ const D = Math.cbrt((discriminant - Math.sqrt(discriminant)) / 2);++ const root1 = (-b - C - D) / (3 * a);+ const root2 = (-b + (C + D) / 2) / (3 * a);+ const root3 = (-b + (C + D) / 2) / (3 * a);++ roots.push(root1, root2, root3);+ } else {+ const realPart = -b / (3 * a);++ const root1 =+ 2 * Math.sqrt(-b / (3 * a)) * Math.cos(Math.acos(realPart) / 3);+ const root2 =+ 2 *+ Math.sqrt(-b / (3 * a)) *+ Math.cos((Math.acos(realPart) + 2 * Math.PI) / 3);+ const root3 =+ 2 *+ Math.sqrt(-b / (3 * a)) *+ Math.cos((Math.acos(realPart) + 4 * Math.PI) / 3);++ roots.push(root1, root2, root3);+ }++ return roots;+};++const findClosestParameter = (point: Point, controlPoints: Curve) => {+ // This function finds the parameter t that minimizes the distance between the point+ // and any point on the cubic Bezier curve.++ const [p0, p1, p2, p3] = controlPoints;++ // Use the direct formula to find the parameter t+ const a = p3[0] - 3 * p2[0] + 3 * p1[0] - p0[0];+ const b = 3 * p2[0] - 6 * p1[0] + 3 * p0[0];+ const c = 3 * p1[0] - 3 * p0[0];+ const d = p0[0] - point[0];++ const rootsX = solveCubicEquation(a, b, c, d);++ // Do the same for the y-coordinate+ const e = p3[1] - 3 * p2[1] + 3 * p1[1] - p0[1];+ const f = 3 * p2[1] - 6 * p1[1] + 3 * p0[1];+ const g = 3 * p1[1] - 3 * p0[1];+ const h = p0[1] - point[1];++ const rootsY = solveCubicEquation(e, f, g, h);++ // Select the real root that is between 0 and 1 (inclusive)+ const validRootsX = rootsX.filter((root) => root >= 0 && root <= 1);+ const validRootsY = rootsY.filter((root) => root >= 0 && root <= 1);++ if (validRootsX.length === 0 || validRootsY.length === 0) {+ // No valid roots found, use the midpoint as a fallback+ return 0.5;+ }++ // Choose the parameter t that minimizes the distance+ let minDistance = Infinity;+ let closestT = 0;++ for (const rootX of validRootsX) {+ for (const rootY of validRootsY) {+ const distance = Math.sqrt(+ (rootX - point[0]) ** 2 + (rootY - point[1]) ** 2,+ );+ if (distance < minDistance) {+ minDistance = distance;+ closestT = (rootX + rootY) / 2; // Use the average for a smoother result+ }+ }+ }++ return closestT;+};++export const cubicBezierDistance = (point: Point, controlPoints: Curve) => {+ // Calculate the closest point on the Bezier curve to the given point+ const t = findClosestParameter(point, controlPoints);++ // Calculate the coordinates of the closest point on the curve+ const [closestX, closestY] = cubicBezierPoint(t, controlPoints);++ // Calculate the distance between the given point and the closest point on the curve+ const distance = Math.sqrt(+ (point[0] - closestX) ** 2 + (point[1] - closestY) ** 2,+ );++ return distance;+};++/**+ * polygons+ */++export const polygonRotate = (+ polygon: Polygon,+ angle: number,+ origin: Point,+) => {+ return polygon.map((p) => pointRotate(p, angle, origin));+};++export const polygonBounds = (polygon: Polygon) => {+ let xMin = Infinity;+ let xMax = -Infinity;+ let yMin = Infinity;+ let yMax = -Infinity;++ for (let i = 0, l = polygon.length; i < l; i++) {+ const p = polygon[i];+ const x = p[0];+ const y = p[1];++ if (x != null && isFinite(x) && y != null && isFinite(y)) {+ if (x < xMin) {+ xMin = x;+ }+ if (x > xMax) {+ xMax = x;+ }+ if (y < yMin) {+ yMin = y;+ }+ if (y > yMax) {+ yMax = y;+ }+ }+ }++ return [+ [xMin, yMin],+ [xMax, yMax],+ ] as [Point, Point];+};++export const polygonCentroid = (vertices: Point[]) => {+ let a = 0;+ let x = 0;+ let y = 0;+ const l = vertices.length;++ for (let i = 0; i < l; i++) {+ const s = i === l - 1 ? 0 : i + 1;+ const v0 = vertices[i];+ const v1 = vertices[s];+ const f = v0[0] * v1[1] - v1[0] * v0[1];++ a += f;+ x += (v0[0] + v1[0]) * f;+ y += (v0[1] + v1[1]) * f;+ }++ const d = a * 3;++ return [x / d, y / d] as Point;+};++export const polygonScale = (+ polygon: Polygon,+ scale: number,+ origin?: Point,+) => {+ if (!origin) {+ origin = polygonCentroid(polygon);+ }++ const p: Polygon = [];++ for (let i = 0, l = polygon.length; i < l; i++) {+ const v = polygon[i];+ const d = lineLength([origin, v]);+ const a = lineAngle([origin, v]);++ p[i] = pointTranslate(origin, a, d * scale);+ }++ return p;+};++export const polygonScaleX = (+ polygon: Polygon,+ scale: number,+ origin?: Point,+) => {+ if (!origin) {+ origin = polygonCentroid(polygon);+ }++ const p: Polygon = [];++ for (let i = 0, l = polygon.length; i < l; i++) {+ const v = polygon[i];+ const d = lineLength([origin, v]);+ const a = lineAngle([origin, v]);+ const t = pointTranslate(origin, a, d * scale);++ p[i] = [t[0], v[1]];+ }++ return p;+};++export const polygonScaleY = (+ polygon: Polygon,+ scale: number,+ origin?: Point,+) => {+ if (!origin) {+ origin = polygonCentroid(polygon);+ }++ const p: Polygon = [];++ for (let i = 0, l = polygon.length; i < l; i++) {+ const v = polygon[i];+ const d = lineLength([origin, v]);+ const a = lineAngle([origin, v]);+ const t = pointTranslate(origin, a, d * scale);++ p[i] = [v[0], t[1]];+ }++ return p;+};++export const polygonReflectX = (polygon: Polygon, reflectFactor = 1) => {+ const [[min], [max]] = polygonBounds(polygon);+ const p: Point[] = [];++ for (let i = 0, l = polygon.length; i < l; i++) {+ const [x, y] = polygon[i];+ const r: Point = [min + max - x, y];++ if (reflectFactor === 0) {+ p[i] = [x, y];+ } else if (reflectFactor === 1) {+ p[i] = r;+ } else {+ const t = lineInterpolate([[x, y], r]);+ p[i] = t(Math.max(Math.min(reflectFactor, 1), 0));+ }+ }++ return p;+};++export const polygonReflectY = (polygon: Polygon, reflectFactor = 1) => {+ const [[, min], [, max]] = polygonBounds(polygon);+ const p: Point[] = [];++ for (let i = 0, l = polygon.length; i < l; i++) {+ const [x, y] = polygon[i];+ const r: Point = [x, min + max - y];++ if (reflectFactor === 0) {+ p[i] = [x, y];+ } else if (reflectFactor === 1) {+ p[i] = r;+ } else {+ const t = lineInterpolate([[x, y], r]);+ p[i] = t(Math.max(Math.min(reflectFactor, 1), 0));+ }+ }++ return p;+};++export const polygonTranslate = (+ polygon: Polygon,+ angle: number,+ distance: number,+) => {+ return polygon.map((p) => pointTranslate(p, angle, distance));+};++/**+ * ellipses+ */++export const ellipseAxes = (ellipse: Ellipse) => {+ const widthGreaterThanHeight = ellipse.halfWidth > ellipse.halfHeight;++ const majorAxis = widthGreaterThanHeight+ ? ellipse.halfWidth * 2+ : ellipse.halfHeight * 2;+ const minorAxis = widthGreaterThanHeight+ ? ellipse.halfHeight * 2+ : ellipse.halfWidth * 2;++ return {+ majorAxis,+ minorAxis,+ };+};++export const ellipseFocusToCenter = (ellipse: Ellipse) => {+ const { majorAxis, minorAxis } = ellipseAxes(ellipse);++ return Math.sqrt(majorAxis ** 2 - minorAxis ** 2);+};++export const ellipseExtremes = (ellipse: Ellipse) => {+ const { center, angle } = ellipse;+ const { majorAxis, minorAxis } = ellipseAxes(ellipse);++ const cos = Math.cos(angle);+ const sin = Math.sin(angle);++ const sqSum = majorAxis ** 2 + minorAxis ** 2;+ const sqDiff = (majorAxis ** 2 - minorAxis ** 2) * Math.cos(2 * angle);++ const yMax = Math.sqrt((sqSum - sqDiff) / 2);+ const xAtYMax =+ (yMax * sqSum * sin * cos) /+ (majorAxis ** 2 * sin ** 2 + minorAxis ** 2 * cos ** 2);++ const xMax = Math.sqrt((sqSum + sqDiff) / 2);+ const yAtXMax =+ (xMax * sqSum * sin * cos) /+ (majorAxis ** 2 * cos ** 2 + minorAxis ** 2 * sin ** 2);++ return [+ pointAdd([xAtYMax, yMax], center),+ pointAdd(pointInverse([xAtYMax, yMax]), center),+ pointAdd([xMax, yAtXMax], center),+ pointAdd([xMax, yAtXMax], center),+ ];+};++export const pointRelativeToCenter = (+ point: Point,+ center: Point,+ angle: number,+): Point => {+ const translated = pointAdd(point, pointInverse(center));+ const rotated = pointRotate(translated, -angleToDegrees(angle));++ return rotated;+};++/**+ * relationships+ */++const topPointFirst = (line: Line) => {+ return line[1][1] > line[0][1] ? line : [line[1], line[0]];+};++export const pointLeftofLine = (point: Point, line: Line) => {+ const t = topPointFirst(line);+ return cross(point, t[1], t[0]) < 0;+};++export const pointRightofLine = (point: Point, line: Line) => {+ const t = topPointFirst(line);+ return cross(point, t[1], t[0]) > 0;+};++export const distanceToSegment = (point: Point, line: Line) => {+ const [x, y] = point;+ const [[x1, y1], [x2, y2]] = line;++ const A = x - x1;+ const B = y - y1;+ const C = x2 - x1;+ const D = y2 - y1;++ const dot = A * C + B * D;+ const len_sq = C * C + D * D;+ let param = -1;+ if (len_sq !== 0) {+ param = dot / len_sq;+ }++ let xx;+ let yy;++ if (param < 0) {+ xx = x1;+ yy = y1;+ } else if (param > 1) {+ xx = x2;+ yy = y2;+ } else {+ xx = x1 + param * C;+ yy = y1 + param * D;+ }++ const dx = x - xx;+ const dy = y - yy;+ return Math.sqrt(dx * dx + dy * dy);+};++export const pointOnLine = (+ point: Point,+ line: Line,+ threshold = DEFAULT_THRESHOLD,+) => {+ const distance = distanceToSegment(point, line);++ if (distance === 0) {+ return true;+ }++ return distance < threshold;+};++export const pointOnPolyline = (+ point: Point,+ polyline: Polyline,+ threshold = DEFAULT_THRESHOLD,+) => {+ return polyline.some((line) => pointOnLine(point, line, threshold));+};++export const lineIntersectsLine = (lineA: Line, lineB: Line) => {+ const [[a0x, a0y], [a1x, a1y]] = lineA;+ const [[b0x, b0y], [b1x, b1y]] = lineB;++ // shared points+ if (a0x === b0x && a0y === b0y) {+ return true;+ }+ if (a1x === b1x && a1y === b1y) {+ return true;+ }++ // point on line+ if (pointOnLine(lineA[0], lineB) || pointOnLine(lineA[1], lineB)) {+ return true;+ }+ if (pointOnLine(lineB[0], lineA) || pointOnLine(lineB[1], lineA)) {+ return true;+ }++ const denom = (b1y - b0y) * (a1x - a0x) - (b1x - b0x) * (a1y - a0y);++ if (denom === 0) {+ return false;+ }++ const deltaY = a0y - b0y;+ const deltaX = a0x - b0x;+ const numer0 = (b1x - b0x) * deltaY - (b1y - b0y) * deltaX;+ const numer1 = (a1x - a0x) * deltaY - (a1y - a0y) * deltaX;+ const quotA = numer0 / denom;+ const quotB = numer1 / denom;++ return quotA > 0 && quotA < 1 && quotB > 0 && quotB < 1;+};++export const lineIntersectsPolygon = (line: Line, polygon: Polygon) => {+ let intersects = false;+ const closed = close(polygon);++ for (let i = 0, l = closed.length - 1; i < l; i++) {+ const v0 = closed[i];+ const v1 = closed[i + 1];++ if (+ lineIntersectsLine(line, [v0, v1]) ||+ (pointOnLine(v0, line) && pointOnLine(v1, line))+ ) {+ intersects = true;+ break;+ }+ }++ return intersects;+};++export const pointInBezierEquation = (+ p0: Point,+ p1: Point,+ p2: Point,+ p3: Point,+ [mx, my]: Point,+ lineThreshold: number,+) => {+ // B(t) = p0 * (1-t)^3 + 3p1 * t * (1-t)^2 + 3p2 * t^2 * (1-t) + p3 * t^3+ const equation = (t: number, idx: number) =>+ Math.pow(1 - t, 3) * p3[idx] ++ 3 * t * Math.pow(1 - t, 2) * p2[idx] ++ 3 * Math.pow(t, 2) * (1 - t) * p1[idx] ++ p0[idx] * Math.pow(t, 3);++ const lineSegmentPoints: Point[] = [];+ let t = 0;+ while (t <= 1.0) {+ const tx = equation(t, 0);+ const ty = equation(t, 1);++ const diff = Math.sqrt(Math.pow(tx - mx, 2) + Math.pow(ty - my, 2));++ if (diff < lineThreshold) {+ return true;+ }++ lineSegmentPoints.push([tx, ty]);++ t += 0.1;+ }++ // check the distance from line segments to the given point++ return false;+};++export const cubicBezierEquation = (curve: Curve) => {+ const [p0, p1, p2, p3] = curve;+ // B(t) = p0 * (1-t)^3 + 3p1 * t * (1-t)^2 + 3p2 * t^2 * (1-t) + p3 * t^3+ return (t: number, idx: number) =>+ Math.pow(1 - t, 3) * p3[idx] ++ 3 * t * Math.pow(1 - t, 2) * p2[idx] ++ 3 * Math.pow(t, 2) * (1 - t) * p1[idx] ++ p0[idx] * Math.pow(t, 3);+};++export const polyLineFromCurve = (curve: Curve, segments = 10): Polyline => {+ const equation = cubicBezierEquation(curve);+ let startingPoint = [equation(0, 0), equation(0, 1)] as Point;+ const lineSegments: Polyline = [];+ let t = 0;+ const increment = 1 / segments;++ for (let i = 0; i < segments; i++) {+ t += increment;+ if (t <= 1) {+ const nextPoint: Point = [equation(t, 0), equation(t, 1)];+ lineSegments.push([startingPoint, nextPoint]);+ startingPoint = nextPoint;+ }+ }++ return lineSegments;+};++export const pointOnCurve = (+ point: Point,+ curve: Curve,+ threshold = DEFAULT_THRESHOLD,+) => {+ return pointOnPolyline(point, polyLineFromCurve(curve), threshold);+};++export const pointOnPolycurve = (+ point: Point,+ polycurve: Polycurve,+ threshold = DEFAULT_THRESHOLD,+) => {+ return polycurve.some((curve) => pointOnCurve(point, curve, threshold));+};++export const pointInPolygon = (point: Point, polygon: Polygon) => {+ const x = point[0];+ const y = point[1];+ let inside = false;++ for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {+ const xi = polygon[i][0];+ const yi = polygon[i][1];+ const xj = polygon[j][0];+ const yj = polygon[j][1];++ if (+ ((yi > y && yj <= y) || (yi <= y && yj > y)) &&+ x < ((xj - xi) * (y - yi)) / (yj - yi) + xi+ ) {+ inside = !inside;+ }+ }++ return inside;+};++export const pointOnPolygon = (+ point: Point,+ polygon: Polygon,+ threshold = DEFAULT_THRESHOLD,+) => {+ let on = false;+ const closed = close(polygon);++ for (let i = 0, l = closed.length - 1; i < l; i++) {+ if (pointOnLine(point, [closed[i], closed[i + 1]], threshold)) {+ on = true;+ break;+ }+ }++ return on;+};++export const polygonInPolygon = (polygonA: Polygon, polygonB: Polygon) => {+ let inside = true;+ const closed = close(polygonA);++ for (let i = 0, l = closed.length - 1; i < l; i++) {+ const v0 = closed[i];++ // Points test+ if (!pointInPolygon(v0, polygonB)) {+ inside = false;+ break;+ }++ // Lines test+ if (lineIntersectsPolygon([v0, closed[i + 1]], polygonB)) {+ inside = false;+ break;+ }+ }++ return inside;+};++export const polygonIntersectPolygon = (+ polygonA: Polygon,+ polygonB: Polygon,+) => {+ let intersects = false;+ let onCount = 0;+ const closed = close(polygonA);++ for (let i = 0, l = closed.length - 1; i < l; i++) {+ const v0 = closed[i];+ const v1 = closed[i + 1];++ if (lineIntersectsPolygon([v0, v1], polygonB)) {+ intersects = true;+ break;+ }++ if (pointOnPolygon(v0, polygonB)) {+ ++onCount;+ }++ if (onCount === 2) {+ intersects = true;+ break;+ }+ }++ return intersects;+};++const distanceToEllipse = (point: Point, ellipse: Ellipse) => {+ const { angle, halfWidth, halfHeight, center } = ellipse;+ const a = halfWidth;+ const b = halfHeight;+ const [rotatedPointX, rotatedPointY] = pointRelativeToCenter(+ point,+ center,+ angle,+ );++ const px = Math.abs(rotatedPointX);+ const py = Math.abs(rotatedPointY);++ let tx = 0.707;+ let ty = 0.707;++ for (let i = 0; i < 3; i++) {+ const x = a * tx;+ const y = b * ty;++ const ex = ((a * a - b * b) * tx ** 3) / a;+ const ey = ((b * b - a * a) * ty ** 3) / b;++ const rx = x - ex;+ const ry = y - ey;++ const qx = px - ex;+ const qy = py - ey;++ const r = Math.hypot(ry, rx);+ const q = Math.hypot(qy, qx);++ tx = Math.min(1, Math.max(0, ((qx * r) / q + ex) / a));+ ty = Math.min(1, Math.max(0, ((qy * r) / q + ey) / b));+ const t = Math.hypot(ty, tx);+ tx /= t;+ ty /= t;+ }++ const [minX, minY] = [+ a * tx * Math.sign(rotatedPointX),+ b * ty * Math.sign(rotatedPointY),+ ];++ return distanceToPoint([rotatedPointX, rotatedPointY], [minX, minY]);+};++export const pointOnEllipse = (+ point: Point,+ ellipse: Ellipse,+ threshold = DEFAULT_THRESHOLD,+) => {+ return distanceToEllipse(point, ellipse) <= threshold;+};++export const pointInEllipse = (point: Point, ellipse: Ellipse) => {+ const { center, angle, halfWidth, halfHeight } = ellipse;+ const [rotatedPointX, rotatedPointY] = pointRelativeToCenter(+ point,+ center,+ angle,+ );++ return (+ (rotatedPointX / halfWidth) * (rotatedPointX / halfWidth) ++ (rotatedPointY / halfHeight) * (rotatedPointY / halfHeight) <=+ 1+ );+};diff --git a/packages/utils/geometry/shape.ts b/packages/utils/geometry/shape.tsnew file mode 100644index 0000000000..1fbcd7935c--- /dev/null+++ b/packages/utils/geometry/shape.ts@@ -0,0 +1,278 @@+/**+ * this file defines pure geometric shapes+ *+ * for instance, a cubic bezier curve is specified by its four control points and+ * an ellipse is defined by its center, angle, semi major axis and semi minor axis+ * (but in semi-width and semi-height so it's more relevant to Excalidraw)+ *+ * the idea with pure shapes is so that we can provide collision and other geoemtric methods not depending on+ * the specifics of roughjs or elements in Excalidraw; instead, we can focus on the pure shapes themselves+ *+ * also included in this file are methods for converting an Excalidraw element or a Drawable from roughjs+ * to pure shapes+ */++import {+ ExcalidrawDiamondElement,+ ExcalidrawEllipseElement,+ ExcalidrawEmbeddableElement,+ ExcalidrawFrameLikeElement,+ ExcalidrawFreeDrawElement,+ ExcalidrawIframeElement,+ ExcalidrawImageElement,+ ExcalidrawRectangleElement,+ ExcalidrawSelectionElement,+ ExcalidrawTextElement,+} from "../../excalidraw/element/types";+import { angleToDegrees, close, pointAdd, pointRotate } from "./geometry";+import { pointsOnBezierCurves } from "points-on-curve";+import type { Drawable, Op } from "roughjs/bin/core";++// a point is specified by its coordinate (x, y)+export type Point = [number, number];+export type Vector = Point;++// a line (segment) is defined by two endpoints+export type Line = [Point, Point];++// a polyline (made up term here) is a line consisting of other line segments+// this corresponds to a straight line element in the editor but it could also+// be used to model other elements+export type Polyline = Line[];++// cubic bezier curve with four control points+export type Curve = [Point, Point, Point, Point];++// a polycurve is a curve consisting of ther curves, this corresponds to a complex+// curve on the canvas+export type Polycurve = Curve[];++// a polygon is a closed shape by connecting the given points+// rectangles and diamonds are modelled by polygons+export type Polygon = Point[];++// an ellipse is specified by its center, angle, and its major and minor axes+// but for the sake of simplicity, we've used halfWidth and halfHeight instead+// in replace of semi major and semi minor axes+export type Ellipse = {+ center: Point;+ angle: number;+ halfWidth: number;+ halfHeight: number;+};++export type GeometricShape =+ | {+ type: "line";+ data: Line;+ }+ | {+ type: "polygon";+ data: Polygon;+ }+ | {+ type: "curve";+ data: Curve;+ }+ | {+ type: "ellipse";+ data: Ellipse;+ }+ | {+ type: "polyline";+ data: Polyline;+ }+ | {+ type: "polycurve";+ data: Polycurve;+ };++type RectangularElement =+ | ExcalidrawRectangleElement+ | ExcalidrawDiamondElement+ | ExcalidrawFrameLikeElement+ | ExcalidrawEmbeddableElement+ | ExcalidrawImageElement+ | ExcalidrawIframeElement+ | ExcalidrawTextElement+ | ExcalidrawSelectionElement;++// polygon+export const getPolygonShape = (+ element: RectangularElement,+): GeometricShape => {+ const { angle, width, height, x, y } = element;+ const angleInDegrees = angleToDegrees(angle);+ const cx = x + width / 2;+ const cy = y + height / 2;++ const center: Point = [cx, cy];++ let data: Polygon = [];++ if (element.type === "diamond") {+ data = [+ pointRotate([cx, y], angleInDegrees, center),+ pointRotate([x + width, cy], angleInDegrees, center),+ pointRotate([cx, y + height], angleInDegrees, center),+ pointRotate([x, cy], angleInDegrees, center),+ ] as Polygon;+ } else {+ data = [+ pointRotate([x, y], angleInDegrees, center),+ pointRotate([x + width, y], angleInDegrees, center),+ pointRotate([x + width, y + height], angleInDegrees, center),+ pointRotate([x, y + height], angleInDegrees, center),+ ] as Polygon;+ }++ return {+ type: "polygon",+ data,+ };+};++// ellipse+export const getEllipseShape = (+ element: ExcalidrawEllipseElement,+): GeometricShape => {+ const { width, height, angle, x, y } = element;++ return {+ type: "ellipse",+ data: {+ center: [x + width / 2, y + height / 2],+ angle,+ halfWidth: width / 2,+ halfHeight: height / 2,+ },+ };+};++export const getCurvePathOps = (shape: Drawable): Op[] => {+ for (const set of shape.sets) {+ if (set.type === "path") {+ return set.ops;+ }+ }+ return shape.sets[0].ops;+};++// linear+export const getCurveShape = (+ roughShape: Drawable,+ startingPoint: Point = [0, 0],+ angleInRadian: number,+ center: Point,+): GeometricShape => {+ const transform = (p: Point) =>+ pointRotate(+ [p[0] + startingPoint[0], p[1] + startingPoint[1]],+ angleToDegrees(angleInRadian),+ center,+ );++ const ops = getCurvePathOps(roughShape);+ const polycurve: Polycurve = [];+ let p0: Point = [0, 0];++ for (const op of ops) {+ if (op.op === "move") {+ p0 = transform(op.data as Point);+ }+ if (op.op === "bcurveTo") {+ const p1: Point = transform([op.data[0], op.data[1]]);+ const p2: Point = transform([op.data[2], op.data[3]]);+ const p3: Point = transform([op.data[4], op.data[5]]);+ polycurve.push([p0, p1, p2, p3]);+ p0 = p3;+ }+ }++ return {+ type: "polycurve",+ data: polycurve,+ };+};++const polylineFromPoints = (points: Point[]) => {+ let previousPoint = points[0];+ const polyline: Polyline = [];++ for (let i = 1; i < points.length; i++) {+ const nextPoint = points[i];+ polyline.push([previousPoint, nextPoint]);+ previousPoint = nextPoint;+ }++ return polyline;+};++export const getFreedrawShape = (+ element: ExcalidrawFreeDrawElement,+ center: Point,+ isClosed: boolean = false,+): GeometricShape => {+ const angle = angleToDegrees(element.angle);+ const transform = (p: Point) =>+ pointRotate(pointAdd(p, [element.x, element.y] as Point), angle, center);++ const polyline = polylineFromPoints(+ element.points.map((p) => transform(p as Point)),+ );++ return isClosed+ ? {+ type: "polygon",+ data: close(polyline.flat()) as Polygon,+ }+ : {+ type: "polyline",+ data: polyline,+ };+};++export const getClosedCurveShape = (+ roughShape: Drawable,+ startingPoint: Point = [0, 0],+ angleInRadian: number,+ center: Point,+): GeometricShape => {+ const ops = getCurvePathOps(roughShape);+ const transform = (p: Point) =>+ pointRotate(+ [p[0] + startingPoint[0], p[1] + startingPoint[1]],+ angleToDegrees(angleInRadian),+ center,+ );++ const points: Point[] = [];+ let odd = false;+ for (const operation of ops) {+ if (operation.op === "move") {+ odd = !odd;+ if (odd) {+ points.push([operation.data[0], operation.data[1]]);+ }+ } else if (operation.op === "bcurveTo") {+ if (odd) {+ points.push([operation.data[0], operation.data[1]]);+ points.push([operation.data[2], operation.data[3]]);+ points.push([operation.data[4], operation.data[5]]);+ }+ } else if (operation.op === "lineTo") {+ if (odd) {+ points.push([operation.data[0], operation.data[1]]);+ }+ }+ }++ const polygonPoints = pointsOnBezierCurves(points, 10, 5).map((p) =>+ transform(p),+ );++ return {+ type: "polygon",+ data: polygonPoints,+ };+};