rays 0.1.11 → 0.1.16

data/.doc/ext/rays/camera.cpp

@@ -0,0 +1,88 @@
+#include "rays/ruby/camera.h"
+
+
+#include "rays/ruby/image.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(Rays::Camera)
+
+#define THIS  to<Rays::Camera*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Rays::Camera, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Rays::Camera>(klass);
+}
+
+static
+VALUE initialize(VALUE self)
+{
+	RUCY_CHECK_OBJ(Rays::Camera, self);
+
+	*THIS = Rays::Camera();
+	return self;
+}
+
+static
+VALUE start(VALUE self)
+{
+	CHECK;
+	return value(THIS->start());
+}
+
+static
+VALUE stop(VALUE self)
+{
+	CHECK;
+	THIS->stop();
+}
+
+static
+VALUE is_active(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_active());
+}
+
+static
+VALUE image(VALUE self)
+{
+	CHECK;
+	const Rays::Image* img = THIS->image();
+	return img ? value(*img) : nil();
+}
+
+
+static Class cCamera;
+
+void
+Init_camera ()
+{
+	Module mRays = rb_define_module("Rays");
+
+	cCamera = rb_define_class_under(mRays, "Camera", rb_cObject);
+	rb_define_alloc_func(cCamera, alloc);
+	rb_define_private_method(cCamera, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_method(cCamera, "start", RUBY_METHOD_FUNC(start), 0);
+	rb_define_method(cCamera, "stop", RUBY_METHOD_FUNC(stop), 0);
+	cCamera.define_method("active?", is_active);
+	rb_define_method(cCamera, "image", RUBY_METHOD_FUNC(image), 0);
+}
+
+
+namespace Rays
+{
+
+
+	Class
+	camera_class ()
+	{
+		return cCamera;
+	}
+
+
+}// Rays

data/.doc/ext/rays/color.cpp

@@ -1,14 +1,11 @@
 #include "rays/ruby/color.h"
 
 
-#include <rucy.h>
+#include <map>
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
-RUCY_DEFINE_VALUE_FROM_TO(Rays::Color)
+RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Rays::Color)
 
 #define THIS  to<Rays::Color*>(self)
 
@@ -22,34 +19,13 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE setup(VALUE self)
+VALUE initialize(VALUE self)
 {
 	CHECK;
 	check_arg_count(__FILE__, __LINE__, "Color#initialize", argc, 0, 1, 2, 3, 4);
 
-	if (argc == 0) return self;
-
-	switch (argc)
-	{
-		case 1:
-			*THIS = Rays::Color(to<float>(argv[0]));
-			break;
-
-		case 2:
-			*THIS = Rays::Color(to<float>(argv[0]), to<float>(argv[1]));
-			break;
-
-		case 3:
-			*THIS = Rays::Color(
-				to<float>(argv[0]), to<float>(argv[1]), to<float>(argv[2]));
-			break;
-
-		case 4:
-			*THIS = Rays::Color(
-				to<float>(argv[0]), to<float>(argv[1]),
-				to<float>(argv[2]), to<float>(argv[3]));
-			break;
-	}
+	if (argc >= 1)
+		*THIS = to<Rays::Color>(argc, argv);
 
 	return self;
 }
@@ -127,6 +103,82 @@ VALUE get_alpha(VALUE self)
 }
 
 
+typedef std::map<Rays::String, Rays::Color> ColorMap;
+
+static ColorMap&
+get_color_map ()
+{
+	static ColorMap map;
+	if (map.empty())
+	{
+		map["no"]          =
+		map["none"]        =
+		map["transp"]      =
+		map["transparent"] = Rays::gray(0, 0);
+
+		map["black"]      = Rays::rgb8(  0,   0,   0);
+		map["white"]      = Rays::rgb8(255, 241, 232);
+		map["gray"]       =
+		map["lightgray"]  = Rays::rgb8(194, 195, 199);
+		map["darkgray"]   = Rays::rgb8( 95,  87,  79);
+		map["brown"]      = Rays::rgb8(171,  82,  54);
+		map["red"]        = Rays::rgb8(255,   0,  77);
+		map["orange"]     = Rays::rgb8(255, 163,   0);
+		map["yellow"]     = Rays::rgb8(255, 236,  39);
+		map["green"]      = Rays::rgb8(  0, 228,  54);
+		map["darkgreen"]  = Rays::rgb8(  0, 135,  81);
+		map["blue"]       = Rays::rgb8( 41, 173, 255);
+		map["darkblue"]   = Rays::rgb8( 29,  43,  83);
+		map["indigo"]     = Rays::rgb8(131, 118, 156);
+		map["pink"]       = Rays::rgb8(255, 119, 168);
+		map["peach"]      = Rays::rgb8(255, 204, 170);
+		map["darkpurple"] = Rays::rgb8(126,  37,  83);
+	}
+	return map;
+}
+
+static const Rays::String
+to_color_name (const char* name)
+{
+	return Rays::String(name).downcase();
+}
+
+static const Rays::Color&
+find_color (const char* name)
+{
+	assert(name);
+
+	const ColorMap& map = get_color_map();
+	ColorMap::const_iterator it = map.find(to_color_name(name));
+	if (it == map.end())
+		argument_error(__FILE__, __LINE__, "color '%s' is not found.", name);
+
+	return it->second;
+}
+
+static
+VALUE hsv(VALUE self)
+{
+	check_arg_count(__FILE__, __LINE__, "Color.hsv", argc, 3, 4);
+
+	float h = to<float>(argv[0]);
+	float s = to<float>(argv[1]);
+	float v = to<float>(argv[2]);
+	if (argc >= 4)
+		return value(Rays::hsv(h, s, v, to<float>(argv[3])));
+	else
+		return value(Rays::hsv(h, s, v));
+}
+
+static
+VALUE set_palette_color(VALUE self)
+{
+	check_arg_count(__FILE__, __LINE__, "Color.set_palette_color", argc, 2, 3, 4, 5);
+
+	get_color_map()[to_color_name(argv[0].c_str())] = to<Rays::Color>(argc - 1, &argv[1]);
+}
+
+
 static Class cColor;
 
 void
@@ -136,7 +188,7 @@ Init_color ()
 
 	cColor = rb_define_class_under(mRays, "Color", rb_cObject);
 	rb_define_alloc_func(cColor, alloc);
-	rb_define_private_method(cColor, "setup", RUBY_METHOD_FUNC(setup), -1);
+	rb_define_private_method(cColor, "initialize", RUBY_METHOD_FUNC(initialize), -1);
 	rb_define_private_method(cColor, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
 	rb_define_method(cColor, "red=", RUBY_METHOD_FUNC(set_red), 1);
 	rb_define_method(cColor, "red", RUBY_METHOD_FUNC(get_red), 0);
@@ -146,6 +198,8 @@ Init_color ()
 	rb_define_method(cColor, "blue", RUBY_METHOD_FUNC(get_blue), 0);
 	rb_define_method(cColor, "alpha=", RUBY_METHOD_FUNC(set_alpha), 1);
 	rb_define_method(cColor, "alpha", RUBY_METHOD_FUNC(get_alpha), 0);
+	rb_define_module_function(cColor, "hsv", RUBY_METHOD_FUNC(hsv), -1);
+	rb_define_module_function(cColor, "set_palette_color", RUBY_METHOD_FUNC(set_palette_color), -1);
 }
 
 
@@ -153,31 +207,155 @@ namespace Rucy
 {
 
 
+	static int
+	char2hex (char c)
+	{
+		     if ('0' <= c && c <= '9') return      c - '0';
+		else if ('a' <= c && c <= 'f') return 10 + c - 'a';
+		else if ('A' <= c && c <= 'F') return 10 + c - 'A';
+		else                           return -1;
+	}
+
+	static bool
+	parse_channel (float* channel, const char* str, size_t nchars, size_t index)
+	{
+		assert(channel && str && 1 <= nchars && nchars <= 2 && 0 <= index && index <= 3);
+
+		const char* p = str + index * nchars;
+
+		if (nchars == 1)
+		{
+			int c0 = char2hex(p[0]);
+			if (c0 < 0)
+				return false;
+
+			assert(c0 < 16);
+
+			*channel = c0 / 15.f;
+			return true;
+		}
+		else
+		{
+			int c0 = char2hex(p[0]);
+			int c1 = char2hex(p[1]);
+			if (c0 < 0 || c1 < 0)
+				return false;
+
+			assert(c0 < 16 && c1 < 16);
+
+			*channel = (c0 * 16 + c1) / 255.f;
+			return true;
+		}
+	}
+
+	static bool
+	parse_string (Rays::Color* color, const char* str)
+	{
+		assert(color && str);
+
+		if (*str != '#') return false;
+		++str;
+
+		size_t len = strlen(str);
+		switch (len)
+		{
+			case 3:
+			case 6:
+			{
+				size_t nchars = len / 3;
+
+				float r, g, b;
+				if (
+					!parse_channel(&r, str, nchars, 0) ||
+					!parse_channel(&g, str, nchars, 1) ||
+					!parse_channel(&b, str, nchars, 2))
+				{
+					return false;
+				}
+
+				color->reset(r, g, b);
+				break;
+			}
+
+			case 4:
+			case 8:
+			{
+				size_t nchars = len / 4;
+
+				float r, g, b, a;
+				if (
+					!parse_channel(&r, str, nchars, 0) ||
+					!parse_channel(&g, str, nchars, 1) ||
+					!parse_channel(&b, str, nchars, 2) ||
+					!parse_channel(&a, str, nchars, 3))
+				{
+					return false;
+				}
+
+				color->reset(r, g, b, a);
+				break;
+			}
+
+			default: return false;
+		}
+
+		return true;
+	}
+
+	static Rays::Color
+	str2color (const char* str)
+	{
+		if (!str)
+			argument_error(__FILE__, __LINE__);
+
+		Rays::String str_ = str;
+		str_ = str_.strip();
+
+		Rays::Color color;
+		if (parse_string(&color, str_.c_str()))
+			return color;
+		else
+			return find_color(str_.c_str());
+	}
+
 	template <> Rays::Color
-	value_to<Rays::Color> (Value value, bool convert)
+	value_to<Rays::Color> (int argc, const Value*argv, bool convert)
 	{
+		if (argc == 1 && argv->is_array())
+		{
+			argc = argv->size();
+			argv = argv->as_array();
+		}
+
+		assert(argc == 0 || (argc > 0 && argv));
+
 		if (convert)
 		{
-			if (value.is_i() || value.is_f())
-				return Rays::Color(value.as_f(true));
-			else if (value.is_array())
+			if (argc == 0)
+				return Rays::Color();
+			else if (argv->is_nil())
+				return str2color("none");
+			else if (argv->is_s() || argv->is_sym())
+				return str2color(argv[0].c_str());
+			else if (argv->is_num())
 			{
-				int size = value.size();
-				if (size <= 0 || 4 < size)
-					Rucy::argument_error(__FILE__, __LINE__);
-
-				Value* a = value.as_array();
-				switch (size)
+				switch (argc)
 				{
-					case 1: return Rays::Color(a[0].as_f(true));
-					case 2: return Rays::Color(a[0].as_f(true), a[1].as_f(true));
-					case 3: return Rays::Color(a[0].as_f(true), a[1].as_f(true), a[2].as_f(true));
-					case 4: return Rays::Color(a[0].as_f(true), a[1].as_f(true), a[2].as_f(true), a[3].as_f(true));
+					#define V(i) argv[i].as_f(true)
+					case 1: return Rays::Color(V(0));
+					case 2: return Rays::Color(V(0), V(1));
+					case 3: return Rays::Color(V(0), V(1), V(2));
+					case 4: return Rays::Color(V(0), V(1), V(2), V(3));
+					#undef V
+					default: argument_error(__FILE__, __LINE__, "invalid array size.");
 				}
 			}
 		}
 
-		return value_to<Rays::Color&>(value, convert);
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		return value_to<Rays::Color&>(*argv, convert);
 	}
 
 

data/.doc/ext/rays/color_space.cpp

@@ -1,18 +1,65 @@
 #include "rays/ruby/color_space.h"
 
 
-#include <rucy.h>
 #include "defs.h"
 
 
-using namespace Rucy;
+RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Rays::ColorSpace)
 
+#define THIS  to<Rays::ColorSpace*>(self)
 
-RUCY_DEFINE_VALUE_FROM_TO(Rays::ColorSpace)
+#define CHECK RUCY_CHECK_OBJECT(Rays::ColorSpace, self)
 
-#define THIS  to<Rays::ColorSpace*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Rays::ColorSpace, self)
+static struct ColorSpaceEnum
+{
+	const char* name;
+	Rays::ColorSpaceType type;
+}
+COLOR_SPACES[] =
+{
+	{"GRAY",        Rays::GRAY},
+	{"ALPHA",       Rays::ALPHA},
+	{"RGB",         Rays:: RGB},
+	{"BGR",         Rays:: BGR},
+	{"RGBA",        Rays:: RGBA},
+	{"RGBX",        Rays:: RGBX},
+	{"ARGB",        Rays::ARGB},
+	{"XRGB",        Rays::XRGB},
+	{"BGRA",        Rays:: BGRA},
+	{"BGRX",        Rays:: BGRX},
+	{"ABGR",        Rays::ABGR},
+	{"XBGR",        Rays::XBGR},
+	{"GRAY_8",      Rays::GRAY_8},
+	{"GRAY_16",     Rays::GRAY_16},
+	{"GRAY_24",     Rays::GRAY_24},
+	{"GRAY_32",     Rays::GRAY_32},
+	{"GRAY_float",  Rays::GRAY_float},
+	{"ALPHA_8",     Rays::ALPHA_8},
+	{"ALPHA_16",    Rays::ALPHA_16},
+	{"ALPHA_24",    Rays::ALPHA_24},
+	{"ALPHA_32",    Rays::ALPHA_32},
+	{"ALPHA_float", Rays::ALPHA_float},
+	{"RGB_888",     Rays:: RGB_888},
+	{"RGBA_8888",   Rays:: RGBA_8888},
+	{"RGBX_8888",   Rays:: RGBX_8888},
+	{"ARGB_8888",   Rays::ARGB_8888},
+	{"XRGB_8888",   Rays::XRGB_8888},
+	{"BGR_888",     Rays:: BGR_888},
+	{"BGRA_8888",   Rays:: BGRA_8888},
+	{"BGRX_8888",   Rays:: BGRX_8888},
+	{"ABGR_8888",   Rays::ABGR_8888},
+	{"XBGR_8888",   Rays::XBGR_8888},
+	{"RGB_float",   Rays:: RGB_float},
+	{"RGBA_float",  Rays:: RGBA_float},
+	{"ARGB_float",  Rays::ARGB_float},
+	{"BGR_float",   Rays:: BGR_float},
+	{"BGRA_float",  Rays:: BGRA_float},
+	{"ABGR_float",  Rays::ABGR_float},
+};
+
+static const size_t COLOR_SPACES_SIZE =
+	sizeof(COLOR_SPACES) / sizeof(COLOR_SPACES[0]);
 
 
 static
@@ -22,13 +69,12 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE setup(VALUE self, VALUE type, VALUE premultiplied)
+VALUE initialize(VALUE self)
 {
-	CHECK;
+	RUCY_CHECK_OBJ(Rays::ColorSpace, self);
+	check_arg_count(__FILE__, __LINE__, "ColorSpace#initialize", argc, 1, 2);
 
-	*THIS = Rays::ColorSpace(
-		(Rays::ColorSpaceType) to<uint>(type),
-		to<bool>(premultiplied));
+	*THIS = to<Rays::ColorSpace>(argc, argv);
 	return self;
 }
 
@@ -56,6 +102,14 @@ VALUE is_gray(VALUE self)
 	return value(THIS->is_gray());
 }
 
+static
+VALUE is_alpha(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->is_alpha());
+}
+
 static
 VALUE is_rgb(VALUE self)
 {
@@ -104,6 +158,21 @@ VALUE is_premult(VALUE self)
 	return value(THIS->is_premult());
 }
 
+static
+VALUE to_s(VALUE self)
+{
+	CHECK;
+
+	Rays::ColorSpaceType type = THIS->type();
+	for (size_t i = 0; i < COLOR_SPACES_SIZE; ++i)
+	{
+		if (type == COLOR_SPACES[i].type)
+			return value(COLOR_SPACES[i].name);
+	}
+
+	invalid_object_error(__FILE__, __LINE__);
+}
+
 
 static Class cColorSpace;
 
@@ -112,54 +181,85 @@ Init_color_space ()
 {
 	Module mRays = rb_define_module("Rays");
 
+	for (size_t i = 0; i < COLOR_SPACES_SIZE; ++i)
+		mRays.define_const(COLOR_SPACES[i].name, COLOR_SPACES[i].type);
+
 	cColorSpace = rb_define_class_under(mRays, "ColorSpace", rb_cObject);
 	rb_define_alloc_func(cColorSpace, alloc);
+	rb_define_private_method(cColorSpace, "initialize", RUBY_METHOD_FUNC(initialize), -1);
 	rb_define_private_method(cColorSpace, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
-	rb_define_private_method(cColorSpace, "setup", RUBY_METHOD_FUNC(setup), 2);
 	rb_define_method(cColorSpace, "type", RUBY_METHOD_FUNC(type), 0);
 	cColorSpace.define_method("gray?",    is_gray);
+	cColorSpace.define_method("alpha?",   is_alpha);
 	cColorSpace.define_method("rgb?",     is_rgb);
 	cColorSpace.define_method("bgr?",     is_bgr);
 	cColorSpace.define_method("float?",   is_float);
-	cColorSpace.define_method("alpha?",   has_alpha);
-	cColorSpace.define_method("skip?",    has_skip);
+	cColorSpace.define_method("has_alpha?", has_alpha);
+	cColorSpace.define_method("has_skip?",  has_skip);
 	cColorSpace.define_method("premult?", is_premult);
-
-	cColorSpace.define_const("GRAY_8",     Rays::GRAY_8);
-	cColorSpace.define_const("GRAY_16",    Rays::GRAY_16);
-	cColorSpace.define_const("GRAY_24",    Rays::GRAY_24);
-	cColorSpace.define_const("GRAY_32",    Rays::GRAY_32);
-	cColorSpace.define_const("GRAY_float", Rays::GRAY_float);
-	cColorSpace.define_const("RGB_888",    Rays:: RGB_888);
-	cColorSpace.define_const("RGBA_8888",  Rays:: RGBA_8888);
-	cColorSpace.define_const("RGBX_8888",  Rays:: RGBX_8888);
-	cColorSpace.define_const("ARGB_8888",  Rays::ARGB_8888);
-	cColorSpace.define_const("XRGB_8888",  Rays::XRGB_8888);
-	cColorSpace.define_const("BGR_888",    Rays:: BGR_888);
-	cColorSpace.define_const("BGRA_8888",  Rays:: BGRA_8888);
-	cColorSpace.define_const("BGRX_8888",  Rays:: BGRX_8888);
-	cColorSpace.define_const("ABGR_8888",  Rays::ABGR_8888);
-	cColorSpace.define_const("XBGR_8888",  Rays::XBGR_8888);
-	cColorSpace.define_const("RGB_float",  Rays:: RGB_float);
-	cColorSpace.define_const("RGBA_float", Rays:: RGBA_float);
-	cColorSpace.define_const("ARGB_float", Rays::ARGB_float);
-	cColorSpace.define_const("BGR_float",  Rays:: BGR_float);
-	cColorSpace.define_const("BGRA_float", Rays:: BGRA_float);
-	cColorSpace.define_const("ABGR_float", Rays::ABGR_float);
-	cColorSpace.define_const("GRAY",       Rays::GRAY);
-	cColorSpace.define_const("RGB",        Rays:: RGB);
-	cColorSpace.define_const("BGR",        Rays:: BGR);
-	cColorSpace.define_const("RGBA",       Rays:: RGBA);
-	cColorSpace.define_const("RGBX",       Rays:: RGBX);
-	cColorSpace.define_const("ARGB",       Rays::ARGB);
-	cColorSpace.define_const("XRGB",       Rays::XRGB);
-	cColorSpace.define_const("BGRA",       Rays:: BGRA);
-	cColorSpace.define_const("BGRX",       Rays:: BGRX);
-	cColorSpace.define_const("ABGR",       Rays::ABGR);
-	cColorSpace.define_const("XBGR",       Rays::XBGR);
+	rb_define_method(cColorSpace, "to_s", RUBY_METHOD_FUNC(to_s), 0);
 }
 
 
+namespace Rucy
+{
+
+
+	template <> Rays::ColorSpace
+	value_to<Rays::ColorSpace> (int argc, const Value* argv, bool convert)
+	{
+		if (argc == 1 && argv->is_array())
+		{
+			argc = argv->size();
+			argv = argv->as_array();
+		}
+
+		assert(argc > 0 && argv);
+
+		if (convert)
+		{
+			if (argv->is_i() || argv->is_s() || argv->is_sym())
+			{
+				return Rays::ColorSpace(
+					to<Rays::ColorSpaceType>(argv[0]),
+					argc >= 2 ? to<bool>(argv[1]) : true);
+			}
+		}
+
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		return value_to<Rays::ColorSpace&>(*argv, convert);
+	}
+
+
+	template <> Rays::ColorSpaceType
+	value_to<Rays::ColorSpaceType> (Value value, bool convert)
+	{
+		if (convert)
+		{
+			if (value.is_s() || value.is_sym())
+			{
+				const char* str = value.c_str();
+				for (size_t i = 0; i < COLOR_SPACES_SIZE; ++i)
+				{
+					if (strcasecmp(str, COLOR_SPACES[i].name) == 0)
+						return COLOR_SPACES[i].type;
+				}
+			}
+		}
+
+		uint type = value_to<uint>(value, convert);
+		if (type >= Rays::COLORSPACE_MAX)
+			argument_error(__FILE__, __LINE__, "invalid color space type -- %d", type);
+
+		return (Rays::ColorSpaceType) type;
+	}
+
+
+}// Rucy
+
+
 namespace Rays
 {