hue-lib 0.6.0 → 0.7.0

data/lib/hue/colors/color.rb

@@ -0,0 +1,35 @@
+module Hue
+  module Colors
+    class Color
+
+      ERROR_METHOD_NOT_IMPLEMENTED = 'method-not-implemented'
+
+      def self.ranged(min, val, max)
+        [[min, val].max, max].min
+      end
+
+      public
+
+      def to_hash
+        raise ERROR_METHOD_NOT_IMPLEMENTED
+      end
+
+      def to_s
+        raise ERROR_METHOD_NOT_IMPLEMENTED
+      end
+
+      def to_rgb
+        raise ERROR_METHOD_NOT_IMPLEMENTED
+      end
+
+      protected
+
+
+      def ranged(min, val, max)
+        # For convinence and polymorphism
+        self.class.ranged(min, val, max)
+      end
+
+    end
+  end
+end

data/lib/hue/colors/color_temperature.rb

@@ -0,0 +1,85 @@
+# Encoding: UTF-8
+
+module Hue
+  module Colors
+    class ColorTemperature < Color
+
+      MEGA = 1e6
+      KELVIN_MIN = 2000
+      KELVIN_MAX = 6500
+      MIRED_MIN = 153
+      MIRED_MAX = 500
+
+      public
+
+      def initialize(temperature)
+        if scale = Hue.percent_to_unit_interval(temperature)
+          self.mired = unit_to_mired_interval(scale)
+        else
+          # Assume an integer value
+          temperature = temperature.to_i
+          if temperature >= KELVIN_MIN
+            self.kelvin = temperature
+          else
+            self.mired = temperature
+          end
+        end
+      end
+
+      def mired
+        @mired.floor
+      end
+
+      def mired=(t)
+        @mired = ranged(MIRED_MIN, t.to_f, MIRED_MAX)
+      end
+
+      def kelvin
+        ranged(KELVIN_MIN, MEGA / @mired, KELVIN_MAX).round
+      end
+
+      def kelvin=(t)
+        self.mired = (MEGA / ranged(KELVIN_MIN, t.to_f, KELVIN_MAX))
+      end
+
+      def to_hash
+        {ct: mired}
+      end
+
+      def to_s
+        "Temperature=#{self.kelvin.to_i}°K (#{self.mired} mired)"
+      end
+
+      def to_rgb
+        # using method described at
+        # http://www.tannerhelland.com/4435/convert-temperature-rgb-algorithm-code/
+        temp = kelvin / 100
+
+        red = temp <= 66 ? 255 : 329.698727446 * ((temp - 60) ** -0.1332047592)
+
+        green = if temp <= 66
+                  99.4708025861 * Math.log(temp) - 161.1195681661
+                else
+                  288.1221695283 * ((temp - 60) ** -0.0755148492)
+                end
+
+        blue = if temp >= 66
+                 255
+               elsif temp <= 19
+                 0
+               else
+                 138.5177312231 * Math.log(temp - 10) - 305.0447927307
+               end
+
+        RGB.new(red, green, blue)
+      end
+
+      private
+
+      def unit_to_mired_interval(unit_interval)
+        unit_interval * (MIRED_MAX - MIRED_MIN) + MIRED_MIN
+      end
+
+    end
+  end
+end

data/lib/hue/colors/hue_saturation.rb

@@ -0,0 +1,104 @@
+module Hue
+  module Colors
+    class HueSaturation < Color
+
+      HUE_MIN = 0
+      HUE_MAX = 65536.0
+      HUE_DEGREES = 360
+      HUE_SCALE = HUE_MAX / HUE_DEGREES
+      SATURATION_MIN = 0
+      SATURATION_MAX = 255
+
+      attr_reader :hue, :saturation
+      alias :sat :saturation
+
+      public
+
+      def initialize(hue, saturation)
+        self.hue = hue
+        self.saturation = saturation
+      end
+
+      def hue=(value)
+        if scale = Hue.percent_to_unit_interval(value)
+          @hue = unit_to_hue_interval(scale)
+        else
+          @hue = ranged(HUE_MIN, value.to_i, HUE_MAX)
+        end
+      end
+
+      def hue_in_degrees
+        self.hue.to_f / HUE_SCALE
+      end
+
+      def hue_in_unit_interval
+        hue_in_degrees / HUE_DEGREES
+      end
+
+      def saturation=(value)
+        if scale = Hue.percent_to_unit_interval(value)
+          @saturation = unit_to_saturation_interval(scale)
+        else
+          @saturation = ranged(SATURATION_MIN, value.to_i, SATURATION_MAX)
+        end
+      end
+      alias :sat= :saturation=
+
+      def saturation_in_unit_interval
+        self.saturation / SATURATION_MAX.to_f
+      end
+      alias :sat_in_unit_interval :saturation_in_unit_interval
+
+      def to_s
+        "Hue=#{self.hue}, Saturation=#{self.saturation}"
+      end
+
+      def to_hash
+        {hue: hue, sat: saturation}
+      end
+
+      def to_rgb(brightness_in_unit_interval = 1.0)
+        h, s, v = hue_in_unit_interval, saturation_in_unit_interval, brightness_in_unit_interval
+        if s == 0 #monochromatic
+          red = green = blue = v
+        else
+
+          v = 1.0 # We are setting the value to 1. Don't count brightness here
+          i = (h * 6).floor
+          f = h * 6 - i
+          p = v * (1 - s)
+          q = v * (1 - f * s)
+          t = v * (1 - (1 - f) * s)
+
+          case i % 6
+          when 0
+            red, green, blue = v, t, p
+          when 1
+            red, green, blue = q, v, p
+          when 2
+            red, green, blue = p, v, t
+          when 3
+            red, green, blue = p, q, v
+          when 4
+            red, green, blue = t, p, v
+          when 5
+            red, green, blue = v, p, q
+          end
+        end
+
+        RGB.new(red * RGB::MAX, green * RGB::MAX, blue * RGB::MAX)
+      end
+
+      private
+
+      def unit_to_hue_interval(value)
+        (value * (HUE_MAX - HUE_MIN) + HUE_MIN).round
+      end
+
+      def unit_to_saturation_interval(value)
+        (value * (SATURATION_MAX - SATURATION_MIN) + SATURATION_MIN).round
+      end
+
+    end
+  end
+end

data/lib/hue/colors/rgb.rb

@@ -0,0 +1,102 @@
+# Encoding: UTF-8
+
+module Hue
+  module Colors
+    class RGB < Color
+
+      MIN = 0
+      MAX = 255
+
+      def self.ranged(value)
+        super(MIN, value, MAX)
+      end
+
+      public
+
+      attr_reader :red, :green, :blue
+
+      def initialize(*rgb)
+        red, green, blue = rgb
+        self.red = red
+        self.green = green
+        self.blue = blue
+      end
+
+      def red=(value)
+        @red = parse(value)
+      end
+
+      def green=(value)
+        @green = parse(value)
+      end
+
+      def blue=(value)
+        @blue = parse(value)
+      end
+
+      def to_hash
+        max = MAX.to_f
+        red, green, blue = self.red / max, self.green / max, self.red / max
+
+        max = [red, green, blue].max
+        min = [red, green, blue].min
+        h, s, l = 0, 0, ((max + min) / 2 * 255)
+
+        d = max - min
+        s = max == 0 ? 0 : (d / max * 255)
+
+        h = case max
+            when min
+              0 # monochromatic
+            when red
+              (green - blue) / d + (green < blue ? 6 : 0)
+            when green
+              (blue - red) / d + 2
+            when blue
+              (red - green) / d + 4
+            end * 60  # / 6 * 360
+
+        h = (h * HueSaturation::HUE_SCALE).to_i
+        {hue: h, sat: s.to_i, bri: Bulb::BRIGHTNESS_MAX}
+      end
+
+      def to_s
+        "RGB≈#{rgb}"
+      end
+
+      def to_rgb
+        self
+      end
+
+      def ==(rhs)
+        rhs.is_a?(RGB) &&
+          [:red, :green, :blue].all? { |m| self.send(m) == rhs.send(m) }
+      end
+
+      protected
+
+      def ranged(value)
+        self.class.ranged(value.to_i).round
+      end
+
+      private
+
+      def rgb
+        [red, green, blue]
+      end
+
+      def unit_to_rgb_scale(value)
+        (value * (MAX - MIN) + MIN).round
+      end
+
+      def parse(value)
+        if scale = Hue.percent_to_unit_interval(value)
+          unit_to_rgb_scale(scale)
+        else
+          ranged(value)
+        end
+      end
+
+    end
+  end
+end

data/lib/hue/colors/xy.rb

@@ -0,0 +1,63 @@
+require 'matrix'
+module Hue
+  module Colors
+    class XY < Color
+
+      MIN = 0.0
+      MAX = 1.0
+      RGB_MATRIX = Matrix[
+        [ 3.233358361244897,  -1.5262682428425947,  0.27916711262124544],
+        [-0.8268442148395835,  2.466767560486707,   0.3323241608108406 ],
+        [ 0.12942207487871885, 0.19839858329512317, 2.0280912276039635 ],
+      ]
+
+      public
+
+      attr_reader :x, :y
+
+      def initialize(*xy)
+        self.x = xy.first
+        self.y = xy.last
+      end
+
+      def x=(value)
+        @x = ranged(value)
+      end
+
+      def y=(value)
+        @y = ranged(value)
+      end
+
+      def to_hash
+        {xy: xy}
+      end
+
+      def to_s
+        "XY=#{xy}"
+      end
+
+      def to_rgb
+        z = 1 - x - y
+        xyz = [x, y, z]
+        values = (RGB_MATRIX * Matrix[xyz].transpose).to_a.flatten.map do |x|
+          RGB.ranged(x * RGB::MAX).to_i
+        end
+
+        RGB.new(*values)
+      end
+
+      protected
+
+      def ranged(val)
+        super(MIN, val.to_f, MAX)
+      end
+
+      private
+
+      def xy
+        [x,y]
+      end
+
+    end
+  end
+end

data/lib/hue/colors.rb

@@ -0,0 +1,42 @@
+require_relative 'colors/color'
+require_relative 'colors/hue_saturation'
+require_relative 'colors/color_temperature'
+require_relative 'colors/xy'
+require_relative 'colors/rgb'
+
+module Hue
+  module Colors
+
+    def self.parse(*args)
+      case args.size
+      when 1
+        Colors::ColorTemperature.new(args.first)
+      when 2
+        a,b = args.first.to_f, args.last.to_f
+        if a > 1.0
+          Colors::HueSaturation.new(args.first, args.last)
+        else
+          Colors::XY.new(*args)
+        end
+      when 3
+        Colors::RGB.new(*args)
+      else
+        raise Error.new("Unable to parse to color: #{args.inspect}")
+      end
+    end
+
+    def self.parse_state(state)
+      case state['colormode']
+      when 'ct'
+        Colors::ColorTemperature.new(state['ct'])
+      when 'xy'
+        Colors::XY.new(*state['xy'])
+      when 'hs'
+        Colors::HueSaturation.new(state['hue'], state['sat'])
+      else
+        raise Error.new("Unknown or missing state: #{state.inspect}")
+      end
+    end
+
+  end
+end

data/lib/hue.rb

@@ -1,15 +1,8 @@
 require 'net/http'
-require 'json'
-require 'matrix'
 require 'digest/md5'
+require 'json'
 require 'uuid'
 
-RGB_MATRIX = Matrix[
-  [3.233358361244897, -1.5262682428425947, 0.27916711262124544],
-  [-0.8268442148395835, 2.466767560486707, 0.3323241608108406],
-  [0.12942207487871885, 0.19839858329512317, 2.0280912276039635]
-]
-
 module Hue
 
   DEVICE_TYPE = 'hue-lib'
@@ -131,10 +124,38 @@ ST: ssdp:all
     end
   end
 
+  def self.logger
+    if !defined?(@@logger)
+      log_dir_path = File.join('/var', 'log', 'hue')
+      begin
+        FileUtils.mkdir_p(log_dir_path)
+      rescue Errno::EACCES
+        log_dir_path = File.join(ENV['HOME'], ".#{device_type}")
+        FileUtils.mkdir_p(log_dir_path)
+      end
+
+      log_file_path = File.join(log_dir_path, 'hue-lib.log')
+      log_file = File.new(log_file_path, File::WRONLY | File::APPEND | File::CREAT)
+      @@logger = Logger.new(log_file)
+      @@logger.level = Logger::INFO
+    end
+
+    @@logger
+  end
+
+  def self.percent_to_unit_interval(value)
+    if percent = /(\d+)%/.match(value.to_s)
+      percent.captures.first.to_i / 100.0
+    else
+      nil
+    end
+  end
+
 end
 
 require 'hue/config/abstract'
 require 'hue/config/application'
 require 'hue/config/bridge'
 require 'hue/bridge'
+require 'hue/colors'
 require 'hue/bulb'

data/spec/hue/bulb_spec.rb

@@ -33,21 +33,20 @@ describe Hue::Bulb do
       bulb.off?.should be_true
     end
 
-    it "should report the hue, brightness and saturation" do
-      bulb.hue.should == 13234
+    it "should report the brightness and color mode" do
       bulb.brightness.should == 146
       bulb.bri.should == 146
-      bulb.saturation.should == 208
-      bulb.sat.should == bulb.saturation
-    end
-
-    it "should report the color temperature and color mode" do
-      bulb.color_temperature.should == 459
-      bulb.ct.should == bulb.color_temperature
       bulb.color_mode.should == 'ct'
       bulb.color_mode.should == bulb.colormode
     end
 
+    it "should report the color" do
+      color = bulb.color
+      color.should be_a(Hue::Colors::ColorTemperature)
+      color.mired.should == 459
+      color.kelvin.should == 2179
+    end
+
     it "should report the alert state" do
       bulb.blinking?.should be_false
       bulb.solid?.should be_true
@@ -64,17 +63,28 @@ describe Hue::Bulb do
       end
 
       it 'should allow setting hue, saturation and brightness' do
-        with_fake_update('lights/1/state', hue: 21845)
-        bulb.hue = 120
-        bulb.hue.should == 21845
+        color = Hue::Colors::HueSaturation.new(21845, 1293)
 
-        with_fake_update('lights/1/state', sat: 1293)
-        bulb.saturation = 1293
-        bulb.saturation.should == 1293
+        with_fake_update('lights/1/state', hue: 21845, sat: 255)
+        set_color = (bulb.color = color)
+        set_color.hue.should == 21845
+        set_color.saturation.should == 255
+      end
 
+      it 'should allow setting brightness as a number, percentage or string' do
         with_fake_update('lights/1/state', bri: 233)
         bulb.brightness = 233
         bulb.brightness.should == 233
+
+        with_fake_update('lights/1/state', bri: 128)
+        bulb.brightness = "50%"
+        bulb.brightness.should == 128
+        bulb.brightness_in_unit_interval.should == 0.5019607843137255
+        bulb.brightness_percent.should == 50
+
+        with_fake_update('lights/1/state', bri: 128)
+        bulb.brightness = "128"
+        bulb.brightness.should == 128
       end
 
       it 'should allow setting blink, solid and flash alerts' do

data/spec/hue/colors/color_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper.rb'
+
+describe Hue::Colors::Color do
+
+  context 'implements a ranged method: max > value > min' do
+    it 'should return the min when value < min' do
+      described_class.ranged(0, -1, 2).should == 0
+    end
+
+    it 'should return the max when value > max' do
+      described_class.ranged(0, 3, 2).should == 2
+    end
+
+    it 'should return the value when max > value > min' do
+      described_class.ranged(0, 1, 2).should == 1
+    end
+  end
+
+  def abstract_method(method)
+    abstract_color = described_class.new
+    abstract_color.should respond_to(method)
+    lambda do
+      abstract_color.send(method)
+    end.should raise_error(described_class::ERROR_METHOD_NOT_IMPLEMENTED)
+  end
+
+  context 'defines but does not implement methods:' do
+    it('#to_hash') { abstract_method(:to_hash) }
+    it('#to_s') { abstract_method(:to_s) }
+    it('#to_rgb') { abstract_method(:to_rgb) }
+  end
+
+end

data/spec/hue/colors/color_temperature_spec.rb

@@ -0,0 +1,106 @@
+# Encoding: UTF-8
+require 'spec_helper.rb'
+
+describe Hue::Colors::ColorTemperature do
+
+  context 'when initialized with a valid value' do
+    color = described_class.new(500)
+
+    it 'should report the temperature in mireds and kelvins' do
+      color.mired.should == 500
+      color.kelvin.should == 2000
+    end
+
+    it 'should have a string representation' do
+      color.to_s.should == "Temperature=2000°K (500 mired)"
+    end
+
+    it 'should have a hash representation' do
+      color.to_hash.should == {ct: 500}
+    end
+
+    it 'should have an RGB representation' do
+      color.to_rgb.should == Hue::Colors::RGB.new(255,136,13)
+    end
+
+    context 'when allowing change to the temperature value' do
+      it 'should go to the max in kelvins' do
+        color.kelvin = 7000
+        color.kelvin.should == described_class::KELVIN_MAX
+        color.mired.should == described_class::MIRED_MIN
+      end
+
+      it 'should go to the max in mireds' do
+        color.mired = 600
+        color.mired.should == described_class::MIRED_MAX
+        color.kelvin.should == described_class::KELVIN_MIN
+      end
+
+      it 'should go to the min in mireds' do
+        color.mired = 100
+        color.mired.should == described_class::MIRED_MIN
+        color.kelvin.should == described_class::KELVIN_MAX
+      end
+
+      it 'should go to the min in kelvins' do
+        color.mired = 2000
+        color.mired.should == described_class::MIRED_MAX
+        color.kelvin.should == described_class::KELVIN_MIN
+      end
+
+      it 'should hit the middle' do
+        mired_middle = described_class::MIRED_MAX/2
+        color.mired = mired_middle
+        color.mired.should == mired_middle
+        color.kelvin.should == 4000
+
+        kelvin_middle = described_class::KELVIN_MAX/2
+        color.kelvin = kelvin_middle
+        color.kelvin.should == kelvin_middle
+        color.mired.should == 307
+      end
+
+    end
+  end
+
+  context 'when initializing' do
+    it 'should set the temperature depending on the value' do
+      color = described_class.new(100)
+      color.mired.should == described_class::MIRED_MIN
+
+      color = described_class.new(600)
+      color.mired.should == described_class::MIRED_MAX
+
+      color = described_class.new(described_class::KELVIN_MIN)
+      color.kelvin.should == described_class::KELVIN_MIN
+
+      color = described_class.new(described_class::KELVIN_MAX + 3000)
+      color.kelvin.should == described_class::KELVIN_MAX
+    end
+
+    it 'should report kelvins as an integer' do
+      color = described_class.new(459)
+      color.kelvin.should == 2179
+    end
+
+    it 'should accept a string value for the temperature' do
+      color = described_class.new("100")
+      color.mired.should == described_class::MIRED_MIN
+
+      color = described_class.new((described_class::KELVIN_MAX + 3000).to_s)
+      color.kelvin.should == described_class::KELVIN_MAX
+    end
+
+    it 'should allow a percentage value for the mired scale' do
+      color = described_class.new("0%")
+      color.mired.should == described_class::MIRED_MIN
+
+      color = described_class.new("50%")
+      color.mired.should == 326
+
+      color = described_class.new("100%")
+      color.mired.should == described_class::MIRED_MAX
+    end
+  end
+
+end