ruby-vips 0.3.14 → 1.0.0

data/lib/vips/operation.rb

@@ -0,0 +1,19 @@
+module Vips
+
+    # add a conventience method to Operation
+    # @private
+    class Operation
+        # Fetch arg list, remove boring ones, sort into priority order.
+        def get_args
+            gobject_class = gtype.to_class
+            props = gobject_class.properties.select do |name|
+                flags = get_argument_flags name
+                io = ((flags & :input) | (flags & :output)) != 0
+                dep = (flags & :deprecated) != 0
+                io & (not dep)
+            end
+            args = props.map {|name| Argument.new self, name}
+            args.sort! {|a, b| a.priority - b.priority}
+        end
+    end
+end

data/ruby-vips8.gemspec

@@ -0,0 +1,112 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: ruby-vips8 0.1.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "ruby-vips8"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["John Cupitt"]
+  s.date = "2016-01-25"
+  s.description = "ruby-vips8 is a ruby extension for vips8. It is extremely fast and it can process huge images without requiring the entire image to be loaded into memory."
+  s.email = "jcupitt@gmail.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md",
+    "TODO"
+  ]
+  s.files = [
+    ".rspec",
+    ".yardopts",
+    "CHANGELOG.md",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "TODO",
+    "VERSION",
+    "example/annotate.rb",
+    "example/daltonize8.rb",
+    "example/example1.rb",
+    "example/example2.rb",
+    "example/example3.rb",
+    "example/example4.rb",
+    "example/example5.rb",
+    "example/trim8.rb",
+    "example/watermark.rb",
+    "example/wobble.rb",
+    "lib/vips8.rb",
+    "lib/vips8/access.rb",
+    "lib/vips8/align.rb",
+    "lib/vips8/angle.rb",
+    "lib/vips8/angle45.rb",
+    "lib/vips8/argument.rb",
+    "lib/vips8/bandformat.rb",
+    "lib/vips8/call.rb",
+    "lib/vips8/coding.rb",
+    "lib/vips8/demandstyle.rb",
+    "lib/vips8/direction.rb",
+    "lib/vips8/error.rb",
+    "lib/vips8/extend.rb",
+    "lib/vips8/foreignflags.rb",
+    "lib/vips8/image.rb",
+    "lib/vips8/interpolate.rb",
+    "lib/vips8/interpretation.rb",
+    "lib/vips8/methods.rb",
+    "lib/vips8/operation.rb",
+    "ruby-vips8.gemspec",
+    "spec/image_spec.rb",
+    "spec/samples/balloon.v",
+    "spec/samples/ghost.ppm",
+    "spec/samples/huge.jpg",
+    "spec/samples/icc.jpg",
+    "spec/samples/lcd.icc",
+    "spec/samples/lion.svg",
+    "spec/samples/sample.csv",
+    "spec/samples/sample.exr",
+    "spec/samples/wagon.jpg",
+    "spec/samples/wagon.v",
+    "spec/spec_helper.rb",
+    "spec/vips_spec.rb"
+  ]
+  s.homepage = "http://github.com/jcupitt/ruby-vips8"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.2.2"
+  s.summary = "Ruby extension for the vips8 image processing library."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<gobject-introspection>, ["~> 3.0"])
+      s.add_development_dependency(%q<rspec>, ["~> 3.3"])
+      s.add_development_dependency(%q<yard>, ["~> 0.8"])
+      s.add_development_dependency(%q<redcarpet>, ["~> 3.3"])
+      s.add_development_dependency(%q<github-markup>, ["~> 1.4"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 2.0"])
+    else
+      s.add_dependency(%q<gobject-introspection>, ["~> 3.0"])
+      s.add_dependency(%q<rspec>, ["~> 3.3"])
+      s.add_dependency(%q<yard>, ["~> 0.8"])
+      s.add_dependency(%q<redcarpet>, ["~> 3.3"])
+      s.add_dependency(%q<github-markup>, ["~> 1.4"])
+      s.add_dependency(%q<bundler>, ["~> 1.0"])
+      s.add_dependency(%q<jeweler>, ["~> 2.0"])
+    end
+  else
+    s.add_dependency(%q<gobject-introspection>, ["~> 3.0"])
+    s.add_dependency(%q<rspec>, ["~> 3.3"])
+    s.add_dependency(%q<yard>, ["~> 0.8"])
+    s.add_dependency(%q<redcarpet>, ["~> 3.3"])
+    s.add_dependency(%q<github-markup>, ["~> 1.4"])
+    s.add_dependency(%q<bundler>, ["~> 1.0"])
+    s.add_dependency(%q<jeweler>, ["~> 2.0"])
+  end
+end
+

data/spec/image_spec.rb

@@ -0,0 +1,515 @@
+require 'spec_helper.rb'
+
+def has_jpeg?
+    Vips::type_find("VipsOperation", "jpegload") != nil
+end
+
+RSpec.describe Vips::Image do
+    describe '#new' do
+        it 'can make an empty image' do
+            image = Vips::Image.new
+
+            expect(image.width).to eq(1)
+            expect(image.height).to eq(1)
+            expect(image.bands).to eq(1)
+        end
+
+        it 'can save an image to a file' do
+            filename = timg "x.v"
+
+            image = Vips::Image.black(16, 16) + 128
+            image.write_to_file filename
+
+            expect(File.exist?(filename)).to be true
+        end
+
+        it 'can load an image from a file' do
+            filename = timg "x.v"
+
+            image = Vips::Image.black(16, 16) + 128
+            image.write_to_file(filename)
+
+            x = Vips::Image.new_from_file filename
+            expect(x.width).to eq(16)
+            expect(x.height).to eq(16)
+            expect(x.bands).to eq(1)
+            expect(x.avg).to eq(128)
+        end
+
+        if has_jpeg?
+            it 'can save an image to a buffer' do
+                image = Vips::Image.black(16, 16) + 128
+                buffer = image.write_to_buffer ".jpg"
+                expect(buffer.length).to be > 100
+            end
+        end
+
+        if has_jpeg?
+            it 'can load an image from a buffer' do
+                image = Vips::Image.black(16, 16) + 128
+                buffer = image.write_to_buffer ".jpg"
+                x = Vips::Image.new_from_buffer buffer, ""
+                expect(x.width).to eq(16)
+                expect(x.height).to eq(16)
+            end
+        end
+
+        it 'can make an image from a 2d array' do
+            image = Vips::Image.new_from_array [[1, 2], [3, 4]]
+            expect(image.width).to eq(2)
+            expect(image.height).to eq(2)
+            expect(image.bands).to eq(1)
+            expect(image.avg).to eq(2.5)
+        end
+
+        it 'can make an image from a 1d array' do
+            image = Vips::Image.new_from_array [1, 2]
+            expect(image.width).to eq(2)
+            expect(image.height).to eq(1)
+            expect(image.bands).to eq(1)
+            expect(image.avg).to eq(1.5)
+        end
+
+        it 'can use array consts for image args' do
+            r = Vips::Image.black(16, 16) 
+            r = r.draw_rect 255, 10, 12, 1, 1
+            g = Vips::Image.black(16, 16) 
+            g = g.draw_rect 255, 10, 11, 1, 1
+            b = Vips::Image.black(16, 16) 
+            b = b.draw_rect 255, 10, 10, 1, 1
+            im = r.bandjoin([g, b])
+
+            expect(im.width).to eq(16)
+            expect(im.height).to eq(16)
+            expect(im.bands).to eq(3)
+
+            im = im.conv [
+                [0.11, 0.11, 0.11],
+                [0.11, 0.11, 0.11],
+                [0.11, 0.11, 0.11]
+            ], :precision => :float
+
+            expect(im.width).to eq(16)
+            expect(im.height).to eq(16)
+            expect(im.bands).to eq(3)
+        end
+
+        it 'can set scale and offset on a convolution mask' do
+            image = Vips::Image.new_from_array [1, 2], 8, 2
+            expect(image.width).to eq(2)
+            expect(image.height).to eq(1)
+            expect(image.bands).to eq(1)
+            expect(image.scale).to eq(8)
+            expect(image.offset).to eq(2)
+            expect(image.avg).to eq(1.5)
+        end
+
+        if has_jpeg?
+            it 'can load a sample jpg image' do
+                x = Vips::Image.new_from_file simg("wagon.jpg")
+                expect(x.width).to eq(685)
+                expect(x.height).to eq(478)
+                expect(x.bands).to eq(3)
+                expect(x.avg).to be_within(0.001).of(109.789)
+            end
+        end
+
+        if has_jpeg?
+            it 'can extract an ICC profile from a jpg image' do
+                x = Vips::Image.new_from_file simg("icc.jpg")
+                expect(x.width).to eq(2800)
+                expect(x.height).to eq(2100)
+                expect(x.bands).to eq(3)
+                expect(x.avg).to be_within(0.001).of(109.189)
+
+                profile = x.get_value "icc-profile-data"
+                expect(profile.class).to eq(String)
+                expect(profile.length).to eq(2360)
+            end
+        end
+
+        if has_jpeg?
+            it 'can set an ICC profile on a jpg image' do
+                x = Vips::Image.new_from_file simg("icc.jpg")
+                profile = File.open(simg("lcd.icc"), "rb").read
+                x.set_value "icc-profile-data", profile
+                x.write_to_file(timg("x.jpg"))
+
+                x = Vips::Image.new_from_file timg("x.jpg")
+                expect(x.width).to eq(2800)
+                expect(x.height).to eq(2100)
+                expect(x.bands).to eq(3)
+                expect(x.avg).to be_within(0.1).of(109.189)
+
+                profile = x.get_value "icc-profile-data"
+                expect(profile.class).to eq(String)
+                expect(profile.length).to eq(3048)
+            end
+        end
+
+        if has_jpeg?
+            it 'can load a sample jpg image' do
+                x = Vips::Image.new_from_file simg("wagon.jpg")
+                expect(x.width).to eq(685)
+                expect(x.height).to eq(478)
+                expect(x.bands).to eq(3)
+                expect(x.avg).to be_within(0.001).of(109.789)
+            end
+        end
+
+        it 'has binary arithmetic operator overloads with constants' do
+            image = Vips::Image.black(16, 16) + 128
+
+            image += 128
+            image -= 128
+            image *= 2
+            image /= 2
+            image %= 100
+            image += 100
+            image **= 2
+            image **= 0.5
+            image <<= 1
+            image >>= 1
+            image |= 64
+            image &= 32
+            image ^= 128
+
+            expect(image.avg).to eq(128) 
+        end
+
+        it 'has binary arithmetic operator overloads with array constants' do
+            image = Vips::Image.black(16, 16, :bands => 3) + 128
+
+            image += [128, 0, 0]
+            image -= [128, 0, 0]
+            image *= [2, 1, 1]
+            image /= [2, 1, 1]
+            image %= [100, 99, 98]
+            image += [100, 99, 98]
+            image **= [2, 3, 4]
+            image **= [1.0 / 2.0, 1.0 / 3.0, 1.0 / 4.0]
+            image <<= [1, 2, 3]
+            image >>= [1, 2, 3]
+            image |= [64, 128, 256]
+            image &= [64, 128, 256]
+            image ^= [64 + 128, 0, 256 + 128]
+
+            expect(image.avg).to eq(128) 
+        end
+
+        it 'has binary arithmetic operator overloads with image args' do
+            image = Vips::Image.black(16, 16) + 128
+            x = image
+
+            x += image
+            x -= image
+            x *= image
+            x /= image
+            x %= image
+            x += image
+            x |= image
+            x &= image
+            x ^= image
+
+            expect(image.avg).to eq(128) 
+        end
+
+        it 'has relational operator overloads with constants' do
+            image = Vips::Image.black(16, 16) + 128
+
+            expect((image > 128).avg).to eq(0) 
+            expect((image >= 128).avg).to eq(255) 
+            expect((image < 128).avg).to eq(0) 
+            expect((image <= 128).avg).to eq(255) 
+            expect((image == 128).avg).to eq(255) 
+            expect((image != 128).avg).to eq(0) 
+        end
+
+        it 'has relational operator overloads with array constants' do
+            image = Vips::Image.black(16, 16, :bands => 3) + [100, 128, 130]
+
+            expect((image > [100, 128, 130]).avg).to eq(0) 
+            expect((image >= [100, 128, 130]).avg).to eq(255) 
+            expect((image < [100, 128, 130]).avg).to eq(0) 
+            expect((image <= [100, 128, 130]).avg).to eq(255) 
+            expect((image == [100, 128, 130]).avg).to eq(255) 
+            expect((image != [100, 128, 130]).avg).to eq(0) 
+        end
+
+        it 'has relational operator overloads with image args' do
+            image = Vips::Image.black(16, 16) + 128
+
+            expect((image > image).avg).to eq(0) 
+            expect((image >= image).avg).to eq(255) 
+            expect((image < image).avg).to eq(0) 
+            expect((image <= image).avg).to eq(255) 
+            expect((image == image).avg).to eq(255) 
+            expect((image != image).avg).to eq(0) 
+        end
+
+        it 'has band extract with numeric arg' do
+            image = Vips::Image.black(16, 16, :bands => 3) + [100, 128, 130]
+            x = image[1]
+
+            expect(x.width).to eq(16)
+            expect(x.height).to eq(16)
+            expect(x.bands).to eq(1)
+            expect(x.avg).to eq(128)
+        end
+
+        it 'has band extract with range arg' do
+            image = Vips::Image.black(16, 16, :bands => 3) + [100, 128, 130]
+            x = image[1..2]
+
+            expect(x.width).to eq(16)
+            expect(x.height).to eq(16)
+            expect(x.bands).to eq(2)
+            expect(x.avg).to eq(129)
+        end
+
+        it 'has rounding members' do
+            # need to avoid rounding down to 0.499999
+            image = Vips::Image.black(16, 16) + 0.500001
+
+            expect(image.floor.avg).to eq(0)
+            expect(image.ceil.avg).to eq(1)
+            expect(image.rint.avg).to eq(1)
+        end
+
+        it 'has bandsplit and bandjoin' do
+            image = Vips::Image.black(16, 16, :bands => 3) + [100, 128, 130]
+
+            split = image.bandsplit
+            x = split[0].bandjoin split[1..2]
+
+            expect(x[0].avg).to eq(100)
+            expect(x[1].avg).to eq(128)
+            expect(x[2].avg).to eq(130)
+        end
+
+        it 'can bandjoin constants' do
+            image = Vips::Image.black(16, 16, :bands => 3) + [100, 128, 130]
+
+            x = image.bandjoin 255
+
+            expect(x[0].avg).to eq(100)
+            expect(x[1].avg).to eq(128)
+            expect(x[2].avg).to eq(130)
+            expect(x[3].avg).to eq(255)
+            expect(x.bands).to eq(4)
+
+            x = image.bandjoin [1, 2]
+
+            expect(x[0].avg).to eq(100)
+            expect(x[1].avg).to eq(128)
+            expect(x[2].avg).to eq(130)
+            expect(x[3].avg).to eq(1)
+            expect(x[4].avg).to eq(2)
+            expect(x.bands).to eq(5)
+
+        end
+
+        it 'has minpos/maxpos' do
+            image = Vips::Image.black(16, 16) + 128
+            image = image.draw_rect 255, 10, 12, 1, 1
+            v, x, y = image.maxpos
+
+            expect(v).to eq(255)
+            expect(x).to eq(10)
+            expect(y).to eq(12)
+
+            image = Vips::Image.black(16, 16) + 128
+            image = image.draw_rect 12, 10, 12, 1, 1
+            v, x, y = image.minpos
+
+            expect(v).to eq(12)
+            expect(x).to eq(10)
+            expect(y).to eq(12)
+
+        end
+
+        it 'can form complex images' do
+            r = Vips::Image.black(16, 16) + 128
+            i = Vips::Image.black(16, 16) + 12
+            cmplx = r.complexform i 
+            re = cmplx.real
+            im = cmplx.imag
+
+            expect(re.avg).to eq(128)
+            expect(im.avg).to eq(12)
+        end
+
+        it 'can convert complex polar <-> rectangular' do
+            r = Vips::Image.black(16, 16) + 128
+            i = Vips::Image.black(16, 16) + 12
+            cmplx = r.complexform i 
+
+            cmplx = cmplx.rect.polar
+
+            expect(cmplx.real.avg).to be_within(0.001).of(128)
+            expect(cmplx.imag.avg).to be_within(0.001).of(12)
+        end
+
+        it 'can take complex conjugate' do
+            r = Vips::Image.black(16, 16) + 128
+            i = Vips::Image.black(16, 16) + 12
+            cmplx = r.complexform i 
+
+            cmplx = cmplx.conj
+
+            expect(cmplx.real.avg).to be_within(0.001).of(128)
+            expect(cmplx.imag.avg).to be_within(0.001).of(-12)
+        end
+
+        it 'has working trig functions' do
+            image = Vips::Image.black(16, 16) + 67
+
+            image = image.sin.cos.tan
+            image = image.atan.acos.asin
+
+            expect(image.avg).to be_within(0.01).of(67)
+        end
+
+        it 'has working log functions' do
+            image = Vips::Image.black(16, 16) + 67
+
+            image = image.log.exp.log10.exp10
+
+            expect(image.avg).to be_within(0.01).of(67)
+        end
+
+        it 'can flip' do
+            a = Vips::Image.black(16, 16) 
+            a = a.draw_rect 255, 10, 12, 1, 1
+            b = Vips::Image.black(16, 16) 
+            b = b.draw_rect 255, 15 - 10, 12, 1, 1
+
+            expect((a - b.fliphor).abs.max).to eq(0.0)
+
+            a = Vips::Image.black(16, 16) 
+            a = a.draw_rect 255, 10, 15 - 12, 1, 1
+            b = Vips::Image.black(16, 16) 
+            b = b.draw_rect 255, 10, 12, 1, 1
+
+            expect((a - b.flipver).abs.max).to eq(0.0)
+        end
+
+        it 'can getpoint' do
+            a = Vips::Image.black(16, 16) 
+            a = a.draw_rect 255, 10, 12, 1, 1
+            b = Vips::Image.black(16, 16) 
+            b = b.draw_rect 255, 10, 10, 1, 1
+            im = a.bandjoin(b)
+
+            expect(im.getpoint(10, 12)).to eq([255, 0])
+            expect(im.getpoint(10, 10)).to eq([0, 255])
+        end
+
+        it 'can median' do
+            a = Vips::Image.black(16, 16) 
+            a = a.draw_rect 255, 10, 12, 1, 1
+            im = a.median
+
+            expect(im.max).to eq(0)
+        end
+
+        it 'can erode' do
+            a = Vips::Image.black(16, 16) 
+            a = a.draw_rect 255, 10, 12, 1, 1
+            mask = Vips::Image.new_from_array [
+                [128, 255, 128],
+                [255, 255, 255],
+                [128, 255, 128]
+            ]
+            im = a.erode mask
+
+            expect(im.max).to eq(0)
+        end
+
+        it 'can dilate' do
+            a = Vips::Image.black(16, 16) 
+            a = a.draw_rect 255, 10, 12, 1, 1
+            mask = Vips::Image.new_from_array [
+                [128, 255, 128],
+                [255, 255, 255],
+                [128, 255, 128]
+            ]
+            im = a.dilate mask
+
+            expect(im.getpoint(10, 12)).to eq([255])
+            expect(im.getpoint(11, 12)).to eq([255])
+            expect(im.getpoint(12, 12)).to eq([0])
+        end
+
+        it 'can rot' do
+            a = Vips::Image.black(16, 16) 
+            a = a.draw_rect 255, 10, 12, 1, 1
+
+            im = a.rot90.rot90.rot90.rot90
+            expect((a - im).abs.max).to eq(0.0)
+
+            im = a.rot180.rot180
+            expect((a - im).abs.max).to eq(0.0)
+
+            im = a.rot270.rot270.rot270.rot270
+            expect((a - im).abs.max).to eq(0.0)
+        end
+
+        it 'can bandbool' do
+            a = Vips::Image.black(16, 16) 
+            a = a.draw_rect 255, 10, 12, 1, 1
+            b = Vips::Image.black(16, 16) 
+            b = b.draw_rect 255, 10, 10, 1, 1
+            im = a.bandjoin(b)
+
+            expect(im.bandand.getpoint(10, 12)).to eq([0])
+            expect(im.bandor.getpoint(10, 12)).to eq([255])
+            expect(im.bandeor.getpoint(10, 12)).to eq([255])
+        end
+
+        it 'ifthenelse with image arguments' do
+            image = Vips::Image.black(16, 16) 
+            image = image.draw_rect 255, 10, 12, 1, 1
+            black = Vips::Image.black(16, 16) 
+            white = Vips::Image.black(16, 16) + 255
+
+            result = image.ifthenelse black, white
+
+            v, x, y = result.minpos
+
+            expect(v).to eq(0)
+            expect(x).to eq(10)
+            expect(y).to eq(12)
+        end
+
+        it 'ifthenelse with constant arguments' do
+            image = Vips::Image.black(16, 16) 
+            image = image.draw_rect 255, 10, 12, 1, 1
+
+            result = image.ifthenelse 0, 255
+
+            v, x, y = result.minpos
+
+            expect(v).to eq(0)
+            expect(x).to eq(10)
+            expect(y).to eq(12)
+        end
+
+        it 'ifthenelse with vector arguments' do
+            image = Vips::Image.black(16, 16) 
+            image = image.draw_rect 255, 10, 12, 1, 1
+            white = Vips::Image.black(16, 16) + 255
+
+            result = image.ifthenelse [255, 0, 0], white
+
+            v, x, y = result.minpos
+
+            expect(v).to eq(0)
+            expect(x).to eq(10)
+            expect(y).to eq(12)
+        end
+
+    end
+
+end
+