farbfetzen / epicycles Goto Github PK

• Better explanation with links to videos
• New gif with heart (keep filesize minimal), use lfs
• How to use (command line arguments and keybindings)

Record the points, then fft them. See https://www.youtube.com/watch?v=n9nfTxp_APM for inspiration.

Make a gui using pygame_gui. Keep the command line arguments.
This is quite ambituous and will be a good learning experience.

• Dropdown list for choosing the shape file.
• Start/pause button.
• Increase/decrease speed.
• Toggle color fading.
• Toggle circle visibility.
• Toggle drawing mode (lets the user draw on the screen and then uses that for the transformation).
• Change scale factor.
• Make window resizable.
• Change number of harmonics.
• Flip direction.
• Erase path
• Save screenshot.
• Change colors (background, path, circles)

Formula for hearts found in this video: https://www.youtube.com/watch?v=oUBAi9xQ2X4

x = 16 sin(t)^3
y = 13 cos(t) - 5 cos(2 t) - 2 cos(3t) - cos(4 t)

https://github.com/BastiHz/epicycles/blob/dacd2c7109e86a3692b2ac0a7ae5e698940287e0/epicycles.py#L161-L167

That shouldn't happen if I use the results from a fft. If this is a problem then just don't bother resetting t because it won't grow that big anyway.

Oh and name t something else, maybe "angle" or "phi".

Looks like pygame will get better typing support in the next version.

proper structure
functions
lots of comments explaining the math
etc.

1. Load a black and white image.
2. Generate a set of the coordinates of all pixels of a certain color.
3. Pick a random pixel from the set as the start of the path.
4. Generate the path by going to the next closest pixel which has not yet been visited.

This might be inefficient but can work. See for example this post on reddit: https://www.reddit.com/r/Python/comments/gvnyx5/finished_a_program_that_draws_images_with/fspwvno

Also these:

• https://stackoverflow.com/questions/12923586/nearest-neighbor-search-python
• https://www.reddit.com/r/dailyprogrammer/comments/3629st/20150515_challenge_214_hard_chester_the_greedy/
• codingtrains quadtree implementation
• https://www.pygame.org/wiki/QuadTree

pygame.draw.aaline() doesn't seem to work well with colored lines. The blending makes them dark. But maybe with black it's ok? Also anti alias the circle line and the circles themselves if possible. Try pygame.gfxdraw. See which is faster and use the fastest version for lines and circles smaller than a threshold.

I have two lists for the points. Can i simplify that into one list?

https://github.com/BastiHz/epicycles/blob/dacd2c7109e86a3692b2ac0a7ae5e698940287e0/epicycles.py#L100-L101

Either take the points in the order they are provided or try to optimize the path on the press of a button.
Optimization includes finding the shortest route and/or filling in gaps between adjacent points.

At the moment the fading only works with a white background. Make it work regardless of the color. I should learn more about the pygame blit flags.

• Better file structure, put all R stuff in subfolder, create src folder, call the main file in the top directory "epicycles.py".
• Improve readme #15
• Change how drawing works, no more transparency, line points as a fifo queue. #21 and #18.
• Create a state machine to make later changes easier
• Create a debug overlay showing fps, angle in rad and degrees, angular velocity in rad/s and °/s. Remove the print output.

Looks like the bug with aalines are now fixed in Pygame. Try to use those so it is no longer necessary to use a scaled surface.

Add dark mode key and command line argument. Remember to document in readme.

python epicycles.py paths/heart.txt -s 1

Notice that the tip if the heart goes off screen. A scale factor of 1 should ensure that the shape fits completely inside the window.

Circles should draw the shape at the original position.

Probably caused by centering the points. Try to keep the offset.

• I should use numpy.fft.fft() to calculate the discrete fourier transform, like I do in the p5.js-sketch. That would be simpler and better than using numpy.fft.ifft() because I get the radii and phases directly.
• Opimize the Epicycles.get_point_at_angle(). Maybe extract radius, phase and frequency once and then work only with that. Look at how I did the function in the p5.js-sketch to avoid creating possibly hundreds of unnecessary vectors.

Change License to MIT and remove the GPL header from all files.

Siehe das Beispiel im privaten Repo.

Make the epicycles class separate from the main loop and setup stuff.

Continuation but slightly different issue from #12.
Idea: blit a semitransparent layer over line_surface before drawing the next line segment. The transparency should be so that after an angle of 2 pi the first line segment has become invisible.
Make this effect optional via command line argument.
Important: The transparency must change if the angular speed changes because then there will be a different number of frames per cycle.

If the distance between the last point and the new point is greater than some limit (maybe 3 pixels?) then interpolate the timestep. Maybe cut the last dt in half to get a point in between. If that is too far away from the first point then repeat until the distances between all points are small enough.
This way where would be no need to manipulate the framerate for different kinds of shapes.

Reset circles to initial position.

Remove what's not necessary anymore. Keep the paths and/or remake them to scale.

• ability to read in shapes, then fft them and save the fft
• remove unecessary components from fft where the radius is 0
  - [ ] read in fft and run the circles
• read command line arguments

Randomly generated pictures:

1. make some circles
2. let them run for a while
3. save the picture (the generated line without the circles)
4. save the circle attributes in a text file
5. name the picture and the text file with the same id

make it so the user can enter the filename of a ruleset and watch the program draw it

At the moment it is only possible to input a file containing the path. But it should also be possible to input a file containing the harmonics.
Modify the command line arguments to also accept this. Maybe define a flag that controls wether the file contains a path or a list of harmonics. Obviously skip the transformation in this case. Remove the example harmonics from the script and store them in a file.

Don't save the images to file while the circles are running! Save them into a list and create the files afterwards. Use a gif framerate that is separate from the pygame animation so only the necessary frames get saved. Maybe default to 20 fps since it's a nice fraction of 60? And Don't count frames, use dt instead.

The program should detect the display size and scale the window accordingly.

Additionally, set the default value for scale_factor to 0.75 or something.