rays 0.1.12 → 0.1.17

data/src/image.h

@@ -0,0 +1,25 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_SRC_IMAGE_H__
+#define __RAYS_SRC_IMAGE_H__
+
+
+#include <rays/image.h>
+
+
+namespace Rays
+{
+
+
+	class Texture;
+
+
+	      Texture& Image_get_texture (      Image& image);
+
+	const Texture& Image_get_texture (const Image& image);
+
+
+}// Rays
+
+
+#endif//EOH

data/src/ios/bitmap.h

@@ -0,0 +1,23 @@
+// -*- mode: c++ -*-
+#pragma once
+#ifndef __RAYS_SRC_IOS_BITMAP_H__
+#define __RAYS_SRC_IOS_BITMAP_H__
+
+
+#import <CoreGraphics/CGImage.h>
+#include "../bitmap.h"
+
+
+namespace Rays
+{
+
+
+	void Bitmap_draw_image (
+		Bitmap* bitmap, CGImageRef image,
+		coord x = 0, coord y = 0, coord width = -1, coord height = -1);
+
+
+}// Rays
+
+
+#endif//EOH

data/src/ios/bitmap.mm

@@ -1,13 +1,13 @@
 // -*- objc -*-
-#import "rays/bitmap.h"
+#import "bitmap.h"
 
 
-#include <assert.h>
-#include <boost/scoped_array.hpp>
-#import <ImageIO/ImageIO.h>
+#import <ImageIO/CGImageDestination.h>
 #import <MobileCoreServices/UTCoreTypes.h>
 #include "rays/exception.h"
-#include "rays/texture.h"
+#include "../color_space.h"
+#include "../font.h"
+#include "../texture.h"
 #include "../frame_buffer.h"
 #include "helper.h"
 
@@ -27,14 +27,14 @@ namespace Rays
 		if (cs.is_alpha_first())
 		{
 			info |= cs.is_premult()
-				? kCGImageAlphaPremultipliedFirst
-				: kCGImageAlphaFirst;
+				?	kCGImageAlphaPremultipliedFirst
+				:	kCGImageAlphaFirst;
 		}
 		else if (cs.is_alpha_last())
 		{
 			info |= cs.is_premult()
-				? kCGImageAlphaPremultipliedLast
-				: kCGImageAlphaLast;
+				?	kCGImageAlphaPremultipliedLast
+				:	kCGImageAlphaLast;
 		}
 		else if (cs.is_skip_first())
 			info |= kCGImageAlphaNoneSkipFirst;
@@ -60,14 +60,13 @@ namespace Rays
 
 		ColorSpace color_space;
 
-		void* pixels;
+		void* pixels = NULL;
 
-		CGContextRef context;
+		CGContextRef context = NULL;
 
-		bool dirty;
+		bool modified;
 
 		Data ()
-		:	pixels(NULL), context(NULL)
 		{
 			clear();
 		}
@@ -86,7 +85,7 @@ namespace Rays
 			if (bpc <= 0 || pitch <= 0) return NULL;
 
 			CGColorSpaceRef cgcs = NULL;
-			if (color_space.is_gray())
+			if (color_space.is_gray() || color_space.is_alpha())
 				cgcs = CGColorSpaceCreateDeviceGray();
 			else if (color_space.is_rgb() || color_space.is_bgr())
 				cgcs = CGColorSpaceCreateDeviceRGB();
@@ -115,7 +114,7 @@ namespace Rays
 			color_space = COLORSPACE_UNKNOWN;
 			pixels      = NULL;
 			context     = NULL;
-			dirty       = false;
+			modified    = false;
 		}
 
 	};// Bitmap::Data
@@ -135,7 +134,7 @@ namespace Rays
 		this_->self->width       = w;
 		this_->self->height      = h;
 		this_->self->color_space = cs;
-		this_->self->dirty       = true;
+		this_->self->modified    = true;
 
 		size_t size = w * h * cs.Bpp();
 		this_->self->pixels = new uchar[size];
@@ -152,16 +151,126 @@ namespace Rays
 		if (!this_ || !tex)
 			argument_error(__FILE__, __LINE__);
 
-		setup_bitmap(this_, tex.width(), tex.height(), tex.color_space(), NULL, false);
+		setup_bitmap(
+			this_, tex.width(), tex.height(), tex.color_space(), NULL, false);
 
 		GLenum format, type;
-		tex.color_space().get_gl_enums(&format, &type, tex.alpha_only());
+		ColorSpace_get_gl_format_and_type(&format, &type, tex.color_space());
 
 		FrameBuffer fb(tex);
 		FrameBufferBinder binder(fb.id());
 
 		for (int y = 0; y < this_->height(); ++y)
-			glReadPixels(0, y, this_->width(), 1, format, type, (GLvoid*) this_->at<uchar>(0, y));
+		{
+			GLvoid* ptr = (GLvoid*) this_->at<uchar>(0, y);
+			glReadPixels(0, y, this_->width(), 1, format, type, ptr);
+		}
+	}
+
+	Bitmap
+	Bitmap_from (const Texture& texture)
+	{
+		Bitmap bmp;
+		setup_bitmap(&bmp, texture);
+		return bmp;
+	}
+
+	void
+	Bitmap_draw_image (
+		Bitmap* bitmap, CGImageRef image,
+		coord x, coord y, coord width, coord height)
+	{
+		if (width == 0 || height == 0) return;
+
+		if (!bitmap || !image)
+			argument_error(__FILE__, __LINE__);
+
+		CGContextRef context = bitmap->self->get_context();
+		if (!context)
+			rays_error(__FILE__, __LINE__, "getting CGContext failed.");
+
+		if (width  < 0) width  = (coord) CGImageGetWidth(image);
+		if (height < 0) height = (coord) CGImageGetHeight(image);
+		CGContextDrawImage(context, CGRectMake(x, y, width, height), image);
+
+		Bitmap_set_modified(bitmap);
+	}
+
+	void
+	Bitmap_draw_string (
+		Bitmap* bitmap, const RawFont& font, const char* str, coord x, coord y)
+	{
+		if (!bitmap || !*bitmap || !font || !str)
+			argument_error(__FILE__, __LINE__);
+
+		if (*str == '\0') return;
+
+		font.draw_string(bitmap->self->get_context(), bitmap->height(), str, x, y);
+
+		Bitmap_set_modified(bitmap);
+	}
+
+	void
+	Bitmap_set_modified (Bitmap* bitmap, bool modified)
+	{
+		assert(bitmap);
+
+		bitmap->self->modified = modified;
+	}
+
+	bool
+	Bitmap_get_modified (const Bitmap& bitmap)
+	{
+		return bitmap.self->modified;
+	}
+
+	void
+	Bitmap_save (const Bitmap& bmp, const char* path_)
+	{
+		std::shared_ptr<CGImage> img(bmp.self->get_image(), CGImageRelease);
+		if (!img)
+			rays_error(__FILE__, __LINE__, "getting CGImage failed.");
+
+		NSString* path = [NSString stringWithUTF8String: path_];
+		NSURL* url = [NSURL fileURLWithPath: path];
+		if (!url)
+			rays_error(__FILE__, __LINE__, "creating NSURL failed.");
+
+		std::shared_ptr<CGImageDestination> dest(
+			CGImageDestinationCreateWithURL((CFURLRef) url, kUTTypePNG, 1, NULL),
+			safe_cfrelease);
+		if (!dest)
+			rays_error(__FILE__, __LINE__, "CGImageDestinationCreateWithURL() failed.");
+
+		CGImageDestinationAddImage(dest.get(), img.get(), NULL);
+		if (!CGImageDestinationFinalize(dest.get()))
+			rays_error(__FILE__, __LINE__, "CGImageDestinationFinalize() failed.");
+	}
+
+	Bitmap
+	Bitmap_load (const char* path_)
+	{
+		if (!path_ || path_[0] == '\0')
+			argument_error(__FILE__, __LINE__);
+
+		NSString* path = [NSString stringWithUTF8String: path_];
+		UIImage* uiimage = [UIImage imageWithContentsOfFile: path];
+		if (!uiimage)
+			rays_error(__FILE__, __LINE__, "[UIImage imageWithContentsOfFile:] failed.");
+
+		CGImageRef image = [uiimage CGImage];
+		if (!image)
+			rays_error(__FILE__, __LINE__, "[imagerep CGImage] failed.");
+
+		size_t width  = CGImageGetWidth(image);
+		size_t height = CGImageGetHeight(image);
+
+		Bitmap bmp((int) width, (int) height, RGBA);
+		if (!bmp)
+			rays_error(__FILE__, __LINE__, "invalid bitmap.");
+
+		Bitmap_draw_image(&bmp, image);
+		return bmp;
 	}
 
 
@@ -175,17 +284,12 @@ namespace Rays
 		setup_bitmap(this, width, height, color_space, pixels);
 	}
 
-	Bitmap::Bitmap (const Texture& texture)
-	{
-		setup_bitmap(this, texture);
-	}
-
 	Bitmap::~Bitmap ()
 	{
 	}
 
 	Bitmap
-	Bitmap::copy () const
+	Bitmap::dup () const
 	{
 		return Bitmap(width(), height(), color_space(), pixels());
 	}
@@ -240,22 +344,13 @@ namespace Rays
 		return const_cast<This*>(this)->pixels();
 	}
 
-	bool
-	Bitmap::dirty () const
-	{
-		return self->dirty;
-	}
-
-	void
-	Bitmap::set_dirty (bool b)
-	{
-		self->dirty = b;
-	}
-
 	Bitmap::operator bool () const
 	{
 		return
-			self->width > 0 && self->height > 0 && self->color_space && self->pixels;
+			self->width  > 0  &&
+			self->height > 0  &&
+			self->color_space &&
+			self->pixels;
 	}
 
 	bool
@@ -265,76 +360,4 @@ namespace Rays
 	}
 
 
-	Bitmap
-	load_bitmap (const char* path_)
-	{
-		if (!path_ || path_[0] == '\0')
-			argument_error(__FILE__, __LINE__);
-
-		NSString* path = [NSString stringWithUTF8String: path_];
-		UIImage* uiimage = [UIImage imageWithContentsOfFile: path];
-		if (!uiimage)
-			rays_error(__FILE__, __LINE__, "[UIImage imageWithContentsOfFile:] failed.");
-
-		CGImageRef image = [uiimage CGImage];
-		if (!image)
-			rays_error(__FILE__, __LINE__, "[imagerep CGImage] failed.");
-
-		size_t width  = CGImageGetWidth(image);
-		size_t height = CGImageGetHeight(image);
-
-		Bitmap bmp((int) width, (int) height, RGBA);
-		if (!bmp)
-			rays_error(__FILE__, __LINE__, "invalid bitmap.");
-
-		CGContextRef context = bmp.self->get_context();
-		if (!context)
-			rays_error(__FILE__, __LINE__, "creating CGContext failed.");
-
-		CGContextDrawImage(context, CGRectMake(0, 0, width, height), image);
-		return bmp;
-	}
-
-	void
-	save_bitmap (const Bitmap& bmp, const char* path_)
-	{
-		boost::shared_ptr<CGImage> img(
-			bmp.self->get_image(), CGImageRelease);
-		if (!img)
-			rays_error(__FILE__, __LINE__, "getting CGImage failed.");
-
-		NSString* path = [NSString stringWithUTF8String: path_];
-		NSURL* url = [NSURL fileURLWithPath: path];
-		if (!url)
-			rays_error(__FILE__, __LINE__, "creating NSURL failed.");
-
-		boost::shared_ptr<CGImageDestination> dest(
-			CGImageDestinationCreateWithURL((CFURLRef) url, kUTTypePNG, 1, NULL),
-			safe_cfrelease);
-		if (!dest)
-			rays_error(__FILE__, __LINE__, "CGImageDestinationCreateWithURL() failed.");
-
-		CGImageDestinationAddImage(dest.get(), img.get(), NULL);
-		if (!CGImageDestinationFinalize(dest.get()))
-			rays_error(__FILE__, __LINE__, "CGImageDestinationFinalize() failed.");
-	}
-
-
-	void draw_string (
-		CGContextRef, coord, const char*, coord, coord, const Font&);
-
-	void
-	draw_string (
-		Bitmap* bmp, const char* str, coord x, coord y, const Font& font)
-	{
-		if (!bmp || !*bmp || !str || !font)
-			argument_error(__FILE__, __LINE__);
-
-		if (*str == '\0') return;
-
-		draw_string(bmp->self->get_context(), bmp->height(), str, x, y, font);
-		bmp->set_dirty();
-	}
-
-
 }// Rays

data/src/ios/camera.mm

@@ -0,0 +1,510 @@
+// -*- mode: objc -*-
+#import "rays/camera.h"
+
+
+#import <AVFoundation/AVFoundation.h>
+#include "rays/exception.h"
+#include "bitmap.h"
+
+
+static int video_input_queue_index = 0;
+
+
+@interface VideoInput : NSObject <AVCaptureVideoDataOutputSampleBufferDelegate>
+@end
+
+
+@implementation VideoInput
+
+	{
+		AVCaptureSession* session;
+		dispatch_queue_t queue;
+		CGImageRef image;
+		AVCaptureVideoOrientation orientation;
+	}
+
+	- (id) init
+	{
+		self = [super init];
+		if (self)
+		{
+			session     = nil;
+			queue       = nil;
+			image       = nil;
+			orientation = AVCaptureVideoOrientationPortrait;
+		}
+		return self;
+	}
+
+	- (void) dealloc
+	{
+		[self stop];
+		[self clearImage];
+
+		if (queue)
+		{
+			dispatch_release(queue);
+			queue = nil;
+		}
+
+		[super dealloc];
+	}
+
+	- (dispatch_queue_t) getQueue
+	{
+		if (!queue)
+		{
+			auto name = Xot::stringf(
+				"org.xord.RaysVideoInputQueue_%d",
+				video_input_queue_index++);
+			queue = dispatch_queue_create(name, DISPATCH_QUEUE_SERIAL);
+		}
+		return queue;
+	}
+
+	- (BOOL) start: (AVCaptureDevice*) device
+		preset: (AVCaptureSessionPreset) preset
+	{
+		if (!device) return NO;
+
+		[self stop];
+		[self updateOrientation];
+
+		AVCaptureSession* sess = [[[AVCaptureSession alloc] init] autorelease];
+		if (preset != nil)
+			sess.sessionPreset = preset;
+
+		//device.activeVideoMinFrameDuration = CMTimeMake(1, 30);
+
+		NSError* error = nil;
+		AVCaptureDeviceInput* input = [[[AVCaptureDeviceInput alloc]
+			initWithDevice: device error: &error]
+			autorelease];
+		if (!input || error || ![sess canAddInput: input])
+			return NO;
+
+		AVCaptureVideoDataOutput* output =
+			[[[AVCaptureVideoDataOutput alloc] init] autorelease];
+		output.videoSettings = @{
+			(NSString*) kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA)
+		};
+		output.alwaysDiscardsLateVideoFrames = YES;
+		[output setSampleBufferDelegate: self queue: [self getQueue]];
+		if (![sess canAddOutput: output])
+			return NO;
+
+		[sess addInput: input];
+		[sess addOutput: output];
+
+		AVCaptureConnection* connection =
+			[output connectionWithMediaType: AVMediaTypeVideo];
+		if (connection)
+		{
+			if (connection.isVideoOrientationSupported)
+				[connection setVideoOrientation: orientation];
+
+			if (connection.isVideoMirroringSupported)
+			{
+				[connection setVideoMirrored:
+					device.position == AVCaptureDevicePositionFront];
+			}
+		}
+
+		[sess startRunning];
+
+		session = [sess retain];
+		return YES;
+	}
+
+	- (void) updateCaptureOrientation
+	{
+		assert(Thread.isMainThread);
+
+		switch (UIApplication.sharedApplication.statusBarOrientation)
+		{
+			case UIInterfaceOrientationPortraitUpsideDown:
+				orientation = AVCaptureVideoOrientationPortraitUpsideDown;
+				break;
+
+			case UIInterfaceOrientationPortraitLandscapeLeft:
+				orientation = AVCaptureVideoOrientationLandscapeLeft;
+				break;
+
+			case UIInterfaceOrientationPortraitLandscapeRight:
+				orientation = AVCaptureVideoOrientationLandscapeRight;
+				break;
+
+			default:
+				orientation = AVCaptureVideoOrientationPortrait;
+				break;
+		}
+	}
+
+	- (void) captureOutput: (AVCaptureOutput*) output
+		didOutputSampleBuffer: (CMSampleBufferRef) sampleBuffer
+		fromConnection: (AVCaptureConnection*) connection
+	{
+		[connection setVideoOrientation: orientation];
+
+		CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
+		if (!pixelBuffer) return;
+
+		CIImage* ciImage = [CIImage imageWithCVPixelBuffer: pixelBuffer];
+		if (!ciImage) return;
+
+		CIContext* context = [CIContext contextWithOptions: nil];
+		size_t width       = CVPixelBufferGetWidth(pixelBuffer);
+		size_t height      = CVPixelBufferGetHeight(pixelBuffer);
+		CGRect rect        = CGRectMake(0, 0, width, height);
+		CGImageRef cgImage = [context createCGImage: ciImage fromRect: rect];
+
+		dispatch_async(dispatch_get_main_queue(), ^{
+			[self clearImage];
+			image = cgImage;
+
+			[self updateOrientation];
+		});
+	}
+
+	- (void) stop
+	{
+		if (!session) return;
+
+		[session stopRunning];
+		[session release];
+		session = nil;
+	}
+
+	- (BOOL) isActive
+	{
+		return session != nil;
+	}
+
+	- (void) clearImage
+	{
+		if (!image) return;
+
+		CGImageRelease(image);
+		image = nil;
+	}
+
+	- (CGImageRef) getImage
+	{
+		return image;
+	}
+
+@end// VideoInput
+
+
+namespace Rays
+{
+
+
+	struct Camera::Data
+	{
+
+		String device_name;
+
+		int min_width = -1, min_height = -1;
+
+		bool resize = false, crop = false;
+
+		mutable Image image;
+
+		VideoInput* video_input = nil;
+
+		AVCaptureSessionPreset get_preset (AVCaptureDevice* device)
+		{
+			int w = min_width, h = min_height;
+			if (w > 0 && h > 0)
+			{
+				#define SUPPORT(x) \
+					[device supportsAVCaptureSessionPreset: AVCaptureSessionPreset##x]
+
+				//if (w <= 320 && h <= 240 && SUPPORT(320x240))
+				//	return AVCaptureSessionPreset320x240;
+
+				if (w <= 352 && h <= 288 && SUPPORT(352x288))
+					return AVCaptureSessionPreset352x288;
+
+				if (w <= 640 && h <= 480 && SUPPORT(640x480))
+					return AVCaptureSessionPreset640x480;
+
+				//if (w <= 960 && h <= 540 && SUPPORT(960x540))
+				//	return AVCaptureSessionPreset960x540;
+
+				if (w <= 1280 && h <= 720 && SUPPORT(1280x720))
+					return AVCaptureSessionPreset1280x720;
+
+				if (/*w <= 1920 && h <= 1080 &&*/ SUPPORT(1920x1080))
+					return AVCaptureSessionPreset1920x1080;
+
+				//if (SUPPORT(3840x2160))
+				//	return AVCaptureSessionPreset3840x2160;
+
+				#undef SUPPORT
+			}
+
+			return nil;
+		}
+
+		void update_image_from_video_input () const
+		{
+			if (!video_input) return;
+
+			CGImageRef cgImage = [video_input getImage];
+			if (!cgImage) return;
+
+			coord draw_x, draw_y, draw_width, draw_height;
+			int bitmap_width, bitmap_height;
+			get_draw_bounds(
+				&draw_x, &draw_y, &draw_width, &draw_height,
+				&bitmap_width, &bitmap_height,
+				cgImage);
+
+			if (
+				!image ||
+				image.bitmap().width()  != bitmap_width ||
+				image.bitmap().height() != bitmap_height)
+			{
+				image = Image(Bitmap(bitmap_width, bitmap_height));
+			}
+
+			Bitmap_draw_image(
+				&image.bitmap(), cgImage,
+				draw_x, draw_y, draw_width, draw_height);
+
+			[video_input clearImage];
+		}
+
+		void get_draw_bounds (
+			coord* draw_x, coord* draw_y, coord* draw_width, coord* draw_height,
+			int* bitmap_width, int* bitmap_height,
+			CGImageRef image) const
+		{
+			int image_width   = (int) CGImageGetWidth(image);
+			int image_height  = (int) CGImageGetHeight(image);
+			float image_ratio = (float) image_width / (float) image_height;
+
+			if (resize && min_width > 0 && min_height > 0)
+			{
+				float min_size_ratio = (float) min_width / (float) min_height;
+				if (image_ratio > min_size_ratio)
+				{
+					*draw_width  = min_height * image_ratio;
+					*draw_height = min_height;
+				}
+				else
+				{
+					*draw_width  = min_width;
+					*draw_height = min_width / image_ratio;
+				}
+			}
+			else if (resize && min_width > 0)
+			{
+				*draw_width  = min_width;
+				*draw_height = min_width / image_ratio;
+			}
+			else if (resize && min_height > 0)
+			{
+				*draw_width  = min_height * image_ratio;
+				*draw_height = min_height;
+			}
+			else
+			{
+				*draw_width  = image_width;
+				*draw_height = image_height;
+			}
+
+			*draw_x        = 0;
+			*draw_y        = 0;
+			*bitmap_width  = *draw_width;
+			*bitmap_height = *draw_height;
+
+			if (crop && min_width > 0)
+			{
+				*draw_x       = min_width / 2 - *draw_width / 2;
+				*bitmap_width = min_width;
+			}
+			else if (crop && min_height > 0)
+			{
+				*draw_y        = min_height / 2 - *draw_height / 2;
+				*bitmap_height = min_height;
+			}
+		}
+
+	};// Camera::Data
+
+
+	static NSArray<AVCaptureDevice*>*
+	get_video_devices ()
+	{
+#if 0
+		AVCaptureDeviceDiscoverySession* discoverySession =
+			[AVCaptureDeviceDiscoverySession
+				discoverySessionWithDeviceTypes: @[
+					AVCaptureDeviceTypeBuiltInWideAngleCamera]
+				mediaType: AVMediaTypeVideo
+				position: AVCaptureDevicePositionUnspecified];
+		NSArray<AVCaptureDevice*>* devices = discoverySession.devices;
+		for (AVCaptureDevice* d in devices)
+		{
+			printf("%s\n", d.localizedName.UTF8String);
+		}
+#endif
+		NSMutableArray<AVCaptureDevice*>* devices = [NSMutableArray array];
+		for (AVCaptureDevice* d in AVCaptureDevice.devices)
+		{
+			if ([d hasMediaType: AVMediaTypeVideo])
+				[devices addObject: d];
+		}
+		return devices;
+	}
+
+	static AVCaptureDevice*
+	get_default_video_device ()
+	{
+		AVCaptureDevice* device =
+			[AVCaptureDevice defaultDeviceWithMediaType: AVMediaTypeVideo];
+		if (!device)
+			rays_error(__FILE__, __LINE__, "Default camera device is not found.");
+
+		return device;
+	}
+
+	static AVCaptureDevice*
+	get_video_device (const char* name)
+	{
+		if (!name || *name == 0)
+			return get_default_video_device();
+
+		for (AVCaptureDevice* d in get_video_devices())
+		{
+			if (strcmp(name, d.localizedName.UTF8String) == 0)
+				return d;
+		}
+
+		rays_error(__FILE__, __LINE__, "Camera device '%s' is not found.", name);
+		return nil;
+	}
+
+	std::vector<String>
+	get_camera_device_names ()
+	{
+		std::vector<String> names;
+		for (AVCaptureDevice* d in get_video_devices())
+			names.emplace_back(d.localizedName.UTF8String);
+		return names;
+	}
+
+
+	Camera::Camera (
+		const char* device_name,
+		int min_width, int min_height, bool resize, bool crop)
+	{
+		if (device_name)
+			self->device_name = device_name;
+
+		self->min_width  = min_width;
+		self->min_height = min_height;
+		self->resize     = resize;
+		self->crop       = crop;
+	}
+
+	Camera::~Camera ()
+	{
+		stop();
+		if (self->video_input) [self->video_input release];
+	}
+
+	bool
+	Camera::start ()
+	{
+		if (!self->video_input) self->video_input = [[VideoInput alloc] init];
+
+		AVCaptureDevice* device = get_video_device(self->device_name.c_str());
+		return [self->video_input start: device preset: self->get_preset(device)];
+	}
+
+	void
+	Camera::stop ()
+	{
+		if (!self->video_input) return;
+
+		[self->video_input stop];
+	}
+
+	bool
+	Camera::is_active () const
+	{
+		return self->video_input && [self->video_input isActive];
+	}
+
+	void
+	Camera::set_min_width (int width)
+	{
+		self->min_width = width;
+	}
+
+	int
+	Camera::min_width () const
+	{
+		return self->min_width;
+	}
+
+	void
+	Camera::set_min_height (int height)
+	{
+		self->min_height = height;
+	}
+
+	int
+	Camera::min_height () const
+	{
+		return self->min_height;
+	}
+
+	void
+	Camera::set_resize (bool resize)
+	{
+		self->resize = resize;
+	}
+
+	bool
+	Camera::is_resize () const
+	{
+		return self->resize;
+	}
+
+	void
+	Camera::set_crop (bool crop)
+	{
+		self->crop = crop;
+	}
+
+	bool
+	Camera::is_crop () const
+	{
+		return self->crop;
+	}
+
+	const Image*
+	Camera::image () const
+	{
+		self->update_image_from_video_input();
+		return self->image ? &self->image : NULL;
+	}
+
+	Camera::operator bool () const
+	{
+		return true;
+	}
+
+	bool
+	Camera::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Rays