ruby-vips 1.0.0 → 1.0.1

data/spec/image_spec.rb

@@ -1,515 +0,0 @@
-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
-