├── .gitignore
├── wavepacket_1D.py
├── mandelbrotzoom.py
├── wavepacket_2D.py
├── fouriercontour.py
├── README.md
├── ballsincircle.py
├── softbody.py
└── stringart.py


/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store


--------------------------------------------------------------------------------
/wavepacket_1D.py:
--------------------------------------------------------------------------------
 1 | import matplotlib as mpl
 2 | import matplotlib.pyplot as plt
 3 | from matplotlib.patches import Rectangle
 4 | import numpy as N   
 5 | import scipy.linalg as SLA
 6 | import os
 7 | 
 8 | os.system('mkdir frames')
 9 | 
10 | mpl.rcParams['figure.figsize'] = 16/9*6,6
11 | 
12 | ymin = -2
13 | xmin = ymin*16/9
14 | xmax = abs(xmin);ymax = abs(ymin)
15 | 
16 | NN   = 2000        # number of x coordinates
17 | pwp  = 40          # momentum
18 | sig  = .15         # width of wave packet
19 | Vmax = pwp**2/2*1. # height of tunneling barrier
20 | noframes = 200     # number of frames
21 | 
22 | dx = (2*xmax-2*xmin)/NN
23 | xvec = N.arange(xmin*2,xmax*2,dx)
24 | b  = -1/2/dx**2
25 | 
26 | # finite difference Laplacian 
27 | diag   = -N.diagflat(2*b*N.ones(NN))
28 | offdiag = N.diagflat(b*N.ones(NN-1),1)
29 | D2 = diag+offdiag+offdiag.transpose()
30 | 
31 | # add potential to diagonal
32 | pot = N.zeros(NN)
33 | for ii in range(NN):
34 |     if (ii>int(.495*NN) and ii<int(.505*NN)):
35 |         pot[ii] = Vmax
36 | 
37 | # Hamiltonian; H = D2 + V
38 | H = D2+N.diagflat(pot)
39 | 
40 | ev,evec = SLA.eigh(H)
41 | idx = ev.argsort()
42 | ev,evec = ev[idx],evec[idx]
43 | 
44 | initwf = N.exp(-(xvec+2)**2/sig-1j*pwp*(xvec+2)) #initial Gaussian
45 | init = ev[0]
46 | cm = N.array([N.sum(initwf*evec[:,mm]) for mm in range(len(ev))])
47 | cm = cm/SLA.norm(cm)
48 | psi = [cm[jj]*evec[:,jj] for jj in range(len(ev))]
49 | 
50 | fig = plt.figure()
51 | for tt in range(noframes):
52 |     tt2 = tt/noframes
53 |     Psi = psi[0]*N.exp(1j*ev[0]*tt2)
54 | 
55 |     for jj in range(1,len(psi)):
56 |         Psi+=psi[jj]*N.exp(1j*ev[jj]*tt2)
57 | 
58 |     plt.xlim([xmin,xmax])
59 |     plt.ylim([ymin*.3,ymax*.3])
60 |     plt.gca().add_patch(Rectangle((-4,-10),10,10,linewidth=1,edgecolor=None,facecolor='gray'))
61 | 
62 |     if max(pot)>0:
63 |         plt.fill(xvec,pot/abs(b)*.5,linewidth=1,color='gray')
64 | 
65 |     else:
66 |         plt.fill(xvec,pot/abs(b)*.5,linewidth=1,color='black')
67 |         
68 |     plt.plot(xvec,5*N.abs(Psi)**2,linewidth=1,color='red')
69 |     plt.savefig('frames/fig'+f"{tt:04d}.png",
70 |                 bbox_inches='tight',pad_inches=0)
71 |     plt.clf()
72 |     plt.close("fig")
73 | 


--------------------------------------------------------------------------------
/mandelbrotzoom.py:
--------------------------------------------------------------------------------
 1 | import numpy as N
 2 | import matplotlib as mpl
 3 | import matplotlib.pyplot as plt
 4 | from matplotlib.colors import LinearSegmentedColormap
 5 | import os,time
 6 | import warnings
 7 | warnings.filterwarnings("ignore", category=RuntimeWarning, message="overflow encountered")
 8 | warnings.filterwarnings("ignore", category=RuntimeWarning, message="invalid value encountered")
 9 | 
10 | os.system('mkdir frames')
11 | 
12 | # customized colormap
13 | mycolor = LinearSegmentedColormap.from_list('mycmap',['gray','black'])
14 | 
15 | # set image resolution for frames to be saved
16 | yr = 10
17 | xr = int(yr*16/9)
18 | mpl.rcParams['figure.figsize'] = xr,yr
19 | 
20 | # function to determine whether coordinate belongs to MB set or not
21 | def mandelbrot_set(xmin, xmax, ymin, ymax, width, height, max_iterations):
22 |     x = N.linspace(xmin, xmax, width).reshape((1, width))
23 |     y = N.linspace(ymin, ymax, height).reshape((height, 1))
24 |     c = x + y * 1j
25 |     z = N.zeros_like(c)
26 | 
27 |     for i in range(max_iterations):
28 |         z = z**2 + c
29 | 
30 |     mandelbrot = (abs(z) < 2).astype(int)
31 | 
32 |     return mandelbrot
33 | 
34 | height = int(2160/2)            # resolution of image (does not need to match the resolution of the saved frames)
35 | width  = int(16/9*height)       # aspect ratio = 16/9
36 | 
37 | Nmax = 50       # number of frames between the initial and final frame (i.e., sets the zoom speed)
38 | zfac = 20/Nmax
39 | itermax = 600   # this number depends on how deep the zoom is. Deeper means larger itermax
40 | myiters = N.linspace(25,600,Nmax)
41 | 
42 | print('\nCalculation starts. Note, calculation time increases with zoom level.')
43 | 
44 | for ii in range(0,Nmax):
45 |     # present frame zoom (XMIN, XMAX, etc.)
46 |     XMIN = -1*16/9*2**(-ii*zfac) - .74877   # .74877 is the x coordinate (real axis) of the point we zoom towards
47 |     XMAX =  1*16/9*2**(-ii*zfac) - .74877
48 |     YMIN = -1*2**(-ii*zfac)      - .065176  # .065176 is the y coordinate (imaginary axis) of the point we zoom towards
49 |     YMAX =  1*2**(-ii*zfac) - .065176
50 |     ext = [XMIN,XMAX,YMIN,YMAX] 
51 |     
52 |     # function that aims to provide a sufficient number of iterations at a specific zoom level
53 |     iters = int(15+zfac*30/abs(XMIN-XMAX)**(.25/zfac)-0*4*N.log(abs(XMIN-XMAX)))
54 | 
55 |     iters = int(myiters[ii])
56 |     mandelbrot = mandelbrot_set(ext[0],ext[1],ext[2],ext[3],width,height,iters)
57 |     plt.imshow(mandelbrot, cmap=mycolor, extent=ext)
58 |     plt.axis('off')
59 |     plt.savefig('frames/fig'+f"{ii:06d}.png",bbox_inches='tight',pad_inches=0)
60 |     plt.close("fig")
61 |     
62 |     if N.mod(ii,round(Nmax/20)) == 0:
63 |         print(round(100*ii/Nmax),'% of the frames saved')
64 | 


--------------------------------------------------------------------------------
/wavepacket_2D.py:
--------------------------------------------------------------------------------
 1 | import numpy as N
 2 | import matplotlib.pyplot as plt
 3 | import matplotlib as mpl
 4 | from scipy import sparse
 5 | import scipy.linalg as SLA
 6 | from scipy.sparse.linalg import isolve
 7 | import os, time
 8 | 
 9 | os.system('mkdir frames')
10 | 
11 | # main program PARAMS
12 | Nx   = 200           
13 | Ny   = Nx           # only tried for Nx=Ny
14 | tmax = 400          # number of frames
15 | xmax = 1.;ymax = 1.
16 | dx   = 1./(Nx-1)
17 | a    = 1j/2/dx**2   # time term: Adds to diagonal of FD Hamiltonian
18 | b    = 1/4/dx**2.   # off-diagonal elements of FD Hamiltonian
19 | TOL  = 1e-6         # tolerance in iterative linear solver
20 | 
21 | # initial Gaussian and its momentum
22 | sig  = .07                # width of Gaussian
23 | cwp  = [Nx/3,Ny/4]        # start position
24 | pwp  = [-4*Nx/10,6*Nx/10] # momentum (2pi/lambda)
25 |     
26 | # potential matrix
27 | V = N.zeros((Nx,Ny))
28 | # define whatever potential you wish here
29 | 
30 | # Gaussian wave packet
31 | psi = [N.exp(1j*(pwp[0]*(ii-cwp[0])+pwp[1]*(jj-cwp[1]))*dx-\
32 |              ((ii-cwp[0])**2+(jj-cwp[1])**2)*dx**2/(2*sig**2))\
33 |        for ii in range(Nx) for jj in range(Ny)]
34 | 
35 | psi = N.array(psi).reshape(Nx,Ny)
36 | psi = psi/SLA.norm(psi)
37 | 
38 | # create FD Hamiltonian for one slice of the domain
39 | lhs = N.zeros((3,Nx))
40 | lhs[0,:] = b*N.ones(Nx) # upper off-diagonal
41 | lhs[2,:] = lhs[0,::-1]  # lower off-diagonal
42 | 
43 | # returns FD Ham in sparse csr format to be used in an iterative solver below
44 | # only the diagonal is updated in LHS/LHS2
45 | 
46 | def LHS(idx):
47 |     mtx = sparse.spdiags([lhs[0],2*a-2*b-V[:,idx]/2,lhs[2]],[1,0,-1],Nx,Nx)
48 |     return sparse.csr_matrix(mtx) 
49 | 
50 | def LHS2(idx):
51 |     mtx = sparse.spdiags([lhs[0],2*a-2*b-V[idx,:]/2,lhs[2]],[1,0,-1],Nx,Nx)
52 |     return sparse.csr_matrix(mtx)
53 | 
54 | def RHS(idx):
55 |     return  N.array((2*a+2*b+V[:,idx]/2)*psi[:,idx]-\
56 |                     b*N.array([psi[ii,min(Nx-1,idx+1)]+psi[ii,max(0,idx-1)] for ii in range(Nx)]))
57 | 
58 | def RHS2(idx):
59 |     return N.array((2*a+2*b+V[idx,:]/2)*psi[:,idx]-\
60 |                    b*N.array([psi[jj,min(Nx-1,idx+1)]+psi[jj,max(0,idx-1)] for jj in range(Nx)]))
61 | 
62 | def plotandsave(tt,psi):
63 |     plt.imshow(N.abs(psi)**2)
64 |     # add possible line plots, etc. here
65 |     plt.savefig('frames/fig'+f"{tt:04d}.png") 
66 | 
67 | t1 = time.process_time()
68 | 
69 | for tt in range(tmax):
70 |     plotandsave(tt,psi)
71 |     psi = N.array([isolve.gmres(LHS(jj),RHS(jj),tol=TOL)[0] for jj in range(Nx)])
72 |     psi = N.array([isolve.gmres(LHS2(ii),RHS2(ii),tol=TOL)[0] for ii in range(Nx)])
73 |     psi = psi/SLA.norm(psi)
74 | 
75 |     if N.mod(tt,round(tmax/10)) == 0:
76 |         print(round(100*tt/tmax),'% of the frames saved')
77 | 
78 | tm = time.process_time()-t1
79 | print('\nAll frames saved in ',round(tm,1),'s')
80 | 


--------------------------------------------------------------------------------
/fouriercontour.py:
--------------------------------------------------------------------------------
 1 | import numpy as N
 2 | import matplotlib.pyplot as plt
 3 | import os,time
 4 | 
 5 | os.system('mkdir ./frames') # creates a folder in which the frames are saved
 6 | 
 7 | timesteps = 121
 8 | dt = 1/timesteps    # incremental time between subsequent frames
 9 | factor = 3;         # number of periods
10 | tsRange = timesteps*factor
11 | 
12 | nn = 1000           # number of points defining a function when made here
13 | mm = 7              # number of basis functions in the F-expansion
14 | lw = 1              # line width of plots
15 | 
16 | # define function in complex plane
17 | function2=[]
18 | for ii in range(nn):
19 |     if ii<int(nn/4)+1:
20 |         function2.append(1+1j*4*ii/nn)
21 | 
22 |     if ii>int(nn/4) and ii<int(2*nn/4)+1:
23 |         function2.append(1+4*(ii-int(nn/4))/nn+1j)
24 | 
25 |     if ii >int(2*nn/4) and ii<int(3*nn/4)+1:
26 |         function2.append(2+1j-1j*4*(ii-int(2*nn/4))/nn)
27 | 
28 |     if ii>int(3*nn/4):
29 |         function2.append(2-4*(ii-int(3*nn/4))/nn)
30 | 
31 | function2 = N.array(function2)+.1*1j
32 | 
33 | # returns positions for all rods at each time stamp
34 | def myfourier(function,nn,mm):
35 |     cf = [1./nn*N.sum([function[ii]*N.exp(-2*N.pi*1j*ii*jj/nn)\
36 |                        for ii in range(0,nn)]) for jj in range(-mm,mm+1)]
37 |     fourier = [N.sum([cf[ii]*N.exp(2*N.pi*1j*(ii-mm)*tt*dt)\
38 |                       for ii in range(0,2*mm+1)]) for tt in range(0,timesteps+1)]
39 |     # sort frequencies to match Fourier coefficients
40 |     mmAsUsed = [ii for ii in range(-mm,mm+1)];
41 |     mmSorted = sorted(mmAsUsed,key=abs)
42 |     idx = [(N.abs(mmSorted[ii]-N.array(mmAsUsed))).argmin() for ii in range(2*mm+1)]
43 |     apprY = [];Ytvec = [];barvec = []
44 | 
45 |     for ttmp in range(tsRange):
46 |         bars = []
47 |         bars.append(cf[idx[0]])
48 | 
49 |         for ii in range(1,2*mm+1):
50 |             bars.append(bars[ii-1]+cf[idx[ii]]*N.exp(2*N.pi*1j*(idx[ii]-mm)*ttmp*dt))
51 | 
52 |         barvec.append(bars)
53 |         apprY.append(N.imag(bars[ii]))
54 |         Ytvec.append(N.real(bars[ii]))
55 | 
56 |     return barvec,apprY,Ytvec
57 | 
58 | t1 = time.process_time()
59 | fig2 = myfourier(N.array(function2),nn,mm)
60 | tm = time.process_time()-t1
61 | print('\nFourier expansion done in:',round(tm,2),'s')
62 | 
63 | for ttmp in range(tsRange):
64 |     plt.plot(N.array(fig2[2][:ttmp+1]),
65 |         N.array(fig2[1][:ttmp+1]),color=[0,1,0],linewidth=lw)
66 | 
67 |     for ii in range(1,2*mm+1):
68 |         plt.plot(N.real(fig2[0][ttmp][ii-1:ii+1]),
69 |             N.imag(fig2[0][ttmp][ii-1:ii+1]),color='magenta',linewidth=lw)
70 | 
71 |     plt.xlim([.7,2.3])
72 |     plt.ylim([-.1,1.3])
73 |     plt.savefig('./frames/fig'+f"{ttmp:05d}.png")
74 |     plt.close()
75 | 
76 |     if N.mod(ttmp,round(tsRange/10)) == 0:
77 |         print(round(100*ttmp/tsRange),'% of the frames saved')
78 |         
79 | print('All',tsRange,' frames saved')
80 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # animations_ag
 2 | 
 3 | - [Introduction](#introduction)
 4 | - [Usage](#usage)
 5 | - [Description](#description)
 6 | 
 7 | ## Introduction
 8 | Short easy-to-use python scripts that generate frames for animating  specific concepts in physics and mathematics.
 9 | 
10 | ## Usage
11 | To run a script, open Terminal, stand in the directory of the script and type:
12 | 
13 |        python (or python3) <script>.py
14 | 
15 | All scripts run on python3 and need numpy, matplotlib, and typically other libraries evident from what a specific script tries to import.
16 | 
17 | Execution of a script generates a 'frames' folder located at the same path as the script. If not (e.g., if executed through Visual Studio), check your home directory.
18 | 
19 | FFmpeg may be used to generate a video of the frames by a simple command line in the Terminal by executing the command below while being in the folder containg the frames:
20 | 
21 |        ffmpeg -pattern_type glob -i "*.png"  -pix_fmt yuv420p movie.mov
22 | 
23 | 
24 | ## Description
25 | 
26 | ### fouriercontour.py  
27 | Generates time dependent plots on epicycles (connected rotating rods) where the apex of the outermost rod draws an approximative path of a predefined contour in the complex plane. Here the contour is exemplified by a square. The contour may have any shape.
28 | 
29 | ### wavepacket_1D.py 
30 | Generates time dependent plots of a wave packet moving in one dimension. The script exemplifies a Gaussian wave packet scattering off a rectangular potential, qualitatively demonstrating quantum tunneling.
31 | 
32 | ### wavepacket_2D.py  
33 | Generates time dependent plots of a wave packet moving in two dimensions. The script exemplifies a Gaussian wave packet moving in a rectangular domain having impenetrable walls.
34 | 
35 | ### ballsincircle.py  
36 | Generates time dependent plots of balls dropped on a circle's interior under gravity. The SymPy library is here used to compute exact reflection angles. This script is particularly badly coded, but at least it works.
37 | 
38 | ### mandelbrotzoom.py  
39 | Generates plots of gradually increasing zoom around a particular coordinate of the Mandelbrot set. The script exemplifies zooming into the so-called seahorse valley.
40 | 
41 | ### stringart.py
42 | Generates a single stringart image based on an input .jpg image. Just type
43 | 
44 | 	  python (or python3) stringart.py -img </path/to/image>.jpg
45 | 
46 | to obtain a first draft of your generated stringart. The default values seem working reasonably well on portraits; however further elaboration with the flags is likely needed. The script auto crops the input image based on its smallest side; hence, to properly frame your image, a substantially quadratic input image is recommended. Needs the PIL library (pip install Pillow). For further usage information, type
47 | 
48 |    	  python (or python3) stringart.py --h
49 | 
50 | ### softbody.py
51 | Generates frames of simple rectangularly arranged grid points connected by springs falling under gravity and bouncing on a floor. Aimed to be a starting point sandbox. Just execute by
52 | 
53 | 	  python (or python3) softbody.py
54 | 
55 | and elaborate with the parameters in the script.


--------------------------------------------------------------------------------
/ballsincircle.py:
--------------------------------------------------------------------------------
  1 | import matplotlib.pyplot as plt
  2 | import numpy as N
  3 | from   sympy.solvers import solve
  4 | from   sympy import Symbol,re,im,diff
  5 | import scipy.linalg as SLA
  6 | import os
  7 | 
  8 | os.system('mkdir frames')
  9 | 
 10 | def mm(* args):
 11 |     tmp=N.dot(args[0],args[1])
 12 |     for ii in range(len(args)-2):
 13 |         tmp=N.dot(tmp,args[ii+2])
 14 |     return tmp
 15 | 
 16 | def myangle(xp1,yp1):
 17 |     if xp1<0 and yp1<0:
 18 |         ang = N.pi+N.arctan(yp1/xp1)
 19 |     elif xp1>0 and yp1<0:
 20 |         ang = N.arctan(yp1/xp1)
 21 |     return ang
 22 | 
 23 | # draw the circle
 24 | mycircle = N.array([[1.01*N.cos(2*N.pi*ii/1000),
 25 |     1.01*N.sin(2*N.pi*ii/1000)] for ii in range(1000)]).T
 26 | 
 27 | # main parameters
 28 | g             = 9.81    # acceleration
 29 | startposition = -.5     # along x axis. 0 is center of circle
 30 | noballs       = 10      # number of balls
 31 | jumps         = 5       # number of bounces
 32 | dt            = .005    # time increment, should be small
 33 | eps           = 1e-2    # distance between adjacent balls
 34 | 
 35 | def findpaths(xp1,yp1,v0):
 36 |     for kk in range(jumps):    
 37 |         angle = myangle(xp1,yp1)
 38 |         dvec = [-N.sin(angle),N.cos(angle)]
 39 |         nvec = [-dvec[1],dvec[0]]
 40 |         nvec = nvec/N.sqrt(mm(nvec,nvec))
 41 |         
 42 |         if kk == 0:
 43 |             ivec = [0,-1]
 44 |             ivec = N.array([float(ivec[0]),float(ivec[1])])
 45 |             ivec = ivec/SLA.norm(ivec)
 46 | 
 47 |         else:
 48 |             ivec = [1,slope]
 49 |             ivec = N.array([float(ivec[0]),float(ivec[1])])
 50 |             ivec = ivec/SLA.norm(ivec)
 51 | 
 52 |             if slope>0 and xp1<0:
 53 |                 ivec[0] = -abs(ivec[0])
 54 |                 ivec[1] = -abs(ivec[1])
 55 | 
 56 |             if slope<0 and xp1<0:
 57 |                 ivec[0] = -abs(ivec[0])
 58 |                 ivec[1] = abs(ivec[1])
 59 | 
 60 |             if slope>0 and xp1>0:
 61 |                 ivec[0] = -abs(ivec[0])
 62 |                 ivec[1] = -abs(ivec[1])
 63 | 
 64 |             if slope<0 and xp1>xp0:
 65 |                 ivec[0] = abs(ivec[0])
 66 |                 ivec[1] = -abs(ivec[1])
 67 |                 
 68 |             if slope>0 and xp1>xp0:    
 69 |                 ivec[0] = abs(ivec[0])
 70 |                 ivec[1] = abs(ivec[1])
 71 | 
 72 |         rvec = (ivec-mm(2*mm(ivec,nvec),nvec))
 73 |         rvec = N.array([float(rvec[0]),float(rvec[1])])
 74 |         rvec = rvec/SLA.norm(rvec)
 75 |         v0 = v0*rvec
 76 |         vx = v0[0]
 77 |         vy0 = v0[1]
 78 |         x = Symbol('x')
 79 |         sol = solve(x**2 + (vy0/vx*(x-xp1)-g/2/vx**2*(x-xp1)**2+yp1)**2 - 1,x)
 80 | 
 81 |         for ii in range(len(sol)):
 82 |             if abs(re(sol[ii])-xp1)>1e-8 and abs(im(sol[ii]))<1e-4: 
 83 |                 soln = re(sol[ii])
 84 | 
 85 |         xi,xe = xp1,soln
 86 |         xp0 = xp1
 87 |         yp0 = yp1
 88 |         pathx = N.arange(xi,xe,dt*vx)
 89 |         pathy = vy0/vx*(pathx-xi)-g/2/vx**2*(pathx-xi)**2+yp1
 90 |         xs = Symbol('xs')
 91 |         slope = diff(vy0/vx*(xs-xi)-g/2/vx**2*(xs-xi)**2+yp1).evalf(subs={xs:xe})
 92 |         yp1 = vy0/vx*(xe-xi)-g/2/vx**2*(xe-xi)**2+yp1
 93 |         yp1 = float(yp1)
 94 |         xp1 = float(xe)
 95 |         slope = float(slope)
 96 |         Etot = g*(1+y0)
 97 |         Ep = g*(1+yp1)
 98 |         v0 = (2*(Etot-Ep))**.5
 99 |         ballpaths.append([pathx,pathy])
100 | 
101 |     return ballpaths
102 | 
103 | ball = []
104 | for ll in range(noballs):
105 |     print('ball',ll)
106 |     x0 = startposition+ll*eps 
107 |     y0 = .0
108 |     xp1 = x0
109 |     yp1 = -N.sqrt(1-xp1**2)
110 |     ds = N.sqrt((y0-yp1)**2)
111 |     t0 = N.sqrt(2*ds/g)
112 |     v0 = g*t0
113 |     xtot0,ytot0 = [],[]
114 |     tt = 0
115 | 
116 |     while dt*tt<t0:
117 |         ytot0.append(y0-g*(dt*tt)**2/2)
118 |         xtot0.append(x0)
119 |         tt+=1
120 | 
121 |     xtot,ytot = N.array(xtot0),N.array(ytot0)
122 |     ballpaths = []
123 |     p = findpaths(xp1,yp1,v0)
124 |     xtot = N.concatenate([xtot,p[0][0]])
125 |     ytot = N.concatenate([ytot,p[0][1]])
126 |     
127 |     for ii in range(1,jumps):
128 |         xtot = N.concatenate([xtot,p[ii][0]])
129 |         ytot = N.concatenate([ytot,p[ii][1]])
130 |     
131 |     ball.append([xtot,ytot])
132 | 
133 | print('All ball paths are calculated')
134 | 
135 | for ii in range(len(xtot)):
136 |     print(ii,'of',len(xtot))
137 |     plt.plot(mycircle[0],mycircle[1])
138 |     plt.gca().set_aspect('equal')
139 |     for bb in range(noballs):
140 |         plt.plot(ball[bb][0][ii],ball[bb][1][ii],marker='.')
141 |     plt.savefig('frames/fig'+f"{ii:05d}.png",bbox_inches='tight',pad_inches=0)
142 |     plt.clf()
143 | 
144 | 


--------------------------------------------------------------------------------
/softbody.py:
--------------------------------------------------------------------------------
  1 | import numpy as np
  2 | import matplotlib.pyplot as plt
  3 | import os
  4 | 
  5 | path = 'frames'
  6 | os.system(f'mkdir {path}')
  7 | 
  8 | # parameters
  9 | N = 8                                       # grid size (N x N)
 10 | mass = 0.05                         
 11 | spring_k = 100.0                            # spring constant
 12 | spring_k_diagonal = spring_k / 2            # diagonal spring constant (smaller)
 13 | damping = 0.5                               # low damping = more jello
 14 | rest_length = 1.0                           
 15 | rest_length_diag = np.sqrt(2) * rest_length
 16 | time_step = 0.01                            # if unstable, try smaller dt 
 17 | num_steps = 1000                            # number of time steps
 18 | gravity = np.array([0, -9.81])
 19 | floor_y = 0                                 # floor y coordinate  
 20 | restitution = 0.75 
 21 | friction_coefficient = 100
 22 | yshift = 6                                  # sets height where body is dropped
 23 | 
 24 | # initialize positions
 25 | positions = np.array([(i, j) for i in range(N) for j in range(N)], dtype=np.float64)
 26 | positions[:, 1] += yshift
 27 | velocities = np.zeros_like(positions)
 28 | 
 29 | def find_neighbors(index):
 30 |     neighbors = {'ortho': [], 'diag': []}
 31 |     x, y = index % N, index // N
 32 |     for dx in [-1, 0, 1]:
 33 |         for dy in [-1, 0, 1]:
 34 |             if dx == 0 and dy == 0:
 35 |                 continue  
 36 |             nx, ny = x + dx, y + dy
 37 |             if 0 <= nx < N and 0 <= ny < N:
 38 |                 if dx == 0 or dy == 0:
 39 |                     neighbors['ortho'].append(ny * N + nx)
 40 |                 else:
 41 |                     neighbors['diag'].append(ny * N + nx)
 42 |     return neighbors
 43 | 
 44 | def compute_spring_forces(positions):
 45 |     forces = np.zeros_like(positions)
 46 |     for i, pos in enumerate(positions):
 47 |         neighbors = find_neighbors(i)
 48 |         for j in neighbors['ortho']:
 49 |             direction = positions[j] - pos
 50 |             distance = np.linalg.norm(direction)
 51 |             if distance > 0:
 52 |                 force_magnitude = spring_k * (distance - rest_length)
 53 |                 force = (direction / distance) * force_magnitude
 54 |                 forces[i] += force
 55 |                 forces[j] -= force  # Newton's third law
 56 |         for j in neighbors['diag']:
 57 |             direction = positions[j] - pos
 58 |             distance = np.linalg.norm(direction)
 59 |             if distance > 0:
 60 |                 force_magnitude = spring_k_diagonal * (distance - rest_length_diag)
 61 |                 force = (direction / distance) * force_magnitude
 62 |                 forces[i] += force
 63 |                 forces[j] -= force
 64 |     return forces
 65 | 
 66 | def compute_damping_forces(positions, velocities):
 67 |     forces = np.zeros_like(positions)
 68 |     for i, pos in enumerate(positions):
 69 |         neighbors = find_neighbors(i)
 70 |         for j in neighbors['ortho'] + neighbors['diag']:
 71 |             relative_velocity = velocities[i] - velocities[j]
 72 |             damping_force = damping * relative_velocity
 73 |             forces[i] -= damping_force / len(neighbors['ortho'] + neighbors['diag'])
 74 |     return forces
 75 | 
 76 | def floor_collision(positions, velocities):
 77 |     for i, (x, y) in enumerate(positions):
 78 |         if y < floor_y:                                             # collision detection
 79 |             positions[i, 1] = floor_y                               # reset y position to floor level
 80 |             if velocities[i, 1] < 0:                                # only reverse velocity if it's moving towards the floor
 81 |                 velocities[i, 1] = -velocities[i, 1] * restitution  # bounce effect
 82 |             
 83 |             normal_force = mass * abs(gravity[1])                   # normal force due to gravity
 84 |             friction_force_magnitude = friction_coefficient * normal_force
 85 |             velocity_magnitude = np.linalg.norm(velocities[i])
 86 |             
 87 |             if velocity_magnitude > 1e-5:
 88 |                 friction_force = friction_force_magnitude * (velocities[i] / velocity_magnitude)
 89 |                 velocities[i] -= friction_force * time_step
 90 | 
 91 | for step in range(num_steps):
 92 |     print(f'{step}/{num_steps} done')
 93 |     spring_forces = compute_spring_forces(positions)
 94 |     damping_forces = compute_damping_forces(positions, velocities)
 95 |     total_forces = spring_forces + damping_forces + mass * gravity
 96 |     velocities += (total_forces / mass) * time_step
 97 |     positions += velocities * time_step
 98 |     floor_collision(positions, velocities)
 99 |     
100 |     fig, ax = plt.subplots()
101 |     plt.scatter(positions[:, 0], positions[:, 1], color='blue', s=10)   # draw balls
102 |     plt.plot([-16, N+15], [floor_y, floor_y], 'black')                  # draw floor
103 |     plt.xlim(-16, N+15)
104 |     plt.ylim(-16, N+15)
105 |     plt.savefig(f'{path}/frame_{step:05}.png', bbox_inches='tight', pad_inches=0)
106 |     plt.close("fig")
107 | 


--------------------------------------------------------------------------------
/stringart.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | 
  3 | import numpy as N
  4 | import matplotlib.pyplot as plt
  5 | import matplotlib as mpl
  6 | import random, time, sys, os
  7 | import argparse
  8 | from PIL import Image, ImageOps, ImageFilter, ImageEnhance
  9 | 
 10 | T, F = True, False
 11 | 
 12 | class stringart:
 13 | 	def __init__(self,scalefactor,weight,lines,linewidth,\
 14 | 		invertimage,contour,autosaturation,resolution,image_path):
 15 | 		
 16 | 		self.scalefactor = scalefactor
 17 | 		self.weight = weight
 18 | 		self.lines = lines
 19 | 		self.linewidth = linewidth
 20 | 		self.invertimage = invertimage
 21 | 		self.contour = contour
 22 | 		self.autosaturation = autosaturation
 23 | 		self.resolution = resolution
 24 | 		self.image_path = image_path
 25 | 		
 26 | 	def prepareimage(self):
 27 | 		image = Image.open(self.image_path)
 28 | 		image = ImageOps.grayscale(image)
 29 | 		image = N.array(image)
 30 | 		image = image/N.max(image)
 31 | 		inputimage = image
 32 | 		if self.invertimage == 'True':
 33 | 			image = 1 - image
 34 | 						
 35 | 		dimension = N.min([N.shape(image)[0],N.shape(image)[1]])		
 36 | 		importedimage = image[:dimension,:dimension]
 37 | 
 38 | 		if self.scalefactor == None:
 39 | 			sf = int(dimension/90)
 40 | 		else:
 41 | 			sf = self.scalefactor
 42 | 		#sf = self.scalefactor
 43 | 		newdim = int(dimension/sf)
 44 | 		sampledimage = N.zeros((newdim,newdim))
 45 | 		for ii in range(newdim):
 46 | 			for jj in range(newdim):
 47 | 				sampledimage[ii,jj] = N.mean(importedimage[sf*ii:sf*(ii+1),sf*jj:sf*(jj+1)])
 48 | 
 49 | 		self.sf = sf
 50 | 		image = sampledimage
 51 | 		dimension = newdim		
 52 | 
 53 | 		return image, dimension, inputimage
 54 | 
 55 | 	def circumferencecoordinates(self,image,dim):
 56 | 		circumference = N.zeros((dim,dim))
 57 | 		circumference_coords = []
 58 | 		# circle
 59 | 		if self.contour == 1:
 60 | 			for ii in range(dim):
 61 | 				for jj in range(dim):
 62 | 					circ1 = (ii-int(dim/2))**2+(jj-int(dim/2))**2
 63 | 					circ2 = (ii-int(dim/2))**2+(jj-int(dim/2))**2 + dim
 64 | 
 65 | 					if circ1 >= int(dim/2)**2:
 66 | 						image[ii,jj] = 0
 67 | 						
 68 | 					if circ1 < int(dim/2)**2 and circ2 >= int(dim/2)**2:
 69 | 						circumference[ii,jj] = 1
 70 | 						circumference_coords.append([ii,jj])
 71 | 		# rectangle
 72 | 		if self.contour == 2:
 73 | 			circumference_coords = []
 74 | 			for ii in range(dim):
 75 | 				for jj in range(dim):
 76 | 					if ii == 0 or jj == 0 or ii == dim-1 or jj == dim-1:
 77 | 						circumference_coords.append([ii,jj])
 78 | 		
 79 | 		return circumference_coords
 80 | 
 81 | 	# apply one-pixel padding (for computational purposes)
 82 | 	def pad_matrix(self,matrix):
 83 | 		original_height, original_width = matrix.shape
 84 | 		padded_matrix = N.zeros((original_height + 2, original_width + 2), dtype=float)
 85 | 		padded_matrix[1:original_height + 1, 1:original_width + 1] = matrix
 86 | 
 87 | 		return padded_matrix
 88 | 
 89 | 	def getlinecoordinates(self, p1, p2, dim):
 90 | 		highlight_color = 1
 91 | 		mat = N.zeros((dim,dim))
 92 | 		x1, y1 = p1
 93 | 		x2, y2 = p2
 94 | 		dx = abs(x2 - x1)
 95 | 		dy = -abs(y2 - y1)
 96 | 		sx = 1 if x1 < x2 else -1
 97 | 		sy = 1 if y1 < y2 else -1
 98 | 		error = dx + dy
 99 | 
100 | 		while True:
101 | 			mat[x1, y1] = highlight_color  # Color the element
102 | 			if x1 == x2 and y1 == y2:
103 | 			    break
104 | 			e2 = 2 * error
105 | 			if e2 >= dy:
106 | 				error += dy
107 | 				x1 += sx
108 | 			if e2 <= dx:
109 | 				error += dx
110 | 				y1 += sy
111 | 		mat = mat.T
112 | 
113 | 		return mat
114 | 
115 | 
116 | 	def choosepair(self,idx, jjpair, pairs_list, jjlinemat):
117 | 		kk = 0
118 | 		while jjpair[idx[kk]] in pairs_list:
119 | 			kk += 1
120 | 			pass
121 | 
122 | 		return kk
123 | 
124 | 	def calculatestrings(self):
125 | 		image,dim = self.prepareimage()[:2]
126 | 		circumference_coords = self.circumferencecoordinates(image,dim)
127 | 		image = self.pad_matrix(image)
128 | 		if self.scalefactor == None:
129 | 			print(f'Calculated scalefactor:		{self.sf}')	
130 | 			print(f'Dimensions, prepared image: 	{dim}x{dim} pixels (set -SF flag manually for other dimensions)')
131 | 		else:
132 | 			print(f'Dimensions, prepared image: 	{dim}x{dim} pixels')
133 | 		dim = dim + 2
134 | 		nocoords = len(circumference_coords) # number of coords on circumference
135 | 		rint = random.randint(0,nocoords-1)  # random starting coordinate
136 | 		print(f'Circumference elements:		{nocoords} coordinates (recommended 250-500)\n')
137 | 		
138 | 		linemat = N.zeros((dim,dim))
139 | 		linecoords = []
140 | 		linecoordsmat = []
141 | 		diff = []
142 | 		pairs = []
143 | 		t1 = time.process_time()
144 | 
145 | 		for ii in range(self.lines):
146 | 			magnitudevec = [] # how much the presently lined image differs from image
147 | 			jjlinemat = []     
148 | 			jjidx = []
149 | 			jjpair = []	
150 | 			pi = circumference_coords[rint]
151 | 
152 | 			for jj in range(nocoords):
153 | 				pf = circumference_coords[jj]
154 | 				if N.sqrt((pi[0]-pf[0])**2 + (pi[1]-pf[1])**2) > 1:
155 | 					tmplinemat = linemat + self.weight*self.getlinecoordinates(pi,pf,dim)
156 | 					magnitudevec.append(N.sqrt(N.mean((image-tmplinemat)**2)))
157 | 					jjlinemat.append(tmplinemat)
158 | 					jjpair.append([pi,pf])
159 | 					jjidx.append(jj)
160 | 
161 | 			magnitudevec = N.array(magnitudevec)
162 | 			idx = N.argsort(magnitudevec)
163 | 			magnitudevec = magnitudevec[idx]
164 | 			
165 | 			if ii == 0:
166 | 				pair = jjpair[idx[0]]
167 | 				pairs.append(pair)
168 | 			else:
169 | 				kk = self.choosepair(idx,jjpair,pairs,jjlinemat)
170 | 				pairs.append(jjpair[idx[kk]])
171 | 				linemat = jjlinemat[idx[kk]]
172 | 				linecoords.append(jjpair[idx[kk]])
173 | 				rint = jjidx[idx[kk]]
174 | 				
175 | 			diff.append(N.sqrt(N.mean((image-linemat)**2)))
176 | 			
177 | 			if self.autosaturation == 'True':
178 | 				if len(diff) > 200:
179 | 					if abs(diff[100] - diff[0]) > 100*abs(diff[-1] - diff[-100]):
180 | 						print('autosaturation chosen (-AS True); generation stopped.')
181 | 						break
182 | 
183 | 			if ii % int(self.lines/25) == 0:
184 | 				print(f'{round(ii/(self.lines)*100)}% done ({ii} of {self.lines} lines), diff: {round(magnitudevec[idx[0]],3)}')
185 | 
186 | 		return linecoords, diff, image
187 | 
188 | 
189 | 
190 | import argparse
191 | 
192 | flags = [
193 |     {'name': 'scalefactor', 'short': '-sf', 'long': '--scalefactor', 'type': int, 'metavar': '', 'help': 'Downsampling factor of the original image. Recommended sampling should be such that the image is just above 100x100 pixels. If not specified, calculation will proceed with an estimated value.', 'default': None},
194 |     {'name': 'weight', 'short': '-wt', 'long': '--weight', 'type': float, 'metavar': '', 'help': 'Parameter used upon minimization between lines and image. Elaboration with values between 0.02 and 0.5 is recommended. Larger weight = faster saturation (with possibly worse result).', 'default': 0.02},
195 |     {'name': 'lines', 'short': '-ls', 'long': '--lines', 'type': int, 'metavar': '', 'help': 'Maximum number of lines used to generate the string art.', 'default': 3000},
196 |     {'name': 'linewidth', 'short': '-lw', 'long': '--linewidth', 'type': float, 'metavar': '', 'help': 'String linewidth.', 'default': 0.1},
197 |     {'name': 'invertimage', 'short': '-ii', 'long': '--invertimage', 'metavar': '', 'help': 'Invert image; True or False', 'default': 'True'},
198 |     {'name': 'contour', 'short': '-co', 'long': '--contour', 'type': int, 'metavar': '', 'help': 'Choose between circle (1) or square (2) as contour.', 'default': 1},
199 |     {'name': 'autosaturation', 'short': '-as', 'long': '--autosaturation', 'metavar': '', 'help': 'Auto finish string art upon reaching calculated saturation.', 'default': 'True'},
200 |     {'name': 'resolution', 'short': '-res', 'long': '--resolution', 'type': str, 'metavar': '', 'help': 'Approximate resolution of the final image. Choose between 4k (~2160x2160), HD (~1080x1080), and VGA (~540x540)', 'default': 'HD'},
201 |     {'name': 'image_path', 'short': '-img', 'long': '--image_path', 'type': str, 'metavar': '', 'help': 'Path to the image file. If the script and image are in the same folder, just type the filename + extension.', 'default': ''}
202 | ]
203 | 
204 | parser = argparse.ArgumentParser(description="The script aims to draw a string art representation of an imported image.\
205 |     Elaboration with the flag parameters may likely be needed depending on your input image. The default flag settings \
206 |     appear performing decently on portraits.")
207 | 
208 | 
209 | for flag in flags:    
210 |     if 'type' in flag and flag['type'] != bool:
211 |         parser.add_argument(flag['short'], flag['long'], dest=flag['name'], metavar=flag['metavar'], type=flag['type'], help=f"{flag['help']} (default = {flag['default']})", default=flag['default'])
212 |     else:
213 |         parser.add_argument(flag['short'], flag['long'], dest=flag['name'], metavar=flag['metavar'], help=f"{flag['help']} (default = {flag['default']})", default=flag['default'])
214 | args = parser.parse_args()
215 | print("Chosen options:")
216 | for flag in flags:
217 | 	if getattr(args, flag['name']) == None:
218 | 	    print(f"{flag['name'].capitalize()} ({flag['short']}): Not specified")
219 | 	else:
220 | 	    print(f"{flag['name'].capitalize()} ({flag['short']}): {getattr(args, flag['name'])}")
221 | if args.image_path:
222 |     if os.path.exists(args.image_path) and os.path.isfile(args.image_path):
223 |         print(f"\nTreating image: {args.image_path}")
224 |     else:
225 |         print(f"Invalid image path: {args.image_path}\n")
226 |         sys.exit(0)
227 | else:
228 |     print("\nYou must specify image path.\n")
229 |     sys.exit(0)
230 | 
231 | sa = stringart(	args.scalefactor, 
232 | 				args.weight,
233 | 				args.lines,
234 | 				args.linewidth,
235 | 				args.invertimage, 
236 | 				args.contour,
237 | 				args.autosaturation,
238 | 				args.resolution,
239 | 				args.image_path)
240 | 
241 | image, dim, inputimage = sa.prepareimage()
242 | inputdimension = N.min([N.shape(inputimage)[0],N.shape(inputimage)[1]])
243 | print(f'Input image dimensions 		{N.shape(inputimage)[0]}x{N.shape(inputimage)[1]}')
244 | print(f'Input image trimmed dim. 	{inputdimension}x{inputdimension}')
245 | 
246 | circ_coords = N.array(sa.circumferencecoordinates(image,dim)).T
247 | t1 = time.process_time()
248 | 
249 | linecoords, diff, image = sa.calculatestrings()
250 | 
251 | t2 = time.process_time()
252 | linecoords = N.array(linecoords)
253 | 
254 | print(f'\nGeneration time: {round(t2-t1,1)} s.')
255 | print(f'Strings used: {len(linecoords)}')
256 | 
257 | original_image_path = args.image_path
258 | filename, extension = os.path.splitext(os.path.basename(original_image_path))
259 | 
260 | singlelinex = [linecoords[ii].T[0] for ii in range(len(linecoords))]
261 | singleliney = [linecoords[ii].T[1] for ii in range(len(linecoords))]
262 | 
263 | resolutions = {'4k':1,'HD':2,'VGA':4}
264 | chosenres = [resolutions.get(sa.resolution,1) if sa.resolution in resolutions else 2][0]
265 | if sa.resolution not in resolutions:
266 | 	print('Invalid resolution chosen: Default HD res applied')
267 | yr = 28.2/chosenres
268 | xr = yr
269 | mpl.rcParams['figure.figsize'] = xr,yr
270 | 
271 | fig, ax = plt.subplots()
272 | sa.invertimage = sa.invertimage.lower() == 'true'
273 | fig.patch.set_facecolor('white' if sa.invertimage else 'black')
274 | line_color = 'black' if sa.invertimage else 'white'
275 | plt.plot(singlelinex, singleliney, '-', color=line_color, linewidth=sa.linewidth)
276 | 
277 | plt.gca().invert_yaxis()
278 | plt.gca().set_aspect('equal')
279 | ax.axis("off")
280 | plt.gca().xaxis.set_major_locator(plt.NullLocator())
281 | plt.gca().yaxis.set_major_locator(plt.NullLocator())
282 | plt.savefig(f'stringart_{filename}.jpg', bbox_inches='tight', pad_inches=0)
283 | print(f'\nProgram finished. Image stringart_{filename}.png saved.\n')
284 | 
285 | 


--------------------------------------------------------------------------------