img_to_script 1.0.0

data/lib/img_to_script/generators/run_length_encoding/vertical.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Generators
+    module RunLengthEncoding
+      #
+      # RLE - vertical scanlines.
+      #
+      class Vertical < RunLengthEncoding
+        private
+
+        def _generate
+          _transpose
+          @pixels = @image.get_pixels(0, 0, @image.width, @image.height)
+          _encode_pixels
+          _append_decoder
+        end
+
+        def _append_decoder
+          @image_size = @image.width + @y_offset
+          @segment_size = @image_size - 1
+
+          @major_axis_symbol = Y_LBL
+          @minor_axis_symbol = X_LBL
+
+          @major_axis_value = @y_offset
+
+          @part_line_pattern = _part_line_pattern
+          @full_line_pattern = _full_line_pattern
+
+          super
+        end
+
+        #
+        # Part-length line, i.e. a line that fills only
+        # a part of the scan line.
+        #
+        # Formatted for the vertical scan lines.
+        #
+        def _part_line_pattern
+          AbstractToken::DrawLineByAbsCoords.new(
+            x0: X_LBL,
+            y0: Y_LBL,
+            x1: X_LBL,
+            y1: _y1_expression
+          )
+        end
+
+        #
+        # Expression to evaluate y1 point.
+        #
+        def _y1_expression
+          AbstractToken::MathSub.new(
+            left: AbstractToken::MathAdd.new(
+              left: Y_LBL,
+              right: READ_VAR
+            ),
+            right: "1"
+          )
+        end
+
+        #
+        # Full-length line pattern, i.e. a line that fills
+        # the whole scan line.
+        #
+        # Formatted for the vertical scan lines.
+        #
+        def _full_line_pattern
+          AbstractToken::DrawLineByAbsCoords.new(
+            x0: X_LBL,
+            y0: Y_LBL,
+            x1: X_LBL,
+            y1: @segment_size
+          )
+        end
+      end
+    end
+  end
+end

data/lib/img_to_script/generators/run_length_encoding.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Generators
+    #
+    # Simple RLE with a depacker.
+    #
+    module RunLengthEncoding; end
+  end
+end

data/lib/img_to_script/generators/segmental/data_read_draw/data_read_draw.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Generators
+    module Segmental
+      module DataReadDraw
+        #
+        # Base class for the 'DATA..READ' draw method.
+        #
+        # The segment's coordinates are stored via the DATA statement. Three
+        # coordinates are stored: two coordinates of the 'major' axis, and oneI
+        # coordinate of the 'minor' axis.
+        #
+        # The FOR..NEXT loop is defined after the DATA statements. It loops
+        # through the array of coordinates, reads three values in a row, and
+        # passes the values to the statement that draws a line.
+        #
+        class DataReadDraw < Segmental
+          private
+
+          def _generate
+            @data = []
+
+            super
+          end
+
+          #
+          # Append a loop to read values from DATA and pass them to the DRAWD
+          # statement that draws a line.
+          #
+          def _append_decoder
+            _append_data
+            _loop_begin
+            _read
+            _draw_line
+            _loop_end
+          end
+
+          def _append_data
+            @tokens.append(
+              AbstractToken::DataStore.new(
+                data: @data,
+                require_nl: true
+              )
+            )
+          end
+
+          def _loop_begin
+            @tokens.append(
+              AbstractToken::LoopBegin.new(
+                start_value: 1,
+                end_value: @n_black_segments,
+                var_name: LOOP_VAR,
+                require_nl: true
+              )
+            )
+          end
+
+          def _loop_end
+            @tokens.append(
+              AbstractToken::LoopEnd.new(
+                var_name: LOOP_VAR
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/img_to_script/generators/segmental/data_read_draw/horizontal.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Generators
+    module Segmental
+      module DataReadDraw
+        #
+        # DATA...READ (with horizontal scan lines).
+        #
+        class Horizontal < DataReadDraw
+          include HorizontalMixin
+
+          private
+
+          def _generate
+            @data = []
+
+            super
+          end
+
+          def _read
+            @tokens.append(
+              AbstractToken::DataRead.new(
+                var_list: READ_PATTERN_HORIZ
+              )
+            )
+          end
+
+          def _draw_line
+            @tokens.append(
+              AbstractToken::DrawLineByAbsCoords.new(
+                x0: X0_LBL,
+                y0: Y_LBL,
+                x1: X1_LBL,
+                y1: Y_LBL
+              )
+            )
+          end
+
+          #
+          # Convert a chunk of black pixel(s) to three coordinates: x0, x1, y.
+          #
+          # @param [Integer] count
+          #   Run-length of the pixel block.
+          #
+          def _encode_chunk(count)
+            coordinates = _segment_coordinates(count)
+            @data.push(coordinates[:x0], coordinates[:x1], coordinates[:y0])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/img_to_script/generators/segmental/data_read_draw/vertical.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Generators
+    module Segmental
+      module DataReadDraw
+        #
+        # DATA...READ (with vertical scan lines).
+        #
+        class Vertical < DataReadDraw
+          include VerticalMixin
+
+          private
+
+          def _generate
+            @data = []
+
+            super
+          end
+
+          def _read
+            @tokens.append(
+              AbstractToken::DataRead.new(
+                var_list: READ_PATTERN_VERT
+              )
+            )
+          end
+
+          def _draw_line
+            @tokens.append(
+              AbstractToken::DrawLineByAbsCoords.new(
+                x0: X_LBL,
+                y0: Y0_LBL,
+                x1: X_LBL,
+                y1: Y1_LBL
+              )
+            )
+          end
+
+          #
+          # Convert a chunk of black pixel(s) to three coordinates: y0, y1, x.
+          #
+          # @param [Integer] count
+          #   Run-length of the pixel block.
+          #
+          def _encode_chunk(count)
+            coordinates = _segment_coordinates(count)
+            @data.push(coordinates[:y0], coordinates[:y1], coordinates[:x0])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/img_to_script/generators/segmental/data_read_draw.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Generators
+    module Segmental
+      module DataReadDraw
+        X0_LBL = :a
+        X1_LBL = :b
+
+        Y0_LBL = :c
+        Y1_LBL = :d
+
+        READ_PATTERN_HORIZ = [X0_LBL, X1_LBL, Y_LBL].freeze
+        READ_PATTERN_VERT = [Y0_LBL, Y1_LBL, X_LBL].freeze
+      end
+    end
+  end
+end

data/lib/img_to_script/generators/segmental/direct_draw/direct_draw.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Generators
+    module Segmental
+      module DirectDraw
+        #
+        # Base class for the 'direct' draw method. Segments are being drawed by
+        # calling the 'draw a pixel' and the 'draw a line' statements, and the
+        # coordinates of the segments are *directly* hard-coded as the statement's
+        # arguments. Hence the name.
+        #
+        class DirectDraw < Segmental
+          private
+
+          #
+          # Convert a chunk of black pixel(s) to a respective BASIC statement:
+          #
+          # - for a sequence of black pixels: append 'draw a line' statement;
+          # - for a single black pixel: append 'draw a dot' statement.
+          #
+          # @param [Integer] count
+          #   Run-length of the pixel block.
+          #
+          def _encode_chunk(count)
+            if count > 1
+              _append_line(_segment_coordinates(count))
+            else
+              _append_dot(_segment_coordinates(count))
+            end
+          end
+
+          #
+          # Draw a dot by a pair of coordinates (x, y).
+          #
+          def _append_dot(coordinates)
+            @tokens.append(
+              AbstractToken::DrawPixelByAbsCoords.new(
+                x: coordinates[:x0],
+                y: coordinates[:y0]
+              )
+            )
+          end
+
+          #
+          # Draw a line by a pairs of coordinates (x0, y0), (x1, y1).
+          #
+          def _append_line(coordinates)
+            @tokens.append(
+              AbstractToken::DrawLineByAbsCoords.new(
+                x0: coordinates[:x0],
+                y0: coordinates[:y0],
+                x1: coordinates[:x1],
+                y1: coordinates[:y1]
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/img_to_script/generators/segmental/direct_draw/horizontal.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Generators
+    module Segmental
+      module DirectDraw
+        #
+        # Horizontal scan lines.
+        #
+        class Horizontal < DirectDraw
+          include HorizontalMixin
+        end
+      end
+    end
+  end
+end

data/lib/img_to_script/generators/segmental/direct_draw/vertical.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Generators
+    module Segmental
+      module DirectDraw
+        #
+        # Vertical scan lines.
+        #
+        class Vertical < DirectDraw
+          include VerticalMixin
+        end
+      end
+    end
+  end
+end

data/lib/img_to_script/generators/segmental/direct_draw.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Generators
+    module Segmental
+      #
+      # @see direct_draw
+      #
+      module DirectDraw; end
+    end
+  end
+end

data/lib/img_to_script/generators/segmental/horizontal_mixin.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Generators
+    module Segmental
+      #
+      # Methods specific to the horizontal scan lines.
+      #
+      module HorizontalMixin
+        private
+
+        #
+        # Return the segment's coordinates x0, y0, x1, y1.
+        #
+        # Formatted for the horizontal scan lines.
+        #
+        # @param [Integer] segment_length
+        #
+        # @return [Hash{ Symbol => Integer }]
+        #
+        def _segment_coordinates(segment_length)
+          {
+            x0: @major_axis + @x_offset,
+            y0: @minor_axis + @y_offset,
+            x1: @major_axis + @x_offset + segment_length - 1,
+            y1: @minor_axis + @y_offset
+          }
+        end
+      end
+    end
+  end
+end

data/lib/img_to_script/generators/segmental/segmental.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Generators
+    module Segmental
+      #
+      # Base class for the segmental generators.
+      #
+      # Segmental generators are designed to scan an image vertically or horizontaly.
+      # In each scan line the isolated black px. segments are being parced out to
+      # get their coordinates (x0, y0), (x1, y1). Drawing lines using these coordinates
+      # will render the image on the target device.
+      #
+      class Segmental < Generator
+        SCAN_LINE_HEIGHT = 1
+
+        private
+
+        def _generate
+          # Keeps track of all black segment in the image.
+          # This value will be used in the depacker (in the DATA..READ scenario).
+          @n_black_segments = 0
+
+          @minor_axis = 0
+
+          _scan_image
+          _append_decoder
+        end
+
+        #
+        # Loop through all scan lines in the image.
+        #
+        def _scan_image
+          (0...@image.height).each do
+            @major_axis = 0
+            _process_scan_line(_encode_scan_line(_get_scan_line))
+            @minor_axis += 1
+          end
+        end
+
+        #
+        # Grab a horizontal line from the image.
+        #
+        # (To make a vertical scan line: simply transpose the image before a scan.)
+        #
+        # @return [Array<Magick::Pixel>]
+        #
+        def _get_scan_line
+          @image.get_pixels(@major_axis, @minor_axis, @image.width, SCAN_LINE_HEIGHT)
+        end
+
+        #
+        # Encode scan line with the RLE.
+        #
+        # @param [Array<Magick::Pixel>] scan_line
+        #   Scan line to encode.
+        #
+        # @return [Array<RunLengthEncodingRb::RLEElement>]
+        #
+        def _encode_scan_line(scan_line)
+          RunLengthEncodingRb.encode(scan_line)
+        end
+
+        #
+        # Process current RLE-encoded scan line.
+        #
+        # @return [Array<RunLengthEncodingRb::RLEElement>] encoded_scan_line
+        #
+        def _process_scan_line(encoded_scan_line)
+          encoded_scan_line.each do |e|
+            _process_scan_line_chunk(e)
+            @major_axis += e.run_length
+          end
+        end
+
+        #
+        # Process a chunk of white or black pixels from the current scan line.
+        #
+        # Depending on the color value of the chunk, the chunk either gets ignored
+        # (white pixels), or gets processed to be appended to the result script
+        # (black pixels) as a respective statement.
+        #
+        # @param [RunLengthEncodingRb::RLEElement] element
+        #   An RLE element.
+        #
+        def _process_scan_line_chunk(element)
+          pixel_color = element.chunk.to_color
+          return unless pixel_color == "black"
+
+          _encode_chunk(element.run_length)
+          @n_black_segments += 1
+        end
+
+        #
+        # Reserved for the DATA..READ scenario.
+        #
+        def _append_decoder; end
+      end
+    end
+  end
+end

data/lib/img_to_script/generators/segmental/vertical_mixin.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Generators
+    module Segmental
+      #
+      # Methods specific to the vertical scan lines.
+      #
+      module VerticalMixin
+        private
+
+        def _generate
+          _transpose
+
+          super
+        end
+
+        #
+        # Return the segment's coordinates x0, y0, x1, y1.
+        #
+        # Formatted for the vertical scan lines.
+        #
+        # @param [Integer] segment_length
+        #
+        # @return [Hash{ Symbol => Integer }]
+        #
+        def _segment_coordinates(segment_length)
+          {
+            x0: @minor_axis + @x_offset,
+            y0: @major_axis + @y_offset,
+            x1: @minor_axis + @x_offset,
+            y1: @major_axis + @y_offset + segment_length - 1
+          }
+        end
+      end
+    end
+  end
+end

data/lib/img_to_script/generators/segmental.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Generators
+    #
+    # @see segmental
+    #
+    module Segmental; end
+  end
+end

data/lib/img_to_script/generators.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  #
+  # Namespace for generators.
+  #
+  # Generators generate array of abstract tokens that represent the image
+  # in terms of simple operations, e.g.: draw a line, draw a pixel, etc.
+  #
+  module Generators
+    X_LBL = :x
+    Y_LBL = :y
+
+    LOOP_VAR = :i
+    READ_VAR = :l
+
+    WAIT_LOOP_COUNT = 100
+    WAIT_TIME = 1024
+
+    X_OFFSET = 0
+    Y_OFFSET = 0
+    CLEAR_SCREEN = true
+    PAUSE_PROGRAM = true
+    PRORGAM_BEGIN_LBL = false
+    PROGRAM_END_LBL = false
+  end
+end

data/lib/img_to_script/import.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  Import = Dry::AutoInject(Container)
+end

data/lib/img_to_script/language_token.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  #
+  # Base class for a target language's statement.
+  #
+  class LanguageToken; end
+end

data/lib/img_to_script/languages/mk90_basic/formatters/formatter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ImgToScript
+  module Languages
+    module MK90Basic
+      module Formatters
+        #
+        # MK90 BASIC formatter base class.
+        #
+        class Formatter < ImgToScript::Formatter
+          setting :line_offset, default: LINE_OFFSET
+          setting :line_step, default: LINE_STEP
+          setting :max_chars_per_line, default: MAX_CHARS_PER_LINE
+          setting :number_lines, default: true
+
+          private
+
+          def _format(basic_tokens, **)
+            _apply_config
+            _calc_initial_line_number
+
+            @script = []
+
+            _process_tokens(basic_tokens)
+
+            @script
+          end
+
+          def _process_tokens(basic_tokens)
+            basic_tokens.each do |token|
+              _append_token(token)
+            end
+          end
+
+          def _apply_config
+            @line_offset = config.line_offset
+            @line_step = config.line_step
+            @max_chars_per_line = config.max_chars_per_line
+            @number_lines = config.number_lines
+          end
+
+          def _calc_initial_line_number
+            @n_line = @line_offset - @line_step
+          end
+        end
+      end
+    end
+  end
+end