compass-magick 0.1.2

data/LICENSE.md

@@ -0,0 +1,22 @@
+The MIT License
+===============
+
+> Copyright (c) 2011 Stan Angeloff
+>
+> 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/README.md

@@ -0,0 +1,67 @@
+Compass Magick
+==============
+
+Dynamic image generation for Compass using ChunkyPNG (no dependency on RMagick).
+
+Example
+-------
+
+    body {
+      background: transparent magick-canvas(100px, 100px,
+        magick-fill(magick-linear-gradient(red, green, blue))
+      ) repeat-x;
+    }
+
+A CSS3 [Sassy Button](http://jaredhardy.com/sassy-buttons/) recreated in Compass Magick:  
+[StanAngeloff.github.com/compass-magick/](http://stanangeloff.github.com/compass-magick/) (showcases all features)
+
+Installation
+------------
+
+Installation is simple via RubyGems. [Compass](http://beta.compass-style.org) and [ChunkyPNG](https://github.com/wvanbergen/chunky_png) are required.
+
+    gem install compass-magick
+
+Usage
+-----
+
+To start a new Compass project with Magick included:
+
+    compass create -r magick my_project
+
+To use Compass Magick within your existing projects, require the plugin from your Compass configuration:
+
+    require 'magick'
+
+APIs
+----
+
+[List of all available commands](https://github.com/StanAngeloff/compass-magick/blob/master/APIs.md).
+
+RDoc is also [available for the entire project](http://stanangeloff.github.com/compass-magick/doc/frames.html).
+
+Contribute
+----------
+
+Compass Magick is very much a work in progress. Documentation is sparse, speed is a major issue and there are probably a lot of bugs.
+
+You can help by looking at any of the following areas (ordered by priority):
+
+- [Optimizing the code](https://github.com/StanAngeloff/compass-magick/blob/master/lib/magick/canvas.rb#L98) as floating point math may not always be needed and too many object copies sucks
+- [Writing tests](https://github.com/StanAngeloff/compass-magick/tree/master/spec) to make sure nothing breaks in new versions
+- [Performing code reviews](https://github.com/StanAngeloff/compass-magick/tree/master/lib) since this is my very first Ruby project and I don't have any experience with the language so there are probably many st**OO**pid things in code
+- [Improving RDoc](http://stanangeloff.github.com/compass-magick/doc/frames.html) because you can never have too much documentation
+- [Adding new plugins](http://stanangeloff.github.com/compass-magick/doc/Compass/Magick/Plugins.html). Compass Magick [looks](https://github.com/StanAngeloff/compass-magick/blob/master/lib/magick.rb#L39) for Ruby files and imports those on startup
+- [Submitting more examples](https://github.com/StanAngeloff/compass-magick/tree/gh-pages) to show off what Compass Magick can do
+- [Opening issues](https://github.com/StanAngeloff/compass-magick/issues) for features you find missing or broken
+- Porting over some of [CamanJS](http://camanjs.com/)' goodness, we all love visual effects
+
+### Credits
+
+- [Willem van Bergen](http://twitter.com/#!/wvanbergen) for his great work on ChunkyPNG which has been a major source of knowledge while working on the project
+- [Chris Eppstein](http://twitter.com/#!/chriseppstein) for [Compass](https://github.com/chriseppstein/compass) itself
+- The Ruby community for being awesome and welcoming a stranger
+
+### Copyright
+
+Copyright (c) 2011 Stan Angeloff. See [LICENSE.md](https://github.com/StanAngeloff/compass-magick/blob/master/LICENSE.md) for details.

data/lib/magick/canvas.rb

@@ -0,0 +1,127 @@
+require 'base64'
+
+module Compass::Magick
+  # A Canvas class that inherits ChunkyPNG::Canvas to represent the image as
+  # a matrix of pixels.
+  #
+  # The canvas is constructed from a given width and height on a transparent
+  # background. The list of commands is executed in order and the resulting
+  # image is returned as a Base64 encoded PNG-24 Data URI.
+  #
+  # @see http://rdoc.info/gems/chunky_png/0.12.0/ChunkyPNG/Canvas
+  # @example
+  #
+  #     Canvas.new(320, 240).to_data_uri
+  class Canvas < ChunkyPNG::Canvas
+    include Scriptable
+    include Utils
+
+    # Initializes a new Canvas instance.
+    #
+    # @overload initialize(canvas, *commands)
+    #   @param [Canvas] canvas Copy image from another Canvas object.
+    #   @param [Array<Command>] commands The list of commands to execute on
+    #     new Canvas instance.
+    # @overload initialize(data, *commands)
+    #   @param [Sass::Script::String] data A Base64 encoded Data URL
+    #     containing the image.
+    #   @param [Array<Command>] commands The list of commands to execute on
+    #     the Canvas instance.
+    # @overload initialize(url, *commands)
+    #   @param [Sass::Script::String] url The URL to the image, relative to
+    #     the stylesheet.
+    #   @param [Array<Command>] commands The list of commands to execute on
+    #     the Canvas instance.
+    # @overload initialize(path, *commands)
+    #   @param [Sass::Script::String] path The path to the image, relative to
+    #     the configured <tt>images_dir</tt>.
+    #   @param [Array<Command>] commands The list of commands to execute on
+    #     the Canvas instance.
+    # @overload initialize(width, height, *commands)
+    #   @param [Sass::Script::Number] width The width of the new transparent
+    #     Canvas.
+    #   @param [Sass::Script::Number] height The height of the new transparent
+    #     Canvas.
+    #   @param [Array<Command>] commands The list of commands to execute on the
+    #     Canvas instance.
+    def initialize(*commands)
+      from_any(commands)
+      list = []
+      commands.each do |command|
+        if command.kind_of?(Sass::Script::List)
+          list.push(command.value)
+        else
+          list.push(command)
+        end
+      end
+      list.flatten!
+      list.each_with_index { |command, index| assert_type "command[#{index}]", command, Command }
+      list.each do |command|
+        result = command.block.call(self)
+        inherit result, false if result.kind_of?(ChunkyPNG::Canvas) unless result == self
+      end
+    end
+
+    # Serializes the Canvas as a Base64 encoded PNG-24 Data URI.
+    #
+    # @return [String] A Base64 encoded PNG-24 Data URI for the generated
+    #   image.
+    def to_data_uri(options = {})
+      data = Base64.encode64(to_blob).gsub("\n", '')
+      "url('data:image/png;base64,#{data}')"
+    end
+
+    alias :to_s :to_data_uri
+
+    # Tile the Canvas to fill the region defined by `width` and `height`.
+    #
+    # @return {Canvas} A new Canvas instance that fills the given region.
+    def tile(width, height)
+      canvas = ChunkyPNG::Canvas.new(width, height)
+      for y in (0...height)
+        for x in (0...width)
+          canvas.set_pixel(x, y, @pixels[(x % @width) + (y % @height) * @height])
+        end
+      end
+      canvas
+    end
+
+    private
+
+    def inherit(canvas, copy = true)
+      @width  = canvas.width
+      @height = canvas.height
+      @pixels = (copy ? canvas.pixels.dup : canvas.pixels)
+      self
+    end
+
+    def from_any(args)
+      source = args.shift
+      if source.kind_of?(ChunkyPNG::Canvas)
+        inherit source
+      elsif source.kind_of?(Sass::Script::Number)
+        inherit ChunkyPNG::Canvas.new(source.value, args.shift.value), false
+      elsif source.kind_of?(Sass::Script::String)
+        if source.value.include?('url(')
+          if source.value.include?('base64,')
+            encoded  = source.value.match(/base64,([a-zA-Z0-9+\/=]+)/)[1]
+            blob     = Base64.decode64(encoded)
+            canvas   = ChunkyPNG::Canvas.from_blob(blob)
+          else
+            filename = source.value.gsub(/^url\(['"]?|["']?\)$/, '')
+            path     = File.join(Compass.configuration.css_path, filename.split('?').shift())
+            canvas   = ChunkyPNG::Canvas.from_file(path)
+          end
+        else
+          path   = File.join(Compass.configuration.images_path, source.value.split('?').shift())
+          canvas = ChunkyPNG::Canvas.from_file(path)
+        end
+        inherit canvas, false
+      else
+        raise NotSupported.new("Canvas.new(..) expected argument of type " +
+          "Compass::Magick::Canvas, Sass::Script::Number or Sass::Script::String " +
+          "got #{source.class}(#{source.inspect}) instead")
+      end
+    end
+  end
+end

data/lib/magick/command.rb

@@ -0,0 +1,32 @@
+module Compass::Magick
+  # A class that executes a block on a {Canvas} object.
+  #
+  # When a function is called in a Sass document, it delays its execution
+  # until placed within a canvas. To do so, it must store state and return a
+  # valid Sass node.
+  #
+  # @example
+  #
+  #     Command.new do |canvas|
+  #       canvas.rect(0, 0, canvas.width - 1, canvas.height - 1, ChunkyPNG::Color::BLACK)
+  #     end
+  class Command
+    include Scriptable
+    include Utils
+
+    # Initializes a new Command instance.
+    #
+    # @param [Proc] block The block to execute.
+    def initialize(&block)
+      @block = block
+    end
+
+    # @return [Proc] The block to execute.
+    attr_reader :block
+
+    # Raises an error if the command is used outside of a {Canvas} object.
+    def to_s(options = {})
+      raise NotAllowed.new("#{self.class} cannot be used outside of a Compass::Magick::Canvas object")
+    end
+  end
+end

data/lib/magick/effect.rb

@@ -0,0 +1,34 @@
+module Compass::Magick
+  # A class that executes a processing block on each {Canvas} pixel.
+  #
+  # @example
+  #
+  #     # Turn all pixels opaque
+  #     Effect.new do |pixel|
+  #       pixel | 0x000000ff
+  #     end
+  class Effect < Command
+
+    # Initializes a new Effect instance.
+    #
+    # @param [Proc] process The processing block to execute.
+    def initialize(&process)
+      @process = process
+      @block   = lambda do |canvas|
+        for y in 0...canvas.height do
+          for x in 0...canvas.width do
+            canvas.set_pixel(x, y, @process.call(canvas.get_pixel(x, y)))
+          end
+        end
+      end
+    end
+
+    # Clamp value between 0..255 so it doesn't overflow the 8-bit colorspace.
+    #
+    # @param [Float] value The value to clamp.
+    # @return [Integer] The value as an integer between 0..255.
+    def self.clamp(value)
+      [0, [value.to_i, 255].min].max
+    end
+  end
+end

data/lib/magick/functions/canvas.rb

@@ -0,0 +1,41 @@
+module Compass::Magick
+  module Functions
+    # Methods for creating a new {Compass::Magick::Canvas}.
+    module Canvas
+      # Creates a new {Compass::Magick::Canvas} and execute all
+      # commands on the instance.
+      #
+      # @overload magick_canvas(canvas, *commands)
+      #   @param [Canvas] canvas Copy image from another Canvas object.
+      #   @param [Array<Command>] commands The list of commands to execute on
+      #     new Canvas instance.
+      # @overload magick_canvas(data, *commands)
+      #   @param [Sass::Script::String] data A Base64 encoded Data URL
+      #     containing the image.
+      #   @param [Array<Command>] commands The list of commands to execute on
+      #     the Canvas instance.
+      # @overload magick_canvas(url, *commands)
+      #   @param [Sass::Script::String] url The URL to the image, relative to
+      #     the stylesheet.
+      #   @param [Array<Command>] commands The list of commands to execute on
+      #     the Canvas instance.
+      # @overload magick_canvas(path, *commands)
+      #   @param [Sass::Script::String] path The path to the image, relative
+      #     to the configured <tt>images_dir</tt>.
+      #   @param [Array<Command>] commands The list of commands to execute on
+      #     the Canvas instance.
+      # @overload magick_canvas(width, height, *commands)
+      #   @param [Sass::Script::Number] width The width of the new transparent
+      #     Canvas.
+      #   @param [Sass::Script::Number] height The height of the new
+      #     transparent Canvas.
+      #   @param [Array<Command>] commands The list of commands to execute on
+      #     the Canvas instance.
+      # @return [String] A Base64 encoded PNG-24 Data URI for the generated
+      #   image.
+      def magick_canvas(*commands)
+        Compass::Magick::Canvas.new(*commands)
+      end
+    end
+  end
+end

data/lib/magick/functions/drawing.rb

@@ -0,0 +1,156 @@
+module Compass::Magick
+  module Functions
+    # Methods for drawing on a {Compass::Magick::Canvas}.
+    module Drawing
+      # Fills the {Canvas} region with the given {Compass::Magick::Type}.
+      #
+      # @param [Object] type The type of fill to apply. Supported:
+      #   * Sass::Script::Color
+      #   * Sass::Script::String
+      #   * {Compass::Magick::Types::Solid}
+      #   * {Compass::Magick::Types::Gradients::Linear}
+      # @param [Sass::Script::Number] x1 The left coordinate of the fill.
+      # @param [Sass::Script::Number] y1 The top coordinate of the fill.
+      # @param [Sass::Script::Number] x2 The right coordinate of the fill.
+      # @param [Sass::Script::Number] y2 The bottom coordinate of the fill.
+      # @return {Command} A command which applies the fill on the canvas.
+      def magick_fill(type, x1 = nil, y1 = nil, x2 = nil, y2 = nil)
+        Compass::Magick::Utils.assert_type 'x1', x1, Sass::Script::Number
+        Compass::Magick::Utils.assert_type 'y1', y1, Sass::Script::Number
+        Compass::Magick::Utils.assert_type 'x2', x2, Sass::Script::Number
+        Compass::Magick::Utils.assert_type 'y2', y2, Sass::Script::Number
+        Command.new do |canvas|
+          canvas_x1 = Compass::Magick::Utils.value_of(x1, canvas.width,  0)
+          canvas_y1 = Compass::Magick::Utils.value_of(y1, canvas.height, 0)
+          canvas_x2 = Compass::Magick::Utils.value_of(x2, canvas.width,  canvas.width)
+          canvas_y2 = Compass::Magick::Utils.value_of(y2, canvas.height, canvas.height)
+          canvas_x1, canvas_x2 = canvas_x2, canvas_x1 if canvas_x1 > canvas_x2
+          canvas_y1, canvas_y2 = canvas_y2, canvas_y1 if canvas_y1 > canvas_y2
+          width     = Sass::Script::Number.new(canvas_x2 - canvas_x1)
+          height    = Sass::Script::Number.new(canvas_y2 - canvas_y1)
+          top       = type
+          tail      = []
+          if top.kind_of?(Sass::Script::List)
+            tail = top.value
+            top  = tail.shift
+          end
+          overlay = Compass::Magick::Utils.to_canvas(top, width, height)
+          tail.each do |mask_type|
+            mask_canvas = Compass::Magick::Utils.to_canvas(mask_type, width, height)
+            overlay     = Compass::Magick::Canvas.new(overlay, magick_mask(mask_canvas))
+          end
+          canvas.compose(overlay, canvas_x1, canvas_y1)
+        end
+      end
+
+      # Draws a circle on the {Canvas} with the given fill
+      # {Compass::Magick::Type}.
+      #
+      # The X and Y coordinates are **not** the center of the circle, but
+      # rather the coordinates at which the circle is composed on top of the
+      # {Canvas}. E.g., <tt>100%, 100%</tt> would put the circle at the
+      # bottom-right corner of the {Canvas}.
+      #
+      # @param [Object] type The type of fill to apply. Supported:
+      #   * Sass::Script::Color
+      #   * Sass::Script::String
+      #   * {Compass::Magick::Types::Solid}
+      #   * {Compass::Magick::Types::Gradients::Linear}
+      # @param [Sass::Script::Number] radius The radius of the circle.
+      # @param [Sass::Script::Number] x The composite X coordinate of the
+      #   circle.
+      # @param [Sass::Script::Number] y The composite Y coordinate of the
+      #   circle.
+      # @param [Sass::Script::Number] feather The feater value determines the
+      #   anti-aliasing the circle will get, defaults to <tt>1</tt>.
+      # @return {Command} A command(-set) which composes a circle on the
+      #   canvas.
+      def magick_circle(type, radius, compose_x, compose_y, feather = nil)
+        Compass::Magick::Utils.assert_type 'radius',   radius,   Sass::Script::Number
+        Compass::Magick::Utils.assert_type 'feather',  feather,  Sass::Script::Number
+        Command.new do |canvas|
+          circle_radius  = Compass::Magick::Utils.value_of(radius,  [canvas.width, canvas.height].min, 1)
+          circle_feather = Compass::Magick::Utils.value_of(feather, [canvas.width, canvas.height].min, 1).to_f
+          mask    = Compass::Magick::Shapes.circle(circle_radius, circle_radius, circle_feather)
+          overlay = Compass::Magick::Utils.to_canvas(type, Sass::Script::Number.new(circle_radius), Sass::Script::Number.new(circle_radius))
+          Compass::Magick::Canvas.new(canvas, magick_compose(Compass::Magick::Canvas.new(overlay, magick_mask(mask)), compose_x, compose_y))
+        end
+      end
+
+      # Draws a (rounded) border around the {Canvas} with the given width and
+      # fill {Compass::Magick::Type}.
+      #
+      # When <tt>width</tt> is not given, the border fills the entire image.
+      #
+      # @param [Object] type The type of fill to apply. Supported:
+      #   * Sass::Script::Color
+      #   * Sass::Script::String
+      #   * {Compass::Magick::Types::Solid}
+      #   * {Compass::Magick::Types::Gradients::Linear}
+      # @param [Sass::Script::Number] radius The border radius.
+      # @param [Sass::Script::Number] will The border width, defaults to
+      #   filling the entire image.
+      # @param [Sass::Script::Bool] top_left Controls the top-left border
+      #   radius effect (default <tt>true</tt>)
+      # @param [Sass::Script::Bool] top_right Controls the top-right border
+      #   radius effect (default <tt>true</tt>)
+      # @param [Sass::Script::Bool] bottom_right Controls the bottom-right
+      #   border radius effect (default <tt>true</tt>)
+      # @param [Sass::Script::Bool] bottom_left Controls the bottom-left
+      #   border radius effect (default <tt>true</tt>)
+      # @return {Command} A command(-set) which composes the border on the
+      #   canvas.
+      def magick_border(type, radius = nil, width = nil, top_left = nil, top_right = nil, bottom_right = nil, bottom_left = nil)
+        Compass::Magick::Utils.assert_type 'radius',       radius,       Sass::Script::Number
+        Compass::Magick::Utils.assert_type 'width',        width,        Sass::Script::Number
+        Compass::Magick::Utils.assert_type 'top_left',     top_left,     Sass::Script::Bool
+        Compass::Magick::Utils.assert_type 'top_right',    top_right,    Sass::Script::Bool
+        Compass::Magick::Utils.assert_type 'bottom_left',  bottom_left,  Sass::Script::Bool
+        Compass::Magick::Utils.assert_type 'bottom_right', bottom_right, Sass::Script::Bool
+        Command.new do |canvas|
+          max = [canvas.width, canvas.height].max
+          min = [canvas.width, canvas.height].min
+          border_width  = Compass::Magick::Utils.value_of(width,  max, max)
+          border_radius = Compass::Magick::Utils.value_of(radius, min, 10)
+          border_top_left     = (top_left.nil?     || top_left.value)
+          border_top_right    = (top_right.nil?    || top_right.value)
+          border_bottom_right = (bottom_right.nil? || bottom_right.value)
+          border_bottom_left  = (bottom_left.nil?  || bottom_left.value)
+          right_x  = canvas.width  - border_radius
+          bottom_y = canvas.height - border_radius
+          mask = ChunkyPNG::Canvas.new(canvas.width, canvas.height, ChunkyPNG::Color.rgba(0, 0, 0, 0))
+          for y in 0...canvas.height
+            for x in 0...canvas.width
+              unless (border_top_left     && (y < border_radius && x < border_radius)) ||
+                     (border_top_right    && (y < border_radius && x > right_x))       ||
+                     (border_bottom_right && (y > bottom_y && x > right_x))            ||
+                     (border_bottom_left  && (y > bottom_y && x < border_radius))
+                if y < border_width || y >= canvas.height - border_width ||
+                   x < border_width || x >= canvas.width - border_width
+                  mask.set_pixel(x, y, ChunkyPNG::Color::WHITE)
+                end
+              end
+            end
+          end
+          if border_radius > 0
+            radius_mask = Compass::Magick::Shapes.circle(border_radius * 2, border_width)
+            if border_top_left
+              mask.compose!(radius_mask.crop(0, 0, border_radius, border_radius), 0, 0)
+            end
+            if border_top_right
+              mask.compose!(radius_mask.crop(border_radius, 0, border_radius, border_radius), mask.width - border_radius, 0)
+            end
+            if border_bottom_right
+              mask.compose!(radius_mask.crop(border_radius, border_radius, border_radius, border_radius), mask.width - border_radius, mask.height - border_radius)
+            end
+            if border_bottom_left
+              mask.compose!(radius_mask.crop(0, border_radius, border_radius, border_radius), 0, mask.height - border_radius)
+            end
+          end
+          overlay = Compass::Magick::Utils.to_canvas(type, Sass::Script::Number.new(canvas.width), Sass::Script::Number.new(canvas.height))
+          Compass::Magick::Canvas.new(canvas, magick_compose(Compass::Magick::Canvas.new(overlay, magick_mask(mask))))
+        end
+      end
+    end
+  end
+end

data/lib/magick/functions/operations/effects.rb

@@ -0,0 +1,143 @@
+module Compass::Magick
+  module Functions::Operations
+    # Methods for performing various visual effects on a
+    # {Compass::Magick::Canvas}, e.g., fade, desaturate, etc.
+    module Effects
+      extend self
+
+      # Adjusts the intensity of a color by changing its alpha by a given
+      # value.
+      #
+      # @param [Sass::Script::Number] adjust Fade value as a float between
+      #   0.0 and 1.0.
+      # @return {Effect} A command which applies the fade to the canvas.
+      def fade(adjust = nil)
+        Compass::Magick::Utils.assert_type 'adjust', adjust, Sass::Script::Number
+        fade_adjust = 255 - (255 * Compass::Magick::Utils.value_of(adjust, 1.0, 0.5)).to_i
+        Effect.new { |pixel| ChunkyPNG::Color.fade(pixel, fade_adjust) }
+      end
+
+      # Adjusts the brightness of a color by changing its [R, G, B]
+      # components by a given value.
+      #
+      # Copyright (c) 2010, Ryan LeFevre
+      # http://www.camanjs.com
+      #
+      # @param [Sass::Script::Number] adjust Brightness value as a float
+      #   between -1.0 and 1.0.
+      # @return {Effect} A command which applies the Brightness to the
+      #   canvas.
+      def brightness(adjust = nil)
+        Compass::Magick::Utils.assert_type 'adjust', adjust, Sass::Script::Number
+        brightness_adjust = 255 * Compass::Magick::Utils.value_of(adjust, 1.0, 0.5)
+        Effect.new do |pixel|
+          ChunkyPNG::Color.rgba(
+            Effect.clamp(ChunkyPNG::Color.r(pixel) + brightness_adjust),
+            Effect.clamp(ChunkyPNG::Color.g(pixel) + brightness_adjust),
+            Effect.clamp(ChunkyPNG::Color.b(pixel) + brightness_adjust),
+            ChunkyPNG::Color.a(pixel)
+          )
+        end
+      end
+
+      # Adjusts the contrast of a color by changing its [R, G, B] components
+      # by a given value.
+      #
+      # Copyright (c) 2010, Ryan LeFevre
+      # http://www.camanjs.com
+      #
+      # @param [Sass::Script::Number] adjust Contrast value as a float,
+      #   above 0.0.
+      # @return {Effect} A command which applies the contrast to the canvas.
+      def contrast(adjust = nil)
+        Compass::Magick::Utils.assert_type 'adjust', adjust, Sass::Script::Number
+        contrast_adjust = (1.0 + Compass::Magick::Utils.value_of(adjust, 1.0, 0.5))
+        Effect.new do |pixel|
+          ChunkyPNG::Color.rgba(
+            Effect.clamp(((ChunkyPNG::Color.r(pixel) / 255.0 - 0.5) * contrast_adjust + 0.5) * 255),
+            Effect.clamp(((ChunkyPNG::Color.g(pixel) / 255.0 - 0.5) * contrast_adjust + 0.5) * 255),
+            Effect.clamp(((ChunkyPNG::Color.b(pixel) / 255.0 - 0.5) * contrast_adjust + 0.5) * 255),
+            ChunkyPNG::Color.a(pixel)
+          )
+        end
+      end
+
+      # Adjusts the saturation of a color by changing its [R, G, B]
+      # components matching the highest intensity.
+      #
+      # Copyright (c) 2010, Ryan LeFevre
+      # http://www.camanjs.com
+      #
+      # @param [Sass::Script::Number] adjust Saturation value as a float,
+      #   above 0.0.
+      # @return {Effect} A command which applies the saturation to the canvas.
+      def saturation(adjust = nil)
+        Compass::Magick::Utils.assert_type 'adjust', adjust, Sass::Script::Number
+        saturation_adjust = Compass::Magick::Utils.value_of(adjust, 1.0, 0.5) * -1
+        Effect.new do |pixel|
+          r   = ChunkyPNG::Color.r(pixel)
+          g   = ChunkyPNG::Color.g(pixel)
+          b   = ChunkyPNG::Color.b(pixel)
+          max = [r, g, b].max
+          r   = r + (max - r) * saturation_adjust unless r == max
+          g   = g + (max - g) * saturation_adjust unless g == max
+          b   = b + (max - b) * saturation_adjust unless b == max
+          ChunkyPNG::Color.rgba(Effect.clamp(r), Effect.clamp(g), Effect.clamp(b), ChunkyPNG::Color.a(pixel))
+        end
+      end
+
+      # Adjusts the vibrance of a color by changing its [R, G, B] components
+      # matching the average intensity.
+      #
+      # Copyright (c) 2010, Ryan LeFevre
+      # http://www.camanjs.com
+      #
+      # @param [Sass::Script::Number] adjust Vibrance value as a float,
+      #   above 0.0.
+      # @return {Effect} A command which applies the vibrance to the canvas.
+      def vibrance(adjust = nil)
+        Compass::Magick::Utils.assert_type 'adjust', adjust, Sass::Script::Number
+        vibrance_adjust = Compass::Magick::Utils.value_of(adjust, 1.0, 0.5) * -1
+        Effect.new do |pixel|
+          r       = ChunkyPNG::Color.r(pixel)
+          g       = ChunkyPNG::Color.g(pixel)
+          b       = ChunkyPNG::Color.b(pixel)
+          max     = [r, g, b].max
+          average = (r + g + b) / 3.0
+          amount  = (((max - average).abs * 2.0) * vibrance_adjust) / 100.0
+          r       = r + (max - r) * amount unless r == max
+          g       = g + (max - g) * amount unless g == max
+          b       = b + (max - b) * amount unless b == max
+          ChunkyPNG::Color.rgba(Effect.clamp(r), Effect.clamp(g), Effect.clamp(b), ChunkyPNG::Color.a(pixel))
+        end
+      end
+
+      # Adjusts the intensity of a color by changing its [R, G, B] components
+      # according to BT709 luminosity factors.
+      #
+      # Copyright (c) 2010, Ryan LeFevre
+      # http://www.camanjs.com
+      #
+      # @param [Sass::Script::Number] adjust Grayscale factor as a float,
+      #   above 0.0 and below 1.0.
+      # @return {Effect} A command which applies the intensity to the canvas.
+      def grayscale(adjust = nil)
+        Compass::Magick::Utils.assert_type 'adjust', adjust, Sass::Script::Number
+        grayscale_adjust = [0, [Compass::Magick::Utils.value_of(adjust, 1.0, 0.5), 1.0].min].max
+        Effect.new do |pixel|
+          r    = ChunkyPNG::Color.r(pixel)
+          g    = ChunkyPNG::Color.g(pixel)
+          b    = ChunkyPNG::Color.b(pixel)
+          gray = r * 0.2125 + g * 0.7154 + b * 0.0721
+          r    = r + (gray - r) * grayscale_adjust unless r == gray
+          g    = g + (gray - g) * grayscale_adjust unless g == gray
+          b    = b + (gray - b) * grayscale_adjust unless b == gray
+          ChunkyPNG::Color.rgba(Effect.clamp(r), Effect.clamp(g), Effect.clamp(b), ChunkyPNG::Color.a(pixel))
+        end
+      end
+
+      alias :greyscale :grayscale
+
+    end
+  end
+end