vips 8.6.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 17ebdb3047de6d3b6982f72e06bcb58dbadd39af057918e601970818646b4007
+  data.tar.gz: ecd94b19ffba51de569bdf7bd58398b9b23cd05dc5e617e08ca0508cafb8099d
+SHA512:
+  metadata.gz: 7587de2d7115ab17b0af59e4cbd304ceff1a9a3c94d8448a6850a07b9296f7291dcd5ce89f35c0bba912cc7049401a6c05457c49765ff727688f4948fdd682c6
+  data.tar.gz: e80bd5ba9216eb25f167ae2aa5a1b3328f603688bacdea269ed78b7620fd2689775e2614f2aca76a9f18851445f936cf53fc9a9dbb53f7040e93676c22734323

data/.gitignore

@@ -0,0 +1,16 @@
+.yardoc
+*.swp
+doc
+pkg/*.gem
+
+# skip Gemfile.lock since this is a gem
+Gemfile.lock
+
+/bin/
+/include/
+/share/
+/lib/lib*
+/lib/girepository-1.0
+/lib/pkgconfig
+
+/ext/vips-*

data/.travis.yml

@@ -0,0 +1,47 @@
+sudo: false
+
+addons:
+  apt:
+    packages:
+      - libexpat1-dev
+      - gettext
+      - liblcms2-dev
+      - libmagickwand-dev
+      - libopenexr-dev
+      - libcfitsio3-dev
+      - libgif-dev
+      - libgs-dev
+      - libgsf-1-dev
+      - libmatio-dev
+      - libopenslide-dev
+      - liborc-0.4-dev
+      - libpango1.0-dev
+      - libpoppler-glib-dev
+      - librsvg2-dev
+      - libwebp-dev
+        # missing on trusty, unfortunately
+        # - libwebpmux2
+      - libfftw3-dev
+      - libglib2.0-dev
+
+cache:
+  bundler: true
+  directories: $HOME/vips/ext
+
+language: ruby
+rvm:
+  - 2.3
+  - 2.4
+  - 2.5
+  - 2.6
+
+before_script:
+  - gem update --system
+  - gem install bundler
+  - bundle exec rake ext
+
+script: 
+  - bundle exec rake
+
+gemfile:
+  - Gemfile

data/.yardopts

@@ -0,0 +1,2 @@
+--markup-provider=redcarpet
+--markup=markdown

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# all gems are handled by .gemspec (since this repo is for a gem)
+gemspec

data/README.md

@@ -0,0 +1,64 @@
+# Vips
+
+This gem is a backwards compatible fork of `ruby-vips` but also includes (and compiles) the [libvips] source code.
+
+[![Build Status](https://secure.travis-ci.org/ioquatix/vips.svg)](http://travis-ci.org/ioquatix/vips)
+
+[libvips]: https://jcupitt.github.io/libvips
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'vips'
+```
+
+And then execute:
+
+	$ bundle
+
+Or install it yourself as:
+
+	$ gem install vips
+
+You'll still need to install `glib` and `gobject-introspection`.
+
+## Usage
+
+Exactly the same way as [ruby-vips].
+
+[ruby-vips]: https://github.com/jcupitt/ruby-vips
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+Released under the MIT license.
+
+Copyright, 2014, by John Cupitt. 
+Copyright, 2017, by [Samuel G. D. Williams](http://www.codeotaku.com/samuel-williams).
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,28 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:test)
+
+task :default => :test
+
+task :ext do
+	Dir.chdir "ext" do
+		sh "rake"
+	end
+end
+
+task :console do
+	require 'pry'
+	
+	require_relative 'lib/vips'
+	
+	Pry.start
+end
+
+require "yard/rake/yardoc_task"
+
+YARD::Rake::YardocTask.new do |yard|
+	require "yard"
+	require "github/markup"
+	require "redcarpet"
+end

data/example/annotate.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/ruby
+
+require 'vips'
+
+im = Vips::Image.new_from_file ARGV[0], :access => :sequential
+
+left_text = Vips::Image.text "left corner", :dpi => 300
+left = left_text.embed 50, 50, im.width, 150 
+
+right_text = Vips::Image.text "right corner", :dpi => 300
+right = right_text.embed im.width - right_text.width - 50, 50, im.width, 150
+
+footer = (left | right).ifthenelse(0, [255, 0, 0], :blend => true)
+
+im = im.insert footer, 0, im.height, :expand => true   
+
+im.write_to_file ARGV[1]

data/example/daltonize8.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/ruby
+
+# daltonize an image with ruby-vips
+# based on
+# http://scien.stanford.edu/pages/labsite/2005/psych221/projects/05/ofidaner/colorblindness_project.htm
+# see
+# http://libvips.blogspot.co.uk/2013/05/daltonize-in-ruby-vips-carrierwave-and.html
+# for a discussion of this code
+
+require 'vips'
+
+#Vips.set_debug true
+
+# matrices to convert D65 XYZ to and from bradford cone space
+xyz_to_brad = [
+    [0.8951,  0.2664, -0.1614],
+    [-0.7502,  1.7135,  0.0367],
+    [0.0389, -0.0685,  1.0296]
+]
+brad_to_xyz = [
+    [0.987, -0.147, 0.16],
+    [0.432, 0.5184, 0.0493],
+    [-0.0085, 0.04, 0.968]
+]
+
+im = Vips::Image.new_from_file ARGV[0]
+
+# remove any alpha channel before processing
+alpha = nil
+if im.bands == 4
+    alpha = im[3]
+    im = im.extract_band 0, :n => 3 
+end
+
+begin
+    # import to XYZ with lcms
+    # if there's no profile there, we'll fall back to the thing below
+    xyz = im.icc_import :embedded => true, :pcs => :xyz 
+rescue Vips::Error
+    # nope .. use the built-in converter instead
+    xyz = im.colourspace :xyz
+end
+
+brad = xyz.recomb xyz_to_brad 
+
+# through the Deuteranope matrix
+# we need rows to sum to 1 in Bradford space --- the matrix in the original
+# Python code sums to 1.742
+deut = brad.recomb [
+    [1, 0, 0],
+    [0.7, 0, 0.3],
+    [0, 0, 1]
+]
+
+xyz = deut.recomb brad_to_xyz 
+
+# .. and back to sRGB 
+rgb = xyz.colourspace :srgb
+
+# so this is the colour error 
+err = im - rgb
+
+# add the error back to other channels to make a compensated image
+im = im + err.recomb([
+    [0, 0, 0], 
+    [0.7, 1, 0],
+    [0.7, 0, 1]
+])
+
+# reattach any alpha we saved above
+if alpha
+    im = im.bandjoin(alpha)
+end
+
+im.write_to_file ARGV[1] 

data/example/example1.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'logger'
+require 'vips'
+
+GLib::logger.level = Logger::DEBUG
+
+op = Vips::Operation.new "black"
+
+op = nil
+GC.start
+Vips::Operation.print_all

data/example/example2.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/ruby
+
+require 'logger'
+require 'vips'
+
+puts ""
+puts "starting up:"
+
+# this makes vips keep a list of all active objects which we can print out
+Vips::leak_set true
+
+# disable the operation cache
+Vips::cache_set_max 0
+
+# GLib::logger.level = Logger::DEBUG
+
+n = 10000
+
+n.times do |i|
+    puts ""
+    puts "call #{i} ..."
+    out = Vips::Operation.call "black", [200, 300]
+    if out.width != 200 or out.height != 300
+        puts "bad image result from black"
+    end
+end
+
+puts ""
+puts "after #{n} calls:"
+GC.start
+Vips::Object::print_all
+
+puts ""
+puts "shutting down:"

data/example/example3.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/ruby
+
+require 'vips'
+
+# this makes vips keep a list of all active objects 
+Vips::leak_set true
+
+# disable the operation cache
+# Vips::cache_set_max 0
+
+# turn on debug logging
+GLib::logger.level = Logger::DEBUG
+
+1.times do |i|
+    puts "loop #{i} ..."
+    im = Vips::Image.new_from_file ARGV[0]
+    im = im.embed 100, 100, 3000, 3000, :extend => :mirror
+    im.write_to_file "x.v"
+end

data/example/example4.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/ruby
+
+require 'vips'
+
+# this makes vips keep a list of all active objects 
+Vips::leak_set true
+
+# disable the operation cache
+#Vips::cache_set_max 0
+
+# turn on debug logging
+#Vips.set_debug true
+
+ARGV.each do |filename|
+    im = Vips::Image.new_from_file filename
+    profile = im.get_value "icc-profile-data"
+    puts "profile has #{profile.length} bytes"
+end

data/example/example5.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/ruby
+
+require 'vips'
+
+# this makes vips keep a list of all active objects 
+# Vips::leak_set true
+
+# disable the operation cache
+# Vips::cache_set_max 0
+
+# turn on debug logging
+#Vips.set_debug true
+
+if ARGV.length < 2
+    raise "usage: #{$PROGRAM_NAME}: input-file output-file"
+end
+
+im = Vips::Image.new_from_file ARGV[0], :access => :sequential
+
+im *= [1, 2, 1]
+
+# we want to be able to specify a scale for the convolution mask, so we have to
+# make it ourselves
+# if you are OK with scale=1, you can just pass the array directly to .conv()
+mask = Vips::Image.new_from_array [
+    [-1, -1, -1],
+    [-1, 16, -1],
+    [-1, -1, -1]], 8
+im = im.conv mask
+
+im.write_to_file ARGV[1]

data/example/inheritance_with_refcount.rb

@@ -0,0 +1,286 @@
+#!/usr/bin/ruby
+
+require 'ffi'
+require 'forwardable'
+
+# this is really very crude logging
+
+# @private
+$vips_debug = true
+
+# @private
+def log str
+    if $vips_debug
+        puts str
+    end
+end
+
+def set_debug debug
+    $vips_debug = debug
+end
+
+module Libc
+    extend FFI::Library
+    ffi_lib FFI::Library::LIBC
+
+    attach_function :malloc, [:size_t], :pointer
+    attach_function :free, [:pointer], :void
+end
+
+module GLib
+    extend FFI::Library
+    ffi_lib 'gobject-2.0'
+
+    # nil being the default
+    glib_log_domain = nil
+
+    def self.set_log_domain(domain)
+        glib_log_domain = domain
+    end
+
+    # we have a set of things we need to inherit in different ways:
+    #
+    # - we want to be able to subclass GObject in a simple way
+    # - the layouts of the nested structs
+    # - casting between structs which share a base
+    # - gobject refcounting
+    #
+    # the solution is to split the class into four areas which we treat
+    # differently:
+    #
+    # - we have a "wrapper" Ruby class to allow easy subclassing ... this has a
+    #   @struct member which holds the actual pointer
+    # - we use "forwardable" to forward the various ffi methods on to the
+    #   @struct member ... we arrange things so that subclasses do not need to
+    #   do the forwarding themselves
+    # - we have two versions of the struct: a plain one which we can use for
+    #   casting that will not change the refcounts
+    # - and a managed one with an unref which we just use for .new
+    # - we separate the struct layout into a separate module to avoid repeating
+    #   ourselves
+
+    class GObject
+        extend Forwardable
+        extend SingleForwardable
+
+        def_instance_delegators :@struct, :[], :to_ptr
+        def_single_delegators :ffi_struct, :ptr
+
+        # the layout of the GObject struct
+        module GObjectLayout
+            def self.included(base)
+                base.class_eval do
+                    layout :g_type_instance, :pointer,
+                           :ref_count, :uint,
+                           :qdata, :pointer
+                end
+            end
+        end
+
+        # the struct with unref ... manage object lifetime with this
+        class ManagedStruct < FFI::ManagedStruct
+            include GObjectLayout
+
+            def initialize(ptr)
+                log "GLib::GObject::ManagedStruct.new: #{ptr}"
+                super
+            end
+
+            def self.release(ptr)
+                log "GLib::GObject::ManagedStruct.release: unreffing #{ptr}"
+                GLib::g_object_unref(ptr) unless ptr.null?
+            end
+
+        end
+
+        # the plain struct ... cast with this
+        class Struct < FFI::Struct
+            include GObjectLayout
+
+            def initialize(ptr)
+                log "GLib::GObject::Struct.new: #{ptr}"
+                super
+            end
+
+        end
+
+        # don't allow ptr == nil, we never want to allocate a GObject struct
+        # ourselves, we just want to wrap GLib-allocated GObjects
+        #
+        # here we use ManagedStruct, not Struct, since this is the ref that will
+        # need the unref
+        def initialize(ptr)
+            log "GLib::GObject.initialize: ptr = #{ptr}"
+            @struct = ffi_managed_struct.new(ptr)
+        end
+
+        # access to the cast struct for this class
+        def ffi_struct
+            self.class.ffi_struct
+        end
+
+        class << self
+            def ffi_struct
+                self.const_get(:Struct)
+            end
+        end
+
+        # access to the lifetime managed struct for this class
+        def ffi_managed_struct
+            self.class.ffi_managed_struct
+        end
+
+        class << self
+            def ffi_managed_struct
+                self.const_get(:ManagedStruct)
+            end
+        end
+
+    end
+
+    # :gtype will usually be 64-bit, but will be 32-bit on 32-bit Windows
+    typedef :ulong, :GType
+
+end
+
+module Vips
+    extend FFI::Library
+    ffi_lib 'vips'
+
+    LOG_DOMAIN = "VIPS"
+    GLib::set_log_domain(LOG_DOMAIN)
+
+    # need to repeat this
+    typedef :ulong, :GType
+
+    attach_function :vips_init, [:string], :int
+    attach_function :vips_shutdown, [], :void
+
+    attach_function :vips_error_buffer, [], :string
+    attach_function :vips_error_clear, [], :void
+
+    def self.get_error
+        errstr = Vips::vips_error_buffer
+        Vips::vips_error_clear
+        errstr
+    end
+
+    if Vips::vips_init($0) != 0
+        puts Vips::get_error
+        exit 1
+    end
+
+    at_exit {
+        Vips::vips_shutdown
+    }
+
+    attach_function :vips_object_print_all, [], :void
+    attach_function :vips_leak_set, [:int], :void
+
+    def self.showall
+        if $vips_debug
+            GC.start
+            vips_object_print_all
+        end
+    end
+
+    if $vips_debug
+        vips_leak_set 1
+    end
+
+    class VipsObject < GLib::GObject
+
+        # the layout of the VipsObject struct
+        module VipsObjectLayout
+            def self.included(base)
+                base.class_eval do
+                    # don't actually need most of these, remove them later
+                    layout :parent, GLib::GObject::Struct, 
+                       :constructed, :int,
+                       :static_object, :int,
+                       :argument_table, :pointer,
+                       :nickname, :string,
+                       :description, :string,
+                       :preclose, :int,
+                       :close, :int,
+                       :postclose, :int,
+                       :local_memory, :size_t
+                end
+            end
+        end
+
+        class Struct < GLib::GObject::Struct
+            include VipsObjectLayout
+
+            def initialize(ptr)
+                log "Vips::VipsObject::Struct.new: #{ptr}"
+                super
+            end
+
+        end
+
+        class ManagedStruct < GLib::GObject::ManagedStruct
+            include VipsObjectLayout
+
+            def initialize(ptr)
+                log "Vips::VipsObject::ManagedStruct.new: #{ptr}"
+                super
+            end
+
+        end
+
+    end
+
+    class VipsImage < VipsObject
+
+        # the layout of the VipsImage struct
+        module VipsImageLayout
+            def self.included(base)
+                base.class_eval do
+                    layout :parent, VipsObject::Struct
+                    # rest opaque
+                end
+            end
+        end
+
+        class Struct < VipsObject::Struct
+            include VipsImageLayout
+
+            def initialize(ptr)
+                log "Vips::VipsImage::Struct.new: #{ptr}"
+                super
+            end
+
+        end
+
+        class ManagedStruct < VipsObject::ManagedStruct
+            include VipsImageLayout
+
+            def initialize(ptr)
+                log "Vips::VipsImage::ManagedStruct.new: #{ptr}"
+                super
+            end
+
+        end
+
+        def self.new_partial
+            VipsImage.new(Vips::vips_image_new)
+        end
+
+    end
+
+    attach_function :vips_image_new, [], :pointer
+
+end
+
+puts "creating image"
+begin
+    x = Vips::VipsImage.new_partial 
+    puts "x = #{x}"
+    puts ""
+    puts "x[:parent] = #{x[:parent]}"
+    puts ""
+    puts "x[:parent][:description] = #{x[:parent][:description]}"
+    puts ""
+end
+