rfreeimage 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cba7a3c8f1d3088123e1bacc6249d39dc1e66d3f
-  data.tar.gz: 972756e89b9b5dd293b213048fac8d1c9aa5a5bf
+  metadata.gz: d8d7e7bca8f13f158da2617a15667627c8a0c31a
+  data.tar.gz: 638dacb99a69891c7cbd5112e31a4c9b13e28680
 SHA512:
-  metadata.gz: ae36dad83c8068efe7919391ad3f637c08f5ce8ee67201a215d0d5c9accf1bfd7404925c932982126bddde44af2234bf36d9e1bfc95a31421960ea2112ee25c6
-  data.tar.gz: f439d72b5a1a953276de0648cfa2d8b6e047670a3dc81522071039703cb2d7e6b4eba17a933cce5b23efdb4ba22d4c582fb4548261457881d6b1a7f48f6ca2f6
+  metadata.gz: af82826b1c9556159e616dca72a0e639dd7897b8aa9e00934cd2ffb62e24710b9f2956afae22ecb862f63548bb2b48754e760dda623b07e7fe4b4079cb0884e5
+  data.tar.gz: cdab92f66f9dcb575d3d429e63e3eaef0b8c5770ae703ddab435a244a4972d19bd496662de6a7483beaaf9efcff0948baaaf695018df1c5dfd5c41f611cc5d70

data/ext/rfreeimage/rfi_main.c

@@ -6,6 +6,16 @@ static VALUE rb_mFI;
 static VALUE Class_Image;
 static VALUE Class_RFIError;
 
+__attribute__((constructor))
+static void __rfi_module_init() {
+	FreeImage_Initialise(FALSE);
+}
+
+__attribute__((destructor))
+static void __rfi_module_uninit() {
+	FreeImage_DeInitialise();
+}
+
 static VALUE rb_rfi_version(VALUE self)
 {
 	return rb_ary_new3(3, INT2NUM(FREEIMAGE_MAJOR_VERSION),
@@ -20,14 +30,6 @@ static VALUE rb_rfi_string_version(VALUE self)
 	return result;
 }
 
-static VALUE
-file_arg_rescue(VALUE arg)
-{
-	rb_raise(rb_eTypeError, "argument must be path name or open file (%s given)",
-			rb_class2name(CLASS_OF(arg)));
-	return(VALUE)0;
-}
-
 struct native_image {
 	int w;
 	int h;
@@ -60,6 +62,7 @@ static inline char *rfi_value_to_str(VALUE v)
 {
 	char *filename;
 	long f_len;
+	Check_Type(v, T_STRING);
 	f_len = RSTRING_LEN(v);
 	filename = malloc(f_len + 1);
 	memcpy(filename, RSTRING_PTR(v), f_len);
@@ -67,14 +70,28 @@ static inline char *rfi_value_to_str(VALUE v)
 	return filename;
 }
 
+static FIBITMAP *
+convert_bpp(FIBITMAP *orig, unsigned int bpp) {
+	FIBITMAP *h = NULL;
+	switch(bpp) {
+		case 8:
+			h = FreeImage_ConvertToGreyscale(orig);
+			break;
+		case 32:
+			h = FreeImage_ConvertTo32Bits(orig);
+			break;
+	}
+	return h;
+}
+
 static void
 rd_image(VALUE clazz, VALUE file, struct native_image *img, unsigned int bpp, BOOL ping)
 {
 	char *filename;
+	int flags = 0;
 	FIBITMAP *h = NULL, *orig = NULL;
 	FREE_IMAGE_FORMAT in_fif;
 
-	file = rb_rescue(rb_String, file, file_arg_rescue, file);
 	filename = rfi_value_to_str(file);
 
 	in_fif = FreeImage_GetFileType(filename, 0);
@@ -83,33 +100,62 @@ rd_image(VALUE clazz, VALUE file, struct native_image *img, unsigned int bpp, BO
 		rb_raise(rb_eIOError, "Invalid image file");
 	}
 
-	orig = FreeImage_Load(in_fif, filename, ping ? FIF_LOAD_NOPIXELS : 0 );
+	if (ping) flags |= FIF_LOAD_NOPIXELS;
+	if (in_fif == FIF_JPEG) flags |= JPEG_EXIFROTATE;
+	orig = FreeImage_Load(in_fif, filename, flags);
 	free(filename);
 	if (!orig)
 		rb_raise(rb_eIOError, "Fail to load image file");
-	if (FreeImage_GetBPP(orig) == bpp || bpp <= 0 || ping) {
+	if (ping) {
 		h = orig;
 	} else {
-		switch(bpp) {
-			case 8:
-				h = FreeImage_ConvertTo8Bits(orig);
-				break;
-			case 24:
-				h = FreeImage_ConvertTo24Bits(orig);
-				break;
-			case 32:
-				h = FreeImage_ConvertTo32Bits(orig);
-				break;
-			default:
-				rb_raise(rb_eArgError, "Invalid bpp");
-		}
+		if (bpp <= 0) bpp = 32;
+		h = convert_bpp(orig, bpp);
+		FreeImage_Unload(orig);
+		if (!h) rb_raise(rb_eArgError, "Invalid bpp");
+	}
+	img->handle = h;
+	img->w = FreeImage_GetWidth(h);
+	img->h = FreeImage_GetHeight(h);
+	img->bpp = FreeImage_GetBPP(h);
+	img->stride = FreeImage_GetPitch(h);
+	img->fif = in_fif;
+}
+
+static void
+rd_image_blob(VALUE clazz, VALUE blob, struct native_image *img, unsigned int bpp, BOOL ping)
+{
+	FIBITMAP *h = NULL, *orig = NULL;
+	FIMEMORY *fmh;
+	FREE_IMAGE_FORMAT in_fif;
+
+	Check_Type(blob, T_STRING);
+	fmh = FreeImage_OpenMemory((BYTE*)RSTRING_PTR(blob), RSTRING_LEN(blob));
+
+	in_fif = FreeImage_GetFileTypeFromMemory(fmh, 0);
+	if (in_fif == FIF_UNKNOWN) {
+		FreeImage_CloseMemory(fmh);
+		rb_raise(rb_eIOError, "Invalid image blob");
+	}
+
+	orig = FreeImage_LoadFromMemory(in_fif, fmh, ping ? FIF_LOAD_NOPIXELS : 0 );
+	FreeImage_CloseMemory(fmh);
+	if (!orig)
+		rb_raise(rb_eIOError, "Fail to load image from memory");
+
+	if (ping) {
+		h = orig;
+	} else {
+		if (bpp <= 0) bpp = 32;
+		h = convert_bpp(orig, bpp);
 		FreeImage_Unload(orig);
+		if (!h) rb_raise(rb_eArgError, "Invalid bpp");
 	}
 	img->handle = h;
 	img->w = FreeImage_GetWidth(h);
 	img->h = FreeImage_GetHeight(h);
 	img->bpp = FreeImage_GetBPP(h);
-	img->stride = FreeImage_GetLine(h);
+	img->stride = FreeImage_GetPitch(h);
 	img->fif = in_fif;
 }
 
@@ -119,7 +165,6 @@ VALUE Image_initialize(int argc, VALUE *argv, VALUE self)
 	/* unwrap */
 	Data_Get_Struct(self, struct native_image, img);
 
-	memset(img, 0, sizeof(struct native_image));
 	switch (argc)
 	{
 		case 1:
@@ -149,7 +194,7 @@ VALUE Image_save(VALUE self, VALUE file)
 	Data_Get_Struct(self, struct native_image, img);
 	RFI_CHECK_IMG(img);
 
-	file = rb_rescue(rb_String, file, file_arg_rescue, file);
+	Check_Type(file, T_STRING);
 	filename = rfi_value_to_str(file);
 
 	out_fif = FreeImage_GetFIFFromFilename(filename);
@@ -158,7 +203,14 @@ VALUE Image_save(VALUE self, VALUE file)
 		rb_raise(Class_RFIError, "Invalid format");
 	}
 
-	result = FreeImage_Save(out_fif, img->handle, filename, 0);
+	if (out_fif == FIF_JPEG && img->bpp != 8 && img->bpp != 24) {
+		FIBITMAP *to_save = FreeImage_ConvertTo24Bits(img->handle);
+		result = FreeImage_Save(out_fif, to_save, filename, JPEG_BASELINE);
+		FreeImage_Unload(to_save);
+	} else {
+		result = FreeImage_Save(out_fif, img->handle, filename, 0);
+	}
+
 	free(filename);
 
 	if(!result)
@@ -219,11 +271,25 @@ VALUE Image_read_bytes(VALUE self)
 {
 	struct native_image* img;
 	const char *p;
+	char *ptr;
+	unsigned stride_dst;
+	int i;
+	VALUE v;
 
 	Data_Get_Struct(self, struct native_image, img);
 	RFI_CHECK_IMG(img);
 	p = (const char*)FreeImage_GetBits(img->handle);
-	return rb_str_new(p, img->stride * img->h);
+	stride_dst = img->w * (img->bpp / 8);
+	v = rb_str_new(NULL, stride_dst * img->h);
+
+	/* up-side-down */
+	ptr = RSTRING_PTR(v) + img->h * stride_dst;
+	for(i = 0; i < img->h; i++) {
+		ptr -= stride_dst;
+		memcpy(ptr, p, stride_dst);
+		p += img->stride;
+	}
+	return v;
 }
 
 VALUE Image_buffer_addr(VALUE self)
@@ -251,7 +317,7 @@ static inline VALUE rfi_get_image(FIBITMAP *nh)
 	new_img = malloc(sizeof(struct native_image));
 	memset(new_img, 0, sizeof(struct native_image));
 	new_img->handle = nh;
-	new_img->stride = FreeImage_GetLine(nh);
+	new_img->stride = FreeImage_GetPitch(nh);
 	new_img->bpp = FreeImage_GetBPP(nh);
 	new_img->w = FreeImage_GetWidth(nh);
 	new_img->h = FreeImage_GetHeight(nh);
@@ -266,20 +332,12 @@ VALUE Image_to_bpp(VALUE self, VALUE _bpp)
 	int bpp = NUM2INT(_bpp);
 	Data_Get_Struct(self, struct native_image, img);
 	RFI_CHECK_IMG(img);
+	if (bpp == img->bpp)
+		return self;
+
+	nh = convert_bpp(img->handle, bpp);
+	if (!nh) rb_raise(rb_eArgError, "Invalid bpp");
 
-	switch(bpp) {
-		case 8:
-			nh = FreeImage_ConvertTo8Bits(img->handle);
-			break;
-		case 24:
-			nh = FreeImage_ConvertTo24Bits(img->handle);
-			break;
-		case 32:
-			nh = FreeImage_ConvertTo32Bits(img->handle);
-			break;
-		default:
-			rb_raise(rb_eArgError, "Invalid bpp");
-	}
 	return rfi_get_image(nh);
 }
 
@@ -342,18 +400,115 @@ VALUE Image_crop(VALUE self, VALUE _left, VALUE _top, VALUE _right, VALUE _botto
 	return rfi_get_image(nh);
 }
 
+#define ALLOC_NEW_IMAGE(__v, img) \
+	VALUE __v = Image_alloc(Class_Image);            \
+	struct native_image* img;                        \
+	Data_Get_Struct(__v, struct native_image, img)   \
+
 VALUE Image_ping(VALUE self, VALUE file)
 {
-	struct native_image* img = malloc(sizeof(struct native_image));
+	ALLOC_NEW_IMAGE(v, img);
+
 	rd_image(self, file, img, 0, 1);
+	if (img->handle)
+		FreeImage_Unload(img->handle);
+	img->handle = NULL;
+
+	return v;
+}
+
+VALUE Image_from_blob(int argc, VALUE *argv, VALUE self)
+{
+	ALLOC_NEW_IMAGE(v, img);
 
+	switch (argc)
+	{
+		case 1:
+			rd_image_blob(self, argv[0], img, 0, 0);
+			break;
+		case 2:
+			rd_image_blob(self, argv[0], img, NUM2INT(argv[1]), 0);
+			break;
+		default:
+			rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
+			break;
+	}
+
+	return v;
+}
+
+VALUE Image_ping_blob(VALUE self, VALUE blob)
+{
+	ALLOC_NEW_IMAGE(v, img);
+
+	rd_image_blob(self, blob, img, 0, 1);
 	if (img->handle)
 		FreeImage_Unload(img->handle);
 	img->handle = NULL;
 
-	return Data_Wrap_Struct(Class_Image, NULL, Image_free, img);
+	return v;
+}
+
+/* draw */
+VALUE Image_draw_point(VALUE self, VALUE _x, VALUE _y, VALUE color, VALUE _size)
+{
+	struct native_image* img;
+	int x = NUM2INT(_x);
+	int y = NUM2INT(_y);
+	int size = NUM2INT(_size);
+	int hs = size / 2, i, j;
+	unsigned int bgra = NUM2UINT(color);
+	if (size < 0)
+		rb_raise(rb_eArgError, "Invalid point size: %d", size);
+	Data_Get_Struct(self, struct native_image, img);
+	RFI_CHECK_IMG(img);
+
+	for(i = -hs; i <= hs; i++) {
+		for(j = -hs; j <= hs; j++) {
+			if (i*i + j*j <= hs*hs)
+				FreeImage_SetPixelColor(img->handle, x + i, img->h - (y + j) - 1, (RGBQUAD*)&bgra);
+		}
+	}
+
+	return self;
 }
 
+VALUE Image_draw_rectangle(VALUE self, VALUE _x1, VALUE _y1,
+		VALUE _x2, VALUE _y2,
+		VALUE color, VALUE _width)
+{
+	struct native_image* img;
+	int x1 = NUM2INT(_x1);
+	int y1 = NUM2INT(_y1);
+	int x2 = NUM2INT(_x2);
+	int y2 = NUM2INT(_y2);
+	int size = NUM2INT(_width);
+	int hs = size / 2, i, j;
+	unsigned int bgra = NUM2UINT(color);
+	if (size < 0)
+		rb_raise(rb_eArgError, "Invalid line width: %d", size);
+	Data_Get_Struct(self, struct native_image, img);
+	RFI_CHECK_IMG(img);
+
+	for(i = -hs; i <= hs; i++) {
+		for(j = x1; j <= x2; j++) {
+			FreeImage_SetPixelColor(img->handle, j, img->h - (y1 + i) - 1, (RGBQUAD*)&bgra);
+			FreeImage_SetPixelColor(img->handle, j, img->h - (y2 + i) - 1, (RGBQUAD*)&bgra);
+		}
+	}
+
+	for(i = -hs; i <= hs; i++) {
+		for(j = y1; j <= y2; j++) {
+			FreeImage_SetPixelColor(img->handle, x1 + i, img->h - j - 1, (RGBQUAD*)&bgra);
+			FreeImage_SetPixelColor(img->handle, x2 + i, img->h - j - 1, (RGBQUAD*)&bgra);
+		}
+	}
+
+	return self;
+}
+
+
+
 void Init_rfreeimage(void)
 {
 	rb_mFI = rb_define_module("RFreeImage");
@@ -382,8 +537,11 @@ void Init_rfreeimage(void)
 	rb_define_method(Class_Image, "resize", Image_resize, 2);
 	rb_define_method(Class_Image, "crop", Image_crop, 4);
 
-	rb_define_singleton_method(Class_Image, "ping", Image_ping, 1);
+	/* draw */
+	rb_define_method(Class_Image, "draw_point", Image_draw_point, 4);
+	rb_define_method(Class_Image, "draw_rectangle", Image_draw_rectangle, 4 + 2);
 
+	rb_define_singleton_method(Class_Image, "ping", Image_ping, 1);
+	rb_define_singleton_method(Class_Image, "from_blob", Image_from_blob, -1);
+	rb_define_singleton_method(Class_Image, "ping_blob", Image_ping_blob, 1);
 }
-
-

data/lib/rfreeimage/image.rb

@@ -4,6 +4,16 @@ module RFreeImage
 		BGR = 24
 		BGRA = 32
 	end
+	module Color
+		BLUE    = 0xff0000ff
+		GREEN   = 0xff00ff00
+		RED     = 0xffff0000
+		YELLOW  = 0xffffff00
+		CYAN    = 0xff00ffff
+		WHITE   = 0xffffffff
+		BLACK   = 0xff000000
+		GRAY    = 0xffa9a9a9
+	end
 	class Image
 		def bytes
 			@bytes ||= read_bytes
@@ -15,12 +25,25 @@ module RFreeImage
 		end
 
 		def gray?
-			bpp == GRAY
+			bpp == ImageBPP::GRAY
 		end
 
 		def to_gray
 			return self if gray?
 			to_bpp 8
 		end
+
+		def bgra?
+			bpp == ImageBPP::BGRA
+		end
+
+		def to_bgra
+			return self if bgra?
+			to_bpp 32
+		end
+
+
+		alias_method :write, :save
+		alias_method :columns, :cols
 	end
 end

data/lib/rfreeimage/version.rb

@@ -1,3 +1,3 @@
 module RFreeImage
-	VERSION = '0.1.0'
+	VERSION = '0.1.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rfreeimage
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Yuheng Chen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-01 00:00:00.000000000 Z
+date: 2015-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler