mirror of
https://github.com/Laex/Delphi-OpenCV.git
synced 2024-11-15 15:55:53 +01:00
785 lines
34 KiB
ObjectPascal
785 lines
34 KiB
ObjectPascal
(*
|
|
**************************************************************************************************
|
|
Project Delphi-OpenCV
|
|
**************************************************************************************************
|
|
Contributor:
|
|
Laentir Valetov
|
|
email:laex@bk.ru
|
|
Mikhail Grigorev
|
|
email:sleuthound@gmail.com
|
|
**************************************************************************************************
|
|
You may retrieve the latest version of this file at the GitHub,
|
|
located at git://github.com/Laex/Delphi-OpenCV.git
|
|
**************************************************************************************************
|
|
License:
|
|
The contents of this file are subject to the Mozilla Public License Version 1.1 (the "License");
|
|
you may not use this file except in compliance with the License. You may obtain a copy of the
|
|
License at http://www.mozilla.org/MPL/
|
|
|
|
Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
|
|
ANY KIND, either express or implied. See the License for the specific language governing rights
|
|
and limitations under the License.
|
|
|
|
Alternatively, the contents of this file may be used under the terms of the
|
|
GNU Lesser General Public License (the "LGPL License"), in which case the
|
|
provisions of the LGPL License are applicable instead of those above.
|
|
If you wish to allow use of your version of this file only under the terms
|
|
of the LGPL License and not to allow others to use your version of this file
|
|
under the MPL, indicate your decision by deleting the provisions above and
|
|
replace them with the notice and other provisions required by the LGPL
|
|
License. If you do not delete the provisions above, a recipient may use
|
|
your version of this file under either the MPL or the LGPL License.
|
|
|
|
For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html
|
|
**************************************************************************************************
|
|
Warning: Using Delphi XE2 syntax!
|
|
**************************************************************************************************
|
|
The Initial Developer of the Original Code:
|
|
OpenCV: open source computer vision library
|
|
Homepage: http://ocv.org
|
|
Online docs: http://docs.ocv.org
|
|
Q&A forum: http://answers.ocv.org
|
|
Dev zone: http://code.ocv.org
|
|
**************************************************************************************************
|
|
Original file:
|
|
opencv\modules\highgui\include\opencv2\highgui\highgui_c.h
|
|
*************************************************************************************************
|
|
*)
|
|
|
|
unit ocv.highgui_c;
|
|
|
|
{$I OpenCV.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
ocv.core.types_c, ocv.core_c;
|
|
|
|
(* ***************************************************************************************\
|
|
* Basic GUI functions *
|
|
*************************************************************************************** *)
|
|
|
|
(* For font *)
|
|
const
|
|
CV_FONT_LIGHT = 25; // QFont::Light;
|
|
CV_FONT_NORMAL = 50; // QFont::Normal;
|
|
CV_FONT_DEMIBOLD = 63; // QFont::DemiBold;
|
|
CV_FONT_BOLD = 75; // QFont::Bold;
|
|
CV_FONT_BLACK = 87; // QFont::Black;
|
|
CV_STYLE_NORMAL = 0; // QFont::StyleNormal;
|
|
CV_STYLE_ITALIC = 1; // QFont::StyleItalic;
|
|
CV_STYLE_OBLIQUE = 2; // QFont::StyleOblique;
|
|
|
|
// for color cvScalar(blue_component, green_component, red\_component[, alpha_component])
|
|
// and alpha= 0 <-> 0xFF (not transparent <-> transparent)
|
|
(*
|
|
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));
|
|
*)
|
|
function cvFontQt(const nameFont: pCvChar; pointSize: Integer { = -1 }; color: TCvScalar { = CV_DEFAULT(cvScalarAll(0)) };
|
|
weight: Integer { = CV_DEFAULT(CV_FONT_NORMAL) }; style: Integer { = CV_DEFAULT(CV_STYLE_NORMAL) }; spacing: Integer { = CV_DEFAULT(0) } )
|
|
: TCvFont; cdecl;
|
|
|
|
(*
|
|
CVAPI(void) cvAddText(const CvArr* img, const char* text, CvPoint org, CvFont *arg2);
|
|
*)
|
|
procedure cvAddText(const img: pCvArr; const text: pCvChar; org: TCvPoint; arg2: pCvFont); cdecl;
|
|
(*
|
|
CVAPI(void) cvDisplayOverlay(const char* name, const char* text, int delayms CV_DEFAULT(0));
|
|
*)
|
|
procedure cvDisplayOverlay(const name: pCvChar; const text: pCvChar; delayms: Integer = 0); cdecl;
|
|
(*
|
|
CVAPI(void) cvDisplayStatusBar(const char* name, const char* text, int delayms CV_DEFAULT(0));
|
|
*)
|
|
procedure cvDisplayStatusBar(const name: pCvChar; const text: pCvChar; delayms: Integer = 0); cdecl;
|
|
(*
|
|
CVAPI(void) cvSaveWindowParameters(const char* name);
|
|
*)
|
|
procedure cvSaveWindowParameters(const name: pCvChar); cdecl;
|
|
(*
|
|
CVAPI(void) cvLoadWindowParameters(const char* name);
|
|
*)
|
|
procedure cvLoadWindowParameters(const name: pCvChar); cdecl;
|
|
|
|
Type
|
|
(* int (*pt2Func)(int argc, char *argv[]) *)
|
|
TArgvArray = array [0 .. 0] of pCvChar;
|
|
pArgvArray = ^TArgvArray;
|
|
Tpt2Func = function(argc: Integer; argv: pArgvArray): Integer; cdecl;
|
|
(*
|
|
CVAPI(int) cvStartLoop(int (*pt2Func)(int argc, char *argv[]), int argc, char* argv[]);
|
|
*)
|
|
function cvStartLoop(pt2Func: Tpt2Func): Integer; cdecl;
|
|
(*
|
|
CVAPI(void) cvStopLoop( void );
|
|
*)
|
|
procedure cvStopLoop; cdecl;
|
|
|
|
Type
|
|
(* typedef void (CV_CDECL *CvButtonCallback)(int state, void* userdata); *)
|
|
TCvButtonCallback = procedure(state: Integer; userdata: Pointer); cdecl;
|
|
|
|
const
|
|
(* enum {CV_PUSH_BUTTON = 0, CV_CHECKBOX = 1, CV_RADIOBOX = 2}; *)
|
|
CV_PUSH_BUTTON = 0;
|
|
CV_CHECKBOX = 1;
|
|
CV_RADIOBOX = 2;
|
|
(*
|
|
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));
|
|
*)
|
|
function cvCreateButton(const button_name: pCvChar = nil; on_change: TCvButtonCallback = nil; userdata: Pointer = nil;
|
|
button_type: Integer = CV_PUSH_BUTTON; initial_button_state: Integer = 0): Integer; cdecl;
|
|
|
|
// ----------------------
|
|
// * this function is used to set some external parameters in case of X Window */
|
|
// CVAPI(int) cvInitSystem( int argc, char** argv );
|
|
function cvInitSystem(argc: Integer; argv: ppCVChar): Integer; cdecl;
|
|
|
|
// CVAPI(int) cvStartWindowThread( void );
|
|
function cvStartWindowThread: Integer; cdecl;
|
|
|
|
// --------- YV ---------
|
|
// These 3 flags are used by cvSet/GetWindowProperty;
|
|
const
|
|
CV_WND_PROP_FULLSCREEN = 0; // to change/get window's fullscreen property
|
|
CV_WND_PROP_AUTOSIZE = 1; // to change/get window's autosize property
|
|
CV_WND_PROP_ASPECTRATIO = 2; // to change/get window's aspectratio property
|
|
CV_WND_PROP_OPENGL = 3; // to change/get window's opengl support
|
|
// These 2 flags are used by cvNamedWindow and cvSet/GetWindowProperty;
|
|
CV_WINDOW_NORMAL = $00000000;
|
|
// the user can resize the window (no raint) / also use to switch a fullscreen window to a normal size
|
|
CV_WINDOW_AUTOSIZE = $00000001;
|
|
// the user cannot resize the window; the size is rainted by the image displayed
|
|
CV_WINDOW_OPENGL = $00001000; // window with opengl support
|
|
// Those flags are only for Qt;
|
|
CV_GUI_EXPANDED = $00000000; // status bar and tool bar
|
|
CV_GUI_NORMAL = $00000010; // old fashious way
|
|
// These 3 flags are used by cvNamedWindow and cvSet/GetWindowProperty;
|
|
CV_WINDOW_FULLSCREEN = 1; // change the window to fullscreen
|
|
CV_WINDOW_FREERATIO = $00000100; // the image expends as much as it can (no ratio raint)
|
|
CV_WINDOW_KEEPRATIO = $00000000; // the ration image is respected.;
|
|
|
|
(* create window *)
|
|
function cvNamedWindow(const name: pCvChar; flags: Integer = CV_WINDOW_AUTOSIZE): Integer; cdecl;
|
|
|
|
// Set and Get Property of the window
|
|
procedure cvSetWindowProperty(name: pCvChar; prop_id: Integer; prop_value: Double); cdecl;
|
|
function cvGetWindowProperty(name: pCvChar; prop_id: Integer): Double; cdecl;
|
|
|
|
{
|
|
//display image within window (highgui windows remember their content)
|
|
CVAPI(void) cvShowImage( const char* name, const CvArr* image );
|
|
}
|
|
procedure cvShowImage(const name: pCvChar; const image: pCvArr); cdecl;
|
|
// procedure cvShowImage(const name: pCVChar; const image: pIplImage); cdecl; overload;
|
|
// procedure cvShowImage(const name: pCVChar; const image: pCvMat); cdecl; overload;
|
|
|
|
(* resize/move window *)
|
|
procedure cvResizeWindow(name: pCvChar; width: Integer; height: Integer); cdecl;
|
|
// CVAPI(void) cvMoveWindow( const char* name, int x, int y );
|
|
procedure cvMoveWindow(const name: pCvChar; x: Integer; y: Integer); cdecl;
|
|
|
|
(* destroy window and all the trackers associated with it *)
|
|
procedure cvDestroyWindow(const name: pCvChar); cdecl;
|
|
procedure cvDestroyAllWindows; cdecl;
|
|
(*
|
|
get native window handle (HWND in case of Win32 and Widget in case of X Window)
|
|
|
|
CVAPI(void* ) cvGetWindowHandle( const char* name );
|
|
*)
|
|
function cvGetWindowHandle(const name: pCvChar): Pointer; cdecl;
|
|
(*
|
|
get name of highgui window given its native handle
|
|
|
|
CVAPI(const char* ) cvGetWindowName( void* window_handle );
|
|
*)
|
|
function cvGetWindowName(window_handle: Pointer): pCvChar; cdecl;
|
|
|
|
type
|
|
TCvTrackbarCallback = procedure(pos: Integer); cdecl;
|
|
|
|
(* create trackbar and display it on top of given window, set callback *)
|
|
function cvCreateTrackbar(const trackbar_name: pCvChar; const window_name: pCvChar; value: PInteger; count: Integer;
|
|
on_change: TCvTrackbarCallback): Integer; cdecl;
|
|
|
|
type
|
|
CvTrackbarCallback2 = procedure(pos: Integer; userdata: Pointer); cdecl;
|
|
|
|
// CVAPI(int) cvCreateTrackbar2( const char* trackbar_name, const char* window_name,
|
|
// int* value, int count, CvTrackbarCallback2 on_change,
|
|
// void* userdata CV_DEFAULT(0));
|
|
function cvCreateTrackbar2(const trackbar_name: pCvChar; const window_name: pCvChar; value: PInteger; count: Integer;
|
|
on_change: CvTrackbarCallback2; userdata: Pointer = nil): Integer; cdecl;
|
|
|
|
// * retrieve or set trackbar position */
|
|
// CVAPI(int) cvGetTrackbarPos( const char* trackbar_name, const char* window_name );
|
|
function cvGetTrackbarPos(const trackbar_name: pCvChar; const window_name: pCvChar): Integer; cdecl;
|
|
// CVAPI(void) cvSetTrackbarPos( const char* trackbar_name, const char* window_name, int pos );
|
|
procedure cvSetTrackbarPos(const trackbar_name: pCvChar; const window_name: pCvChar; pos: Integer); cdecl;
|
|
|
|
const
|
|
CV_EVENT_MOUSEMOVE = 0;
|
|
CV_EVENT_LBUTTONDOWN = 1;
|
|
CV_EVENT_RBUTTONDOWN = 2;
|
|
CV_EVENT_MBUTTONDOWN = 3;
|
|
CV_EVENT_LBUTTONUP = 4;
|
|
CV_EVENT_RBUTTONUP = 5;
|
|
CV_EVENT_MBUTTONUP = 6;
|
|
CV_EVENT_LBUTTONDBLCLK = 7;
|
|
CV_EVENT_RBUTTONDBLCLK = 8;
|
|
CV_EVENT_MBUTTONDBLCLK = 9;
|
|
CV_EVENT_FLAG_LBUTTON = 1;
|
|
CV_EVENT_FLAG_RBUTTON = 2;
|
|
CV_EVENT_FLAG_MBUTTON = 4;
|
|
CV_EVENT_FLAG_CTRLKEY = 8;
|
|
CV_EVENT_FLAG_SHIFTKEY = 16;
|
|
CV_EVENT_FLAG_ALTKEY = 32;
|
|
|
|
type
|
|
CvMouseCallback = procedure(event: Integer; x: Integer; y: Integer; flags: Integer; param: Pointer); cdecl;
|
|
|
|
(* assign callback for mouse events *)
|
|
// CVAPI(procedure)cvSetMouseCallback(var 8 bit = 0; color or not * )
|
|
{
|
|
CVAPI(void) cvSetMouseCallback( const char* window_name, CvMouseCallback on_mouse,
|
|
void* param CV_DEFAULT(NULL));
|
|
}
|
|
|
|
Type
|
|
// typedef void (CV_CDECL *CvMouseCallback )(int event, int x, int y, int flags, void* param);
|
|
TCvMouseCallback = procedure(event: Integer; x, y, flags: Integer; param: Pointer); cdecl;
|
|
|
|
procedure cvSetMouseCallback(const window_name: pCvChar; on_mouse: TCvMouseCallback; param: Pointer = nil); cdecl;
|
|
|
|
const
|
|
CV_LOAD_IMAGE_UNCHANGED = -1;
|
|
(* 8bit= 1; gray *)
|
|
CV_LOAD_IMAGE_GRAYSCALE = 0;
|
|
(* ?= 2; color *)
|
|
CV_LOAD_IMAGE_COLOR = 1;
|
|
(* any depth= 3; ? *)
|
|
CV_LOAD_IMAGE_ANYDEPTH = 2;
|
|
(* ?= 4; any color *)
|
|
CV_LOAD_IMAGE_ANYCOLOR = 4;
|
|
|
|
(* load image from file iscolor can be a combination of above flags where
|
|
CV_LOAD_IMAGE_UNCHANGED overrides the other flags
|
|
using CV_LOAD_IMAGE_ANYCOLOR alone is equivalent to CV_LOAD_IMAGE_UNCHANGED
|
|
unless CV_LOAD_IMAGE_ANYDEPTH is specified images are converted to 8bit *)
|
|
// CVAPI(IplImage*) cvLoadImage(const char* filename,int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
|
|
function cvLoadImage(const filename: pCvChar; iscolor: Integer = CV_LOAD_IMAGE_UNCHANGED): pIplImage; cdecl;
|
|
|
|
(*
|
|
CVAPI(CvMat* ) cvLoadImageM( const char* filename, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
|
|
*)
|
|
function cvLoadImageM(const filename: pCvChar; iscolor: Integer = CV_LOAD_IMAGE_COLOR): pCvMat; cdecl;
|
|
|
|
const
|
|
CV_IMWRITE_JPEG_QUALITY = 1;
|
|
CV_IMWRITE_PNG_COMPRESSION = 16;
|
|
CV_IMWRITE_PNG_STRATEGY = 17;
|
|
CV_IMWRITE_PNG_STRATEGY_DEFAULT = 0;
|
|
CV_IMWRITE_PNG_STRATEGY_FILTERED = 1;
|
|
CV_IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY = 2;
|
|
CV_IMWRITE_PNG_STRATEGY_RLE = 3;
|
|
CV_IMWRITE_PNG_STRATEGY_FIXED = 4;
|
|
CV_IMWRITE_PXM_BINARY = 32;
|
|
|
|
(* save image to file *)
|
|
// CVAPI(Integer)cvSaveImage(PCVChar filename, CvArr * image,
|
|
// function params CV_DEFAULT(v1: 0)): Integer;
|
|
{
|
|
CVAPI(int) cvSaveImage( const char* filename, const CvArr* image, const int* params CV_DEFAULT(0) );
|
|
}
|
|
|
|
// function cvSaveImage(const filename: pCVChar; const image: pIplImage; const params: PInteger = nil): Integer; cdecl;
|
|
function cvSaveImage(const filename: pCvChar; const image: Pointer; const params: PInteger = nil): Integer; cdecl;
|
|
|
|
(*
|
|
decode image stored in the buffer
|
|
|
|
CVAPI(IplImage* ) cvDecodeImage( const CvMat* buf, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
|
|
*)
|
|
function cvDecodeImage(const buf: pCvMat; iscolor: Integer = CV_LOAD_IMAGE_COLOR): pIplImage; cdecl;
|
|
(*
|
|
CVAPI(CvMat* ) cvDecodeImageM( const CvMat* buf, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
|
|
*)
|
|
function cvDecodeImageM(const buf: pCvMat; iscolor: Integer = CV_LOAD_IMAGE_COLOR): pCvMat; cdecl;
|
|
(*
|
|
encode image and store the result as a byte vector (single-row 8uC1 matrix)
|
|
|
|
CVAPI(CvMat* cvEncodeImage( const char* ext, const CvArr* image,
|
|
const int* params CV_DEFAULT(0) );
|
|
*)
|
|
function cvEncodeImage(const ext: pCvChar; const image: pCvArr; const params: PInteger = nil): pCvMat; cdecl;
|
|
|
|
const
|
|
(* enum
|
|
{
|
|
CV_CVTIMG_FLIP =1,
|
|
CV_CVTIMG_SWAP_RB =2
|
|
}; *)
|
|
CV_CVTIMG_FLIP = 1;
|
|
CV_CVTIMG_SWAP_RB = 2;
|
|
(*
|
|
utility function: convert one image to another with optional vertical flip
|
|
*)
|
|
(*
|
|
CVAPI(void) cvConvertImage( const CvArr* src, CvArr* dst, int flags CV_DEFAULT(0));
|
|
*)
|
|
procedure cvConvertImage(const src: pCvArr; dst: pCvArr; flags: Integer = 0); cdecl; overload;
|
|
|
|
{
|
|
/* utility function: convert one image to another with optional vertical flip */
|
|
CVAPI(void) cvConvertImage( const CvArr* src, CvArr* dst, int flags CV_DEFAULT(0));
|
|
}
|
|
procedure cvConvertImage(const src: pIplImage; dst: pIplImage; flags: Integer = 0); cdecl; overload;
|
|
|
|
(* wait for key event infinitely (delay<=0) or for "delay" milliseconds *)
|
|
function cvWaitKey(delay: Integer = 0): Integer; cdecl;
|
|
|
|
// OpenGL support
|
|
|
|
// type
|
|
// CvOpenGlDrawCallback = procedure(v1:var userdata); cdecl;
|
|
// CVAPI( procedure)cvSetOpenGlDrawCallback(v1: 0));
|
|
|
|
// CVAPI( procedure)cvSetOpenGlContext(window_name: PCVChar);
|
|
// CVAPI(procedure)cvUpdateWindow(window_name: PCVChar);
|
|
|
|
(* ***************************************************************************************\
|
|
* Working with Video Files and Cameras *
|
|
*************************************************************************************** *)
|
|
|
|
type
|
|
(* "black box" capture structure *)
|
|
TCvCapture = record
|
|
end;
|
|
|
|
pCvCapture = ^TCvCapture;
|
|
|
|
(* start capturing frames from video file *)
|
|
// CVAPI(CvCapture*) cvCreateFileCapture( const char* filename );
|
|
function cvCreateFileCapture(const filename: pCvChar): pCvCapture; cdecl;
|
|
|
|
const
|
|
CV_CAP_ANY = 0; // autodetect
|
|
CV_CAP_CAM_0 = CV_CAP_ANY;
|
|
CV_CAP_CAM_1 = 1;
|
|
CV_CAP_CAM_2 = 2;
|
|
CV_CAP_CAM_3 = 3;
|
|
CV_CAP_CAM_4 = 4;
|
|
CV_CAP_CAM_5 = 5;
|
|
CV_CAP_MIL = 100; // MIL proprietary drivers
|
|
CV_CAP_VFW = 200; // platform native
|
|
CV_CAP_V4L = 200;
|
|
CV_CAP_V4L2 = 200;
|
|
CV_CAP_FIREWARE = 300; // IEEE 1394 drivers
|
|
CV_CAP_FIREWIRE = 300;
|
|
CV_CAP_IEEE1394 = 300;
|
|
CV_CAP_DC1394 = 300;
|
|
CV_CAP_CMU1394 = 300;
|
|
CV_CAP_STEREO = 400;
|
|
// TYZX proprietary drivers
|
|
CV_CAP_TYZX = 400;
|
|
CV_TYZX_LEFT = 400;
|
|
CV_TYZX_RIGHT = 401;
|
|
CV_TYZX_COLOR = 402;
|
|
CV_TYZX_Z = 403;
|
|
CV_CAP_QT = 500;
|
|
// QuickTime
|
|
CV_CAP_UNICAP = 600; // Unicap drivers
|
|
CV_CAP_DSHOW = 700; // DirectShow (via videoInput)
|
|
CV_CAP_PVAPI = 800; // PvAPI; Prosilica GigE SDK
|
|
CV_CAP_OPENNI = 900; // OpenNI (for Kinect)
|
|
CV_CAP_OPENNI_ASUS = 910; // OpenNI (for Asus Xtion)
|
|
CV_CAP_ANDROID = 1000; // Android
|
|
CV_CAP_XIAPI = 1100; // XIMEA Camera API
|
|
CV_CAP_AVFOUNDATION = 1200;
|
|
// AVFoundation framework for iOS (OS X Lion will have the same API);
|
|
|
|
(* start capturing frames from camera: index = camera_index + domain_offset (CV_CAP_ *)
|
|
// CVAPI(CvCapture)cvCreateCameraCapture(Integer index);
|
|
function cvCreateCameraCapture(index: Longint): pCvCapture; cdecl;
|
|
|
|
(*
|
|
grab a frame, return 1 on success, 0 on fail.
|
|
this function is thought to be fast
|
|
|
|
CVAPI(int) cvGrabFrame( CvCapture* capture );
|
|
*)
|
|
function cvGrabFrame(capture: pCvCapture): Integer; cdecl;
|
|
|
|
(*
|
|
get the frame grabbed with cvGrabFrame(..)
|
|
This function may apply some frame processing like
|
|
frame decompression, flipping etc.
|
|
!!!DO NOT RELEASE or MODIFY the retrieved frame!!!
|
|
|
|
CVAPI(IplImage* ) cvRetrieveFrame( CvCapture* capture, int streamIdx CV_DEFAULT(0) );
|
|
*)
|
|
function cvRetrieveFrame(capture: pCvCapture; streamIdx: Integer = 0): pIplImage; cdecl;
|
|
|
|
(* Just a combination of cvGrabFrame and cvRetrieveFrame
|
|
not not not DO NOT RELEASE or MODIFY the retrieved frame not not not *)
|
|
// CVAPI(IplImage*) cvQueryFrame( CvCapture* capture );
|
|
function cvQueryFrame(capture: pCvCapture): pIplImage; cdecl;
|
|
|
|
(* stop capturing/reading and free resources *)
|
|
// CVAPI(void) cvReleaseCapture( CvCapture** capture );
|
|
procedure cvReleaseCapture(Var capture: pCvCapture); cdecl;
|
|
|
|
// modes of the controlling registers (can be: auto; manual; auto single push; absolute Latter allowed with any other mode)
|
|
// every feature can have only one mode turned on at a time;
|
|
const
|
|
CV_CAP_PROP_DC1394_OFF = -4;
|
|
// turn the feature off (not controlled manually nor automatically)
|
|
CV_CAP_PROP_DC1394_MODE_MANUAL = -3;
|
|
// set automatically when a value of the feature is set by the user
|
|
CV_CAP_PROP_DC1394_MODE_AUTO = -2;
|
|
CV_CAP_PROP_DC1394_MODE_ONE_PUSH_AUTO = -1;
|
|
CV_CAP_PROP_POS_MSEC = 0;
|
|
CV_CAP_PROP_POS_FRAMES = 1;
|
|
CV_CAP_PROP_POS_AVI_RATIO = 2;
|
|
CV_CAP_PROP_FRAME_WIDTH = 3;
|
|
CV_CAP_PROP_FRAME_HEIGHT = 4;
|
|
CV_CAP_PROP_FPS = 5;
|
|
CV_CAP_PROP_FOURCC = 6;
|
|
CV_CAP_PROP_FRAME_COUNT = 7;
|
|
CV_CAP_PROP_FORMAT = 8;
|
|
CV_CAP_PROP_MODE = 9;
|
|
CV_CAP_PROP_BRIGHTNESS = 10;
|
|
CV_CAP_PROP_CONTRAST = 11;
|
|
CV_CAP_PROP_SATURATION = 12;
|
|
CV_CAP_PROP_HUE = 13;
|
|
CV_CAP_PROP_GAIN = 14;
|
|
CV_CAP_PROP_EXPOSURE = 15;
|
|
CV_CAP_PROP_CONVERT_RGB = 16;
|
|
CV_CAP_PROP_WHITE_BALANCE_BLUE_U = 17;
|
|
CV_CAP_PROP_RECTIFICATION = 18;
|
|
CV_CAP_PROP_MONOCROME = 19;
|
|
CV_CAP_PROP_SHARPNESS = 20;
|
|
CV_CAP_PROP_AUTO_EXPOSURE = 21; // exposure control done by camera;
|
|
// user can adjust refernce level;
|
|
// using this feature;
|
|
CV_CAP_PROP_GAMMA = 22;
|
|
CV_CAP_PROP_TEMPERATURE = 23;
|
|
CV_CAP_PROP_TRIGGER = 24;
|
|
CV_CAP_PROP_TRIGGER_DELAY = 25;
|
|
CV_CAP_PROP_WHITE_BALANCE_RED_V = 26;
|
|
CV_CAP_PROP_ZOOM = 27;
|
|
CV_CAP_PROP_FOCUS = 28;
|
|
CV_CAP_PROP_GUID = 29;
|
|
CV_CAP_PROP_ISO_SPEED = 30;
|
|
CV_CAP_PROP_MAX_DC1394 = 31;
|
|
CV_CAP_PROP_BACKLIGHT = 32;
|
|
CV_CAP_PROP_PAN = 33;
|
|
CV_CAP_PROP_TILT = 34;
|
|
CV_CAP_PROP_ROLL = 35;
|
|
CV_CAP_PROP_IRIS = 36;
|
|
CV_CAP_PROP_SETTINGS = 37;
|
|
CV_CAP_PROP_AUTOGRAB = 1024; // property for highgui class CvCapture_Android only
|
|
CV_CAP_PROP_SUPPORTED_PREVIEW_SIZES_STRING = 1025;
|
|
// readonly; tricky property; returns cpnst char* indeed
|
|
CV_CAP_PROP_PREVIEW_FORMAT = 1026; // readonly; tricky property; returns cpnst char* indeed
|
|
// OpenNI map generators;
|
|
CV_CAP_OPENNI_DEPTH_GENERATOR = 1 shl 31;
|
|
CV_CAP_OPENNI_IMAGE_GENERATOR = 1 shl 30;
|
|
CV_CAP_OPENNI_GENERATORS_MASK = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_OPENNI_IMAGE_GENERATOR;
|
|
// Properties of cameras available through OpenNI interfaces;
|
|
CV_CAP_PROP_OPENNI_OUTPUT_MODE = 100;
|
|
CV_CAP_PROP_OPENNI_FRAME_MAX_DEPTH = 101; // in mm
|
|
CV_CAP_PROP_OPENNI_BASELINE = 102; // in mm
|
|
CV_CAP_PROP_OPENNI_FOCAL_LENGTH = 103; // in pixels
|
|
CV_CAP_PROP_OPENNI_REGISTRATION = 104; // flag
|
|
CV_CAP_PROP_OPENNI_REGISTRATION_ON = CV_CAP_PROP_OPENNI_REGISTRATION;
|
|
// flag that synchronizes the remapping depth map to image map
|
|
// by changing depth generator's view point (if the flag is "on") or;
|
|
// sets this view point to its normal one (if the flag is "off").;
|
|
CV_CAP_PROP_OPENNI_APPROX_FRAME_SYNC = 105;
|
|
CV_CAP_PROP_OPENNI_MAX_BUFFER_SIZE = 106;
|
|
CV_CAP_PROP_OPENNI_CIRCLE_BUFFER = 107;
|
|
CV_CAP_PROP_OPENNI_MAX_TIME_DURATION = 108;
|
|
CV_CAP_PROP_OPENNI_GENERATOR_PRESENT = 109;
|
|
CV_CAP_OPENNI_IMAGE_GENERATOR_PRESENT = CV_CAP_OPENNI_IMAGE_GENERATOR + CV_CAP_PROP_OPENNI_GENERATOR_PRESENT;
|
|
CV_CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE = CV_CAP_OPENNI_IMAGE_GENERATOR + CV_CAP_PROP_OPENNI_OUTPUT_MODE;
|
|
CV_CAP_OPENNI_DEPTH_GENERATOR_BASELINE = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_BASELINE;
|
|
CV_CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_FOCAL_LENGTH;
|
|
CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_REGISTRATION;
|
|
CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION_ON = CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION;
|
|
// Properties of cameras available through GStreamer interface;
|
|
CV_CAP_GSTREAMER_QUEUE_LENGTH = 200; // default is 1
|
|
CV_CAP_PROP_PVAPI_MULTICASTIP = 300;
|
|
// ip for anable multicast master mode. 0 for disable multicast
|
|
// Properties of cameras available through XIMEA SDK interface;
|
|
CV_CAP_PROP_XI_DOWNSAMPLING = 400; // Change image resolution by binning or skipping.
|
|
CV_CAP_PROP_XI_DATA_FORMAT = 401; // Output data format.
|
|
CV_CAP_PROP_XI_OFFSET_X = 402;
|
|
// Horizontal offset from the origin to the area of interest (in pixels).
|
|
CV_CAP_PROP_XI_OFFSET_Y = 403;
|
|
// Vertical offset from the origin to the area of interest (in pixels).
|
|
CV_CAP_PROP_XI_TRG_SOURCE = 404; // Defines source of trigger.
|
|
CV_CAP_PROP_XI_TRG_SOFTWARE = 405;
|
|
// Generates an internal trigger. PRM_TRG_SOURCE must be set to TRG_SOFTWARE.
|
|
CV_CAP_PROP_XI_GPI_SELECTOR = 406; // Selects general purpose input
|
|
CV_CAP_PROP_XI_GPI_MODE = 407; // Set general purpose input mode
|
|
CV_CAP_PROP_XI_GPI_LEVEL = 408; // Get general purpose level
|
|
CV_CAP_PROP_XI_GPO_SELECTOR = 409; // Selects general purpose output
|
|
CV_CAP_PROP_XI_GPO_MODE = 410; // Set general purpose output mode
|
|
CV_CAP_PROP_XI_LED_SELECTOR = 411; // Selects camera signalling LED
|
|
CV_CAP_PROP_XI_LED_MODE = 412; // Define camera signalling LED functionality
|
|
CV_CAP_PROP_XI_MANUAL_WB = 413; // Calculates White Balance(must be called during acquisition)
|
|
CV_CAP_PROP_XI_AUTO_WB = 414; // Automatic white balance
|
|
CV_CAP_PROP_XI_AEAG = 415; // Automatic exposure/gain
|
|
CV_CAP_PROP_XI_EXP_PRIORITY = 416; // Exposure priority (0.5 - exposure 50%; gain 50%).
|
|
CV_CAP_PROP_XI_AE_MAX_LIMIT = 417;
|
|
// Maximum limit of exposure in AEAG procedure CV_CAP_PROP_XI_AG_MAX_LIMIT = 418; // Maximum limit of gain in AEAG procedure
|
|
CV_CAP_PROP_XI_AEAG_LEVEL = 419;
|
|
// Average intensity of output signal AEAG should achieve(in %)
|
|
CV_CAP_PROP_XI_TIMEOUT = 420; // Image capture timeout in milliseconds
|
|
// Properties for Android cameras;
|
|
CV_CAP_PROP_ANDROID_FLASH_MODE = 8001;
|
|
CV_CAP_PROP_ANDROID_FOCUS_MODE = 8002;
|
|
CV_CAP_PROP_ANDROID_WHITE_BALANCE = 8003;
|
|
CV_CAP_PROP_ANDROID_ANTIBANDING = 8004;
|
|
CV_CAP_PROP_ANDROID_FOCAL_LENGTH = 8005;
|
|
CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_NEAR = 8006;
|
|
CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_OPTIMAL = 8007;
|
|
CV_CAP_PROP_ANDROID_FOCUS_DISTANCE_FAR = 8008;
|
|
// Properties of cameras available through AVFOUNDATION interface;
|
|
CV_CAP_PROP_IOS_DEVICE_FOCUS = 9001;
|
|
CV_CAP_PROP_IOS_DEVICE_EXPOSURE = 9002;
|
|
CV_CAP_PROP_IOS_DEVICE_FLASH = 9003;
|
|
CV_CAP_PROP_IOS_DEVICE_WHITEBALANCE = 9004;
|
|
CV_CAP_PROP_IOS_DEVICE_TORCH = 9005;
|
|
// Data given from depth generator.;
|
|
CV_CAP_OPENNI_DEPTH_MAP = 0; // Depth values in mm (CV_16UC1)
|
|
CV_CAP_OPENNI_POINT_CLOUD_MAP = 1; // XYZ in meters (CV_32FC3)
|
|
CV_CAP_OPENNI_DISPARITY_MAP = 2; // Disparity in pixels (CV_8UC1)
|
|
CV_CAP_OPENNI_DISPARITY_MAP_32F = 3; // Disparity in pixels (CV_32FC1)
|
|
CV_CAP_OPENNI_VALID_DEPTH_MASK = 4; // CV_8UC1
|
|
// Data given from RGB image generator.;
|
|
CV_CAP_OPENNI_BGR_IMAGE = 5;
|
|
CV_CAP_OPENNI_GRAY_IMAGE = 6;
|
|
// Supported output modes of OpenNI image generator
|
|
CV_CAP_OPENNI_VGA_30HZ = 0;
|
|
CV_CAP_OPENNI_SXGA_15HZ = 1;
|
|
CV_CAP_OPENNI_SXGA_30HZ = 2;
|
|
// supported by Android camera output formats
|
|
CV_CAP_ANDROID_COLOR_FRAME_BGR = 0; // BGR
|
|
CV_CAP_ANDROID_COLOR_FRAME = CV_CAP_ANDROID_COLOR_FRAME_BGR;
|
|
CV_CAP_ANDROID_GREY_FRAME = 1; // Y
|
|
CV_CAP_ANDROID_COLOR_FRAME_RGB = 2;
|
|
CV_CAP_ANDROID_COLOR_FRAME_BGRA = 3;
|
|
CV_CAP_ANDROID_COLOR_FRAME_RGBA = 4;
|
|
// supported Android camera flash modes
|
|
CV_CAP_ANDROID_FLASH_MODE_AUTO = 0;
|
|
CV_CAP_ANDROID_FLASH_MODE_OFF = 0;
|
|
CV_CAP_ANDROID_FLASH_MODE_ON = 1;
|
|
CV_CAP_ANDROID_FLASH_MODE_RED_EYE = 2;
|
|
CV_CAP_ANDROID_FLASH_MODE_TORCH = 3;
|
|
// supported Android camera focus modes
|
|
CV_CAP_ANDROID_FOCUS_MODE_AUTO = 0;
|
|
CV_CAP_ANDROID_FOCUS_MODE_CONTINUOUS_VIDEO = 0;
|
|
CV_CAP_ANDROID_FOCUS_MODE_EDOF = 1;
|
|
CV_CAP_ANDROID_FOCUS_MODE_FIXED = 2;
|
|
CV_CAP_ANDROID_FOCUS_MODE_INFINITY = 3;
|
|
CV_CAP_ANDROID_FOCUS_MODE_MACRO = 4;
|
|
// supported Android camera white balance modes
|
|
CV_CAP_ANDROID_WHITE_BALANCE_AUTO = 0;
|
|
CV_CAP_ANDROID_WHITE_BALANCE_CLOUDY_DAYLIGHT = 0;
|
|
CV_CAP_ANDROID_WHITE_BALANCE_DAYLIGHT = 1;
|
|
CV_CAP_ANDROID_WHITE_BALANCE_FLUORESCENT = 2;
|
|
CV_CAP_ANDROID_WHITE_BALANCE_INCANDESCENT = 3;
|
|
CV_CAP_ANDROID_WHITE_BALANCE_SHADE = 4;
|
|
CV_CAP_ANDROID_WHITE_BALANCE_TWILIGHT = 5;
|
|
CV_CAP_ANDROID_WHITE_BALANCE_WARM_FLUORESCENT = 6;
|
|
// supported Android camera antibanding modes
|
|
CV_CAP_ANDROID_ANTIBANDING_50HZ = 0;
|
|
CV_CAP_ANDROID_ANTIBANDING_60HZ = 0;
|
|
CV_CAP_ANDROID_ANTIBANDING_AUTO = 1;
|
|
CV_CAP_ANDROID_ANTIBANDING_OFF = 2;
|
|
|
|
(* retrieve or set capture properties *)
|
|
function cvGetCaptureProperty(capture: pCvCapture; property_id: Integer): Double; cdecl;
|
|
function cvSetCaptureProperty(capture: pCvCapture; property_id: Integer; value: Double): Integer; cdecl;
|
|
|
|
// Return the type of the capturer (eg, CV_CAP_V4W, CV_CAP_UNICAP), which is unknown if created with CV_CAP_ANY
|
|
(*
|
|
CVAPI(int) cvGetCaptureDomain( CvCapture* capture);
|
|
*)
|
|
function cvGetCaptureDomain(capture: pCvCapture): Integer; cdecl;
|
|
|
|
type
|
|
(* "black box" video file writer structure *)
|
|
TCvVideoWriter = Integer;
|
|
pCvVideoWriter = ^TCvVideoWriter;
|
|
ppCvVideoWriter = ^pCvVideoWriter;
|
|
//
|
|
// CV_INLINE
|
|
// function CV_FOURCC(and 255) + ((c2 and 255) shl 8) + ((c3 and 255) shl 16) +
|
|
// ((c4 and 255) shl 24: c1): Integer;
|
|
// end;
|
|
|
|
const
|
|
CV_FOURCC_PROMPT = -1; (* Open Codec Selection Dialog (Windows only) *)
|
|
{$EXTERNALSYM CV_FOURCC_PROMPT}
|
|
// const
|
|
// CV_FOURCC_DEFAULT = CV_FOURCC('I', 'Y', 'U',
|
|
// 'V'( / * Use default codec for specified filename(Linux only) * /;
|
|
// {$EXTERNALSYM CV_FOURCC_DEFAULT}
|
|
// (* initialize video file writer *)
|
|
|
|
// CVAPI(CvVideoWriter)cvCreateVideoWriter(PCVChar filename, Integer fourcc, Double fps,
|
|
// CvSize frame_size,
|
|
// function is_color CV_DEFAULT(v1: 1)): Integer;
|
|
{
|
|
CVAPI(CvVideoWriter*) cvCreateVideoWriter( const char* filename, int fourcc,
|
|
double fps, CvSize frame_size,
|
|
int is_color CV_DEFAULT(1));
|
|
}
|
|
function cvCreateVideoWriter(const filename: pCvChar; fourcc: Integer; fps: Double; frame_size: TCvSize; is_color: Integer = 1)
|
|
: pCvVideoWriter; cdecl;
|
|
|
|
function CV_FOURCC(const c1, c2, c3, c4: CVChar): Integer; {$IFDEF USE_INLINE}inline; {$ENDIF}
|
|
// CVAPI(CvVideoWriter*) cvCreateImageSequenceWriter( const char* filename,
|
|
// int is_color CV_DEFAULT(1));
|
|
|
|
(* write frame to video file *)
|
|
// CVAPI(Integer)cvWriteFrame(CvVideoWriter * writer, IplImage * image);
|
|
function cvWriteFrame(writer: pCvVideoWriter; image: pIplImage): Integer; cdecl;
|
|
|
|
(* close video file writer *)
|
|
// CVAPI(procedure)cvReleaseVideoWriter(writer: array of CvVideoWriter);
|
|
procedure cvReleaseVideoWriter(Var writer: pCvVideoWriter); cdecl;
|
|
|
|
(* ***************************************************************************************\
|
|
* Obsolete functions/synonyms *
|
|
*************************************************************************************** *)
|
|
|
|
// const cvCaptureFromFile = cvCreateFileCapture;
|
|
// {$EXTERNALSYM cvCaptureFromFile}
|
|
// const cvCaptureFromCAM = cvCreateCameraCapture;
|
|
// {$EXTERNALSYM cvCaptureFromCAM}
|
|
// const cvCaptureFromAVI = cvCaptureFromFile;
|
|
// {$EXTERNALSYM cvCaptureFromAVI}
|
|
// const cvCreateAVIWriter = cvCreateVideoWriter;
|
|
// {$EXTERNALSYM cvCreateAVIWriter}
|
|
// const cvWriteToAVI = cvWriteFrame;
|
|
// {$EXTERNALSYM cvWriteToAVI}
|
|
// {$DEFINE cvAddSearchPath(path)}
|
|
// const cvvInitSystem = cvInitSystem;
|
|
// {$EXTERNALSYM cvvInitSystem}
|
|
// const cvvNamedWindow = cvNamedWindow;
|
|
// {$EXTERNALSYM cvvNamedWindow}
|
|
// const cvvShowImage = cvShowImage;
|
|
// {$EXTERNALSYM cvvShowImage}
|
|
// const cvvResizeWindow = cvResizeWindow;
|
|
// {$EXTERNALSYM cvvResizeWindow}
|
|
// const cvvDestroyWindow = cvDestroyWindow;
|
|
// {$EXTERNALSYM cvvDestroyWindow}
|
|
// const cvvCreateTrackbar = cvCreateTrackbar;
|
|
// {$EXTERNALSYM cvvCreateTrackbar}
|
|
/// / >> Following declaration is a macro definition!
|
|
// const cvvLoadImage(name)cvLoadImage((name), 1);
|
|
//
|
|
// const cvvSaveImage = cvSaveImage;
|
|
// {$EXTERNALSYM cvvSaveImage}
|
|
// const cvvAddSearchPath = cvAddSearchPath;
|
|
// {$EXTERNALSYM cvvAddSearchPath}
|
|
/// / >> Following declaration is a macro definition!
|
|
// const cvvWaitKey(name)cvWaitKey(0);
|
|
//
|
|
/// / >> Following declaration is a macro definition!
|
|
// const cvvWaitKeyEx(name, delay)cvWaitKey(delay);
|
|
//
|
|
// const cvvConvertImage = cvConvertImage;
|
|
// {$EXTERNALSYM cvvConvertImage}
|
|
// const HG_AUTOSIZE = CV_WINDOW_AUTOSIZE;
|
|
// {$EXTERNALSYM HG_AUTOSIZE}
|
|
// const set_preprocess_func = cvSetPreprocessFuncWin32;
|
|
// {$EXTERNALSYM set_preprocess_func}
|
|
// const set_postprocess_func = cvSetPostprocessFuncWin32;
|
|
// {$EXTERNALSYM set_postprocess_func}
|
|
// {$IFNDEF WIN32 || defined _WIN32}
|
|
// CVAPI(
|
|
// procedure)cvSetPreprocessFuncWin32_(callback: Pointer); CVAPI(
|
|
// procedure)cvSetPostprocessFuncWin32_(callback: Pointer);
|
|
//
|
|
/// / >> Following declaration is a macro definition!
|
|
// const cvSetPreprocessFuncWin32(callback)cvSetPreprocessFuncWin32_
|
|
// ((# define cvSetPreprocessFuncWin32(callback)cvSetPreprocessFuncWin32_((
|
|
// procedure((callback): ();
|
|
|
|
// {$ENDIF}
|
|
// {$IFDEF __cplusplus}
|
|
// end;
|
|
|
|
// {$ENDIF}
|
|
// {$ENDIF}
|
|
implementation
|
|
|
|
uses ocv.lib;
|
|
|
|
function cvNamedWindow; external highgui_lib;
|
|
procedure cvShowImage; external highgui_lib;
|
|
function cvWaitKey; external highgui_lib;
|
|
procedure cvDestroyWindow; external highgui_lib;
|
|
procedure cvDestroyAllWindows; external highgui_lib;
|
|
function cvLoadImage; external highgui_lib;
|
|
function cvCreateFileCapture; external highgui_lib;
|
|
function cvQueryFrame; external highgui_lib;
|
|
procedure cvReleaseCapture; external highgui_lib;
|
|
function cvSetCaptureProperty; external highgui_lib;
|
|
function cvGetCaptureProperty; external highgui_lib;
|
|
function cvCreateTrackbar; external highgui_lib;
|
|
function cvCreateCameraCapture; external highgui_lib;
|
|
function cvSaveImage; external highgui_lib;
|
|
function cvCreateVideoWriter; external highgui_lib;
|
|
function cvWriteFrame; external highgui_lib;
|
|
procedure cvReleaseVideoWriter; external highgui_lib;
|
|
procedure cvSetMouseCallback; external highgui_lib;
|
|
procedure cvConvertImage(const src: pCvArr; dst: pCvArr; flags: Integer = 0); cdecl; overload; external highgui_lib;
|
|
procedure cvConvertImage(const src: pIplImage; dst: pIplImage; flags: Integer = 0); cdecl; overload; external highgui_lib;
|
|
procedure cvMoveWindow; external highgui_lib;
|
|
|
|
function CV_FOURCC(const c1, c2, c3, c4: CVChar): Integer; {$IFDEF USE_INLINE}inline; {$ENDIF}
|
|
begin
|
|
Result := Integer(c1) + (Integer(c2) shl 8) + (Integer(c3) shl 16) + (Integer(c4) shl 24);
|
|
end;
|
|
|
|
procedure cvResizeWindow; external highgui_lib;
|
|
procedure cvSetWindowProperty; external highgui_lib;
|
|
function cvGetWindowProperty; external highgui_lib;
|
|
function cvInitSystem; external highgui_lib;
|
|
function cvStartWindowThread; external highgui_lib;
|
|
function cvCreateTrackbar2; external highgui_lib;
|
|
|
|
function cvGetTrackbarPos; external highgui_lib;
|
|
procedure cvSetTrackbarPos; external highgui_lib;
|
|
|
|
function cvFontQt; external highgui_lib;
|
|
procedure cvAddText; external highgui_lib;
|
|
procedure cvDisplayOverlay; external highgui_lib;
|
|
procedure cvDisplayStatusBar; external highgui_lib;
|
|
procedure cvSaveWindowParameters; external highgui_lib;
|
|
procedure cvLoadWindowParameters; external highgui_lib;
|
|
function cvStartLoop; external highgui_lib;
|
|
procedure cvStopLoop; external highgui_lib;
|
|
function cvCreateButton; external highgui_lib;
|
|
function cvGetWindowHandle; external highgui_lib;
|
|
function cvGetWindowName; external highgui_lib;
|
|
function cvLoadImageM; external highgui_lib;
|
|
function cvDecodeImage; external highgui_lib;
|
|
function cvDecodeImageM; external highgui_lib;
|
|
function cvEncodeImage; external highgui_lib;
|
|
procedure cvSetOpenGlDrawCallback; external highgui_lib;
|
|
procedure cvSetOpenGlContext; external highgui_lib;
|
|
procedure cvUpdateWindow; external highgui_lib;
|
|
function cvGrabFrame; external highgui_lib;
|
|
function cvRetrieveFrame; external highgui_lib;
|
|
function cvGetCaptureDomain; external highgui_lib;
|
|
procedure cvSetPreprocessFuncWin32_; external highgui_lib;
|
|
procedure cvSetPostprocessFuncWin32_; external highgui_lib;
|
|
|
|
end.
|