rays 0.1.6 → 0.1.7

data/src/bounds.cpp

@@ -1,29 +1,43 @@
 #include "rays/bounds.h"
 
 
+#include <algorithm>
+#include "rays/exception.h"
+
+
 namespace Rays
 {
 
 
 	Bounds::Bounds (coord size)
 	{
-		set(size);
+		reset(size);
 	}
 
 	Bounds::Bounds (coord width, coord height, coord depth)
 	{
-		set(width, height, depth);
+		reset(width, height, depth);
 	}
 
 	Bounds::Bounds (coord x, coord y, coord width, coord height)
 	{
-		set(x, y, width, height);
+		reset(x, y, width, height);
 	}
 
 	Bounds::Bounds (
 		coord x, coord y, coord z, coord width, coord height, coord depth)
 	{
-		set(x, y, z, width, height, depth);
+		reset(x, y, z, width, height, depth);
+	}
+
+	Bounds::Bounds (const Point& size)
+	{
+		reset(size);
+	}
+
+	Bounds::Bounds (const Point& position, const Point& size)
+	{
+		reset(position, size);
 	}
 
 	Bounds
@@ -32,69 +46,183 @@ namespace Rays
 		return *this;
 	}
 
+	bool
+	Bounds::is_intersect (const Bounds& other, int dimension) const
+	{
+		if (dimension < 1 || 3 < dimension)
+			argument_error(__FILE__, __LINE__);
+
+		Point size = (*this & other).size();
+		for (int i = 0; i < dimension; ++i)
+			if (size[i] <= 0) return false;
+
+		return true;
+	}
+
+	bool
+	Bounds::is_include (coord x, coord y, coord z, int dimension) const
+	{
+		return is_include(Point(x, y, z), dimension);
+	}
+
+	bool
+	Bounds::is_include (const Point& point, int dimension) const
+	{
+		if (dimension < 1 || 3 < dimension)
+			argument_error(__FILE__, __LINE__);
+
+		const Point &pos = position(), &size_ = size();
+		for (int i = 0; i < dimension; ++i)
+		{
+			coord value = point[i], min_ = pos[i], max_ = min_ + size_[i];
+			if (value < min_ || max_ <= value)
+				return false;
+		}
+
+		return true;
+	}
+
+	Bounds&
+	Bounds::reset (coord size)
+	{
+		return reset(size, size, 0);
+	}
+
+	Bounds&
+	Bounds::reset (coord width, coord height, coord depth)
+	{
+		this->x =
+		this->y =
+		this->z = 0;
+		this->w = width;
+		this->h = height;
+		this->d = depth;
+		return *this;
+	}
+
+	Bounds&
+	Bounds::reset (coord x, coord y, coord width, coord height)
+	{
+		return reset(x, y, 0, width, height, 0);
+	}
+
+	Bounds&
+	Bounds::reset (coord x, coord y, coord z, coord width, coord height, coord depth)
+	{
+		this->x = x;
+		this->y = y;
+		this->z = z;
+		this->w = width;
+		this->h = height;
+		this->d = depth;
+		return *this;
+	}
+
 	Bounds&
-	Bounds::set (coord size)
+	Bounds::reset (const Point& size)
 	{
-		return set(size, size, 0);
+		this->x = this->y = this->z = 0;
+		this->w = size.x;
+		this->h = size.y;
+		this->d = size.z;
+		return *this;
 	}
 
 	Bounds&
-	Bounds::set (coord width, coord height, coord depth)
+	Bounds::reset (const Point& position, const Point& size)
+	{
+		this->x = position.x;
+		this->y = position.y;
+		this->z = position.z;
+		this->w = size.x;
+		this->h = size.y;
+		this->d = size.z;
+		return *this;
+	}
+
+	Bounds&
+	Bounds::move_to (coord x, coord y, coord z)
 	{
-		this->x      =
-		this->y      =
-		this->z      = 0;
-		this->width  = width;
-		this->height = height;
-		this->depth  = depth;
+		this->x = x;
+		this->y = y;
+		this->z = z;
 		return *this;
 	}
 
 	Bounds&
-	Bounds::set (coord x, coord y, coord width, coord height)
+	Bounds::move_to (const Point& point)
 	{
-		return set(x, y, 0, width, height, 0);
+		return move_to(point.x, point.y, point.z);
 	}
 
 	Bounds&
-	Bounds::set (coord x, coord y, coord z, coord width, coord height, coord depth)
+	Bounds::move_by (coord x, coord y, coord z)
 	{
-		this->x      = x;
-		this->y      = y;
-		this->z      = z;
-		this->width  = width;
-		this->height = height;
-		this->depth  = depth;
+		this->x += x;
+		this->y += y;
+		this->z += z;
 		return *this;
 	}
 
-	bool
-	Bounds::get (coord* x, coord* y, coord* width, coord* height) const
+	Bounds&
+	Bounds::move_by (const Point& point)
 	{
-		return get(x, y, NULL, width, height, NULL);
+		return move_by(point.x, point.y, point.z);
 	}
 
-	bool
-	Bounds::get (
-		coord* x, coord* y, coord* z, coord* width, coord* height, coord* depth) const
-	{
-		if (!x && !y && !z && !width && !height && !depth)
-			return false;
-
-		if (x)      *x      = this->x;
-		if (y)      *y      = this->y;
-		if (z)      *z      = this->z;
-		if (width)  *width  = this->width;
-		if (height) *height = this->height;
-		if (depth)  *depth  = this->depth;
-		return true;
+	Bounds&
+	Bounds::resize_to (coord width, coord height, coord depth)
+	{
+		this->w = width;
+		this->h = height;
+		this->d = depth;
+		return *this;
+	}
+
+	Bounds&
+	Bounds::resize_to (const Point& point)
+	{
+		return resize_to(point.x, point.y, point.z);
+	}
+
+	Bounds&
+	Bounds::resize_by (coord width, coord height, coord depth)
+	{
+		this->w += width;
+		this->h += height;
+		this->d += depth;
+		return *this;
+	}
+
+	Bounds&
+	Bounds::resize_by (const Point& point)
+	{
+		return resize_by(point.x, point.y, point.z);
+	}
+
+	Bounds&
+	Bounds::inset_by (coord x, coord y, coord z)
+	{
+		this->x += x;
+		this->y += y;
+		this->z += z;
+		this->w -= x * 2;
+		this->h -= y * 2;
+		this->d -= z * 2;
+		return *this;
+	}
+
+	Bounds&
+	Bounds::inset_by (const Point& point)
+	{
+		return inset_by(point.x, point.y, point.z);
 	}
 
 	void
 	Bounds::set_left (coord left)
 	{
-		width -= left - x;
-		x = left;
+		w -= left - x;
+		x  = left;
 	}
 
 	coord
@@ -106,20 +234,20 @@ namespace Rays
 	void
 	Bounds::set_right (coord right)
 	{
-		width = right - x + 1;
+		w = right - x + (right >= 0 ? 1 : -1);
 	}
 
 	coord
 	Bounds::right () const
 	{
-		return x + width - 1;
+		return x + w - 1;
 	}
 
 	void
 	Bounds::set_top (coord top)
 	{
-		height -= top - y;
-		y = top;
+		h -= top - y;
+		y  = top;
 	}
 
 	coord
@@ -131,20 +259,20 @@ namespace Rays
 	void
 	Bounds::set_bottom (coord bottom)
 	{
-		height = bottom - y + 1;
+		h = bottom - y + (bottom >= 0 ? 1 : -1);
 	}
 
 	coord
 	Bounds::bottom () const
 	{
-		return y + height - 1;
+		return y + h - 1;
 	}
 
 	void
 	Bounds::set_back (coord back)
 	{
-		depth -= back - z;
-		z = back;
+		d -= back - z;
+		z  = back;
 	}
 
 	coord
@@ -156,19 +284,19 @@ namespace Rays
 	void
 	Bounds::set_front (coord front)
 	{
-		depth = front - z + 1;
+		d = front - z + (front >= 0 ? 1 : -1);
 	}
 
 	coord
 	Bounds::front () const
 	{
-		return z + depth - 1;
+		return z + d - 1;
 	}
 
 	Point&
 	Bounds::position ()
 	{
-		return ((Point*) this)[0];
+		return (*this)[0];
 	}
 
 	const Point&
@@ -180,7 +308,7 @@ namespace Rays
 	Point&
 	Bounds::size ()
 	{
-		return ((Point*) this)[1];
+		return (*this)[1];
 	}
 
 	const Point&
@@ -189,21 +317,50 @@ namespace Rays
 		return const_cast<This*>(this)->size();
 	}
 
-	coord*
-	Bounds::array ()
+	void
+	Bounds::set_center (coord x, coord y, coord z)
+	{
+		this->x = x - w / 2;
+		this->y = y - h / 2;
+		this->z = z - d / 2;
+	}
+
+	void
+	Bounds::set_center (const Point& point)
+	{
+		set_center(point.x, point.y, point.z);
+	}
+
+	Point
+	Bounds::center () const
+	{
+		return Point(x + w / 2, y + h / 2, z + d / 2);
+	}
+
+	String
+	Bounds::inspect () const
 	{
-		return (coord*) this;
+		return Xot::stringf("x=%f y=%f z=%f width=%f height=%f depth=%f", x, y, z, w, h, d);
+	}
+
+	Point&
+	Bounds::operator [] (size_t index)
+	{
+		if (index > 1)
+			argument_error(__FILE__, __LINE__);
+
+		return ((Point*) array)[index];
 	}
 
-	const coord*
-	Bounds::array () const
+	const Point&
+	Bounds::operator [] (size_t index) const
 	{
-		return const_cast<Bounds*>(this)->array();
+		return const_cast<Bounds*>(this)->operator[](index);
 	}
 
 	Bounds::operator bool () const
 	{
-		return width >= 0 && height >= 0 && depth >= 0;
+		return w >= 0 && h >= 0 && d >= 0;
 	}
 
 	bool
@@ -212,6 +369,42 @@ namespace Rays
 		return !operator bool();
 	}
 
+	Bounds&
+	Bounds::operator &= (const Bounds& rhs)
+	{
+		if (!*this || !rhs)
+			argument_error(__FILE__, __LINE__);
+
+		coord x = std::max(this->x, rhs.x);
+		coord y = std::max(this->y, rhs.y);
+		coord z = std::max(this->z, rhs.z);
+		coord w = std::min(this->x + this->w, rhs.x + rhs.w) - x;
+		coord h = std::min(this->y + this->h, rhs.y + rhs.h) - y;
+		coord d = std::min(this->z + this->d, rhs.z + rhs.d) - z;
+
+		return reset(
+			x, y, z,
+			std::max(w, (coord) 0),
+			std::max(h, (coord) 0),
+			std::max(d, (coord) 0));
+	}
+
+	Bounds&
+	Bounds::operator |= (const Bounds& rhs)
+	{
+		if (!*this || !rhs)
+			argument_error(__FILE__, __LINE__);
+
+		coord x = std::min(this->x, rhs.x);
+		coord y = std::min(this->y, rhs.y);
+		coord z = std::min(this->z, rhs.z);
+		coord w = std::max(this->x + this->w, rhs.x + rhs.w) - x;
+		coord h = std::max(this->y + this->h, rhs.y + rhs.h) - y;
+		coord d = std::max(this->z + this->d, rhs.z + rhs.d) - z;
+
+		return reset(x, y, z, w, h, d);
+	}
+
 	bool
 	operator == (const Bounds& lhs, const Bounds& rhs)
 	{
@@ -219,9 +412,9 @@ namespace Rays
 			lhs.x == rhs.x &&
 			lhs.y == rhs.y &&
 			lhs.z == rhs.z &&
-			lhs.width  == rhs.width  &&
-			lhs.height == rhs.height &&
-			lhs.depth  == rhs.depth;
+			lhs.w == rhs.w &&
+			lhs.h == rhs.h &&
+			lhs.d == rhs.d;
 	}
 
 	bool
@@ -230,5 +423,21 @@ namespace Rays
 		return !operator==(lhs, rhs);
 	}
 
+	Bounds
+	operator & (const Bounds& lhs, const Bounds& rhs)
+	{
+		Bounds t = lhs;
+		t &= rhs;
+		return t;
+	}
+
+	Bounds
+	operator | (const Bounds& lhs, const Bounds& rhs)
+	{
+		Bounds t = lhs;
+		t |= rhs;
+		return t;
+	}
+
 
 }// Rays

data/src/color.cpp

@@ -1,18 +1,45 @@
 #include "rays/color.h"
 
 
+#include <limits.h>
+#include <xot/util.h>
+#include "rays/exception.h"
+#include "rays/color_space.h"
+
+
 namespace Rays
 {
 
 
-	Color::Color (float value, float alpha)
+	Color::Color (float gray, float alpha)
 	{
-		set(value, alpha);
+		reset(gray, alpha);
 	}
 
 	Color::Color (float red, float green, float blue, float alpha)
 	{
-		set(red, green, blue, alpha);
+		reset(red, green, blue, alpha);
+	}
+
+	Color::Color (void* pixel, const ColorSpace& cs)
+	{
+		reset(pixel, cs);
+	}
+
+	Color
+	Color8 (uchar gray, uchar alpha)
+	{
+		Color c;
+		c.reset8(gray, alpha);
+		return c;
+	}
+
+	Color
+	Color8 (uchar red, uchar green, uchar blue, uchar alpha)
+	{
+		Color c;
+		c.reset8(red, green, blue, alpha);
+		return c;
 	}
 
 	Color
@@ -22,13 +49,13 @@ namespace Rays
 	}
 
 	Color&
-	Color::set (float value, float alpha)
+	Color::reset (float gray, float alpha)
 	{
-		return set(value, value, value, alpha);
+		return reset(gray, gray, gray, alpha);
 	}
 
 	Color&
-	Color::set (float red, float green, float blue, float alpha)
+	Color::reset (float red, float green, float blue, float alpha)
 	{
 		this->red   = red;
 		this->green = green;
@@ -37,29 +64,149 @@ namespace Rays
 		return *this;
 	}
 
-	bool
-	Color::get (float* red, float* green, float* blue, float* alpha) const
+	Color&
+	Color::reset8 (uchar gray, uchar alpha)
+	{
+		float g = uchar2float(gray);
+		float a = uchar2float(alpha);
+		return reset(g, g, g, a);
+	}
+
+	Color&
+	Color::reset8 (uchar red, uchar green, uchar blue, uchar alpha)
+	{
+		this->red   = uchar2float(red);
+		this->green = uchar2float(green);
+		this->blue  = uchar2float(blue);
+		this->alpha = uchar2float(alpha);
+		return *this;
+	}
+
+	Color&
+	Color::reset (const void* pixel, const ColorSpace& cs)
+	{
+		if (!pixel || !cs)
+			argument_error(__FILE__, __LINE__);
+
+		if (cs.is_float())
+		{
+			float* p = (float*) pixel;
+			switch (cs.type())
+			{
+				case GRAY_float:  reset(p[0]); break;
+				case  RGB_float:  reset(p[0], p[1], p[2]); break;
+				case  RGBA_float: reset(p[0], p[1], p[2], p[3]); break;
+				case ARGB_float:  reset(p[1], p[2], p[3], p[0]); break;
+				case  BGR_float:  reset(p[2], p[1], p[0]); break;
+				case  BGRA_float: reset(p[2], p[1], p[0], p[3]); break;
+				case ABGR_float:  reset(p[3], p[2], p[1], p[0]); break;
+				default:          rays_error(__FILE__, __LINE__);
+			}
+		}
+		else
+		{
+			uchar* p = (uchar*) pixel;
+			switch (cs.type())
+			{
+				case GRAY_8:     reset8(*((uchar*)  pixel) / (float)  UCHAR_MAX); break;
+				case GRAY_16:    reset8(*((ushort*) pixel) / (float)  USHRT_MAX); break;
+				case GRAY_32:    reset8((float) (*((uint*) pixel) / (double) UINT_MAX)); break;
+				case  RGB_888:   reset8(p[0], p[1], p[2]); break;
+				case  RGBA_8888: reset8(p[0], p[1], p[2], p[3]); break;
+				case ARGB_8888:  reset8(p[1], p[2], p[3], p[0]); break;
+				case  RGBX_8888: reset8(p[0], p[1], p[2]); break;
+				case XRGB_8888:  reset8(p[1], p[2], p[3]); break;
+				case  BGR_888:   reset8(p[2], p[1], p[0]); break;
+				case  BGRA_8888: reset8(p[2], p[1], p[0], p[3]); break;
+				case ABGR_8888:  reset8(p[3], p[2], p[1], p[0]); break;
+				case  BGRX_8888: reset8(p[2], p[1], p[0]); break;
+				case XBGR_8888:  reset8(p[3], p[2], p[1]); break;
+				default:         rays_error(__FILE__, __LINE__);
+			}
+		}
+
+		return *this;
+	}
+
+	static float
+	to_gray (const float* c)
 	{
-		if (!red && !green && !blue && !alpha)
-			return false;
+		return (c[0] + c[1] + c[2]) / 3;
+	}
 
-		if (red)   *red   = this->red;
-		if (green) *green = this->green;
-		if (blue)  *blue  = this->blue;
-		if (alpha) *alpha = this->alpha;
-		return true;
+	static uint
+	to_gray (const float* c, uint max)
+	{
+		return Xot::clip<uint>(0, max, to_gray(c) * max);
 	}
 
-	float*
-	Color::array ()
+	static void
+	get_rgba (float* red, float* green, float* blue, float* alpha, const float* c)
 	{
-		return (float*) this;
+		if ((!red && !green && !blue && !alpha) || !c)
+			argument_error(__FILE__, __LINE__);
+
+		if (red)   *red   = c[0];
+		if (green) *green = c[1];
+		if (blue)  *blue  = c[2];
+		if (alpha) *alpha = c[3];
+	}
+
+	static void
+	get_rgba (uchar* red, uchar* green, uchar* blue, uchar* alpha, const float* c)
+	{
+		if ((!red && !green && !blue && !alpha) || !c)
+			argument_error(__FILE__, __LINE__);
+
+		if (red)   *red   = Color::float2uchar(c[0]);
+		if (green) *green = Color::float2uchar(c[1]);
+		if (blue)  *blue  = Color::float2uchar(c[2]);
+		if (alpha) *alpha = Color::float2uchar(c[3]);
 	}
 
-	const float*
-	Color::array () const
+	void
+	Color::get (void* pixel, const ColorSpace& cs) const
 	{
-		return const_cast<Color*>(this)->array();
+		if (!pixel || !cs)
+			argument_error(__FILE__, __LINE__);
+
+		const float* c = array;
+		if (cs.is_float())
+		{
+			float* p = (float*) pixel;
+			switch (cs.type())
+			{
+				case GRAY_float:  p[0] = to_gray(c); break;
+				case  RGB_float:  get_rgba(p+0, p+1, p+2, NULL, c); break;
+				case  RGBA_float: get_rgba(p+0, p+1, p+2, p+3,  c); break;
+				case ARGB_float:  get_rgba(p+1, p+2, p+3, p+0,  c); break;
+				case  BGR_float:  get_rgba(p+2, p+1, p+0, NULL, c); break;
+				case  BGRA_float: get_rgba(p+2, p+1, p+0, p+3,  c); break;
+				case ABGR_float:  get_rgba(p+3, p+2, p+1, p+0,  c); break;
+				default:          rays_error(__FILE__, __LINE__);
+			}
+		}
+		else
+		{
+			uchar* p = (uchar*) pixel;
+			switch (cs.type())
+			{
+				case GRAY_8:  *(uchar*)  p = (uchar)  to_gray(c, UCHAR_MAX); break;
+				case GRAY_16: *(ushort*) p = (ushort) to_gray(c, USHRT_MAX); break;
+				case GRAY_32: *(uint*)   p = (uint)   to_gray(c, UINT_MAX);  break;
+				case  RGB_888:   get_rgba(p+0, p+1, p+2, NULL, c); break;
+				case  RGBA_8888: get_rgba(p+0, p+1, p+2, p+3,  c); break;
+				case ARGB_8888:  get_rgba(p+1, p+2, p+3, p+0,  c); break;
+				case  RGBX_8888: get_rgba(p+0, p+1, p+2, NULL, c); break;
+				case XRGB_8888:  get_rgba(p+1, p+2, p+3, NULL, c); break;
+				case  BGR_888:   get_rgba(p+2, p+1, p+0, NULL, c); break;
+				case  BGRA_8888: get_rgba(p+2, p+1, p+0, p+3,  c); break;
+				case ABGR_8888:  get_rgba(p+3, p+2, p+1, p+0,  c); break;
+				case  BGRX_8888: get_rgba(p+2, p+1, p+0, NULL, c); break;
+				case XBGR_8888:  get_rgba(p+3, p+2, p+1, NULL, c); break;
+				default:         rays_error(__FILE__, __LINE__);
+			}
+		}
 	}
 
 	Color::operator bool () const