gradient 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f318a955895204681e1ee985f8decfb009557eb4
-  data.tar.gz: 9af5a313c38bf4824dc53c4f1f2346c25cef0f60
+  metadata.gz: f55c2143e51c8034863193036c2609ac11007591
+  data.tar.gz: e042d481cbd1e8b034b611715709555badd24bb6
 SHA512:
-  metadata.gz: 6ca6cd175607983e38b4ca60d30a7a1d16edb94b245408498bddeac41165c4e0dba507ad33919aaad0bed8fdd03038b9f63e6d2b90868ee050f1a9f13c6e3644
-  data.tar.gz: eb7551719748b8361fb6db2bf8a3195ffa0e322d9b9d435873f9dd82d052aee6a91618eae87493e80dbd847d88eb182fd0cc5db00e8285a925332cb7732c651a
+  metadata.gz: 42aa087d8edd0c5faf199beb34ca5eec83a250b0b0fb1cbeea0f65b9bfe73a2bb045e3a8f5907861ba16001c0aa5de6c356e6323530f39517ec0e1a2542b1fda
+  data.tar.gz: 07f2d6c7e4f6cec682abc15c8f78306b5530a43015b67488b384c6fd83c391a2f510058eb378d034db3b470d50f3f205d3c3c4c78f41e79add0362ef265a12ac

data/README.md

@@ -2,6 +2,52 @@
 Library for dealing with color gradients in ruby
 
 ## Usage
+Gradient works by placing points along two one dimensional planes.
+One for color and one for opacity.
+Start by creating a few points and use them to create a gradient map.
+
+```ruby
+color_points = [
+  Gradient::ColorPoint.new(0, Color::RGB.new(30, 87, 153)),
+  Gradient::ColorPoint.new(0.49, Color::RGB.new(41, 137, 216)),
+  Gradient::ColorPoint.new(0.51, Color::RGB.new(32, 124, 202)),
+  Gradient::ColorPoint.new(1, Color::RGB.new(125, 185, 232)),
+]
+
+opacity_points = [
+  Gradient::OpacityPoint.new(0, 1),
+  Gradient::OpacityPoint.new(0.5, 0),
+  Gradient::OpacityPoint.new(1, 1)
+]
+
+gradient = Gradient::Map.new(color_points, opacity_points)
+# => #<Gradient Map #<Point 0 #1e5799ff> #<Point 49.0 #2989d805> #<Point 50.0 #2583d100> #<Point 51.0 #207cca05> #<Point 100 #7db9e8ff>>
+```
+
+### Convert to CSS
+If you use ruby to serve web content you can use Gradient to convert gradient maps in to [CSS3 Gradients](http://www.w3schools.com/css/css3_gradients.asp)
+
+```ruby
+gradient.to_css
+# => "background:linear-gradient(to right, rgba(30,87,153,1.0) 0%, rgba(41,137,216,0.02) 49%, rgba(37,131,209,0.0) 50%, rgba(32,124,202,0.02) 51%, rgba(125,185,232,1.0) 100%);"
+
+gradient.to_css(property: "border-image")
+# => "border-image:linear-gradient(to right, rgba(30,87,153,1.0) 0%, rgba(41,137,216,0.02) 49%, rgba(37,131,209,0.0) 50%, rgba(32,124,202,0.02) 51%, rgba(125,185,232,1.0) 100%);"
+```
+
+If you want some more control of the css generation you can invoke the CSS Printer manually.
+
+```ruby
+printer = Gradient::CSSPrinter.new(gradient)
+printer.linear
+# => "linear-gradient(to right, rgba(30,87,153,1.0) 0%, rgba(41,137,216,0.02) 49%, rgba(37,131,209,0.0) 50%, rgba(32,124,202,0.02) 51%, rgba(125,185,232,1.0) 100%)"
+
+printer.linear(direction: "to bottom")
+# => "linear-gradient(to bottom, rgba(30,87,153,1.0) 0%, rgba(41,137,216,0.02) 49%, rgba(37,131,209,0.0) 50%, rgba(32,124,202,0.02) 51%, rgba(125,185,232,1.0) 100%)"
+
+printer.radial(shape: :circle)
+# => "radial-gradient(circle, rgba(30,87,153,1.0) 0%, rgba(41,137,216,0.02) 49%, rgba(37,131,209,0.0) 50%, rgba(32,124,202,0.02) 51%, rgba(125,185,232,1.0) 100%)"
+```
 
 ### Import Adobe Photoshop Gradient (`.grd`) files
 For many artists a preferred way of creating gradients is through Photoshop.
@@ -9,14 +55,8 @@ You are able to parse `.grd` files and turn them in to a hash of `Gradient::Map`
 
 ```ruby
 Gradient::GRD.parse("./kiwi.grd")
-# => {"Kiwi" => <Gradient::Map:0x00000000000000
-#   @points=[
-#     #<Gradient::Point:0x007fae248a9358 @color=RGB [#3d1103], @location=0.0>,
-#     #<Gradient::Point:0x007fae248a9308 @color=RGB [#29860d], @location=0.386>,
-#     #<Gradient::Point:0x007fae248a92b8 @color=RGB [#a0cb1b], @location=0.84>,
-#     #<Gradient::Point:0x007fae248a9268 @color=RGB [#f3f56e], @location=0.927>,
-#     #<Gradient::Point:0x007fae248a9218 @color=RGB [#ffffff], @location=1.0>
-#   ]>
+# => {
+#   "Kiwi"=> #<Gradient Map #<Point 0.0 #3d1103ff> #<Point 38.6 #29860dff> #<Point 84.0 #a0cb1bff> #<Point 92.7 #f3f56eff> #<Point 100.0 #ffffffff>>
 # }
 ```
 
@@ -49,3 +89,7 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/zeeraw
 ## License
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
 
+## Acknowledgments
+Valek Filippov and the RE-lab team decoded the `.grd` file format and provided
+an [initial parser implementation](https://gitorious.org/re-lab/graphics/source/781a65604d405f29c2da487820f64de8ddb0724d:photoshop/grd).
+[Andy Boughton](https://github.com/abought) later created an [implementation in python](https://github.com/abought/grd_to_cmap) which is the base for this library's implementation.

data/lib/gradient.rb

@@ -1,7 +1,10 @@
 require "gradient/version"
+require "gradient/color_point"
+require "gradient/opacity_point"
 require "gradient/point"
 require "gradient/map"
 require "gradient/grd"
+require "gradient/css_printer"
 
 module Gradient
   require "color"

data/lib/gradient/color_point.rb

@@ -0,0 +1,8 @@
+module Gradient
+  class ColorPoint
+    attr_reader :color, :location
+    def initialize(location, color)
+      @color, @location = color, location
+    end
+  end
+end

data/lib/gradient/css_printer.rb

@@ -0,0 +1,50 @@
+module Gradient
+  class CSSPrinter
+
+    ORIENTATIONS = %i(horizontal vertical diagonal_top diagonal_bottom radial)
+
+    def initialize(map)
+      @map = map
+    end
+
+    def css(type: :linear, property: "background", **args)
+      "#{property}:#{send(type,**args)};"
+    end
+
+    def linear(vendor: nil, direction: "to right", angle: nil, repeating: false)
+      angle_or_direction = [angle || direction]
+      arguments = (angle_or_direction + rgba_values)
+      format_css_function(vendor, repeating, "linear-gradient") + "(#{arguments.join(", ")})"
+    end
+
+    def radial(vendor: nil, shape: nil, size: nil, position: nil, repeating: false)
+      shape_and_size_at_position = []
+      shape_and_size_at_position << shape if shape
+      shape_and_size_at_position << size if size
+      shape_and_size_at_position << position if position
+      arguments = rgba_values
+      arguments.unshift(shape_and_size_at_position.join(" ")) if shape_and_size_at_position.any?
+      format_css_function(vendor, repeating, "radial-gradient") + "(#{arguments.join(", ")})"
+    end
+
+    def rgba_values
+      @map.points.map { |point| point_to_rgba(point) }
+    end
+
+    private def point_to_rgba(point)
+      red, green, blue = [:red,:green, :blue].map{|c|point.color.send(c).round}
+      opacity = point.opacity.round(2)
+      location = (point.location * 100).round
+      "rgba(#{red},#{green},#{blue},#{opacity}) #{location}%"
+    end
+
+    private def format_css_function(vendor, repeating, type)
+      css_function = []
+      css_function << "-#{vendor}" if !!vendor
+      css_function << "repeating" if !!repeating
+      css_function << type
+      css_function.join("-")
+    end
+
+  end
+end

data/lib/gradient/grd.rb

@@ -1,7 +1,6 @@
 module Gradient
   class GRD
 
-    SHIFT_BUFFER = "                                    "
     COLOR_TERMS = %w(Cyn Mgnt Ylw Blck Rd Grn Bl H Strt Brgh)
     PARSE_METHODS = {
       "patt" => :parse_patt,
@@ -21,55 +20,93 @@ module Gradient
 
     class << self
 
-      def parse(file)
-        new(file).maps
+      def parse(string_buffer)
+        new.tap do |parser|
+          parser.parse(string_buffer)
+        end.maps
+      end
+
+      def read(file)
+        new.tap do |parser|
+          File.open(file, "r") do |file|
+            while (string_buffer = file.gets)
+              parser.parse(string_buffer)
+            end
+          end
+        end.maps
       end
 
     end
 
-    def initialize(file)
+    def initialize
       @maps = {}
-      @gradients = []
+
       @gradient_names = []
+      @color_gradients = []
+      @transparency_gradients = []
+
       @current_object_name = ""
-      @current_gradient = []
+      @current_color_gradient = []
+      @current_transparency_gradient = []
       @current_color = {}
-      @shift = 0
+      @current_transparency = {}
 
-      File.open(file, "r") do |file|
-        parse while (@buffer = file.gets)
-      end
+      @shift = 0
     end
 
-    private def parse
+    def parse(buffer)
+      @buffer = buffer
       @offset = 28
       parse_entry while @offset < @buffer.length
       flush_current_gradient
 
-      gradients = @gradients.map do |gradient|
-        points = clean_gradient(gradient).map do |point_data|
-          Gradient::Point.new(*point_data)
+      color_gradients = @color_gradients.map do |gradient|
+        clean_color_gradient(gradient).map do |color_step|
+          Gradient::ColorPoint.new(*color_step)
+        end
+      end
+
+      transparency_gradients = @transparency_gradients.map do |gradient|
+        clean_transparency_gradient(gradient).map do |transparency_step|
+          Gradient::OpacityPoint.new(*transparency_step)
         end
+      end
 
-        Gradient::Map.new(*points)
+      gradients = color_gradients.zip(transparency_gradients).map do |color_points|
+        Gradient::Map.new(*color_points)
       end
 
       @maps = Hash[ @gradient_names.zip(gradients) ]
     end
 
-    private def clean_gradient(color_steps)
-      locations = color_steps.map { |g| g["Lctn"] }
+    private def clean_gradient(steps)
+      locations = steps.map { |g| g["Lctn"] }
       min_location = locations.min
       max_location = locations.max
+
       locations = locations.map do |location|
         ((location - min_location) * (1.0 / (max_location - min_location))).round(3)
       end
+    end
+
+    private def clean_color_gradient(steps)
+      locations = clean_gradient(steps)
+      colors = steps.map do |step|
+        convert_to_color(step)
+      end
+      locations.zip(colors)
+    end
 
-      colors = color_steps.map do |color_step|
-        convert_to_color(color_step)
+    private def clean_transparency_gradient(steps)
+      locations = clean_gradient(steps)
+      transparencies = steps.map do |step|
+        convert_to_opacity(step)
       end
+      locations.zip(transparencies)
+    end
 
-      color_locations = locations.zip(colors)
+    private def convert_to_opacity(opacity_data)
+      opacity_data["Opct"]
     end
 
     private def convert_to_color(color_data)
@@ -139,15 +176,23 @@ module Gradient
 
     private def flush_current_gradient
       flush_current_color
-      @gradients << @current_gradient if @current_gradient.any?
-      @current_gradient = []
+      flush_current_transparency
+      @color_gradients << @current_color_gradient if @current_color_gradient.any?
+      @transparency_gradients << @current_transparency_gradient if @current_transparency_gradient.any?
+      @current_color_gradient = []
+      @current_transparency_gradient = []
     end
 
     private def flush_current_color
-      @current_gradient << @current_color if @current_color.any?
+      @current_color_gradient << @current_color if @current_color.any?
       @current_color = {}
     end
 
+    private def flush_current_transparency
+      @current_transparency_gradient << @current_transparency if @current_transparency.any?
+      @current_transparency = {}
+    end
+
     private def parse_patt(name)
       # TODO: Figure out exactly what this is and implement it.
       log(name, "patt")
@@ -237,6 +282,11 @@ module Gradient
         @current_color[name.strip] = value
       end
 
+      if @current_object_name == "Trns" && name == "Opct" && type == "#Prc"
+        flush_current_transparency
+        @current_transparency[name.strip] = value / 100
+      end
+
       continue!(12)
     end
 
@@ -254,6 +304,10 @@ module Gradient
         @current_color[name.strip] = size
       end
 
+      if @current_object_name == "Trns" && name == "Lctn"
+        @current_transparency[name.strip] = size
+      end
+
       continue!
     end
 

data/lib/gradient/map.rb

@@ -1,8 +1,83 @@
 module Gradient
   class Map
-    attr_reader :points
-    def initialize(*points)
-      @points = Array(points).sort { |a, b| a.location <=> b.location }
+
+    attr_reader :color_points, :opacity_points, :points
+
+    def initialize(color_points=[], opacity_points=[])
+      @color_points = sort_points(Array(color_points))
+      @opacity_points = sort_points(Array(opacity_points))
+      @all_points = sort_points(@color_points + @opacity_points)
+      @locations = @all_points.map { |point| point.location }.uniq
+      @points ||= expand_points
     end
+
+    def inspect
+      "#<Gradient Map #{points.map(&:inspect).join(" ")}>"
+    end
+
+    def to_css(**args)
+      @css_printer ||= Gradient::CSSPrinter.new(self)
+      @css_printer.css(**args)
+    end
+
+    private def expand_points
+      new_points = @locations.map do |location|
+        selected_points = @all_points.select { |point| point.location == location }
+        colored_points, opacity_points = selected_points.group_by(&:class).values_at(ColorPoint, OpacityPoint)
+        if colored_points && opacity_points
+          Gradient::Point.new(location, colored_points.first.color, opacity_points.first.opacity)
+        elsif colored_points
+          point = colored_points.first
+          a, b = previous_and_next_in(@opacity_points, point)
+          fraction = location_fraction(a, b, point)
+          opacity = opacity_difference(fraction, a, b)
+          Gradient::Point.new(location, point.color, opacity)
+        elsif opacity_points
+          point = opacity_points.first
+          a, b = previous_and_next_in(@color_points, point)
+          fraction = location_fraction(a, b, point)
+          color = color_difference(fraction, a, b)
+          Gradient::Point.new(location, color, point.opacity)
+        end
+      end
+    end
+
+    private def previous_and_next_in(bucket, point)
+      groups = bucket.group_by { |p| point_group(p, point) }
+      a = groups.fetch(:same) { groups.fetch(:less) }.max { |p| p.location }
+      b = groups.fetch(:same) { groups.fetch(:more) }.min { |p| p.location }
+      return a, b
+    end
+
+    private def point_group(a, b)
+      if a.location < b.location
+        :less
+      elsif a.location > b.location
+        :more
+      else
+        :same
+      end
+    end
+
+    private def color_difference(fraction, a, b)
+      red = a.color.red + fraction * (b.color.red - a.color.red)
+      green = a.color.green + fraction * (b.color.green - a.color.green)
+      blue = a.color.blue + fraction * (b.color.blue - a.color.blue)
+      Color::RGB.new(red, green, blue)
+    end
+
+    private def opacity_difference(fraction, a, b)
+      a.opacity + fraction * (b.opacity - a.opacity)
+    end
+
+    private def location_fraction(a, b, x)
+      return 0 if a.location == b.location
+      (x.location - a.location) / (b.location - a.location)
+    end
+
+    private def sort_points(points)
+      points.sort { |a, b| a.location <=> b.location }
+    end
+
   end
 end

data/lib/gradient/opacity_point.rb

@@ -0,0 +1,8 @@
+module Gradient
+  class OpacityPoint
+    attr_reader :opacity, :location
+    def initialize(location, opacity)
+      @location, @opacity = location, opacity
+    end
+  end
+end

data/lib/gradient/point.rb

@@ -1,8 +1,15 @@
 module Gradient
   class Point
-    attr_reader :color, :location
-    def initialize(location, color)
-      @color, @location = color, location
+
+    attr_reader :location, :color, :opacity
+
+    def initialize(location, color, opacity)
+      @location, @color, @opacity = location, color, opacity
     end
+
+    def inspect
+      "#<Point #{location * 100} ##{color.hex}#{"%02x" % (opacity * 255).round}>"
+    end
+
   end
 end

data/lib/gradient/version.rb

@@ -1,3 +1,3 @@
 module Gradient
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gradient
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Philip Vieira
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-11-18 00:00:00.000000000 Z
+date: 2015-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: color
@@ -98,8 +98,11 @@ files:
 - bin/setup
 - gradient.gemspec
 - lib/gradient.rb
+- lib/gradient/color_point.rb
+- lib/gradient/css_printer.rb
 - lib/gradient/grd.rb
 - lib/gradient/map.rb
+- lib/gradient/opacity_point.rb
 - lib/gradient/point.rb
 - lib/gradient/version.rb
 homepage: https://github.com/zeeraw/gradient