MathPlotAI Logo MathPlotAI

Pursuit Curves on a Cube

Pursuit Curves on a Cube
Loading the math board and drawing, please wait…
2020-01-24 03:32
VectorSequenceSolid GeometryCalculusLocus
This example demonstrates the dynamic generation of pursuit curves on the surface of a cube in 3D space. A pursuit curve is the path traced by a point (the pursuer) that always moves directly toward another moving point (the target), and here the classic 2D pursuit problem is extended to the edges and faces of a cube. Core mathematical concepts include vectors, midpoints, polygons, sequence iteration, rotation, and the limit/integral ideas from calculus, with iterative approximation of the pursuit path. Construction highlights: using GeoGebra commands such as Vector, Midpoint, Polygon, Sequence, Line, Rotate, Point, and Cube to build the cube framework, and employing an Iteration object to progressively generate the pursuer point sequence, resulting in multiple curves (L1 through L9). Suitable for high school to university students, this example helps understand spatial geometry, vector operations, iterative algorithms, and limit concepts, and can serve as a teaching demonstration for mathematical modeling or computer graphics.

GeoGebra Commands & Parameters

  1. Vector((1, 0)) → u
  2. Midpoint(A, C) → O
  3. Polygon(A, B, C, D) → poly1, a, b, c, d
  4. Sequence(Rotate[Dilate[A, r^(n), O], (n * α), O], n, 1, Iteration) → L2
  5. Sequence(Rotate[Dilate[B, r^(n), O], (n * α), O], n, 1, Iteration) → L3
  6. Sequence(Rotate[Dilate[C, r^(n), O], (n * α), O], n, 1, Iteration) → L4
  7. Sequence(Rotate[Dilate[D, r^(n), O], (n * α), O], n, 1, Iteration) → L5
  8. Vector((0, 1)) → v
  9. Sequence(Segment[Rotate[Dilate[A, r^(n - 1), O], ((n - 1) * α), O], Rotate[Dilate[A + (Pas * u), r^(n - 1), O], ((n - 1) * α), O]], n, 1, Iteration) → L6
  10. Sequence(Segment[Rotate[Dilate[B, r^(n - 1), O], ((n - 1) * α), O], Rotate[Dilate[B + (Pas * v), r^(n - 1), O], ((n - 1) * α), O]], n, 1, Iteration) → L7
  11. Sequence(Segment[Rotate[Dilate[C, r^(n - 1), O], ((n - 1) * α), O], Rotate[Dilate[C - (Pas * u), r^(n - 1), O], ((n - 1) * α), O]], n, 1, Iteration) → L8
  12. Sequence(Segment[Rotate[Dilate[D, r^(n - 1), O], ((n - 1) * α), O], Rotate[Dilate[D - (Pas * v), r^(n - 1), O], ((n - 1) * α), O]], n, 1, Iteration) → L9
  13. Sequence(Polygon[Rotate[Dilate[A, r^(n), O], (n * α), O], Rotate[Dilate[B, r^(n), O], (n * α), O], Rotate[Dilate[C, r^(n), O], (n * α), O], Rotate[Dilate[D, r^(n), O], (n * α), O]], n, 1, Iteration, 2) → L1
  14. Sequence(Polygon[Element[L4, i], Element[L5, i], Element[L5, i + 1], Element[L4, i]], i, 1, Length[L4], 2) → liste1
  15. Sequence(Polygon[Element[L5, i], Element[L2, i], Element[L2, i + 1], Element[L5, i]], i, 1, Length[L4], 2) → liste2
  16. Sequence(Polygon[Element[L2, i], Element[L3, i], Element[L3, i + 1], Element[L2, i]], i, 1, Length[L2], 2) → liste3
  17. Sequence(Polygon[Element[L3, i], Element[L4, i], Element[L4, i + 1], Element[L3, i]], i, 1, Length[L4], 2) → liste4
  18. Line(A, B) → f
  19. Rotate(liste1, 90°, f) → liste1'
  20. Rotate(liste2, 90°, f) → liste2'
  21. Rotate(liste3, 90°, f) → liste3'
  22. Rotate(liste4, 90°, f) → liste4'
  23. Midpoint(A, C) → E
  24. Line(E, zAxis) → g
  25. Sequence(Rotate[liste1', i, g], i, 0, (2 * π), (2 * π / 4)) → l1
  26. Sequence(Rotate[liste2', i, g], i, 0, (2 * π), (2 * π / 4)) → l2
  27. Sequence(Rotate[liste3', i, g], i, 0, (2 * π), (2 * π / 4)) → l3
  28. Sequence(Rotate[liste4', i, g], i, 0, (2 * π), (2 * π / 4)) → l4
  29. Point(Circle[B, Distance[A, B], Segment[A, B]]) → F
  30. Cube(A, B, F) → e, G, faceFGKJ, faceHIJK, arêteAG, arêteAB, arêteBF, arêteFG, arêteAH, arêteGK, arêteHK, arêteHI, H, arêteBI, arêteIJ, arêteFJ, arêteJK, I, J, K, faceABFG, faceAGKH, faceABIH, faceBFJI
  31. Line(H, I) → h
  32. Rotate(liste1', 90°, h) → liste1''
  33. Rotate(liste2', 90°, h) → liste2''
  34. Rotate(liste3', 90°, h) → liste3''
  35. Rotate(liste4', 90°, h) → liste4''

AI Drawing Prompt Reference

Draw a cube and generate pursuit curves on its surface. First, create a cube framework, then generate pursuit paths on each face, consisting of a sequence of points where each point moves towards a target point. Use rotation and iteration to generate multiple pursuit curves, ultimately displaying these curves on the cube's faces.
The prompt above was compiled from the original drawing commands and is for reference only.