spirograph | An interactive spirograph written in vanilla JS | Grid library

I think that you have a commit with this file. Even if you delete the file and make a new commit, the file is persisted in a previous commit. And git push send all the missing commits to the remote.

You have to rewrite git history before pushing it. Without a git log, I can't help you with an exact command. Squashing Commits can do the job.

To get some animation into your coode you will have to refactor your code a little bit:

• Create a function that draws only one line segment of your loop. This means, begin a new path and stroke every segment
• call requestAnimationFrame repeatedly instead of your loop, stop at your iteration count
• Take care if another line drawing started! If so, stop calling requestAnimationFrame

Here a simple implenentation. Play around a little bit with the parameters and maybe add colors. Have fun!

Three times you say you want it "very fast", but you also say, "as fast as the spiro was created". We can easily make it faster than the spiro was created, but just slightly more work to make it "as fast".

This problem points out the underbelly of the undo() mechanism. To undo just one of your circles, involves a sequence of over 80 steps. But, even that doesn't make it completely clear why it's so slow. If we turn off screen updates, we can make it instantaneous. But if that's acceptable, then you might as well replace undo() with clear().

I rarely encourage folks to mess with tracer(), and even when I do, I usually write examples that do simple tracer(False) and tracer(True), to avoid the numeric argument. But this is the rare case where we want a specific numeric argument to tracer() to control the speed of the undo() graphics:

I think the easy way to do this would be, as you suggest, maintain an array of the line segments, pushing newly calculated segments onto the end of the array, and shifting the oldest segments from the beginning. Then, paint the old segment white. This has the side effect of also erasing little bits and pieces of line that shouldn't be erased, but the line moves so fast in your example that it shouldn't be too noticeable.

If that imperfection is not acceptable, then I can't see any other way than to redraw the whole curve every frame. Painting in HTML canvases is nice because the browser won't update the screen until the frame is completely drawn (so you don't have to worry about managing another framebuffer.)

I recommend to create a class CLine, which can holde the coordinates of a line and draw a line:

In my version of fractal.lua there is no reference to C variable on line 123. I'd try a newer version, as I don't see any issue with the execution of zplane.lua with the current version of fractal.lua.

If you want a view to update when you change some property (such as insideRadius and rotationalSpeed), you would generally have a didSet observer for the property that would trigger the re-rendering of the path.

Now, your example is building an image. That's a pretty inefficient way of doing it (and, btw, all of that transparent image stuff is unnecessary). I'd suggest just using a CAShapeLayer. That way, you can just update the path of the CAShapeLayer and the OS will take care of rendering it for you.

For example, you might have a UIView subclass that captures your path creation stuff and updates a CAShapeLayer. And the various didSet observers will update the path for that shape layer:

Interesting visualization.

This is not a direct answer to you question because I find your code overly confusing and troubling to debug. You seem to be doing way more math then you need; converting back from forth to different coordinate systems. Also, animating in a setTimeout is not a good practice.

Here's a quick refactor that takes advantage of d3.transition and simplifies the calculations. It also drives the addition of new circles through data.