devil 0.1.6-x86-mswin32-60

data/ext/devil/ruby_ilu.c

@@ -0,0 +1,154 @@
+#include <ruby.h>
+#include <IL/ilu.h>
+#include "ruby_devil_ext.h"
+
+static VALUE mILU;
+
+static VALUE ilu_Init(VALUE obj) {
+    iluInit();
+    return Qnil;
+}
+
+static VALUE ilu_ErrorString(VALUE obj, VALUE rb_error) {
+    ILenum num = NUM2INT(rb_error);
+    const char* error = iluErrorString(num);
+    return rb_str_new2(error);
+}
+
+static VALUE ilu_Alienify(VALUE obj) {
+    ILboolean flag = iluAlienify();
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilu_BlurAvg(VALUE obj, VALUE rb_iter) {
+    ILuint iter = NUM2INT(rb_iter);
+    ILboolean flag = iluBlurAvg(iter);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilu_BlurGaussian(VALUE obj, VALUE rb_iter) {
+    ILuint iter = NUM2INT(rb_iter);
+    ILboolean flag = iluBlurGaussian(iter);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilu_Contrast(VALUE obj, VALUE rb_cont) {
+    ILfloat cont = NUM2DBL(rb_cont);
+    ILboolean flag = iluContrast(cont);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilu_Equalize(VALUE obj) {
+    ILboolean flag = iluEqualize();
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilu_GammaCorrect (VALUE obj, VALUE rb_gamma) {
+    ILfloat gamma = NUM2DBL(rb_gamma);
+    ILboolean flag = iluGammaCorrect(gamma);
+    return flag ? Qtrue : Qfalse;
+}
+static VALUE ilu_Negative (VALUE obj) {
+    ILboolean flag = iluNegative();
+    return flag ? Qtrue : Qfalse;
+}
+static VALUE ilu_Noisify (VALUE obj, VALUE rb_tolerance) {
+    ILclampf tolerance = NUM2DBL(rb_tolerance);
+    ILboolean flag = iluNoisify(tolerance);
+    return flag ? Qtrue : Qfalse;
+}
+static VALUE ilu_Pixelize (VALUE obj, VALUE rb_pix_size) {
+    ILuint pix = NUM2INT(rb_pix_size);
+    ILboolean flag = iluPixelize(pix);
+    return flag ? Qtrue : Qfalse;
+}
+static VALUE ilu_Sharpen (VALUE obj, VALUE rb_factor, VALUE rb_iter) {
+    ILfloat factor = NUM2DBL(rb_factor);
+    ILuint iter = NUM2INT(rb_iter);
+    ILboolean flag = iluSharpen(factor, iter);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilu_Scale(VALUE obj, VALUE rb_Width, VALUE rb_Height, VALUE rb_Depth) {
+    ILuint Width = NUM2INT(rb_Width);
+    ILuint Height = NUM2INT(rb_Height);
+    ILuint Depth = NUM2INT(rb_Depth);
+    ILboolean flag = iluScale(Width, Height, Depth);
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilu_ImageParameter(VALUE obj, VALUE rb_PName, VALUE rb_Param) {
+    ILenum PName = NUM2INT(rb_PName);
+    ILenum Param = NUM2INT(rb_Param);
+    iluImageParameter(PName, Param);
+    return Qnil;
+}
+
+static VALUE ilu_BuildMipmaps(VALUE obj) {
+    ILboolean flag = iluBuildMipmaps();
+    return flag ? Qtrue : Qfalse;
+}
+
+/* functions added by banisterfiend */
+static VALUE ilu_FlipImage(VALUE obj) {
+    ILboolean flag = iluFlipImage();
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilu_Rotate(VALUE obj, VALUE rb_angle) {
+    ILfloat angle = NUM2DBL(rb_angle);
+
+    ILboolean flag = iluRotate(angle);
+
+    return flag ? Qtrue : Qfalse;
+}
+
+static VALUE ilu_Crop(VALUE obj, VALUE rb_XOff, VALUE rb_YOff, VALUE rb_width, VALUE rb_height)
+{
+    ILuint XOff = NUM2INT(rb_XOff);
+    ILuint YOff = NUM2INT(rb_YOff);
+    ILuint width = NUM2INT(rb_width);
+    ILuint height = NUM2INT(rb_height);
+                       	
+    ILboolean flag = iluCrop(XOff, YOff, 1, width, height, 1);
+
+    return flag ? Qtrue : Qfalse;
+}
+/* end of functions added by banisterfiend */
+
+void
+InitializeILU() {
+    mILU = rb_define_module("ILU");
+    rb_define_module_function(mILU, "Init", ilu_Init, 0);
+    rb_define_module_function(mILU, "ErrorString", ilu_ErrorString, 1);
+    rb_define_module_function(mILU, "Alienify", ilu_Alienify, 0);
+    rb_define_module_function(mILU, "BlurAvg", ilu_BlurAvg, 1);
+    rb_define_module_function(mILU, "BlurGaussian", ilu_BlurGaussian, 1);
+    rb_define_module_function(mILU, "Contrast",ilu_Contrast , 1);
+    rb_define_module_function(mILU, "Equalize",ilu_Equalize , 0);
+    rb_define_module_function(mILU, "GammaCorrect",ilu_GammaCorrect , 1);
+    rb_define_module_function(mILU, "Negative", ilu_Negative , 0);
+    rb_define_module_function(mILU, "Noisify", ilu_Noisify , 1);
+    rb_define_module_function(mILU, "Pixelize", ilu_Pixelize , 1);
+    rb_define_module_function(mILU, "Sharpen", ilu_Sharpen, 2);
+    rb_define_module_function(mILU, "Scale", ilu_Scale , 3);
+    rb_define_module_function(mILU, "ImageParameter", ilu_ImageParameter , 2);
+    rb_define_module_function(mILU, "BuildMipmaps",  ilu_BuildMipmaps, 0);
+
+    /* methods added by banisterfiend */
+    rb_define_module_function(mILU, "FlipImage",  ilu_FlipImage, 0);
+    rb_define_module_function(mILU, "Rotate",  ilu_Rotate, 1);
+    rb_define_module_function(mILU, "Crop",  ilu_Crop, 4);
+    /* end of functions added by banisterfiend */
+
+    rb_define_const(mILU, "FILTER", INT2NUM(ILU_FILTER));
+    rb_define_const(mILU, "NEAREST", INT2NUM(ILU_NEAREST));
+    rb_define_const(mILU, "LINEAR", INT2NUM(ILU_LINEAR));
+    rb_define_const(mILU, "BILINEAR", INT2NUM(ILU_BILINEAR));
+    rb_define_const(mILU, "SCALE_BOX", INT2NUM(ILU_SCALE_BOX));
+    rb_define_const(mILU, "SCALE_TRIANGLE", INT2NUM(ILU_SCALE_TRIANGLE));
+    rb_define_const(mILU, "SCALE_BELL", INT2NUM(ILU_SCALE_BELL));
+    rb_define_const(mILU, "SCALE_BSPLINE", INT2NUM(ILU_SCALE_BSPLINE));
+    rb_define_const(mILU, "SCALE_LANCZOS3", INT2NUM(ILU_SCALE_LANCZOS3));
+    rb_define_const(mILU, "SCALE_MITCHELL", INT2NUM(ILU_SCALE_MITCHELL));
+}

data/lib/devil.rb

@@ -0,0 +1,226 @@
+require 'rbconfig'
+
+direc = File.dirname(__FILE__)
+dlext = Config::CONFIG['DLEXT']
+begin
+    if RUBY_VERSION && RUBY_VERSION =~ /1.9/
+        require "#{direc}/1.9/devil.#{dlext}"
+    else
+        require "#{direc}/1.8/devil.#{dlext}"
+    end
+rescue LoadError => e
+    require "#{direc}/devil.#{dlext}"
+end
+
+# Provides a high level wrapper for the low-level DevIL Ruby bindings
+module Devil
+    VERSION = '0.1.6'
+    
+    class << self
+
+        # loads +file+ and returns a new image
+        # Optionally accepts a block and yields the newly created image to the block.
+        def load_image(file, &block)
+            name = IL.GenImages(1).first
+            IL.BindImage(name)
+            IL.LoadImage(file)
+
+            img = Image.new(name, file)
+            if block
+                block.call(img)
+            end
+            
+            img
+        end
+
+        # convert an image +blob+ with +width+ and +height+
+        # to a bona fide image
+        def from_blob(blob, width, height)
+            Image.new(IL.FromBlob(blob, width, height), nil)
+        end
+
+        # initializes Devil and sets defaults
+        # This method should never need to be called directly.
+        def init
+            # initialize DevIL
+            IL.Init
+
+            # default options
+            IL.Enable(IL::FILE_OVERWRITE)
+            ILU.ImageParameter(ILU::FILTER, ILU::BILINEAR) 
+        end
+
+        alias_method :with_image, :load_image
+        alias_method :load, :load_image
+    end
+
+    class Image
+        attr_reader :name, :file
+
+        def initialize(name, file)
+            @name = name
+            @file = file
+
+            ObjectSpace.define_finalizer( self, proc { IL.DeleteImages(1, [name]) } )
+        end
+        
+        # returns the width of the image
+        def width
+            set_binding
+            IL.GetInteger(IL::IMAGE_WIDTH)
+        end
+
+        # returns the height of the image
+        def height
+            set_binding
+            IL.GetInteger(IL::IMAGE_HEIGHT)
+        end
+
+        # saves the image to +file+. If no +file+ is provided default to the opened file.
+        def save(file = @file)
+            set_binding
+            IL.SaveImage(file)
+            self
+        end
+        
+        # resize the image to +width+ and +height+. Aspect ratios of the image do not have to be the same.
+        def resize(width, height)
+            set_binding
+            ILU.Scale(width, height, 1)
+            self
+        end
+
+        # Creates a proportional thumbnail of the image scaled so its longest
+        # edge is resized to +size+ 
+        def thumbnail(size)
+            # this thumbnail code from image_science.rb
+            
+            w, h = width, height
+            scale = size.to_f / (w > h ? w : h)
+            resize((w * scale).to_i, (h * scale).to_i)
+            self
+        end
+
+        # return a deep copy of the current image
+        def dup
+            set_binding
+            Image.new(IL.CloneCurImage, nil)
+        end
+
+        # crop the current image
+        # +xoff+ number of pixels to skip in x direction
+        # +yoff+ number of pixels to skip in y direction
+        # +width+ number of pixels to preserve in x direction
+        # +height+ number of pixels to preserve in y direction
+        def crop(xoff, yoff, width, height)
+            set_binding
+            ILU.Crop(xoff, yoff, width, height)
+            self
+        end
+
+        # performs a gaussian blur on the image. The blur is performed +iter+ times.
+        def blur(iter)
+            set_binding
+            ILU.BlurGaussian(iter)
+            self
+        end
+
+        # 'pixelize' the image using a pixel size of +pixel_size+
+        def pixelize(pixel_size)
+            set_binding
+            ILU.Pixelize(pixel_size)
+            self
+        end
+
+        # add random noise to the image. +factor+ is the tolerance to use.
+        # accepeted values range from 0.0 - 1.0
+        def noisify(factor)
+            set_binding
+            ILU.Noisify(factor)
+            self
+        end
+
+        # The sharpening +factor+ must be in the range of 0.0 - 2.5. A value of 1.0 for the sharpening
+        # factor will have no effect on the image. Values in the range 1.0 - 2.5 will sharpen the
+        # image, with 2.5 having the most pronounced sharpening effect. Values from 0.0 to 1.0 do
+        # a type of reverse sharpening, blurring the image. Values outside of the 0.0 - 2.5 range
+        # produce undefined results.
+        #        
+        # The number of +iter+ (iterations) to perform will usually be 1, but to achieve more sharpening,
+        # increase the number of iterations. 
+        def sharpen(factor, iter)
+            set_binding
+            ILU.Sharpen(factor, iter)
+            self
+        end
+
+        # applies gamma correction to an image using an exponential curve.
+        # +factor+ is gamma correction factor to use.
+        # A value of 1.0 leaves the image unmodified.
+        # Values in the range 0.0 - 1.0 darken the image
+        # Values above 1.0 brighten the image.
+        def gamma_correct(factor)
+            set_binding
+            ILU.GammaCorrect(factor)
+            self
+        end
+
+        # invert the color of every pixel in the image.
+        def negative
+            set_binding
+            ILU.Negative
+            self
+        end
+
+        # +factor+ describes desired contrast to use
+        # A value of 1.0 has no effect on the image.
+        # Values between 1.0 and 1.7 increase the amount of contrast (values above 1.7 have no effect)
+        # Valid range of +factor+ is 0.0 - 1.7
+        def contrast(factor)
+            set_binding
+            ILU.Contrast(factor)
+            self
+        end
+
+        # darkens the bright colours and lightens the dark
+        # colours, reducing the contrast in an image or 'equalizing' it.
+        def equalize
+            set_binding
+            ILU.Equalize
+            self
+        end
+
+        # returns the image data in the form of a ruby string
+        # The image data is formatted to RGBA / UNSIGNED BYTE
+        def to_blob
+            set_binding
+            IL.ToBlob
+        end
+
+        # flip the image about its x axis
+        def flip
+            set_binding
+            ILU.FlipImage
+            self
+        end
+
+        # rotate an image about its central point by +angle+ degrees
+        def rotate(angle)
+            set_binding
+            ILU.Rotate(angle)
+            self
+        end
+
+        alias_method :columns, :width
+        alias_method :rows, :height
+
+        private
+        
+        def set_binding
+            IL.BindImage(@name)
+        end
+
+    end
+end
+
+Devil.init

data/lib/devil/gosu.rb

@@ -0,0 +1,96 @@
+require 'texplay'
+require 'devil'
+
+module TexPlay
+
+    # save a Gosu::Image to +file+
+    # This method is only available if require 'devil/gosu' is used
+    def save(file)
+        capture { 
+            save_image = Devil.from_blob(self.to_blob, self.width, self.height)
+            save_image.flip
+            save_image.save(file)
+        }
+    end
+
+    # convert a Gosu::Image to a Devil::Image
+    # This method is only available if require 'devil/gosu' is used
+    def to_devil
+        devil_img = nil
+        capture {
+            devil_img = Devil.from_blob(self.to_blob, self.width, self.height)
+            devil_img.flip
+        }
+        devil_img
+    end
+end
+
+class Gosu::Window
+
+    # return a screenshot of the framebuffer as a Devil::Image
+    # This method is only available if require 'devil/gosu' is used
+    def screenshot
+        require 'opengl'
+
+        canvas_texture_id = glGenTextures(1).first
+        
+        img = nil
+        self.gl do
+            glEnable(GL_TEXTURE_2D)
+            glBindTexture(GL_TEXTURE_2D, canvas_texture_id)
+            
+            glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, 1)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, self.width, self.height, 0, GL_RGB, GL_UNSIGNED_BYTE, "\0" * self.width * self.height * 3)
+            
+            glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 0, 0, self.width, self.height, 0)
+
+            data = glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE)
+            img = Devil.from_blob(data, self.width, self.height)
+        end
+        
+        img
+    end
+end
+
+class Devil::Image
+
+    # convert a Devil::Image to a Gosu::Image.
+    # Must provide a +window+ parameter, as per Gosu::Image#new()
+    def to_gosu(window)
+        Gosu::Image.new(window, self)
+    end
+    
+    # display the Devil images on screen utilizing the Gosu library for visualization
+    # if +x+ and +y+ are specified then show the image centered at this location, otherwise
+    # draw the image at the center of the screen 
+    # This method is only available if require 'devil/gosu' is used
+    def show(x = 512, y = 384)
+        if !Devil.const_defined?(:Window)
+            c = Class.new(Gosu::Window) do
+                attr_accessor :show_list
+                
+                def initialize
+                    super(1024, 768, false)
+                    @show_list = []
+                end
+
+                def draw    # :nodoc:
+                    @show_list.each { |v| v[:image].draw_rot(v[:x], v[:y], 1, 0) }
+                end
+            end
+
+            Devil.const_set :Window, c
+        end
+        
+        if !defined? @@window
+            @@window ||= Devil::Window.new
+
+            at_exit { @@window.show }
+        end
+        
+        @@window.show_list.push :image => Gosu::Image.new(@@window, self), :x => x, :y => y
+    end
+
+end