magro 0.5.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1383da33f22a42bc1dbf7ed16cd1f6d21d0e8444967fb027b29bb39dd189d836
-  data.tar.gz: 710cb0248ab131d7a5cfc6671b0ec2e83f335287221dfe795887bf3784b0a682
+  metadata.gz: 461bbd071fe195f5edc86daf605b89b021aa97a8164a060e2239f9c7eef57b77
+  data.tar.gz: 0dc546f4643257704deb3e31dbdf1d2dd0dc42405d35386babcab59c3ab618aa
 SHA512:
-  metadata.gz: c3bb0a6c16df89efa22b8e057b425fba66235c826f9d2fcaca74d8191825f8b6153d440fe1edda003b311cef313b2ec8b7a817d3a7e54b86f182474bad26899f
-  data.tar.gz: 804a97560558d95d56a9867c4a1b36275a1aaca62a872a340ba2eb2a765a3b9e120e072ddc8a6d923b12b20b304f2b25e0e83d957fbe4b3dbf72a0bfe618c471
+  metadata.gz: 19756e1ccb2b703de929a8c589e249442ae8901c12d095a8a9976c8e8c49593a55a6ba1267a1696cacbcbb15dc6a4d210cee11362854f8c72181a54ecb10f24a
+  data.tar.gz: 89695893f37e8e69cc2470a7e09f0b064f447df4293773218104b91a95a59033395d72f2a0b12bf1b83858841e3cefa7e8958c67206d2969f063bda411837260

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+# 0.6.1
+
+- Refactor codes and configs with RuboCop.
+
+# 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.
+
 # 0.5.0
 - Add type declaration files.
 - Refactor some codes.

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

@@ -4,7 +4,7 @@
 [![Coverage Status](https://coveralls.io/repos/github/yoshoku/magro/badge.svg?branch=main)](https://coveralls.io/github/yoshoku/magro?branch=main)
 [![Gem Version](https://badge.fury.io/rb/magro.svg)](https://badge.fury.io/rb/magro)
 [![BSD 3-Clause License](https://img.shields.io/badge/License-BSD%203--Clause-orange.svg)](https://github.com/yoshoku/numo-liblinear/blob/main/LICENSE.txt)
-[![Documentation](http://img.shields.io/badge/api-reference-blue.svg)](https://yoshoku.github.io/magro/doc/)
+[![Documentation](https://img.shields.io/badge/api-reference-blue.svg)](https://yoshoku.github.io/magro/doc/)
 
 Magro is a minimal image processing library in Ruby.
 Magro uses [Numo::NArray](https://github.com/ruby-numo/numo-narray) arrays as image objects and
@@ -59,8 +59,8 @@ Or install it yourself as:
 ## Contributing
 
 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.
+This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](https://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/filter.rb

@@ -26,6 +26,7 @@ module Magro
     # @return [Numo::UInt8] (shape: [height, width, n_channels]) Filtered image.
     def filter2d(image, kernel, scale: nil, offset: 0)
       raise ArgumentError, 'Expect class of image to be Numo::NArray.' unless image.is_a?(Numo::NArray)
+
       filter_h, filter_w = kernel.shape
       padded = zero_padding(image, filter_h, filter_w)
       n_channels = image.shape[2]
@@ -46,11 +47,12 @@ module Magro
     # @param arr2 [Numo::NArray] (shape: [row2, col2]) Second input array.
     # @raise [ArgumentError] This error is raised when class of input array is not Numo::NArray.
     # @return [Numo::NArray] (shape: [row1 - row2 + 1, col1 - col2 + 1]) Convolution of arr1 with arr2.
-    def convolve2d(arr1, arr2)
+    def convolve2d(arr1, arr2) # rubocop:disable Metrics/AbcSize
       raise ArgumentError, 'Expect class of first input array to be Numo::NArray.' unless arr1.is_a?(Numo::NArray)
       raise ArgumentError, 'Expect class of second input array to be Numo::NArray.' unless arr2.is_a?(Numo::NArray)
       raise ArgumentError, 'Expect first input array to be 2-dimensional array.' unless arr1.ndim == 2
       raise ArgumentError, 'Expect second input array to be 2-dimensional array.' unless arr2.ndim == 2
+
       row1, col1 = arr1.shape
       row2, col2 = arr2.shape
       # FIXME: lib/numo/narray/extra.rb:1098: warning: Using the last argument as keyword parameters is deprecated
@@ -61,7 +63,7 @@ module Magro
 
     # private
 
-    def zero_padding(image, filter_h, filter_w)
+    def zero_padding(image, filter_h, filter_w) # rubocop:disable Metrics/AbcSize
       image_h, image_w, n_channels = image.shape
       pad_h = filter_h / 2
       pad_w = filter_w / 2