[V0_FILE]typescriptreact:file="line-intersection.tsx" isFixed="true" isQuickEdit="true" isMerged="true" isEdit="true" "use client" import type React from "react" import { useState, useRef, useEffect } from "react" export default function LineIntersection() { const svgRef = useRef(null) // Store the coordinates of both lines const [redLine, setRedLine] = useState({ start: { x: 300, y: 100 }, end: { x: 300, y: 400 }, }) const [grayLine] = useState({ start: { x: 100, y: 250 }, end: { x: 500, y: 250 }, }) // Track which point is being dragged const [dragging, setDragging] = useState(null) // Use a ref for the intersection point to avoid re-render cycles const intersectionRef = useRef<{ x: number; y: number } | null>(null) // Display state for the intersection (separate from calculation) const [showIntersection, setShowIntersection] = useState(false) // Calculate intersection of two lines const getIntersection = (line1Start: any, line1End: any, line2Start: any, line2End: any) => { // Line 1 represented as a1x + b1y = c1 const a1 = line1End.y - line1Start.y const b1 = line1Start.x - line1End.x const c1 = a1 * line1Start.x + b1 * line1Start.y // Line 2 represented as a2x + b2y = c2 const a2 = line2End.y - line2Start.y const b2 = line2Start.x - line2End.x const c2 = a2 * line2Start.x + b2 * line2Start.y // Small number to handle floating point precision issues const epsilon = 0.001 const determinant = a1 * b2 - a2 * b1 // If lines are almost parallel, treat them as parallel if (Math.abs(determinant) < epsilon) return null const x = (b2 * c1 - b1 * c2) / determinant const y = (a1 * c2 - a2 * c1) / determinant // Add a small buffer for line segment checking to handle numerical imprecision const buffer = 1 const onSegment1 = x >= Math.min(line1Start.x, line1End.x) - buffer && x <= Math.max(line1Start.x, line1End.x) + buffer && y >= Math.min(line1Start.y, line1End.y) - buffer && y <= Math.max(line1Start.y, line1End.y) + buffer const onSegment2 = x >= Math.min(line2Start.x, line2End.x) - buffer && x <= Math.max(line2Start.x, line2End.x) + buffer && y >= Math.min(line2Start.y, line2End.y) - buffer && y <= Math.max(line2Start.y, line2End.y) + buffer return onSegment1 && onSegment2 ? { x, y } : null } // Update intersection when lines change useEffect(() => { // Calculate the new intersection const newIntersection = getIntersection(redLine.start, redLine.end, grayLine.start, grayLine.end) // Store the intersection in the ref intersectionRef.current = newIntersection // Update visibility state if (newIntersection) { setShowIntersection(true) } else { // Hide after a short delay to prevent flickering const timer = setTimeout(() => { setShowIntersection(false) }, 100) return () => clearTimeout(timer) } }, [redLine]) // Convert screen coordinates to SVG coordinates const screenToSVGCoordinates = (screenX: number, screenY: number) => { if (!svgRef.current) return { x: 0, y: 0 } const svg = svgRef.current const svgRect = svg.getBoundingClientRect() // Calculate the scale factor between SVG viewBox and actual size const scaleX = 600 / svgRect.width const scaleY = 500 / svgRect.height // Convert screen coordinates to SVG viewBox coordinates const x = (screenX - svgRect.left) * scaleX const y = (screenY - svgRect.top) * scaleY return { x, y } } // Handle mouse events for dragging useEffect(() => { const handleMouseMove = (e: MouseEvent) => { if (!dragging) return const coords = screenToSVGCoordinates(e.clientX, e.clientY) setRedLine((prev) => ({ ...prev, [dragging]: coords, })) } const handleMouseUp = () => { setDragging(null) } if (dragging) { window.addEventListener("mousemove", handleMouseMove) window.addEventListener("mouseup", handleMouseUp) } return () => { window.removeEventListener("mousemove", handleMouseMove) window.removeEventListener("mouseup", handleMouseUp) } }, [dragging]) // Handle touch events for mobile useEffect(() => { const handleTouchMove = (e: TouchEvent) => { if (!dragging || !e.touches[0]) return const touch = e.touches[0] const coords = screenToSVGCoordinates(touch.clientX, touch.clientY) setRedLine((prev) => ({ ...prev, [dragging]: coords, })) // Prevent page scrolling while dragging e.preventDefault() } const handleTouchEnd = () => { setDragging(null) } if (dragging) { window.addEventListener("touchmove", handleTouchMove, { passive: false }) window.addEventListener("touchend", handleTouchEnd) } return () => { window.removeEventListener("touchmove", handleTouchMove) window.removeEventListener("touchend", handleTouchEnd) } }, [dragging]) // Handle starting drag on touch devices const handleTouchStart = (point: "start" | "end", e: React.TouchEvent) => { setDragging(point) } // Handle starting drag with mouse const handleMouseDown = (point: "start" | "end", e: React.MouseEvent) => { setDragging(point) // Prevent text selection during drag e.preventDefault() } return (

{/* Fixed aspect ratio container */}

{/* 4:3 aspect ratio spacer */}

Drag the red circles to move the red line

{showIntersection && intersectionRef.current && `Intersection at: (${intersectionRef.current.x.toFixed(1)}, ${intersectionRef.current.y.toFixed(1)})`}

) } [V0_FILE]typescriptreact:file="app/page.tsx" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import FlowVisualization from "../flow-visualization" import { useState } from "react" export default function Home() { const [dimensions, setDimensions] = useState({ width: 600, height: 500, }) return (

Flow Visualization

{/* Size controls */}

Width: {dimensions.width}px setDimensions((prev) => ({ ...prev, width: Number.parseInt(e.target.value) }))} className="w-full h-2 bg-gray-200 rounded-lg appearance-none cursor-pointer" />

Height: {dimensions.height}px setDimensions((prev) => ({ ...prev, height: Number.parseInt(e.target.value) }))} className="w-full h-2 bg-gray-200 rounded-lg appearance-none cursor-pointer" />

{/* Single visualization */}

Press 'C' to toggle controls. The dot location copy tool is available below the controls.

) } [V0_FILE]typescriptreact:file="dot-location-copy.tsx" isEdit="true" isMerged="true" "use client" import { useState } from "react" interface DotLocationCopyProps { controlPoints: Record } export default function DotLocationCopy({ controlPoints }: DotLocationCopyProps) { const [copied, setCopied] = useState(false) // Format the control points as a JSON string const formattedPoints = JSON.stringify(controlPoints, null, 2) // Copy to clipboard function const copyToClipboard = () => { navigator.clipboard.writeText(formattedPoints) setCopied(true) setTimeout(() => setCopied(false), 2000) } return (

Control Point Coordinates

{formattedPoints}

) } [V0_FILE]typescriptreact:file="flow-visualization.tsx" isEdit="true" isQuickEdit="true" "use client" import { useState, useRef, useEffect } from "react" import DotLocationCopy from "./dot-location-copy" interface FlowVisualizationProps { width?: number height?: number } export default function FlowVisualization({ width = 600, height = 500 }: FlowVisualizationProps) { const svgRef = useRef(null) // Store original coordinates to scale properly const [originalCoordinates] = useState({ width: 600, height: 500, }) // State for the control points with provided coordinates const [controlPoints, setControlPoints] = useState({ topStart1: { x: 108, y: 138.06620209059233, }, topEnd1: { x: 531.0704960835509, y: 188.58885017421602, }, topStart2: { x: 108, y: 96.25435540069685, }, topEnd2: { x: 194.64751958224545, y: 36.149825783972126, }, topStart3: { x: 108, y: 111.06271777003484, }, topEnd3: { x: 349.7389033942559, y: 28.310104529616723, }, topStart4: { x: 108, y: 126.74216027874564, }, topEnd4: { x: 530, y: 36.36363636363636, }, }) // State for showing/hiding point coordinates const [showCoordinates, setShowCoordinates] = useState(false) // Controls with updated default values const [amplitude, setAmplitude] = useState(20) const [frequency, setFrequency] = useState(1.5) const [curviness, setCurviness] = useState(240) const [innerCurviness, setInnerCurviness] = useState(220) // Right border wave controls with updated default values const [rightAmplitude, setRightAmplitude] = useState(31) const [rightFrequency, setRightFrequency] = useState(0.5) // Track dragging state - expanded to include control points const [dragging, setDragging] = useState<"pointA" | "pointB" | string | null>(null) // Add a state variable to track whether controls are visible const [showControls, setShowControls] = useState(false) // Add states for animation const [hoveredPoint, setHoveredPoint] = useState<"pointA" | "pointB" | string | null>(null) const animationRef = useRef(null) const animationTimeRef = useRef(0) // Define left border padding const leftBorderPadding = 20 * (width / originalCoordinates.width) // Scale a coordinate from original dimensions to current dimensions const scaleX = (x: number) => (x / originalCoordinates.width) * width const scaleY = (y: number) => (y / originalCoordinates.height) * height // Scale a coordinate from current dimensions back to original dimensions const unscaleX = (x: number) => (x / width) * originalCoordinates.width const unscaleY = (y: number) => (y / height) * originalCoordinates.height // Calculate point at a specific t value along a quadratic Bezier curve const getPointOnQuadraticBezier = ( startX: number, startY: number, controlX: number, controlY: number, endX: number, endY: number, t: number, ) => { const x = Math.pow(1 - t, 2) * startX + 2 * (1 - t) * t * controlX + Math.pow(t, 2) * endX const y = Math.pow(1 - t, 2) * startY + 2 * (1 - t) * t * controlY + Math.pow(t, 2) * endY return { x, y } } // Calculate tangent at a specific t value along a quadratic Bezier curve const getTangentOnQuadraticBezier = ( startX: number, startY: number, controlX: number, controlY: number, endX: number, endY: number, t: number, ) => { // Derivative of quadratic Bezier const dx = 2 * (1 - t) * (controlX - startX) + 2 * t * (endX - controlX) const dy = 2 * (1 - t) * (controlY - startY) + 2 * t * (endY - controlY) // Fixed this line // Normalize const length = Math.sqrt(dx * dx + dy * dy) return { dx: dx / length, dy: dy / length } } // Generate a simple Bezier curve path with different curvature for inner lines const generateSimpleBezier = ( startX: number, startY: number, endX: number, endY: number, isInner: boolean, isBottom: boolean, ) => { // Use innerCurviness for inner lines, regular curviness for others let curvinessValue = isInner ? innerCurviness : curviness // Invert curvature for bottom lines to create proper mirroring if (isBottom) { curvinessValue = -curvinessValue } // Scale down the curviness value to make it more manageable const curvinessScale = curvinessValue / 1000 // Calculate distance between points to scale the curve appropriately const distance = Math.sqrt(Math.pow(endX - startX, 2) + Math.pow(endY - startY, 2)) // Calculate control point for the curve const controlX = startX + (endX - startX) * 0.5 const controlY = startY + (endY - startY) * 0.5 + distance * curvinessScale return { path: `M${startX},${startY} Q${controlX},${controlY} ${endX},${endY}`, controlPoint: { x: controlX, y: controlY }, start: { x: startX, y: startY }, end: { x: endX, y: endY }, } } // Get amplitude envelope based on y position (0 at ends, 1 in middle) const getAmplitudeEnvelope = (y: number) => { // Use a sine function for smooth transition (0 at y=0 and y=height, 1 at y=height/2) return Math.sin((y / height) * Math.PI) } // Get X position on sine wave at a given Y position with smooth transition const getSineWaveX = (y: number) => { const baseX = width * 0.133 + leftBorderPadding // Scale baseX (80/600 ≈ 0.133) // Calculate normalized position for the sine wave (0 to 1 across the height) const normalizedY = y / height // Calculate the sine wave value at this position const sineValue = Math.sin(normalizedY * Math.PI * 2 * frequency) * amplitude * (width / originalCoordinates.width) // Apply the envelope to create smooth transition from flat to wavy const envelope = getAmplitudeEnvelope(y) // Return the base position plus the modulated sine wave return baseX + sineValue * envelope } // Get X position on right border sine wave at a given Y position with smooth transition const getRightBorderX = (y: number) => { const baseX = width * 0.917 // Scale baseX (550/600 ≈ 0.917) // Calculate normalized position for the sine wave (0 to 1 across the height) const normalizedY = y / height // Calculate the sine wave value at this position const sineValue = Math.sin(normalizedY * Math.PI * 2 * rightFrequency) * rightAmplitude * (width / originalCoordinates.width) // Apply the envelope to create smooth transition from flat to wavy const envelope = getAmplitudeEnvelope(y) // Return the base position plus the modulated sine wave return baseX + sineValue * envelope } // Generate a sine wave path for the left border with smooth transitions const generateSineWavePath = () => { const baseX = width * 0.133 // Scale baseX (80/600 ≈ 0.133) const steps = 300 // Start with the top point let path = `M${baseX},0` // Generate the wave section with many small steps for smoothness for (let i = 0; i <= steps; i++) { const y = (i / steps) * height const x = getSineWaveX(y) - leftBorderPadding // Subtract padding to get the border path path += ` L${x},${y}` } return path } // Generate a sine wave path for the right border with smooth transitions const generateRightBorderPath = () => { const baseX = width * 0.917 // Scale baseX (550/600 ≈ 0.917) const steps = 300 // Start with the top point let path = `M${baseX},0` // Generate the wave section with many small steps for smoothness for (let i = 0; i <= steps; i++) { const y = (i / steps) * height const x = getRightBorderX(y) path += ` L${x},${y}` } return path } // Get point on line 5 (first bottom line) at a specific t value const getPointOnLine5 = (t: number) => { // Line 5 is the first bottom line (mirror of topStart1/topEnd1) const line5Start = { x: scaleX(108), // Use fixed x-coordinate instead of sine wave y: height - scaleY(controlPoints.topStart1.y), } const line5End = { x: scaleX(controlPoints.topEnd1.x), y: height - scaleY(controlPoints.topEnd1.y), } // Generate bezier data for line 5 const bezierData = generateSimpleBezier( line5Start.x, line5Start.y, line5End.x, line5End.y, true, // isInner true, // isBottom ) // Get point at t value along the bezier curve return getPointOnQuadraticBezier( line5Start.x, line5Start.y, bezierData.controlPoint.x, bezierData.controlPoint.y, line5End.x, line5End.y, t, ) } // Initialize the red line points properly on the L5 line // Now that getPointOnLine5 is defined, we can use it const [redLinePoints, setRedLinePoints] = useState(() => { // Initialize points on the L5 line const pointA = getPointOnLine5(0.8) // Right point at 80% along the curve const pointB = getPointOnLine5(0.8) // Initially at the same position as pointA return { pointA, pointB } }) // Find t value for a point on line 5 closest to the given x coordinate const findTValueForX = (targetX: number) => { let bestT = 0.5 let minDist = Number.POSITIVE_INFINITY // Simple numerical method to find closest t for (let t = 0; t <= 1; t += 0.01) { const point = getPointOnLine5(t) const dist = Math.abs(point.x - targetX) if (dist < minDist) { minDist = dist bestT = t } } return bestT } // Calculate intersection point with the left border curve const calculatePointC = (pointA: { x: number; y: number }, pointB: { x: number; y: number }) => { // Fixed x-coordinate for the left flow line endpoints const fixedX = scaleX(108) // Handle case where points A and B have the same x-coordinate (vertical line) if (Math.abs(pointA.x - pointB.x) < 0.001) { // For a vertical line, we can't calculate a slope, so just return a point // with the fixed x-coordinate and a y-coordinate that's a continuation of the line const direction = pointB.y > pointA.y ? 1 : -1 // Determine if line is going up or down return { x: fixedX, y: Math.max(0, Math.min(height, pointB.y + direction * 50)), // Continue in the same direction } } // Calculate line equation: y = mx + b const m = (pointA.y - pointB.y) / (pointA.x - pointB.x) const b = pointA.y - m * pointA.x // Calculate y where the line intersects with x = fixedX const y = m * fixedX + b // Ensure y is within the SVG bounds and not NaN const boundedY = isNaN(y) ? height / 2 : Math.max(0, Math.min(height, y)) // Return the point with the fixed x-coordinate return { x: fixedX, y: boundedY, } } // Calculate the arrow from Point B to Point C const calculateArrowFromBToC = () => { // Calculate the direction vector from B to C const dirX = pointC.x - redLinePoints.pointB.x const dirY = pointC.y - redLinePoints.pointB.y // Normalize the direction vector const length = Math.sqrt(dirX * dirX + dirY * dirY) // Prevent division by zero if (length < 0.001) { return { points: `${redLinePoints.pointB.x},${redLinePoints.pointB.y} ${redLinePoints.pointB.x},${redLinePoints.pointB.y} ${redLinePoints.pointB.x},${redLinePoints.pointB.y}`, } } const normDirX = dirX / length const normDirY = dirY / length // Calculate the position for the arrow (just behind Point B) const arrowSize = 10 * (width / originalCoordinates.width) const arrowOffset = 12 * (width / originalCoordinates.width) // Distance behind Point B // Position the arrow behind Point B along the B-to-C direction const arrowX = redLinePoints.pointB.x - normDirX * arrowOffset const arrowY = redLinePoints.pointB.y - normDirY * arrowOffset // Calculate the arrow points (triangle) const arrowPoint1 = { x: arrowX + normDirX * arrowSize, y: arrowY + normDirY * arrowSize, } const arrowPoint2 = { x: arrowX + (normDirY * arrowSize) / 2, y: arrowY - (normDirX * arrowSize) / 2, } const arrowPoint3 = { x: arrowX - (normDirY * arrowSize) / 2, y: arrowY + (normDirX * arrowSize) / 2, } return { points: `${arrowPoint1.x},${arrowPoint1.y} ${arrowPoint2.x},${arrowPoint2.y} ${arrowPoint3.x},${arrowPoint3.y}`, } } // Helper function to get curvature direction text const getCurvatureText = (value: number) => { if (value === 0) return "(neutral)" return value > 0 ? "(upward)" : "(downward)" } // Generate flow line starting positions with individual control const generateFlowLines = () => { // Calculate the fixed x position for all start points const fixedStartX = scaleX(108) // Use the same x-coordinate for all start points // Top lines with individual control const topLines = [ { start: { x: fixedStartX, y: scaleY(controlPoints.topStart1.y), }, end: { x: scaleX(controlPoints.topEnd1.x), y: scaleY(controlPoints.topEnd1.y), }, isInner: true, isBottom: false, }, { start: { x: fixedStartX, y: scaleY(controlPoints.topStart2.y), }, end: { x: scaleX(controlPoints.topEnd2.x), y: scaleY(controlPoints.topEnd2.y), }, isInner: false, isBottom: false, }, { start: { x: fixedStartX, y: scaleY(controlPoints.topStart3.y), }, end: { x: scaleX(controlPoints.topEnd3.x), y: scaleY(controlPoints.topEnd3.y), }, isInner: false, isBottom: false, }, { start: { x: fixedStartX, y: scaleY(controlPoints.topStart4.y), }, end: { x: scaleX(controlPoints.topEnd4.x), y: scaleY(controlPoints.topEnd4.y), }, isInner: false, isBottom: false, }, ] // Mirror to bottom with the same fixed x-coordinate const bottomLines = topLines.map((line) => ({ start: { x: fixedStartX, y: height - line.start.y, }, end: { x: line.end.x, y: height - line.end.y, }, isInner: line.isInner, isBottom: true, })) return [...topLines, ...bottomLines] } // Generate all flow paths const flowLines = generateFlowLines() const flowPathsWithArrows = flowLines.map((line) => { const bezierData = generateSimpleBezier( line.start.x, line.start.y, line.end.x, line.end.y, line.isInner, line.isBottom, ) // Calculate midpoint for arrow (use t=0.5 for exact middle of the curve) const midPoint = getPointOnQuadraticBezier( line.start.x, line.start.y, bezierData.controlPoint.x, bezierData.controlPoint.y, line.end.x, line.end.y, 0.5, ) // Calculate tangent at the midpoint for proper arrow direction const tangent = getTangentOnQuadraticBezier( line.start.x, line.start.y, bezierData.controlPoint.x, bezierData.controlPoint.y, line.end.x, line.end.y, 0.5, ) // Arrow size scaled proportionally to the visualization width const arrowSize = 8 * (width / originalCoordinates.width) // Calculate arrow points perpendicular to the tangent // For arrows pointing to the left, we reverse the tangent direction const arrowPoint1 = { x: midPoint.x + tangent.dx * arrowSize + (tangent.dy * arrowSize) / 2, y: midPoint.y + tangent.dy * arrowSize - (tangent.dx * arrowSize) / 2, } const arrowPoint2 = { x: midPoint.x + tangent.dx * arrowSize - (tangent.dy * arrowSize) / 2, y: midPoint.y + tangent.dy * arrowSize + (tangent.dx * arrowSize) / 2, } return { path: bezierData.path, midPoint, arrowPoints: [arrowPoint1, arrowPoint2], bezierData, } }) // Add a keyboard event listener to toggle controls visibility useEffect(() => { const handleKeyDown = (e: KeyboardEvent) => { if (e.key.toLowerCase() === "c") { setShowControls((prev) => !prev) } } window.addEventListener("keydown", handleKeyDown) return () => { window.removeEventListener("keydown", handleKeyDown) } }, []) // Convert screen coordinates to SVG coordinates const screenToSVGCoordinates = (screenX: number, screenY: number) => { if (!svgRef.current) return { x: 0, y: 0 } const svg = svgRef.current const svgRect = svg.getBoundingClientRect() const scaleX = width / svgRect.width const scaleY = height / svgRect.height return { x: (screenX - svgRect.left) * scaleX, y: (screenY - svgRect.top) * scaleY, } } // Handle mouse/touch events for dragging useEffect(() => { const handleMove = (clientX: number, clientY: number) => { if (!dragging) return const coords = screenToSVGCoordinates(clientX, clientY) if (dragging === "pointA") { // Find t value for the x coordinate on line 5 const t = findTValueForX(coords.x) // Get the point on line 5 at that t value const pointOnLine5 = getPointOnLine5(t) setRedLinePoints((prev) => ({ ...prev, pointA: pointOnLine5, })) } else if (dragging === "pointB") { // For pointB, we allow free movement setRedLinePoints((prev) => ({ ...prev, pointB: coords, })) } else if (dragging.startsWith("control_")) { // Handle control point dragging const pointKey = dragging.replace("control_", "") // Update the control point position setControlPoints((prev) => { // Create a copy of the previous state const newControlPoints = { ...prev } // Update the specific control point if (pointKey in newControlPoints) { newControlPoints[pointKey as keyof typeof newControlPoints] = { x: unscaleX(coords.x), y: unscaleY(coords.y), } } return newControlPoints }) } } const handleMouseMove = (e: MouseEvent) => { handleMove(e.clientX, e.clientY) } const handleTouchMove = (e: TouchEvent) => { if (!e.touches[0]) return handleMove(e.touches[0].clientX, e.touches[0].clientY) e.preventDefault() } const handleMouseUp = () => { setDragging(null) } const handleTouchEnd = () => { setDragging(null) } if (dragging) { window.addEventListener("mousemove", handleMouseMove) window.addEventListener("touchmove", handleTouchMove, { passive: false }) window.addEventListener("mouseup", handleMouseUp) window.addEventListener("touchend", handleTouchEnd) } return () => { window.removeEventListener("mousemove", handleMouseMove) window.removeEventListener("touchmove", handleTouchMove) window.removeEventListener("mouseup", handleMouseUp) window.removeEventListener("touchend", handleTouchEnd) } }, [dragging, width, height]) // Calculate point C based on points A and B const pointC = calculatePointC(redLinePoints.pointA, redLinePoints.pointB) // Get the arrow data const arrowFromBToC = calculateArrowFromBToC() // Update left point positions when sine wave changes useEffect(() => { setControlPoints((prev) => ({ ...prev, // Keep the x-coordinate fixed at 108 for all start points topStart1: { x: 108, y: prev.topStart1.y, }, topStart2: { x: 108, y: prev.topStart2.y, }, topStart3: { x: 108, y: prev.topStart3.y, }, topStart4: { x: 108, y: prev.topStart4.y, }, })) }, [amplitude, frequency, width, height]) // Update points when dimensions change useEffect(() => { // Recalculate the red line points const newPointA = getPointOnLine5(0.8) const newPointB = getPointOnLine5(0.8) setRedLinePoints({ pointA: newPointA, pointB: newPointB, }) }, [width, height]) // Continuous animation loop for point B useEffect(() => { // Animation duration in ms const duration = 5000 // Animation function const animate = (timestamp: number) => { // Update the animation time if (animationTimeRef.current === 0) { animationTimeRef.current = timestamp } const elapsed = timestamp - animationTimeRef.current // Calculate progress (0 to 1) with looping const normalizedTime = (elapsed % duration) / duration // Use sine wave to create smooth back-and-forth motion // This will oscillate between 0.2 and 0.8 const t = 0.5 + 0.3 * Math.sin(normalizedTime * Math.PI * 2) // Get the point on the curve at the current t value const newPointB = getPointOnLine5(t) // Only update if not being dragged if (dragging !== "pointB") { setRedLinePoints((prev) => ({ ...prev, pointB: newPointB, })) } // Continue the animation loop animationRef.current = requestAnimationFrame(animate) } // Start the animation animationRef.current = requestAnimationFrame(animate) // Cleanup function return () => { if (animationRef.current) { cancelAnimationFrame(animationRef.current) } } }, [width, height, dragging]) // Handle starting drag for control points const handleControlPointDrag = (pointKey: string) => { setDragging(`control_${pointKey}`) } return (

{/* Controls hint */}

Press 'C' to toggle controls

{/* Controls panel - only shown when showControls is true */} {showControls && (

Left Border Controls

Wave Amplitude: {amplitude} setAmplitude(Number.parseInt(e.target.value))} className="w-full h-2 bg-gray-200 rounded-lg appearance-none cursor-pointer" />

Wave Frequency: {frequency} setFrequency(Number.parseFloat(e.target.value))} className="w-full h-2 bg-gray-200 rounded-lg appearance-none cursor-pointer" />

Right Border Controls

Wave Amplitude: {rightAmplitude} setRightAmplitude(Number.parseInt(e.target.value))} className="w-full h-2 bg-gray-200 rounded-lg appearance-none cursor-pointer" />

Wave Frequency: {rightFrequency} setRightFrequency(Number.parseFloat(e.target.value))} className="w-full h-2 bg-gray-200 rounded-lg appearance-none cursor-pointer" />

Flow Curvature (Outer Lines): {curviness}% {getCurvatureText(curviness)} setCurviness(Number.parseInt(e.target.value))} className="w-full h-2 bg-gray-200 rounded-lg appearance-none cursor-pointer" />

Flow Curvature (Inner Lines): {innerCurviness}% {getCurvatureText(innerCurviness)} setInnerCurviness(Number.parseInt(e.target.value))} className="w-full h-2 bg-gray-200 rounded-lg appearance-none cursor-pointer" />

)} {/* Dot Location Copy Tool */}

) }

About

Tags

Share

More from oeneco

More Templates Like This

About

Tags

Share

About

Tags

Share

More from oeneco

More Templates Like This