contrek 1.4.1 → 1.4.3

data/ext/cpp_polygon_finder/extconf.rb

@@ -3,6 +3,8 @@
 require "mkmf-rice"
 
 has_tcmalloc = find_library("tcmalloc", "malloc")
+has_tiff = have_library("tiff", "TIFFOpen", "tiffio.h")
+has_geotiff = has_tiff && have_library("geotiff", "XTIFFOpen", "geotiff/xtiffio.h")
 
 # rubocop:disable Style/GlobalVars
 
@@ -16,6 +18,13 @@ else
   puts "tcmalloc not found; standard malloc will be used."
 end
 
+if has_tiff && has_geotiff
+  $CXXFLAGS << " -DCONTREK_HAS_TIFF"
+  puts "TIFF/GeoTIFF support enabled."
+else
+  puts "TIFF/GeoTIFF support disabled."
+end
+
 $LDFLAGS << " -lz -lstdc++ -flto -pthread"
 
 $objs = [

data/lib/contrek/bitmaps/bitmap.rb

@@ -5,7 +5,7 @@ module Contrek
     class Bitmap
       include Painting
 
-      def scan(start_x: 0, end_x: w)
+      def scan(start_x: 0, end_x: w, end_y: h)
         x = start_x
         y = 0
         loop do
@@ -14,7 +14,7 @@ module Contrek
           if x == end_x
             x = start_x
             y += 1
-            break if y == h
+            break if y == end_y
           end
         end
       end

data/lib/contrek/bitmaps/chunky_bitmap.rb

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
+require "ffi"
+
 module Contrek
   module Bitmaps
     class ChunkyBitmap < Bitmap
       def initialize(data, mod)
-        @raw = data.dup
         @module = mod
+        @height = data.bytesize / @module
+        @raw = FFI::MemoryPointer.new(:uint8, data.bytesize)
+        @raw.put_bytes(0, data)
       end
 
       def clear(val = "0")
-        @raw = val * @module * h
+        @raw.put_bytes(0, val * @module * h)
       end
 
       def w
@@ -17,22 +21,30 @@ module Contrek
       end
 
       def h
-        @raw.size / @module
+        @height
+      end
+
+      def get_bytes_per_pixel
+        1
+      end
+
+      def get_row_ptr(y)
+        @raw + (@module * y)
       end
 
       def value_at(x, y)
-        @raw[y * @module + x]
+        @raw.get_uint8(y * @module + x).chr
       end
 
       def value_set(x, y, value)
         return if y >= h
         return if x >= w
 
-        @raw[y * @module + x] = value
+        @raw.put_uint8(y * @module + x, value.ord)
       end
 
       def dup!
-        ChunkyBitmap.new(@raw, @module)
+        ChunkyBitmap.new(@raw.read_bytes(@module * h), @module)
       end
 
       def draw_rect(x:, y:, width:, height:, color: "o", filled: true)
@@ -80,7 +92,7 @@ module Contrek
         puts label if label
         puts "  " + (0...@module).map { |i| (i % 10).to_s }.join
         n = 0
-        @raw.scan(/.{1,#{@module}}/).each do |line|
+        @raw.read_bytes(@module * h).scan(/.{1,#{@module}}/).each do |line|
           colored_line = line.chars.map { |c| colorize_char(c) }.join
           puts "#{n} #{colored_line}"
           n += 1
@@ -96,8 +108,11 @@ module Contrek
             transposed += value_at(x, y)
           end
         end
-        @raw = transposed
+        old_width = w
         @module = h
+        @height = old_width
+        @raw = FFI::MemoryPointer.new(:uint8, transposed.bytesize)
+        @raw.put_bytes(0, transposed)
       end
 
       private

data/lib/contrek/bitmaps/png_bitmap.rb

@@ -20,6 +20,10 @@ module Contrek
         @image.dimension.height
       end
 
+      def get_bytes_per_pixel
+        4
+      end
+
       def draw_line(start_x, start_y, end_x, end_y, value)
         @image.line_xiaolin_wu(start_x, start_y, end_x, end_y, value)
       end

data/lib/contrek/bitmaps/rgba_bitmap.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Contrek
+  module Bitmaps
+    class RgbaBitmap < Bitmap
+      BYTES_PER_PIXEL = 4
+
+      def initialize(width, height)
+        @width = width
+        @height = height
+        @raw = FFI::MemoryPointer.new(:uint8, @width * @height * BYTES_PER_PIXEL)
+      end
+
+      def w
+        @width
+      end
+
+      def h
+        @height
+      end
+
+      def get_bytes_per_pixel
+        BYTES_PER_PIXEL
+      end
+
+      def value_at(x, y)
+        rgb_value_at(x, y)
+      end
+
+      def get_row_ptr(y)
+        @raw + (y * @width * BYTES_PER_PIXEL)
+      end
+
+      def rgb_value_at(x, y)
+        index = (y * @width + x) * BYTES_PER_PIXEL
+        r = @raw.get_uint8(index)
+        g = @raw.get_uint8(index + 1)
+        b = @raw.get_uint8(index + 2)
+        a = @raw.get_uint8(index + 3)
+        r | (g << 8) | (b << 16) | (a << 24)
+      end
+
+      def read_bytes(size)
+        @raw.read_bytes(size)
+      end
+    end
+  end
+end

data/lib/contrek/bitmaps/streaming/raster_streamer.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Contrek
+  module Bitmaps
+    module Streaming
+      class RasterStreamer
+        OVERLAP = 1
+
+        attr_reader :stripe_height
+
+        def initialize(source, stripe_height:)
+          @source = source
+          @stripe_height = stripe_height
+
+          raise ArgumentError, "stripe_height must be greater than 1" if @stripe_height <= OVERLAP
+        end
+
+        def each(buffer)
+          return enum_for(:each, buffer) unless block_given?
+
+          width = @source.width
+          height = @source.height
+          bytes_per_pixel = @source.get_bytes_per_pixel
+
+          row_size = width * bytes_per_pixel
+
+          source_row = 0
+          buffer_rows = 0
+          first_stripe = true
+
+          while source_row < height
+            unless first_stripe
+              previous_last_row = buffer.get_row_ptr(buffer_rows - 1)
+              current_first_row = buffer.get_row_ptr(0)
+              current_first_row.put_bytes(0, previous_last_row.read_bytes(row_size))
+            end
+
+            overlap_rows = first_stripe ? 0 : OVERLAP
+            available_rows = @stripe_height - overlap_rows
+            remaining_rows = height - source_row
+            rows_to_read = [available_rows, remaining_rows].min
+
+            rows_read = 0
+            rows_to_read.times do |i|
+              buffer_y = overlap_rows + i
+              row_ptr = buffer.get_row_ptr(buffer_y)
+              break unless @source.read_next_row(row_ptr, row_size)
+
+              source_row += 1
+              rows_read += 1
+            end
+
+            buffer_rows = overlap_rows + rows_read
+            break if buffer_rows == 0
+
+            yield buffer, buffer_rows, buffer_rows * row_size, rows_read
+
+            first_stripe = false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contrek/bitmaps/streaming/sources/ascii.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Contrek
+  module Bitmaps
+    module Streaming
+      module Sources
+        class Ascii < Base
+          extend Forwardable
+
+          def_delegator :@bitmap, :w, :width
+          def_delegator :@bitmap, :h, :height
+          def_delegators :@bitmap, :get_bytes_per_pixel
+
+          def initialize(bitmap)
+            @current_row = 0
+            @bitmap = bitmap
+          end
+
+          def read_next_row(destination, row_size)
+            return false if @current_row >= height
+
+            row = @bitmap.get_row_ptr(@current_row)
+            destination.put_bytes(0, row.read_bytes(row_size))
+            @current_row += 1
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contrek/bitmaps/streaming/sources/base.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Contrek
+  module Bitmaps
+    module Streaming
+      module Sources
+        class Base
+          def width
+            raise NotImplementedError
+          end
+
+          def height
+            raise NotImplementedError
+          end
+
+          def get_bytes_per_pixel
+            raise NotImplementedError
+          end
+
+          def read_next_row(destination, row_size)
+            raise NotImplementedError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contrek/bitmaps/streaming/sources/png.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "ffi"
+require "cpp_polygon_finder"
+
+module Contrek
+  module Bitmaps
+    module Streaming
+      module Sources
+        class Png
+          attr_reader :width, :height
+
+          module LibSpng
+            extend FFI::Library
+
+            ffi_lib FFI::Library::CURRENT_PROCESS
+
+            SPNG_FMT_RGBA8 = 1
+            SPNG_DECODE_PROGRESSIVE = 256
+            SPNG_EOI = 75
+
+            class Ihdr < FFI::Struct
+              layout(
+                :width, :uint32,
+                :height, :uint32,
+                :bit_depth, :uint8,
+                :color_type, :uint8,
+                :compression_method, :uint8,
+                :filter_method, :uint8,
+                :interlace_method, :uint8
+              )
+            end
+
+            attach_function :spng_ctx_new, [:int], :pointer
+            attach_function :spng_ctx_free, [:pointer], :void
+            attach_function :spng_set_png_file, [:pointer, :pointer], :int
+            attach_function :spng_get_ihdr, [:pointer, :pointer], :int
+            attach_function :spng_decode_image, [:pointer, :pointer, :size_t, :int, :int], :int
+            attach_function :spng_decode_row, [:pointer, :pointer, :size_t], :int
+          end
+
+          module LibC
+            extend FFI::Library
+
+            ffi_lib FFI::Library::LIBC
+
+            attach_function :fopen, [:string, :string], :pointer
+            attach_function :fclose, [:pointer], :int
+          end
+
+          def initialize(filepath)
+            @fp = LibC.fopen(filepath, "rb")
+            raise "Unable to open PNG: #{filepath}" if @fp.null?
+
+            @ctx = LibSpng.spng_ctx_new(0)
+            raise "Unable to create spng context" if @ctx.null?
+
+            ret = LibSpng.spng_set_png_file(@ctx, @fp)
+            raise "spng_set_png_file failed: #{ret}" unless ret == 0
+
+            ihdr = LibSpng::Ihdr.new
+
+            ret = LibSpng.spng_get_ihdr(@ctx, ihdr)
+            raise "spng_get_ihdr failed: #{ret}" unless ret == 0
+
+            @width = ihdr[:width]
+            @height = ihdr[:height]
+
+            ret = LibSpng.spng_decode_image(
+              @ctx,
+              nil,
+              0,
+              LibSpng::SPNG_FMT_RGBA8,
+              LibSpng::SPNG_DECODE_PROGRESSIVE
+            )
+            raise "Unable to initialize progressive decoding: #{ret}" unless ret == 0
+          end
+
+          def get_bytes_per_pixel
+            4
+          end
+
+          def read_next_row(destination, row_size)
+            ret = LibSpng.spng_decode_row(@ctx, destination, row_size)
+            unless ret == 0 || ret == LibSpng::SPNG_EOI
+              raise "spng_decode_row failed: #{ret}"
+            end
+            true
+          end
+
+          def close
+            unless @ctx.nil? || @ctx.null?
+              LibSpng.spng_ctx_free(@ctx)
+              @ctx = nil
+            end
+            unless @fp.nil? || @fp.null?
+              LibC.fclose(@fp)
+              @fp = nil
+            end
+          end
+        end
+      end
+    end
+  end
+end