jellies-draw 0.1.11 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jellies-draw",
-  "version": "0.1.11",
+  "version": "0.2.1",
   "description": "A drawer for jellies",
   "private": false,
   "main": "./src/index.js",

package/src/components/functions/canvas.js

@@ -35,8 +35,14 @@ export default {
     Histories.record();
     this.stage.on('pointerdown', this.pointerDownHandler);
     this.stage.on('pointermove', this.pointerMoveHandler);
-    this.stage.on('pointerup', this.pointerUpHandler);
+    this.stage.on('pointerup', this.handleCanvasPointerUp);
     this.stage.on('click tap', this.clickHandler);
+    this.stage.on('pointerdown', () => {
+      if (Properties.isUsingDrawingTool) {
+        window.addEventListener('pointerup', this.handleGlobalPointerUp, { once: true });
+      }
+    });
+    this.stage.on('mousemove', this._handleMouseMove.bind(this));
   },
   generateEventHandlers() {
     this.resizeHandler = this._handleResize.bind(this);
@@ -44,7 +50,17 @@ export default {
     this.keyupHandler = this._handleKeyup.bind(this);
     this.pointerDownHandler = this.handlePointerDown.bind(this);
     this.pointerMoveHandler = this.handlePointerMove.bind(this);
-    this.pointerUpHandler = this.handlePointerUp.bind(this);
+    this.handleCanvasPointerUp = (event) => {
+      if (event.target.getStage()) {
+        this.handlePointerUp(event);
+      }
+    };
+    this.handleGlobalPointerUp = (event) => {
+      const container = this.stage.container();
+      if (!container.contains(event.target)) {
+        this.handlePointerUp(event);
+      }
+    };
     this.clickHandler = this.handleClick.bind(this);
   },
   clear() {
@@ -54,7 +70,7 @@ export default {
   destroy() {
     this.stage.off('pointerdown', this.pointerDownHandler);
     this.stage.off('pointermove', this.pointerMoveHandler);
-    this.stage.off('pointerup', this.pointerUpHandler);
+    this.stage.off('pointerup', this.handleCanvasPointerUp);
     this.stage.off('click tap', this.clickHandler);
     document.removeEventListener('keydown', this.keydownHandler);
     document.removeEventListener('keyup', this.keyupHandler);
@@ -178,5 +194,43 @@ export default {
       return;
     }
     Transformer.selectNode(targetNode, metaPressed);
+  },
+  _handleMouseMove(e) {
+    if (Properties.isUsingDrawingTool || Properties.isUsingText) {
+      return;
+    }
+
+    const target = e.target;
+    
+    // Reset cursor to default when over stage
+    if (target === this.stage) {
+      this.stage.container().style.cursor = 'default';
+      return;
+    }
+
+    // Handle cursor for nodes
+    if (target.hasName('node')) {
+      if (this._shouldShowMoveCursor(target)) {
+        this.stage.container().style.cursor = 'move';
+      } else {
+        this.stage.container().style.cursor = 'default';
+      }
+    }
+  },
+  _shouldShowMoveCursor(node) {
+    // Always show move cursor for non-shape nodes
+    if (!['Rect', 'Circle', 'Ellipse'].includes(node.className)) {
+      return true;
+    }
+
+    // Show move cursor for filled shapes
+    if (node.attrs.fill && node.attrs.fill !== 'transparent') {
+      return true;
+    }
+
+    // For unfilled shapes, only show move cursor near border
+    const mousePos = this.stage.getPointerPosition();
+    return Transformer._isNearBorder(node, mousePos);
   }
 }
+

package/src/components/functions/tools/eraser.js

@@ -1,51 +1,278 @@
 import Konva from 'konva'
 import Properties from '../properties'
 import Canvas from '../canvas'
+
 export default {
-  temporalCurveTrajectory: null,
   temporalShape: null,
   startX: 0,
   startY: 0,
+  lastX: 0,
+  lastY: 0,
+  erasedNodes: new Set(),
+
   show({ offsetX, offsetY }) {
-    Canvas.isDrawing = true;
+    Canvas.isDrawing = true
     this.startX = offsetX
     this.startY = offsetY
-    this.temporalCurveTrajectory = null
-    const strokeWidth = Properties.strokeWidth
-    const newCurve = new Konva.Line({
-      points: [offsetX, offsetY, offsetX, offsetY],
-      stroke: 'transparent',
-      strokeWidth,
-      name: 'node',
-      bezier: true,
-      lineCap: 'round',
-      strokeScaleEnabled: false
-    });
+    this.lastX = offsetX
+    this.lastY = offsetY
+    this.erasedNodes.clear()
+    
+    const newCurve = this._generateEraserLine(offsetX, offsetY)
     this.temporalShape = newCurve
-    Canvas.layer.add(this.temporalShape);
+    Canvas.layer.add(this.temporalShape)
   },
+
   change({ offsetX, offsetY }) {
-    if (Canvas.isDrawing) {
-      if (!this.temporalCurveTrajectory) {
-        this.temporalCurveTrajectory = [this.startX, this.startY]
+    if (!Canvas.isDrawing) return
+
+    this._interpolateAndCheck(this.lastX, this.lastY, offsetX, offsetY)
+    this._updateEraserPath(offsetX, offsetY)
+    
+    this.lastX = offsetX
+    this.lastY = offsetY
+    Canvas.layer.batchDraw()
+  },
+
+  finish() {
+    this._destroyErasedNodes()
+    this._cleanupTemporalShape()
+    Canvas.layer.batchDraw()
+  },
+
+  _generateEraserLine(x, y) {
+    return new Konva.Line({
+      points: [x, y],
+      stroke: '#000000',
+      strokeWidth: Properties.strokeWidth * 2,
+      opacity: 0,
+      lineCap: 'round',
+      lineJoin: 'round',
+      tension: 0.5,
+      strokeScaleEnabled: false
+    })
+  },
+
+  _updateEraserPath(x, y) {
+    const points = this.temporalShape.points()
+    points.push(x, y)
+    this.temporalShape.points(points)
+  },
+
+  _checkAndMarkIntersections(x, y) {
+    const eraserRadius = Properties.strokeWidth
+
+    Canvas.stage.find('.node').forEach(node => {
+      if (node === this.temporalShape) return
+      
+      const nodeRect = node.getClientRect()
+      const eraserRect = {
+        x: x - eraserRadius,
+        y: y - eraserRadius,
+        width: eraserRadius * 2,
+        height: eraserRadius * 2
+      }
+
+      if (this._checkRectOverlap(nodeRect, eraserRect)) {
+        if (this._checkIntersection(node, { x, y }) && !this.erasedNodes.has(node)) {
+          this._markNodeForErasure(node)
+        }
       }
-      this.temporalCurveTrajectory.push(offsetX, offsetY)
-      this.temporalShape.points(this.temporalCurveTrajectory);
-      Canvas.stage.find('.node')
-        .filter(node => this._hasIntersectionOnEraserCurve(node))
-        .forEach(node => node.opacity(0.1));
+    })
+  },
+
+  _markNodeForErasure(node) {
+    node.opacity(0.2)
+    this.erasedNodes.add(node)
+  },
+
+  _destroyErasedNodes() {
+    this.erasedNodes.forEach(node => node.destroy())
+    this.erasedNodes.clear()
+  },
+
+  _cleanupTemporalShape() {
+    if (this.temporalShape) {
+      this.temporalShape.destroy()
+      this.temporalShape = null
     }
   },
-  finish() {
-    Canvas.stage.find('.node')
-      .filter(node => this._hasIntersectionOnEraserCurve(node))
-      .forEach(node => node.remove())
-    this.temporalShape = null
+
+  _checkIntersection(node, point) {
+    if (node.attrs.nodeType === 'pen') {
+      return this._checkPenIntersection(node, point)
+    }
+    
+    switch (node.className) {
+      case 'Line':
+      case 'Arrow':
+        return this._checkLineIntersection(node, point)
+      case 'Circle':
+      case 'Ellipse':
+        return this._checkEllipseIntersection(node, point)
+      case 'Rect':
+        return this._checkRectIntersection(node, point)
+      default:
+        return this._checkDefaultIntersection(node)
+    }
   },
-  _hasIntersectionOnEraserCurve(node) {
+
+  _checkPenIntersection(node, point) {
+    const localPoint = this._transformPointToLocal(node, point)
+    const { points, widths } = node.attrs
+    const eraserRadius = Properties.strokeWidth
+
+    for (let i = 0; i < points.length - 1; i++) {
+      const distance = this._getDistanceToLineSegment(
+        localPoint.x,
+        localPoint.y,
+        points[i][0],
+        points[i][1],
+        points[i + 1][0],
+        points[i + 1][1]
+      )
+
+      const combinedWidth = (widths[i] + eraserRadius) / 2
+      if (distance < combinedWidth) {
+        return true
+      }
+    }
+    return false
+  },
+
+  _checkDefaultIntersection(node) {
     return Konva.Util.haveIntersection(
       this.temporalShape.getClientRect(),
       node.getClientRect()
-    );
+    )
+  },
+
+  _transformPointToLocal(node, point) {
+    const transform = node.getTransform()
+    return transform.copy().invert().point(point)
+  },
+
+  _getDistanceToLineSegment(px, py, x1, y1, x2, y2) {
+    const A = px - x1
+    const B = py - y1
+    const C = x2 - x1
+    const D = y2 - y1
+
+    const dot = A * C + B * D
+    const lenSq = C * C + D * D
+    const param = lenSq !== 0 ? dot / lenSq : -1
+
+    if (param < 0) return this._getDistance(px, py, x1, y1)
+    if (param > 1) return this._getDistance(px, py, x2, y2)
+
+    return this._getDistance(
+      px,
+      py,
+      x1 + param * C,
+      y1 + param * D
+    )
+  },
+
+  _getDistance(x1, y1, x2, y2) {
+    const dx = x1 - x2
+    const dy = y1 - y2
+    return Math.sqrt(dx * dx + dy * dy)
+  },
+
+  _checkLineIntersection(node, point) {
+    const points = node.points()
+    const transform = node.getTransform()
+    const localPoint = transform.copy().invert().point(point)
+    const eraserRadius = Properties.strokeWidth
+    
+    for (let i = 0; i < points.length - 2; i += 2) {
+      const distance = this._getDistanceToLineSegment(
+        localPoint.x,
+        localPoint.y,
+        points[i],
+        points[i + 1],
+        points[i + 2],
+        points[i + 3]
+      )
+      
+      const combinedWidth = (node.strokeWidth() + eraserRadius) / 2
+      if (distance < combinedWidth) {
+        return true
+      }
+    }
+    return false
+  },
+
+  _checkEllipseIntersection(node, point) {
+    const transform = node.getTransform()
+    const localPoint = transform.copy().invert().point(point)
+    
+    const radiusX = node.radiusX()
+    const radiusY = node.radiusY()
+    
+    // Normalize point to unit circle
+    const normalizedX = localPoint.x / radiusX
+    const normalizedY = localPoint.y / radiusY
+    
+    // Check if point is within ellipse border
+    const distanceFromCenter = Math.sqrt(
+      normalizedX * normalizedX + normalizedY * normalizedY
+    )
+    
+    if (node.attrs.fill && node.attrs.fill !== 'transparent') {
+      // For filled ellipses, allow erasing anywhere inside
+      return distanceFromCenter <= 1
+    } 
+    // For unfilled ellipses, only erase near the border
+    return Math.abs(distanceFromCenter - 1) < Properties.strokeWidth / Math.min(radiusX, radiusY)
+  },
+
+  _checkRectIntersection(node, point) {
+    const transform = node.getTransform()
+    const localPoint = transform.copy().invert().point(point)
+    
+    const width = node.width()
+    const height = node.height()
+    const strokeWidth = Properties.strokeWidth
+
+    if (node.attrs.fill && node.attrs.fill !== 'transparent') {
+      // For filled rectangles, allow erasing anywhere inside
+      return localPoint.x >= -strokeWidth &&
+             localPoint.x <= width + strokeWidth &&
+             localPoint.y >= -strokeWidth &&
+             localPoint.y <= height + strokeWidth
+    }
+    // For unfilled rectangles, only erase near the border
+    return (Math.abs(localPoint.x) < strokeWidth || 
+            Math.abs(localPoint.x - width) < strokeWidth ||
+            Math.abs(localPoint.y) < strokeWidth ||
+            Math.abs(localPoint.y - height) < strokeWidth) &&
+            localPoint.x >= -strokeWidth &&
+            localPoint.x <= width + strokeWidth &&
+            localPoint.y >= -strokeWidth &&
+            localPoint.y <= height + strokeWidth
+  },
+
+  _interpolateAndCheck(x1, y1, x2, y2) {
+    const distance = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2))
+    const steps = Math.ceil(distance / (Properties.strokeWidth / 2))
+    
+    if (steps > 1) {
+      for (let i = 1; i < steps; i++) {
+        const ratio = i / steps
+        const x = x1 + (x2 - x1) * ratio
+        const y = y1 + (y2 - y1) * ratio
+        this._checkAndMarkIntersections(x, y)
+      }
+    } else {
+      this._checkAndMarkIntersections(x2, y2)
+    }
+  },
+
+  _checkRectOverlap(rect1, rect2) {
+    return !(rect1.x > rect2.x + rect2.width ||
+             rect1.x + rect1.width < rect2.x ||
+             rect1.y > rect2.y + rect2.height ||
+             rect1.y + rect1.height < rect2.y)
   }
 }

package/src/components/functions/tools/pen.js

@@ -2,62 +2,373 @@ import Konva from 'konva'
 import Properties from '../properties'
 import Canvas from '../canvas'
 import Histories from '../histories'
+
 export default {
-  temporalCurveTrajectory: null,
   temporalShape: null,
   startX: 0,
   startY: 0,
+  lastX: 0,
+  lastY: 0,
+  lastTime: 0,
+  points: [],
+  widths: [],
+  boundMinX: 0,
+  boundMinY: 0,
+  boundMaxX: 0,
+  boundMaxY: 0,
+
   show({ offsetX, offsetY }) {
-    Canvas.isDrawing = true;
+    Canvas.isDrawing = true
     this.startX = offsetX
     this.startY = offsetY
-    this.temporalCurveTrajectory = null
-    const stroke = Properties.strokeColor
-    const strokeWidth = Properties.strokeWidth
+    this.lastX = offsetX
+    this.lastY = offsetY
+    this.lastTime = Date.now()
+    
+    this.boundMinX = offsetX
+    this.boundMinY = offsetY
+    this.boundMaxX = offsetX
+    this.boundMaxY = offsetY
+    
+    this.points = [[0, 0]]
+    this.widths = [Properties.strokeWidth]
+    
     const newCurve = this.generate({ 
-      points: [offsetX, offsetY, offsetX, offsetY],
-      stroke,
-      strokeWidth
+      x: offsetX,
+      y: offsetY,
+      points: this.points,
+      widths: this.widths,
+      stroke: Properties.strokeColor
     })
+    
     this.temporalShape = newCurve
     Canvas.layer.add(this.temporalShape)
   },
+
   change({ offsetX, offsetY }) {
-    if (Canvas.isDrawing) {
-      if (!this.temporalCurveTrajectory) {
-        this.temporalCurveTrajectory = [this.startX, this.startY]
-      }
-      this.temporalCurveTrajectory.push(offsetX, offsetY)
-      this.temporalShape.points(this.temporalCurveTrajectory);
-    }
+    if (!Canvas.isDrawing) return
+
+    const currentTime = Date.now()
+    const strokeWidth = this._calculateStrokeWidth(offsetX, offsetY, currentTime)
+
+    this._updateBoundaries(offsetX, offsetY)
+    
+    const relativeX = offsetX - this.startX
+    const relativeY = offsetY - this.startY
+    
+    this.points.push([relativeX, relativeY])
+    this.widths.push(strokeWidth)
+    
+    Canvas.layer.batchDraw()
+    
+    this.lastX = offsetX
+    this.lastY = offsetY
+    this.lastTime = currentTime
   },
+
   finish() {
+    if (!this.temporalShape) return
+
+    const maxStrokeWidth = Math.max(...this.widths)
+    const padding = maxStrokeWidth
+
+    this._adjustShapeBoundaries(padding)
+    Canvas.layer.batchDraw()
     this.temporalShape = null
   },
-  generate({ x, y, scaleX, scaleY, skewX, rotation, points, stroke, strokeWidth }) {
-    const newLine = new Konva.Line({
-      x,
-      y,
-      scaleX,
-      scaleY,
-      skewX,
-      rotation,
-      points,
+
+  generate({ points, widths, stroke, x, y, width, height }) {
+    const tool = this
+
+    const shape = new Konva.Shape({
+      x: x || 0,
+      y: y || 0,
+      width: width || 0,
+      height: height || 0,
       stroke,
-      strokeWidth,
+      points,
+      widths,
       name: 'node',
       nodeType: 'pen',
-      lineCap: 'round',
-      bezier: false,
-      strokeScaleEnabled: false
+      strokeScaleEnabled: false,
+
+      sceneFunc: (context, shape) => {
+        const smoothPoints = tool._calculateSmoothPoints(shape.attrs.points)
+        tool._drawSmoothLine(context, smoothPoints, shape.attrs.widths, shape.attrs.stroke)
+      },
+
+      hitFunc: (context, shape) => {
+        const smoothPoints = tool._calculateSmoothPoints(shape.attrs.points)
+        tool._drawHitPath(context, smoothPoints, shape.attrs.widths)
+        context.fillStrokeShape(shape)
+      }
     })
-    this.bindEvents(newLine)
-    return newLine
-  },
-  bindEvents(newLine) {
-    newLine.off('transformend')
-    newLine.off('dragend')
-    newLine.on('transformend', Histories.record)
-    newLine.on('dragend', Histories.record)
+
+    this.bindEvents(shape)
+    return shape
+  },
+
+  bindEvents(shape) {
+    shape.off('transformend')
+    shape.off('dragend')
+    shape.on('transformend', Histories.record)
+    shape.on('dragend', Histories.record)
+  },
+
+  _calculateStrokeWidth(offsetX, offsetY, currentTime) {
+    const timeDiff = currentTime - this.lastTime
+    const distance = Math.sqrt(
+      Math.pow(offsetX - this.lastX, 2) + 
+      Math.pow(offsetY - this.lastY, 2)
+    )
+    const velocity = distance / (timeDiff + 1)
+
+    const baseWidth = Properties.strokeWidth
+    const minWidth = baseWidth * 0.7
+    const maxWidth = baseWidth * 1.2
+    
+    if (velocity > 0.7) return minWidth
+    if (velocity < 0.2) return maxWidth
+    return maxWidth - (velocity - 0.2) * (maxWidth - minWidth) / 0.5
+  },
+
+  _updateBoundaries(x, y) {
+    this.boundMinX = Math.min(this.boundMinX, x)
+    this.boundMinY = Math.min(this.boundMinY, y)
+    this.boundMaxX = Math.max(this.boundMaxX, x)
+    this.boundMaxY = Math.max(this.boundMaxY, y)
+  },
+
+  _adjustShapeBoundaries(padding) {
+    this.temporalShape.x(this.boundMinX - padding)
+    this.temporalShape.y(this.boundMinY - padding)
+    this.temporalShape.width(this.boundMaxX - this.boundMinX + padding * 2)
+    this.temporalShape.height(this.boundMaxY - this.boundMinY + padding * 2)
+
+    const adjustedPoints = this.points.map(point => [
+      point[0] - (this.boundMinX - this.startX - padding),
+      point[1] - (this.boundMinY - this.startY - padding)
+    ])
+    this.temporalShape.attrs.points = adjustedPoints
+  },
+
+  _drawSmoothLine(context, points, widths, stroke) {
+    context.beginPath()
+    context.strokeStyle = stroke
+    context.lineCap = 'round'
+    context.lineJoin = 'round'
+    context.moveTo(points[0][0], points[0][1])
+
+    for (let i = 1; i < points.length; i++) {
+      const width = this._interpolateWidth(i, points.length, widths)
+      context.lineWidth = width
+      context.lineTo(points[i][0], points[i][1])
+      context.stroke()
+      context.beginPath()
+      context.moveTo(points[i][0], points[i][1])
+    }
+  },
+
+  _drawHitPath(context, points, widths) {
+    context.beginPath()
+    context.lineCap = 'round'
+    context.lineJoin = 'round'
+    context.moveTo(points[0][0], points[0][1])
+
+    this._drawForwardPath(context, points, widths)
+    this._drawReversePath(context, points, widths)
+  },
+
+  _drawForwardPath(context, points, widths) {
+    for (let i = 1; i < points.length; i++) {
+      const width = this._interpolateWidth(i, points.length, widths) + 10
+      context.lineWidth = width
+      context.lineTo(points[i][0], points[i][1])
+    }
+  },
+
+  _drawReversePath(context, points, widths) {
+    for (let i = points.length - 1; i >= 0; i--) {
+      const width = this._interpolateWidth(i, points.length, widths) + 10
+      context.lineWidth = width
+      context.lineTo(points[i][0], points[i][1])
+    }
+  },
+
+  _interpolateWidth(index, total, widths) {
+    const progress = index / total
+    const widthIndex = Math.floor(progress * (widths.length - 1))
+    const nextWidthIndex = Math.min(widthIndex + 1, widths.length - 1)
+    const widthProgress = progress * (widths.length - 1) - widthIndex
+    return widths[widthIndex] * (1 - widthProgress) + 
+           widths[nextWidthIndex] * widthProgress
+  },
+
+  _calculateSmoothPoints(points) {
+    // 首先检查是否是近似直线
+    const isNearlyLine = this._checkIfNearlyLine(points)
+    
+    // 如果是近似直线，使用 Douglas-Peucker 算法简化
+    if (isNearlyLine) {
+      return this._simplifyDouglasPeucker(points, 2)
+    }
+
+    const smoothPoints = []
+    for (let i = 0; i < points.length - 1; i++) {
+      const p0 = i > 0 ? points[i - 1] : points[i]
+      const p1 = points[i]
+      const p2 = points[i + 1]
+      const p3 = i < points.length - 2 ? points[i + 2] : p2
+
+      // 检查是否是锐角
+      if (i > 0 && i < points.length - 2) {
+        const angle = this._getAngle(p1, p2, p0)
+        
+        if (angle < Math.PI * 0.6 && this._getSegmentLength(p1, p2) > 20) {
+          smoothPoints.push(p1)
+          smoothPoints.push(p2)
+          continue
+        }
+      }
+
+      this._addCatmullRomPoints(smoothPoints, p0, p1, p2, p3)
+    }
+    smoothPoints.push(points[points.length - 1])
+    return smoothPoints
+  },
+
+  _checkIfNearlyLine(points) {
+    if (points.length < 3) return true
+
+    // 计算所有点到起点和终点连线的最大偏差
+    const start = points[0]
+    const end = points[points.length - 1]
+    let maxDeviation = 0
+
+    for (let i = 1; i < points.length - 1; i++) {
+      const deviation = this._getPointToLineDistance(
+        points[i],
+        start,
+        end
+      )
+      maxDeviation = Math.max(maxDeviation, deviation)
+    }
+
+    // 检查所有相邻点之间的角度
+    for (let i = 1; i < points.length - 1; i++) {
+      const angle = this._getAngle(points[i-1], points[i], points[i+1])
+      // 176度 ≈ 3.07 弧度
+      if (angle < 3.07) {
+        return false
+      }
+    }
+
+    // 如果最大偏差小于阈值且所有角度都接近180度，认为是近似直线
+    return maxDeviation < 5
+  },
+
+  _getPointToLineDistance(point, lineStart, lineEnd) {
+    const dx = lineEnd[0] - lineStart[0]
+    const dy = lineEnd[1] - lineStart[1]
+    const lineLengthSq = dx * dx + dy * dy
+    
+    if (lineLengthSq === 0) return 0
+    
+    const t = ((point[0] - lineStart[0]) * dx + 
+               (point[1] - lineStart[1]) * dy) / lineLengthSq
+    
+    if (t < 0) return this._getSegmentLength(point, lineStart)
+    if (t > 1) return this._getSegmentLength(point, lineEnd)
+    
+    const projX = lineStart[0] + t * dx
+    const projY = lineStart[1] + t * dy
+    
+    return Math.sqrt(
+      Math.pow(point[0] - projX, 2) + 
+      Math.pow(point[1] - projY, 2)
+    )
+  },
+
+  _getAngle(p1, p2, p0) {
+    const v1 = [p1[0] - p0[0], p1[1] - p0[1]]
+    const v2 = [p2[0] - p1[0], p2[1] - p1[1]]
+    
+    // 计算向量夹角
+    const dot = v1[0] * v2[0] + v1[1] * v2[1]
+    const len1 = Math.sqrt(v1[0] * v1[0] + v1[1] * v1[1])
+    const len2 = Math.sqrt(v2[0] * v2[0] + v2[1] * v2[1])
+    
+    return Math.acos(dot / (len1 * len2))
+  },
+
+  _getSegmentLength(p1, p2) {
+    const dx = p2[0] - p1[0]
+    const dy = p2[1] - p1[1]
+    return Math.sqrt(dx * dx + dy * dy)
+  },
+
+  _addCatmullRomPoints(smoothPoints, p0, p1, p2, p3) {
+    for (let t = 0; t < 1; t += 0.1) {
+      const t2 = t * t
+      const t3 = t2 * t
+      
+      const x = 0.5 * (
+        (2 * p1[0]) +
+        (-p0[0] + p2[0]) * t +
+        (2 * p0[0] - 5 * p1[0] + 4 * p2[0] - p3[0]) * t2 +
+        (-p0[0] + 3 * p1[0] - 3 * p2[0] + p3[0]) * t3
+      )
+      const y = 0.5 * (
+        (2 * p1[1]) +
+        (-p0[1] + p2[1]) * t +
+        (2 * p0[1] - 5 * p1[1] + 4 * p2[1] - p3[1]) * t2 +
+        (-p0[1] + 3 * p1[1] - 3 * p2[1] + p3[1]) * t3
+      )
+      
+      smoothPoints.push([x, y])
+    }
+  },
+
+  _simplifyDouglasPeucker(points, epsilon) {
+    if (points.length <= 2) return points
+
+    // 找到最远点
+    let maxDistance = 0
+    let maxIndex = 0
+
+    const firstPoint = points[0]
+    const lastPoint = points[points.length - 1]
+
+    // 找到距离首尾连线最远的点
+    for (let i = 1; i < points.length - 1; i++) {
+      const distance = this._getPointToLineDistance(
+        points[i],
+        firstPoint,
+        lastPoint
+      )
+
+      if (distance > maxDistance) {
+        maxDistance = distance
+        maxIndex = i
+      }
+    }
+
+    // 如果最大距离大于阈值，递归处理两个子段
+    if (maxDistance > epsilon) {
+      const firstHalf = this._simplifyDouglasPeucker(
+        points.slice(0, maxIndex + 1),
+        epsilon
+      )
+      const secondHalf = this._simplifyDouglasPeucker(
+        points.slice(maxIndex),
+        epsilon
+      )
+
+      // 合并两个子段，去掉重复的中间点
+      return firstHalf.slice(0, -1).concat(secondHalf)
+    }
+
+    // 如果最大距离小于阈值，只保留首尾两点
+    return [firstPoint, lastPoint]
   }
 }

package/src/components/functions/tools/selector.js

@@ -39,9 +39,43 @@ export default {
     return this.selector !== null
   },
   _isInSelector(node) {
-    return Konva.Util.haveIntersection(
-      this.selector.getClientRect(),
-      node.getClientRect()
-    );
+    const selectorRect = this.selector.getClientRect()
+    
+    if (node.className === 'Line' || node.className === 'Arrow') {
+      return this._isLineFullyContained(node, selectorRect)
+    }
+    
+    return this._isShapeFullyContained(node, selectorRect)
+  },
+  _isLineFullyContained(node, selectorRect) {
+    const points = node.points()
+    for (let i = 0; i < points.length; i += 2) {
+      const point = node.getAbsoluteTransform().point({ 
+        x: points[i], 
+        y: points[i + 1] 
+      })
+      
+      if (!this._isPointInRect(point, selectorRect)) {
+        return false
+      }
+    }
+    return true
+  },
+  _isShapeFullyContained(node, selectorRect) {
+    const nodeRect = node.getClientRect()
+    const corners = [
+      { x: nodeRect.x, y: nodeRect.y }, // top-left
+      { x: nodeRect.x + nodeRect.width, y: nodeRect.y }, // top-right
+      { x: nodeRect.x, y: nodeRect.y + nodeRect.height }, // bottom-left
+      { x: nodeRect.x + nodeRect.width, y: nodeRect.y + nodeRect.height } // bottom-right
+    ]
+    
+    return corners.every(point => this._isPointInRect(point, selectorRect))
+  },
+  _isPointInRect(point, rect) {
+    return point.x >= rect.x && 
+           point.x <= rect.x + rect.width &&
+           point.y >= rect.y && 
+           point.y <= rect.y + rect.height
   }
 }

package/src/components/functions/transformer.js

@@ -39,6 +39,10 @@ export default {
     });
   },
   selectNode(targetNode, isAppending = false) {
+    if (!this._shouldSelectNode(targetNode)) {
+      return;
+    }
+
     const isSelected = this._nodes().indexOf(targetNode) >= 0 || this.linearTransformer.node === targetNode;
     if (!isAppending && !isSelected) {
       this.selectNodes([targetNode]);
@@ -211,5 +215,44 @@ export default {
       return hasOnlyTextNodes;
     }
     return false;
+  },
+  _shouldSelectNode(node) {
+    if ((node.className === 'Rect' || node.className === 'Circle' || node.className === 'Ellipse') &&
+        (!node.attrs.fill || node.attrs.fill === 'transparent')) {
+      const stage = Canvas.stage;
+      const mousePos = stage.getPointerPosition();
+      return this._isNearBorder(node, mousePos);
+    }
+    return true;
+  },
+  _isNearBorder(node, point) {
+    const localPoint = node.getAbsoluteTransform().copy().invert().point(point);
+    const threshold = Properties.strokeWidth * 2;
+
+    if (node.className === 'Rect') {
+      const width = node.width();
+      const height = node.height();
+      
+      return (Math.abs(localPoint.x) < threshold || 
+              Math.abs(localPoint.x - width) < threshold ||
+              Math.abs(localPoint.y) < threshold ||
+              Math.abs(localPoint.y - height) < threshold) &&
+             localPoint.x >= -threshold &&
+             localPoint.x <= width + threshold &&
+             localPoint.y >= -threshold &&
+             localPoint.y <= height + threshold;
+    } else if (node.className === 'Circle' || node.className === 'Ellipse') {
+      const radiusX = node.radiusX ? node.radiusX() : node.radius();
+      const radiusY = node.radiusY ? node.radiusY() : node.radius();
+      
+      const normalizedX = localPoint.x / radiusX;
+      const normalizedY = localPoint.y / radiusY;
+      
+      const distanceFromCenter = Math.sqrt(
+        normalizedX * normalizedX + normalizedY * normalizedY
+      );
+      return Math.abs(distanceFromCenter - 1) < threshold / Math.min(radiusX, radiusY);
+    }
+    return true;
   }
 }