commit 259ed6b8609a334b7dbf1ba17620daee870de9e8
Author: Bachir Soussi Chiadmi <bachir@g-u-i.me>
Date:   Tue Mar 14 15:43:14 2017 +0100

    first draft, trying to convert to svg

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..c901d12
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+maps/*
+
diff --git a/mapgen.py b/mapgen.py
new file mode 100755
index 0000000..b2a8acd
--- /dev/null
+++ b/mapgen.py
@@ -0,0 +1,124 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# http://stackoverflow.com/questions/8997099/algorithm-to-generate-random-2d-polygon
+
+import os, glob, errno
+import math, random
+from PIL import Image, ImageDraw
+import svgwrite
+
+def generatePolygon( ctrX, ctrY, aveRadius, irregularity, spikeyness, numVerts ) :
+   '''Start with the centre of the polygon at ctrX, ctrY,
+    then creates the polygon by sampling points on a circle around the centre.
+    Randon noise is added by varying the angular spacing between sequential points,
+    and by varying the radial distance of each point from the centre.
+
+    Params:
+    ctrX, ctrY - coordinates of the "centre" of the polygon
+    aveRadius - in px, the average radius of this polygon, this roughly controls how large the polygon is, really only useful for order of magnitude.
+    irregularity - [0,1] indicating how much variance there is in the angular spacing of vertices. [0,1] will map to [0, 2pi/numberOfVerts]
+    spikeyness - [0,1] indicating how much variance there is in each vertex from the circle of radius aveRadius. [0,1] will map to [0, aveRadius]
+    numVerts - self-explanatory
+
+    Returns a list of vertices, in CCW order.
+    '''
+
+   irregularity = clip( irregularity, 0,1 ) * 2*math.pi / numVerts
+   spikeyness = clip( spikeyness, 0,1 ) * aveRadius
+
+   # generate n angle steps
+   angleSteps = []
+   lower = (2*math.pi / numVerts) - irregularity
+   upper = (2*math.pi / numVerts) + irregularity
+   sum = 0
+   for i in range(numVerts) :
+      tmp = random.uniform(lower, upper)
+      angleSteps.append( tmp )
+      sum = sum + tmp
+
+   # normalize the steps so that point 0 and point n+1 are the same
+   k = sum / (2*math.pi)
+   for i in range(numVerts) :
+     angleSteps[i] = angleSteps[i] / k
+
+   # now generate the points
+   points = []
+   angle = random.uniform(0, 2*math.pi)
+   for i in range(numVerts) :
+     r_i = clip( random.gauss(aveRadius, spikeyness), 0, 2*aveRadius )
+     x = ctrX + r_i*math.cos(angle)
+     y = ctrY + r_i*math.sin(angle)
+     points.append( (int(x),int(y)) )
+
+     angle = angle + angleSteps[i]
+
+   return points
+
+def clip(x, min, max) :
+   if( min > max ) :  return x
+   elif( x < min ) :  return min
+   elif( x > max ) :  return max
+   else :             return x
+
+# create maps export folder
+directory = "maps"
+try:
+   os.makedirs(directory)
+except OSError as exception:
+   if exception.errno != errno.EEXIST:
+      raise
+# remove old image
+# os.chdir(directory)
+# files=glob.glob('*')
+# for filename in files:
+#     os.unlink(filename)
+
+for i in range(0, 1):
+
+   verts = generatePolygon( ctrX=500, ctrY=500, aveRadius=300, irregularity=1, spikeyness=0.15, numVerts=13 )
+
+   index = str(i) if i > 9 else '0'+str(i)
+
+   #    ______    ________
+   #   / ___/ |  / / ____/
+   #   \__ \| | / / / __
+   #  ___/ /| |/ / /_/ /
+   # /____/ |___/\____/
+
+   svg = svgwrite.Drawing(filename = directory+"/map"+index+".svg",size = ("1000px", "1000px"))
+
+   print(len(verts))
+   for v in range(0, len(verts)):
+      print('---- '+str(v)+' ----')
+      # p1 = verts[v]
+      # p2 = verts[0] if v >= len(verts) else verts[v+1];
+      # print(p1)
+      # print(p2)
+      # svg.add(svg.line(p1, p2))
+
+   svg.save()
+
+
+   #     __    _ __
+   #    / /_  (_) /_____ ___  ____ _____
+   #   / __ \/ / __/ __ `__ \/ __ `/ __ \
+   #  / /_/ / / /_/ / / / / / /_/ / /_/ /
+   # /_.___/_/\__/_/ /_/ /_/\__,_/ .___/
+   #                            /_/
+   # black = (0,0,0)
+   # white=(255,255,255)
+   # im = Image.new('RGB', (1000, 1000), white)
+   # imPxAccess = im.load()
+   # draw = ImageDraw.Draw(im)
+   # tupVerts = list(map(tuple,verts))
+   #
+   # # either use .polygon(), if you want to fill the area with a solid colour
+   # # draw.polygon( tupVerts, outline=black,fill=white )
+   #
+   # # or .line() if you want to control the line thickness, or use both methods together!
+   # draw.line( tupVerts+[tupVerts[0]], width=1, fill=black )
+   #
+   # # im.show()
+   # im.save(directory+'/map-'+str(index)+'.bmp')
+   # # now you can save the image (im), or do whatever else you want with it.