refactor: rename matrix -> canvas

spec/mask_spec.cr

@@ -5,7 +5,7 @@ module Goban
     describe ".evaluate_score" do
       it "reports correct score" do
         version = QR::Version.new(1)
-        canvas = Matrix(UInt8).new(version.symbol_size, version.symbol_size, 0)
+        canvas = Canvas(UInt8).new(version.symbol_size, version.symbol_size, 0)
         QR::Template.draw_function_patterns(canvas, version)
 
         expected = 283 + 283 + 711 + 360 + 360 + 50 # = 2047
@@ -18,7 +18,7 @@ module Goban
     describe ".evaluate_score" do
       it "reports correct score" do
         version = MQR::Version.new(1)
-        canvas = Matrix(UInt8).new(version.symbol_size, version.symbol_size, 0)
+        canvas = Canvas(UInt8).new(version.symbol_size, version.symbol_size, 0)
         canvas[10, 0, 1, 6] = 1
         canvas[0, 10, 5, 1] = 1
 

spec/mqr_spec.cr

@@ -49,7 +49,7 @@ module Goban
     describe ".draw_data_codewords" do
       it "fills codewords properly" do
         version = MQR::Version.new(1)
-        canvas = Matrix(UInt8).new(version.symbol_size, version.symbol_size, 0)
+        canvas = Canvas(UInt8).new(version.symbol_size, version.symbol_size, 0)
         canvas[3, 3, 3, 3] = 0xc0
 
         codewords = Slice(UInt8).new(11 ** 2 // 8, 154)
@@ -63,7 +63,7 @@ module Goban
     describe ".apply_best_mask" do
       it "applies best mask" do
         version = MQR::Version.new(1)
-        canvas = Matrix(UInt8).new(version.symbol_size, version.symbol_size, 0)
+        canvas = Canvas(UInt8).new(version.symbol_size, version.symbol_size, 0)
         canvas.data.map_with_index! { |_, idx| idx.odd?.to_unsafe.to_u8 }
 
         MQR::Encoder.apply_best_mask(canvas, version, ECC::Level::Low)[0].value.should eq(3)

spec/qr_spec.cr

@@ -47,7 +47,7 @@ module Goban
     end
 
     describe ".decode" do
-      canvas = convert_text_to_matrix(SAMPLE_RESULT_MODS_QR)
+      canvas = convert_text_to_canvas(SAMPLE_RESULT_MODS_QR)
 
       it "decodes properly" do
         segments = QR.decode(canvas).segments
@@ -58,7 +58,7 @@ module Goban
     describe ".draw_data_codewords" do
       it "fills codewords properly" do
         version = QR::Version.new(1)
-        canvas = Matrix(UInt8).new(version.symbol_size, version.symbol_size, 0)
+        canvas = Canvas(UInt8).new(version.symbol_size, version.symbol_size, 0)
         canvas[8, 8, 7, 7] = 0xc0
 
         codewords = Slice(UInt8).new(21 ** 2 // 8, 154)
@@ -72,7 +72,7 @@ module Goban
     describe ".apply_best_mask" do
       it "applies best mask" do
         version = QR::Version.new(1)
-        canvas = Matrix(UInt8).new(version.symbol_size, version.symbol_size, 0)
+        canvas = Canvas(UInt8).new(version.symbol_size, version.symbol_size, 0)
         canvas.data.map_with_index! { |_, idx| idx.odd?.to_unsafe.to_u8 }
 
         QR::Encoder.apply_best_mask(canvas, ECC::Level::Low)[0].value.should eq(2)

spec/spec_helper.cr

@@ -1,7 +1,7 @@
 require "spec"
 require "../src/goban"
 
-def convert_canvas_to_text(canvas : Goban::Matrix(UInt8))
+def convert_canvas_to_text(canvas : Goban::Canvas(UInt8))
   String.build do |io|
     canvas.each_row do |row|
       row.each do |mod|
@@ -12,17 +12,17 @@ def convert_canvas_to_text(canvas : Goban::Matrix(UInt8))
   end.lines
 end
 
-def convert_text_to_matrix(lines : Array(String))
-  matrix = Goban::Matrix(UInt8).new(lines[0].size // 2, lines.size, 0)
+def convert_text_to_canvas(lines : Array(String))
+  canvas = Goban::Canvas(UInt8).new(lines[0].size // 2, lines.size, 0)
 
   lines.each_with_index do |line, y|
     line.each_char.each_slice(2, reuse: true).with_index do |slice, x|
       mod = slice[0] == '█' ? 1_u8 : 0_u8
-      matrix[x, y] = mod
+      canvas[x, y] = mod
     end
   end
 
-  matrix
+  canvas
 end
 
 ALL_NUMERIC_STR  = "0123456789"

spec/template_spec.cr

@@ -5,7 +5,7 @@ module Goban
     describe ".draw_function_patterns" do
       it "draws all function patterns" do
         version = QR::Version.new(7)
-        canvas = Matrix(UInt8).new(version.symbol_size, version.symbol_size, 0)
+        canvas = Canvas(UInt8).new(version.symbol_size, version.symbol_size, 0)
         QR::Template.draw_function_patterns(canvas, version)
         canvas.normalize
 
@@ -19,7 +19,7 @@ module Goban
     describe ".draw_function_patterns" do
       it "draws all function patterns" do
         version = MQR::Version.new(1)
-        canvas = Matrix(UInt8).new(version.symbol_size, version.symbol_size, 0)
+        canvas = Canvas(UInt8).new(version.symbol_size, version.symbol_size, 0)
         MQR::Template.draw_function_patterns(canvas)
         canvas.normalize
 
@@ -33,7 +33,7 @@ module Goban
     describe ".draw_function_patterns" do
       it "draws all function patterns" do
         version = RMQR::Version.new(RMQR::VersionValue::R7x77)
-        canvas = Matrix(UInt8).new(version.symbol_size.width, version.symbol_size.height, 0)
+        canvas = Canvas(UInt8).new(version.symbol_size.width, version.symbol_size.height, 0)
         RMQR::Template.draw_function_patterns(canvas, version, ECC::Level::Medium)
         canvas.normalize
 

src/goban/abstract/mask.cr

@@ -9,7 +9,7 @@ abstract struct Goban::AbstractQR
 
     # Apply mask to the given canvas.
     # Call this method again to reverse the applied mask.
-    protected def apply_to(canvas : Matrix(UInt8))
+    protected def apply_to(canvas : Canvas(UInt8))
       canvas.size_y.times do |y|
         canvas.size_x.times do |x|
           value = canvas[x, y]

src/goban/abstract/template.cr

@@ -26,7 +26,7 @@ abstract struct Goban::AbstractQR
       0xc1_u8, 0xc1_u8, 0xc1_u8,
     }
 
-    protected def draw_pattern(canvas : Matrix(UInt8), x : Int, y : Int, pattern, pattern_size : Int)
+    protected def draw_pattern(canvas : Canvas(UInt8), x : Int, y : Int, pattern, pattern_size : Int)
       pattern_size.times do |i|
         xx = x + i
         pattern_size.times do |j|
@@ -36,7 +36,7 @@ abstract struct Goban::AbstractQR
       end
     end
 
-    protected def draw_timing_pattern(canvas : Matrix(UInt8), j : Int, count : Int)
+    protected def draw_timing_pattern(canvas : Canvas(UInt8), j : Int, count : Int)
       count.times do |k|
         i = 8 + k
         mod = i.even? ? 0xc1_u8 : 0xc0_u8

src/goban/matrix.cr → src/goban/canvas.cr

@@ -1,6 +1,6 @@
 module Goban
-  # Data type representing 2D matrix symbol.
-  struct Matrix(T)
+  # Data type representing 2D canvas symbol.
+  struct Canvas(T)
     include Indexable::Mutable(T)
 
     getter size_x : Int32
@@ -20,7 +20,7 @@ module Goban
     end
 
     def clone
-      Matrix(T).new(@size_x, @size_y, @data.dup)
+      Canvas(T).new(@size_x, @size_y, @data.dup)
     end
 
     def size

src/goban/mqr.cr

@@ -16,7 +16,7 @@ module Goban
     getter segments : Array(Segment)
     # Returns the canvas of the Micro QR Code symbol. Canvas contains information about
     # each single module (pixel) in the symbol.
-    getter canvas : Matrix(UInt8)
+    getter canvas : Canvas(UInt8)
     # Length of a side in the symbol.
     getter size : Int32
     # Mask applied to this Micro QR Code symbol.

src/goban/mqr/decoder.cr

@@ -9,17 +9,17 @@ struct Goban::MQR < Goban::AbstractQR
       end
     end
 
-    def decode_to_string(matrix : Matrix(UInt8))
-      segments = self.decode(matrix).segments
+    def decode_to_string(canvas : Canvas(UInt8))
+      segments = self.decode(canvas).segments
       segments.join { |seg| seg.text }
     end
 
-    def decode(matrix : Matrix(UInt8))
-      raise InputError.new("Matrix not square") unless matrix.size_x == matrix.size_y
+    def decode(canvas : Canvas(UInt8))
+      raise InputError.new("Canvas not square") unless canvas.size_x == canvas.size_y
 
-      version = (matrix.size_x - 9) // 2
+      version = (canvas.size_x - 9) // 2
       raise InputError.new("Invalid version") unless (Version::MIN..Version::MAX).includes?(version)
-      mask, symbol_num = self.read_format(matrix)
+      mask, symbol_num = self.read_format(canvas)
       ecl = nil
       Version::SYMBOL_NUMS.each_with_index do |group, ver|
         group.each do |key, bits|
@@ -35,10 +35,10 @@ struct Goban::MQR < Goban::AbstractQR
       p! version, mask, ecl
 
       # For reserving function patterns
-      Template.draw_function_patterns(matrix)
-      mask.apply_to(matrix)
+      Template.draw_function_patterns(canvas)
+      mask.apply_to(canvas)
 
-      raw_data_codewords = self.read_data_codewords(matrix, version, ecl)
+      raw_data_codewords = self.read_data_codewords(canvas, version, ecl)
       data_codewords = ECC::RSDeflator.deflate_codewords(raw_data_codewords, version, ecl)
 
       bit_stream = BitStream.new(data_codewords)
@@ -62,20 +62,20 @@ struct Goban::MQR < Goban::AbstractQR
         bit_stream.read_pos -= terminator_bits_size
       end
 
-      MQR.new(version, ecl, segments, matrix, mask)
+      MQR.new(version, ecl, segments, canvas, mask)
     end
 
-    private def read_format(matrix : Matrix(UInt8))
-      size = matrix.size_x
+    private def read_format(canvas : Canvas(UInt8))
+      size = canvas.size_x
 
       f_bits = 0
       (8..14).reverse_each do |i|
         pos = 15 - i
-        f_bits = (f_bits << 1) | matrix[pos, 8]
+        f_bits = (f_bits << 1) | canvas[pos, 8]
       end
       (0..7).reverse_each do |i|
         pos = i + 1
-        f_bits = (f_bits << 1) | matrix[8, pos]
+        f_bits = (f_bits << 1) | canvas[8, pos]
       end
 
       f_best, f_best_diff = nil, 15
@@ -96,8 +96,8 @@ struct Goban::MQR < Goban::AbstractQR
       f_best
     end
 
-    private def read_data_codewords(matrix : Matrix(UInt8), version : Version, ecl : ECC::Level)
-      size = matrix.size
+    private def read_data_codewords(canvas : Canvas(UInt8), version : Version, ecl : ECC::Level)
+      size = canvas.size
       data_codewords = Slice(UInt8).new(version.raw_max_data_codewords, 0)
       data_length = data_codewords.size * 8
 
@@ -109,7 +109,7 @@ struct Goban::MQR < Goban::AbstractQR
           (0..1).each do |alt|
             x = base_x - alt
             y = upward ? base_y : size - 1 - base_y
-            bit = matrix[x, y]
+            bit = canvas[x, y]
             next if bit & 0x80 > 0
             return data_codewords if i >= data_length
 

src/goban/mqr/encoder.cr

@@ -70,7 +70,7 @@ struct Goban::MQR < Goban::AbstractQR
       {segments, version}
     end
 
-    protected def draw_codewords(canvas : Matrix(UInt8), codewords : Slice(UInt8), version : Version, ecl : ECC::Level)
+    protected def draw_codewords(canvas : Canvas(UInt8), codewords : Slice(UInt8), version : Version, ecl : ECC::Level)
       size = canvas.size
       data_length = codewords.size * 8
 
@@ -106,7 +106,7 @@ struct Goban::MQR < Goban::AbstractQR
       end
     end
 
-    protected def apply_best_mask(canvas : Matrix(UInt8), version : Version, ecl : ECC::Level)
+    protected def apply_best_mask(canvas : Canvas(UInt8), version : Version, ecl : ECC::Level)
       mask, best_canvas = nil, nil
       max_score = Int32::MIN
 

src/goban/mqr/mask.cr

@@ -42,7 +42,7 @@ struct Goban::MQR < Goban::AbstractQR
 
     # Evaluate penalty score for the given canvas.
     # It assumes that one of the masks is applied to the canvas.
-    protected def self.evaluate_score(canvas : Matrix(UInt8))
+    protected def self.evaluate_score(canvas : Canvas(UInt8))
       s1, s2 = 0, 0
       canvas.size.times do |i|
         s1 += canvas[canvas.size - 1, i] & 1

src/goban/mqr/template.cr

@@ -4,10 +4,10 @@ struct Goban::MQR < Goban::AbstractQR
     extend self
     include AbstractQR::Template
 
-    # Creates a new matrix canvas with all the function patterns drawn for the given version.
+    # Creates a new canvas canvas with all the function patterns drawn for the given version.
     protected def make_canvas(version : Version)
       size = version.symbol_size
-      canvas = Matrix(UInt8).new(size, size, 0)
+      canvas = Canvas(UInt8).new(size, size, 0)
       self.draw_function_patterns(canvas)
 
       canvas
@@ -18,15 +18,15 @@ struct Goban::MQR < Goban::AbstractQR
     #
     # - Finder patterns on the top left corner
     # - Timing patterns in both directions
-    protected def draw_function_patterns(canvas : Matrix(UInt8))
+    protected def draw_function_patterns(canvas : Canvas(UInt8))
       canvas[0, 0, 9, 9] = 0xc0
 
       self.draw_pattern(canvas, 0, 0, FINDER_PATTERN, 7)
 
       self.draw_timing_pattern(canvas, 0, canvas.size - 8)
     end
 
-    protected def draw_format_modules(canvas : Matrix(UInt8), mask : Mask, ver : Version, ecl : ECC::Level)
+    protected def draw_format_modules(canvas : Canvas(UInt8), mask : Mask, ver : Version, ecl : ECC::Level)
       bits = mask.get_format_bits(ver, ecl)
 
       (0...8).each do |i|

src/goban/qr.cr

@@ -17,7 +17,7 @@ module Goban
     getter segments : Array(Segment)
     # Returns the canvas of the QR Code symbol. Canvas contains information about
     # each single module (pixel) in the symbol.
-    getter canvas : Matrix(UInt8)
+    getter canvas : Canvas(UInt8)
     # Length of a side in the symbol.
     getter size : Int32
     # Mask applied to this QR Code symbol.