ndav-magick-image 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf489f7ae5981b5e552d896e8ce0f0696784d914572af0678790464f409f9b16
-  data.tar.gz: '09e621d161ed19c832229e535a9f9ff3a6864b1f05756ab91c0c2e5a1e3e800b'
+  metadata.gz: '0996608a78022414f8bd891b56e9505ae3f0f1784efe2b32e55b158ddfe53fce'
+  data.tar.gz: a6e1042355ee3cc29adfe82d1b50d805eefc151d0961e8304fc61f0284eb0fcc
 SHA512:
-  metadata.gz: 955db5a60c525d1be3a242c424428a93a71cdec036724684f14c1876741bb56f3de86d0e3be75ced7980f44038573332a7a508b0918df524017f3b3e17c4e666
-  data.tar.gz: 85d97b041b9153ff193b5348fee2b55257458f76450019307b2a4ff529b726c68d388fb3f1944328aaba12deaf09422d4b6d525c41c5658364b6c7146b30faea
+  metadata.gz: 07c973f3747bd2358672c1729700f1a09f0d0d95cf33ee292e133962cf1f54e2158a5189001f2848246678c6e3d49136e05aeb1975f7947546cbbf0f61210c23
+  data.tar.gz: b8062885f5f5e2e53ca33cbab91ca36ca1aff098001b66444f3da463e611e20ea951600e7b863eed7b09942604d274bfc97184db8a0a199ed9f06226c1792c35

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 MemoryCiew 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.
+On the other hand, this bridge can import MemoryViews whose format differs from `NDAV::Magick::Image::MemoryViewable::FORMAT`. Formats that are not currently supported might be supported in the future.
 
 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,16 @@ require "rmagick"
 class NDAV
   module Magick
     module Image
+      IS_HDRI_SUPPORTED = ::Magick::Magick_features.match?(/\bHDRI\b/)
+      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",
@@ -11,11 +21,32 @@ class NDAV
         3   => "RGB",
         4   => "RGBA"
       }
+      FORMAT_TO_TYPE = Hash.new {|types, format| types[format] = type_from_format(format)}
+
+      class << self
+        # TODO: Support more formats like "CCC"
+        def type_from_format(format)
+          item_desc = NDAV::ITEM_DESCS[format]
+          return unless item_desc.length == 1
+
+          component = item_desc[0]
+          return unless component.repeat == 1
+
+          case component.format
+          when MemoryViewable::FORMAT then ::Magick::QuantumPixel
+          when "C"                    then ::Magick::CharPixel
+          when "S"                    then ::Magick::ShortPixel
+          when "L"                    then ::Magick::IntegerPixel
+          when "f"                    then ::Magick::FloatPixel
+          when "d"                    then ::Magick::DoublePixel
+          else raise "Unsupported format: #{format}"
+          end
+        end
+      end
 
       module FromNDAV
         # TODO: Support more formats
         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
 
@@ -24,33 +55,37 @@ class NDAV
           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, FORMAT_TO_TYPE[ndav.format]
           image
         end
       end
   
       module MemoryViewable
+        FORMAT = case [::Magick::MAGICKCORE_QUANTUM_DEPTH, NDAV::Magick::Image::IS_HDRI_SUPPORTED]
+                 in [ 8, true ] then "f"
+                 in [ 8, false] then "C"
+                 in [16, true ] then "f"
+                 in [16, false] then "S"
+                 in [32, true ] then "f"
+                 in [32, false] then "L"
+                 in [64, true ] then "d"
+                 end
+        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

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.2"
   s.authors = ["Kitaiti Makoto"]
   s.summary = "N-Dimensional Array View for RMagick"
   s.licenses = ["MIT"]

data/test/helper.rb

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

data/test/test_memory_viewable.rb

@@ -1,6 +1,9 @@
 require_relative "helper"
 
 class TestMemoryViewable < Test::Unit::TestCase
+  FORMAT = NDAV::Magick::Image::MemoryViewable::FORMAT
+  ITEM_SIZE = NDAV::ITEM_SIZES[FORMAT]
+
   def setup
     @width = 3
     @height = 2
@@ -18,14 +21,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 +34,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.2
 platform: ruby
 authors:
 - Kitaiti Makoto