Aptus is a Mandelbrot set viewer and renderer. It is written in Python 9 | with a computation engine in C for speed. 10 |
11 | 12 |
14 | Getting Aptus
18 | 19 |Installation
20 | 21 |Aptus requires Python 3.9 or greater.
22 | 23 |Use pip to install Aptus. The web interface requires the "web" extra:
24 | 25 |python3.9 -m pip install "aptus[web]"
26 |
27 | Source
28 | 29 |The source is available on 30 | GitHub if you prefer direct access to the code, including recent 31 | changes.
32 | 33 | 34 |Using Aptus
35 | 36 |There are two ways to use Aptus: a browser-based explorer, and a command line 37 | renderer. There is also an older GUI which doesn't work as well as it used to, 38 | but has more features than the browser interface. The browser and GUI let you 39 | zoom in and out, and change the color palette to find an image you like. The 40 | command line renderer produces higher-quality images.
41 | 42 |Web interface
43 | 44 |To launch the web interface, use the "aptusweb" command. It starts a local 45 | web server on http://127.0.0.1:8042. Open 46 | that URL in your browser, and you should see a Mandelbrot set.
47 | 48 |Hitting the "?" key will bring up a help panel, but briefly, click to zoom 49 | in, shift-click to zoom out. Dragging will move the image around, and 50 | shift-dragging will select a new rectangle to view.
51 | 52 |The "s" key will render a downloadable image with super-sampling for higher 53 | quality.
54 | 55 |Parameter files
56 | 57 |When saving an image as a .PNG file, Aptus also stores all its parameter 58 | information in a text block hidden in the image, so that the .PNG can be used 59 | directly as a parameter file for the command line renderer.
60 | 61 |GUI usage
62 | 63 |The GUI interface runs with the "aptusgui" command. Details of how to use it 64 | are on the older Aptus page.
65 | 66 | 67 |Command line usage
68 | 69 |The command line renderer is called "aptuscmd". It will accept a number of 70 | switches or parameter files: 71 |
72 | 73 |
74 | Usage: aptuscmd [options] [parameterfile]
75 |
76 | Aptus renders Mandelbrot set images. Three flavors are available: aptusweb and
77 | aptusgui for interactive exploration, and aptuscmd for high-quality rendering.
78 |
79 | Options:
80 | -h, --help show this help message and exit
81 | -a ANGLE, --angle=ANGLE
82 | set the angle of rotation
83 | --center=RE,IM set the center of the view
84 | -c, --continuous use continuous coloring
85 | --diam=DIAM set the diameter of the view
86 | -i ITER_LIMIT, --iterlimit=ITER_LIMIT
87 | set the limit on the iteration count
88 | -o OUTFILE, --output=OUTFILE
89 | set the output filename (aptuscmd only)
90 | --phase=PHASE set the palette phase
91 | --pscale=SCALE set the palette scale
92 | -s WIDxHGT, --size=WIDxHGT
93 | set the pixel size of the image
94 | --super=S set the supersample rate (aptuscmd only)
95 |
96 |
97 |
98 | More samples
99 | 100 |104 |
15 |
19 |
20 | {% set altnote -%}
21 | *
22 | {%- endset %}
23 |
24 | {% set alt -%}
25 | altoption
26 | {%- endset %}
27 |
28 | {% set closebtn -%}
29 |
16 | Rendering...
17 |
18 | {% include "icon_close.svg" %}
30 | {%- endset %}
31 |
32 |
33 | {{closebtn}}
34 |
37 |
38 | Aptus Mandelbrot explorer.
35 |Type ? for help.
36 |
39 | {{closebtn}}
40 |
78 |
79 | Aptus {{version}}, Mandelbrot set explorer.
41 | 42 |Copyright 2007-2024, Ned Batchelder.
43 |
http://nedbatchelder.com/code/aptus/v3.html
44 |
47 | a set the angle
48 | c toggle continuous coloring
49 | F toggle full-screen
50 | i set the iteration limit
51 | I toggle the computation parameters panel
52 | L display a permalink
53 |
54 | r redraw
55 | R reset everything
56 | s render and save a super-sampled image
57 | U upload a file
58 | w set the canvas size
59 | ( ) rotate the angle {{altnote}}
60 | < > cycle through palettes
61 | , . cycle the palette one color
62 | ; ' stretch the colors, if continuous {{altnote}}
63 | [ ] adjust the hue {{altnote}}
64 | { } adjust the saturation {{altnote}}
65 | - = adjust the lightness {{altnote}}
66 | 0 (zero) reset all color adjustments
67 | ? toggle help panel
68 |
70 | click: zoom in {{altnote}}
71 | shift-click: zoom out {{altnote}}
72 | drag: pan the view
73 | shift-drag: select new view area
74 |
75 | {{altnote}} +{{alt}}: just a little
76 |
80 | {{closebtn}}
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 | {{closebtn}}
90 |
91 |
97 |
98 | 92 |
93 |
94 | 95 | 96 |
99 | {{closebtn}}
100 |
101 |
102 |
103 |
104 |
105 |
106 | {{closebtn}}
107 |
108 |
109 |
110 |
111 | {{closebtn}}
112 |
114 |
115 | UPLOAD
113 |
116 | {{closebtn}}
117 |
118 |
119 |
120 |
123 |
124 |
--------------------------------------------------------------------------------
/lab/boundary.py:
--------------------------------------------------------------------------------
1 | """ A boundary trace function for Mandelbrot computation.
2 | """
3 |
4 | import numpy
5 |
6 | def trace_boundary(count_fn, w, h, maxiter, threshold=10000, progress_fn=None):
7 | """ Compute counts for pixels, using a boundary trace technique.
8 | count_fn(x,y) returns the iteration count for a pixel.
9 | Returns a numpy array w by h with iteration counts for each pixel.
10 | Threshold is the minimum count that triggers a boundary trace. Below
11 | this, the expense of the trace outweighs simply computing each pixel.
12 | """
13 |
14 | DOWN, LEFT, UP, RIGHT = range(4)
15 | turn_right = [LEFT, UP, RIGHT, DOWN]
16 | turn_left = [RIGHT, DOWN, LEFT, UP]
17 | counts = numpy.zeros((h, w), dtype=numpy.uint32)
18 | status = numpy.zeros((h, w), dtype=numpy.uint8)
19 | num_trace = 0
20 | num_pixels = 0
21 | total_pixels = h * w
22 |
23 | for yi in xrange(h):
24 | for xi in xrange(w):
25 | s = status[yi,xi]
26 | if s == 0:
27 | c = count_fn(xi, -yi)
28 | counts[yi,xi] = c
29 | num_pixels += 1
30 | status[yi,xi] = s = 1
31 | else:
32 | c = counts[yi,xi]
33 |
34 | comp_c = c or maxiter
35 | if s == 1 and comp_c >= threshold:
36 | # Start a boundary trace.
37 | status[yi,xi] = 2
38 | curdir = DOWN
39 | curx, cury = xi, yi
40 | orig_pt = (xi, yi)
41 | lastx, lasty = xi, yi
42 | start = True
43 | points = []
44 |
45 | # Find all the points on the boundary.
46 | while True:
47 |
48 | # Eventually, we reach our starting point. Stop.
49 | if not start and (curx,cury) == orig_pt and curdir == DOWN:
50 | break
51 |
52 | # Move to the next position. If we're off the field, turn left.
53 | if curdir == DOWN:
54 | if cury >= h-1:
55 | curdir = RIGHT
56 | continue
57 | cury += 1
58 | elif curdir == LEFT:
59 | if curx <= 0:
60 | curdir = DOWN
61 | continue
62 | curx -= 1
63 | elif curdir == UP:
64 | if cury <= 0:
65 | curdir = LEFT
66 | continue
67 | cury -= 1
68 | elif curdir == RIGHT:
69 | if curx >= w-1:
70 | curdir = UP
71 | continue
72 | curx += 1
73 |
74 | # Get the count of the next position
75 | if status[cury,curx] == 0:
76 | c2 = count_fn(curx, -cury)
77 | counts[cury,curx] = c2
78 | num_pixels += 1
79 | status[cury,curx] = 1
80 | else:
81 | c2 = counts[cury,curx]
82 |
83 | # If the same color, turn right, else turn left.
84 | if c2 == c:
85 | status[cury,curx] = 2
86 | points.append((curx,cury))
87 | lastx, lasty = curx, cury
88 | curdir = turn_right[curdir]
89 | else:
90 | curx, cury = lastx, lasty
91 | curdir = turn_left[curdir]
92 |
93 | start = False
94 |
95 | if points:
96 | num_trace += 1
97 |
98 | # Now flood fill the region. The points list has all the boundary
99 | # points, so we only need to fill left and right from each of those.
100 | for ptx, pty in points:
101 | curx = ptx
102 | while True:
103 | curx -= 1
104 | if curx < 0:
105 | break
106 | if status[pty,curx] != 0:
107 | break
108 | counts[pty,curx] = c
109 | num_pixels += 1
110 | status[pty,curx] = 2
111 | curx = ptx
112 | while True:
113 | curx += 1
114 | if curx > w-1:
115 | break
116 | if status[pty,curx] != 0:
117 | break
118 | counts[pty,curx] = c
119 | num_pixels += 1
120 | status[pty,curx] = 2
121 |
122 | progress_fn(float(num_pixels)/total_pixels, info='trace %d' % c)
123 |
124 | progress_fn(float(num_pixels)/total_pixels, info='scan %d' % (yi+1))
125 |
126 | print "Traced %s boundaries" % num_trace
127 | return counts
128 |
--------------------------------------------------------------------------------
/src/aptus/ggr.py:
--------------------------------------------------------------------------------
1 | """ Read Gimp .ggr gradient files.
2 | Ned Batchelder, http://nedbatchelder.com
3 | This code is in the public domain.
4 | """
5 |
6 | __version__ = '1.0.20070915'
7 |
8 | import colorsys
9 | import math
10 |
11 |
12 | class GimpGradient:
13 | """ Read and interpret a Gimp .ggr gradient file.
14 | """
15 | def __init__(self, f=None):
16 | if f:
17 | self.read(f)
18 |
19 | class _segment:
20 | pass
21 |
22 | def read(self, f):
23 | """ Read a .ggr file from f (either an open file or a file path).
24 | """
25 | if isinstance(f, str):
26 | f = open(f)
27 | if f.readline().strip() != "GIMP Gradient":
28 | raise IOError("Not a GIMP gradient file")
29 | line = f.readline().strip()
30 | if not line.startswith("Name: "):
31 | raise IOError("Not a GIMP gradient file")
32 | self.name = line.split(": ", 1)[1]
33 | nsegs = int(f.readline().strip())
34 | self.segs = []
35 | for dummy in range(nsegs):
36 | line = f.readline().strip()
37 | seg = self._segment()
38 | (seg.l, seg.m, seg.r,
39 | seg.rl, seg.gl, seg.bl, _,
40 | seg.rr, seg.gr, seg.br, _,
41 | seg.fn, seg.space) = map(float, line.split())
42 | self.segs.append(seg)
43 |
44 | def color(self, x):
45 | """ Get the color for the point x in the range [0..1).
46 | The color is returned as an rgb triple, with all values in the range
47 | [0..1).
48 | """
49 | # Find the segment.
50 | for s in self.segs:
51 | if s.l <= x <= s.r:
52 | seg = s
53 | break
54 | else:
55 | # No segment applies! Return black I guess.
56 | return (0,0,0)
57 |
58 | # Normalize the segment geometry.
59 | mid = (seg.m - seg.l)/(seg.r - seg.l)
60 | pos = (x - seg.l)/(seg.r - seg.l)
61 |
62 | # Assume linear (most common, and needed by most others).
63 | if pos <= mid:
64 | f = pos/mid/2
65 | else:
66 | f = (pos - mid)/(1 - mid)/2 + 0.5
67 |
68 | # Find the correct interpolation factor.
69 | if seg.fn == 1: # Curved
70 | f = math.pow(pos, math.log(0.5) / math.log(mid))
71 | elif seg.fn == 2: # Sinusoidal
72 | f = (math.sin((-math.pi/2) + math.pi*f) + 1)/2
73 | elif seg.fn == 3: # Spherical increasing
74 | f -= 1
75 | f = math.sqrt(1 - f*f)
76 | elif seg.fn == 4: # Spherical decreasing
77 | f = 1 - math.sqrt(1 - f*f)
78 |
79 | # Interpolate the colors
80 | if seg.space == 0:
81 | c = (
82 | seg.rl + (seg.rr-seg.rl) * f,
83 | seg.gl + (seg.gr-seg.gl) * f,
84 | seg.bl + (seg.br-seg.bl) * f
85 | )
86 | elif seg.space in (1,2):
87 | hl, sl, vl = colorsys.rgb_to_hsv(seg.rl, seg.gl, seg.bl)
88 | hr, sr, vr = colorsys.rgb_to_hsv(seg.rr, seg.gr, seg.br)
89 |
90 | if seg.space == 1 and hr < hl:
91 | hr += 1
92 | elif seg.space == 2 and hr > hl:
93 | hr -= 1
94 |
95 | c = colorsys.hsv_to_rgb(
96 | (hl + (hr-hl) * f) % 1.0,
97 | sl + (sr-sl) * f,
98 | vl + (vr-vl) * f
99 | )
100 | return c
101 |
102 | def test_it():
103 | import sys, wx
104 |
105 | class GgrView(wx.Frame):
106 | def __init__(self, ggr, chunks):
107 | """ Display the ggr file as a strip of colors.
108 | If chunks is non-zero, then also display the gradient quantized
109 | into that many chunks.
110 | """
111 | super(GgrView, self).__init__(None, -1, 'Ggr: %s' % ggr.name)
112 | self.ggr = ggr
113 | self.chunks = chunks
114 | self.SetSize((600, 100))
115 | self.panel = wx.Panel(self)
116 | self.panel.Bind(wx.EVT_PAINT, self.on_paint)
117 | self.panel.Bind(wx.EVT_SIZE, self.on_size)
118 |
119 | def on_paint(self, event_unused):
120 | dc = wx.PaintDC(self.panel)
121 | cw_unused, ch = self.GetClientSize()
122 | if self.chunks:
123 | self.paint_some(dc, 0, 0, ch/2)
124 | self.paint_some(dc, self.chunks, ch/2, ch)
125 | else:
126 | self.paint_some(dc, 0, 0, ch)
127 |
128 | def paint_some(self, dc, chunks, y0, y1):
129 | cw, ch_unused = self.GetClientSize()
130 | chunkw = 1
131 | if chunks:
132 | chunkw = (cw // chunks) or 1
133 | for x in range(0, cw, chunkw):
134 | c = [int(255*x) for x in ggr.color(float(x)/cw)]
135 | dc.SetPen(wx.Pen(wx.Colour(*c), 1))
136 | dc.SetBrush(wx.Brush(wx.Colour(*c), wx.SOLID))
137 | dc.DrawRectangle(x, y0, chunkw, y1-y0)
138 |
139 | def on_size(self, event_unused):
140 | self.Refresh()
141 |
142 | app = wx.PySimpleApp()
143 | ggr = GimpGradient(sys.argv[1])
144 | chunks = 0
145 | if len(sys.argv) > 2:
146 | chunks = int(sys.argv[2])
147 | f = GgrView(ggr, chunks)
148 | f.Show()
149 | app.MainLoop()
150 |
151 | if __name__ == '__main__':
152 | test_it()
153 |
--------------------------------------------------------------------------------
/lab/test_boundary.py:
--------------------------------------------------------------------------------
1 | """ Unit tests for the boundary tracer.
2 | """
3 |
4 | from boundary import trace_boundary
5 | import unittest
6 | import numpy
7 |
8 | class BoundaryTest(unittest.TestCase):
9 |
10 | def prepare_picture(self, picture):
11 | lines = picture.split()
12 | # Make sure it's really a rectangle.
13 | assert [len(l) for l in lines] == [len(lines[0])]*len(lines)
14 | return lines, len(lines[0]), len(lines)
15 |
16 | def count_fn_from_picture(self, picture):
17 | lines, _, _ = self.prepare_picture(picture)
18 | self.fn_calls = 0
19 | def fn(x,y):
20 | self.fn_calls += 1
21 | pic = lines[-y][x]
22 | if pic == '.':
23 | return 0
24 | else:
25 | return ord(pic)
26 | return fn
27 |
28 | def assert_correct(self, counts, lines, xo, yo):
29 | y, x = counts.shape
30 | out = []
31 | for yi in range(y):
32 | l = ''
33 | for xi in range(x):
34 | l += chr(counts[yi,xi] or ord('.'))
35 | out.append(l)
36 |
37 | self.assertEqual(xo, x)
38 | self.assertEqual(yo, y)
39 | if out != lines:
40 | print "Out:"
41 | print "\n".join(out)
42 | print "Lines:"
43 | print "\n".join(lines)
44 | self.assertEqual(out, lines)
45 |
46 | def try_picture(self, picture, num_calls=0):
47 | lines, x, y = self.prepare_picture(picture)
48 | cfn = self.count_fn_from_picture(picture)
49 | counts = trace_boundary(cfn, x, y)
50 | self.assert_correct(counts, lines, x, y)
51 | if num_calls:
52 | self.assertEqual(self.fn_calls, num_calls)
53 |
54 | def try_mand_file(self, fname):
55 | from mand import MandState
56 | ms = MandState()
57 | ms.read(fname)
58 | counts = numpy.fromstring(ms.counts, dtype=numpy.uint32)
59 | counts = counts.reshape((ms.w,ms.h))
60 |
61 | def fn(x,y):
62 | return counts[-y,x]
63 |
64 | counts2 = trace_boundary(fn, counts.shape[1], counts.shape[0])
65 | wrong_count = numpy.sum(numpy.logical_not(numpy.equal(counts, counts2)))
66 | print wrong_count
67 |
68 |
69 | def testTestCode(self):
70 | cfn = self.count_fn_from_picture("""
71 | abcdefghi
72 | xyz012345
73 | """)
74 | self.assertEqual(cfn(0,0), 97)
75 | self.assertEqual(cfn(1,0), 98)
76 | self.assertEqual(cfn(0,1), 120)
77 | self.assertEqual(self.fn_calls, 3)
78 |
79 | def test1(self):
80 | self.try_picture("""
81 | XXXXXX
82 | XXXXXX
83 | XXXXXX
84 | XXXXXX
85 | """, num_calls=16)
86 |
87 | def test2(self):
88 | self.try_picture("""
89 | XXXXXX
90 | XXXXXX
91 | XXYYXX
92 | XXYYXX
93 | """, num_calls=24)
94 |
95 | def test3(self):
96 | self.try_picture("""
97 | XXXXXA
98 | XXXXXB
99 | XXYZXC
100 | XXYZXD
101 | JKLMNE
102 | """, num_calls=30)
103 |
104 | def testMandelbrot(self):
105 | self.try_picture("""
106 | ~~~~~~~~~~~~~}}}}}}}}}}}}}}}}}}}}||||||||{{{zyvrwuW{|||||}}}}}}~~~~~~~~~~~~
107 | ~~~~~~~~~~}}}}}}}}}}}}}}}}}}}}|||||||||{{{zyxwoaqwxz{{{|||||}}}}}}~~~~~~~~~
108 | ~~~~~~~~}}}}}}}}}}}}}}}}}}}|||||||||{{zzzyxvn....Knwyz{{{{||||}}}}}}~~~~~~~
109 | ~~~~~~}}}}}}}}}}}}}}}}}}||||||||{{zyxuxxxwvuq.....svwwyzzzyr{||}}}}}}}~~~~~
110 | ~~~~}}}}}}}}}}}}}}}}}|||||{{{{{zzzxt>..qf.............pttfqeqz{|}}}}}}}}~~~
111 | ~~~}}}}}}}}}}}}}}|||{{{{{{{{{zzzywotn.....................atyz{||}}}}}}}}~~
112 | ~~}}}}}}}}}||||{{zwvyyyyyyyyyyyxvsP........................swvz{||}}}}}}}}~
113 | ~}}}}|||||||{{{{zyxvpN[ur]spvwwvi...........................qxz{|||}}}}}}}}
114 | ~}||||||||{{{{{zyytun.........qq............................avz{|||}}}}}}}}
115 | ~||||||{zzzzyyxtroqb...........a............................xz{{|||}}}}}}}}
116 | ~@G::#.6#.(..............................................pvxyz{{||||}}}}}}}
117 | ~||||||{zzzzyyxtroqb...........a............................xz{{|||}}}}}}}}
118 | ~}||||||||{{{{{zyytun.........qq............................avz{|||}}}}}}}}
119 | ~}}}}|||||||{{{{zyxvpN[ur]spvwwvi...........................qxz{|||}}}}}}}}
120 | ~~}}}}}}}}}||||{{zwvyyyyyyyyyyyxvsP........................swvz{||}}}}}}}}~
121 | ~~~}}}}}}}}}}}}}}|||{{{{{{{{{zzzywotn.....................atyz{||}}}}}}}}~~
122 | ~~~~}}}}}}}}}}}}}}}}}|||||{{{{{zzzxt>..qf.............pttfqeqz{|}}}}}}}}~~~
123 | ~~~~~~}}}}}}}}}}}}}}}}}}||||||||{{zyxuxxxwvuq.....svwwyzzzyr{||}}}}}}}~~~~~
124 | ~~~~~~~~}}}}}}}}}}}}}}}}}}}|||||||||{{zzzyxvn....Knwyz{{{{||||}}}}}}~~~~~~~
125 | ~~~~~~~~~~}}}}}}}}}}}}}}}}}}}}|||||||||{{{zyxwoaqwxz{{{|||||}}}}}}~~~~~~~~~
126 | ~~~~~~~~~~~~~}}}}}}}}}}}}}}}}}}}}||||||||{{{zyvrwuW{|||||}}}}}}~~~~~~~~~~~~
127 | ~~~~~~~~~~~~~~~~~}}}}}}}}}}}}}}}}}}}}}|||||{zmt{{{||||}}}}}~~~~~~~~~~~~~~~~
128 | """)
129 |
130 | def testBigForReal(self):
131 | self.try_mand_file('test_data\\twelve_wrong.mand')
132 |
133 | if __name__ == '__main__':
134 | unittest.main()
135 |
--------------------------------------------------------------------------------
/src/aptus/gui/help.py:
--------------------------------------------------------------------------------
1 | """ Help dialog for Aptus.
2 | """
3 |
4 | import webbrowser
5 | import sys
6 |
7 | import numpy
8 | import wx
9 | import wx.html2
10 | import wx.lib.layoutf
11 | from PIL import Image
12 |
13 | from aptus import data_file, __version__
14 | from aptus.options import AptusOptions
15 |
16 |
17 | class HtmlDialog(wx.Dialog):
18 | """ A simple dialog for displaying HTML, with clickable links that launch
19 | a web browser, or change the page displayed in the dialog.
20 | """
21 | def __init__(self, parent, caption, pages, subs=None,
22 | pos=wx.DefaultPosition, size=(500,530),
23 | style=wx.DEFAULT_DIALOG_STYLE):
24 | wx.Dialog.__init__(self, parent, -1, caption, pos, size, style)
25 | if pos == (-1, -1):
26 | self.CenterOnScreen(wx.BOTH)
27 |
28 | self.pages = pages
29 | self.subs = subs or {}
30 | self.html = wx.html2.WebView.New(self)
31 | self.html.Bind(wx.html2.EVT_WEBVIEW_NAVIGATING, self.on_navigating)
32 | ok = wx.Button(self, wx.ID_OK, "OK")
33 | ok.SetDefault()
34 |
35 | lc = wx.lib.layoutf.Layoutf('t=t#1;b=t5#2;l=l#1;r=r#1', (self,ok))
36 | self.html.SetConstraints(lc)
37 | self.set_page('interactive')
38 |
39 | lc = wx.lib.layoutf.Layoutf('b=b5#1;r=r5#1;w!80;h*', (self,))
40 | ok.SetConstraints(lc)
41 |
42 | self.SetAutoLayout(1)
43 | self.Layout()
44 |
45 | def on_navigating(self, event):
46 | url = event.GetURL()
47 | if url == "":
48 | event.Veto()
49 | elif url.startswith(("http:", "https:")):
50 | webbrowser.open(url)
51 | event.Veto()
52 | elif url.startswith('internal:'):
53 | self.set_page(url.split(':')[1])
54 |
55 | def set_page(self, pagename):
56 | html = self.pages['head'] + self.pages[pagename]
57 | html = html % self.subs
58 | self.html.SetPage(html, "")
59 |
60 |
61 | # The help text
62 |
63 | is_mac = ('wxMac' in wx.PlatformInfo)
64 |
65 | TERMS = {
66 | 'ctrl': 'cmd' if is_mac else 'ctrl',
67 | 'iconsrc': data_file('icon48.png'),
68 | 'version': __version__,
69 | 'python_version': sys.version,
70 | 'wx_version': wx.__version__,
71 | 'numpy_version': numpy.__version__,
72 | 'pil_version': Image.__version__,
73 | }
74 |
75 |
76 | HELP_PAGES = {
77 | 'head': """\
78 |
89 |
90 | |
94 | Aptus %(version)s, Mandelbrot set explorer. 95 | Copyright 2007-2020, Ned Batchelder. 96 | http://nedbatchelder.com/code/aptus 97 | |
98 |
102 | Interactive | 103 | Command line | 104 | About
105 |106 | """, 107 | 108 | 'interactive': """ 109 |
Interactive controls:
110 | 111 |112 | a: set the angle of rotation.136 | 137 |
113 | c: toggle continuous coloring.
114 | f: toggle full-screen display.
115 | h or ?: show this help.
116 | i: set the limit on iterations.
117 | j: jump among a few pre-determined locations.
118 | n: create a new window.
119 | o: open a saved settings or image file.
120 | r: redraw the current image.
121 | s: save the current image or settings.
122 | w: set the window size.
123 | < or >: switch to the next palette.
124 | , or .: cycle the current palette one color.
125 | ; or ': stretch the palette colors (+%(ctrl)s: just a little), if continuous.
126 | [ or ]: adjust the hue of the palette (+%(ctrl)s: just a little).
127 | { or }: adjust the saturation of the palette (+%(ctrl)s: just a little).
128 | 0 (zero): reset all palette adjustments.
129 | space: drag mode: click to drag the image to a new position.
130 | shift: indicate a point of interest for Julia set and point info.
131 | left-click: zoom in (+%(ctrl)s: just a little).
132 | right-click: zoom out (+%(ctrl)s: just a little).
133 | left-drag: select a new rectangle to display.
134 | middle-drag: drag the image to a new position.
135 |
Tool windows: press a key to toggle on and off:
138 | 139 |140 | J (shift-j): Show a Julia set for the current (shift-hovered) point.146 | """, 147 | 148 | 'command': """ 149 |
141 | l (ell): Show zoom snapshots indicating the current position.
142 | p: Show a list of palettes that can be applied to the current view.
143 | q: Show point info for the current (shift-hovered) point.
144 | v: Show statistics for the latest calculation. 145 |
On the command line, use --help to see options:
150 |""" + AptusOptions(None).options_help() + "", 151 | 152 | 'about': """ 153 |
Built with 154 | Python, wxPython, 155 | numpy, and 156 | PIL.
157 | 158 |Thanks to Rob McMullen and Paul Ollis for help with the drawing code.
159 | 160 |161 |
Installed versions:
162 |
163 | Aptus: %(version)s
164 | Python: %(python_version)s
165 | wx: %(wx_version)s
166 | numpy: %(numpy_version)s
167 | PIL: %(pil_version)s
168 |
Aptus is a Mandelbrot set viewer and renderer. It is written in Python 20 | with a computation engine in C for speed. 21 |
22 | 23 |
25 | Getting Aptus
29 | 30 |Pre-requisites
31 |Aptus installs like any other Python package. 32 | Before installing Aptus, you'll need to install these prerequisite Python packages:
33 | 34 |-
35 |
- wxPython, 2.8 or greater. 36 |
- Numpy. 37 |
- Python Imaging Library, 1.1.6 or greater. 38 |
Installation
41 |Download the kit that's right for you. Linux and Mac use the tar.gz, Windows 42 | users will probably be happier with the .exe:
43 | 44 |Install the kit with the usual command:
48 | 49 |python setup.py install
50 |
51 | Source
52 | 53 |The source is available on bitbucket if you 54 | prefer direct access to the code, including recent changes.
55 | 56 | 57 |Using Aptus
58 | 59 |There are two ways to use Aptus: a GUI explorer, and a command line renderer. 60 | The GUI lets you zoom in and out, and change the color palette to find an image 61 | you like. The command line renderer produces higher-quality images. 62 |
63 | 64 |Parameter files
65 | 66 |Aptus stores information about the image to display in a few ways. Small 67 | textual .aptus files store all the parameters needed to recreate an image, 68 | and can be saved from the GUI and fed to the command line renderer.
69 | 70 |When saving an image as a .PNG file, Aptus also stores all its parameter 71 | information in a text block hidden in the image, so that the .PNG can be used 72 | directly as a parameter file. 73 |
74 | 75 |Aptus can also read Xaos 76 | .xpf files so that you can use Xaos to explore, and Aptus to render if you like.
77 | 78 |GUI usage
79 | 80 |Start Aptus with aptusgui.py, and start poking around. Left click or drag 81 | zooms you in, right click zooms you out. Type 'h' for help on other controls. 82 | Detailed descriptions of GUI behavior are below.
83 | 84 |aptusgui.py also accepts applicable command-line switches so you can start it from a 85 | parameter file, or specify the size of the window, and so on.
86 | 87 | 88 |Command line usage
89 | 90 |The command line renderer is called aptuscmd.py. It will accept a number of 91 | switches or parameter files: 92 |
93 | 94 |
95 | Usage: aptuscmd.py [options] [parameterfile]
96 |
97 | Aptus renders Mandelbrot set images. Two flavors are available: aptusgui.py
98 | for interactive exploration, and aptuscmd.py for high-quality rendering.
99 |
100 | Options:
101 | -h, --help show this help message and exit
102 | -a ANGLE, --angle=ANGLE
103 | set the angle of rotation
104 | --center=RE,IM set the center of the view
105 | -c, --continuous use continuous coloring
106 | --diam=DIAM set the diameter of the view
107 | -i ITER_LIMIT, --iterlimit=ITER_LIMIT
108 | set the limit on the iteration count
109 | -o OUTFILE, --output=OUTFILE
110 | set the output filename (aptuscmd.py only)
111 | --phase=PHASE set the palette phase
112 | --pscale=SCALE set the palette scale
113 | -s WIDxHGT, --size=WIDxHGT
114 | set the pixel size of the image
115 | --super=S set the supersample rate (aptuscmd.py only)
116 |
117 |
118 |
119 | GUI controls
120 | 121 |The Aptus GUI is very bare: there's just an image of the Mandelbrot set, with 122 | no visible controls. You use the mouse and keyboard to control Aptus.
123 | 124 |Moving around
125 | 126 |Left-clicking zooms into the set, right-clicking zooms out; clicking while 127 | holding the Ctrl (or Cmd) key zooms just a little bit. If you drag out a 128 | rectangle with the left mouse button, you will zoom into that rectangle, so you 129 | have more control over exactly where you end up.
130 | 131 |If you drag with the middle mouse button, you will drag the image, re-centering 132 | it on a new point of interest.
133 | 134 |The 'a' key will prompt you for a new angle of rotation for the image.
135 | 136 |The 'n' key will open a new top-level window to explore elsewhere in the set.
137 | 138 |Appearance
139 | 140 |The image of the Mandelbrot set is drawn by calculating a value at each pixel,
141 | then mapping that value to a color through a palette. The values can be discrete
142 | or continuous
The accuracy of the black boundary of the set depends on the number of iterations 145 | Aptus is permitted to calculate at each point. The value can be adjusted with 146 | the 'i' key.
147 | 148 |Aptus has handful of different palettes. Cycle through them with the '<'
149 | (less-than) and '>' (greater-than) keys. A list of all the palettes can be
150 | displayed with 'p'. The color mapped to each value can be shifted one color with
151 | the ',' (comma) and '.' (period) keys. If the pixel values are continuous, then
152 | the palette can also be scaled to change the distance between color bands
153 |
The hue and saturation of the palette can also be shifted. The '[' and ']' 157 | (square bracket) keys change the hue, and '{' and '}' (curly braces) change the 158 | saturation. Both also use the Ctrl key to change just a little.
159 | 160 |The '0' (zero) key will reset all palette adjustments.
161 | 162 |Auxiliary windows
163 | 164 |Aptus has a few tool windows. Each is toggled with a particular key.
165 | 166 |'p' displays a list of all Aptus' palettes. Clicking one will change 167 | the display to use it.
168 | 169 |'v' displays a list of statistics about the last fractal calculation.
170 | 171 |'q' displays information about a point in the display. Hold the shift key 172 | and hover over a point in the image to see iteration counts, coordinates, and so on.
173 | 174 |'l' (lowercase L) displays the You Are Here panel. It shows a series of images, 175 | zooming in to the currently displayed view of the set. Each image has a rectangle 176 | drawn on it corresponding to the next image in the list, so that you can see 177 | how your close-up view in the main window relates to the larger set. Any rectangle 178 | can be dragged to change the main window's view of the set.
179 | 180 | 181 |Julia set
182 | 183 |The Julia set is closely related to the Mandelbrot set. Each point in the 184 | Mandelbrot set corresponds to a Julia set. To display the Julia set, use the 'J' 185 | key (with the shift key). A small tool window appears. It shows the Julia set 186 | for the current shift-hovered point in the main window. Hold the shift key and 187 | move the mouse over the Mandelbrot set. The Julia set will change as the mouse 188 | moves.
189 | 190 |To further explore a particular Julia set, double-click in the Julia set window. 191 | You'll get a new top-level window displaying the Julia set, and you can use all 192 | the usual Aptus controls to navigate and manipulate the image.
193 | 194 | 195 |History
196 | 197 |Version 2.0, October 2008
198 | 199 |-
200 |
- Multiple top-level exploration windows. 201 | 202 |
- Tool panels show supplementary information:
203 |
-
204 |
- You Are Here shows your location in the Mandelbrot set. 205 |
- Palettes panel shows all the palettes, and the one currently in use. 206 |
- Statistics panel shows statistics about the latest computation. 207 |
- Point Info panel shows information about the current point, shift-hover to indicate point. 208 |
- Julia panel shows Julia set for the current point, shift-hover to indicate point. 209 | Double-clicking the Julia panel opens a new exploration window to explore that Julia set. 210 |
211 |
212 | - Computation improvements:
213 |
-
214 |
- Faster. 215 |
- The exploration window updates during computation. 216 |
- Continuous coloring is more accurate now: banding artifacts are gone. 217 |
- When dragging the exploration window, pixels still in the window aren't re-calculated. 218 |
219 |
220 | - Center and diameter can be specified in the command line arguments. 221 |
Version 1.56, April 2008
224 | 225 |More display improvements and simplifications. Thanks, Paul Ollis.
226 | 227 | 228 |Version 1.55, April 2008
229 | 230 |The display is now flicker-free. Thanks, Rob McMullen.
231 | 232 | 233 |Version 1.51, March 2008
234 | 235 |Fixed a few bugs, including not drawing at all on Mac or Linux!
236 | 237 | 238 |Version 1.5, March 2008
239 | 240 |A number of improvements:
241 | 242 |-
243 |
- Continuous coloring. 244 | 245 |
- Arbitrary rotation support. 246 | 247 |
- Middle mouse button drags the image. 248 | 249 |
- Palette tweaking:
250 |
-
251 |
- Hue and saturation adjustments. 252 |
- Scaling the palette to adjust distance between colors. 253 |
254 |
255 | - Statistics:
256 |
-
257 |
- More statistics: boundaries traced, boundaries filled, and points computed. 258 |
- Statistics are written into the final .PNG files. 259 |
260 |
261 | - Reads .xet files from servebeer.com. 262 | 263 |
- Some old .aptus files recorded the y coordinate incorrectly, 264 | and will now render upside-down: negate the y component of the center to fix this. 265 |
Version 1.0, October 2007
269 | 270 |First version.
271 | 272 | 273 |More samples
274 | 275 |279 |
See also
284 | 285 |-
286 |
- Xaos, a full-featured 287 | fractal explorer which has many more rendering and fractal options than Aptus. 288 |
- Gnofract 4D, a Linux-based 289 | fractal exploration program. 290 |
- My blog, where recreational math and Python 291 | topics intersect from time to time. 292 |