breadkit-render 0.1.0 → 0.2.0

data/lib/breadkit/render/netlist_renderer.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Breadkit
+  module Render
+    # Shows each resolved net as a bus with its connected physical terminals.
+    # This layout keeps large circuits readable without crossing unrelated nets.
+    class NetlistRenderer
+      COLORS = %w[#d85e65 #4f8fd6 #319b7d #aa75c7 #c58a37 #4a9da7 #a0b95c #d57da8
+                  #8499df #d67c53 #55b58c #c299d3].freeze
+      WIDTH = 1120
+      LEFT = 48
+      CARD_WIDTH = WIDTH - LEFT * 2
+      TERMINALS_PER_ROW = 5
+
+      def render(circuit, theme: "light", state: nil)
+        raise ArgumentError, "unknown netlist theme: #{theme}" unless %w[light dark print].include?(theme)
+
+        colors = palette(theme)
+        nets = circuit.nets(state)
+        devices = component_devices(circuit) + supply_devices(circuit)
+        terminals = devices.flat_map { |device| device[:terminals] }
+        terminal_nets = nets.each_with_object({}) { |net, index| net.members.each { |member| index[member] = net } }
+        terminals.each do |terminal|
+          raise Error, "netlist cannot resolve terminal #{terminal[:id]}" unless terminal_nets[terminal[:id]]
+        end
+
+        device_rows = (devices.length.to_f / 3).ceil
+        net_y = 116 + device_rows * 88 + 58
+        net_y += 36 if devices.empty?
+        net_layout = nets.map do |net|
+          members = terminals.select { |terminal| terminal_nets[terminal[:id]] == net }
+          rows = (members.length.to_f / TERMINALS_PER_ROW).ceil
+          height = 82 + [rows, 1].max * 66
+          layout = { net: net, terminals: members, y: net_y, height: height }
+          net_y += height + 16
+          layout
+        end
+        height = [net_y + 32, 300].max
+
+        lines = []
+        lines << %(<?xml version="1.0" encoding="UTF-8"?>)
+        lines << %(<svg xmlns="http://www.w3.org/2000/svg" width="#{WIDTH}" height="#{height}" viewBox="0 0 #{WIDTH} #{height}" role="img" aria-label="Circuit netlist" data-view="netlist" data-theme="#{theme}"#{state&.name ? %( data-state="#{xml(state.name)}") : ""}>)
+        lines << %(<title>Circuit netlist</title>)
+        lines << %(<desc>#{xml((["Each colored bus is one resolved net. Terminals on the same bus are connected."] + nets.map { |net| "#{net.name}: #{net.members.join(', ')}" }).join(' '))}</desc>)
+        lines << %(<rect width="#{WIDTH}" height="#{height}" fill="#{colors[:background]}"/>)
+        lines << %(<g font-family="Arial, Helvetica, sans-serif">)
+        lines << %(<text x="48" y="39" fill="#{colors[:muted]}" font-size="11" font-weight="700" letter-spacing="2.4">BREADKIT / NETLIST</text>)
+        lines << %(<text x="48" y="76" fill="#{colors[:text]}" font-size="29" font-weight="700">Circuit netlist</text>)
+        lines << %(<text x="1072" y="75" text-anchor="end" fill="#{colors[:muted]}" font-size="12">#{devices.length} devices  ·  #{nets.length} nets#{state&.name ? "  ·  #{xml(state.name)} closed" : ""}</text>)
+        lines << %(<line x1="48" y1="93" x2="1072" y2="93" stroke="#{colors[:border]}"/>)
+
+        lines << %(<g id="devices">)
+        devices.each_with_index do |device, index|
+          x = LEFT + (index % 3) * 346
+          y = 116 + (index / 3) * 88
+          lines << %(<g data-ref="#{xml(device[:ref])}">)
+          lines << %(<rect x="#{x}" y="#{y}" width="328" height="70" rx="12" fill="#{colors[:card]}" stroke="#{colors[:border]}"/>)
+          lines << %(<text x="#{x + 18}" y="#{y + 30}" fill="#{colors[:text]}" font-size="17" font-weight="700">#{xml(device[:ref])}</text>)
+          lines << %(<text x="#{x + 18}" y="#{y + 51}" fill="#{colors[:muted]}" font-size="11">#{xml(device[:detail])}  ·  #{device[:terminals].length} pins</text>)
+          lines << %(</g>)
+        end
+        lines << %(</g>)
+        lines << %(<text x="48" y="#{net_layout.first ? net_layout.first[:y] - 18 : net_y - 18}" fill="#{colors[:muted]}" font-size="11" font-weight="700" letter-spacing="1.8">RESOLVED NETS</text>)
+
+        lines << %(<g id="nets">)
+        net_layout.each_with_index do |layout, index|
+          net = layout[:net]
+          y = layout[:y]
+          accent = COLORS[index % COLORS.length]
+          lines << %(<g data-net="#{xml(net.name)}">)
+          lines << %(<rect x="#{LEFT}" y="#{y}" width="#{CARD_WIDTH}" height="#{layout[:height]}" rx="12" fill="#{colors[:card]}" stroke="#{colors[:border]}"/>)
+          lines << %(<rect x="#{LEFT}" y="#{y}" width="5" height="#{layout[:height]}" rx="2.5" fill="#{accent}"/>)
+          lines << %(<text x="#{LEFT + 22}" y="#{y + 31}" fill="#{colors[:text]}" font-size="18" font-weight="700">#{xml(net.name)}</text>)
+          lines << %(<text x="#{LEFT + 22}" y="#{y + 51}" fill="#{colors[:muted]}" font-size="11">#{layout[:terminals].length} terminals  ·  #{net.holes.length} holes</text>)
+          lines << %(<line x1="#{LEFT + 20}" y1="#{y + 61}" x2="#{LEFT + CARD_WIDTH - 20}" y2="#{y + 61}" stroke="#{colors[:border]}"/>)
+          if layout[:terminals].empty?
+            lines << %(<text x="#{LEFT + 25}" y="#{y + 105}" fill="#{colors[:muted]}" font-size="12">No device terminals on this net</text>)
+          else
+            draw_terminals(lines, layout, accent, colors)
+          end
+          lines << %(</g>)
+        end
+        lines << %(</g>)
+        lines << %(</g></svg>)
+        lines.join("\n")
+      end
+
+      private
+
+      def draw_terminals(lines, layout, accent, colors)
+        y = layout[:y]
+        rows = (layout[:terminals].length.to_f / TERMINALS_PER_ROW).ceil
+        lines << %(<line x1="#{LEFT + 27}" y1="#{y + 77}" x2="#{LEFT + 27}" y2="#{y + 77 + (rows - 1) * 66}" stroke="#{accent}" stroke-width="2"/>) if rows > 1
+        layout[:terminals].each_slice(TERMINALS_PER_ROW).with_index do |terminals, row|
+          bus_y = y + 77 + row * 66
+          last_x = LEFT + 35 + (terminals.length - 1) * 196 + 90
+          lines << %(<line x1="#{LEFT + 27}" y1="#{bus_y}" x2="#{last_x}" y2="#{bus_y}" stroke="#{accent}" stroke-width="2"/>)
+          terminals.each_with_index do |terminal, column|
+            chip_x = LEFT + 35 + column * 196
+            center_x = chip_x + 90
+            lines << %(<path d="M #{center_x} #{bus_y} V #{bus_y + 13}" stroke="#{accent}" stroke-width="2" data-terminal="#{xml(terminal[:id])}" data-net="#{xml(layout[:net].name)}"/>)
+            lines << %(<circle cx="#{center_x}" cy="#{bus_y}" r="3" fill="#{accent}"/>)
+            lines << %(<rect x="#{chip_x}" y="#{bus_y + 13}" width="180" height="42" rx="8" fill="#{colors[:chip]}" stroke="#{colors[:border]}"/>)
+            lines << %(<text x="#{chip_x + 11}" y="#{bus_y + 39}" fill="#{colors[:text]}" font-size="13" font-weight="700">#{xml(terminal[:ref])}</text>)
+            lines << %(<text x="#{chip_x + 169}" y="#{bus_y + 39}" text-anchor="end" fill="#{colors[:muted]}" font-size="12">#{xml(terminal[:pin])}</text>)
+          end
+        end
+      end
+
+      def component_devices(circuit)
+        circuit.components.values.map do |component|
+          { ref: component.ref, detail: component.part.id,
+            terminals: component.pins.values.map { |pin| { id: "#{component.ref}.#{pin.name}", ref: component.ref, pin: pin.name } } }
+        end
+      end
+
+      def supply_devices(circuit)
+        circuit.supplies.map do |supply|
+          voltage = supply.voltage_range ? "#{supply.voltage_range.join('–')} V" : format("%g V", supply.voltage)
+          { ref: supply.name, detail: "Power supply · #{voltage}",
+            terminals: [{ id: "#{supply.name}.+", ref: supply.name, pin: "+" },
+                        { id: "#{supply.name}.-", ref: supply.name, pin: "−" }] }
+        end
+      end
+
+      def palette(theme)
+        return { background: "#ffffff", card: "#ffffff", chip: "#ffffff", border: "#bec5cf", text: "#111827", muted: "#4b5563" } if theme == "print"
+        return { background: "#0d1420", card: "#172233", chip: "#202d40", border: "#35435a", text: "#f2f6fc", muted: "#a5b4c8" } if theme == "dark"
+
+        { background: "#f4f7fb", card: "#ffffff", chip: "#f1f5fa", border: "#d6deea", text: "#172338", muted: "#63738a" }
+      end
+
+      def xml(value)
+        CGI.escapeHTML(value.to_s)
+      end
+    end
+  end
+end

data/lib/breadkit/render/orthogonal_router.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Breadkit
+  module Render
+    class OrthogonalRouter
+      DIRECTIONS = [[1, 0], [0, 1], [-1, 0], [0, -1]].freeze
+
+      def initialize(obstacles)
+        @obstacles = obstacles.map { |left, bottom, right, top| [left - 0.35, bottom - 0.35, right + 0.35, top + 0.35] }
+        @used_edges = Hash.new(0)
+      end
+
+      def route(from, to)
+        start = breakout(from, to)
+        goal = breakout(to, from)
+        start_grid, goal_grid = [start, goal].map { |point| point.map { |coordinate| (coordinate * 2).round } }
+        grid = search(start_grid, goal_grid)
+        points = [from, start, [start[0], start_grid[1] / 2.0]] + grid.map { |x, y| [x / 2.0, y / 2.0] } +
+                 [[goal[0], goal_grid[1] / 2.0], goal, to]
+        simplify(points)
+      end
+
+      private
+
+      def breakout(point, target)
+        box = @obstacles.find { |left, bottom, right, top| point[0].between?(left, right) && point[1].between?(bottom, top) }
+        return point unless box
+
+        left = (box[0] * 2).floor / 2.0 - 0.5
+        right = (box[2] * 2).ceil / 2.0 + 0.5
+        distance_left, distance_right = point[0] - left, right - point[0]
+        x = if distance_left == distance_right
+          target[0] < point[0] ? left : right
+        else
+          distance_left < distance_right ? left : right
+        end
+        [x, point[1]]
+      end
+
+      def search(start, goal)
+        all_x = [start[0], goal[0]] + @obstacles.flat_map { |box| [box[0] * 2, box[2] * 2] }
+        all_y = [start[1], goal[1]] + @obstacles.flat_map { |box| [box[1] * 2, box[3] * 2] }
+        xmin, xmax = all_x.min.floor - 4, all_x.max.ceil + 4
+        ymin, ymax = all_y.min.floor - 4, all_y.max.ceil + 4
+        heap = []
+        serial = 0
+        initial = [start[0], start[1], -1]
+        distance = { initial => 0 }
+        parent = {}
+        push(heap, [heuristic(start, goal), 0, serial, *initial])
+        until heap.empty?
+          _score, cost, _serial, x, y, direction = pop(heap)
+          key = [x, y, direction]
+          next unless distance[key] == cost
+          if [x, y] == goal
+            path = [key]
+            path << parent[path.last] while parent.key?(path.last)
+            points = path.reverse.map { |item| item.first(2) }
+            points.each_cons(2) { |a, b| @used_edges[edge(a, b)] += 1 }
+            return points
+          end
+          DIRECTIONS.each_with_index do |(dx, dy), next_direction|
+            nx, ny = x + dx, y + dy
+            next unless nx.between?(xmin, xmax) && ny.between?(ymin, ymax)
+            next if blocked?(nx, ny) && [nx, ny] != goal
+
+            next_key = [nx, ny, next_direction]
+            step = 1 + (direction >= 0 && direction != next_direction ? 2 : 0) + @used_edges[edge([x, y], [nx, ny])] * 5
+            next_cost = cost + step
+            next if distance.key?(next_key) && distance[next_key] <= next_cost
+
+            distance[next_key] = next_cost
+            parent[next_key] = key
+            serial += 1
+            push(heap, [next_cost + heuristic([nx, ny], goal), next_cost, serial, *next_key])
+          end
+          raise Error, "automatic wire route exceeds search limit" if distance.length > 100_000
+        end
+        raise Error, "no obstacle-free wire route found"
+      end
+
+      def blocked?(x, y)
+        @obstacles.any? { |left, bottom, right, top| x / 2.0 > left && x / 2.0 < right && y / 2.0 > bottom && y / 2.0 < top }
+      end
+
+      def heuristic(point, goal)
+        (point[0] - goal[0]).abs + (point[1] - goal[1]).abs
+      end
+
+      def edge(a, b)
+        (a <=> b).negative? ? [a, b] : [b, a]
+      end
+
+      def simplify(points)
+        result = []
+        points.each do |point|
+          next if result.last == point
+          result.pop if result.length >= 2 &&
+                        (result[-2][0] == result[-1][0] && result[-1][0] == point[0] ||
+                         result[-2][1] == result[-1][1] && result[-1][1] == point[1])
+          result << point
+        end
+        result
+      end
+
+      def push(heap, item)
+        index = heap.length
+        heap << item
+        while index.positive?
+          parent = (index - 1) / 2
+          break if (heap[parent] <=> item) <= 0
+
+          heap[index] = heap[parent]
+          index = parent
+        end
+        heap[index] = item
+      end
+
+      def pop(heap)
+        first = heap.first
+        last = heap.pop
+        return first if heap.empty?
+
+        index = 0
+        while (child = index * 2 + 1) < heap.length
+          child += 1 if child + 1 < heap.length && (heap[child + 1] <=> heap[child]).negative?
+          break if (last <=> heap[child]) <= 0
+
+          heap[index] = heap[child]
+          index = child
+        end
+        heap[index] = last
+        first
+      end
+    end
+  end
+end

data/lib/breadkit/render/rasterizer.rb

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
+require "tmpdir"
+
 module Breadkit
   module Render
     class Rasterizer
-      def rasterize(svg, format:, scale: 2.0, background: "white", quality: 90, backend: "auto")
+      class TimeoutError < Error; end
+
+      def rasterize(svg, format:, scale: 2.0, background: "white", quality: 90, backend: "auto", timeout: 60)
         format = format.to_s
         backend = backend.to_s
-        raise Error, "unsupported raster format: #{format}" unless %w[png jpeg].include?(format)
-        raise Error, "unsupported raster backend: #{backend}" unless %w[auto rsvg vips magick].include?(backend)
+        raise Error, "unsupported raster format: #{format}" unless %w[png jpeg webp pdf].include?(format)
+        raise Error, "unsupported raster backend: #{backend}" unless %w[auto rsvg resvg vips magick chrome].include?(backend)
 
         begin
           scale = Float(scale)
@@ -16,63 +20,150 @@ module Breadkit
         end
         raise Error, "scale must be a positive finite number" unless scale.finite? && scale.positive?
         raise Error, "quality must be an integer between 0 and 100" unless quality.is_a?(Integer) && quality.between?(0, 100)
+        raise Error, "render timeout must be a positive finite number" unless timeout.is_a?(Numeric) && timeout.finite? && timeout.positive?
         background = color(background) if format == "jpeg"
 
         candidates = case backend
         when "rsvg" then ["rsvg"]
+        when "resvg" then ["resvg"]
+        when "chrome" then ["chrome"]
         when "magick" then ["magick"]
         when "vips" then ["vips"]
-        else format == "png" ? %w[rsvg vips magick] : %w[vips magick]
+        else case format
+        when "png" then %w[rsvg resvg vips magick chrome]
+        when "pdf" then %w[rsvg]
+        else %w[vips magick]
+        end
         end
         candidates.each do |name|
           next unless supports?(name, format)
           begin
-            return send(name, svg, format, scale, background, quality)
-          rescue Error
-            raise if backend != "auto"
+            return send(name, svg, format, scale, background, quality, timeout)
+          rescue Error => e
+            raise if backend != "auto" || e.is_a?(TimeoutError)
           end
         end
-        raise Error, "no raster backend found for #{format}; install librsvg (brew install librsvg / apt install librsvg2-bin) or ImageMagick"
+        raise Error, "no conversion backend found for #{format}; install librsvg, resvg, ruby-vips, ImageMagick, or Chrome"
       end
 
       private
 
       def supports?(name, format)
-        return !!executable("rsvg-convert") if name == "rsvg" && format == "png"
-        return !!magick_command if name == "magick"
-        return false unless name == "vips"
+        return !!executable("rsvg-convert") if name == "rsvg" && %w[png pdf].include?(format)
+        return !!executable("resvg") if name == "resvg" && format == "png"
+        return !!chrome_binary if name == "chrome" && format == "png"
+        return !!magick_command if name == "magick" && format != "pdf"
+        return false unless name == "vips" && format != "pdf"
         require "vips"
         true
       rescue LoadError
         false
       end
 
-      def rsvg(svg, _format, scale, _background, _quality)
-        stdout, stderr, status = Open3.capture3(executable("rsvg-convert"), "--format=png", "--zoom=#{scale}", stdin_data: svg, binmode: true)
+      def rsvg(svg, format, scale, _background, _quality, timeout)
+        stdout, stderr, status = capture_command(executable("rsvg-convert"), "--format=#{format}", "--zoom=#{scale}", svg: svg, timeout: timeout)
         raise Error, "rsvg-convert failed: #{stderr}" unless status.success?
         stdout
       end
 
-      def magick(svg, format, scale, background, quality)
+      def resvg(svg, _format, scale, _background, _quality, timeout)
+        stdout, stderr, status = capture_command(executable("resvg"), "-z", scale.to_s, "-", "-c", svg: svg, timeout: timeout)
+        raise Error, "resvg failed: #{stderr}" unless status.success?
+
+        stdout
+      end
+
+      def chrome(svg, _format, scale, background, _quality, timeout)
+        raise Error, "Chrome PNG supports only an opaque white background" unless background == "white"
+
+        width, height = chrome_dimensions(svg, scale)
+        Dir.mktmpdir("breadkit-chrome-") do |dir|
+          html_path = File.join(dir, "image.html")
+          png_path = File.join(dir, "image.png")
+          error_path = File.join(dir, "chrome.log")
+          encoded = [svg].pack("m0")
+          File.write(html_path, %(<html><head><meta charset="utf-8"><style>html,body{margin:0;padding:0}img{display:block;width:#{width}px;height:#{height}px}</style></head><body><img src="data:image/svg+xml;base64,#{encoded}"></body></html>))
+          command = [chrome_binary, "--headless", "--disable-gpu", "--disable-background-networking", "--no-first-run",
+                     "--no-default-browser-check", "--hide-scrollbars", "--force-device-scale-factor=1",
+                     "--window-size=#{width},#{height}", "--screenshot=#{png_path}",
+                     "--user-data-dir=#{File.join(dir, 'profile')}", "file://#{html_path}"]
+          process_options = { out: File::NULL, err: error_path }
+          process_options[:pgroup] = true unless RbConfig::CONFIG["host_os"].match?(/mswin|mingw/i)
+          pid = Process.spawn(*command, **process_options)
+          begin
+            deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+            loop do
+              if File.file?(png_path)
+                bytes = File.binread(png_path)
+                if bytes.start_with?("\x89PNG\r\n\x1a\n".b) && bytes.end_with?("IEND\xAE\x42\x60\x82".b)
+                  actual = bytes.byteslice(16, 8).unpack("N2")
+                  raise Error, "Chrome PNG dimensions #{actual.join('x')} differ from #{width}x#{height}" unless actual == [width, height]
+                  return bytes
+                end
+              end
+              break if Process.waitpid(pid, Process::WNOHANG)
+              raise TimeoutError, "Chrome timed out after #{timeout} seconds" if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+              sleep 0.02
+            end
+            raise Error, "Chrome failed: #{File.read(error_path).lines.last.to_s.strip}"
+          ensure
+            signal = process_options[:pgroup] ? -pid : pid
+            begin
+              Process.kill("KILL", signal)
+              Process.waitpid(pid)
+            rescue Errno::ESRCH, Errno::ECHILD
+              nil
+            end
+          end
+        end
+      end
+
+      def chrome_dimensions(svg, scale)
+        match = /<svg\b[^>]*\bwidth="([\d.]+)"\s+height="([\d.]+)"/.match(svg)
+        raise Error, "Chrome needs SVG width and height dimensions" unless match
+
+        dimensions = match.captures.map { |value| (value.to_f * scale).round }
+        raise Error, "Chrome dimensions must be 1 to 16384 pixels" unless dimensions.all? { |value| value.between?(1, 16_384) }
+        raise Error, "Chrome image exceeds 25 million pixels" if dimensions.inject(:*) > 25_000_000
+
+        dimensions
+      end
+
+      def chrome_binary
+        configured = ENV["BREADKIT_CHROME"]
+        return configured if configured && File.executable?(configured)
+
+        %w[google-chrome chromium chromium-browser chrome].each do |name|
+          path = executable(name)
+          return path if path
+        end
+        mac = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+        mac if File.executable?(mac)
+      end
+
+      def magick(svg, format, scale, background, quality, timeout)
         command = magick_command
-        background_color = format == "png" ? "none" : "##{background.map { |channel| channel.to_s(16).rjust(2, "0") }.join}"
+        background_color = format == "jpeg" ? "##{background.map { |channel| channel.to_s(16).rjust(2, "0") }.join}" : "none"
         args = ["-density", (96 * scale).to_s, "-background", background_color]
         font = font_file
         args.concat(["-font", font]) if font
         args << "svg:-"
         args += ["-background", background_color, "-alpha", "remove"] if format == "jpeg"
-        args += ["-quality", quality.to_s] if format == "jpeg"
+        args += ["-quality", quality.to_s] if %w[jpeg webp].include?(format)
         args << "#{format}:-"
-        stdout, stderr, status = Open3.capture3(command, *args, stdin_data: svg, binmode: true)
+        stdout, stderr, status = capture_command(command, *args, svg: svg, timeout: timeout)
         raise Error, "ImageMagick failed: #{stderr}" unless status.success?
         stdout
       end
 
-      def vips(svg, format, scale, background, quality)
+      def vips(svg, format, scale, background, quality, _timeout)
         image = Vips::Image.svgload_buffer(svg, scale: scale.to_f)
         if format == "jpeg"
           image = image.flatten(background: background) if image.has_alpha?
           image.jpegsave_buffer(Q: quality.to_i)
+        elsif format == "webp"
+          image.webpsave_buffer(Q: quality.to_i)
         else
           image.pngsave_buffer
         end
@@ -80,6 +171,35 @@ module Breadkit
         raise Error, "libvips failed: #{e.message}"
       end
 
+      def capture_command(*command, svg:, timeout:)
+        Open3.popen3(*command) do |stdin, stdout, stderr, process|
+          [stdin, stdout, stderr].each(&:binmode)
+          writer = Thread.new do
+            stdin.write(svg)
+          rescue Errno::EPIPE, IOError
+            nil
+          ensure
+            stdin.close
+          end
+          output = Thread.new { stdout.read }
+          errors = Thread.new { stderr.read }
+          unless process.join(timeout)
+            begin
+              Process.kill("KILL", process.pid)
+            rescue Errno::ESRCH
+              nil
+            end
+            process.join
+            raise TimeoutError, "#{File.basename(command.first)} timed out after #{timeout} seconds"
+          end
+          raise TimeoutError, "#{File.basename(command.first)} output timed out after #{timeout} seconds" unless output.join(timeout) && errors.join(timeout)
+          [output.value, errors.value, process.value]
+        ensure
+          stdin.close unless stdin.closed?
+          [writer, output, errors].each { |thread| thread.kill if thread&.alive? }
+        end
+      end
+
       def color(value)
         named = { "aqua" => [0, 255, 255], "black" => [0, 0, 0], "blue" => [0, 0, 255],
                   "fuchsia" => [255, 0, 255], "gray" => [128, 128, 128], "green" => [0, 128, 0],