/prog/ - Programming★

For svg, without anything special being done to it, and just dumping it to stdout:

from xml.etree.ElementTree import Element, SubElement, tostring

def makeserp(width, height, x, y, e, recursions):
	if recursions == 0:
		return
	a = (x + (width / 2), y + height)
	b = (x + (width / 4), y + (height / 2))
	c = (x + (3 * width / 4), y + (height / 2))
	tri = (a, b, c)
	smalle = SubElement(e, 'polygon')
	smalle.attrib = {'style': 'fill:white', 'points': ' '.join(','.join(str(part) for part in point) for point in tri)}
	makeserp(width / 2, height / 2, x, y + (height / 2), e, recursions - 1)
	makeserp(width / 2, height / 2, x + (width / 2), y + (height / 2), e, recursions - 1)
	makeserp(width / 2, height / 2, x + (width / 4), y, e, recursions - 1)


svg = Element('svg')
svg.attrib = {'height': '866', 'width': '1000', 'xmlns': 'http://www.w3.org/2000/svg', 'version': '1.1'}
bigtri = SubElement(svg, 'polygon')
bigtri.attrib = {'style': 'fill:black', 'points': '0,866 1000,866 500,0'}
makeserp(1000, 866, 0, 0, svg, 8)
print(str(tostring(svg), 'utf-8'))

The image is at the 8 levels of recursion.

Sierpinski, you say? Fine, I'll fill up this square.

   @ addtest
   def sfc_sierpinski (self):
      delta = {
         # quarters
         'u': (2, 1), 'd': (2, 3),
         'l': (1, 2), 'r': (3, 2),

         # halves
         "UR": (1, 0), "UL": (0, 0),
         "DL": (0, 1), "DR": (1, 1)
      }

      reduce = {
         "UR": "drul", "UL": "ruld",
         "DL": "uldr", "DR": "ldru"
      }
      terminal = {
         key: tuple (delta [ch] for ch in val)
            for key, val in reduce.items ()
      }

      expand = {
         "UR": ("UR", "DR", "UR", "UL"),
         "UL": ("UL", "UR", "UL", "DL"),
         "DL": ("DL", "UL", "DL", "DR"),
         "DR": ("DR", "DL", "DR", "UR")
      }

      places = {
         "UR": ("DL", "DR", "UR", "UL"),
         "UL": ("DR", "UR", "UL", "DL"),
         "DL": ("UR", "UL", "DL", "DR"),
         "DR": ("UL", "DL", "DR", "UR")
      }
      wind = {
         key: tuple (delta [x] for x in val)
            for key, val in places.items ()
      }

      size = 512
      draw = self.makedraw (size, size)
      Tests.sfc_sierpinski_work (
         draw, expand, wind, terminal,
         0, 0, size, "UR", 5)
      return draw

   @ staticmethod
   def sfc_sierpinski_work (draw, expand, wind, terminal, x, y, size, var, level):
      ps = Tests.sfc_sierpinski_points (
         expand, wind, terminal, x, y, size, var, level)
      pit = iter (ps)
      p0 = p = next (pit)

      for q in pit:
         draw.line (p [0], p [1], q [0], q [1])
         p = q

      draw.line (p [0], p [1], p0 [0], p0 [1])

   @ staticmethod
   def sfc_sierpinski_points (expand, wind, terminal, x, y, size, var, level):
      if level == 0:
         s14 = size // 4
         delta = terminal [var]
         return [(x + dx * s14, y + dy * s14) for dx, dy in delta]

      symbols = expand [var]
      delta = wind [var]
      level -= 1
      s12 = size // 2

      l = [
         Tests.sfc_sierpinski_points (
            expand, wind, terminal,
            x + d [0] * s12, y + d [1] * s12,
            s12, sym, level
         ) for d, sym in zip (delta, symbols)
      ]

      l0 = l [0]
      l1 = l [1:]
      half = (4 ** level) * 2
      l0it = iter (l0)

      return itertools.chain (
         itertools.islice (l0it, half),
         itertools.chain.from_iterable (l1),
         l0it
      )

>>4598

forgot pic

>>4872

gradient path

added the white stop to get quarters

U+2665

random choice between stamps

fixed cycle of random alternates

text stamp with fill and outline

random choice

U+2601 U+2660 U+2691

fixed rotation cycle

fixed color cycle

outputs Sierpinski using rule 90

One outputs as ascii, other outputs as farbfeld to stdout (save as .ff)

>>5029

The output of the second one after being converted from farbfeld to png. (A bit fucked cuz of its massive size and grey pixels)

>>5031

In my defense, there aren't many tools to convert ff to png and I used the standard one.

Did the rule90 thing to see whether pycairo will export its 1-bit packed FORMAT_A1 surfaces as 1-bit grayscale PNGs. Turns out write_to_png does produce grayscale in this case but uses 8-bit samples, so 7 bits wasted. So I wrote my own quick hack of an exporter to output 1-bit grayscale PNGs anyway. Here's a sample run with one seed, and also some saner image dimensions, because unlike smug anime girls I don't have a terabyte of RAM.

import functools
import sys

import lib.pong as pong


class Show:
   @ staticmethod
   def null (row):
      pass

   @ staticmethod
   def text (symbols):
      def show (row):
         print (''.join (map (
            lambda x: symbols [x], row)))
      return show


class NextRow:
   @ staticmethod
   def r90 (rowin, rowout):
      last = len (rowin) - 1

      rowout [0   ] = rowin [1]
      rowout [last] = rowin [last - 1]

      for k in range (1, last):
         rowout [k] = rowin [k - 1] ^ rowin [k + 1]

   @ staticmethod
   def r90wrap (rowin, rowout):
      last = len (rowin) - 1

      rowout [0   ] = rowin [1] ^ rowin [last    ]
      rowout [last] = rowin [0] ^ rowin [last - 1]

      for k in range (1, last):
         rowout [k] = rowin [k - 1] ^ rowin [k + 1]


class Seed:
   @ staticmethod
   def middle (row):
      w = len (row)

      row [w // 2] = 1

   @ staticmethod
   def uniform (count):
      n = count + 1

      def seed (row):
         w = len (row)

         for k in range (1, n):
            row [k * w // n] = 1

      return seed


def runcells (width, steps, seed_func, next_func, show_func):
   row  = bytearray (width)
   row2 = row [:]

   seed_func (row)
   show_func (row)

   for k in range (0, steps):
      next_func (row, row2)
      row, row2 = row2, row
      show_func (row)


def textrun (data):
   dots = ['.', 'O']

   width     = data ["width"    ]
   steps     = data ["steps"    ]
   seed_func = data ["seed_func"]
   next_func = data ["next_func"]
   show_func = Show.text (dots)
   # show_func = Show.null

   runcells (width, steps, seed_func, next_func, show_func)


def pngrun (data):
   out = "temp/cells-{}-{}-{}-{}.png".format (
      data ["width"], data ["steps"],
      data ["seeds"], data ["rule" ])
   print (out)

   with open (out, "wb") as f:
      data ["outfile"] = f
      pngrun_open (data)
      del data ["outfile"]

def pngrun_open (data):
   pw = pong.Write

   width   = data ["width"  ]
   steps   = data ["steps"  ]
   outfile = data ["outfile"]

   pw.beforeIDATs (outfile,
      width, steps + 1,
      color = "GRAY", bits = 1)

   wdiv8, wmod8 = divmod (width, 8)
   rowbytes = wdiv8 + (0 if wmod8 == 0 else 1)
   packed = bytearray (rowbytes)

   r2i = pw.rowsToIDATs (
      outfile, rowbytes, steps + 1)
   proc = r2i ["processor"]

   seed_func = data ["seed_func"]
   next_func = data ["next_func"]
   show_func = process_row_func (
      proc, packed, wdiv8, wmod8)

   runcells (width, steps, seed_func, next_func, show_func)

   proc.flush ()
   pw.afterIDATs (outfile)

def packrow (row, packed, wdiv8, wmod8):
   srcoff = 0
   reduce = functools.reduce
   range8 = range (8)

   def redstep (acc, item):
      return acc | (row [srcoff + item] << (7 - item))

   for k in range (wdiv8):
      packed [k] = reduce (redstep, range8, 0)
      srcoff += 8

   if wmod8 > 0:
      packed [wdiv8] = reduce (redstep, range (wmod8), 0)

def process_row_func (processor, packed, wdiv8, wmod8):
   def work (row):
      packrow (row, packed, wdiv8, wmod8)
      processor.process (packed)
   return work


def main_argv (argv, handler):
   width = int (argv [0])
   steps = int (argv [1])
   seeds = int (argv [2])
   rule  = argv [3]

   data = {
      "width"    : width,
      "steps"    : steps,
      "seeds"    : seeds,
      "rule"     : rule,
      "seed_func": Seed.uniform (seeds),
      "next_func": getattr (NextRow, rule),
   }

   handler (data)

def main ():
   argv    = sys.argv [1:]
   # handler = textrun
   handler = pngrun

   main_argv (argv, handler)

if __name__ == "__main__": main ()

r90wrap for comparison

>>5051

>unlike smug anime girls I don't have a terabyte of RAM.

Sorry to hear fam.

Seriously tho, the pic does load on my machine, just not particularly quickly.

I was considering using PNG directly but it's fucking cancer to work with :/