ndav-magick-image 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf489f7ae5981b5e552d896e8ce0f0696784d914572af0678790464f409f9b16
-  data.tar.gz: '09e621d161ed19c832229e535a9f9ff3a6864b1f05756ab91c0c2e5a1e3e800b'
+  metadata.gz: 96acb84dd6f8a244f0951db50db36caf76cdf29d87804a45cac2fb356b699e28
+  data.tar.gz: 5a5c8fce397292d41afa18d60cbdbd6e8948c40a014143ce3a003b88aea66444
 SHA512:
-  metadata.gz: 955db5a60c525d1be3a242c424428a93a71cdec036724684f14c1876741bb56f3de86d0e3be75ced7980f44038573332a7a508b0918df524017f3b3e17c4e666
-  data.tar.gz: 85d97b041b9153ff193b5348fee2b55257458f76450019307b2a4ff529b726c68d388fb3f1944328aaba12deaf09422d4b6d525c41c5658364b6c7146b30faea
+  metadata.gz: d2dcc5754ad77b221630fde7deb4a6f8b36067bc938e3b0d3a2f3d5623c675d44cfba2c41527cade9e7eb4e5a2acda4dbf7cf53dbfb8c5ee9a62aec5df4825a9
+  data.tar.gz: 2b76f5e90698374a5788c212837a6cb466977479e18514606b10061be1da6e43047e712530824a6ca67f51e1e9060ba3a7e170f3e78a404d4a0238ea503cd451

data/README.md

@@ -60,9 +60,9 @@ The shape is `[height, width, channels]`. Channels vary based on the image attri
 
 ### format and item size ###
 
-Currently, this bridge supports only 8-bit depth expression of pixels, which means all channels including grayscale intencity, RGB and alpha are 0-255 values. Therefore, the MemoryView format is always `"C"` and the item size is 1-byte. Currently, HDR images are converted to standard dynamic-range images.
+Currently, this bridge exports `Magick::Image`'s MemoryView and imports from `NDAV` using `Magick::QuantumPixel`. Therefore, the MemoryView's format and item_size depend on the build options of ImageMagick. You can check the format with `NDAV::Magick::Image::MemoryViewable::FORMAT`.
 
-Other formats such as float might be supported in the future.
+It's under consideration whether other formats should be supported or not.
 
 EXAMPLE
 -------
@@ -82,25 +82,25 @@ image = image_list[0]
 numo = NumoNArray(image)
 abort "Use RGB image" unless numo.shape[2] == 3
 
-noise = Numo::Int8.new(numo.shape).rand(Numo::Int8::MIN, Numo::Int8::MAX)
-noised = Numo::Int16.cast(numo)
-noised.inplace + noise
-noised.inplace.clip(Numo::UInt8::MIN, Numo::UInt8::MAX)
+# Assumes numo is Numo::SFloat here. It depends on your environment.
+noise = Numo::SFloat.new(numo.shape).rand(0, -Magick::QuantumRange / 2)
+noised = numo + noise
+noised.inplace.clip(0, Magick::QuantumRange)
 
-noised_image = MagickImage(Numo::UInt8.cast(noised))
+noised_image = MagickImage(noised)
 noised_image.write "noised.png"
+
 ```
 
 | Before | After |
 |--------|-------|
-| [![Original image](https://i.gyazo.com/905f541f15c0d57db5fc7ea3f6edaf07.png)](https://gyazo.com/905f541f15c0d57db5fc7ea3f6edaf07) | [![Noized image](https://i.gyazo.com/7ad51507e7a2d2c8c39c15ce71a5175a.png)](https://gyazo.com/7ad51507e7a2d2c8c39c15ce71a5175a) |
+| [![Original image](https://i.gyazo.com/905f541f15c0d57db5fc7ea3f6edaf07.png)](https://gyazo.com/905f541f15c0d57db5fc7ea3f6edaf07) | [![Noised image](https://i.gyazo.com/c8c7191713d97fffaa2509e6b0874aab.png)](https://gyazo.com/c8c7191713d97fffaa2509e6b0874aab) |
 
 TODO
 ----
 
-* Support HDRI
 * Support zero-copy
-* Support float value pixels
+* Support export in non-ImageMagick-native format
 
 LICENSE
 -------

data/lib/ndav/magick/image.rb

@@ -4,6 +4,25 @@ require "rmagick"
 class NDAV
   module Magick
     module Image
+      IS_HDRI_SUPPORTED = ::Magick::Magick_features.match?(/\bHDRI\b/)
+      is_little_endian = IO::Buffer::HOST_ENDIAN == IO::Buffer::LITTLE_ENDIAN
+      SUPPORTED_FORMATS =
+        case [::Magick::MAGICKCORE_QUANTUM_DEPTH, IS_HDRI_SUPPORTED]
+        in [ 8, false] then ["C"]
+        in [16, false] then ["S", is_little_endian ? "v" : "n"]
+        in [32, false] then ["L", is_little_endian ? "V" : "N"]
+        in [ 8, true ] | [16, true] | [32, true] then ["f", is_little_endian ? "e" : "g"]
+        in [64, true ] then ["d", is_little_endian ? "E" : "G"]
+        end
+      COLORSPACE_TO_MAP = {
+        ::Magick::GRAYColorspace        => "I",
+        ::Magick::LinearGRAYColorspace  => "I",
+        ::Magick::RGBColorspace         => "RGB",
+        ::Magick::ScRGBColorspace       => "RGB",
+        ::Magick::SRGBColorspace        => "RGB",
+        ::Magick::CMYColorspace         => "CMY",
+        ::Magick::CMYKColorspace        => "CMYK"
+      }
       CHANNELS_TO_MAP = {
         nil => "I",
         1   => "I",
@@ -14,48 +33,50 @@ class NDAV
 
       module FromNDAV
         # TODO: Support more formats
+        # TODO: Support CMYK
         def from_ndav(ndav)
-          raise %|Currently, supports only format "C", but is "#{ndav.format}"| unless ndav.format == "C"
-          raise "Currently, supports only row-major contiguous NDAV" unless ndav.row_major_contiguous?
-          raise "ndim must be 2 or 3 but is #{ndav.ndim}" unless [2, 3].include? ndav.ndim
+          Kernel.raise "ndim must be 2 or 3 but is #{ndav.ndim}" unless [2, 3].include? ndav.ndim
+          Kernel.raise "Currently, supports only row-major contiguous NDAV" unless ndav.row_major_contiguous?
+
+          item_desc = NDAV::ITEM_DESCS[ndav.format]
+          Kernel.raise "Unsupported format: #{ndav.format}. Must be single character" unless item_desc.length == 1
+          component = item_desc[0]
+          Kernel.raise "Unsupported format: #{ndav.format}. Must not be repeated" unless component.repeat == 1
+          Kernel.raise "Unsupported format: #{ndav.format}. Supported chars: #{SUPPORTED_FORMATS.join(', ')}" unless SUPPORTED_FORMATS.include? component.format
 
           height, width, channels = ndav.shape
           map = CHANNELS_TO_MAP[channels]          
-          raise "Unsupported channels: #{channels}" unless map
+          Kernel.raise "Unsupported channels: #{channels}" unless map
 
           image = ::Magick::Image.new(width, height)
-          image.import_pixels 0, 0, width, height, map, ndav.to_s
+          image.import_pixels 0, 0, width, height, map, ndav.to_s, ::Magick::QuantumPixel
           image
         end
       end
-  
+
       module MemoryViewable
+        FORMAT = SUPPORTED_FORMATS.first
+        ITEM_SIZE = NDAV::ITEM_SIZES[FORMAT]
+
         private
 
-        # TODO: Support HDRI
         def ndav_descriptor(**)
-          map =
-            case [gray?, alpha?]
-            when [true, true]  then "IA"
-            when [true, false] then "I"
-            when [false, true] then "RGBA"
-            else                    "RGB"
-            end
+          map = COLORSPACE_TO_MAP[colorspace]
+          Kernel.raise "Unsupported color space: #{colorspace}" unless map
+          map += "A" if alpha?
           shape = [rows, columns, map.length]
-          format = "C"
-          item_size = ::NDAV::ITEM_SIZES[format]
 
           {
-            data: export_pixels_to_str(0, 0, columns, rows, map, ::Magick::CharPixel),
+            data: export_pixels_to_str(0, 0, columns, rows, map, ::Magick::QuantumPixel),
             shape:,
-            strides: ::NDAV.default_strides(shape:, item_size:),
-            format:,
-            byte_size: shape.reduce(item_size, :*),
+            strides: NDAV.default_strides(shape:, item_size: ITEM_SIZE),
+            format: FORMAT,
+            byte_size: shape.reduce(ITEM_SIZE, :*),
             readonly?: true
           }
         end
       end
-  
+
       module Converter
         def MagickImage(array, *, **)
           if array.kind_of? ::Magick::Image

data/ndav-magick-image.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "ndav-magick-image"
-  s.version = "0.0.1"
+  s.version = "0.0.3"
   s.authors = ["Kitaiti Makoto"]
   s.summary = "N-Dimensional Array View for RMagick"
   s.licenses = ["MIT"]

data/test/helper.rb

@@ -3,3 +3,19 @@ require "test/unit"
 require "test/unit/notify"
 require "fiddle"
 require "tmpdir"
+
+module Helper
+  FORMAT = NDAV::Magick::Image::MemoryViewable::FORMAT
+
+  private
+
+  def make_image(width, height, former = [255, 255, 255], latter = [0, 255, 0])
+    ratio = (2 ** ::Magick::MAGICKCORE_QUANTUM_DEPTH - 1) / 255
+    [
+      [former * width] * (height / 2),
+      [latter * width] * (height / 2)
+    ].flatten.collect {|item| item * ratio}
+  end
+end
+
+Test::Unit::TestCase.include Helper

data/test/test_converter.rb

@@ -18,12 +18,9 @@ class TestConverter < Test::Unit::TestCase
   end
 
   def test_magick_image_from_ndav
-    array = [
-              [[255, 255, 255] * @width] * (@height / 2),
-              [[  0, 255,   0] * @width] * (@height / 2)
-            ]
-    ptr = Fiddle::Pointer[array.flatten.pack("C*")]
-    ndav = ::NDAV.new(ptr, shape: [@height, @width, 3])
+    array = make_image(@width, @height)
+    ptr = Fiddle::Pointer[array.flatten.pack("#{FORMAT}*")]
+    ndav = ::NDAV.new(ptr, format: FORMAT, shape: [@height, @width, 3])
 
     assert_instance_of ::Magick::Image, ::NDAV::Converter::MagickImage(ndav)
   end

data/test/test_from_ndav.rb

@@ -7,66 +7,58 @@ class TestFromNDAV < Test::Unit::TestCase
   end
 
   def test_basic
-    array = [
-               [[255, 255, 255] * @width] * (@height / 2),
-               [[  0, 255,   0] * @width] * (@height / 2)
-             ]
-    ptr = Fiddle::Pointer[array.flatten.pack("C*")]
-    ndav = ::NDAV.new(ptr, shape: [@height, @width, 3])
+    array = make_image(@width, @height)
+    ptr = Fiddle::Pointer[array.flatten.pack("#{FORMAT}*")]
+    ndav = ::NDAV.new(ptr, format: FORMAT, shape: [@height, @width, 3])
     image = ::Magick::Image.from_ndav(ndav)
 
     assert_equal @width, image.columns
     assert_equal @height, image.rows
     assert_false image.gray?
     assert_false image.alpha?
-    assert_equal array.flatten, image.export_pixels_to_str.unpack("C*")
+    assert_equal array.flatten,
+                 image.export_pixels_to_str(0, 0, @width, @height, "RGB", ::Magick::QuantumPixel).unpack("#{FORMAT}*")
   end
 
   def test_alpha
-    array = [
-              [[255, 255, 255, 128] * @width] * (@height / 2),
-              [[  0, 255,   0, 128] * @width] * (@height / 2)
-            ]
-    ptr = Fiddle::Pointer[array.flatten.pack("C*")]
-    ndav = ::NDAV.new(ptr, shape: [@height, @width, 4])
+    array = make_image(@width, @height, [255, 255, 255, 128], [0, 255, 0, 128])
+    ptr = Fiddle::Pointer[array.flatten.pack("#{FORMAT}*")]
+    ndav = ::NDAV.new(ptr, format: FORMAT, shape: [@height, @width, 4])
     image = ::Magick::Image.from_ndav(ndav)
 
     assert_equal @width, image.columns
     assert_equal @height, image.rows
     assert_false image.gray?
     assert_true image.alpha?
-    assert_equal array.flatten, image.export_pixels_to_str(0, 0, @width, @height, "RGBA").unpack("C*")
+    assert_equal array.flatten,
+                 image.export_pixels_to_str(0, 0, @width, @height, "RGBA", ::Magick::QuantumPixel).unpack("#{FORMAT}*")
   end
 
   def test_grayscale
-    array = [
-              [[255] * @width] * (@height / 2),
-              [[128] * @width] * (@height / 2)
-            ]
-    ptr = Fiddle::Pointer[array.flatten.pack("C*")]
-    ndav = ::NDAV.new(ptr, shape: [@height, @width, 1])
+    array = make_image(@width, @height, [255], [128])
+    ptr = Fiddle::Pointer[array.flatten.pack("#{FORMAT}*")]
+    ndav = ::NDAV.new(ptr, format: FORMAT, shape: [@height, @width, 1])
     image = ::Magick::Image.from_ndav(ndav)
 
     assert_equal @width, image.columns
     assert_equal @height, image.rows
     assert_true image.gray?
     assert_false image.alpha?
-    assert_equal array.flatten, image.export_pixels_to_str(0, 0, @width, @height, "R").unpack("C*")
+    assert_equal array.flatten,
+                 image.export_pixels_to_str(0, 0, @width, @height, "R", ::Magick::QuantumPixel).unpack("#{FORMAT}*")
   end
 
   def test_gray_alpha
-    array = [
-              [[255, 128] * @width] * (@height / 2),
-              [[128, 128] * @width] * (@height / 2)
-            ]
-    ptr = Fiddle::Pointer[array.flatten.pack("C*")]
-    ndav = ::NDAV.new(ptr, shape: [@height, @width, 2])
+    array = make_image(@width, @height, [255, 128], [128, 128])
+    ptr = Fiddle::Pointer[array.flatten.pack("#{FORMAT}*")]
+    ndav = ::NDAV.new(ptr, format: FORMAT, shape: [@height, @width, 2])
     image = ::Magick::Image.from_ndav(ndav)
 
     assert_equal @width, image.columns
     assert_equal @height, image.rows
     assert_true image.gray?
     assert_true image.alpha?
-    assert_equal array.flatten, image.export_pixels_to_str(0, 0, @width, @height, "RA").unpack("C*")
+    assert_equal array.flatten,
+                 image.export_pixels_to_str(0, 0, @width, @height, "RA", ::Magick::QuantumPixel).unpack("#{FORMAT}*")
   end
 end

data/test/test_memory_viewable.rb

@@ -1,6 +1,8 @@
 require_relative "helper"
 
 class TestMemoryViewable < Test::Unit::TestCase
+  ITEM_SIZE = NDAV::ITEM_SIZES[FORMAT]
+
   def setup
     @width = 3
     @height = 2
@@ -18,14 +20,10 @@ class TestMemoryViewable < Test::Unit::TestCase
     Fiddle::MemoryView.export @image do |view|
       assert_equal 3, view.ndim
       assert_equal [@height, @width, 3], view.shape
-      assert_equal 1, view.item_size
-      assert_equal "C", view.format
-      assert_equal @width * @height * 3, view.byte_size
-      assert_equal [
-                     [[255, 255, 255] * @width] * (@height / 2),
-                     [[  0, 255,   0] * @width] * (@height / 2)
-                   ].flatten,
-                   view.to_s.unpack("C*")
+      assert_equal ITEM_SIZE, view.item_size
+      assert_equal FORMAT, view.format
+      assert_equal @width * @height * 3 * ITEM_SIZE, view.byte_size
+      assert_equal make_image(@width, @height), view.to_s.unpack("#{FORMAT}*")
     end
   end
 
@@ -35,44 +33,38 @@ class TestMemoryViewable < Test::Unit::TestCase
     Fiddle::MemoryView.export @image do |view|
       assert_equal 3, view.ndim
       assert_equal [@height, @width, 4], view.shape
-      assert_equal 1, view.item_size
-      assert_equal "C", view.format
-      assert_equal @width * @height * 4, view.byte_size
+      assert_equal ITEM_SIZE, view.item_size
+      assert_equal FORMAT, view.format
+      assert_equal @width * @height * 4* ITEM_SIZE, view.byte_size
     end
   end
 
   def test_grayscale
-    image = @image.quantize(256, Magick::GRAYColorspace)
+    @image.colorspace = Magick::GRAYColorspace
 
-    Fiddle::MemoryView.export image do |view|
+    Fiddle::MemoryView.export @image do |view|
       assert_equal 3, view.ndim
       assert_equal [@height, @width, 1], view.shape
-      assert_equal 1, view.item_size
-      assert_equal "C", view.format
-      assert_equal @width * @height * 1, view.byte_size
-      assert_equal [
-                     [[255] * @width] * (@height / 2),
-                     [[182] * @width] * (@height / 2)
-                   ].flatten,
-                   view.to_s.unpack("C*")
+      assert_equal ITEM_SIZE, view.item_size
+      assert_equal FORMAT, view.format
+      assert_equal @width * @height * 1 * ITEM_SIZE, view.byte_size
+      assert_equal @image.export_pixels_to_str(0, 0, @width, @height, "I", Magick::QuantumPixel).unpack("#{FORMAT}*"),
+                   view.to_s.unpack("#{FORMAT}*")
     end
   end
 
   def test_gray_alpha
-    image = @image.quantize(256, Magick::GRAYColorspace)
-    image.alpha Magick::OnAlphaChannel
+    @image.colorspace = Magick::GRAYColorspace
+    @image.alpha Magick::OnAlphaChannel
 
-    Fiddle::MemoryView.export image do |view|
+    Fiddle::MemoryView.export @image do |view|
       assert_equal 3, view.ndim
       assert_equal [@height, @width, 2], view.shape
-      assert_equal 1, view.item_size
-      assert_equal "C", view.format
-      assert_equal @width * @height * 2, view.byte_size
-      assert_equal [
-                      [[255, 255] * @width] * (@height / 2),
-                      [[182, 255] * @width] * (@height / 2)
-                    ].flatten,
-                    view.to_s.unpack("C*")
+      assert_equal ITEM_SIZE, view.item_size
+      assert_equal FORMAT, view.format
+      assert_equal @width * @height * 2 * ITEM_SIZE, view.byte_size
+      assert_equal @image.export_pixels_to_str(0, 0, @width, @height, "IA", Magick::QuantumPixel).unpack("#{FORMAT}*"),
+                   view.to_s.unpack("#{FORMAT}*")
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ndav-magick-image
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Kitaiti Makoto