mork 0.0.9 → 0.0.10

data/lib/mork/sheet_pdf.rb

@@ -1,12 +1,13 @@
+require 'mork/grid_pdf'
 require 'prawn'
 
 module Mork
   class SheetPDF < Prawn::Document
-    def initialize(content, grid=Grid.new)
-      @grid = case grid.class.to_s
-              when "String"; Grid.new grid
-              when "Mork::Grid";      grid
-              else raise "Invalid initialization parameter"
+    def initialize(content, grip=GridPDF.new)
+      @grip = case grip
+              when String, Hash; GridPDF.new grip
+              when Mork::GridPDF; grip
+              else raise 'Invalid initialization parameter'
               end
       super my_page_params
       # @content should be an array of hashes, one per page;
@@ -33,76 +34,66 @@ module Mork
         stroke_color "000000"
         line_width 0.3
         registration_marks
-        calibration_and_code content[:code]
+        barcode content[:barcode]
         header content[:header]
-        control content[:control] if content[:control]
         questions_and_choices content[:choices]
+        calibration_cells
       end
     end
     
     def my_page_params
       {
-        page_size: @grid.pdf_page_size,
-        margin: @grid.pdf_margins
+        page_size: @grip.page_size,
+        margin:    @grip.margins
       }
     end
     
     def registration_marks
       fill do
-        @grid.pdf_reg_marks.each do |r|
+        @grip.reg_marks.each do |r|
           circle r[:p], r[:r]
         end
       end
     end
     
-    def calibration_and_code(code)
+    def calibration_cells
+      font_size @grip.item_font_size do
+        stroke do
+          stroke_color "ff0000"
+          @grip.calibration_cell_areas.each_with_index do |a, i|
+            rounded_rectangle a[:p], a[:w], a[:h], [a[:h], a[:w]].min / 2
+            fill_color "ff0000"
+            text_box 'X', at: @grip.calibration_letter_xy(i)
+          end
+        end
+      end
+    end
+    
+    def barcode(code)
       fill do
         # draw the dark calibration bar
-        c = @grid.pdf_dark_calibration_area
+        c = @grip.ink_black_area
         rectangle c[:p], c[:w], c[:h]
         # draw the bars corresponding to the code
         # least to most significant bit, left to right
-        @grid.pdf_code_areas_for(code).each do |c|
+        @grip.barcode_bit_areas_for(code).each do |c|
           rectangle c[:p], c[:w], c[:h]
         end
       end
     end
     
-    def control(content)
-      font_size @grid.pdf_control_size do
-        text_box content[:string], at: @grid.pdf_control_xy,
-                                width: @grid.pdf_control_width,
-                                align: :right
-        stroke do
-          font_size 
-          stroke_color "ff0000"
-          # dark
-          a = @grid.pdf_ctrl_area_dark
-          rounded_rectangle a[:p], a[:w], a[:h], [a[:h], a[:w]].min / 2
-          fill_color "ff0000"
-          draw_text content[:labels][0], at: @grid.pdf_dark_control_letter_xy
-          # light
-          a = @grid.pdf_ctrl_area_light
-          rounded_rectangle a[:p], a[:w], a[:h], [a[:h], a[:w]].min / 2
-          fill_color "ff0000"
-          draw_text content[:labels][1], at: @grid.pdf_light_control_letter_xy
-          
-        end
-      end
-    end
-    
     def header(content)
       content.each do |k,v|
-        font_size @grid.pdf_header_size(k) do
-          if @grid.pdf_header_boxed?(k)
-            bounding_box @grid.pdf_header_xy(k), width: @grid.pdf_header_width(k), height: @grid.pdf_header_height(k) do
+        font_size @grip.header_size(k) do
+          if @grip.header_boxed?(k)
+            bounding_box @grip.header_xy(k), width: @grip.header_width(k), height: @grip.header_height(k) do
               stroke_bounds
-              bounding_box @grid.pdf_header_padding(k), width: @grid.pdf_header_width(k) do
+              bounding_box @grip.header_padding(k), width: @grip.header_width(k) do
                 text v
               end
             end
           else
-            text_box v, at: @grid.pdf_header_xy(k), width: @grid.pdf_header_width(k)
+            text_box v, at: @grip.header_xy(k), width: @grip.header_width(k)
           end
         end
       end
@@ -112,40 +103,43 @@ module Mork
       stroke do
         content.length.times do |q|
           fill_color "000000"
-          text_box "#{q+1}", at: @grid.pdf_qnum_xy(q),
-                             width: @grid.pdf_qnum_width,
+          text_box "#{q+1}", at: @grip.qnum_xy(q),
+                             width: @grip.qnum_width,
                              align: :right,
-                             size: @grid.pdf_qnum_size
+                             size: @grip.item_font_size
           stroke_color "ff0000"
-          font_size @grid.pdf_chlett_size
+          font_size @grip.item_font_size
           content[q].times do |c|
-            a = @grid.pdf_choice_cell_area q, c
+            a = @grip.choice_cell_area q, c
             rounded_rectangle a[:p], a[:w], a[:h], [a[:h], a[:w]].min / 2
             fill_color "ff0000"
-            draw_text (65+c).chr, at: @grid.pdf_choice_letter_xy(q, c)
+            text_box (65+c).chr, at: @grip.choice_letter_xy(q, c)
           end
         end
       end
     end
-
-    # def nquestions
-    #   @content[:choices].length
-    # end
-    #
-    # def nchoices(i)
-    #   @content[:choices][i]
-    # end
   end
 end
 
-class Fixnum
-  def mm
-    self * 2.83464566929134
-  end
-end
-
-class Float
-  def mm
-    self * 2.83464566929134
-  end
-end
+# def control(content)
+#   font_size @grip.control_size do
+#     text_box content[:string], at: @grip.control_xy,
+#                             width: @grip.control_width,
+#                             align: :right
+#     stroke do
+#       stroke_color "ff0000"
+#       # dark
+#       a = @grip.ctrl_area_dark
+#       rounded_rectangle a[:p], a[:w], a[:h], [a[:h], a[:w]].min / 2
+#       fill_color "ff0000"
+#       draw_text content[:labels][0], at: @grip.dark_control_letter_xy
+#       # light
+#       a = @grip.ctrl_area_light
+#       rounded_rectangle a[:p], a[:w], a[:h], [a[:h], a[:w]].min / 2
+#       fill_color "ff0000"
+#       draw_text content[:labels][1], at: @grip.light_control_letter_xy
+#
+#     end
+#   end
+# end
+#

data/lib/mork/version.rb

@@ -1,3 +1,3 @@
 module Mork
-  VERSION = "0.0.9"
+  VERSION = "0.0.10"
 end

data/lib/mork.rb

@@ -1,8 +1,4 @@
 require 'mork/version'
-require 'mork/sheet'
-require 'mork/grid'
-require 'mork/grid_const'
-require 'mork/mimage'
-require 'mork/mimage_list'
-require 'mork/npatch'
+require 'mork/extensions'
+require 'mork/sheet_omr'
 require 'mork/sheet_pdf'

data/spec/mork/extensions_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+module Mork
+  describe Array do
+    it 'should give the standard deviation' do
+      a = [ 20, 23, 23, 24, 25, 22, 12, 21, 29 ]
+      a.stdev.should == 4.594682917363407
+    end
+  end
+end

data/spec/mork/grid_omr_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+module Mork
+  describe GridOMR do
+    let(:grom) { GridOMR.new 1601, 2281, 'spec/samples/grid_omr_01.yml' }
+      
+    describe '#choice_cell_area' do
+      it 'returns the coordinates of the first choice cell' do
+        grom.choice_cell_area(0,0).should == {x: 63, y: 436, w: 51, h: 41}
+      end
+      
+      it 'returns the coordinates of the last choice cell' do
+        grom.choice_cell_area(119,4).should == {x: 1411, y: 2108, w: 51, h: 41}
+      end
+    end
+    
+    describe '#barcode_bit_area' do
+      # it 'returns the coordinates of the first barcode bit area' do
+      #   grom.barcode_bit_area(0).should == {x: 160, y: 2260, w: 25, h: 21}
+      # end
+      #
+      # it 'returns the coordinates of the last barcode bit area' do
+      #   grom.barcode_bit_area(39).should == {x: 1475, y: 2260, w: 25, h: 21}
+      # end
+      #
+      # it 'fails if an invalid barcode bit is requested' do
+      #   lambda { grom.barcode_bit_area(40) }.should raise_error
+      # end
+    end
+
+    describe '#rm_search_area' do
+      context 'on the first iteration' do
+        it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :tl reg_mark corner' do
+          c = grom.rm_search_area :tl, 0
+          c.should == {x: 15, y: 15, w: 91, h: 92}
+        end
+
+        it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :tr reg_mark corner' do
+          c = grom.rm_search_area :tr, 0
+          c.should == { x: 1494, y: 15, w: 91, h: 92 }
+        end
+
+        it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :br reg_mark corner' do
+          c = grom.rm_search_area :br, 0
+          c.should == { x: 1494, y: 2173, w: 91, h: 92 }
+        end
+
+        it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :bl reg_mark corner' do
+          c = grom.rm_search_area :bl, 0
+          c.should == { x: 15, y: 2173, w: 91, h: 92 }
+        end
+      end
+
+      context 'on the third iteration' do
+        it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :tl reg_mark corner' do
+          c = grom.rm_search_area :tl, 2
+          c.should == { x: 15, y: 15, w: 130, h: 131 }
+        end
+
+        it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :tr reg_mark corner' do
+          c = grom.rm_search_area :tr, 2
+          c.should == { x: 1456, y: 15, w: 130, h: 131 }
+        end
+
+        it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :br reg_mark corner' do
+          c = grom.rm_search_area :br, 2
+          c.should == { x: 1456, y: 2135, w: 130, h: 131 }
+        end
+
+        it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :bl reg_mark corner' do
+          c = grom.rm_search_area :bl, 2
+          c.should == { x: 15, y: 2135, w: 130, h: 131 }
+        end
+      end
+    end
+    
+    describe '#rm_edgy_x' do
+      it 'returns the minimum acceptable number of pixels from the regmark center to the edge of the rm_search_area' do
+        grom.rm_edgy_x.should == 24
+      end
+      it 'returns an integer' do
+        grom.rm_edgy_x.should be_a Fixnum
+      end
+    end
+
+    describe '#rm_edgy_y' do
+      it 'returns the minimum acceptable number of pixels from the regmark center to the edge of the rm_search_area' do
+        grom.rm_edgy_y.should == 24
+      end
+      it 'returns an integer' do
+        grom.rm_edgy_y.should be_a Fixnum
+      end
+    end
+    
+    describe '#rm_max_search_area_side' do
+      it 'returns the maximum extent of the regmark search area, 1/4 of the raw image horizontal pixels' do
+        grom.rm_max_search_area_side.should == 400
+      end
+      it 'returns an integer' do
+        grom.rm_max_search_area_side.should be_a Fixnum
+      end
+    end
+
+    describe '#max_choices_per_question' do
+      it 'returns the maximum number of choice cells per question' do
+        grom.max_choices_per_question.should == 5
+      end
+    end
+    
+    describe '#paper_white_area' do
+      it 'returns the coordinates of the white area used for barcode calibration' do
+        grom.paper_white_area.should == {x: 93, y: 2260, w: 25, h: 21}
+      end
+    end
+    
+    describe '#ink_black_area' do
+      it 'returns the coordinates of the barcode calibration bar' do
+        grom.ink_black_area.should == {x: 126, y: 2260, w: 25, h: 21}
+      end
+    end
+  end
+end

data/spec/mork/grid_spec.rb

@@ -2,10 +2,15 @@ require 'spec_helper'
 
 module Mork
   describe Grid do
+    context 'init params' do
+      it 'does not work with an integer' do
+        expect {Grid.new 1}.to raise_error
+      end
+    end
+
     context 'default grid' do
       before(:all) do
-        @grid = Grid.new
-        @grid.set_page_size 1601, 2281 # the size of sample01.jpg
+        @grid = Grid.new 'spec/samples/grid_omr_01.yml'
       end
       
       describe '#max_questions' do
@@ -14,144 +19,11 @@ module Mork
         end
       end
       
-      describe '#max_choices_per_question' do
-        it 'returns the maximum number of choice cells per question' do
-          @grid.max_choices_per_question.should == 5
-        end
-      end
-      
-      describe '#code_bits' do
-        it 'returns the number of bits used to define the form code' do
-          @grid.code_bits.should == 40
-        end
-        
-        it 'returns an integer' do
-          @grid.code_bits.should be_a Fixnum
-        end
-      end
-      
-      describe '#rm_search_area' do
-        context 'on the first iteration' do
-          it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :tl reg_mark corner' do
-            c = @grid.rm_search_area :tl, 0
-            c.should == {:x=>15, :y=>15, :w=>76, :h=>77}
-          end
-
-          it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :tr reg_mark corner' do
-            c = @grid.rm_search_area :tr, 0
-            c.should == { x: 1510, y: 15, w: 76, h: 77 }
-          end
-
-          it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :br reg_mark corner' do
-            c = @grid.rm_search_area :br, 0
-            c.should == { x: 1510, y: 2189, w: 76, h: 77 }
-          end
-
-          it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :bl reg_mark corner' do
-            c = @grid.rm_search_area :bl, 0
-            c.should == { x: 15, y: 2189, w: 76, h: 77 }
-          end
-        end
-
-        context 'on the third iteration' do
-          it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :tl reg_mark corner' do
-            c = @grid.rm_search_area :tl, 2
-            c.should == { x: 15, y: 15, w: 114, h: 115 }
-          end
-
-          it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :tr reg_mark corner' do
-            c = @grid.rm_search_area :tr, 2
-            c.should == { x: 1471, y: 15, w: 114, h: 115 }
-          end
-
-          it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :br reg_mark corner' do
-            c = @grid.rm_search_area :br, 2
-            c.should == { x: 1471, y: 2150, w: 114, h: 115 }
-          end
-
-          it 'returns an {:x, :y, :w, :h} hash of coordinates in pixels for the :bl reg_mark corner' do
-            c = @grid.rm_search_area :bl, 2
-            c.should == { x: 15, y: 2150, w: 114, h: 115 }
-          end
-        end
-      end
-      
-      describe '#rm_edgy_x' do
-        it 'returns the minimum acceptable number of pixels from the regmark center to the edge of the rm_search_area' do
-          @grid.rm_edgy_x.should == 24
-        end
-        it 'returns an integer' do
-          @grid.rm_edgy_x.should be_a Fixnum
-        end
-      end
-
-      describe '#rm_edgy_y' do
-        it 'returns the minimum acceptable number of pixels from the regmark center to the edge of the rm_search_area' do
-          @grid.rm_edgy_y.should == 24
-        end
-        it 'returns an integer' do
-          @grid.rm_edgy_y.should be_a Fixnum
-        end
-      end
-      
-      describe '#rm_max_search_area_side' do
-        it 'returns the maximum extent of the regmark search area, 1/4 of the raw image horizontal pixels' do
-          @grid.rm_max_search_area_side.should == 400
-        end
-        it 'returns an integer' do
-          @grid.rm_max_search_area_side.should be_a Fixnum
+      describe '#barcode_bits' do
+        it 'returns the number of bits used to define the form barcode' do
+          @grid.send(:barcode_bits).should == 40
         end
       end
-      
-      describe '#choice_cell_area' do
-        it 'returns the coordinates of the first choice cell' do
-          @grid.choice_cell_area(0,0).should == {x: 63, y: 436, w: 51, h: 41}
-        end
-        
-        it 'returns the coordinates of the last choice cell' do
-          @grid.choice_cell_area(119,4).should == {x: 1538, y: 2108, w: 51, h: 41}
-        end
-      end
-      
-      describe '#ctrl_area_dark' do
-        it 'returns the coordinates of the control cell used to set the darkened threshold' do
-          @grid.ctrl_area_dark.should == {:x=>1479, :y=>329, :w=>51, :h=>41}
-        end
-      end
-      
-      describe '#ctrl_area_light' do
-        it 'returns the coordinates of the control cell used to set the darkened threshold' do
-          @grid.ctrl_area_light.should == {:x=>1538, :y=>329, :w=>51, :h=>41}
-        end
-      end
-      
-      describe '#cal_area_white' do
-        it 'returns the coordinates of the white area used for code calibration' do
-          @grid.cal_area_white.should == {:x=>93, :y=>2260, :w=>25, :h=>21}
-        end
-      end
-      
-      describe '#cal_area_black' do
-        it 'returns the coordinates of the code calibration bar' do
-          @grid.cal_area_black.should == {:x=>126, :y=>2260, :w=>25, :h=>21}
-        end
-      end
-      
-      describe '#code_bit_area' do
-        it 'returns the coordinates of the first code bit area' do
-          @grid.code_bit_area(0).should == {:x=>160, :y=>2260, :w=>25, :h=>21}
-        end
-
-        it 'returns the coordinates of the last code bit area' do
-          @grid.code_bit_area(39).should == {:x=>1475, :y=>2260, :w=>25, :h=>21}
-        end
-        
-        it 'fails if an invalid code bit is requested' do
-          lambda { @grid.code_bit_area(40) }.should raise_error
-        end
-      end
-      
-      
     end
 
     
@@ -220,3 +92,15 @@ end
 #     c[:y].should be_within(4).of(3120)
 #   end
 # end
+
+# describe '#ctrl_area_dark' do
+#   it 'returns the coordinates of the control cell used to set the darkened threshold' do
+#     @grid.ctrl_area_dark.should == {:x=>1479, :y=>329, :w=>51, :h=>41}
+#   end
+# end
+#
+# describe '#ctrl_area_light' do
+#   it 'returns the coordinates of the control cell used to set the darkened threshold' do
+#     @grid.ctrl_area_light.should == {:x=>1538, :y=>329, :w=>51, :h=>41}
+#   end
+# end

data/spec/mork/sheet_omr_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+module Mork
+  describe SheetOMR do
+    context 'highlighting' do
+      # since these specs change the @crop, they must be run in isolation
+      # with the SheetOMR rebuilt each time, even though it is time consuming!
+      let(:sheet) { SheetOMR.new 'spec/samples/sample_gray.jpg', 'spec/samples/grid_omr_01.yml' }
+      
+      it 'highlights the registration areas and frame' do
+        sheet.highlight_reg_area
+        sheet.write_raw 'tmp/reg_areas.jpg'
+      end
+      
+      it 'should highlight all areas' do
+        sheet.highlight_all
+        sheet.write 'tmp/all_highlights.jpg'
+      end
+      
+      it 'should highlight marked cells and outline correct responses' do
+        sheet.highlight_marked
+        sheet.outline [[1],[1],[2],[2],[3,4],[],[0,1,2,3,4]]
+        sheet.write 'tmp/marked_highlights.jpg'
+      end
+    end
+
+    context 'marking a nicely printed and scanned sheet' do
+      before(:all) do
+        @sheet = SheetOMR.new('spec/samples/sample_gray.jpg', 'spec/samples/grid_omr_01.yml')
+      end
+      
+      describe '#valid?' do
+        it 'returns true' do
+          @sheet.valid?.should be_truthy
+        end
+      end
+      
+      describe '#marked?' do
+        it 'returns true for some darkened choices' do
+          expect(@sheet.marked?(0,0)).to be_truthy
+          expect(@sheet.marked?(1,1)).to be_truthy
+          expect(@sheet.marked?(2,2)).to be_truthy
+        end
+        
+        it 'return false for some blank choices' do
+          expect(@sheet.marked?(0,1)).to be_falsy
+          expect(@sheet.marked?(1,0)).to be_falsy
+          expect(@sheet.marked?(2,3)).to be_falsy
+        end
+
+        it 'writes out average whiteness of choice cells' do
+          puts "Choice threshold: #{@sheet.send :choice_threshold}"
+          File.open('tmp/choices.txt', 'w') do |f|
+            120.times do |q|
+              t = (0..4).collect do |c|
+                @sheet.send(:shade_of, q, c).round
+              end
+              f.puts "#{q+1}: #{t.join(' ')}"
+            end
+          end
+          
+          mf = File.open('tmp/marked.txt',   'w')
+          uf = File.open('tmp/unmarked.txt', 'w')
+          120.times do |q|
+            5.times do |c|
+              shade = @sheet.send(:shade_of, q, c)
+              @sheet.marked?(q,c) ? mf.puts(shade) : uf.puts(shade)
+            end
+          end
+          mf.close
+          uf.close
+        end
+      end
+
+      describe '#mark_array' do
+        it 'should return an array of marked choices for each of the first 5 questions' do
+          @sheet.mark_array(5).should == [[0], [1], [2], [3], [4]]
+        end
+
+        it 'should return an array of marked choices for the specified question set' do
+          @sheet.mark_array([0, 1, 13, 16, 31, 104, 21]).should == [[0], [1], [3,4], [2], [1], [], [0,1,2,3,4]]
+        end
+
+        it 'should return an array of @grid.max_questions length if called without arguments' do
+          @sheet.mark_array.length.should == 120
+        end
+      end
+
+      describe '#mark_logical_array' do
+        it 'should return an array of booleans for each of the first questions' do
+          @sheet.mark_logical_array(5).should == [
+            [true, false, false, false, false],
+            [false, true, false, false, false],
+            [false, false, true, false, false],
+            [false, false, false, true, false],
+            [false, false, false, false, true],
+          ]
+        end
+      end
+      
+      describe 'barcodes' do
+        it 'should read the bit string as all ones' do
+          @sheet.barcode_string.should == '1111111111111111111111111111111111111111'
+          @sheet.barcode.should == 1099511627775
+        end
+        
+        it 'should read another bit string' do
+          barcode_string = '0000000000000000000000000010000110100000'
+          s2 = SheetOMR.new('spec/samples/sample02.jpg')
+          s2.barcode_string.should == barcode_string
+          s2.barcode.should == 8608
+          s2.highlight_barcode
+          s2.write 'tmp/code_bits.jpg'
+        end
+
+        it 'should read the 666 bit string' do
+          s2 = SheetOMR.new('spec/samples/sheet666.jpg')
+          s2.barcode.should == 666666666666
+          s2.highlight_barcode
+          s2.write 'tmp/code_bits666.jpg'
+        end
+      end
+      
+    end
+    
+    context 'a faded, b&w, distorted sheet' do
+      it 'should return the correct barcode' do
+        SheetOMR.new('spec/samples/sample03.jpg').barcode.should == 8608
+      end
+    end
+
+    # context "multi-page pdf" do
+    #   before(:all) do
+    #     @mlist = MimageList.new('spec/samples/two_pages.pdf')
+    #   end
+    #
+    #   describe "reading the codes" do
+    #     it "should read the right code for the first page" do
+    #       s = SheetOMR.new(@mlist[0], Grid.new)
+    #       s.code.should == 18446744073709551615
+    #     end
+    #     it "should read the right code for the second page" do
+    #       s = SheetOMR.new(@mlist[1], Grid.new)
+    #       s.code.should == 283764283738
+    #     end
+    #   end
+    #
+    #   describe "getting the answers" do
+    #     it "should read the correct choices for the first page" do
+    #       s = SheetOMR.new(@mlist[0], Grid.new)
+    #       s.marked?( 0, 0).should be_truthy
+    #       s.marked?( 0, 1).should be_falsy
+    #       s.marked?(15, 3).should be_falsy
+    #       s.marked?(15, 4).should be_truthy
+    #     end
+    #
+    #     it "should read the correct choices for the second page" do
+    #       s = SheetOMR.new(@mlist[1], Grid.new)
+    #       s.mark_array(15).should == [[0], [1], [2], [3], [4], [0], [1], [2, 3], [4], [1, 2, 3], [0], [1], [2], [3], [4]]
+    #     end
+    #   end
+    # end
+  end
+end
+