Category: Software

Setting n2=n3=1.5 generates smoothly rounded shapes, rather than the spiky ones produced by n2=n3=1.0, so I combined the two into a single demo routine:

A closer look shows all the curves meet at the points, of which there are 37:

The spikes suffer from limited resolution: each curve has 10 k points, but if the extreme end of a spike lies between two points, then it gets blunted on the page. Doubling the number of points would help, although I think this has already gone well beyond the, ah, point of diminishing returns.

I used the three remaining “disposable” liquid ink pens for the spiked curves; the black pen was beyond repair. They produce gorgeous lines, although the magenta ink seems a bit thinned out by the water I used to rinse the remains of the last refill out of the spiral vent channel.

I modified the Chiplotle supershape() function to default to my choices for point_count and travel, then copied the superformula() function and changed it to return polar coordinates, because I’ll eventually try scaling the linear value as a function of the total angle, which is much easier in polar coordinates.

The demo code produces the patterns in the picture by iterating over interesting values of n1 and n2=n3, stepping through the pen carousel for each pattern. As before, m should be prime/10 to produce a prime number of spikes / bumps. You could add more iteration values, but six of ’em seem entirely sufficient.

A real demo should include a large collection of known-good parameter sets, from which it can pick six sets to make a plot. A legend documenting the parameters for each pattern, plus the date & time, would bolster the geek cred.

The Python source code with the modified Chiplotle routines:

from chiplotle import *
from math import *

def superformula_polar(a, b, m, n1, n2, n3, phi):
   ''' Computes the position of the point on a
   superformula curve.
   Superformula has first been proposed by Johan Gielis
   and is a generalization of superellipse.
   see: http://en.wikipedia.org/wiki/Superformula
   Tweaked to return polar coordinates
   '''

   t1 = cos(m * phi / 4.0) / a
   t1 = abs(t1)
   t1 = pow(t1, n2)

   t2 = sin(m * phi / 4.0) / b
   t2 = abs(t2)
   t2 = pow(t2, n3)

   t3 = -1 / float(n1)
   r = pow(t1 + t2, t3)
   if abs(r) == 0:
      return (0,0)
   else:
 #     return (r * cos(phi), r * sin(phi))
     return (r,phi)

def supershape(width, height, m, n1, n2, n3,
   point_count=10*1000, percentage=1.0, a=1.0, b=1.0, travel=None):
   '''Supershape, generated using the superformula first proposed
   by Johan Gielis.

   - `points_count` is the total number of points to compute.
   - `travel` is the length of the outline drawn in radians.
      3.1416 * 2 is a complete cycle.
   '''
   travel = travel or (10*2*pi)

   ## compute points...
   phis = [i * travel / point_count
      for i in range(1 + int(point_count * percentage))]
   points = [superformula_polar(a, b, m, n1, n2, n3, x) for x in phis]

   ## scale and transpose...
   path = [ ]
   for r, a in points:
      x = width * r * cos(a)
      y = height * r * sin(a)
      path.append(Coordinate(x, y))

   return Path(path)

## RUN DEMO CODE

if __name__ == '__main__':
   paperx = 8000
   papery = 5000
   if  not False:
     plt=instantiate_plotters()[0]
     plt.set_origin_center()
     plt.write(hpgl.VS(10))
     pen = 1
     for m in [3.7]:
        for n1 in [0.20, 0.60, 0.8]:
          for n2 in [1.0, 1.5]:
              n3 = n2
              e = supershape(paperx, papery, m, n1, n2, n3)
              plt.select_pen(pen)
              if pen < 6:
                 pen += 1
              else:
                 pen = 1
              plt.write(e)
     plt.select_pen(0)
   else:
     e = supershape(paperx, papery, 1.9, 0.8, 3, 3)
     io.view(e)

Although the Superformula can produce a bewildering variety of patterns, I wanted to build an automated demo that plotted interesting sets of similar results. Herewith, some notes after an evening of fiddling around with the machinery.

Starting with the original Chiplotle formula, tweaked for B size paper:

ss=geometry.shapes.supershape(8000,5000,5.3,0.4,1,1,point_count=1+10*1000,travel=10.001*2*math.pi)

The first two parameters set the more-or-less maximum X and Y values in plotter units; the plot is centered at zero and will extend that far in both the positive and negative directions. For US paper:

• A = Letter = 11 x 8½ inch → 4900 x 3900
• B = 17 x 11 inch → 8000 x 5000

The point_count parameter defines the number of points to be plotted for the entire figure. They’re uniformly distributed in angle, not in distance, so some parts of the figure will plot very densely and others sparsely, but the plotter will connect all of the points with straight lines and it’ll look reasonably OK. For the figures below, 10*1000 works well.

The travel value defines the number of full cycles that the figure will make, in units of 2π. Ten cycles seems about right.

The four parameters in between those are the m, n1, n2, and n3 values plugged directly into the basic Superformula. The latter two are exponents of the trig terms; 1.0 seems less bizarre than anything else.

Sooo, that leaves only two knobs…

With travel set for 10 full cycles, m works best when set to a value that’s equal to prime/10, which produces prime points around the figure. Thus, if you want 11 points, use m=1.1 and for 51 points, use m=5.1. Some non-prime numbers produce useful patterns (as below), others collapse into just a few points.

The n1 parameter is an overall exponent for the whole formula in the form -1/n1. Increasing values, from 0.1 to about 2.0, expand the innermost points of the pattern outward and turn the figure into more of a ring and less of a lattice.

So, for example, with m=3.1, setting n1= 0.15, 0.30, 0.60 produces this pattern with 31 points:

Varying both at once, thusly:
(m,n1) = (1.9,0.20)=green (3.7,0.30)=red (4.9,0.40)=blue
produces this pattern:

Yeah, 49 isn’t a prime number. It’s interesting, though.

Note that n1 doesn’t set the absolute location of the innermost points; you must see how it interacts with m before leaping to any conclusions.

It’s still not much in the way of Art, but it does keep the plotter chugging along for quite a while and that’s the whole point. I must yank the functions out of the Chiplotle library, set my default values, add one point to automagically close the last vertex, and maybe convert them to polar coordinates to adjust the magnitude as a function of angle.

Yes, that poor green ceramic-tip pen is running out of ink after all these decades.