From f3889d8932032237f4ec12ec013cf5eb1a3a62a4 Mon Sep 17 00:00:00 2001
From: Christopher Haster <geky@geky.net>
Date: Wed, 12 Mar 2025 13:42:18 -0500
Subject: [PATCH] scripts: Adopted Canvas class in plot.py

This should have no noticeable impact on plot.py, but shared classes
have proven helpful for maintaining these scripts.

Unfortunately, this did require some tweaking of the Canvas class to get
things working.

Now, instead of storing things in an internal high-resolution grid,
the Canvas class only keeps track of the most recent character, with
bitmasked ints storing sub-char info.

This makes it so sub-char draws overwrite full characters, which is
necessary for plot.py's axis/data overlap to work.
---
 scripts/codemap.py | 131 +++++++++--------
 scripts/plot.py    | 340 +++++++++++++++++++++++++++++----------------
 scripts/treemap.py | 131 +++++++++--------
 3 files changed, 348 insertions(+), 254 deletions(-)

diff --git a/scripts/codemap.py b/scripts/codemap.py
index 98fbd495..876a882a 100755
--- a/scripts/codemap.py
+++ b/scripts/codemap.py
@@ -253,6 +253,8 @@ class Canvas:
         else:
             xscale, yscale = 1, 1
 
+        self.width_ = width
+        self.height_ = height
         self.width = xscale*width
         self.height = yscale*height
         self.xscale = xscale
@@ -262,50 +264,63 @@ class Canvas:
         self.braille = braille
 
         # create initial canvas
-        self.grid = [False] * (self.width*self.height)
-        self.colors = [''] * (self.width*self.height)
+        self.chars = [0] * (width*height)
+        self.colors = [''] * (width*height)
 
-    def __getitem__(self, xy):
-        x, y = xy
+    def char(self, x, y, char=None):
         # ignore out of bounds
         if x < 0 or y < 0 or x >= self.width or y >= self.height:
-            return
+            return False
 
-        return self.grid[x + y*self.width]
-
-    def __setitem__(self, xy, char):
-        x, y = xy
-        # ignore out of bounds
-        if x < 0 or y < 0 or x >= self.width or y >= self.height:
-            return
-
-        self.grid[x + y*self.width] = char
+        x_ = x // self.xscale
+        y_ = y // self.yscale
+        if char is not None:
+            c = self.chars[x_ + y_*self.width_]
+            # mask in sub-char pixel?
+            if isinstance(char, bool):
+                if not isinstance(c, int):
+                    c = 0
+                self.chars[x_ + y_*self.width_] = (c
+                        | (1
+                            << ((y%self.yscale)*self.xscale
+                                + (self.xscale-1)-(x%self.xscale))))
+            else:
+                self.chars[x_ + y_*self.width_] = char
+        else:
+            c = self.chars[x_ + y_*self.width_]
+            if isinstance(c, int):
+                return ((c
+                            >> ((y%self.yscale)*self.xscale
+                                + (self.xscale-1)-(x%self.xscale)))
+                        & 1) == 1
+            else:
+                return c
 
     def color(self, x, y, color=None):
         # ignore out of bounds
         if x < 0 or y < 0 or x >= self.width or y >= self.height:
-            return
+            return ''
 
+        x_ = x // self.xscale
+        y_ = y // self.yscale
         if color is not None:
-            self.colors[x + y*self.width] = color
+            self.colors[x_ + y_*self.width_] = color
         else:
-            return self.colors[x + y*self.width]
+            return self.colors[x_ + y_*self.width_]
+
+    def __getitem__(self, xy):
+        x, y = xy
+        return self.char(x, y)
+
+    def __setitem__(self, xy, char):
+        x, y = xy
+        self.char(x, y, char)
 
     def point(self, x, y, *,
             char=True,
             color=''):
-        # make sure non-bool chars map attrs to all points under char
-        if not isinstance(char, bool):
-            xscale, yscale = self.xscale, self.yscale
-        else:
-            xscale, yscale = 1, 1
-
-        for i in range(xscale*yscale):
-            x_ = x-(x%xscale) + (xscale-1-(i%xscale))
-            y_ = y-(y%yscale) + (i//xscale)
-
-            self[x_, y_] = char
-            self.color(x_, y_, color)
+        self.char(x, y, char)
+        self.color(x, y, color)
 
     def line(self, x1, y1, x2, y2, *,
             char=True,
@@ -318,7 +333,7 @@ class Canvas:
         e = ex + ey
 
         while True:
-            self.point(x1, y1, color=color, char=char)
+            self.point(x1, y1, char=char, color=color)
             e2 = 2*e
 
             if x1 == x2 and y1 == y2:
@@ -335,7 +350,7 @@ class Canvas:
                 e += ex
                 y1 += dy
 
-        self.point(x2, y2, color=color, char=char)
+        self.point(x2, y2, char=char, color=color)
 
     def rect(self, x, y, w, h, *,
             char=True,
@@ -359,47 +374,29 @@ class Canvas:
                 x_ += self.xscale
 
     def draw(self, row):
-        # scale if needed
-        xscale, yscale = self.xscale, self.yscale
-
-        y = self.height//yscale-1 - row
+        y_ = self.height_-1 - row
         row_ = []
-        for x in range(self.width//xscale):
-            color = ''
-            char = False
-            byte = 0
-            for i in range(xscale*yscale):
-                x_ = x*xscale + (xscale-1-(i%xscale))
-                y_ = y*yscale + (i//xscale)
-
-                # calculate char
-                char_ = self[x_, y_]
-                if char_:
-                    byte |= 1 << i
-                    if char_ is not True and char_ is not False:
-                        char = char_
-
-                # keep track of best color
-                color_ = self.color(x_, y_)
-                if color_:
-                    color = color_
-
-            # figure out winning char
-            if byte:
-                if char is not True and char is not False:
-                    pass
-                elif self.braille:
-                    char = CHARS_BRAILLE[byte]
+        for x_ in range(self.width_):
+            # char?
+            c = self.chars[x_ + y_*self.width_]
+            if isinstance(c, int):
+                if self.braille:
+                    assert c < 256
+                    c = CHARS_BRAILLE[c]
+                elif self.dots:
+                    assert c < 4
+                    c = CHARS_DOTS[c]
                 else:
-                    char = CHARS_DOTS[byte]
-            else:
-                char = ' '
+                    assert c < 2
+                    c = '.' if c else ' '
 
             # color?
-            if byte and self.color_ and color:
-                char = '\x1b[%sm%s\x1b[m' % (color, char)
+            if self.color_:
+                color = self.colors[x_ + y_*self.width_]
+                if color:
+                    c = '\x1b[%sm%s\x1b[m' % (color, c)
 
-            row_.append(char)
+            row_.append(c)
 
         return ''.join(row_)
 
diff --git a/scripts/plot.py b/scripts/plot.py
index 59edf4e0..3638a0cd 100755
--- a/scripts/plot.py
+++ b/scripts/plot.py
@@ -524,6 +524,168 @@ def psplit(s):
     return [m.group() for m in re.finditer(pattern.pattern + '|.', s)]
 
 
+# a little ascii renderer
+class Canvas:
+    def __init__(self, width, height, *,
+            color=False,
+            dots=False,
+            braille=False):
+        # scale if we're printing with dots or braille
+        if braille:
+            xscale, yscale = 2, 4
+        elif dots:
+            xscale, yscale = 1, 2
+        else:
+            xscale, yscale = 1, 1
+
+        self.width_ = width
+        self.height_ = height
+        self.width = xscale*width
+        self.height = yscale*height
+        self.xscale = xscale
+        self.yscale = yscale
+        self.color_ = color
+        self.dots = dots
+        self.braille = braille
+
+        # create initial canvas
+        self.chars = [0] * (width*height)
+        self.colors = [''] * (width*height)
+
+    def char(self, x, y, char=None):
+        # ignore out of bounds
+        if x < 0 or y < 0 or x >= self.width or y >= self.height:
+            return False
+
+        x_ = x // self.xscale
+        y_ = y // self.yscale
+        if char is not None:
+            c = self.chars[x_ + y_*self.width_]
+            # mask in sub-char pixel?
+            if isinstance(char, bool):
+                if not isinstance(c, int):
+                    c = 0
+                self.chars[x_ + y_*self.width_] = (c
+                        | (1
+                            << ((y%self.yscale)*self.xscale
+                                + (self.xscale-1)-(x%self.xscale))))
+            else:
+                self.chars[x_ + y_*self.width_] = char
+        else:
+            c = self.chars[x_ + y_*self.width_]
+            if isinstance(c, int):
+                return ((c
+                            >> ((y%self.yscale)*self.xscale
+                                + (self.xscale-1)-(x%self.xscale)))
+                        & 1) == 1
+            else:
+                return c
+
+    def color(self, x, y, color=None):
+        # ignore out of bounds
+        if x < 0 or y < 0 or x >= self.width or y >= self.height:
+            return ''
+
+        x_ = x // self.xscale
+        y_ = y // self.yscale
+        if color is not None:
+            self.colors[x_ + y_*self.width_] = color
+        else:
+            return self.colors[x_ + y_*self.width_]
+
+    def __getitem__(self, xy):
+        x, y = xy
+        return self.char(x, y)
+
+    def __setitem__(self, xy, char):
+        x, y = xy
+        self.char(x, y, char)
+
+    def point(self, x, y, *,
+            char=True,
+            color=''):
+        self.char(x, y, char)
+        self.color(x, y, color)
+
+    def line(self, x1, y1, x2, y2, *,
+            char=True,
+            color=''):
+        # incremental error line algorithm
+        ex = abs(x2 - x1)
+        ey = -abs(y2 - y1)
+        dx = +1 if x1 < x2 else -1
+        dy = +1 if y1 < y2 else -1
+        e = ex + ey
+
+        while True:
+            self.point(x1, y1, char=char, color=color)
+            e2 = 2*e
+
+            if x1 == x2 and y1 == y2:
+                break
+
+            if e2 > ey:
+                e += ey
+                x1 += dx
+
+            if x1 == x2 and y1 == y2:
+                break
+
+            if e2 < ex:
+                e += ex
+                y1 += dy
+
+        self.point(x2, y2, char=char, color=color)
+
+    def rect(self, x, y, w, h, *,
+            char=True,
+            color=''):
+        for j in range(h):
+            for i in range(w):
+                self.point(x+i, y+j, char=char, color=color)
+
+    def label(self, x, y, label, width=None, height=None, *,
+            color=''):
+        x_ = x
+        y_ = y
+        for char in label:
+            if char == '\n':
+                x_ = x
+                y_ -= self.yscale
+            else:
+                if ((width is None or x_ < x+width)
+                        and (height is None or y_ > y-height)):
+                    self.point(x_, y_, char=char, color=color)
+                x_ += self.xscale
+
+    def draw(self, row):
+        y_ = self.height_-1 - row
+        row_ = []
+        for x_ in range(self.width_):
+            # char?
+            c = self.chars[x_ + y_*self.width_]
+            if isinstance(c, int):
+                if self.braille:
+                    assert c < 256
+                    c = CHARS_BRAILLE[c]
+                elif self.dots:
+                    assert c < 4
+                    c = CHARS_DOTS[c]
+                else:
+                    assert c < 2
+                    c = '.' if c else ' '
+
+            # color?
+            if self.color_:
+                color = self.colors[x_ + y_*self.width_]
+                if color:
+                    c = '\x1b[%sm%s\x1b[m' % (color, c)
+
+            row_.append(c)
+
+        return ''.join(row_)
+
+
 # a hack log that preserves sign, with a linear region between -1 and 1
 def symlog(x):
     if x > 1:
@@ -533,30 +695,47 @@ def symlog(x):
     else:
         return x
 
+# our main plot class
 class Plot:
     def __init__(self, width, height, *,
+            color=False,
+            dots=False,
+            braille=False,
             xlim=None,
             ylim=None,
             xlog=False,
-            ylog=False,
-            braille=False,
-            dots=False):
-        # scale if we're printing with dots or braille
-        self.width = 2*width if braille else width
-        self.height = (4*height if braille
-                else 2*height if dots
-                else height)
+            ylog=False):
+        # let Canvas handle braille/dots scaling
+        self.canvas = Canvas(width, height,
+                color=color,
+                dots=dots,
+                braille=braille)
 
+        # we handle xlim/ylim scaling
         self.xlim = xlim or (0, width)
         self.ylim = ylim or (0, height)
         self.xlog = xlog
         self.ylog = ylog
-        self.braille = braille
-        self.dots = dots
 
-        self.grid = [('',False)]*(self.width*self.height)
+        # go ahead and draw out axis first, we let data overwrite this
+        # to make the best of the limited space
+        for x in range(self.width):
+            self.canvas.point(x, 0, char='-')
+        for y in range(self.height):
+            self.canvas.point(0, y, char='|')
+        self.canvas.point(self.width-1, 0, char='>')
+        self.canvas.point(0, self.height-1, char='^')
+        self.canvas.point(0, 0, char='+')
 
-    def scale(self, x, y):
+    @property
+    def width(self):
+        return self.canvas.width
+
+    @property
+    def height(self):
+        return self.canvas.height
+
+    def _scale(self, x, y):
         # scale and clamp
         try:
             if self.xlog:
@@ -581,131 +760,50 @@ class Plot:
         return x, y
 
     def point(self, x, y, *,
-            color=COLORS[0],
-            char=True):
+            char=True,
+            color=''):
         # scale
-        x, y = self.scale(x, y)
+        x, y = self._scale(x, y)
 
-        # ignore out of bounds points
-        if x >= 0 and x < self.width and y >= 0 and y < self.height:
-            self.grid[x + y*self.width] = (color, char)
+        # render to canvas
+        self.canvas.point(x, y,
+                char=char,
+                color=color)
 
     def line(self, x1, y1, x2, y2, *,
-            color=COLORS[0],
-            char=True):
+            char=True,
+            color=''):
         # scale
-        x1, y1 = self.scale(x1, y1)
-        x2, y2 = self.scale(x2, y2)
+        x1, y1 = self._scale(x1, y1)
+        x2, y2 = self._scale(x2, y2)
 
-        # incremental error line algorithm
-        ex = abs(x2 - x1)
-        ey = -abs(y2 - y1)
-        dx = +1 if x1 < x2 else -1
-        dy = +1 if y1 < y2 else -1
-        e = ex + ey
-
-        while True:
-            if x1 >= 0 and x1 < self.width and y1 >= 0 and y1 < self.height:
-                self.grid[x1 + y1*self.width] = (color, char)
-            e2 = 2*e
-
-            if x1 == x2 and y1 == y2:
-                break
-
-            if e2 > ey:
-                e += ey
-                x1 += dx
-
-            if x1 == x2 and y1 == y2:
-                break
-
-            if e2 < ex:
-                e += ex
-                y1 += dy
-
-        if x2 >= 0 and x2 < self.width and y2 >= 0 and y2 < self.height:
-            self.grid[x2 + y2*self.width] = (color, char)
+        # render to canvas
+        self.canvas.line(x1, y1, x2, y2,
+                char=char,
+                color=color)
 
     def plot(self, coords, *,
-            color=COLORS[0],
             char=True,
-            line_char=True):
+            line_char=True,
+            color=''):
         # draw lines
         if line_char:
             for (x1, y1), (x2, y2) in zip(coords, coords[1:]):
                 if y1 is not None and y2 is not None:
                     self.line(x1, y1, x2, y2,
-                            color=color,
-                            char=line_char)
+                            char=line_char,
+                            color=color)
 
         # draw points
         if char and (not line_char or char is not True):
             for x, y in coords:
                 if y is not None:
                     self.point(x, y,
-                            color=color,
-                            char=char)
+                            char=char,
+                            color=color)
 
-    def draw(self, row, *,
-            color=False):
-        # scale if needed
-        if self.braille:
-            xscale, yscale = 2, 4
-        elif self.dots:
-            xscale, yscale = 1, 2
-        else:
-            xscale, yscale = 1, 1
-
-        y = self.height//yscale-1 - row
-        row_ = []
-        for x in range(self.width//xscale):
-            best_f = ''
-            best_c = False
-
-            # encode into a byte
-            b = 0
-            for i in range(xscale*yscale):
-                f, c = self.grid[x*xscale+(xscale-1-(i%xscale))
-                        + (y*yscale+(i//xscale))*self.width]
-                if c:
-                    b |= 1 << i
-
-                if f:
-                    best_f = f
-                if c and c is not True:
-                    best_c = c
-
-            # use byte to lookup character
-            if b:
-                if best_c:
-                    c = best_c
-                elif self.braille:
-                    c = CHARS_BRAILLE[b]
-                else:
-                    c = CHARS_DOTS[b]
-            else:
-                c = ' '
-
-            # color?
-            if b and color and best_f:
-                c = '\x1b[%sm%s\x1b[m' % (best_f, c)
-
-            # draw axis in blank spaces
-            if not b:
-                if x == 0 and y == 0:
-                    c = '+'
-                elif x == 0 and y == self.height//yscale-1:
-                    c = '^'
-                elif x == self.width//xscale-1 and y == 0:
-                    c = '>'
-                elif x == 0:
-                    c = '|'
-                elif y == 0:
-                    c = '-'
-
-            row_.append(c)
-
-        return ''.join(row_)
+    def draw(self, row):
+        return self.canvas.draw(row)
 
 
 # some classes for organizing subplots into a grid
@@ -982,6 +1080,7 @@ def main(csv_paths, *,
         line_chars=[],
         colors=[],
         color=False,
+        dots=False,
         braille=False,
         points=False,
         points_and_lines=False,
@@ -1427,12 +1526,13 @@ def main(csv_paths, *,
             plot = Plot(
                     subwidth,
                     subheight,
+                    color=color,
+                    dots=dots or not line_chars,
+                    braille=braille,
                     xlim=xlim_,
                     ylim=ylim_,
                     xlog=xlog_,
-                    ylog=ylog_,
-                    braille=not line_chars and braille,
-                    dots=not line_chars and not braille)
+                    ylog=ylog_)
 
             for name, dataset in subdatasets.items():
                 plot.plot(
@@ -1551,7 +1651,7 @@ def main(csv_paths, *,
                                 s.xmargin[1], ''))
 
                     # draw plot!
-                    f.write(s.plot_.draw(subrow, color=color))
+                    f.write(s.plot_.draw(subrow))
 
                 # footer
                 else:
diff --git a/scripts/treemap.py b/scripts/treemap.py
index c9fea928..57969373 100755
--- a/scripts/treemap.py
+++ b/scripts/treemap.py
@@ -321,6 +321,8 @@ class Canvas:
         else:
             xscale, yscale = 1, 1
 
+        self.width_ = width
+        self.height_ = height
         self.width = xscale*width
         self.height = yscale*height
         self.xscale = xscale
@@ -330,50 +332,63 @@ class Canvas:
         self.braille = braille
 
         # create initial canvas
-        self.grid = [False] * (self.width*self.height)
-        self.colors = [''] * (self.width*self.height)
+        self.chars = [0] * (width*height)
+        self.colors = [''] * (width*height)
 
-    def __getitem__(self, xy):
-        x, y = xy
+    def char(self, x, y, char=None):
         # ignore out of bounds
         if x < 0 or y < 0 or x >= self.width or y >= self.height:
-            return
+            return False
 
-        return self.grid[x + y*self.width]
-
-    def __setitem__(self, xy, char):
-        x, y = xy
-        # ignore out of bounds
-        if x < 0 or y < 0 or x >= self.width or y >= self.height:
-            return
-
-        self.grid[x + y*self.width] = char
+        x_ = x // self.xscale
+        y_ = y // self.yscale
+        if char is not None:
+            c = self.chars[x_ + y_*self.width_]
+            # mask in sub-char pixel?
+            if isinstance(char, bool):
+                if not isinstance(c, int):
+                    c = 0
+                self.chars[x_ + y_*self.width_] = (c
+                        | (1
+                            << ((y%self.yscale)*self.xscale
+                                + (self.xscale-1)-(x%self.xscale))))
+            else:
+                self.chars[x_ + y_*self.width_] = char
+        else:
+            c = self.chars[x_ + y_*self.width_]
+            if isinstance(c, int):
+                return ((c
+                            >> ((y%self.yscale)*self.xscale
+                                + (self.xscale-1)-(x%self.xscale)))
+                        & 1) == 1
+            else:
+                return c
 
     def color(self, x, y, color=None):
         # ignore out of bounds
         if x < 0 or y < 0 or x >= self.width or y >= self.height:
-            return
+            return ''
 
+        x_ = x // self.xscale
+        y_ = y // self.yscale
         if color is not None:
-            self.colors[x + y*self.width] = color
+            self.colors[x_ + y_*self.width_] = color
         else:
-            return self.colors[x + y*self.width]
+            return self.colors[x_ + y_*self.width_]
+
+    def __getitem__(self, xy):
+        x, y = xy
+        return self.char(x, y)
+
+    def __setitem__(self, xy, char):
+        x, y = xy
+        self.char(x, y, char)
 
     def point(self, x, y, *,
             char=True,
             color=''):
-        # make sure non-bool chars map attrs to all points under char
-        if not isinstance(char, bool):
-            xscale, yscale = self.xscale, self.yscale
-        else:
-            xscale, yscale = 1, 1
-
-        for i in range(xscale*yscale):
-            x_ = x-(x%xscale) + (xscale-1-(i%xscale))
-            y_ = y-(y%yscale) + (i//xscale)
-
-            self[x_, y_] = char
-            self.color(x_, y_, color)
+        self.char(x, y, char)
+        self.color(x, y, color)
 
     def line(self, x1, y1, x2, y2, *,
             char=True,
@@ -386,7 +401,7 @@ class Canvas:
         e = ex + ey
 
         while True:
-            self.point(x1, y1, color=color, char=char)
+            self.point(x1, y1, char=char, color=color)
             e2 = 2*e
 
             if x1 == x2 and y1 == y2:
@@ -403,7 +418,7 @@ class Canvas:
                 e += ex
                 y1 += dy
 
-        self.point(x2, y2, color=color, char=char)
+        self.point(x2, y2, char=char, color=color)
 
     def rect(self, x, y, w, h, *,
             char=True,
@@ -427,47 +442,29 @@ class Canvas:
                 x_ += self.xscale
 
     def draw(self, row):
-        # scale if needed
-        xscale, yscale = self.xscale, self.yscale
-
-        y = self.height//yscale-1 - row
+        y_ = self.height_-1 - row
         row_ = []
-        for x in range(self.width//xscale):
-            color = ''
-            char = False
-            byte = 0
-            for i in range(xscale*yscale):
-                x_ = x*xscale + (xscale-1-(i%xscale))
-                y_ = y*yscale + (i//xscale)
-
-                # calculate char
-                char_ = self[x_, y_]
-                if char_:
-                    byte |= 1 << i
-                    if char_ is not True and char_ is not False:
-                        char = char_
-
-                # keep track of best color
-                color_ = self.color(x_, y_)
-                if color_:
-                    color = color_
-
-            # figure out winning char
-            if byte:
-                if char is not True and char is not False:
-                    pass
-                elif self.braille:
-                    char = CHARS_BRAILLE[byte]
+        for x_ in range(self.width_):
+            # char?
+            c = self.chars[x_ + y_*self.width_]
+            if isinstance(c, int):
+                if self.braille:
+                    assert c < 256
+                    c = CHARS_BRAILLE[c]
+                elif self.dots:
+                    assert c < 4
+                    c = CHARS_DOTS[c]
                 else:
-                    char = CHARS_DOTS[byte]
-            else:
-                char = ' '
+                    assert c < 2
+                    c = '.' if c else ' '
 
             # color?
-            if byte and self.color_ and color:
-                char = '\x1b[%sm%s\x1b[m' % (color, char)
+            if self.color_:
+                color = self.colors[x_ + y_*self.width_]
+                if color:
+                    c = '\x1b[%sm%s\x1b[m' % (color, c)
 
-            row_.append(char)
+            row_.append(c)
 
         return ''.join(row_)