magro 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfa8a730f370ebbdf54c3bbbe2248046ec82e0dc759e14f974637d79d437e254
-  data.tar.gz: c907656b0d0732f095d103e0c2bfa76eca70859831c19426ebe517c7560d6592
+  metadata.gz: c1c544837f96597012ff6cf938a4148b7fcc640237daf460ae26c64f91588767
+  data.tar.gz: '08915ee5d2d4ed4b535963684b160e2ab4707d7823b56578f5574099ca33d7ad'
 SHA512:
-  metadata.gz: 8943d964496a118ee778532cfc5fe9cdf8ef4a9731b9217453c98f09ec5ef05be77a5d205ef7e6172e9e3d18475b4dcb336d0626ec458a74b957b1504e3f6e36
-  data.tar.gz: 14ef03b1c882e6d0c2502edce3a93b8bf805588e8ee319652bae5b39cb4d6f682df8387268b646e1e1c1b751db5b944247eec96ad7f7152813af97c3afadf74a
+  metadata.gz: 4d5cd134c942319d0ecb83fb39b89cf8a42c3cacc9c4336eaf592b0170a4257e597ce5c62e4fdb35b4641f2446e206c79da4b012c009516547ff7ae464745975
+  data.tar.gz: cd6cdb5059adf3ed20ea6b9625d314f0519c338b0f01b8abb1ea73ecb8c5cb183b0288e1cdbdb22482d8fb71945b26f4761911c606bb81ce62008cb3ee984742

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 0.6.0
+- Reorganize native exntesion codes.
+- Remove dependent gem's type declaration file from installation files.
+- Update documentations.
+- Introduce conventional commits.
+
 # 0.5.1
 - Fix version specifier of runtime dependencies.
 

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2019-2021 Atsushi Tatsuma
+Copyright (c) 2019-2022 Atsushi Tatsuma
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/README.md

@@ -61,6 +61,6 @@ Or install it yourself as:
 Bug reports and pull requests are welcome on GitHub at https://github.com/yoshoku/magro.
 This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
-## Code of Conduct
+## License
 
-Everyone interacting in the Magro project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/yoshoku/magro/blob/main/CODE_OF_CONDUCT.md).
+The gem is available as open source under the terms of the [BSD-3-Clause License](https://opensource.org/licenses/BSD-3-Clause).

data/ext/magro/extconf.rb

@@ -8,10 +8,7 @@ $LOAD_PATH.each do |lp|
   end
 end
 
-unless have_header('numo/narray.h')
-  puts 'numo/narray.h not found.'
-  exit(1)
-end
+abort 'numo/narray.h not found.' unless have_header('numo/narray.h')
 
 if RUBY_PLATFORM =~ /mswin|cygwin|mingw/
   $LOAD_PATH.each do |lp|
@@ -20,35 +17,14 @@ if RUBY_PLATFORM =~ /mswin|cygwin|mingw/
       break
     end
   end
-  unless have_library('narray', 'nary_new')
-    puts 'libnarray.a not found.'
-    exit(1)
-  end
-end
-
-unless have_header('setjmp.h')
-  puts 'setjmp.h not found.'
-  exit(1)
-end
-
-unless have_header('png.h')
-  puts 'png.h not found.'
-  exit(1)
+  abort 'libnarray.a not found.' unless have_library('narray', 'nary_new')
 end
 
-unless have_header('jpeglib.h')
-  puts 'jpeglib.h not found.'
-  exit(1)
-end
+abort 'setjmp.h not found.' unless have_header('setjmp.h')
+abort 'png.h not found.' unless have_header('png.h')
+abort 'libpng not found.' unless have_library('png')
 
-unless have_library('png')
-  puts 'libpng not found.'
-  exit(1)
-end
-
-unless have_library('jpeg')
-  puts 'libjpeg not found.'
-  exit(1)
-end
+abort 'jpeglib.h not found.' unless have_header('jpeglib.h')
+abort 'libjpeg not found.' unless have_library('jpeg')
 
 create_makefile('magro/magro')

data/ext/magro/magro.c

@@ -1,9 +1,462 @@
+/**
+ * Copyright (c) 2019-2022 Atsushi Tatsuma
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the copyright holder nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
 #include "magro.h"
 
 VALUE mMagro;
+VALUE mMagroIO;
+
+static VALUE magro_io_read_png(VALUE self, VALUE filename_) {
+  char* filename = StringValuePtr(filename_);
+  FILE* file_ptr = fopen(filename, "rb");
+  unsigned char header[8];
+  png_structp png_ptr;
+  png_infop info_ptr;
+  png_bytep* row_ptr_ptr;
+  png_bytep row_ptr;
+  png_uint_32 width, height;
+  int color_type;
+  int bit_depth;
+  png_uint_32 y;
+  int n_dims = 0;
+  int n_ch;
+  size_t shape[3] = {0};
+  VALUE nary;
+  uint8_t* nary_ptr;
+
+  if (file_ptr == NULL) {
+    rb_raise(rb_eIOError, "Failed to open file '%s'", filename);
+    return Qnil;
+  }
+
+  if (fread(header, 1, 8, file_ptr) < 8) {
+    fclose(file_ptr);
+    rb_raise(rb_eIOError, "Failed to read header info '%s'", filename);
+    return Qnil;
+  }
+
+  if (png_sig_cmp(header, 0, 8)) {
+    fclose(file_ptr);
+    rb_raise(rb_eIOError, "Failed to read header info '%s'", filename);
+    return Qnil;
+  }
+
+  png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+  if (png_ptr == NULL) {
+    fclose(file_ptr);
+    rb_raise(rb_eNoMemError, "Failed to allocate memory.");
+    return Qnil;
+  }
+  info_ptr = png_create_info_struct(png_ptr);
+  if (info_ptr == NULL) {
+    png_destroy_read_struct(&png_ptr, NULL, NULL);
+    fclose(file_ptr);
+    rb_raise(rb_eNoMemError, "Failed to allocate memory.");
+    return Qnil;
+  }
+  if (setjmp(png_jmpbuf(png_ptr))) {
+    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+    fclose(file_ptr);
+    rb_raise(rb_eIOError, "Error happened while reading file '%s'", filename);
+    return Qnil;
+  }
+
+  png_init_io(png_ptr, file_ptr);
+  png_set_sig_bytes(png_ptr, 8);
+
+  png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_PACKING | PNG_TRANSFORM_EXPAND | PNG_TRANSFORM_STRIP_16, NULL);
+  row_ptr_ptr = png_get_rows(png_ptr, info_ptr);
+  png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, NULL, NULL, NULL);
+
+  if (color_type == PNG_COLOR_TYPE_PALETTE) {
+    png_set_palette_to_rgb(png_ptr);
+    png_read_update_info(png_ptr, info_ptr);
+    png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, NULL, NULL, NULL);
+  }
+
+  switch (color_type) {
+  case PNG_COLOR_TYPE_GRAY:
+    n_ch = 1;
+    n_dims = 2;
+    shape[0] = height;
+    shape[1] = width;
+    break;
+  case PNG_COLOR_TYPE_GRAY_ALPHA:
+    n_ch = 2;
+    n_dims = 3;
+    shape[0] = height;
+    shape[1] = width;
+    shape[2] = 2;
+    break;
+  case PNG_COLOR_TYPE_RGB:
+    n_ch = 3;
+    n_dims = 3;
+    shape[0] = height;
+    shape[1] = width;
+    shape[2] = 3;
+    break;
+  case PNG_COLOR_TYPE_RGB_ALPHA:
+    n_ch = 4;
+    n_dims = 3;
+    shape[0] = height;
+    shape[1] = width;
+    shape[2] = 4;
+    break;
+  default:
+    n_dims = 0;
+    break;
+  }
+
+  if (n_dims == 0) {
+    fclose(file_ptr);
+    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+    rb_raise(rb_eIOError, "Unsupported color type of input file '%s'", filename);
+    return Qnil;
+  }
+
+  nary = rb_narray_new(numo_cUInt8, n_dims, shape);
+  nary_ptr = (uint8_t*)na_get_pointer_for_write(nary);
+
+  for (y = 0; y < height; y++) {
+    row_ptr = row_ptr_ptr[y];
+    memcpy(nary_ptr + y * width * n_ch, row_ptr, width * n_ch);
+  }
+
+  fclose(file_ptr);
+  png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+
+  RB_GC_GUARD(filename_);
+
+  return nary;
+}
+
+static VALUE magro_io_save_png(VALUE self, VALUE filename_, VALUE image) {
+  char* filename = StringValuePtr(filename_);
+  FILE* file_ptr = fopen(filename, "wb");
+  png_structp png_ptr;
+  png_infop info_ptr;
+  png_bytep* row_ptr_ptr;
+  png_uint_32 width, height;
+  int color_type;
+  int bit_depth = 8;
+  png_uint_32 y;
+  int n_ch;
+  int n_dims;
+  narray_t* image_nary;
+  uint8_t* image_ptr;
+
+  if (file_ptr == NULL) {
+    rb_raise(rb_eIOError, "Failed to open file '%s'", filename);
+    return Qfalse;
+  }
+
+  if (CLASS_OF(image) != numo_cUInt8) image = rb_funcall(numo_cUInt8, rb_intern("cast"), 1, image);
+  if (!RTEST(nary_check_contiguous(image))) image = nary_dup(image);
+
+  GetNArray(image, image_nary);
+  n_dims = NA_NDIM(image_nary);
+  height = (png_uint_32)NA_SHAPE(image_nary)[0];
+  width = (png_uint_32)NA_SHAPE(image_nary)[1];
+  image_ptr = (uint8_t*)na_get_pointer_for_read(image);
+  n_ch = n_dims == 3 ? (int)NA_SHAPE(image_nary)[2] : 1;
+
+  switch (n_ch) {
+  case 4:
+    color_type = PNG_COLOR_TYPE_RGBA;
+    break;
+  case 3:
+    color_type = PNG_COLOR_TYPE_RGB;
+    break;
+  case 2:
+    color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+    break;
+  default:
+    color_type = PNG_COLOR_TYPE_GRAY;
+    break;
+  }
+
+  png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+  if (png_ptr == NULL) {
+    fclose(file_ptr);
+    rb_raise(rb_eNoMemError, "Failed to allocate memory.");
+    return Qfalse;
+  }
+  info_ptr = png_create_info_struct(png_ptr);
+  if (info_ptr == NULL) {
+    png_destroy_read_struct(&png_ptr, NULL, NULL);
+    fclose(file_ptr);
+    rb_raise(rb_eNoMemError, "Failed to allocate memory.");
+    return Qfalse;
+  }
+  if (setjmp(png_jmpbuf(png_ptr))) {
+    png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+    fclose(file_ptr);
+    return Qfalse;
+  }
+
+  png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, color_type, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
+               PNG_FILTER_TYPE_DEFAULT);
+
+  row_ptr_ptr = png_malloc(png_ptr, height * sizeof(png_bytep));
+  for (y = 0; y < height; y++) {
+    row_ptr_ptr[y] = png_malloc(png_ptr, width * n_ch * sizeof(png_byte));
+    memcpy(row_ptr_ptr[y], image_ptr + y * width * n_ch, width * n_ch);
+  }
+
+  png_init_io(png_ptr, file_ptr);
+  png_set_rows(png_ptr, info_ptr, row_ptr_ptr);
+  png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
+
+  fclose(file_ptr);
+  for (y = 0; y < height; y++) png_free(png_ptr, row_ptr_ptr[y]);
+  png_free(png_ptr, row_ptr_ptr);
+  png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+
+  RB_GC_GUARD(image);
+  RB_GC_GUARD(filename_);
+
+  return Qtrue;
+}
+
+struct my_error_mgr {
+  struct jpeg_error_mgr pub;
+  jmp_buf setjmp_buffer;
+};
+
+static void my_error_exit(j_common_ptr cinfo) {
+  struct my_error_mgr* my_err = (struct my_error_mgr*)cinfo->err;
+  (*cinfo->err->output_message)(cinfo);
+  longjmp(my_err->setjmp_buffer, 1);
+}
+
+static VALUE magro_io_read_jpg(VALUE self, VALUE filename_) {
+  char* filename = StringValuePtr(filename_);
+  FILE* file_ptr = fopen(filename, "rb");
+  struct jpeg_decompress_struct jpeg;
+  struct my_error_mgr err;
+  unsigned int width, height;
+  int n_colors;
+  size_t shape[3] = {0};
+  int n_dims;
+  unsigned int y;
+  VALUE nary;
+  uint8_t* nary_ptr;
+  JSAMPLE* tmp;
+
+  if (file_ptr == NULL) {
+    rb_raise(rb_eIOError, "Failed to open file '%s'", filename);
+    return Qnil;
+  }
+
+  jpeg.err = jpeg_std_error(&err.pub);
+  err.pub.error_exit = my_error_exit;
+  if (setjmp(err.setjmp_buffer)) {
+    rb_raise(rb_eIOError, "Error happened while reading file '%s'", filename);
+    return Qnil;
+  }
+
+  jpeg_create_decompress(&jpeg);
+  jpeg_stdio_src(&jpeg, file_ptr);
+  jpeg_read_header(&jpeg, TRUE);
+  jpeg_start_decompress(&jpeg);
+
+  width = jpeg.output_width;
+  height = jpeg.output_height;
+  n_colors = jpeg.out_color_components;
+
+  n_dims = n_colors == 1 ? 2 : 3;
+  shape[0] = height;
+  shape[1] = width;
+  shape[2] = n_colors;
+  nary = rb_narray_new(numo_cUInt8, n_dims, shape);
+  nary_ptr = (uint8_t*)na_get_pointer_for_write(nary);
+
+  for (y = 0; y < height; y++) {
+    tmp = nary_ptr + y * width * n_colors;
+    jpeg_read_scanlines(&jpeg, &tmp, 1);
+  }
+
+  fclose(file_ptr);
+  jpeg_finish_decompress(&jpeg);
+  jpeg_destroy_decompress(&jpeg);
+
+  RB_GC_GUARD(filename_);
+
+  return nary;
+}
+
+static VALUE magro_io_save_jpg(int argc, VALUE* argv, VALUE self) {
+  VALUE filename_;
+  VALUE image;
+  VALUE quality_;
+  char* filename;
+  FILE* file_ptr;
+  struct jpeg_compress_struct jpeg;
+  struct my_error_mgr err;
+  narray_t* image_nary;
+  int quality;
+  int n_dims, n_ch;
+  unsigned int width, height, y;
+  uint8_t* image_ptr;
+  JSAMPLE* tmp;
+
+  rb_scan_args(argc, argv, "21", &filename_, &image, &quality_);
+
+  quality = NIL_P(quality_) ? 95 : NUM2INT(quality_);
+
+  filename = StringValuePtr(filename_);
+
+  if (CLASS_OF(image) != numo_cUInt8) image = rb_funcall(numo_cUInt8, rb_intern("cast"), 1, image);
+  if (!RTEST(nary_check_contiguous(image))) image = nary_dup(image);
+
+  jpeg.err = jpeg_std_error(&err.pub);
+  err.pub.error_exit = my_error_exit;
+  if (setjmp(err.setjmp_buffer)) return Qfalse;
+
+  jpeg_create_compress(&jpeg);
+
+  file_ptr = fopen(filename, "wb");
+  if (file_ptr == NULL) {
+    rb_raise(rb_eIOError, "Failed to open file '%s'", filename);
+    jpeg_destroy_compress(&jpeg);
+    return Qfalse;
+  }
+
+  GetNArray(image, image_nary);
+  n_dims = NA_NDIM(image_nary);
+  height = (unsigned int)NA_SHAPE(image_nary)[0];
+  width = (unsigned int)NA_SHAPE(image_nary)[1];
+  image_ptr = (uint8_t*)na_get_pointer_for_read(image);
+  n_ch = n_dims == 3 ? (int)NA_SHAPE(image_nary)[2] : 1;
+
+  jpeg_stdio_dest(&jpeg, file_ptr);
+
+  jpeg.image_height = height;
+  jpeg.image_width = width;
+  jpeg.input_components = n_ch;
+
+  switch (n_ch) {
+  case 3:
+    jpeg.in_color_space = JCS_RGB;
+    break;
+  case 1:
+    jpeg.in_color_space = JCS_GRAYSCALE;
+    break;
+  default:
+    jpeg.in_color_space = JCS_UNKNOWN;
+    break;
+  }
+
+  jpeg_set_defaults(&jpeg);
+
+  jpeg_set_quality(&jpeg, quality, TRUE);
+
+  jpeg_start_compress(&jpeg, TRUE);
+
+  for (y = 0; y < height; y++) {
+    tmp = image_ptr + y * width * n_ch;
+    jpeg_write_scanlines(&jpeg, &tmp, 1);
+  }
+
+  jpeg_finish_compress(&jpeg);
+  jpeg_destroy_compress(&jpeg);
+
+  fclose(file_ptr);
+
+  RB_GC_GUARD(image);
+  RB_GC_GUARD(filename_);
+
+  return Qtrue;
+}
 
 void Init_magro() {
+  /**
+   * Document-module: Magro
+   * Magro is an image processing library in Ruby.
+   */
   mMagro = rb_define_module("Magro");
-
-  init_io_module();
+  /**
+   * Document-module: Magro::IO
+   * IO module provides functions for input and output of image file.
+   */
+  mMagroIO = rb_define_module_under(mMagro, "IO");
+  /**
+   * @!visibility private
+   *
+   * Loads PNG image file.
+   *
+   * @overload read_png(filename) -> Numo::UInt8
+   *   @param filename [String] File path of PNG image file.
+   *
+   * @raise [IOError] This error is raised when failed to read image file.
+   * @raise [NoMemoryError] If memory allocation of image data fails, this error is raised.
+   * @return [Numo::UInt8] (shape: [height, width, n_channels]) Loaded image.
+   */
+  rb_define_module_function(mMagroIO, "read_png", RUBY_METHOD_FUNC(magro_io_read_png), 1);
+  /**
+   * @!visibility private
+   *
+   * Saves PNG image file.
+   *
+   * @overload save_png(filename, image) -> Boolean
+   *   @param filename [String] Path to image file to be saved.
+   *   @param image [Numo::UInt8] (shape: [height, width, n_channels]) Image data to be saved.
+   *
+   * @raise [IOError] This error is raised when failed to write image file.
+   * @raise [NoMemoryError] If memory allocation of image data fails, this error is raised.
+   * @return [Boolean] true if file save is successful.
+   */
+  rb_define_module_function(mMagroIO, "save_png", RUBY_METHOD_FUNC(magro_io_save_png), 2);
+  /**
+   * @!visibility private
+   *
+   * Loads JPEG image file.
+   *
+   * @overload read_jpg(filename) -> Numo::UInt8
+   *   @param filename [String] File path of JPEG image file.
+   *
+   * @raise [IOError] This error is raised when failed to read image file.
+   * @return [Numo::UInt8] (shape: [height, width, n_channels]) Loaded image.
+   */
+  rb_define_module_function(mMagroIO, "read_jpg", RUBY_METHOD_FUNC(magro_io_read_jpg), 1);
+  /**
+   * @!visibility private
+   *
+   * Saves JPEG image file.
+   *
+   * @overload save_jpg(filename, image, quality) -> Boolean
+   *   @param filename [String] Path to image file to be saved.
+   *   @param image [Numo::UInt8] (shape: [height, width, n_channels]) Image data to be saved.
+   *   @param quality [Integer/Nil] Quality parameter of jpeg image that takes a value between 0 to 100.
+   *
+   * @return [Boolean] true if file save is successful.
+   */
+  rb_define_module_function(mMagroIO, "save_jpg", RUBY_METHOD_FUNC(magro_io_save_jpg), -1);
 }

data/ext/magro/magro.h

@@ -1,8 +1,48 @@
+/**
+ * Copyright (c) 2019-2022 Atsushi Tatsuma
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the copyright holder nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
 #ifndef MAGRO_H
 #define MAGRO_H 1
 
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <setjmp.h>
+
+#include <jpeglib.h>
+#include <png.h>
+
 #include <ruby.h>
 
-#include "imgrw.h"
+#include <numo/narray.h>
+#include <numo/template.h>
 
 #endif /* MAGRO_H */

data/lib/magro/io.rb

@@ -48,7 +48,7 @@ module Magro
     # @param image [Numo::UInt8] (shape: [height, width, n_channels]) Image data to be saved.
     # @param quality [Integer] Quality parameter of jpeg image that takes a value between 0 to 100.
     # @raise [ArgumentError] If filename is not String or image is not Numo::NArray, this error is raised.
-    # @raise [IOError] This error is raised when failed to read image file.
+    # @raise [IOError] This error is raised when failed to write image file.
     # @raise [NoMemoryError] If memory allocation of image data fails, this error is raised.
     # @return [Boolean] true if file save is successful.
     def imsave(filename, image, quality: nil)

data/lib/magro/version.rb

@@ -3,5 +3,5 @@
 # Magro is an image processing library in Ruby.
 module Magro
   # The version of Magro you are using.
-  VERSION = '0.5.1'
+  VERSION = '0.6.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: magro
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - yoshoku
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-06-28 00:00:00.000000000 Z
+date: 2022-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -36,24 +36,10 @@ extensions:
 - ext/magro/extconf.rb
 extra_rdoc_files: []
 files:
-- ".clang-format"
-- ".coveralls.yml"
-- ".github/workflows/build.yml"
-- ".github/workflows/coverage.yml"
-- ".gitignore"
-- ".rspec"
 - CHANGELOG.md
-- CODE_OF_CONDUCT.md
-- Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile
-- Steepfile
-- bin/console
-- bin/setup
 - ext/magro/extconf.rb
-- ext/magro/imgrw.c
-- ext/magro/imgrw.h
 - ext/magro/magro.c
 - ext/magro/magro.h
 - lib/magro.rb
@@ -61,12 +47,10 @@ files:
 - lib/magro/io.rb
 - lib/magro/transform.rb
 - lib/magro/version.rb
-- magro.gemspec
 - sig/magro.rbs
 - sig/magro/filter.rbs
 - sig/magro/io.rbs
 - sig/magro/transform.rbs
-- sig/patch.rbs
 homepage: https://github.com/yoshoku/magro
 licenses:
 - BSD-3-Clause
@@ -75,7 +59,7 @@ metadata:
   source_code_uri: https://github.com/yoshoku/magro
   changelog_uri: https://github.com/yoshoku/magro/blob/main/CHANGELOG.md
   documentation_uri: https://yoshoku.github.io/magro/doc/
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -90,8 +74,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.21
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: Magro is a minimal image processing library for Ruby.
 test_files: []