ruby-vips 1.0.6 → 2.0.0

data/lib/vips/operationboolean.rb

@@ -0,0 +1,14 @@
+module Vips
+
+    # The type of boolean operation to perform on an image. See 
+    # {Image#boolean}.
+    #
+    # * ':and' bitwise and
+    # * ':or' bitwise or
+    # * ':eor' bitwise eor
+    # * ':lshift' shift left n bits
+    # * ':rshift' shift right n bits
+
+    class OperationBoolean < Symbol
+    end
+end

data/lib/vips/operationcomplex.rb

@@ -0,0 +1,12 @@
+module Vips
+
+    # The type of complex operation to perform on an image. See 
+    # {Image#complex}.
+    #
+    # * ':polar' to polar coordinates
+    # * ':rect' to rectangular coordinates
+    # * ':conj' complex conjugate
+
+    class OperationComplex < Symbol
+    end
+end

data/lib/vips/operationcomplex2.rb

@@ -0,0 +1,10 @@
+module Vips
+
+    # The type of binary complex operation to perform on an image. See 
+    # {Image#complex2}.
+    #
+    # * ':cross_phase' cross phase
+
+    class OperationComplex2 < Symbol
+    end
+end

data/lib/vips/operationcomplexget.rb

@@ -0,0 +1,11 @@
+module Vips
+
+    # The type of complex projection operation to perform on an image. See 
+    # {Image#complexget}.
+    #
+    # * ':real' get real part
+    # * ':imag' get imaginary part
+
+    class OperationComplexget < Symbol
+    end
+end

data/lib/vips/operationmath.rb

@@ -0,0 +1,18 @@
+module Vips
+
+    # The math operation to perform on an image. See {Image#math}.
+    #
+    # * ':sin' sin(), angles in degrees
+    # * ':cos' cos(), angles in degrees
+    # * ':tan' tan(), angles in degrees
+    # * ':asin' asin(), angles in degrees
+    # * ':acos' acos(), angles in degrees
+    # * ':atan' atan(), angles in degrees
+    # * ':log' log base e 
+    # * ':log10' log base 10 
+    # * ':exp' e to the something
+    # * ':exp10' 10 to the something
+
+    class OperationMath < Symbol
+    end
+end

data/lib/vips/operationmath2.rb

@@ -0,0 +1,10 @@
+module Vips
+
+    # The binary math operation to perform on an image. See {Image#math2}.
+    #
+    # * ':pow' pow()
+    # * ':wop' pow(), but with the arguments reversed
+
+    class OperationMath2 < Symbol
+    end
+end

data/lib/vips/operationrelational.rb

@@ -0,0 +1,15 @@
+module Vips
+
+    # The type of relational operation to perform on an image. See 
+    # {Image#relational}.
+    #
+    # * ':more' more than
+    # * ':less' less than
+    # * ':moreeq' more than or equal to
+    # * ':lesseq' less than or equal to
+    # * ':equal' equal to
+    # * ':noteq' not equal to
+
+    class OperationRelational < Symbol
+    end
+end

data/lib/vips/operationround.rb

@@ -0,0 +1,11 @@
+module Vips
+
+    # The type of rounding to perform on an image. See {Image#round}.
+    #
+    # * ':ceil' round up
+    # * ':floor' round down
+    # * ':rint' round to nearest integer
+
+    class OperationRound < Symbol
+    end
+end

data/lib/vips/size.rb

@@ -6,7 +6,8 @@ module Vips
     # * `:both` size both up and down
     # * `:up` only upsize
     # * `:down` only downsize
+    # * `:force` change aspect ratio
 
-    class Size
+    class Size < Symbol
     end
 end

data/lib/vips/version.rb

@@ -1,4 +1,4 @@
 module Vips
-    VERSION = "1.0.6"
+    VERSION = "2.0.0"
 end
 

data/ruby-vips.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.name = "ruby-vips"
   spec.version = Vips::VERSION
   spec.authors = ["John Cupitt"]
-  spec.date = "2016-06-07"
+  spec.date = "2017-07-15"
   spec.email = "jcupitt@gmail.com"
 
   spec.summary = "Ruby extension for the vips image processing library."
@@ -16,10 +16,6 @@ Gem::Specification.new do |spec|
   spec.homepage = "http://github.com/jcupitt/ruby-vips"
   spec.licenses = ["MIT"]
 
-  # gobject-introspection really needs 2.1, but it just about works on 2.0, the
-  # ruby that OS X is still bundling ... only ask for 2.0 to help OS X
-  spec.required_ruby_version = ">= 2.0"
-  spec.rubygems_version = "2.5.1"
   spec.require_paths = ["lib"]
   spec.extra_rdoc_files = [
     "LICENSE.txt",
@@ -31,7 +27,7 @@ Gem::Specification.new do |spec|
     f.match(%r{^(test|spec|features)/})
   end
 
-  spec.add_runtime_dependency "gobject-introspection", ["~> 3.1"]
+  spec.add_runtime_dependency "ffi", ["~> 1.9"]
 
   spec.add_development_dependency "rake", ["~> 11.0"]
   spec.add_development_dependency "rspec", ["~> 3.3"]

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: ruby-vips
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 2.0.0
 platform: ruby
 authors:
 - John Cupitt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-07 00:00:00.000000000 Z
+date: 2017-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: gobject-introspection
+  name: ffi
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '1.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '1.9'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -135,31 +135,39 @@ files:
 - example/example3.rb
 - example/example4.rb
 - example/example5.rb
+- example/inheritance_with_refcount.rb
 - example/trim8.rb
 - example/watermark.rb
 - example/wobble.rb
 - install-vips.sh
+- lib/ruby-vips.rb
 - lib/vips.rb
 - lib/vips/access.rb
 - lib/vips/align.rb
 - lib/vips/angle.rb
 - lib/vips/angle45.rb
-- lib/vips/argument.rb
 - lib/vips/bandformat.rb
-- lib/vips/call.rb
 - lib/vips/coding.rb
-- lib/vips/demandstyle.rb
 - lib/vips/direction.rb
-- lib/vips/error.rb
 - lib/vips/extend.rb
-- lib/vips/foreignflags.rb
+- lib/vips/gobject.rb
+- lib/vips/gvalue.rb
 - lib/vips/image.rb
 - lib/vips/interesting.rb
 - lib/vips/interpolate.rb
 - lib/vips/interpretation.rb
 - lib/vips/kernel.rb
 - lib/vips/methods.rb
+- lib/vips/object.rb
 - lib/vips/operation.rb
+- lib/vips/operationboolean.rb
+- lib/vips/operationcomplex.rb
+- lib/vips/operationcomplex2.rb
+- lib/vips/operationcomplexget.rb
+- lib/vips/operationmath.rb
+- lib/vips/operationmath2.rb
+- lib/vips/operationrelational.rb
+- lib/vips/operationround.rb
 - lib/vips/size.rb
 - lib/vips/version.rb
 - ruby-vips.gemspec
@@ -175,7 +183,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/vips/argument.rb

@@ -1,159 +0,0 @@
-
-module Vips
-
-    # This class is used internally to convert Ruby values to arguments to 
-    # libvips operations. 
-    # @private
-    class Argument 
-        attr_reader :op, :name, :flags, :priority, :isset, :prop
-        attr_reader :blurb, :gtype, :type
-
-        # map gobject-introspection's ruby class names to ours
-        @@map_goi_to_vips = {
-            "TrueClass" => "Boolean",
-            "Vips::ArrayDouble" => "Array<Double>",
-            "Vips::ArrayInt" => "Array<Integer>",
-            "Vips::ArrayImage" => "Array<Image>",
-            "Vips::ArrayString" => "Array<String>",
-        }
-
-        def initialize(op, name)
-            @op = op
-            @name = name.tr '-', '_'
-            @prop = op.gtype.to_class.property name
-            @blurb = @prop.blurb
-            @gtype = prop.value_type
-            @flags = op.get_argument_flags name
-            @priority = op.get_argument_priority @name
-            @isset = op.argument_isset @name
-
-            type = GLib::Type[gtype.name].to_class.name
-            type = @@map_goi_to_vips[type] if @@map_goi_to_vips.include? type
-            @type = type
-        end
-
-        private
-
-        def self.imageize match_image, value
-            return value if match_image == nil
-            return value if value.is_a? Vips::Image
-
-            # 2D array values become tiny 2D images
-            if value.is_a? Array and value[0].is_a? Array
-                return Vips::Image.new_from_array value
-            end
-
-            # if there's nothing to match to, we also make a 2D image
-            if match_image == nil
-                return Vips::Image.new_from_array value
-            end
-
-            # we have a 1D array ... use that as a pixel constant and expand 
-            # to match match_image
-            match_image.new_from_image(value)
-        end
-
-        # @private
-        class ArrayImageConst < Vips::ArrayImage 
-            def self.new(value)
-                if not value.is_a? Array
-                    value = [value]
-                end
-
-                match_image = value.find {|x| x.is_a? Vips::Image}
-                if match_image == nil
-                    raise Vips::Error, 
-                        "Argument must contain at least one image."
-                end
-
-                value = value.map {|x| Argument::imageize match_image, x}
-
-                # we'd like to just 
-                #   super(value)
-                # to construct, but the gobject-introspection gem does not
-                # support new from object array ... instead, we build in stages
-                array = Vips::ArrayImage.empty
-                value.each {|x| array = array.append(x)}
-
-                return array
-            end
-        end
-
-        # if this gtype needs an array, try to transform the value into one
-        def self.arrayize(gtype, value)
-            arrayize_map = {
-                GLib::Type["VipsArrayDouble"] => Vips::ArrayDouble,
-                GLib::Type["VipsArrayInt"] => Vips::ArrayInt,
-                GLib::Type["VipsArrayImage"] => ArrayImageConst
-            }
-
-            if arrayize_map.has_key? gtype
-                if not value.is_a? Array
-                    value = [value]
-                end
-
-                value = arrayize_map[gtype].new(value)
-            end
-
-            value
-        end
-
-        def self.unwrap value
-            [Vips::Blob, Vips::ArrayDouble, Vips::ArrayImage, 
-                Vips::ArrayInt, Vips::RefString].each do |cls|
-                if value.is_a? cls
-                    value = value.get
-
-                    # blobs come from gobject-introspection as arrays ... 
-                    # repack as strings for convenience
-                    if value and cls == Vips::Blob
-                        value = value.pack("C*")
-                    end
-
-                end
-
-            end
-
-            value
-        end
-
-        public
-
-        def set_value(match_image, value)
-            # array-ize
-            value = Argument::arrayize gtype, value
-
-            # blob-ize
-            if gtype.type_is_a? GLib::Type["VipsBlob"]
-                if not value.is_a? Vips::Blob
-                    value = Vips::Blob.copy value
-                end
-            end
-
-            # image-ize
-            if gtype.type_is_a? GLib::Type["VipsImage"]
-                if not value.is_a? Vips::Image
-                    value = Argument::imageize match_image, value
-                end
-            end
-
-            # MODIFY input images need to be copied before assigning them
-            if (flags & :modify) != 0
-                # don't use .copy(): we want to make a new pipeline with no
-                # reference back to the old stuff ... this way we can free the
-                # previous image earlier 
-                new_image = Vips::Image.memory
-                value.write new_image
-                value = new_image
-            end
-
-            op.set_property @name, value
-        end
-
-        def get_value
-            Argument::unwrap @op.get_property(@name)
-        end
-
-    end
-
-end

data/lib/vips/call.rb

@@ -1,370 +0,0 @@
-module Vips
-
-    # Call a vips operation.
-    #
-    # This will crash if there's a GC during the call, only use 
-    # this via {Vips.call}. 
-    private 
-    class Call
-        attr_writer :instance, :option_string
-
-        def initialize(name, supplied_values)
-            @name = name
-            @supplied_values = supplied_values
-            @optional_values = {}
-            @instance = nil
-            @option_string = nil
-
-            if @supplied_values.last.is_a? Hash
-                @optional_values = @supplied_values.last
-                @supplied_values.delete_at(-1)
-            end
-
-            begin
-                @op = Vips::Operation.new @name
-            rescue
-                raise Vips::Error, "no operator '#{@name}'"
-            end
-
-            log "Vips::Call.init"
-            log "name = #{@name}"
-            log "supplied_values are:"
-            @supplied_values.each {|x| log "   #{x}"}
-            log "optional_values are:"
-            @optional_values.each {|x| log "   #{x}"}
-        end
-
-        # set any string options on the operation
-        def set_string_args
-            if @option_string
-                log "setting string options #{@option_string} ..."
-
-                if @op.set_from_string(@option_string) != 0
-                    raise Error
-                end
-            end
-        end
-
-        # set @match_image to be the image we build constants to match
-        def find_match_image
-            # the instance, if supplied, must be a vips image ... we use it for
-            # match_image, below
-            if @instance and not @instance.is_a? Vips::Image
-                raise Vips::Error, "@instance is not a Vips::Image."
-            end
-
-            # if the op needs images but the user supplies constants, we expand
-            # them to match the first input image argument ... find the first
-            # image
-            log "searching for first image argument ..."
-            match_image = @instance
-            if match_image == nil
-                match_image = @supplied_values.find {|x| x.is_a? Vips::Image}
-            end
-            if match_image == nil
-                match = @optional_values.find do |name, value|
-                    value.is_a? Vips::Image
-                end
-                # if we found a match, it'll be [name, value]
-                if match
-                    match_image = match[1]
-                end
-            end
-
-            return match_image
-        end
-
-        # look through the operation args and find required and optional 
-        # input args
-        def find_input
-            all_args = @op.get_args
-
-            # find unassigned required input args
-            log "finding unassigned required input arguments ..."
-            required_input = all_args.select do |arg|
-                not arg.isset and
-                (arg.flags & :input) != 0 and
-                (arg.flags & :required) != 0 
-            end
-
-            # find optional unassigned input args
-            log "finding optional unassigned input arguments ..."
-            optional_input = all_args.select do |arg|
-                not arg.isset and
-                (arg.flags & :input) != 0 and
-                (arg.flags & :required) == 0 
-            end
-
-            # make a hash from name to arg for the options
-            optional_input = Hash[
-                optional_input.map(&:name).zip(optional_input)]
-
-            return required_input, optional_input
-        end
-
-        def find_optional_output
-            all_args = @op.get_args
-
-            log "finding optional output arguments ..."
-            optional_output = all_args.select do |arg|
-                (arg.flags & :output) != 0 and
-                (arg.flags & :required) == 0 
-            end
-            optional_output = Hash[
-                optional_output.map(&:name).zip(optional_output)]
-
-            return optional_output
-
-        end
-
-        def set_required_input(match_image, required_input)
-            log "set_required_input: @instance = #{@instance}"
-
-            # do we have a non-nil instance? set the first image arg with this
-            if @instance != nil
-                log "BANANA"
-                log "setting first image arg with instance ..."
-                x = required_input.find do |arg|
-                    gtype = GLib::Type["VipsImage"]
-                    vtype = arg.prop.value_type
-
-                    vtype.type_is_a? gtype
-                end
-                if x == nil
-                    raise Vips::Error, 
-                        "No #{@instance.class} argument to #{@name}."
-                end
-                x.set_value match_image, @instance
-                required_input.delete x
-            end
-
-            if required_input.length != @supplied_values.length
-                raise Vips::Error, 
-                    "Wrong number of arguments. '#{@name}' requires " +
-                    "#{required_input.length} arguments, you supplied " +
-                    "#{@supplied_values.length}."
-            end
-
-            log "setting required input arguments ..."
-            required_input.zip(@supplied_values).each do |arg, value|
-                arg.set_value match_image, value
-            end
-
-        end       
-
-        def set_optional_input(match_image, optional_input, optional_output)
-            log "setting optional input args ..."
-            @optional_values.each do |name, value|
-                # we are passed symbols as keys
-                name = name.to_s
-                if optional_input.has_key? name
-                    log "setting #{name} to #{value}"
-                    optional_input[name].set_value match_image, value
-                elsif optional_output.has_key? name and value != true
-                    raise Vips::Error, 
-                        "Optional output argument #{name} must be true."
-                elsif not optional_output.has_key? name 
-                    raise Vips::Error, "No such option '#{name}',"
-                end
-            end
-        end
-
-        def build
-            log "building ..."
-
-            op2 = Vips::cache_operation_lookup @op
-            if op2
-                log "cache hit"
-
-                hit = true
-                @op = op2
-            else
-                log "cache miss ... building"
-
-                hit = false
-                if @op.build() != 0
-                    raise Vips::Error
-                end
-                # showall
-
-                log "adding to cache ... "
-                Vips::cache_operation_add @op
-            end
-
-            return hit
-        end
-
-        def fetch_output(optional_output)
-            log "fetching outputs ..."
-
-            # gather output args 
-            out = []
-
-            all_args = @op.get_args
-            all_args.each do |arg|
-                # required output
-                if (arg.flags & :output) != 0 and
-                    (arg.flags & :required) != 0 
-                    log "fetching required output #{arg.name}"
-                    out << arg.get_value
-                end
-
-                # modified input arg ... this will get the result of the 
-                # copy() we did in Argument.set_value 
-                if (arg.flags & :input) != 0 and
-                    (arg.flags & :modify) != 0 
-                    log "fetching modified input arg ..."
-                    out << arg.get_value
-                end
-            end
-
-            opts = {}
-            @optional_values.each do |name, value|
-                # we are passed symbols as keys
-                name = name.to_s
-                if optional_output.has_key? name
-                    log "fetching optional output arg ..."
-                    opts[name] = optional_output[name].get_value
-                end
-            end
-            out << opts if opts != {}
-
-            if out.length == 1
-                out = out[0]
-            elsif out.length == 0
-                out = nil
-            end
-
-            return out
-
-        end
-
-        def invoke
-            log "invoke starting ..."
-            log "invoke instance is #{@instance}"
-            set_string_args()
-            match_image = find_match_image()
-            required_input, optional_input = find_input()
-            optional_output = find_optional_output()
-
-            set_required_input(match_image, required_input)
-            set_optional_input(match_image, optional_input, optional_output)
-
-            hit = build()
-
-            # if there was a cache hit, we need to refind this since all the arg
-            # pointers will have changed
-            if hit
-                optional_output = find_optional_output()
-            end
-            out = fetch_output(optional_output)
-
-            log "unreffing outputs ..."
-            @op.unref_outputs()
-            @op = nil
-            # showall
-
-            log "success! #{@name}.out = #{out}"
-
-            return out
-        end
-
-    end
-
-    # full-fat call, with the GC disabled
-    private
-    def self.call_base(name, instance, option_string, supplied_values)
-        gc_was_enabled = GC.disable
-        begin
-            call = Call.new(name, supplied_values)
-            call.instance = instance
-            call.option_string = option_string
-            result = call.invoke
-        ensure
-            GC.enable if gc_was_enabled
-        end
-
-        return result
-    end
-
-    public
-
-    # This is the public entry point for the vips binding. {call} will run
-    # any vips operation, for example:
-    #
-    # ```ruby
-    # out = Vips::call "black", 100, 100, :bands => 12
-    # ```
-    #
-    # will call the C function 
-    #
-    # ```C
-    # vips_black( &out, 100, 100, "bands", 12, NULL );
-    # ```
-    # 
-    # There are {Image#method_missing} hooks which will run {call} for you 
-    # on {Image} for undefined instance or class methods. So you can also 
-    # write:
-    #
-    # ```ruby
-    # out = Vips::Image.black 100, 100, :bands => 12
-    # ```
-    #
-    # Or perhaps:
-    #
-    # ```ruby
-    # x = Vips::Image.black 100, 100
-    # y = x.invert
-    # ```
-    #
-    # to run the `vips_invert()` operator.
-    #
-    # There are also a set of operator overloads and some convenience functions,
-    # see {Image}. 
-    #
-    # If the operator needs a vector constant, {call} will turn a scalar into a
-    # vector for you. So for `x.linear(a, b)`, which calculates 
-    # `x * a + b` where `a` and `b` are vector constants, you can write:
-    #
-    # ```ruby
-    # x = Vips::Image.black 100, 100, :bands => 3
-    # y = x.linear(1, 2)
-    # y = x.linear([1], 4)
-    # y = x.linear([1, 2, 3], 4)
-    # ```
-    #
-    # or any other combination. The operator overloads use this facility to
-    # support all the variations on:
-    #
-    # ```ruby
-    # x = Vips::Image.black 100, 100, :bands => 3
-    # y = x * 2
-    # y = x + [1,2,3]
-    # y = x % [1]
-    # ```
-    #
-    # Similarly, wherever an image is required, you can use a constant. The
-    # constant will be expanded to an image matching the first input image
-    # argument. For example, you can write:
-    #
-    # ```
-    # x = Vips::Image.black 100, 100, :bands => 3
-    # y = x.bandjoin(255)
-    # ```
-    #
-    # to add an extra band to the image where each pixel in the new band has 
-    # the constant value 255. 
-
-    def self.call(name, *args)
-        gc_was_enabled = GC.disable
-        begin
-            call = Call.new(name, args)
-            result = call.invoke
-        ensure
-            GC.enable if gc_was_enabled
-        end
-
-        return result
-    end
-
-end