bonanza-ruby-opencv 0.0.13.20160621111908 → 0.0.13.20200923185241

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9db0b94905f6087fa029acc9c129281308832420
-  data.tar.gz: 0a14b2216cfe58ca0eac122a4771fec9c5ef667d
+SHA256:
+  metadata.gz: b1e5119a7a5d2271845769949eddcaccd0a519c3afd373f967b4b7c6a19880a6
+  data.tar.gz: 05c6480bfdc0f25d07fdc6e4e1d79ee6be8a1ddf94f2d9aabcc7654bd3f6598e
 SHA512:
-  metadata.gz: 6c792de42ba8042d613b1821bf12f437bf7354736eb4347f458946eb8957f19cda09f3f642d26ed8e27b08d9bb229aa84b3a4c25603f3714b96b509db7fa0683
-  data.tar.gz: 62157065d7794ce7f3ec08ad8bd4fe94d7b17632621d7bc239bc7f79ffb7d8be81f10e5ba93d8afb38b018d2fe14f6411a965959965ee4eb0f8dc40964a14a16
+  metadata.gz: 645336822d5bed3ce63d416646bfa96fe040d4f868af99546e0247abdbc1103be5fac7009340a759271bb2c2be16a7ec4d5e74328e50a9f7fe055c641906da6d
+  data.tar.gz: 9ecc114298d4f79d2d57f30bb8630125c089104d9a7aee0c14dd3b95826f6cc19c590e64b5eae380a56397e7143f81749c7e0227e4a9f2ffd92d4a5180e4d25d

data/ext/opencv/cvchain.cpp

@@ -62,7 +62,11 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
     raise_cverror(e);
   }
   CvSeq* self_ptr = CVSEQ(self);
+#ifdef RUBY_INTEGER_UNIFICATION
+  cCvSeq::register_elem_class(self, rb_cInteger);
+#else
   cCvSeq::register_elem_class(self, rb_cFixnum);
+#endif
   register_root_object(self_ptr, storage_value);
 
   return self;

data/ext/opencv/cvhistogram.cpp

@@ -95,19 +95,19 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
 
   rb_scan_args(argc, argv, "32", &_dims, &_sizes, &_type, &_ranges, &_uniform);
   int sizes_len = RARRAY_LEN(_sizes);
-  sizes = ALLOCA_N(int, sizes_len);
+  sizes = RB_ALLOC_N(int, sizes_len);
 
   if (NIL_P(_ranges)) {
     sizes = ary2intptr(_sizes, sizes);
     ranges = NULL;
   }
   else {
-    ranges = ALLOCA_N(float*, sizes_len);
+    ranges = RB_ALLOC_N(float*, sizes_len);
     VALUE* range_ptr = RARRAY_PTR(_ranges);
     int i;
     for (i = 0; i < sizes_len; i++) {
       sizes[i] = NUM2INT(RARRAY_PTR(_sizes)[i]);
-      ranges[i] = ary2fltptr(range_ptr[i], ALLOCA_N(float, 2));
+      ranges[i] = ary2fltptr(range_ptr[i], RB_ALLOC_N(float, 2));
     }
   }
   uniform = TRUE_OR_FALSE(_uniform, 1);
@@ -193,7 +193,7 @@ rb_calc_hist_bang(int argc, VALUE* argv, VALUE self)
   rb_scan_args(argc, argv, "12", &images, &accumulate, &mask);
   Check_Type(images, T_ARRAY);
   int num_images = RARRAY_LEN(images);
-  IplImage** img = ALLOCA_N(IplImage*, num_images);
+  IplImage** img = RB_ALLOC_N(IplImage*, num_images);
   VALUE* images_ptr = RARRAY_PTR(images);
   for (int i = 0; i < num_images; i++) {
     img[i] = IPLIMAGE_WITH_CHECK(images_ptr[i]);
@@ -226,7 +226,7 @@ VALUE
 rb_aref(VALUE self, VALUE args)
 {
   int num_idx = RARRAY_LEN(args);
-  int* idx = ALLOCA_N(int, num_idx);
+  int* idx = RB_ALLOC_N(int, num_idx);
   VALUE* args_ptr = RARRAY_PTR(args);
   for (int i = 0; i < num_idx; i++) {
     idx[i] = NUM2INT(args_ptr[i]);
@@ -257,6 +257,36 @@ rb_aref(VALUE self, VALUE args)
   return rb_float_new((double)value);
 }
 
+VALUE
+rb_at(VALUE self, VALUE x)
+{
+  float value = 0.0;
+  CvHistogram* self_ptr = CVHISTOGRAM(self);
+  try {
+    value = cvQueryHistValue_1D(self_ptr, NUM2INT(x));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  
+  return rb_float_new((double)value);
+}
+
+VALUE
+rb_at_3d(VALUE self, VALUE x, VALUE y, VALUE z)
+{
+  float value = 0.0;
+  CvHistogram* self_ptr = CVHISTOGRAM(self);
+  try {
+    value = cvQueryHistValue_3D(self_ptr, NUM2INT(x), NUM2INT(y), NUM2INT(z));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  
+  return rb_float_new((double)value);
+}
+
 /*
  * Finds the minimum and maximum histogram bins.
  * @overload min_max_value
@@ -279,8 +309,8 @@ rb_min_max_value(VALUE self)
   int *max_idx = NULL;
   try {
     dims = cvGetDims(self_ptr->bins, NULL);
-    min_idx = ALLOCA_N(int, dims);
-    max_idx = ALLOCA_N(int, dims);
+    min_idx = RB_ALLOC_N(int, dims);
+    max_idx = RB_ALLOC_N(int, dims);
     cvGetMinMaxHistValue(CVHISTOGRAM(self), &min_value, &max_value, min_idx, max_idx);
   }
   catch (cv::Exception& e) {
@@ -493,10 +523,10 @@ rb_set_hist_bin_ranges_bang(int argc, VALUE* argv, VALUE self)
   Check_Type(_ranges, T_ARRAY);
 
   int ranges_size = RARRAY_LEN(_ranges);
-  float** ranges = ALLOCA_N(float*, ranges_size);
+  float** ranges = RB_ALLOC_N(float*, ranges_size);
   VALUE* range_ptr = RARRAY_PTR(_ranges);
   for (int i = 0; i < ranges_size; ++i) {
-    ranges[i] = ary2fltptr(range_ptr[i], ALLOCA_N(float, 2));
+    ranges[i] = ary2fltptr(range_ptr[i], RB_ALLOC_N(float, 2));
   }
   int uniform = TRUE_OR_FALSE(_uniform, 1);
 
@@ -530,7 +560,7 @@ rb_calc_back_project(VALUE self, VALUE image)
     return Qnil;
   }
   
-  IplImage** img = ALLOCA_N(IplImage*, num_images);
+  IplImage** img = RB_ALLOC_N(IplImage*, num_images);
   VALUE* image_ptr = RARRAY_PTR(image);
   for (int i = 0; i < num_images; ++i) {
     img[i] = IPLIMAGE_WITH_CHECK(image_ptr[i]);
@@ -577,7 +607,7 @@ rb_calc_back_project_patch(VALUE self, VALUE image, VALUE patch_size, VALUE meth
     return Qnil;
   }
   
-  IplImage** img = ALLOCA_N(IplImage*, num_images);
+  IplImage** img = RB_ALLOC_N(IplImage*, num_images);
   VALUE* image_ptr = RARRAY_PTR(image);
   for (int i = 0; i < num_images; ++i) {
     img[i] = IPLIMAGE_WITH_CHECK(image_ptr[i]);
@@ -682,6 +712,8 @@ init_ruby_class()
   rb_define_method(rb_klass, "calc_hist", RUBY_METHOD_FUNC(rb_calc_hist), -1);
   rb_define_method(rb_klass, "calc_hist!", RUBY_METHOD_FUNC(rb_calc_hist_bang), -1);
   rb_define_method(rb_klass, "[]", RUBY_METHOD_FUNC(rb_aref), -2);
+  rb_define_method(rb_klass, "at", RUBY_METHOD_FUNC(rb_at), 1);
+  rb_define_method(rb_klass, "at_3d", RUBY_METHOD_FUNC(rb_at_3d), 3);
   rb_define_alias(rb_klass, "query_hist_value", "[]");
   rb_define_method(rb_klass, "min_max_value", RUBY_METHOD_FUNC(rb_min_max_value), 0);
   rb_define_method(rb_klass, "copy_hist", RUBY_METHOD_FUNC(rb_copy_hist), 0);

data/ext/opencv/cvmat.cpp

@@ -1137,14 +1137,11 @@ rb_set_data(VALUE self, VALUE data)
   int depth = CV_MAT_DEPTH(self_ptr->type);
 
   if (TYPE(data) == T_STRING) {
-    if (depth != CV_8U)
-      rb_raise(rb_eArgError, "Invalid CvMat depth");
-      
     if (!CV_IS_MAT_CONT(self_ptr->type))
       rb_raise(rb_eArgError, "CvMat must be continuous");
       
     const int dataLength = RSTRING_LEN(data);
-    if (dataLength != self_ptr->width * self_ptr->height * CV_MAT_CN(self_ptr->type))
+    if (dataLength != self_ptr->width * self_ptr->height * CV_ELEM_SIZE(self_ptr->type))
       rb_raise(rb_eArgError, "Invalid data string length");
     
     memcpy(self_ptr->data.ptr, RSTRING_PTR(data), dataLength);
@@ -2101,12 +2098,21 @@ VALUE
 rb_cmp_internal(VALUE self, VALUE val, VALUE dest, int operand)
 {
   CvArr* self_ptr = CVARR(self);
+
+  if (CV_MAT_CN(cvGetElemType(self_ptr)) != 1) {
+    rb_raise(rb_eArgError, "self should be a single-channel CvMat.");
+  }
+
   try {
-    if (rb_obj_is_kind_of(val, rb_klass))
-      cvCmp(self_ptr, CVARR(val), CVARR(dest), operand);
-    else if (CV_MAT_CN(cvGetElemType(self_ptr)) == 1 && rb_obj_is_kind_of(val, rb_cNumeric))
+    if (rb_obj_is_kind_of(val, rb_klass)) {
+      CvArr* val_ptr = CVARR(val);
+      if (CV_MAT_CN(cvGetElemType(val_ptr)) != 1) {
+        rb_raise(rb_eArgError, "val should be a single-channel CvMat.");
+      }
+      cvCmp(self_ptr, val_ptr, CVARR(dest), operand);
+    } else if (rb_obj_is_kind_of(val, rb_cNumeric)) {
       cvCmpS(self_ptr, NUM2DBL(val), CVARR(dest), operand);
-    else {
+    } else {
       VALUE mat = new_mat_kind_object(cvGetSize(CVARR(self)), self);
       cvSet(CVARR(mat), VALUE_TO_CVSCALAR(val));
       cvCmp(self_ptr, CVARR(mat), CVARR(dest), operand);
@@ -3415,14 +3421,14 @@ rb_fill_poly_bang(int argc, VALUE *argv, VALUE self)
   Check_Type(polygons, T_ARRAY);
   drawing_option = DRAWING_OPTION(drawing_option);
   num_polygons = RARRAY_LEN(polygons);
-  num_points = ALLOCA_N(int, num_polygons);
+  num_points = RB_ALLOC_N(int, num_polygons);
 
-  p = ALLOCA_N(CvPoint*, num_polygons);
+  p = RB_ALLOC_N(CvPoint*, num_polygons);
   for (j = 0; j < num_polygons; ++j) {
     points = rb_ary_entry(polygons, j);
     Check_Type(points, T_ARRAY);
     num_points[j] = RARRAY_LEN(points);
-    p[j] = ALLOCA_N(CvPoint, num_points[j]);
+    p[j] = RB_ALLOC_N(CvPoint, num_points[j]);
     for (i = 0; i < num_points[j]; ++i) {
       p[j][i] = VALUE_TO_CVPOINT(rb_ary_entry(points, i));
     }
@@ -3488,7 +3494,7 @@ rb_fill_convex_poly_bang(int argc, VALUE *argv, VALUE self)
   Check_Type(points, T_ARRAY);
   drawing_option = DRAWING_OPTION(drawing_option);
   num_points = RARRAY_LEN(points);
-  p = ALLOCA_N(CvPoint, num_points);
+  p = RB_ALLOC_N(CvPoint, num_points);
   for (i = 0; i < num_points; ++i)
     p[i] = VALUE_TO_CVPOINT(rb_ary_entry(points, i));
 
@@ -3564,14 +3570,14 @@ rb_poly_line_bang(int argc, VALUE *argv, VALUE self)
   Check_Type(polygons, T_ARRAY);
   drawing_option = DRAWING_OPTION(drawing_option);
   num_polygons = RARRAY_LEN(polygons);
-  num_points = ALLOCA_N(int, num_polygons);
-  p = ALLOCA_N(CvPoint*, num_polygons);
+  num_points = RB_ALLOC_N(int, num_polygons);
+  p = RB_ALLOC_N(CvPoint*, num_polygons);
 
   for (j = 0; j < num_polygons; ++j) {
     points = rb_ary_entry(polygons, j);
     Check_Type(points, T_ARRAY);
     num_points[j] = RARRAY_LEN(points);
-    p[j] = ALLOCA_N(CvPoint, num_points[j]);
+    p[j] = RB_ALLOC_N(CvPoint, num_points[j]);
     for (i = 0; i < num_points[j]; ++i) {
       p[j][i] = VALUE_TO_CVPOINT(rb_ary_entry(points, i));
     }
@@ -3980,7 +3986,7 @@ rb_find_chessboard_corners(int argc, VALUE *argv, VALUE self)
 
   int flag = NIL_P(flag_val) ? CV_CALIB_CB_ADAPTIVE_THRESH : NUM2INT(flag_val);
   CvSize pattern_size = VALUE_TO_CVSIZE(pattern_size_val);
-  CvPoint2D32f* corners = ALLOCA_N(CvPoint2D32f, pattern_size.width * pattern_size.height);
+  CvPoint2D32f* corners = RB_ALLOC_N(CvPoint2D32f, pattern_size.width * pattern_size.height);
   int num_found_corners = 0;
   int pattern_was_found = 0;
   try {
@@ -4016,7 +4022,7 @@ rb_find_corner_sub_pix(VALUE self, VALUE corners, VALUE win_size, VALUE zero_zon
 {
   Check_Type(corners, T_ARRAY);
   int count = RARRAY_LEN(corners);
-  CvPoint2D32f* corners_buff = ALLOCA_N(CvPoint2D32f, count);
+  CvPoint2D32f* corners_buff = RB_ALLOC_N(CvPoint2D32f, count);
   VALUE* corners_ptr = RARRAY_PTR(corners);
 
   for (int i = 0; i < count; i++) {
@@ -4325,8 +4331,8 @@ rb_get_perspective_transform(VALUE self, VALUE source, VALUE dest)
 
   int count = RARRAY_LEN(source);
 
-  CvPoint2D32f* source_buff = ALLOCA_N(CvPoint2D32f, count);
-  CvPoint2D32f* dest_buff = ALLOCA_N(CvPoint2D32f, count);
+  CvPoint2D32f* source_buff = RB_ALLOC_N(CvPoint2D32f, count);
+  CvPoint2D32f* dest_buff = RB_ALLOC_N(CvPoint2D32f, count);
 
   for (int i = 0; i < count; i++) {
     source_buff[i] = *(CVPOINT2D32F(RARRAY_PTR(source)[i]));
@@ -5192,6 +5198,35 @@ rb_flood_fill_bang(int argc, VALUE *argv, VALUE self)
   return rb_ary_new3(3, self, cCvRect::new_object(cvRect(rect.x, rect.y, rect.width, rect.height)), mask);
 }
 
+VALUE
+rb_flood_fill_mask(VALUE self, VALUE seed_point, VALUE mask, VALUE lo_diff, VALUE up_diff, VALUE connectivity, VALUE fixed_range)
+{
+  int flags = NUM2INT(connectivity);
+  if (RTEST(fixed_range)) {
+    flags |= CV_FLOODFILL_FIXED_RANGE;
+  }
+  flags |= CV_FLOODFILL_MASK_ONLY;
+  cv::Rect rect;
+  try {
+    cv::Mat selfMat(CVMAT(self));
+    cv::Mat maskMat(CVMAT(mask));
+
+    cv::floodFill(
+      selfMat,
+      maskMat,
+      cv::Point(VALUE_TO_CVPOINT(seed_point)),
+      cv::Scalar(cvScalar(0)),
+      &rect,
+      cv::Scalar(NIL_P(lo_diff) ? cvScalar(0) : VALUE_TO_CVSCALAR(lo_diff)),
+      cv::Scalar(NIL_P(up_diff) ? cvScalar(0) : VALUE_TO_CVSCALAR(up_diff)),
+      flags);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return cCvRect::new_object(cvRect(rect.x, rect.y, rect.width, rect.height));
+}
+
 /*
  * Finds contours in binary image.
  *
@@ -5340,7 +5375,7 @@ rb_draw_chessboard_corners_bang(VALUE self, VALUE pattern_size, VALUE corners, V
 {
   Check_Type(corners, T_ARRAY);
   int count = RARRAY_LEN(corners);
-  CvPoint2D32f* corners_buff = ALLOCA_N(CvPoint2D32f, count);
+  CvPoint2D32f* corners_buff = RB_ALLOC_N(CvPoint2D32f, count);
   VALUE* corners_ptr = RARRAY_PTR(corners);
   for (int i = 0; i < count; i++) {
     corners_buff[i] = *(CVPOINT2D32F(corners_ptr[i]));
@@ -5432,6 +5467,19 @@ rb_watershed(VALUE self, VALUE markers)
   return markers;
 }
 
+VALUE
+rb_kmeans(VALUE self, VALUE k, VALUE termcrit)
+{
+  VALUE labels = new_object(CVMAT(self)->height, 1, CV_32SC1);
+  try {
+    cvKMeans2(CVARR(self), NUM2INT(k), CVARR(labels), *CVTERMCRITERIA(termcrit));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return labels;
+}
+
 /*
  * call-seq:
  *   grab_cut -> cvmat(mask:cv8uc1)
@@ -6018,9 +6066,9 @@ rb_snake_image(int argc, VALUE *argv, VALUE self)
 	(RARRAY_LEN(beta) != length) ||
 	(RARRAY_LEN(gamma) != length))
       rb_raise(rb_eArgError, "alpha, beta, gamma should be same size of points");
-    a = ALLOCA_N(float, length);
-    b = ALLOCA_N(float, length);
-    c = ALLOCA_N(float, length);
+    a = RB_ALLOC_N(float, length);
+    b = RB_ALLOC_N(float, length);
+    c = RB_ALLOC_N(float, length);
     for (i = 0; i < length; ++i) {
       a[i] = (float)NUM2DBL(RARRAY_PTR(alpha)[i]);
       b[i] = (float)NUM2DBL(RARRAY_PTR(beta)[i]);
@@ -6696,7 +6744,7 @@ init_ruby_class()
   rb_define_method(rb_klass, "range", RUBY_METHOD_FUNC(rb_range), 2);
   rb_define_method(rb_klass, "range!", RUBY_METHOD_FUNC(rb_range_bang), 2);
 
-  rb_define_method(rb_klass, "reshape", RUBY_METHOD_FUNC(rb_reshape), -1);
+  rb_define_method(rb_klass, "reshape", RUBY_METHOD_FUNC(rb_reshape), 1);
   rb_define_method(rb_klass, "repeat", RUBY_METHOD_FUNC(rb_repeat), 1);
   rb_define_method(rb_klass, "flip", RUBY_METHOD_FUNC(rb_flip), -1);
   rb_define_method(rb_klass, "flip!", RUBY_METHOD_FUNC(rb_flip_bang), -1);
@@ -6832,6 +6880,7 @@ init_ruby_class()
 
   rb_define_method(rb_klass, "flood_fill", RUBY_METHOD_FUNC(rb_flood_fill), -1);
   rb_define_method(rb_klass, "flood_fill!", RUBY_METHOD_FUNC(rb_flood_fill_bang), -1);
+  rb_define_method(rb_klass, "flood_fill_mask", RUBY_METHOD_FUNC(rb_flood_fill_mask), 6);
   rb_define_method(rb_klass, "find_contours", RUBY_METHOD_FUNC(rb_find_contours), -1);
   rb_define_method(rb_klass, "find_contours!", RUBY_METHOD_FUNC(rb_find_contours_bang), -1);
   rb_define_method(rb_klass, "draw_contours", RUBY_METHOD_FUNC(rb_draw_contours), -1);
@@ -6840,6 +6889,7 @@ init_ruby_class()
   rb_define_method(rb_klass, "draw_chessboard_corners!", RUBY_METHOD_FUNC(rb_draw_chessboard_corners_bang), 3);
   rb_define_method(rb_klass, "pyr_mean_shift_filtering", RUBY_METHOD_FUNC(rb_pyr_mean_shift_filtering), -1);
   rb_define_method(rb_klass, "watershed", RUBY_METHOD_FUNC(rb_watershed), 1);
+  rb_define_method(rb_klass, "kmeans", RUBY_METHOD_FUNC(rb_kmeans), 2);
   rb_define_method(rb_klass, "grab_cut", RUBY_METHOD_FUNC(rb_grab_cut), 6);
   rb_define_method(rb_klass, "grab_cut2", RUBY_METHOD_FUNC(rb_grab_cut2), 10);
 

data/ext/opencv/cvseq.cpp

@@ -88,7 +88,11 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
     raise_typeerror(klass, rb_cClass);
 
   int type = 0, size = 0;
+#ifdef RUBY_INTEGER_UNIFICATION
+  if (klass == rb_cInteger) {
+#else
   if (klass == rb_cFixnum) {
+#endif
     type = CV_SEQ_ELTYPE_INDEX;
     size = sizeof(int);
   }
@@ -170,7 +174,11 @@ rb_aref(VALUE self, VALUE index)
 
   VALUE result = Qnil;
   try {
+#ifdef RUBY_INTEGER_UNIFICATION
+    if (seqblock_class(self) == rb_cInteger)
+#else
     if (seqblock_class(self) == rb_cFixnum)
+#endif
       result = INT2NUM(*CV_GET_SEQ_ELEM(int, seq, idx));
     else
       result = REFER_OBJECT(seqblock_class(self), cvGetSeqElem(seq, idx), self);
@@ -352,7 +360,11 @@ rb_pop(VALUE self)
   VALUE object = Qnil;
   VALUE klass = seqblock_class(self);
   try {
+#ifdef RUBY_INTEGER_UNIFICATION
+    if (klass == rb_cInteger) {
+#else
     if (klass == rb_cFixnum) {
+#endif
       int n = 0;
       cvSeqPop(seq, &n);
       object = INT2FIX(n);
@@ -420,7 +432,11 @@ rb_shift(VALUE self)
 
   VALUE object = Qnil;
   try {
+#ifdef RUBY_INTEGER_UNIFICATION
+    if (seqblock_class(self) == rb_cInteger) {
+#else
     if (seqblock_class(self) == rb_cFixnum) {
+#endif
       int n = 0;
       cvSeqPopFront(seq, &n);
       object = INT2NUM(n);
@@ -456,7 +472,11 @@ rb_each(VALUE self)
   if (seq->total > 0) {
     VALUE klass = seqblock_class(self);
     try {
+#ifdef RUBY_INTEGER_UNIFICATION
+      if (klass == rb_cInteger)
+#else
       if (klass == rb_cFixnum)
+#endif
 	for (int i = 0; i < seq->total; ++i)
 	  rb_yield(INT2NUM(*CV_GET_SEQ_ELEM(int, seq, i)));
       else
@@ -501,7 +521,11 @@ rb_insert(VALUE self, VALUE index, VALUE object)
   if (CLASS_OF(object) != klass)
     rb_raise(rb_eTypeError, "arguments should be %s.", rb_class2name(klass));
   try {
+#ifdef RUBY_INTEGER_UNIFICATION
+    if (klass == rb_cInteger) {
+#else
     if (klass == rb_cFixnum) {
+#endif
       int n = NUM2INT(object);
       cvSeqInsert(seq, NUM2INT(index), &n);
     }

data/ext/opencv/iplconvkernel.cpp

@@ -75,7 +75,7 @@ rb_initialize(int argc, VALUE *argv, VALUE self)
     if (NIL_P(values))
       rb_raise(rb_eArgError, "argument 6 (values) should not be nil when the shape is :custom.");
     num_values = RARRAY_LEN(values);
-    _values = ALLOCA_N(int, num_values);
+    _values = RB_ALLOC_N(int, num_values);
     VALUE *values_ptr = RARRAY_PTR(values);
     for (int i = 0; i < num_values; ++i)
       _values[i] = NUM2INT(values_ptr[i]);

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: bonanza-ruby-opencv
 version: !ruby/object:Gem::Version
-  version: 0.0.13.20160621111908
+  version: 0.0.13.20200923185241
 platform: ruby
 authors:
 - lsxi
 - ser1zw
 - pcting
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-06-21 00:00:00.000000000 Z
+date: 2020-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -328,7 +328,7 @@ homepage: https://github.com/ruby-opencv/ruby-opencv/
 licenses:
 - The BSD License
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--main"
 - README.md
@@ -345,9 +345,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.1
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
 summary: OpenCV wrapper for Ruby
 test_files: