/* * Constructor * * @overload new(seq_flags = CV_SEQ_ELTYPE_POINT | CV_SEQ_KIND_GENERIC, storage = nil) * @param [Fixnum] seq_flags Flags of the created sequence, which are combinations of * the element types and sequence types. * - Element type: * - <tt>CV_SEQ_ELTYPE_POINT</tt>: {CvPoint} * - <tt>CV_32FC2</tt>: {CvPoint2D32f} * - <tt>CV_SEQ_ELTYPE_POINT3D</tt>: {CvPoint3D32f} * - <tt>CV_SEQ_ELTYPE_INDEX</tt>: Fixnum * - <tt>CV_SEQ_ELTYPE_CODE</tt>: Fixnum (Freeman code) * - Sequence type: * - <tt>CV_SEQ_KIND_GENERIC</tt>: Generic sequence * - <tt>CV_SEQ_KIND_CURVE</tt>: Curve * @param [CvMemStorage] storage Sequence location * @return [CvContour] self * @opencv_func cvCreateSeq * @example * seq = CvContour.new(CV_SEQ_ELTYPE_POINT | CV_SEQ_KIND_CURVE) * seq << CvPoint.new(1, 2) * seq << 3 #=> TypeError */ VALUE rb_initialize(int argc, VALUE *argv, VALUE self) { VALUE seq_flags_value, storage_value; rb_scan_args(argc, argv, "02", &seq_flags_value, &storage_value); int seq_flags = 0; if (NIL_P(seq_flags_value)) { seq_flags = CV_SEQ_ELTYPE_POINT | CV_SEQ_KIND_GENERIC; } else { Check_Type(seq_flags_value, T_FIXNUM); seq_flags = FIX2INT(seq_flags_value); } storage_value = CHECK_CVMEMSTORAGE(storage_value); try { DATA_PTR(self) = (CvContour*)cCvSeq::create_seq(seq_flags, sizeof(CvContour), storage_value); } catch (cv::Exception& e) { raise_cverror(e); } return self; }
CvSeq* create_seq(int seq_flags, size_t header_size, VALUE storage_value) { VALUE klass = Qnil; int eltype = seq_flags & CV_SEQ_ELTYPE_MASK; storage_value = CHECK_CVMEMSTORAGE(storage_value); if (!eltype2class(eltype, &klass)) { seq_flags = CV_SEQ_ELTYPE_POINT | CV_SEQ_KIND_GENERIC; } int mat_type = CV_MAT_TYPE(seq_flags); size_t elem_size = (size_t)(CV_ELEM_SIZE(mat_type)); CvSeq* seq = NULL; try { seq = cvCreateSeq(seq_flags, header_size, elem_size, CVMEMSTORAGE(storage_value)); } catch (cv::Exception& e) { raise_cverror(e); } register_elem_class(seq, klass); register_root_object(seq, storage_value); return seq; }
/* * call-seq: * CvSeq.new(type[,storage]) * * Return a new CvSeq. <i>type</i> should be following classes. * * * CvIndex * * CvPoint */ VALUE rb_initialize(int argc, VALUE *argv, VALUE self) { VALUE klass, storage_value; rb_scan_args(argc, argv, "11", &klass, &storage_value); if (!rb_obj_is_kind_of(klass, rb_cClass)) raise_typeerror(klass, rb_cClass); int type = 0, size = 0; if (klass == rb_cFixnum) { type = CV_SEQ_ELTYPE_INDEX; size = sizeof(int); } else if (klass == cCvPoint::rb_class()) { type = CV_SEQ_ELTYPE_POINT; size = sizeof(CvPoint); } else if (klass == cCvPoint2D32f::rb_class()) { type = CV_SEQ_ELTYPE_POINT; size = sizeof(CvPoint2D32f); } else if (klass == cCvPoint3D32f::rb_class()) { type = CV_SEQ_ELTYPE_POINT3D; size = sizeof(CvPoint3D32f); } else rb_raise(rb_eArgError, "unsupport %s class for sequence-block.", rb_class2name(klass)); CvSeq* seq = NULL; if (NIL_P(storage_value)) { storage_value = cCvMemStorage::new_object(0); } else { storage_value = CHECK_CVMEMSTORAGE(storage_value); } try { seq = cvCreateSeq(type, sizeof(CvSeq), size, CVMEMSTORAGE(storage_value)); } catch (cv::Exception& e) { raise_cverror(e); } DATA_PTR(self) = seq; register_elem_class(seq, klass); register_root_object(seq, storage_value); return self; }
CvSeq* create_seq(int seq_flags, size_t header_size, VALUE storage_value) { VALUE klass = Qnil; int eltype = seq_flags & CV_SEQ_ELTYPE_MASK; storage_value = CHECK_CVMEMSTORAGE(storage_value); switch (eltype) { case CV_SEQ_ELTYPE_POINT: klass = cCvPoint::rb_class(); break; case CV_32FC2: klass = cCvPoint2D32f::rb_class(); break; case CV_SEQ_ELTYPE_POINT3D: klass = cCvPoint3D32f::rb_class(); break; case CV_SEQ_ELTYPE_CODE: case CV_SEQ_ELTYPE_INDEX: klass = rb_cFixnum; break; case CV_SEQ_ELTYPE_PPOINT: // or CV_SEQ_ELTYPE_PTR: // Not supported rb_raise(rb_eArgError, "seq_flags %d is not supported.", eltype); break; default: seq_flags = CV_SEQ_ELTYPE_POINT | CV_SEQ_KIND_GENERIC; klass = cCvPoint::rb_class(); break; } int mat_type = CV_MAT_TYPE(seq_flags); size_t elem_size = (size_t)(CV_ELEM_SIZE(mat_type)); CvSeq* seq = NULL; try { seq = cvCreateSeq(seq_flags, header_size, elem_size, CVMEMSTORAGE(storage_value)); } catch (cv::Exception& e) { raise_cverror(e); } register_elem_class(seq, klass); register_root_object(seq, storage_value); return seq; }
/* * call-seq: * detect_objects(image[, options]) -> cvseq(include CvAvgComp object) * detect_objects(image[, options]){|cmp| ... } -> cvseq(include CvAvgComp object) * * Detects objects in the image. This method finds rectangular regions in the * given image that are likely to contain objects the cascade has been trained * for and return those regions as a sequence of rectangles. * * * <i>option</i> should be Hash include these keys. * :scale_factor (should be > 1.0) * The factor by which the search window is scaled between the subsequent scans, * 1.1 mean increasing window by 10%. * :storage * Memory storage to store the resultant sequence of the object candidate rectangles * :flags * Mode of operation. Currently the only flag that may be specified is CV_HAAR_DO_CANNY_PRUNING . * If it is set, the function uses Canny edge detector to reject some image regions that contain * too few or too much edges and thus can not contain the searched object. The particular threshold * values are tuned for face detection and in this case the pruning speeds up the processing * :min_neighbors * Minimum number (minus 1) of neighbor rectangles that makes up an object. * All the groups of a smaller number of rectangles than min_neighbors - 1 are rejected. * If min_neighbors is 0, the function does not any grouping at all and returns all the detected * candidate rectangles, whitch many be useful if the user wants to apply a customized grouping procedure. * :min_size * Minimum window size. By default, it is set to size of samples the classifier has been * trained on (~20x20 for face detection). * :max_size * aximum window size to use. By default, it is set to the size of the image. */ VALUE rb_detect_objects(int argc, VALUE *argv, VALUE self) { VALUE image, options; rb_scan_args(argc, argv, "11", &image, &options); double scale_factor; int flags, min_neighbors; CvSize min_size, max_size; VALUE storage_val; if (NIL_P(options)) { scale_factor = 1.1; flags = 0; min_neighbors = 3; min_size = max_size = cvSize(0, 0); storage_val = cCvMemStorage::new_object(); } else { scale_factor = IF_DBL(LOOKUP_CVMETHOD(options, "scale_factor"), 1.1); flags = IF_INT(LOOKUP_CVMETHOD(options, "flags"), 0); min_neighbors = IF_INT(LOOKUP_CVMETHOD(options, "min_neighbors"), 3); VALUE min_size_val = LOOKUP_CVMETHOD(options, "min_size"); min_size = NIL_P(min_size_val) ? cvSize(0, 0) : VALUE_TO_CVSIZE(min_size_val); VALUE max_size_val = LOOKUP_CVMETHOD(options, "max_size"); max_size = NIL_P(max_size_val) ? cvSize(0, 0) : VALUE_TO_CVSIZE(max_size_val); storage_val = CHECK_CVMEMSTORAGE(LOOKUP_CVMETHOD(options, "storage")); } VALUE result = Qnil; try { IplImage *ipl = IPLIMAGE_WITH_CHECK(image); CvSeq *seq = cvHaarDetectObjects(ipl, CVHAARCLASSIFIERCASCADE(self), CVMEMSTORAGE(storage_val), scale_factor, min_neighbors, flags, min_size, max_size); result = cCvSeq::new_sequence(cCvSeq::rb_class(), seq, cCvAvgComp::rb_class(), storage_val); if (rb_block_given_p()) { for(int i = 0; i < seq->total; ++i) rb_yield(REFER_OBJECT(cCvAvgComp::rb_class(), cvGetSeqElem(seq, i), storage_val)); } } catch (cv::Exception& e) { raise_cverror(e); } return result; }
/* * call-seq: * CvSeq.new(<i>type[,storage]</i>) * * Return a new CvSeq. <i>type</i> should be following classes. * * * CvIndex * * CvPoint */ VALUE rb_initialize(int argc, VALUE *argv, VALUE self) { VALUE klass, storage_value; CvMemStorage *storage; if (rb_scan_args(argc, argv, "11", &klass, &storage_value) > 1) { storage_value = CHECK_CVMEMSTORAGE(storage_value); storage = CVMEMSTORAGE(storage_value); } else storage = cvCreateMemStorage(0); if(!rb_obj_is_kind_of(klass, rb_cClass)) rb_raise(rb_eTypeError, "argument 1 (sequence-block class) should be %s.", rb_class2name(rb_cClass)); int type = 0, size = 0; if (klass == cCvIndex::rb_class()) { type = CV_SEQ_ELTYPE_INDEX; size = sizeof(CvIndex); } else if (klass == cCvPoint::rb_class()) { type = CV_SEQ_ELTYPE_POINT; size = sizeof(CvPoint); } else if (klass == cCvPoint2D32f::rb_class()) { type = CV_SEQ_ELTYPE_POINT; size = sizeof(CvPoint2D32f); } else if (klass == cCvPoint3D32f::rb_class()) { type = CV_SEQ_ELTYPE_POINT3D; size = sizeof(CvPoint3D32f); } // todo: more various class will be support. if (!size) rb_raise(rb_eTypeError, "unsupport %s class for sequence-block.", rb_class2name(klass)); CvSeq* seq = cvCreateSeq(type, sizeof(CvSeq), size, storage); DATA_PTR(self) = seq; resist_class_information_of_sequence(seq, klass); return self; }
VALUE rb_initialize(int argc, VALUE *argv, VALUE self) { CvMemStorage *storage; VALUE storage_value; if (rb_scan_args(argc, argv, "01", &storage_value) > 0) { storage_value = CHECK_CVMEMSTORAGE(storage_value); storage = CVMEMSTORAGE(storage_value); } else storage = rb_cvCreateMemStorage(0); try { DATA_PTR(self) = (CvChain*)cvCreateSeq(CV_SEQ_ELTYPE_CODE, sizeof(CvChain), sizeof(char), storage); } catch (cv::Exception& e) { raise_cverror(e); } return self; }
/* * call-seq: * detect_objects_with_pruning(image[,scale_factor = 1.1, min_neighbor = 3, min_size = CvSize.new(0,0)]) -> cvseq(include CvAvgComp object) * detect_objects_with_pruning(image[,scale_factor = 1.1, min_neighbor = 3, min_size = CvSize.new(0,0)]){|cmp| ... } -> cvseq(include CvAvgComp object) * * Almost same to #detect_objects (Return detected objects). * * Before scanning to image, Canny edge detector to reject some image regions * that contain too few or too much edges, and thus can not contain the searched object. * * note: The particular threshold values are tuned for face detection. * And in this case the pruning speeds up the processing. */ VALUE rb_detect_objects_with_pruning(int argc, VALUE *argv, VALUE self) { VALUE image, storage, scale_factor, min_neighbors, min_size, result; rb_scan_args(argc, argv, "14", &image, &storage, &scale_factor, &min_neighbors, &min_size); if (!rb_obj_is_kind_of(image, cCvMat::rb_class())) rb_raise(rb_eTypeError, "argument 1(target-image) should be %s.", rb_class2name(cCvMat::rb_class())); double scale = IF_DBL(scale_factor, 1.1); if (!(scale > 1.0)) rb_raise(rb_eArgError, "argument 2 (scale factor) must > 1.0."); storage = CHECK_CVMEMSTORAGE(storage); CvSeq *seq = cvHaarDetectObjects(CVMAT(image), CVHAARCLASSIFIERCASCADE(self), CVMEMSTORAGE(storage), scale, IF_INT(min_neighbors, 3), CV_HAAR_DO_CANNY_PRUNING, NIL_P(min_size) ? cvSize(0,0) : VALUE_TO_CVSIZE(min_size)); result = cCvSeq::new_sequence(cCvSeq::rb_class(), seq, cCvAvgComp::rb_class(), storage); if (rb_block_given_p()) { for(int i = 0; i < seq->total; i++) rb_yield(REFER_OBJECT(cCvAvgComp::rb_class(), cvGetSeqElem(seq, i), storage)); } return result; }
/* * Constructor * @overload new(storage = nil) * @param [CvMemStorage] storage Sequence location * @return [CvContour] self * @opencv_func cvCreateSeq */ VALUE rb_initialize(int argc, VALUE *argv, VALUE self) { VALUE storage; rb_scan_args(argc, argv, "01", &storage); if (NIL_P(storage)) storage = cCvMemStorage::new_object(0); else storage = CHECK_CVMEMSTORAGE(storage); try { DATA_PTR(self) = (CvContour*)cvCreateSeq(CV_SEQ_ELTYPE_POINT, sizeof(CvContour), sizeof(CvPoint), CVMEMSTORAGE(storage)); } catch (cv::Exception& e) { raise_cverror(e); } cCvSeq::register_elem_class(self, cCvPoint::rb_class()); register_root_object(CVSEQ(self), storage); return self; }