Class: OpenCV::CvCapture

Inherits:
Data
  • Object
show all
Includes:
Curve, PointSet
Defined in:
ext/opencv/cvcapture.cpp,
ext/opencv/cvcapture.cpp

Overview

Class for video capturing from video files or cameras

Constant Summary collapse

INTERFACE =

:any, :mil, :vfw, :v4l, :v4l2, :fireware, :ieee1394, :dc1394, :cmu1394, :stereo, :tyzx, :tyzx_left, :tyzx_right, :tyzx_color, :tyzx_z, :qt, :qtuicktime

video_interface
APPROX_OPTION = 
approx_option

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Curve

#arc_length, #closed?, #convex?, #hole?, #simple?

Methods included from PointSet

#check_contour_convexity, #contour_area, #convex_hull2, #convexity_defects, #fit_ellipse2, #min_area_rect2, #min_enclosing_circle

Constructor Details

#new(seq_flags = CV_SEQ_ELTYPE_POINT|CV_SEQ_KIND_GENERIC, storage = nil) ⇒ CvContour

Constructor

Examples:

seq = CvContour.new(CV_SEQ_ELTYPE_POINT | CV_SEQ_KIND_CURVE)
seq << CvPoint.new(1, 2)
seq << 3 #=> TypeError

Parameters:

  • seq_flags (Integer) (defaults to: CV_SEQ_ELTYPE_POINT|CV_SEQ_KIND_GENERIC) —

    Flags of the created sequence, which are combinations of the element types and sequence types.

    • Element type:

    • Sequence type:

      • CV_SEQ_KIND_GENERIC: Generic sequence

      • CV_SEQ_KIND_CURVE: Curve

  • storage (CvMemStorage) (defaults to: nil) —

    Sequence location



66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'ext/opencv/cvcontour.cpp', line 66

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;
}

Class Method Details

.open(dev = nil) ⇒ CvCapture

Open video file or a capturing device for video capturing

Parameters:

  • dev (String, Integer, Simbol, nil) (defaults to: nil) —

    Video capturing device

    • If dev is a string (i.e “stream.avi”), reads video stream from a file.

    • If dev is a number or symbol (included in CvCapture::INTERFACE), reads video stream from a device.

    • If dev is a nil, same as CvCapture.open(:any)

Returns:



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'ext/opencv/cvcapture.cpp', line 50

VALUE
rb_open(int argc, VALUE *argv, VALUE self)
{
  VALUE device;
  rb_scan_args(argc, argv, "01", &device);
  CvCapture *capture = 0;
  sCvCapture *scap = new sCvCapture();
  try {
    switch (TYPE(device)) {
    case T_STRING:
      capture = cvCaptureFromFile(StringValueCStr(device));
      break;
    case T_FIXNUM:
      capture = cvCaptureFromCAM(FIX2INT(device));
      break;
    case T_SYMBOL: {
      VALUE cap_index = rb_hash_lookup(rb_const_get(rb_class(), rb_intern("INTERFACE")), device);
      if (NIL_P(cap_index))
        rb_raise(rb_eArgError, "undefined interface.");
      capture = cvCaptureFromCAM(NUM2INT(cap_index));
      break;
    }
    case T_NIL:
      capture = cvCaptureFromCAM(CV_CAP_ANY);
      break;
    }
  }
  catch (cv::Exception& e) {
    raise_cverror(e);
  }
  if (!capture)
    rb_raise(rb_eStandardError, "Invalid capture format.");
  scap->ptr = capture;
  scap->opened = true;
  return Data_Wrap_Struct(rb_klass, 0, cvcapture_free, scap);
}

Instance Method Details

#approx_poly(options) ⇒ CvContour? Also known as: approx

Approximates polygonal curves with desired precision

Parameters:

  • options (Hash) —

    Parameters

Options Hash (options):

  • :method (Symbol) —

    Approximation method (default :dp)

    • :dp - Douglas-Peucker algorithm.

  • :accuracy (Number) —

    Parameter specifying the approximation accuracy. This is the maximum distance between the original curve and its approximation.

  • :recursive (Boolean) —

    Recursion flag. If true, the function approximates all the contours accessible from curve by h_next and v_next links.

Returns:

  • (CvContour) —

    Result of the approximation

  • (nil) —

    Approximation faied



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
 
# File 'ext/opencv/cvcontour.cpp', line 154

VALUE
rb_approx_poly(int argc, VALUE *argv, VALUE self)
{
  VALUE approx_poly_option;
  rb_scan_args(argc, argv, "01", &approx_poly_option);  
  approx_poly_option = APPROX_POLY_OPTION(approx_poly_option);
  VALUE storage = cCvMemStorage::new_object();
  CvSeq *contour = cvApproxPoly(CVCONTOUR(self), sizeof(CvContour), CVMEMSTORAGE(storage),
				APPROX_POLY_METHOD(approx_poly_option),
				APPROX_POLY_ACCURACY(approx_poly_option),
				APPROX_POLY_RECURSIVE(approx_poly_option));

  if (contour && contour->total > 0) {
    return cCvSeq::new_sequence(cCvContour::rb_class(), contour, cCvPoint::rb_class(), storage);
  }
  return Qnil;
}

#avi_ratio ⇒ Number

Get relative position of video file

Returns:

  • (Number) —

    Relative position of video file (0: Start of the film, 1: End of the film)



268
269
270
271
272
 
# File 'ext/opencv/cvcapture.cpp', line 268

VALUE
rb_get_avi_ratio(VALUE self)
{
  return rb_get_capture_property(self, CV_CAP_PROP_POS_AVI_RATIO);
}

#avi_ratio= ⇒ Number

Set relative position of video file

Parameters:

  • value (Number) —

    Relative position of video file (0: Start of the film, 1: End of the film)

Returns:

  • (Number) 


280
281
282
283
284
 
# File 'ext/opencv/cvcapture.cpp', line 280

VALUE
rb_set_avi_ratio(VALUE self, VALUE value)
{
  return rb_set_capture_property(self, CV_CAP_PROP_POS_AVI_RATIO, value);
}

#bounding_rect ⇒ CvRect

Calculates up-right bounding rectangle of point set.

Returns:

  • (CvRect) —

    Bounding rectangle



178
179
180
181
182
183
184
185
186
187
188
189
 
# File 'ext/opencv/cvcontour.cpp', line 178

VALUE
rb_bounding_rect(VALUE self)
{
  CvRect rect;
  try {
    rect = cvBoundingRect(CVCONTOUR(self), 1);
  }
  catch (cv::Exception& e) {
    raise_cverror(e);
  }
  return cCvRect::new_object(rect);
}

#brightness ⇒ Number

Get brightness of the image (only for cameras)

Returns:

  • (Number) —

    Brightness



462
463
464
465
466
 
# File 'ext/opencv/cvcapture.cpp', line 462

VALUE
rb_get_brightness(VALUE self)
{
  return rb_get_capture_property(self, CV_CAP_PROP_BRIGHTNESS);
}

#close ⇒ boolean

Releases an opened video file or a capturing device

Returns:

  • (boolean) —

    False if the device was already closed



92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'ext/opencv/cvcapture.cpp', line 92

VALUE
rb_close(VALUE self)
{
  sCvCapture *scap;
  Data_Get_Struct(self, sCvCapture, scap);
  if (scap->opened) {
    scap->opened = false;
    cvReleaseCapture(&scap->ptr);
    return true;
  } else
    return false;
}

#color ⇒ Number

Returns color of the contour

Returns:

  • (Number) —

    Color of the contour



108
109
110
111
112
 
# File 'ext/opencv/cvcontour.cpp', line 108

VALUE
rb_color(VALUE self)
{
  return INT2NUM(CVCONTOUR(self)->color);
}

#color= ⇒ Object

Set color of the contour

Parameters:

  • value (Number) —

    Color of the contour



119
120
121
122
123
124
 
# File 'ext/opencv/cvcontour.cpp', line 119

VALUE
rb_set_color(VALUE self, VALUE color)
{
  CVCONTOUR(self)->color = NUM2INT(color);
  return self;
}

#contrast ⇒ Number

Get contrast of the image (only for cameras)

Returns:

  • (Number) —

    Contrast



474
475
476
477
478
 
# File 'ext/opencv/cvcapture.cpp', line 474

VALUE
rb_get_contrast(VALUE self)
{
  return rb_get_capture_property(self, CV_CAP_PROP_CONTRAST);
}

#convert_rgb ⇒ Boolean

Get boolean flags indicating whether images should be converted to RGB

Returns:

  • (Boolean) —

    Whether images should be converted to RGB



533
534
535
536
537
538
539
540
541
542
543
544
 
# File 'ext/opencv/cvcapture.cpp', line 533

VALUE
rb_get_convert_rgb(VALUE self)
{
  int flag = 0;
  try {
    flag = (int)cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_CONVERT_RGB);
  }
  catch (cv::Exception& e) {
    raise_cverror(e);
  }
  return flag ? Qtrue : Qfalse;
}

#create_tree(threshold = 0.0) ⇒ CvContourTree

Creates hierarchical representation of contour

Parameters:

  • threshold (Number) (defaults to: 0.0) —

    If <= 0, the method creates full binary tree representation. If > 0, the method creates representation with the precision threshold.

Returns:



199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
 
# File 'ext/opencv/cvcontour.cpp', line 199

VALUE
rb_create_tree(int argc, VALUE *argv, VALUE self)
{
  VALUE threshold, storage;
  rb_scan_args(argc, argv, "01", &threshold);
  storage = cCvMemStorage::new_object();
  CvContourTree *tree = NULL;
  try {
    tree = cvCreateContourTree(CVSEQ(self), CVMEMSTORAGE(storage), IF_DBL(threshold, 0.0));
  }
  catch (cv::Exception& e) {
    raise_cverror(e);
  }
  return cCvSeq::new_sequence(cCvContourTree::rb_class(), (CvSeq*)tree, cCvPoint::rb_class(), storage);
}

#exposure ⇒ Number

Get exposure (only for cameras)

Returns:

  • (Number) —

    Exposure



521
522
523
524
525
 
# File 'ext/opencv/cvcapture.cpp', line 521

VALUE
rb_get_exposure(VALUE self)
{
  return rb_get_capture_property(self, CV_CAP_PROP_EXPOSURE);
}

#format ⇒ Number

Get format of images returned by CvCapture#retrieve

Returns:

  • (Number) —

    format



438
439
440
441
442
 
# File 'ext/opencv/cvcapture.cpp', line 438

VALUE
rb_get_format(VALUE self)
{
  return rb_get_capture_property(self, CV_CAP_PROP_FORMAT);
}

#fourcc ⇒ Number

Get 4 character code of codec. see www.fourcc.org/

Returns:

  • (Number) —

    Codec code



411
412
413
414
415
416
417
418
 
# File 'ext/opencv/cvcapture.cpp', line 411

VALUE
rb_get_fourcc(VALUE self)
{
  char str[4];
  double fourcc = cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_FOURCC);
  sprintf(str, "%s", (char*)&fourcc);
  return rb_str_new2(str);
}

#fps ⇒ Number

Get frame rate

Returns:

  • (Number) —

    Frame rate



386
387
388
389
390
 
# File 'ext/opencv/cvcapture.cpp', line 386

VALUE
rb_get_fps(VALUE self)
{
  return rb_get_capture_property(self, CV_CAP_PROP_FPS);
}

#fps= ⇒ Number

Set frame rate

Parameters:

  • value (Number) —

    Frame rate

Returns:

  • (Number) 


399
400
401
402
403
 
# File 'ext/opencv/cvcapture.cpp', line 399

VALUE
rb_set_fps(VALUE self, VALUE value)
{
  return rb_set_capture_property(self, CV_CAP_PROP_FPS, value);
}

#frame_count ⇒ Number

Get number of frames in video file.

Returns:

  • (Number) —

    Number of frames



426
427
428
429
430
 
# File 'ext/opencv/cvcapture.cpp', line 426

VALUE
rb_get_frame_count(VALUE self)
{
  return rb_get_capture_property(self, CV_CAP_PROP_FRAME_COUNT);
}

#frames ⇒ Number

Get 0-based index of the frame to be decoded/captured next

Returns:

  • (Number) —

    0-based index of the frame to be decoded/captured next



244
245
246
247
248
 
# File 'ext/opencv/cvcapture.cpp', line 244

VALUE
rb_get_frames(VALUE self)
{
  return rb_get_capture_property(self, CV_CAP_PROP_POS_FRAMES);
}

#frames= ⇒ Number

Set 0-based index of the frame to be decoded/captured next

Parameters:

  • value (Number) —

    0-based index of the frame to be decoded/captured next

Returns:

  • (Number) 


257
258
259
260
261
 
# File 'ext/opencv/cvcapture.cpp', line 257

VALUE
rb_set_frames(VALUE self, VALUE value)
{
  return rb_set_capture_property(self, CV_CAP_PROP_POS_FRAMES, value);
}

#gain ⇒ Number

Get gain of the image (only for cameras)

Returns:

  • (Number) —

    Gain



509
510
511
512
513
 
# File 'ext/opencv/cvcapture.cpp', line 509

VALUE
rb_get_gain(VALUE self)
{
  return rb_get_capture_property(self, CV_CAP_PROP_GAIN);
}

#grab ⇒ Boolean

Grabs the next frame from video file or capturing device.

Returns:

  • (Boolean) —

    If grabbing a frame successed, returns true, otherwise returns false.



111
112
113
114
115
116
117
118
119
120
121
122
 
# File 'ext/opencv/cvcapture.cpp', line 111

VALUE
rb_grab(VALUE self)
{
  int grab = 0;
  try {
    grab = cvGrabFrame(CVCAPTURE(self));
  }
  catch (cv::Exception& e) {
    raise_cverror(e);
  }
  return grab ? Qtrue : Qfalse;
}

#height ⇒ Number

Get height of frames in the video stream.

Returns:

  • (Number) —

    Height of frames in the video stream.



361
362
363
364
365
 
# File 'ext/opencv/cvcapture.cpp', line 361

VALUE
rb_get_height(VALUE self)
{
  return rb_get_capture_property(self, CV_CAP_PROP_FRAME_HEIGHT);
}

#height= ⇒ Number

Set height of frames in the video stream.

Parameters:

  • value (Number) —

    Height of frames

Returns:

  • (Number) 


374
375
376
377
378
 
# File 'ext/opencv/cvcapture.cpp', line 374

VALUE
rb_set_height(VALUE self, VALUE value)
{
  return rb_set_capture_property(self, CV_CAP_PROP_FRAME_HEIGHT, value);
}

#hue ⇒ Number

Get hue of the image (only for cameras)

Returns:

  • (Number) —

    Hue



497
498
499
500
501
 
# File 'ext/opencv/cvcapture.cpp', line 497

VALUE
rb_get_hue(VALUE self)
{
  return rb_get_capture_property(self, CV_CAP_PROP_HUE);
}

#in?(point) ⇒ Boolean

Performs a point-in-contour test. The method determines whether the point is inside a contour, outside, or lies on an edge (or coincides with a vertex).

Parameters:

Returns:

  • (Boolean) —

    If the point is inside, returns true. If outside, returns false. If lies on an edge, returns nil.



225
226
227
228
229
230
231
232
233
234
235
236
 
# File 'ext/opencv/cvcontour.cpp', line 225

VALUE
rb_in_q(VALUE self, VALUE point)
{
  double n = 0;
  try {
    n = cvPointPolygonTest(CVARR(self), VALUE_TO_CVPOINT2D32F(point), 0);
  }
  catch (cv::Exception& e) {
    raise_cverror(e);
  }
  return n == 0 ? Qnil : n > 0 ? Qtrue : Qfalse;
}

#match_shapes(object, method) ⇒ Float

Compares two shapes(self and object). object should be CvContour.

A - object1, B - object2:

  • method=CV_CONTOURS_MATCH_I1

    I1(A,B)=sumi=1..7abs(1/mAi - 1/mBi)

  • method=CV_CONTOURS_MATCH_I2

    I2(A,B)=sumi=1..7abs(mAi - mBi)

  • method=CV_CONTOURS_MATCH_I3

    I3(A,B)=sumi=1..7abs(mAi - mBi)/abs(mAi)

Returns:

  • (Float) 


309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
 
# File 'ext/opencv/cvcontour.cpp', line 309

VALUE
rb_match_shapes(int argc, VALUE *argv, VALUE self)
{
  VALUE object, method, param;
  rb_scan_args(argc, argv, "21", &object, &method, &param);
  int method_flag = CVMETHOD("COMPARISON_METHOD", method);
  if (!rb_obj_is_kind_of(object, cCvContour::rb_class()))
    rb_raise(rb_eTypeError, "argument 1 (shape) should be %s",
        rb_class2name(cCvContour::rb_class()));
  double result = 0;
  try {
    result = cvMatchShapes(CVARR(self), CVARR(object), method_flag);
  }
  catch (cv::Exception& e) {
    raise_cverror(e);
  }
  return rb_float_new(result);
}

#measure_distance(point) ⇒ Object

Calculates distance between a point and the nearest contour edgex

Parameters:

Returns:

  • Signed distance between the point and the nearest contour edge



245
246
247
248
249
250
251
252
253
254
255
256
 
# File 'ext/opencv/cvcontour.cpp', line 245

VALUE
rb_measure_distance(VALUE self, VALUE point)
{
  double distance = 0;
  try {
    distance = cvPointPolygonTest(CVARR(self), VALUE_TO_CVPOINT2D32F(point), 1);
  }
  catch (cv::Exception& e) {
    raise_cverror(e);
  }
  return rb_float_new(distance);
}

#millisecond ⇒ Number

Get film current position in milliseconds or video capture timestamp.

Returns:

  • (Number) —

    Current position of the video file in milliseconds or video capture timestamp



219
220
221
222
223
 
# File 'ext/opencv/cvcapture.cpp', line 219

VALUE
rb_get_millisecond(VALUE self)
{
  return rb_get_capture_property(self, CV_CAP_PROP_POS_MSEC);
}

#millisecond= ⇒ Number

Set film current position in milliseconds or video capture timestamp.

Parameters:

  • value (Number) —

    Position in milliseconds or video capture timestamp.

Returns:

  • (Number) 


232
233
234
235
236
 
# File 'ext/opencv/cvcapture.cpp', line 232

VALUE
rb_set_millisecond(VALUE self, VALUE value)
{
  return rb_set_capture_property(self, CV_CAP_PROP_POS_MSEC, value);
}

#mode ⇒ Number

Get a backend-specific value indicating the current capture mode

Returns:

  • (Number) —

    Backend-specific value indicating the current capture mode



450
451
452
453
454
 
# File 'ext/opencv/cvcapture.cpp', line 450

VALUE
rb_get_mode(VALUE self)
{
  return rb_get_capture_property(self, CV_CAP_PROP_MODE);
}

#point_polygon_test(point, measure_dist) ⇒ Number

Determines whether the point is inside a contour, outside, or lies on an edge (or coinsides with a vertex).

Parameters:

  • point (CvPoint2D32f) —

    Point tested against the contour

  • measure_dist (Boolean) —

    If true, the method estimates the signed distance from the point to the nearest contour edge. Otherwise, the function only checks if the point is inside a contour or not.

Returns:

  • (Number) —

    When measure_dist = false, the return value is +1, -1 and 0, respectively. When measure_dist = true, it is a signed distance between the point and the nearest contour edge.



268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
 
# File 'ext/opencv/cvcontour.cpp', line 268

VALUE
rb_point_polygon_test(VALUE self, VALUE point, VALUE measure_dist)
{
  int measure_dist_flag;

  if (measure_dist == Qtrue)
    measure_dist_flag = 1;
  else if (measure_dist == Qfalse)
    measure_dist_flag = 0;
  else
    measure_dist_flag = NUM2INT(measure_dist);

  double dist = Qnil;
  try {
    dist = cvPointPolygonTest(CVARR(self), VALUE_TO_CVPOINT2D32F(point), measure_dist_flag);
  }
  catch (cv::Exception& e) {
    raise_cverror(e);
  }
  
  /* cvPointPolygonTest returns 100, -100 or 0 when measure_dist = 0 */
  if ((!measure_dist_flag) && ((int)dist) != 0)
    dist = (dist > 0) ? 1 : -1;

  return rb_float_new(dist);
}

#query ⇒ IplImage?

Grabs, decodes and returns the next video frame.

Returns:

  • (IplImage) —

    Next video frame

  • (nil) —

    Failed to read next video frame



163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
 
# File 'ext/opencv/cvcapture.cpp', line 163

VALUE
rb_query(VALUE self)
{
  VALUE image = Qnil;
  IplImage *frame = NULL;
  try {
    if (!(frame = cvQueryFrame(CVCAPTURE(self)))) {
      return Qnil;
    }
    image = cIplImage::new_object(frame->width, frame->height,
				  CV_MAKETYPE(IPL2CV_DEPTH(frame->depth), frame->nChannels));
    if (frame->origin == IPL_ORIGIN_TL) {
      cvCopy(frame, CVARR(image));
    }
    else {
      cvFlip(frame, CVARR(image));
    }
  }
  catch (cv::Exception& e) {
    raise_cverror(e);
  }
  return image;
}

#rect ⇒ CvRect

Returns bounding box of the contour

Returns:

  • (CvRect) —

    Bounding box of the contour



97
98
99
100
101
 
# File 'ext/opencv/cvcontour.cpp', line 97

VALUE
rb_rect(VALUE self)
{
  return cCvRect::new_object(CVCONTOUR(self)->rect);
}

#rectification ⇒ Number

Get rectification flag for stereo cameras (note: only supported by DC1394 v 2.x backend currently)

Returns:

  • (Number) —

    Rectification flag



552
553
554
555
556
 
# File 'ext/opencv/cvcapture.cpp', line 552

VALUE
rb_get_rectification(VALUE self)
{
  return rb_get_capture_property(self, CV_CAP_PROP_RECTIFICATION);
}

#reserved ⇒ Array<Number>

Returns reserved region values of the contour

Returns:

  • (Array<Number>) —

    Reserved region values of the contour



131
132
133
134
135
136
137
138
 
# File 'ext/opencv/cvcontour.cpp', line 131

VALUE
rb_reserved(VALUE self)
{
  return rb_ary_new3(3,
		     INT2NUM(CVCONTOUR(self)->reserved[0]),
		     INT2NUM(CVCONTOUR(self)->reserved[1]),
		     INT2NUM(CVCONTOUR(self)->reserved[2]));
}

#retrieve ⇒ IplImage?

Decodes and returns the grabbed video frame.

Returns:

  • (IplImage) —

    Grabbed video frame

  • (nil) —

    Failed to grabbing a frame



131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'ext/opencv/cvcapture.cpp', line 131

VALUE
rb_retrieve(VALUE self)
{
  VALUE image = Qnil;
  IplImage *frame = NULL;
  try {
    if (!(frame = cvRetrieveFrame(CVCAPTURE(self)))) {
      return Qnil;
    }
    image = cIplImage::new_object(frame->width, frame->height,
				  CV_MAKETYPE(IPL2CV_DEPTH(frame->depth), frame->nChannels));
    if (frame->origin == IPL_ORIGIN_TL) {
      cvCopy(frame, CVARR(image));
    }
    else {
      cvFlip(frame, CVARR(image));
    }
  }
  catch (cv::Exception& e) {
    raise_cverror(e);
  }
  return image;

}

#saturation ⇒ Number

Get saturation of the image (only for cameras)

Returns:

  • (Number) —

    Saturation



486
487
488
489
490
 
# File 'ext/opencv/cvcapture.cpp', line 486

VALUE
rb_get_saturation(VALUE self)
{
  return rb_get_capture_property(self, CV_CAP_PROP_SATURATION);
}

#size ⇒ Size

Get size of frames in the video stream.

Returns:

  • (Size) —

    Size of frames in the video stream.



292
293
294
295
296
297
298
299
300
301
302
303
304
305
 
# File 'ext/opencv/cvcapture.cpp', line 292

VALUE
rb_get_size(VALUE self)
{
  CvSize size;
  try {
    CvCapture* self_ptr = CVCAPTURE(self);
    size = cvSize((int)cvGetCaptureProperty(self_ptr, CV_CAP_PROP_FRAME_WIDTH),
		  (int)cvGetCaptureProperty(self_ptr, CV_CAP_PROP_FRAME_HEIGHT));
  }
  catch (cv::Exception& e) {
    raise_cverror(e);
  }
  return cCvSize::new_object(size);
}

#size= ⇒ Number

Set size of frames in the video stream.

Parameters:

  • value (CvSize) —

    Size of frames

Returns:

  • (Number) 


314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
 
# File 'ext/opencv/cvcapture.cpp', line 314

VALUE
rb_set_size(VALUE self, VALUE value)
{
  double result = 0;
  CvSize size = VALUE_TO_CVSIZE(value);
  try {
    CvCapture* self_ptr = CVCAPTURE(self);
    cvSetCaptureProperty(self_ptr, CV_CAP_PROP_FRAME_WIDTH, size.width);
    result = cvSetCaptureProperty(self_ptr, CV_CAP_PROP_FRAME_HEIGHT, size.height);
  }
  catch (cv::Exception& e) {
    raise_cverror(e);
  }
  return DBL2NUM(result);
}

#width ⇒ Number

Get width of frames in the video stream.

Returns:

  • (Number) —

    Width of frames in the video stream.



336
337
338
339
340
 
# File 'ext/opencv/cvcapture.cpp', line 336

VALUE
rb_get_width(VALUE self)
{
  return rb_get_capture_property(self, CV_CAP_PROP_FRAME_WIDTH);
}

#width= ⇒ Number

Set width of frames in the video stream.

Parameters:

  • value (Number) —

    Width of frames

Returns:

  • (Number) 


349
350
351
352
353
 
# File 'ext/opencv/cvcapture.cpp', line 349

VALUE
rb_set_width(VALUE self, VALUE value)
{
  return rb_set_capture_property(self, CV_CAP_PROP_FRAME_WIDTH, value);
}