interesting mistake

Author: dorianbrown

angular_lines.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+
+import cairo as cr
+import numpy as np
+from random import choice
+from math import pi
+
+from src.objects import DrawGraph
+from src.draw import Canvas
+from fn import Fn
+from matplotlib import cm
+
+# Constants
+
+
+# Create graph
+
+
+# Document configuration
+cnv_conf = {
+    "fname": f"temp/{Fn().name()}",
+    "dpi": 300,
+    "width": 10,
+    "height": 20,
+    "bg_rgb": [(0.05, 0.05, 0.05), (0.15, 0.15, 0.15)]
+}
+
+n_lines = 3000
+cm = cm.viridis
+
+# Draw to canvas
+with Canvas(**cnv_conf) as cnv:
+
+    angle = 0.5*pi*np.random.uniform()
+    y0 = np.random.uniform(0.1*1, 1, n_lines)
+    x0 = y0*np.tan(y0)
+    col_mid = choice(y0)
+    col_vec = 1.1 - y0 + np.random.normal(0, 0.5, n_lines)
+    col_vec = (col_vec - min(col_vec))/(max(col_vec) - min(col_vec))
+    colors = cm(col_vec, alpha=0.15)
+
+    for x, y, col in zip(x0, y0, colors):
+        edge = [[0, y], [x, 0]]
+        cnv.draw_edge(edge, 0.00001, col)

draw.py

@@ -2,21 +2,21 @@
 
 import cairo as cr
 import numpy as np
-from matplotlib import cm
 
-from objects import DrawGraph
-from rnd import rnd_crc_pnt
-from draw import Canvas
+from src.objects import DrawGraph
+from src.rnd import rnd_crc_pnt
+from src.draw import Canvas
 from fn import Fn
 
 init_vert = [0.5, 0.5]
-edge_length = 0.0025
+edge_length = 0.01
+num_verts = 1000
 
 graph = DrawGraph()
 graph.add_vertex(init_vert)
 
 tries = 0
-while len(graph.verts) < 17_500:
+while len(graph.verts) < num_verts:
     if len(graph.verts) % 100 == 0 and tries == 0:
         print(f"vertices: {len(graph.verts)}")
     tries += 1
@@ -39,8 +39,8 @@
     "fname": f"temp/{Fn().name()}",
     "dpi": 300,
     "width": 10,
-    "height": 10,
-    "bg_rgb": (0.05, 0.05, 0.05)
+    "height": 15,
+    "bg_rgb": [(0.05, 0.05, 0.05), (0.7, 0.7, 0.7)]
 }
 
 with Canvas(**cnv_settings) as cnv:
@@ -49,4 +49,4 @@
     for edge in graph.edges:
         edge_coord = [graph.verts[i] for i in edge]
         if np.linalg.norm(edge_coord[0] - edge_coord[1]) < 2*edge_length:
-            cnv.draw_edge(edge_coord, 0.01, [0.95, 0.95, 0.95])
+            cnv.draw_edge(edge_coord, 0.05, [0.95, 0.95, 0.95])

random_walks_jumps.py

@@ -0,0 +1,77 @@
+import cairo as cr
+
+
+class Canvas:
+
+    def __init__(self, width, height, dpi, fname, bg_rgb):
+        """
+        Create a canvas object.
+        :param width: Width in inch (of inner canvas)
+        :param height: Height in inch (of inner canvas)
+        :param dpi: Dots-per-inch of final png
+        :param fname:
+        :param bg_rgb:
+        :param zoom: Fractional border size between outer and inner canvas
+        """
+        self.inner_width = width * dpi
+        self.inner_height = height * dpi
+        self.dpi = dpi
+        self.fname = fname
+        self.zoom_factor = 1.1
+        if width > height:
+            self.outer_width = self.inner_width * self.zoom_factor
+            self.outer_height = self.inner_width * self.zoom_factor
+        else:
+            self.outer_width = self.inner_height * self.zoom_factor
+            self.outer_height = self.inner_height * self.zoom_factor
+        if len(bg_rgb) is 1:
+            self.bg_rgb = bg_rgb[0]
+            self.fg_rgb = bg_rgb[0]
+        elif len(bg_rgb) is 2:
+            self.bg_rgb = bg_rgb[0]
+            self.fg_rgb = bg_rgb[1]
+
+    def __enter__(self):
+        self.surface = cr.SVGSurface(f"{self.fname}.svg",
+                                     self.outer_width,
+                                     self.outer_height)
+        self.ctx = cr.Context(self.surface)
+
+        self.ctx.save()
+        self.ctx.set_source_rgb(*self.bg_rgb)
+        self.ctx.paint()
+        self.ctx.restore()
+
+        # Paint inner background
+        self.ctx.save()
+        self.ctx.set_source_rgb(*self.fg_rgb)
+        y_top = 0.5*(self.outer_height - self.inner_height)
+        x_top = 0.5*(self.outer_width - self.inner_width)
+        self.ctx.rectangle(x_top, y_top, self.inner_width, self.inner_height)
+        self.ctx.fill()
+        self.ctx.restore()
+
+        xtrans = 0.5 * (self.outer_width - self.inner_width)
+        ytrans = 0.5 * (self.outer_height - self.inner_height)
+        xmult = self.inner_width
+        ymult = self.inner_height
+
+        trans_matrix = cr.Matrix(x0=xtrans, xx=xmult, y0=ytrans, yy=ymult, xy=0, yx=0)
+        self.ctx.set_matrix(trans_matrix)
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        # Close canvas and export it
+        self.surface.write_to_png(f"{self.fname}.png")
+        self.surface.finish()
+
+    def draw_edge(self, edge, line_width, rgb):
+        self.ctx.set_source_rgba(*rgb)
+        self.ctx.set_line_width(line_width * self.dpi)
+        self.ctx.move_to(*edge[0])
+        self.ctx.line_to(*edge[1])
+        self.ctx.save()
+        self.ctx.stroke_preserve()
+        self.ctx.fill()
+        self.ctx.restore()

src/draw.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python
+
+from src.draw import Canvas
+from fn import Fn
+
+cnv_settings = {
+    "fname": f"temp/test",
+    "dpi": 300,
+    "width": 15,
+    "height": 10,
+    "bg_rgb": [(0.05, 0.05, 0.05), (0.7, 0.7, 0.7)]
+}
+
+with Canvas(**cnv_settings) as cnv:
+    cnv.draw_edge([[0, 0], [1, 1]], 0.00001, [1, 1, 1])
+    cnv.draw_edge([[1, 0], [0, 1]], 0.00001, [1, 1, 1])