rgbcell 0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bb2bf06b2bb1f5162249b2a5e02d1ec58ad4b35a7c4f172c30a3302f6ec36f99
+  data.tar.gz: e3df58f700117a89c5e2183ec36f90859986f0567888923948439a49d1f65096
+SHA512:
+  metadata.gz: 5182f8c620e5bd05652efbc95c4cc75167a323b316e154c50fe4162a81758873e1157b92640a51cc8fd2cd978bf83744fd81c4f759b8337b2be28b869aacf82b
+  data.tar.gz: d9aac83ce02fa07b1c92104cd8ee21e7fcd4c10c8bbd7da24a9fde624aa4e1b9016d0a2970d485148d72af9e2dbff20c8c8317631ed9cdbb12dcde24223c2721

data/README.md

@@ -0,0 +1,119 @@
+# RGBCell
+
+RGBCell represents a color as the coordinates in the x-y-z coordinate system.
+Each of the three component color elements, red, green, and blue, have a float
+value from 0 to 256.
+
+Creating an object without any params creates black:
+
+    1.  require 'rgbcell'
+    2.  color = RGBCell.new
+    3.  color.to_s    #=> #000000
+    4.  color.red     #=> 0.0
+    5.  color.green   #=> 0.0
+    6.  color.blue    #=> 0.0
+
+Line 1 loads the RGBCell module.
+Line 2 create an RGBCell object. Because there are no parameters
+given, the object represents black. Line 3 show the
+stringification of the color such as might be used in CSS. Lines
+4-6 show the numeric values of the three component
+colors, which are stored as floats.
+
+There are several ways to indicate the color in RGBCell::new. One way is to give
+its three components as numeric values.
+
+    color = RGBCell.new(127, 255, 0)
+    color.to_s    #=> #7fff00
+
+You can indicate the color using hex format:
+
+    color = RGBCell.new('#7fff00')
+    color.to_s    #=> #7fff00
+    color.red     #=> 127.0
+    color.green   #=> 255.0
+    color.blue    #=> 0.0
+
+You can give one of the HTML named colors:
+
+    color = RGBCell.new('purple')
+    color.to_s    #=> #800080
+    color.red     #=> 128.0
+    color.green   #=> 0.0
+    color.blue    #=> 128.0
+
+Finally, you can use 'random' to get a random color:
+
+    color = RGBCell.new('random')
+    color.to_s    #=> #dbd25b
+    color.red     #=> 219.0
+    color.green   #=> 210.0
+    color.blue    #=> 91.0
+
+You can also set each component color individually. Notice in this example that
+a component integer value is converted to float.
+
+    color = RGBCell.new()
+    color.red = 60       #=> 60.0
+    color.green = 230    #=> 210.0
+    color.blue = 91.005  #=> 91.0005
+    color.to_s           #=> #3ce65b
+
+## Distance
+
+Because every color is a set of coordinates, the difference between two colors
+can be expressed as a distance. The distance is always zero or a positive
+number. For example, the following example gives the distance between red and
+chartreuse.
+
+    red = RGBCell.new('red')
+    chartreuse = RGBCell.new('chartreuse')
+    red.distance(chartreuse)  #=> 285.3226244096321
+
+The same thing can be expressed with the minus operator.
+
+    puts red - chartreuse  #=> 285.3226244096321
+
+The second color does not have to be an RGBCell object; it only needs to be an
+expression that can be used to create an RGBCell object.
+
+    puts red - 'green'  #=> 360.62445840513925
+
+## Average
+
+Two or more colors can be averaged by calculating the midpoint of their
+coordinates using the `average` method. The result of the average is itself an
+RGBCell object.
+
+    red = RGBCell.new('red')
+    tomato = RGBCell.new('tomato')
+    avg = red.average(tomato)
+    puts avg.class  #=> RGBCell
+    puts avg.to_s   #=> #ff3100
+
+You can pass in more than one color for averaging. You can use RGBCell objects
+or any object that can be used to create an RGBCell object.
+
+    tomato = RGBCell.new('tomato')
+    puts tomato.average('orange', 'olive') #=> #d48200
+
+If you prefer not to create any colors at all, you can use the class method.
+
+    puts RGBCell.average('tomato', 'orange', 'olive') #=> #d48200
+
+## Install
+
+```
+gem install rgbcube
+```
+
+## Author
+
+Mike O'Sullivan
+mike@idocs.com
+
+## History
+
+| version | date          | notes                                                 |
+|---------|---------------|-------------------------------------------------------|
+| 0.5     | June 25, 2020 | Initial upload.                                       |

data/lib/rgbcell.rb

@@ -0,0 +1,574 @@
+#===============================================================================
+# RGBCell
+#
+
+# An RGBCell object represents a single color in the red-green-blue color
+# scheme, such as is used in HTML or CSS.
+
+class RGBCell
+	# version
+	VERSION = '0.5'
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	
+	# Initializes a new RGBCell object. The params can be in one of several
+	# forms.
+	#
+	# - three numbers
+	#    RGBCell.new(127, 255, 0)
+	#
+	# - a named color
+	#    RGBCell.new('orange')
+	#
+	# - a hexidecimal expression
+	#    RGBCell.new('#7fff00')
+	#
+	# - a random color
+	#    RGBCell.new('random')
+	#
+	# - no param returns black
+	#    RGBCell.new
+	
+	def initialize(*opts)
+		# $tm.hrm
+		
+		# no opts: set to black
+		if opts.length == 0
+			@red = 0.0
+			@green = 0.0
+			@blue = 0.0
+			
+		# 1 opt
+		elsif opts.length == 1
+			# array
+			if opts[0].is_a?(Array)
+				@red = opts[0][0].to_f
+				@green = opts[0][1].to_f
+				@blue = opts[0][2].to_f
+			
+			# random
+			elsif opts[0] == 'random'
+				randomize()
+				
+			# named
+			elsif coords = NAMES[opts[0]]
+				@red = coords[0].to_f
+				@green = coords[1].to_f
+				@blue = coords[2].to_f
+				
+			# hex
+			elsif opts[0].match(/\A\#?[a-f0-9]{6,}\z/mu)
+				rgbs = opts[0]
+				rgbs = rgbs.sub(/\A\#/mu, '')
+				@red = rgbs[0..1].hex
+				@green = rgbs[2..3].hex
+				@blue = rgbs[4..5].hex
+			
+			# else unknown opt
+			else
+				raise 'unknown-opt: ' + opts[0].to_s
+			end
+			
+		# 3 opts
+		elsif opts.length == 3
+			@red = opts[0].to_f
+			@green = opts[1].to_f
+			@blue = opts[2].to_f
+			
+		# any other number of options is invalid
+		else
+			raise 'invalid-initialize-options-length: ' + opts.length.to_s
+		end
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# readers
+	#
+	
+	# The value of the red component.
+	attr_reader :red
+	
+	# The value of the green component.
+	attr_reader :green
+	
+	# The value of the blue component.
+	attr_reader :blue
+	
+	#
+	# readers
+	#---------------------------------------------------------------------------
+	
+	
+	
+	#---------------------------------------------------------------------------
+	# obj_or_new
+	#
+	
+	# If the given object is an EGBCell object, then it is returned. Otherwise
+	# the object is used to create an RGBCell object.
+	def self.obj_or_new(*positions)
+		if positions[0].is_a?(RGBCell)
+			return positions[0]
+		else
+			return self.new(*positions)
+		end
+	end
+	
+	#
+	# obj_or_new
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# red=, green=, blue=
+	#
+	
+	# Sets the red coordinate. Converts the given number to a float.
+	def red=(coord)
+		@red = coord.to_f
+	end
+	
+	# Sets the greens coordinate. Converts the given number to a float.
+	def green=(coord)
+		@green = coord.to_f
+	end
+	
+	# Sets the blue coordinate. Converts the given number to a float.
+	def blue=(coord)
+		@blue = coord.to_f
+	end
+	
+	#
+	# red=, green=, blue=
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# positions
+	#
+	
+	# Returns an array of the three component coordinates.
+	def positions()
+		return [@red, @green, @blue]
+	end
+	#
+	# positions
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# randomize
+	#
+	
+	# Sets the object to a random color.
+	def randomize
+		@red = self.class.rand_255().to_f
+		@green = self.class.rand_255().to_f
+		@blue = self.class.rand_255().to_f
+	end
+	
+	#
+	# randomize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# average
+	#
+	
+	# Returns a color representing the midpoint between the object's color and
+	# the other given colors.
+	def average(*others)
+		# $tm.hrm
+		r_sum = @red
+		g_sum = @green
+		b_sum = @blue
+		
+		# loop through others
+		others.each do |other|
+			other = self.class.obj_or_new(other)
+			r_sum += other.red
+			g_sum += other.green
+			b_sum += other.blue
+		end
+		
+		# total
+		total = others.length + 1
+		
+		# return
+		return self.class.new( r_sum/total, g_sum/total, b_sum/total )
+	end
+	
+	#
+	# average
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# self.average
+	#
+	
+	# Returns the midpoint of the given colors expressed as a color.
+	def self.average(*colors)
+		base = self.obj_or_new(colors.shift)
+		return base.average(*colors)
+	end
+	
+	#
+	# self.average
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# to_s, to_str, +
+	#
+	
+	# Returns the hexidecimal representation of the color.
+	def to_s
+		return to_str()
+	end
+	
+	# Returns the hexidecimal representation of the color.
+	def to_str
+		rv = '#'
+		
+		# loop through coordinates
+		positions.each do |pos|
+			rv += self.class.coord_to_hex(pos)
+		end
+		
+		# return
+		return rv
+	end
+	
+	# I don't remember what the point of this method was supposed to be.
+	# def +(val)
+	#	return to_str() + val.to_str
+	# end
+	
+	#
+	# to_s, to_str, +
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# coord_to_hex
+	#
+	
+	# Converts a color coordinate to hexidecimal.
+	def self.coord_to_hex(coord)
+		return coord.to_i.to_s(16).rjust(2, '0')
+	end
+	#
+	# coord_to_hex
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# distance
+	#
+	
+	# Returns the distance between the color and the given color. Always returns
+	# zero or a positive number.
+	def distance(*other)
+		# $tm.hrm
+		
+		# ensure object
+		other = self.class.obj_or_new(*other)
+		
+		# individual distances
+		red_d = (@red - other.red).abs2
+		green_d = (@green - other.green).abs2
+		blue_d = (@blue - other.blue).abs2
+		
+		# rv
+		return Math.sqrt(red_d + green_d + blue_d).abs
+	end
+	#
+	# distance
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# -
+	#
+	
+	# Alias for RGBCell#distance.
+	def -(*other)
+		return distance(*other)
+	end
+	
+	#
+	# -
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# named colors
+	# https://www.w3.org/wiki/CSS/Properties/color/keywords
+	#
+	
+	# A hash of official named HTML colors. For the full list of names, see
+	# https://www.w3.org/wiki/CSS/Properties/color/keywords
+	NAMES = {}
+	
+	NAMES['aliceblue'] = [240, 248, 255]
+	NAMES['antiquewhite'] = [250, 235, 215]
+	NAMES['aqua'] = [0, 255, 255]
+	NAMES['aquamarine'] = [127, 255, 212]
+	NAMES['azure'] = [240, 255, 255]
+	NAMES['beige'] = [245, 245, 220]
+	NAMES['bisque'] = [255, 228, 196]
+	NAMES['black'] = [0, 0, 0]
+	NAMES['blanchedalmond'] = [255, 235, 205]
+	NAMES['blue'] = [0, 0, 255]
+	NAMES['blueviolet'] = [138, 43, 226]
+	NAMES['brown'] = [165, 42, 42]
+	NAMES['burlywood'] = [222, 184, 135]
+	NAMES['cadetblue'] = [95, 158, 160]
+	NAMES['chartreuse'] = [127, 255, 0]
+	NAMES['chocolate'] = [210, 105, 30]
+	NAMES['coral'] = [255, 127, 80]
+	NAMES['cornflowerblue'] = [100, 149, 237]
+	NAMES['cornsilk'] = [255, 248, 220]
+	NAMES['crimson'] = [220, 20, 60]
+	NAMES['cyan'] = [0, 255, 255]
+	NAMES['darkblue'] = [0, 0, 139]
+	NAMES['darkcyan'] = [0, 139, 139]
+	NAMES['darkgoldenrod'] = [184, 134, 11]
+	NAMES['darkgray'] = [169, 169, 169]
+	NAMES['darkgreen'] = [0, 100, 0]
+	NAMES['darkkhaki'] = [189, 183, 107]
+	NAMES['darkmagenta'] = [139, 0, 139]
+	NAMES['darkolivegreen'] = [85, 107, 47]
+	NAMES['darkorange'] = [255, 140, 0]
+	NAMES['darkorchid'] = [153, 50, 204]
+	NAMES['darkred'] = [139, 0, 0]
+	NAMES['darksalmon'] = [233, 150, 122]
+	NAMES['darkseagreen'] = [143, 188, 143]
+	NAMES['darkslateblue'] = [72, 61, 139]
+	NAMES['darkslategray'] = [47, 79, 79]
+	NAMES['darkturquoise'] = [0, 206, 209]
+	NAMES['darkviolet'] = [148, 0, 211]
+	NAMES['deeppink'] = [255, 20, 147]
+	NAMES['deepskyblue'] = [0, 191, 255]
+	NAMES['dimgray'] = [105, 105, 105]
+	NAMES['dodgerblue'] = [30, 144, 255]
+	NAMES['firebrick'] = [178, 34, 34]
+	NAMES['floralwhite'] = [255, 250, 240]
+	NAMES['forestgreen'] = [34, 139, 34]
+	NAMES['fuchsia'] = [255, 0, 255]
+	NAMES['gainsboro'] = [220, 220, 220]
+	NAMES['ghostwhite'] = [248, 248, 255]
+	NAMES['gold'] = [255, 215, 0]
+	NAMES['goldenrod'] = [218, 165, 32]
+	NAMES['gray'] = [128, 128, 128]
+	NAMES['green'] = [0, 128, 0]
+	NAMES['greenyellow'] = [173, 255, 47]
+	NAMES['honeydew'] = [240, 255, 240]
+	NAMES['hotpink'] = [255, 105, 180]
+	NAMES['indianred'] = [205, 92, 92]
+	NAMES['indigo'] = [75, 0, 130]
+	NAMES['ivory'] = [255, 255, 240]
+	NAMES['khaki'] = [240, 230, 140]
+	NAMES['lavender'] = [230, 230, 250]
+	NAMES['lavenderblush'] = [255, 240, 245]
+	NAMES['lawngreen'] = [124, 252, 0]
+	NAMES['lemonchiffon'] = [255, 250, 205]
+	NAMES['lightblue'] = [173, 216, 230]
+	NAMES['lightcoral'] = [240, 128, 128]
+	NAMES['lightcyan'] = [224, 255, 255]
+	NAMES['lightgoldenrodyellow'] = [250, 250, 210]
+	NAMES['lightgray'] = [211, 211, 211]
+	NAMES['lightgreen'] = [144, 238, 144]
+	NAMES['lightpink'] = [255, 182, 193]
+	NAMES['lightsalmon'] = [255, 160, 122]
+	NAMES['lightseagreen'] = [32, 178, 170]
+	NAMES['lightskyblue'] = [135, 206, 250]
+	NAMES['lightslategray'] = [119, 136, 153]
+	NAMES['lightsteelblue'] = [176, 196, 222]
+	NAMES['lightyellow'] = [255, 255, 224]
+	NAMES['lime'] = [0, 255, 0]
+	NAMES['limegreen'] = [50, 205, 50]
+	NAMES['linen'] = [250, 240, 230]
+	NAMES['magenta'] = [255, 0, 255]
+	NAMES['maroon'] = [128, 0, 0]
+	NAMES['mediumaquamarine'] = [102, 205, 170]
+	NAMES['mediumblue'] = [0, 0, 205]
+	NAMES['mediumorchid'] = [186, 85, 211]
+	NAMES['mediumpurple'] = [147, 112, 219]
+	NAMES['mediumseagreen'] = [60, 179, 113]
+	NAMES['mediumslateblue'] = [123, 104, 238]
+	NAMES['mediumspringgreen'] = [0, 250, 154]
+	NAMES['mediumturquoise'] = [72, 209, 204]
+	NAMES['mediumvioletred'] = [199, 21, 133]
+	NAMES['midnightblue'] = [25, 25, 112]
+	NAMES['mintcream'] = [245, 255, 250]
+	NAMES['mistyrose'] = [255, 228, 225]
+	NAMES['moccasin'] = [255, 228, 181]
+	NAMES['navajowhite'] = [255, 222, 173]
+	NAMES['navy'] = [0, 0, 128]
+	NAMES['oldlace'] = [253, 245, 230]
+	NAMES['olive'] = [128, 128, 0]
+	NAMES['olivedrab'] = [107, 142, 35]
+	NAMES['orange'] = [255, 165, 0]
+	NAMES['orangered'] = [255, 69, 0]
+	NAMES['orchid'] = [218, 112, 214]
+	NAMES['palegoldenrod'] = [238, 232, 170]
+	NAMES['palegreen'] = [152, 251, 152]
+	NAMES['paleturquoise'] = [175, 238, 238]
+	NAMES['palevioletred'] = [219, 112, 147]
+	NAMES['papayawhip'] = [255, 239, 213]
+	NAMES['peachpuff'] = [255, 218, 185]
+	NAMES['peru'] = [205, 133, 63]
+	NAMES['pink'] = [255, 192, 203]
+	NAMES['plum'] = [221, 160, 221]
+	NAMES['powderblue'] = [176, 224, 230]
+	NAMES['purple'] = [128, 0, 128]
+	NAMES['red'] = [255, 0, 0]
+	NAMES['rosybrown'] = [188, 143, 143]
+	NAMES['royalblue'] = [65, 105, 225]
+	NAMES['saddlebrown'] = [139, 69, 19]
+	NAMES['salmon'] = [250, 128, 114]
+	NAMES['sandybrown'] = [244, 164, 96]
+	NAMES['seagreen'] = [46, 139, 87]
+	NAMES['seashell'] = [255, 245, 238]
+	NAMES['sienna'] = [160, 82, 45]
+	NAMES['silver'] = [192, 192, 192]
+	NAMES['skyblue'] = [135, 206, 235]
+	NAMES['slateblue'] = [106, 90, 205]
+	NAMES['slategray'] = [112, 128, 144]
+	NAMES['snow'] = [255, 250, 250]
+	NAMES['springgreen'] = [0, 255, 127]
+	NAMES['steelblue'] = [70, 130, 180]
+	NAMES['tan'] = [210, 180, 140]
+	NAMES['teal'] = [0, 128, 128]
+	NAMES['thistle'] = [216, 191, 216]
+	NAMES['tomato'] = [255, 99, 71]
+	NAMES['turquoise'] = [64, 224, 208]
+	NAMES['violet'] = [238, 130, 238]
+	NAMES['wheat'] = [245, 222, 179]
+	NAMES['white'] = [255, 255, 255]
+	NAMES['whitesmoke'] = [245, 245, 245]
+	NAMES['yellow'] = [255, 255, 0]
+	NAMES['yellowgreen'] = [154, 205, 50]
+	
+	#
+	# named colors
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# method_missing
+	#
+	
+	# This method allows you to create colors by name as if the color names were
+	# methods. For example, RGBCell.red returns an object representing the color
+	# red.
+	def self.method_missing(key)
+		# $tm.hrm
+		# puts key.class
+		# puts NAMES[key.to_s]
+		# $tm.devexit
+		
+		if name = NAMES[key.to_s]
+			return self.new(name)
+		else
+			super(key)
+		end
+	end
+	
+	#
+	# method_missing
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# froms
+	#
+	
+	# Returns the distance from the color black.
+	def from_black
+		return distance(self.class.black)
+	end
+	
+	# Returns the distance from the color white.
+	def from_white
+		return distance(self.class.white)
+	end
+	
+	#
+	# froms
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# comparison operators
+	#
+	# def >(other)
+	#	return (from_white() > other.from_white)
+	# end
+	#
+	# def ==(other)
+	#	return (from_white.to_s == other.from_white)
+	# end
+	#
+	# def <(other)
+	#	return (from_white() < other.from_white)
+	# end
+	#
+	# def <=>(other)
+	#	return (from_white() <=> other.from_white())
+	# end
+	#
+	# comparison operators
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# pivot
+	#
+	
+	# Returns a new RGBCell object in which the component colors have been
+	# pivoted. Red becomes blue, green becomes red, blue becomes green.
+	def pivot
+		return self.class.new(@green, @blue, @red)
+	end
+	
+	# Pivots the objects colors in place.
+	def pivot!
+		rgb = [@green, @blue, @red]
+		@red = rgb[0]
+		@green = rgb[1]
+		@blue = rgb[2]
+		return self
+	end
+	
+	#
+	# pivot
+	#---------------------------------------------------------------------------
+	
+	
+	# private
+	private
+	
+	
+	#---------------------------------------------------------------------------
+	# rand_255
+	#
+	def self.rand_255
+		return rand(0..255).to_f
+	end
+	#
+	# rand_255
+	#---------------------------------------------------------------------------
+end
+#
+# RGBCell
+#===============================================================================

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: rgbcell
+version: !ruby/object:Gem::Version
+  version: '0.5'
+platform: ruby
+authors:
+- Mike O'Sullivan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-06-25 00:00:00.000000000 Z
+dependencies: []
+description: Calculates colors based on their x-y-z coordinates. Used for cellular
+  automata.
+email: mike@idocs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/rgbcell.rb
+homepage: https://rubygems.org/gems/rgbcell
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Color calculations using Cartesian coordinat geometery
+test_files: []