include/opencv2/highgui/highgui_c.h
Go to the documentation of this file.
00001 /*M///////////////////////////////////////////////////////////////////////////////////////
00002 //
00003 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
00004 //
00005 //  By downloading, copying, installing or using the software you agree to this license.
00006 //  If you do not agree to this license, do not download, install,
00007 //  copy or use the software.
00008 //
00009 //
00010 //                        Intel License Agreement
00011 //                For Open Source Computer Vision Library
00012 //
00013 // Copyright (C) 2000, Intel Corporation, all rights reserved.
00014 // Third party copyrights are property of their respective owners.
00015 //
00016 // Redistribution and use in source and binary forms, with or without modification,
00017 // are permitted provided that the following conditions are met:
00018 //
00019 //   * Redistribution's of source code must retain the above copyright notice,
00020 //     this list of conditions and the following disclaimer.
00021 //
00022 //   * Redistribution's in binary form must reproduce the above copyright notice,
00023 //     this list of conditions and the following disclaimer in the documentation
00024 //     and/or other materials provided with the distribution.
00025 //
00026 //   * The name of Intel Corporation may not be used to endorse or promote products
00027 //     derived from this software without specific prior written permission.
00028 //
00029 // This software is provided by the copyright holders and contributors "as is" and
00030 // any express or implied warranties, including, but not limited to, the implied
00031 // warranties of merchantability and fitness for a particular purpose are disclaimed.
00032 // In no event shall the Intel Corporation or contributors be liable for any direct,
00033 // indirect, incidental, special, exemplary, or consequential damages
00034 // (including, but not limited to, procurement of substitute goods or services;
00035 // loss of use, data, or profits; or business interruption) however caused
00036 // and on any theory of liability, whether in contract, strict liability,
00037 // or tort (including negligence or otherwise) arising in any way out of
00038 // the use of this software, even if advised of the possibility of such damage.
00039 //
00040 //M*/
00041 
00042 #ifndef __OPENCV_HIGHGUI_H__
00043 #define __OPENCV_HIGHGUI_H__
00044 
00045 #include "opencv2/core/core_c.h"
00046 
00047 #ifdef __cplusplus
00048 extern "C" {
00049 #endif /* __cplusplus */
00050 
00051 /****************************************************************************************\
00052 *                                  Basic GUI functions                                   *
00053 \****************************************************************************************/
00054 //YV
00055 //-----------New for Qt
00056 /* For font */
00057 enum {  CV_FONT_LIGHT           = 25,//QFont::Light,
00058         CV_FONT_NORMAL          = 50,//QFont::Normal,
00059         CV_FONT_DEMIBOLD        = 63,//QFont::DemiBold,
00060         CV_FONT_BOLD            = 75,//QFont::Bold,
00061         CV_FONT_BLACK           = 87 //QFont::Black
00062 };
00063 
00064 enum {  CV_STYLE_NORMAL         = 0,//QFont::StyleNormal,
00065         CV_STYLE_ITALIC         = 1,//QFont::StyleItalic,
00066         CV_STYLE_OBLIQUE        = 2 //QFont::StyleOblique
00067 };
00068 /* ---------*/
00069 
00070 //for color cvScalar(blue_component, green_component, red\_component[, alpha_component])
00071 //and alpha= 0 <-> 0xFF (not transparent <-> transparent)
00072 CVAPI(CvFont) cvFontQt(const char* nameFont, int pointSize CV_DEFAULT(-1), CvScalar color CV_DEFAULT(cvScalarAll(0)), int weight CV_DEFAULT(CV_FONT_NORMAL),  int style CV_DEFAULT(CV_STYLE_NORMAL), int spacing CV_DEFAULT(0));
00073 
00074 CVAPI(void) cvAddText(const CvArr* img, const char* text, CvPoint org, CvFont *arg2);
00075 
00076 CVAPI(void) cvDisplayOverlay(const char* name, const char* text, int delayms);
00077 CVAPI(void) cvDisplayStatusBar(const char* name, const char* text, int delayms);
00078 
00079 typedef void (CV_CDECL *CvOpenGLCallback)(void* userdata);
00080 CVAPI(void) cvCreateOpenGLCallback( const char* window_name, CvOpenGLCallback callbackOpenGL, void* userdata CV_DEFAULT(NULL), double angle CV_DEFAULT(-1), double zmin CV_DEFAULT(-1), double zmax CV_DEFAULT(-1));
00081 
00082 CVAPI(void) cvSaveWindowParameters(const char* name);
00083 CVAPI(void) cvLoadWindowParameters(const char* name);
00084 CVAPI(int) cvStartLoop(int (*pt2Func)(int argc, char *argv[]), int argc, char* argv[]);
00085 CVAPI(void) cvStopLoop();
00086 
00087 typedef void (CV_CDECL *CvButtonCallback)(int state, void* userdata);
00088 enum {CV_PUSH_BUTTON = 0, CV_CHECKBOX = 1, CV_RADIOBOX = 2};
00089 CVAPI(int) cvCreateButton( const char* button_name CV_DEFAULT(NULL),CvButtonCallback on_change CV_DEFAULT(NULL), void* userdata CV_DEFAULT(NULL) , int button_type CV_DEFAULT(CV_PUSH_BUTTON), int initial_button_state CV_DEFAULT(0));
00090 //----------------------
00091 
00092 
00093 /* this function is used to set some external parameters in case of X Window */
00094 CVAPI(int) cvInitSystem( int argc, char** argv );
00095 
00096 CVAPI(int) cvStartWindowThread();
00097 
00098 // ---------  YV ---------
00099 enum
00100 {
00101     //These 3 flags are used by cvSet/GetWindowProperty
00102     CV_WND_PROP_FULLSCREEN = 0,//to change/get window's fullscreen property
00103     CV_WND_PROP_AUTOSIZE   = 1,//to change/get window's autosize property
00104     CV_WND_PROP_ASPECTRATIO= 2,//to change/get window's aspectratio property
00105     //
00106     //These 2 flags are used by cvNamedWindow and cvSet/GetWindowProperty
00107     CV_WINDOW_NORMAL       = 0x00000000,//the user can resize the window (no constraint)  / also use to switch a fullscreen window to a normal size
00108     CV_WINDOW_AUTOSIZE     = 0x00000001,//the user cannot resize the window, the size is constrainted by the image displayed
00109     //
00110     //Those flags are only for Qt
00111     CV_GUI_EXPANDED         = 0x00000000,//status bar and tool bar
00112     CV_GUI_NORMAL           = 0x00000010,//old fashious way
00113     //
00114     //These 3 flags are used by cvNamedWindow and cvSet/GetWindowProperty
00115     CV_WINDOW_FULLSCREEN   = 1,//change the window to fullscreen
00116     CV_WINDOW_FREERATIO    = 0x00000100,//the image expends as much as it can (no ratio constraint)
00117     CV_WINDOW_KEEPRATIO    = 0x00000000//the ration image is respected.
00118 };
00119 
00120 /* create window */
00121 CVAPI(int) cvNamedWindow( const char* name, int flags CV_DEFAULT(CV_WINDOW_AUTOSIZE) );
00122 
00123 /* Set and Get Property of the window */
00124 CVAPI(void) cvSetWindowProperty(const char* name, int prop_id, double prop_value);
00125 CVAPI(double) cvGetWindowProperty(const char* name, int prop_id);
00126 
00127 /* display image within window (highgui windows remember their content) */
00128 CVAPI(void) cvShowImage( const char* name, const CvArr* image );
00129 
00130 /* resize/move window */
00131 CVAPI(void) cvResizeWindow( const char* name, int width, int height );
00132 CVAPI(void) cvMoveWindow( const char* name, int x, int y );
00133 
00134 
00135 /* destroy window and all the trackers associated with it */
00136 CVAPI(void) cvDestroyWindow( const char* name );
00137 
00138 CVAPI(void) cvDestroyAllWindows(void);
00139 
00140 /* get native window handle (HWND in case of Win32 and Widget in case of X Window) */
00141 CVAPI(void*) cvGetWindowHandle( const char* name );
00142 
00143 /* get name of highgui window given its native handle */
00144 CVAPI(const char*) cvGetWindowName( void* window_handle );
00145 
00146 
00147 typedef void (CV_CDECL *CvTrackbarCallback)(int pos);
00148 
00149 /* create trackbar and display it on top of given window, set callback */
00150 CVAPI(int) cvCreateTrackbar( const char* trackbar_name, const char* window_name,
00151                              int* value, int count, CvTrackbarCallback on_change CV_DEFAULT(NULL));
00152 
00153 typedef void (CV_CDECL *CvTrackbarCallback2)(int pos, void* userdata);
00154 
00155 CVAPI(int) cvCreateTrackbar2( const char* trackbar_name, const char* window_name,
00156                               int* value, int count, CvTrackbarCallback2 on_change,
00157                               void* userdata CV_DEFAULT(0));
00158 
00159 /* retrieve or set trackbar position */
00160 CVAPI(int) cvGetTrackbarPos( const char* trackbar_name, const char* window_name );
00161 CVAPI(void) cvSetTrackbarPos( const char* trackbar_name, const char* window_name, int pos );
00162 
00163 enum
00164 {
00165     CV_EVENT_MOUSEMOVE      =0,
00166     CV_EVENT_LBUTTONDOWN    =1,
00167     CV_EVENT_RBUTTONDOWN    =2,
00168     CV_EVENT_MBUTTONDOWN    =3,
00169     CV_EVENT_LBUTTONUP      =4,
00170     CV_EVENT_RBUTTONUP      =5,
00171     CV_EVENT_MBUTTONUP      =6,
00172     CV_EVENT_LBUTTONDBLCLK  =7,
00173     CV_EVENT_RBUTTONDBLCLK  =8,
00174     CV_EVENT_MBUTTONDBLCLK  =9
00175 };
00176 
00177 enum
00178 {
00179     CV_EVENT_FLAG_LBUTTON   =1,
00180     CV_EVENT_FLAG_RBUTTON   =2,
00181     CV_EVENT_FLAG_MBUTTON   =4,
00182     CV_EVENT_FLAG_CTRLKEY   =8,
00183     CV_EVENT_FLAG_SHIFTKEY  =16,
00184     CV_EVENT_FLAG_ALTKEY    =32
00185 };
00186 
00187 typedef void (CV_CDECL *CvMouseCallback )(int event, int x, int y, int flags, void* param);
00188 
00189 /* assign callback for mouse events */
00190 CVAPI(void) cvSetMouseCallback( const char* window_name, CvMouseCallback on_mouse,
00191                                 void* param CV_DEFAULT(NULL));
00192 
00193 enum
00194 {
00195 /* 8bit, color or not */
00196     CV_LOAD_IMAGE_UNCHANGED  =-1,
00197 /* 8bit, gray */
00198     CV_LOAD_IMAGE_GRAYSCALE  =0,
00199 /* ?, color */
00200     CV_LOAD_IMAGE_COLOR      =1,
00201 /* any depth, ? */
00202     CV_LOAD_IMAGE_ANYDEPTH   =2,
00203 /* ?, any color */
00204     CV_LOAD_IMAGE_ANYCOLOR   =4
00205 };
00206 
00207 /* load image from file
00208   iscolor can be a combination of above flags where CV_LOAD_IMAGE_UNCHANGED
00209   overrides the other flags
00210   using CV_LOAD_IMAGE_ANYCOLOR alone is equivalent to CV_LOAD_IMAGE_UNCHANGED
00211   unless CV_LOAD_IMAGE_ANYDEPTH is specified images are converted to 8bit
00212 */
00213 CVAPI(IplImage*) cvLoadImage( const char* filename, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
00214 CVAPI(CvMat*) cvLoadImageM( const char* filename, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
00215 
00216 enum
00217 {
00218     CV_IMWRITE_JPEG_QUALITY =1,
00219     CV_IMWRITE_PNG_COMPRESSION =16,
00220     CV_IMWRITE_PXM_BINARY =32
00221 };
00222 
00223 /* save image to file */
00224 CVAPI(int) cvSaveImage( const char* filename, const CvArr* image,
00225                         const int* params CV_DEFAULT(0) );
00226 
00227 /* decode image stored in the buffer */
00228 CVAPI(IplImage*) cvDecodeImage( const CvMat* buf, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
00229 CVAPI(CvMat*) cvDecodeImageM( const CvMat* buf, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
00230 
00231 /* encode image and store the result as a byte vector (single-row 8uC1 matrix) */
00232 CVAPI(CvMat*) cvEncodeImage( const char* ext, const CvArr* image,
00233                              const int* params CV_DEFAULT(0) );
00234 
00235 enum
00236 {
00237     CV_CVTIMG_FLIP      =1,
00238     CV_CVTIMG_SWAP_RB   =2
00239 };
00240 
00241 /* utility function: convert one image to another with optional vertical flip */
00242 CVAPI(void) cvConvertImage( const CvArr* src, CvArr* dst, int flags CV_DEFAULT(0));
00243 
00244 /* wait for key event infinitely (delay<=0) or for "delay" milliseconds */
00245 CVAPI(int) cvWaitKey(int delay CV_DEFAULT(0));
00246 
00247 /****************************************************************************************\
00248 *                         Working with Video Files and Cameras                           *
00249 \****************************************************************************************/
00250 
00251 /* "black box" capture structure */
00252 typedef struct CvCapture CvCapture;
00253 
00254 /* start capturing frames from video file */
00255 CVAPI(CvCapture*) cvCreateFileCapture( const char* filename );
00256 
00257 enum
00258 {
00259     CV_CAP_ANY      =0,     // autodetect
00260 
00261     CV_CAP_MIL      =100,   // MIL proprietary drivers
00262 
00263     CV_CAP_VFW      =200,   // platform native
00264     CV_CAP_V4L      =200,
00265     CV_CAP_V4L2     =200,
00266 
00267     CV_CAP_FIREWARE =300,   // IEEE 1394 drivers
00268     CV_CAP_FIREWIRE =300,
00269     CV_CAP_IEEE1394 =300,
00270     CV_CAP_DC1394   =300,
00271     CV_CAP_CMU1394  =300,
00272 
00273     CV_CAP_STEREO   =400,   // TYZX proprietary drivers
00274     CV_CAP_TYZX     =400,
00275     CV_TYZX_LEFT    =400,
00276     CV_TYZX_RIGHT   =401,
00277     CV_TYZX_COLOR   =402,
00278     CV_TYZX_Z       =403,
00279 
00280     CV_CAP_QT       =500,   // QuickTime
00281 
00282     CV_CAP_UNICAP   =600,   // Unicap drivers
00283 
00284     CV_CAP_DSHOW    =700,   // DirectShow (via videoInput)
00285 
00286     CV_CAP_PVAPI    =800,   // PvAPI, Prosilica GigE SDK
00287 
00288     CV_CAP_OPENNI   =900,   // OpenNI (for Kinect)
00289 
00290     CV_CAP_ANDROID  =1000   // Android
00291 };
00292 
00293 /* start capturing frames from camera: index = camera_index + domain_offset (CV_CAP_*) */
00294 CVAPI(CvCapture*) cvCreateCameraCapture( int index );
00295 
00296 /* grab a frame, return 1 on success, 0 on fail.
00297   this function is thought to be fast               */
00298 CVAPI(int) cvGrabFrame( CvCapture* capture );
00299 
00300 /* get the frame grabbed with cvGrabFrame(..)
00301   This function may apply some frame processing like
00302   frame decompression, flipping etc.
00303   !!!DO NOT RELEASE or MODIFY the retrieved frame!!! */
00304 CVAPI(IplImage*) cvRetrieveFrame( CvCapture* capture, int streamIdx CV_DEFAULT(0) );
00305 
00306 /* Just a combination of cvGrabFrame and cvRetrieveFrame
00307    !!!DO NOT RELEASE or MODIFY the retrieved frame!!!      */
00308 CVAPI(IplImage*) cvQueryFrame( CvCapture* capture );
00309 
00310 /* stop capturing/reading and free resources */
00311 CVAPI(void) cvReleaseCapture( CvCapture** capture );
00312 
00313 enum
00314 {
00315     // modes of the controlling registers (can be: auto, manual, auto single push, absolute Latter allowed with any other mode)
00316     // every feature can have only one mode turned on at a time
00317     CV_CAP_PROP_DC1394_OFF         = -4,  //turn the feature off (not controlled manually nor automatically)
00318     CV_CAP_PROP_DC1394_MODE_MANUAL = -3, //set automatically when a value of the feature is set by the user
00319     CV_CAP_PROP_DC1394_MODE_AUTO = -2,
00320     CV_CAP_PROP_DC1394_MODE_ONE_PUSH_AUTO = -1,
00321     CV_CAP_PROP_POS_MSEC       =0,
00322     CV_CAP_PROP_POS_FRAMES     =1,
00323     CV_CAP_PROP_POS_AVI_RATIO  =2,
00324     CV_CAP_PROP_FRAME_WIDTH    =3,
00325     CV_CAP_PROP_FRAME_HEIGHT   =4,
00326     CV_CAP_PROP_FPS            =5,
00327     CV_CAP_PROP_FOURCC         =6,
00328     CV_CAP_PROP_FRAME_COUNT    =7,
00329     CV_CAP_PROP_FORMAT         =8,
00330     CV_CAP_PROP_MODE           =9,
00331     CV_CAP_PROP_BRIGHTNESS    =10,
00332     CV_CAP_PROP_CONTRAST      =11,
00333     CV_CAP_PROP_SATURATION    =12,
00334     CV_CAP_PROP_HUE           =13,
00335     CV_CAP_PROP_GAIN          =14,
00336     CV_CAP_PROP_EXPOSURE      =15,
00337     CV_CAP_PROP_CONVERT_RGB   =16,
00338     CV_CAP_PROP_WHITE_BALANCE_BLUE_U =17,
00339     CV_CAP_PROP_RECTIFICATION =18,
00340     CV_CAP_PROP_MONOCROME     =19,
00341     CV_CAP_PROP_SHARPNESS     =20,
00342     CV_CAP_PROP_AUTO_EXPOSURE =21, // exposure control done by camera,
00343                                    // user can adjust refernce level
00344                                    // using this feature
00345     CV_CAP_PROP_GAMMA         =22,
00346     CV_CAP_PROP_TEMPERATURE   =23,
00347     CV_CAP_PROP_TRIGGER       =24,
00348     CV_CAP_PROP_TRIGGER_DELAY =25,
00349     CV_CAP_PROP_WHITE_BALANCE_RED_V =26,
00350     CV_CAP_PROP_MAX_DC1394    =27,
00351     CV_CAP_PROP_AUTOGRAB      =1024, // property for highgui class CvCapture_Android only
00352     CV_CAP_PROP_SUPPORTED_PREVIEW_SIZES_STRING=1025, // tricky property, returns cpnst char* indeed
00353     // OpenNI map generators
00354     CV_CAP_OPENNI_DEPTH_GENERATOR = 0,
00355     CV_CAP_OPENNI_IMAGE_GENERATOR = 1 << 31,
00356     CV_CAP_OPENNI_GENERATORS_MASK = 1 << 31,
00357 
00358     // Properties of cameras available through OpenNI interfaces
00359     CV_CAP_PROP_OPENNI_OUTPUT_MODE      = 100,
00360     CV_CAP_PROP_OPENNI_FRAME_MAX_DEPTH  = 101, // in mm
00361     CV_CAP_PROP_OPENNI_BASELINE         = 102, // in mm
00362     CV_CAP_PROP_OPENNI_FOCAL_LENGTH     = 103, // in pixels
00363     CV_CAP_PROP_OPENNI_REGISTRATION_ON    = 104, // flag
00364     CV_CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE = CV_CAP_OPENNI_IMAGE_GENERATOR + CV_CAP_PROP_OPENNI_OUTPUT_MODE,
00365     CV_CAP_OPENNI_DEPTH_GENERATOR_BASELINE = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_BASELINE,
00366     CV_CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_FOCAL_LENGTH,
00367     CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION_ON = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_REGISTRATION_ON,
00368     
00369     // Properties of cameras available through GStreamer interface
00370     CV_CAP_GSTREAMER_QUEUE_LENGTH   = 200, // default is 1
00371     CV_CAP_PROP_PVAPI_MULTICASTIP       = 300 // ip for anable multicast master mode. 0 for disable multicast
00372 };
00373 
00374 enum
00375 {
00376     // Data given from depth generator.
00377     CV_CAP_OPENNI_DEPTH_MAP                 = 0, // Depth values in mm (CV_16UC1)
00378     CV_CAP_OPENNI_POINT_CLOUD_MAP           = 1, // XYZ in meters (CV_32FC3)
00379     CV_CAP_OPENNI_DISPARITY_MAP             = 2, // Disparity in pixels (CV_8UC1)
00380     CV_CAP_OPENNI_DISPARITY_MAP_32F         = 3, // Disparity in pixels (CV_32FC1)
00381     CV_CAP_OPENNI_VALID_DEPTH_MASK          = 4, // CV_8UC1
00382 
00383     // Data given from RGB image generator.
00384     CV_CAP_OPENNI_BGR_IMAGE                 = 5,
00385     CV_CAP_OPENNI_GRAY_IMAGE                = 6
00386 };
00387 
00388 // Supported output modes of OpenNI image generator
00389 enum
00390 {
00391     CV_CAP_OPENNI_VGA_30HZ     = 0,
00392     CV_CAP_OPENNI_SXGA_15HZ    = 1
00393 };
00394 
00395 //supported by Android camera output formats
00396 enum
00397 {
00398   CV_CAP_ANDROID_COLOR_FRAME_BGR = 0, //BGR
00399   CV_CAP_ANDROID_COLOR_FRAME = CV_CAP_ANDROID_COLOR_FRAME_BGR,
00400   CV_CAP_ANDROID_GREY_FRAME  = 1,  //Y
00401   CV_CAP_ANDROID_COLOR_FRAME_RGB = 2,
00402   CV_CAP_ANDROID_COLOR_FRAME_BGRA = 3,
00403   CV_CAP_ANDROID_COLOR_FRAME_RGBA = 4
00404 };
00405 
00406 /* retrieve or set capture properties */
00407 CVAPI(double) cvGetCaptureProperty( CvCapture* capture, int property_id );
00408 CVAPI(int)    cvSetCaptureProperty( CvCapture* capture, int property_id, double value );
00409 
00410 // Return the type of the capturer (eg, CV_CAP_V4W, CV_CAP_UNICAP), which is unknown if created with CV_CAP_ANY
00411 CVAPI(int)    cvGetCaptureDomain( CvCapture* capture);  
00412 
00413 /* "black box" video file writer structure */
00414 typedef struct CvVideoWriter CvVideoWriter;
00415 
00416 CV_INLINE int CV_FOURCC(char c1, char c2, char c3, char c4)
00417 {
00418     return (c1 & 255) + ((c2 & 255) << 8) + ((c3 &255) << 16) + ((c4 & 255) << 24);
00419 }
00420 
00421 #define CV_FOURCC_PROMPT -1  /* Open Codec Selection Dialog (Windows only) */
00422 #define CV_FOURCC_DEFAULT CV_FOURCC('I', 'Y', 'U', 'V') /* Use default codec for specified filename (Linux only) */
00423 
00424 /* initialize video file writer */
00425 CVAPI(CvVideoWriter*) cvCreateVideoWriter( const char* filename, int fourcc,
00426                                            double fps, CvSize frame_size,
00427                                            int is_color CV_DEFAULT(1));
00428 
00429 //CVAPI(CvVideoWriter*) cvCreateImageSequenceWriter( const char* filename,
00430 //                                                   int is_color CV_DEFAULT(1));
00431 
00432 /* write frame to video file */
00433 CVAPI(int) cvWriteFrame( CvVideoWriter* writer, const IplImage* image );
00434 
00435 /* close video file writer */
00436 CVAPI(void) cvReleaseVideoWriter( CvVideoWriter** writer );
00437 
00438 /****************************************************************************************\
00439 *                              Obsolete functions/synonyms                               *
00440 \****************************************************************************************/
00441 
00442 #define cvCaptureFromFile cvCreateFileCapture
00443 #define cvCaptureFromCAM cvCreateCameraCapture
00444 #define cvCaptureFromAVI cvCaptureFromFile
00445 #define cvCreateAVIWriter cvCreateVideoWriter
00446 #define cvWriteToAVI cvWriteFrame
00447 #define cvAddSearchPath(path)
00448 #define cvvInitSystem cvInitSystem
00449 #define cvvNamedWindow cvNamedWindow
00450 #define cvvShowImage cvShowImage
00451 #define cvvResizeWindow cvResizeWindow
00452 #define cvvDestroyWindow cvDestroyWindow
00453 #define cvvCreateTrackbar cvCreateTrackbar
00454 #define cvvLoadImage(name) cvLoadImage((name),1)
00455 #define cvvSaveImage cvSaveImage
00456 #define cvvAddSearchPath cvAddSearchPath
00457 #define cvvWaitKey(name) cvWaitKey(0)
00458 #define cvvWaitKeyEx(name,delay) cvWaitKey(delay)
00459 #define cvvConvertImage cvConvertImage
00460 #define HG_AUTOSIZE CV_WINDOW_AUTOSIZE
00461 #define set_preprocess_func cvSetPreprocessFuncWin32
00462 #define set_postprocess_func cvSetPostprocessFuncWin32
00463 
00464 #if defined WIN32 || defined _WIN32
00465 
00466 CVAPI(void) cvSetPreprocessFuncWin32_(const void* callback);
00467 CVAPI(void) cvSetPostprocessFuncWin32_(const void* callback);
00468 #define cvSetPreprocessFuncWin32(callback) cvSetPreprocessFuncWin32_((const void*)(callback))
00469 #define cvSetPostprocessFuncWin32(callback) cvSetPostprocessFuncWin32_((const void*)(callback))
00470 
00471 #endif
00472 
00473 #ifdef __cplusplus
00474 }
00475 #endif
00476 
00477 #endif