Im trying to convert this autoit OpenCv example to autohotkey
Here is my code up to now
Code: Select all
#NoEnv
#Persistent
#SingleInstance Force
SetBatchLines, -1
#Include <OpenCV>
;#Include <gdip>
; Create a fully opaque red brush (ARGB = Transparency, red, green, blue) to draw a circle
; pBrush := Gdip_BrushCreateSolid(0xffff0000)
; pPen := Gdip_CreatePenFromBrush(pBrush, 1.0)
tagCvContour := ""
. "int flags;" ;sequence flags, including the sequence signature (CV_SEQ_MAGIC_VAL or CV_SET_MAGIC_VAL), type of the elements and some other information about the sequence.
. "int header_size;" ;size of the sequence header. It should be sizeof(CvSeq) at minimum. See CreateSeq().
. "ptr h_next;"
. "ptr h_prev;"
. "ptr v_next;"
. "ptr v_prev;" ;pointers to another sequences in a sequence tree. Sequence trees are used to store hierarchical contour structures, retrieved by FindContours()
. "int total;" ;the number of sequence elements
. "int elem_size;" ;size of each sequence element in bytes
. "ptr block_max;" ;memory storage where the sequence resides. It can be a NULL pointer.
. "ptr w_ptr;" ;pointer to the first data block
. "int delta_elems;"
. "ptr storage;"
. "ptr free_blocks;"
. "ptr first;"
. "int x;"
. "int y;"
. "int width;"
. "int height;"
. "int color;"
. "int reserved1;"
. "int reserved2;"
. "int reserved3;"
. "int padding1;"
. "int padding2;"
file := "Images\shapes.jpg"
; Create OpenCV instance.
cv := new OpenCV()
pImg := cv.LoadImage(file) ; Load IPL type image
; pImg := cv.BmpToIPL(pBitmap) ; Load Bitmap image
cv.ShowImage("Example-in", pImg) ; Display input image inside window
; Create destination images
pimgGrayScale := cv.CreateImage(cv.GetSize(pImg, width, height), 8, 1)
cv.Smooth( pimg, pimg, GAUSSIAN:=2, 3, 3) ;
;cv.ShowImage("Example-in2", pImg) ; Display input image inside window
cv.CvtColor( pimg, pimgGrayScale, cv.Constants.BGR2GRAY) ; BGR2GRAY = 6
;cv.ShowImage("Example-in3", pImg) ; Display input image inside window
;//get ride of some noise by erode and dilate and convert to black and white image
pimgBW := cv.CreateImage( cv.GetSize(pimg), 8, 1) ;
cv.Erode( pimgGrayScale, pimgBW , Null:=0, 3 )
cv.Threshold( pimgBW, pimgBW, 200, 255, cv.Constants.THRESH_BINARY) ;// may need to adjust threshold value (200)
cv.Dilate( pimgBW, pimgBW, Null:=0, 3 )
cv.Threshold( pimgBW, pimgBW, 128, 255, cv.Constants.THRESH_BINARY_INV) ;
;// show black and white image
cv.ShowImage( "Example-bw", pimgBW) ;
; //setup memory block
; Local $pstorage = _cvCreateMemStorage(0); //storage area for all contours
pStorage := cv.CreateMemStorage(0) ; Storage area for all contours
; //setup sequence block
tagCvPoint := ""
. "int x;"
. "int y;"
; Local $pcontours = _cvCreateSeq(0, 64, DllStructGetSize(DllStructCreate($tagCvPoint)), $pstorage);
pcontours := cv.CreateSeq(0, 64, 2*A_PtrSize, pstorage)
msgbox % "Pointer to contours -> " pcontours
;// find all exterior and inner contours in a list format (no vertical)
;// $num_found = _cvFindContours($pimgBW, $pstorage, $pcontours, DllStructGetSize(DllStructCreate($tagCvContour)), $CV_RETR_LIST, $CV_CHAIN_APPROX_SIMPLE, _cvPoint(0,0))
num_found := cv.FindContours(pimgBW, pstorage, pcontours, 8 + NumberOfMembersInTag(tagCvContour)*A_PtrSize, cv.Constants.CV_RETR_LIST, cv.Constants.CHAIN_APPROX_SIMPLE, cv.Point(0,0))
msgbox % "Number of contours found = " num_found
;// cycle through all exterior contours "0x4299500C" or interior contours "0x4299D00C". Remove if statement for both
pnext := pcontours
;for $t = 1 to $num_found
loop % num_found
{
;Local $vnext = DllStructCreate($tagCvSeq,$pnext)
vnext := DllStructCreate_tagCvSeq(pnext)
;$pnext = DllStructGetData($vnext,"h_next")
DllStructGetData(vnext, 8, "ptr") ; h_next = offset = 2*A_ptrsize
;~ If $pnext = 0 Then $pnext = $pcontours + DllStructGetData($vnext,"header_size") ; skip over first sequence which is empty
if (pnext = 0)
pnext := pcontours + DllStructGetData(vnext, 4, "int") ; "header_size" 1*a_ptrsize ; skip over first sequence which is empty
;~ ;// Check if sequence is an exterior contour "0x4299500C"
;~ If DllStructGetData(DllStructCreate($tagCvContour,$pnext),"flags") = 0x4299500C then
flags := DllStructGetData(pnext, 0, "int") ; tagCvContour -> struct | "int flags;" at 0*A_ptrsize
if (flags = 0x4299500C)
{
;~ ; // determine number of elements in sequence and create an array
;~ Local $datasize = DllStructGetData(DllStructCreate($tagCvContour,$pnext),"total")
datasize := DllStructGetData(pnext, 24, "int") ; tagCvContour -> struct | "int total;" at 6*A_ptrsize
;~ dim $apts[$datasize+2][2]
;~ $apts[0][0] = $datasize+1
apts[0, 0] := datasize+1
;~ ; // retrieve x,y values of each points in sequence
;~ ;for $itt = 0 to $datasize -1
itt := 0
loop % datasize ;~ loop % datasize
{
itt := A_index-1
vpoint = cv.GetSeqElem(pnext, itt) ; $vpoint = DllStructCreate($tagCvPoint, _cvGetSeqElem($pnext,$itt))
apts[itt+1, 0] := vpoint & 0xFFFFFFFF ; DllStructGetData($vpoint,"x")
apts[itt+1, 1] := vpoint << 32 ; DllStructGetData($vpoint,"y")
If (itt = 0)
{
apts[datasize+1, 0] := vpoint & 0xFFFFFFFF ;~ $apts[$datasize+1][0] = DllStructGetData($vpoint,"x")
apts[datasize+1, 1] := vpoint << 32 ;~ $apts[$datasize+1][1] = DllStructGetData($vpoint,"y")
}
vpoint := 0 ;~ $vpoint = 0
} ;Next
;~ ; // draw it in autoit gui using gdi drawlines
;~ _GDIPlus_GraphicsDrawLines($hGraphics, $apts)
;Gdip_DrawLines(hGraphics, pPen, apts)
;~ $vnext = 0
vnext := 0
} ;~ EndIf
;~ sleep(1000) ;just to show that each sequence is drawn individually
Sleep 1000
} ;Next
; // Wait for the user to hit a key, then clean up the windows
; _cvWaitKey( 0 ); Opencv function to wait for a key pressed
;cv.WaitKey( 0 )
msgbox % "wait for key"
; Do
; Until GUIGetMsg() = $GUI_EVENT_CLOSE
; ;// Be tidy
; ;//
; _GDIPlus_GraphicsDispose($hGraphics)
; GUIDelete($hGUI)
cv.ReleaseImage( pimgBW ) ;
cv.ReleaseImage( pimgGrayScale ) ;
cv.ReleaseImage( pimg ) ;
cv.DestroyAllWindows() ;
cv.ClearMemStorage( pstorage ) ;
cv.ClearSeq(pcontours) ;
; _Opencv_CloseDLL()
; _GDIPlus_Shutdown()
return
NumberOfMembersInTag(tagCV)
{
RegExReplace(tagCV, ";", ";", OutputVarCount)
return OutputVarCount
}
DllStructCreate_tagCvSeq(pointer="")
{
tagCvSeq := ""
. "int flags;" ; sequence flags, including the sequence signature (CV_SEQ_MAGIC_VAL or CV_SET_MAGIC_VAL), type of the elements and some other information about the sequence.
. "int header_size;" ;size of the sequence header. It should be sizeof(CvSeq) at minimum. See CreateSeq().
. "ptr h_next;"
. "ptr h_prev;"
. "ptr v_next;"
. "ptr v_prev;" ;pointers to another sequences in a sequence tree. Sequence trees are used to store hierarchical contour structures, retrieved by FindContours()
. "int total;" ;the number of sequence elements
. "int elem_size;" ;size of each sequence element in bytes
. "ptr block_max;" ;memory storage where the sequence resides. It can be a NULL pointer.
. "ptr w_ptr;" ;pointer to the first data block
. "int delta_elems;"
. "ptr storage;"
. "ptr free_blocks;"
. "ptr first;"
. "int padding1;"
. "int padding2;"
if (pointer != "")
Struct := pointer
else
VarSetCapacity(Struct, NumberOfMembersInTag(tagCvSeq)*8, 0)
NumPut(flags, struct+0, 0, "int") ; "int flags;" ; sequence flags, including the sequence signature (CV_SEQ_MAGIC_VAL or CV_SET_MAGIC_VAL), type of the elements and some other information about the sequence.
NumPut(header_size, struct+0, 8, "int") ; "int header_size;" ;size of the sequence header. It should be sizeof(CvSeq) at minimum. See CreateSeq().
NumPut(h_next, struct+0, 16, "ptr") ; "ptr h_next;"
NumPut(h_prev, struct+0, 24, "ptr") ; "ptr h_prev;"
NumPut(v_next, struct+0, 32, "ptr") ; "ptr v_next;"
NumPut(v_prev, struct+0, 40, "ptr") ; "ptr v_prev;" ;pointers to another sequences in a sequence tree. Sequence trees are used to store hierarchical contour structures, retrieved by FindContours()
NumPut(total, struct+0, 48, "int") ; "int total;" ;the number of sequence elements
NumPut(elem_size, struct+0, 56, "int") ; "int elem_size;" ;size of each sequence element in bytes
NumPut(block_max, struct+0, 64, "ptr") ; "ptr block_max;" ;memory storage where the sequence resides. It can be a NULL pointer.
NumPut(w_ptr, struct+0, 72, "ptr") ; "ptr w_ptr;" ;pointer to the first data block
NumPut(delta_elems, struct+0, 80, "int") ; "int delta_elems;"
NumPut(storage, struct+0, 88, "ptr") ; "ptr storage;"
NumPut(free_blocks, struct+0, 96, "ptr") ; "ptr free_blocks;"
NumPut(first, struct+0, 104, "ptr") ; "ptr first;"
NumPut(padding1, struct+0, 112, "int") ; "int padding1;"
NumPut(padding2, struct+0, 120, "int") ; "int padding2;"
return &struct
}
DllStructGetData_tagCvSeq_h_next(pointer)
{
pointer := NumGet(pointer+0, 16, "ptr") ; "ptr h_next;"
return pointer
}
DllStructGetData(VarOrAddress, offset, type)
{
return NumGet(VarOrAddress+0, offset, type)
}
~ESC:: ExitAppCode: Select all
class OpenCV {
__New() {
this.Libs := new this.Libs(this)
this.error := this.__Init.error
}
class Constants {
static PI := 3.1415926535897932384626433832795
static LOG2 := 0.69314718055994530941723212145818
static AUTO_STEP := 0x7fffffff
static DEFAULT := 0
static LOAD_IMAGE_UNCHANGED := -1
static LOAD_IMAGE_GRAYSCALE := 0
static LOAD_IMAGE_COLOR := 1
static LOAD_IMAGE_ANYDEPTH := 2
static LOAD_IMAGE_ANYCOLOR := 4
; These 4 flags are used by cvSet/GetWindowProperty
static WND_PROP_FULLSCREEN := 0 ; to change/get window's fullscreen property
static WND_PROP_AUTOSIZE := 1 ; to change/get window's autosize property
static WND_PROP_ASPECTRATIO := 2 ; to change/get window's aspectratio property
static WND_PROP_OPENGL := 3 ; to change/get window's opengl support
; These 3 flags are used by cvNamedWindow and cvSet/GetWindowProperty
static WINDOW_NORMAL := 0x00000000 ; the user can resize the window (no constraint) / also use to switch a fullscreen window to a normal size
static WINDOW_AUTOSIZE := 0x00000001 ; the user cannot resize the window, the size is constrainted by the image displayed
static WINDOW_OPENGL := 0x00001000 ; window with opengl support
; Those flags are only for Qt
static GUI_EXPANDED := 0x00000000 ; status bar and tool bar
static GUI_NORMAL := 0x00000010 ; old fashious way
; These 3 flags are used by cvNamedWindow and cvSet/GetWindowProperty
static WINDOW_FULLSCREEN := 1 ; change the window to fullscreen
static WINDOW_FREERATIO := 0x00000100 ; the image expends as much as it can (no ratio constraint)
static WINDOW_KEEPRATIO := 0x00000000 ; the ration image is respected.
; Video Files and Cameras types and parameters
static CAP_PROP_POS_MSEC := 0
static CAP_PROP_POS_FRAMES := 1
static CAP_PROP_POS_AVI_RATIO := 2
static CAP_PROP_FRAME_WIDTH := 3
static CAP_PROP_FRAME_HEIGHT := 4
static CAP_PROP_FPS := 5
static CAP_PROP_FOURCC := 6
static CAP_PROP_FRAME_COUNT := 7
static CAP_PROP_FORMAT := 8
static CAP_PROP_MODE := 9
static CAP_PROP_BRIGHTNESS := 10
static CAP_PROP_CONTRAST := 11
static CAP_PROP_SATURATION := 12
static CAP_PROP_HUE := 13
static CAP_PROP_GAIN := 14
static CAP_PROP_EXPOSURE := 15
static CAP_PROP_CONVERT_RGB := 16
static CAP_PROP_WHITE_BALANCE_BLUE_U := 17
static CAP_PROP_RECTIFICATION := 18
static CAP_PROP_MONOCROME := 19
static CAP_PROP_SHARPNESS := 20
static CAP_PROP_AUTO_EXPOSURE := 21
static CAP_PROP_GAMMA := 22
static CAP_PROP_TEMPERATURE := 23
static CAP_PROP_TRIGGER := 24
static CAP_PROP_TRIGGER_DELAY := 25
static CAP_PROP_WHITE_BALANCE_RED_V := 26
static CAP_PROP_ZOOM := 27
static CAP_PROP_FOCUS := 28
static CAP_PROP_GUID := 29
static CAP_PROP_ISO_SPEED := 30
static CAP_PROP_MAX_DC1394 := 31
static CAP_PROP_BACKLIGHT := 32
static CAP_PROP_PAN := 33
static CAP_PROP_TILT := 34
static CAP_PROP_ROLL := 35
static CAP_PROP_IRIS := 36
static CAP_PROP_SETTINGS := 37
; Different constant used by opencv for selecting webcam ie. dshow web cam index would be 700, 701, 702, etc...
static CAP_ANY := 0 ; // autodetect
static CAP_MIL := 100 ; // MIL proprietary drivers
static CAP_VFW := 200 ; // platform native
static CAP_V4L := 200 ;
static CAP_V4L2 := 200 ;
static CAP_FIREWARE := 300 ; // IEEE 1394 drivers
static CAP_FIREWIRE := 300 ;
static CAP_IEEE1394 := 300 ;
static CAP_DC1394 := 300 ;
static CAP_CMU1394 := 300 ;
static CAP_STEREO := 400 ; // TYZX proprietary drivers
static CAP_TYZX := 400 ;
static TYZX_LEFT := 400 ;
static TYZX_RIGHT := 401 ;
static TYZX_COLOR := 402 ;
static TYZX_Z := 403 ;
static CAP_QT := 500 ; // QuickTime
static CAP_UNICAP := 600 ; // Unicap drivers
static CAP_DSHOW := 700 ; // DirectShow (via videoInput)
static CAP_MSMF := 1400 ; // Microsoft Media Foundation (via videoInput)
static CAP_PVAPI := 800 ; // PvAPI, Prosilica GigE SDK
static CAP_OPENNI := 900 ; // OpenNI (for Kinect)
static CAP_OPENNI_ASUS := 910 ; // OpenNI (for Asus Xtion)
static CAP_ANDROID := 1000 ; // Android
static CAP_XIAPI := 1100 ; // XIMEA Camera API
static CAP_AVFOUNDATION := 1200 ; // AVFoundation framework for iOS (OS X Lion will have the same API)
static CAP_GIGANETIX := 1300 ; // Smartek Giganetix GigEVisionSDK
;/* Image smooth methods */
static BLUR_NO_SCALE := 0
static BLUR := 1
static GAUSSIAN := 2
static MEDIAN := 3
static BILATERAL := 4
; image types
static IPL_DEPTH_SIGN := 0x80000000
static IPL_DEPTH_1U := 1
static IPL_DEPTH_8U := 8
static IPL_DEPTH_16U := 16
static IPL_DEPTH_32F := 32
static IPL_DEPTH_8S := 0x80000000 | 8
static IPL_DEPTH_16S := 0x80000000 | 16
static IPL_DEPTH_32S := 0x80000000 | 32
; CV channel types
static 8UC1 := 0
static 8UC2 := 8
static 8UC3 := 16
static 8UC4 := 24
static 8SC1 := 1
static 8SC2 := 9
static 8SC3 := 17
static 8SC4 := 25
static 16UC1 := 2
static 16UC2 := 10
static 16UC3 := 18
static 16UC4 := 26
static 16SC1 := 3
static 16SC2 := 11
static 16SC3 := 19
static 16SC4 := 27
static 32SC1 := 3
static 32SC2 := 12
static 32SC3 := 20
static 32SC4 := 28
static 32FC1 := 5
static 32FC2 := 13
static 32FC3 := 21
static 32FC4 := 29
static 64FC1 := 6
static 64FC2 := 14
static 64FC3 := 22
static 64FC4 := 30
; Mouse
static EVENT_MOUSEMOVE := 0
static EVENT_LBUTTONDOWN := 1
static EVENT_RBUTTONDOWN := 2
static EVENT_MBUTTONDOWN := 3
static EVENT_LBUTTONUP := 4
static EVENT_RBUTTONUP := 5
static EVENT_MBUTTONUP := 6
static EVENT_LBUTTONDBLCLK := 7
static EVENT_RBUTTONDBLCLK := 8
static EVENT_MBUTTONDBLCLK := 9
static EVENT_FLAG_LBUTTON := 1
static EVENT_FLAG_RBUTTON := 2
static EVENT_FLAG_MBUTTON := 4
static EVENT_FLAG_CTRLKEY := 8
static EVENT_FLAG_SHIFTKEY := 16
static EVENT_FLAG_ALTKEY := 32
; Save file image format
static IMWRITE_JPEG_QUALITY := 1
static IMWRITE_PNG_COMPRESSION := 16
static IMWRITE_PNG_STRATEGY := 17
static IMWRITE_PNG_BILEVEL := 18
static IMWRITE_PNG_STRATEGY_DEFAULT := 0
static IMWRITE_PNG_STRATEGY_FILTERED := 1
static IMWRITE_PNG_STRATEGY_HUFFMAN_ONLY := 2
static IMWRITE_PNG_STRATEGY_RLE := 3
static IMWRITE_PNG_STRATEGY_FIXED := 4
static IMWRITE_PXM_BINARY := 32
; cvConvertImage flip types
static CVTIMG_FLIP := 1
static CVTIMG_SWAP_RB := 2
; compare operation
static CMP_EQ := 0
static CMP_GT := 1
static CMP_GE := 2
static CMP_LT := 3
static CMP_LE := 4
static CMP_NE := 5
; cvSort flags
static SORT_EVERY_ROW := 0
static SORT_EVERY_COLUMN := 1
static SORT_ASCENDING := 0
static SORT_DESCENDING := 16
;/* types of array norm */
static C := 1
static L1 := 2
static L2 := 4
static NORM_MASK := 7
static RELATIVE := 8
static DIFF := 16
static MINMAX := 32
static DIFF_C := 16 | 1
static DIFF_L1 := 16 | 2
static DIFF_L2 := 16 | 4
static RELATIVE_C := 8 | 1
static RELATIVE_L1 := 8 | 2
static RELATIVE_L2 := 8 | 4
;/*********************************** CPU capabilities ***********************************/
static CPU_NONE := 0
static CPU_MMX := 1
static CPU_SSE := 2
static CPU_SSE2 := 3
static CPU_SSE3 := 4
static CPU_SSSE3 := 5
static CPU_SSE4_1 := 6
static CPU_SSE4_2 := 7
static CPU_POPCNT := 8
static CPU_AVX := 10
static HARDWARE_MAX_FEATURE := 255
; cvFindChessBoard flag
static CALIB_CB_ADAPTIVE_THRESH := 1
static CALIB_CB_NORMALIZE_IMAGE := 2
static CALIB_CB_FILTER_QUADS := 4
static CALIB_CB_FAST_CHECK := 8
static CALIB_USE_INTRINSIC_GUESS := 1
static CALIB_FIX_ASPECT_RATIO := 2
static CALIB_FIX_PRINCIPAL_POINT := 4
static CALIB_ZERO_TANGENT_DIST := 8
static CALIB_FIX_FOCAL_LENGTH := 16
static CALIB_FIX_K1 := 32
static CALIB_FIX_K2 := 64
static CALIB_FIX_K3 := 128
static CALIB_FIX_K4 := 2048
static CALIB_FIX_K5 := 4096
static CALIB_FIX_K6 := 8192
static CALIB_RATIONAL_MODEL := 16384
;/* Filters used in pyramid decomposition */
static GAUSSIAN_5x5 := 7
;/* Special filters */
static SCHARR := -1
static MAX_SOBEL_KSIZE := 7
;/* Constants for color conversion */
static BGR2BGRA := 0
static RGB2RGBA := 0
static BGRA2BGR := 1
static RGBA2RGB := 1
static BGR2RGBA := 2
static RGB2BGRA := 2
static RGBA2BGR := 3
static BGRA2RGB := 3
static BGR2RGB := 4
static RGB2BGR := 4
static BGRA2RGBA := 5
static RGBA2BGRA := 5
static BGR2GRAY := 6
static RGB2GRAY := 7
static GRAY2BGR := 8
static GRAY2RGB := 8
static GRAY2BGRA := 9
static GRAY2RGBA := 9
static BGRA2GRAY := 10
static RGBA2GRAY := 11
static BGR2BGR565 := 12
static RGB2BGR565 := 13
static BGR5652BGR := 14
static BGR5652RGB := 15
static BGRA2BGR565 := 16
static RGBA2BGR565 := 17
static BGR5652BGRA := 18
static BGR5652RGBA := 19
static GRAY2BGR565 := 20
static BGR5652GRAY := 21
static BGR2BGR555 := 22
static RGB2BGR555 := 23
static BGR5552BGR := 24
static BGR5552RGB := 25
static BGRA2BGR555 := 26
static RGBA2BGR555 := 27
static BGR5552BGRA := 28
static BGR5552RGBA := 29
static GRAY2BGR555 := 30
static BGR5552GRAY := 31
static BGR2XYZ := 32
static RGB2XYZ := 33
static XYZ2BGR := 34
static XYZ2RGB := 35
static BGR2YCrCb := 36
static RGB2YCrCb := 37
static YCrCb2BGR := 38
static YCrCb2RGB := 39
static BGR2HSV := 40
static RGB2HSV := 41
static BGR2Lab := 44
static RGB2Lab := 45
static BayerBG2BGR := 46
static BayerGB2BGR := 47
static BayerRG2BGR := 48
static BayerGR2BGR := 49
static BayerBG2RGB := 48
static BayerGB2RGB := 49
static BayerRG2RGB := 46
static BayerGR2RGB := 47
static BGR2Luv := 50
static RGB2Luv := 51
static BGR2HLS := 52
static RGB2HLS := 53
static HSV2BGR := 54
static HSV2RGB := 55
static Lab2BGR := 56
static Lab2RGB := 57
static Luv2BGR := 58
static Luv2RGB := 59
static HLS2BGR := 60
static HLS2RGB := 61
static BayerBG2BGR_VNG := 62
static BayerGB2BGR_VNG := 63
static BayerRG2BGR_VNG := 64
static BayerGR2BGR_VNG := 65
static BayerBG2RGB_VNG := 64
static BayerGB2RGB_VNG := 65
static BayerRG2RGB_VNG := 62
static BayerGR2RGB_VNG := 63
static BGR2HSV_FULL := 66
static RGB2HSV_FULL := 67
static BGR2HLS_FULL := 68
static RGB2HLS_FULL := 69
static HSV2BGR_FULL := 70
static HSV2RGB_FULL := 71
static HLS2BGR_FULL := 72
static HLS2RGB_FULL := 73
static LBGR2Lab := 74
static LRGB2Lab := 75
static LBGR2Luv := 76
static LRGB2Luv := 77
static Lab2LBGR := 78
static Lab2LRGB := 79
static Luv2LBGR := 80
static Luv2LRGB := 81
static BGR2YUV := 82
static RGB2YUV := 83
static YUV2BGR := 84
static YUV2RGB := 85
static BayerBG2GRAY := 86
static BayerGB2GRAY := 87
static BayerRG2GRAY := 88
static BayerGR2GRAY := 89
; //YUV 4:2:0 formats family
static YUV2RGB_NV12 := 90
static YUV2BGR_NV12 := 91
static YUV2RGB_NV21 := 92
static YUV2BGR_NV21 := 93
static YUV420sp2RGB := 92
static YUV420sp2BGR := 93
static YUV2RGBA_NV12 := 94
static YUV2BGRA_NV12 := 95
static YUV2RGBA_NV21 := 96
static YUV2BGRA_NV21 := 97
static YUV420sp2RGBA := 96
static YUV420sp2BGRA := 97
static YUV2RGB_YV12 := 98
static YUV2BGR_YV12 := 99
static YUV2RGB_IYUV := 100
static YUV2BGR_IYUV := 101
static YUV2RGB_I420 := 100
static YUV2BGR_I420 := 101
static YUV420p2RGB := 98
static YUV420p2BGR := 99
static YUV2RGBA_YV12 := 102
static YUV2BGRA_YV12 := 103
static YUV2RGBA_IYUV := 104
static YUV2BGRA_IYUV := 105
static YUV2RGBA_I420 := 104
static YUV2BGRA_I420 := 105
static YUV420p2RGBA := 102
static YUV420p2BGRA := 103
static YUV2GRAY_420 := 106
static YUV2GRAY_NV21 := 106
static YUV2GRAY_NV12 := 106
static YUV2GRAY_YV12 := 106
static YUV2GRAY_IYUV := 106
static YUV2GRAY_I420 := 106
static YUV420sp2GRAY := 106
static YUV420p2GRAY := 106
; //YUV 4:2:2 formats family
static YUV2RGB_UYVY := 107
static YUV2BGR_UYVY := 108
; //YUV2RGB_VYUY := 109
; //YUV2BGR_VYUY := 110
static YUV2RGB_Y422 := 107
static YUV2BGR_Y422 := 108
static YUV2RGB_UYNV := 107
static YUV2BGR_UYNV := 108
static YUV2RGBA_UYVY := 111
static YUV2BGRA_UYVY := 112
; //YUV2RGBA_VYUY := 113
; //YUV2BGRA_VYUY := 114
static YUV2RGBA_Y422 := 111
static YUV2BGRA_Y422 := 112
static YUV2RGBA_UYNV := 111
static YUV2BGRA_UYNV := 112
static YUV2RGB_YUY2 := 115
static YUV2BGR_YUY2 := 116
static YUV2RGB_YVYU := 117
static YUV2BGR_YVYU := 118
static YUV2RGB_YUYV := 115
static YUV2BGR_YUYV := 116
static YUV2RGB_YUNV := 115
static YUV2BGR_YUNV := 116
static YUV2RGBA_YUY2 := 119
static YUV2BGRA_YUY2 := 120
static YUV2RGBA_YVYU := 121
static YUV2BGRA_YVYU := 122
static YUV2RGBA_YUYV := 119
static YUV2BGRA_YUYV := 120
static YUV2RGBA_YUNV := 119
static YUV2BGRA_YUNV := 120
static YUV2GRAY_UYVY := 123
static YUV2GRAY_YUY2 := 124
; //YUV2GRAY_VYUY := 123
static YUV2GRAY_Y422 := 123
static YUV2GRAY_UYNV := 123
static YUV2GRAY_YVYU := 124
static YUV2GRAY_YUYV := 124
static YUV2GRAY_YUNV := 124
; // alpha premultiplication
static RGBA2mRGBA := 125
static mRGBA2RGBA := 126
static RGB2YUV_I420 := 127
static BGR2YUV_I420 := 128
static RGB2YUV_IYUV := 127
static BGR2YUV_IYUV := 128
static RGBA2YUV_I420 := 129
static BGRA2YUV_I420 := 130
static RGBA2YUV_IYUV := 129
static BGRA2YUV_IYUV := 130
static RGB2YUV_YV12 := 131
static BGR2YUV_YV12 := 132
static RGBA2YUV_YV12 := 133
static BGRA2YUV_YV12 := 134
static COLORCVT_MAX := 135
;/* Sub-pixel interpolation methods */
static INTER_NN := 0
static INTER_LINEAR := 1
static INTER_CUBIC := 2
static INTER_AREA := 3
static INTER_LANCZOS4 := 4
;/* ... and other image warping flags */
static WARP_FILL_OUTLIERS := 8
static WARP_INVERSE_MAP := 16
;/* Shapes of a structuring element for morphological operations */
static SHAPE_RECT := 0
static SHAPE_CROSS := 1
static SHAPE_ELLIPSE := 2
static SHAPE_CUSTOM := 100
;/* Morphological operations */
static MOP_ERODE := 0
static MOP_DILATE := 1
static MOP_OPEN := 2
static MOP_CLOSE := 3
static MOP_GRADIENT := 4
static MOP_TOPHAT := 5
static MOP_BLACKHAT := 6
;/* Template matching methods */
static TM_SQDIFF := 0
static TM_SQDIFF_NORMED := 1
static TM_CCORR := 2
static TM_CCORR_NORMED := 3
static TM_CCOEFF := 4
static TM_CCOEFF_NORMED := 5
;/* Contour retrieval modes */
static RETR_EXTERNAL := 0
static RETR_LIST := 1
static RETR_CCOMP := 2
static RETR_TREE := 3
static RETR_FLOODFILL := 4
;/* Contour approximation methods */
static CHAIN_CODE := 0
static CHAIN_APPROX_NONE := 1
static CHAIN_APPROX_SIMPLE := 2
static CHAIN_APPROX_TC89_L1 := 3
static CHAIN_APPROX_TC89_KCOS := 4
static LINK_RUNS := 5
;/* Histogram comparison methods */
static COMP_CORREL := 0
static COMP_CHISQR := 1
static COMP_INTERSECT := 2
static COMP_BHATTACHARYYA := 3
static COMP_HELLINGER := 3
;/* Mask size for distance transform */
static DIST_MASK_3 := 3
static DIST_MASK_5 := 5
static DIST_MASK_PRECISE := 0
;/* Content of output label array: connected components or pixels */
static DIST_LABEL_CCOMP := 0
static DIST_LABEL_PIXEL := 1
;/* Distance types for Distance Transform and M-estimators */
static DIST_USER := -1 ;/* User defined distance */
static DIST_L1 := 1 ;/* distance = |x1-x2| + |y1-y2| */
static DIST_L2 := 2 ;/* the simple euclidean distance */
static DIST_C := 3 ;/* distance = max(|x1-x2||y1-y2|) */
static DIST_L12 := 4 ;/* L1-L2 metric: distance = 2(sqrt(1+x*x/2) - 1)) */
static DIST_FAIR := 5 ;/* distance = c^2(|x|/c-log(1+|x|/c)) c = 1.3998 */
static DIST_WELSCH := 6 ;/* distance = c^2/2(1-exp(-(x/c)^2)) c = 2.9846 */
static DIST_HUBER := 7 ;/* distance = |x|<c ? x^2/2 : c(|x|-c/2) c=1.345 */
;/* Threshold types */
static THRESH_BINARY := 0 ;/* value = value > threshold ? max_value : 0 */
static THRESH_BINARY_INV := 1 ;/* value = value > threshold ? 0 : max_value */
static THRESH_TRUNC := 2 ;/* value = value > threshold ? threshold : value */
static THRESH_TOZERO := 3 ;/* value = value > threshold ? value : 0 */
static THRESH_TOZERO_INV := 4 ;/* value = value > threshold ? 0 : value */
static THRESH_MASK := 7
static THRESH_OTSU := 8 ;/* use Otsu algorithm to choose the optimal threshold value;
; combine the flag with one of the above THRESH_* values */
;/* Adaptive threshold methods */
static ADAPTIVE_THRESH_MEAN_C := 0
static ADAPTIVE_THRESH_GAUSSIAN_C := 1
;/* FloodFill flags */
static FLOODFILL_FIXED_RANGE := 1 << -16
static FLOODFILL_MASK_ONLY := 1 << -17
;/* Variants of a Hough transform */
static HOUGH_STANDARD := 0
static HOUGH_PROBABILISTIC := 1
static HOUGH_MULTI_SCALE := 2
static HOUGH_GRADIENT := 3
;/* For font */
static FONT_LIGHT := 25 ;//QFont::Light,
static FONT_NORMAL := 50 ;//QFont::Normal,
static FONT_DEMIBOLD := 63 ;//QFont::DemiBold,
static FONT_BOLD := 75 ;//QFont::Bold,
static FONT_BLACK := 87 ;//QFont::Black
static STYLE_NORMAL := 0 ;//QFont::StyleNormal,
static STYLE_ITALIC := 1 ;//QFont::StyleItalic,
static STYLE_OBLIQUE := 2 ;//QFont::StyleOblique
; type of button
static PUSH_BUTTON := 0
static CHECKBOX := 1
static RADIOBOX := 2
static TERMCRIT_ITER := 1
static TERMCRIT_NUMBER := 1
static TERMCRIT_EPS := 2
;/* Contour approximation algorithms */
static POLY_APPROX_DP := 0
}
class Libs {
static path := "\Lib\DLL\"
static libraries := {
(Join,
opencv_core: "opencv_core2413.dll"
opencv_highgui: "opencv_highgui2413.dll"
opencv_imgproc: "opencv_imgproc2413.dll"
opencv_objdetect: "opencv_objdetect2413.dll"
)}
__New(parent) {
this.generateCallMethods(parent)
}
__Call(method, args*) {
if (method == "call") {
if (IsObject(args[2])) ; Remove passed 'this' inside 'call' function
args.RemoveAt(2)
return this.Call(args*)
}
}
generateCallMethods(ctx) {
for libName, dllName in this.libraries {
ctx[libName] := ObjBindMethod(this, "call", libName)
}
}
getDLL(libName) {
return this.libraries[libName]
}
call(libName, fnName, params*) {
return DllCall(this.getDLL(libName) . "\" . fnName, params*)
}
load() {
static OriginalWorkingDir := A_ScriptDir
SetWorkingDir % OriginalWorkingDir . this.path
for libName, dllName in this.libraries
DllCall("LoadLibrary", "Str", dllName, "Ptr")
SetWorkingDir % OriginalWorkingDir
}
unload() {
for libName, dllName in this.libraries
if (hModule := DllCall("GetModuleHandle", "str", dllName))
DllCall("FreeLibrary", "ptr", hModule)
}
}
class __Init {
static _ := OpenCV.__Init := new OpenCV.__Init()
__New() {
OpenCV.Libs.load()
OnExit(ObjBindMethod(OpenCV.Libs, "unload"))
}
error(additionalMsg := "") {
Tooltip % additionalMsg
stackTrace := (A_ThisFunc "`n" ErrorLevel)
errorCode := "`nLastError - " A_LastError
if ErrorLevel
MsgBox % additionalMsg . " " . stackTrace . " " . errorCode
return ErrorLevel
}
}
__wrapAround(result := "") {
this._error()
return result
}
BmpToIPL(pBitmap) {
if (!IsFunc("Gdip_GetImageDimensions")) {
MsgBox % "BmpToIPL >> GDI+ Library is missing!"
return
}
Func("Gdip_GetImageDimensions").Call(pBitmap, iW, iH)
tBitmapData := Func("Gdip_LockBits").Call(pBitmap, 0, 0, iW, iH, Stride, Scan0, BitmapData)
pIPL := this.CreateImageHeader(this.Size(iW, iH), 8, 4)
this.SetData(pIPL, Scan0, Stride)
Func("Gdip_UnlockBits").Call(pBitmap, tBitmapData)
return pIPL
}
Load(cvfilename, cvmemstorage := 0, cvname := 0, cvreal_name := 0) {
result := this.opencv_core("cvLoad", "AStr", cvfilename, "ptr", cvmemstorage, "ptr", cvname, "ptr", cvreal_name, "Cdecl ptr")
return this.__wrapAround(result)
}
NamedWindow(name, flags := 0x00000001) {
result := this.opencv_highgui("cvNamedWindow", "AStr", name, "int", flags, "Cdecl ptr")
return this.__wrapAround(result)
}
LoadImage(filename, iscolor := 1) {
result := this.opencv_highgui("cvLoadImage", "AStr", filename, "int", iscolor, "Cdecl ptr")
return this.__wrapAround(result)
}
ShowImage(name, pimage) {
result := this.opencv_highgui("cvShowImage", "AStr", name, "ptr", pimage, "Cdecl")
return this.__wrapAround(result)
}
CreateImage(cvsize, cvdepth, cvchannels) {
result := this.opencv_core("cvCreateImage", "int64", cvsize, "int", cvdepth, "int", cvchannels, "Cdecl ptr")
return this.__wrapAround(result)
}
CreateImageHeader(cvsize, cvdepth, cvchannels) {
result := this.opencv_core("cvCreateImageHeader", "int64", cvsize, "int", cvdepth, "int", cvchannels, "Cdecl ptr")
return this.__wrapAround(result)
}
CreateMat(cvrows, cvcols, cvtype) {
result := this.opencv_core("cvCreateMat", "int", cvrows, "int", cvcols, "int", cvtype, "Cdecl ptr")
return this.__wrapAround(result)
}
MatchTemplate(cvimage, cvtempl, cvresult, cvmethod) {
result := this.opencv_imgproc("cvMatchTemplate", "ptr", cvimage, "ptr", cvtempl, "ptr", cvresult, "int", cvmethod, "Cdecl")
return this.__wrapAround(result)
}
Normalize(cvsrc, cvdst, cva, cvb, cvnorm_type, cvmask) {
result := this.opencv_core("cvNormalize", "ptr", cvsrc, "ptr", cvdst, "Double", cva, "Double", cvb, "int", cvnorm_type, "ptr", cvmask, "Cdecl")
return this.__wrapAround(result)
}
Threshold(cvsrc, cvdst, cvthreshold, cvmax_value, cvthreshold_type) {
result := this.opencv_imgproc("cvThreshold", "ptr", cvsrc, "ptr", cvdst, "Double", cvthreshold, "Double", cvmax_value, "int", cvthreshold_type, "Cdecl double")
return this.__wrapAround(result)
}
ArrTohBitmap(pimage, byref width = "", byref height = "") {
result := this.CreateImage(this.GetSize(pimage, width, height), 8, 4)
this.CvtColor(pimage, Result, 0)
pData := NumGet(Result + 0, 68 + 20 * (A_PtrSize = 8), "Ptr")
hBitmap := DllCall("CreateBitmap", "Int", width, "Int", height, "UInt", 1, "UInt", 32, "Ptr", pData)
Return this.__wrapAround(hBitmap), this.ReleaseImage(result)
}
Scalar(value) {
VarSetCapacity(vScalar, 32, 0)
if IsObject(value) {
Loop 4
NumPut(value%A_Index%, vScalar, (A_Index - 1) * 8, "double")
} else {
Loop 4
NumPut(value, vScalar, (A_Index - 1) * 8, "double")
}
return this.__wrapAround(&vScalar)
}
Set(cvarr, cvvalue, cvmask := 0) {
if (A_PtrSize = 4)
result := this.opencv_core("cvSet", "ptr", cvarr, "double", NumGet(cvvalue+0, 0, "double"), "double", NumGet(cvvalue+0, 8, "double"), "double", NumGet(cvvalue+0, 16, "double"), "double", NumGet(cvvalue+0, 24, "double"), "ptr", cvmask, "Cdecl")
else
result := this.opencv_core("cvSet", "ptr", cvarr, "ptr", cvvalue, "ptr", cvmask, "Cdecl")
return this.__wrapAround(result)
}
GetSize(pimage, ByRef width := 0, ByRef height := 0) {
WidthHeight := this.opencv_core("cvGetSize", "ptr", pimage, "Cdecl int64")
width := 0xFFFFFFFF & WidthHeight
height := WidthHeight >> 32
return this.__wrapAround(WidthHeight)
}
Size(width, height) {
return this.__wrapAround(width & 0xFFFFFFFF | height << 32)
}
;------------------------------------------------
;/*
;CVAPI(void) cvCvtColor( const CvArr* src, CvArr* dst, int code );
;
;
CvtColor(cvsrc, cvdst, cvcode) {
result := this.opencv_imgproc("cvCvtColor", "ptr", cvsrc, "ptr", cvdst, "int", cvcode, "Cdecl")
return this.__wrapAround(result)
}
Resize(cvsrc, cvdst, cvinterpolation := 1) {
result := this.opencv_imgproc("cvResize", "ptr", cvsrc, "ptr", cvdst, "int", cvinterpolation, "Cdecl")
return this.__wrapAround(result)
}
EqualizeHist(cvsrc, cvdst) {
result := this.opencv_imgproc("cvEqualizeHist", "ptr", cvsrc, "ptr", cvdst, "Cdecl")
return this.__wrapAround(result)
}
CreateMemStorage(cvblock_size) {
result := this.opencv_core("cvCreateMemStorage", "int", cvblock_size, "Cdecl ptr")
return this.__wrapAround(result)
}
ClearMemStorage(cvstorage) {
result := this.opencv_core("cvClearMemStorage", "ptr", cvstorage, "Cdecl")
return this.__wrapAround(result)
}
HaarDetectObjects(cvimage, cvcascade, cvstorage, cvscale_factor := 1.1, cvmin_neighbors := 3, cvflags := 0, cvmin_size := 0, cvmax_size := 0) {
result := this.opencv_objdetect("cvHaarDetectObjects", "ptr", cvimage, "ptr", cvcascade, "ptr", cvstorage, "double", cvscale_factor, "int", cvmin_neighbors, "int", cvflags, "int64", cvmin_size, "int64", cvmax_size, "Cdecl ptr")
return this.__wrapAround(result)
}
GetSeqElem(cvseq, cvindex) {
result := this.opencv_core("cvGetSeqElem", "ptr", cvseq, "int", cvindex, "Cdecl ptr")
return this.__wrapAround(result)
}
Rectangle(cvimg, cvpt1, cvpt2, cvcolor, cvthickness, cvline_type, cvshift) {
if (A_PtrSize = 4)
result := this.opencv_core("cvRectangle", "ptr", cvimg, "int64", cvpt1, "int64", cvpt2, "double", NumGet(cvcolor+0, 0, "double"), "double", NumGet(cvcolor+0, 8, "double"), "double", NumGet(cvcolor+0, 16, "double"), "double", NumGet(cvcolor+0, 24, "double"), "int", cvthickness, "int", cvline_type, "int", cvshift, "Cdecl")
else
result := this.opencv_core("cvRectangle", "ptr", cvimg, "int64", cvpt1, "int64", cvpt2, "ptr", cvcolor, "int", cvthickness, "int", cvline_type, "int", cvshift, "Cdecl")
return this.__wrapAround(result)
}
ReleaseImage(pimage) {
result := this.opencv_core("cvReleaseImage", "ptr*", pimage, "Cdecl")
return this.__wrapAround(result)
}
DestroyAllWindows() {
result := this.opencv_highgui("cvDestroyAllWindows", "Cdecl")
return this.__wrapAround(result)
}
ClearSeq(cvseq) {
result := this.opencv_core("cvClearSeq", "ptr", cvseq, "Cdecl")
return this.__wrapAround(result)
}
Point(x, y) {
return this.__wrapAround(x & 0xFFFFFFFF | y << 32)
}
RGB(cvRed, cvGreen, cvBlue) {
VarSetCapacity(vScalar, 32, 0)
NumPut(cvBlue, vScalar, 0, "double")
NumPut(cvGreen, vScalar, 8, "double")
NumPut(cvRed, vScalar, 16, "double")
NumPut(0, vScalar, 24, "double")
return this.__wrapAround(&vScalar)
}
SetData(cvarr, data, step) {
result := this.opencv_core("cvSetData", "ptr", cvarr, "ptr", data, "int", step, "Cdecl")
return this.__wrapAround(result)
}
;------------------------------------------------
;/*
;CVAPI(void) cvMinMaxLoc( const CvArr* arr, double* min_val, double* max_val, CvPoint* min_loc CV_DEFAULT(NULL), CvPoint* max_loc CV_DEFAULT(NULL), const CvArr* mask CV_DEFAULT(NULL) );
;
;
MinMaxLoc(cvarr, cvmin_val, cvmax_val, cvmin_loc, cvmax_loc, cvmask) {
result := this.opencv_core("cvMinMaxLoc", "ptr", cvarr, "ptr", cvmin_val, "ptr", cvmax_val, "ptr", cvmin_loc, "ptr", cvmax_loc, "ptr", cvmask, "Cdecl")
return this.__wrapAround(result)
}
CloneImage(pimage) {
result := this.opencv_core("cvCloneImage", "ptr", pimage, "Cdecl ptr")
return this.__wrapAround(result)
}
ReleaseImageHeader(pimage) {
result := this.opencv_core("cvReleaseImageHeader", "ptr*", pimage, "Cdecl")
return this.__wrapAround(result)
}
ReleaseMat(cvmat) {
result := this.opencv_core("cvReleaseMat", "ptr*", cvmat, "Cdecl")
return this.__wrapAround(result)
}
;------------------------------------------------
;/*
;CVAPI(void) cvSmooth( const CvArr* src, CvArr* dst, int smoothtype CV_DEFAULT(CV_GAUSSIAN), int size1 CV_DEFAULT(3), int size2 CV_DEFAULT(0), double sigma1 CV_DEFAULT(0), double sigma2 CV_DEFAULT(0));
;
;
Smooth( cvsrc , cvdst , cvsmoothtype = 2 , cvsize1 = 3 , cvsize2 = 0 , cvsigma1 = 0 , cvsigma2 = 0)
{
result := this.opencv_imgproc("cvSmooth", "ptr", cvsrc, "ptr", cvdst, "int", cvsmoothtype, "int", cvsize1, "int", cvsize2, "ptr", cvsigma1, "ptr", cvsigma2, "Cdecl")
return this.__wrapAround(result)
}
;------------------------------------------------
;/*
;CVAPI(void) cvErode( const CvArr* src, CvArr* dst, IplConvKernel* element CV_DEFAULT(NULL), int iterations CV_DEFAULT(1) );
;
;
Erode( cvsrc , cvdst , cvelement = 0 , cviterations = 1 )
{
result := this.opencv_imgproc("cvErode", "ptr", cvsrc, "ptr", cvdst, "ptr", cvelement, "int", cviterations, "Cdecl")
return this.__wrapAround(result)
}
;------------------------------------------------
;/*
;CVAPI(void) cvDilate( const CvArr* src, CvArr* dst, IplConvKernel* element CV_DEFAULT(NULL), int iterations CV_DEFAULT(1) );
;
;
cvDilate(cvsrc, cvdst, cvelement = 0, cviterations = 1 )
{
result := this.opencv_imgproc("cvDilate", "ptr", cvsrc, "ptr", cvdst, "ptr", cvelement, "int", cviterations, "Cdecl")
return this.__wrapAround(result)
}
;------------------------------------------------
;/*
;CVAPI(CvSeq*) cvCreateSeq( int seq_flags, size_t header_size, size_t elem_size, CvMemStorage* storage );
;
;
CreateSeq( cvseq_flags , cvheader_size , cvelem_size , cvstorage )
{
result := this.opencv_core("cvCreateSeq" , "int" , cvseq_flags , "ptr" , cvheader_size , "ptr" , cvelem_size , "ptr" , cvstorage, "Cdecl ptr")
return this.__wrapAround(result)
}
;------------------------------------------------
;/*
;CVAPI(int) cvFindContours( CvArr* image, CvMemStorage* storage, CvSeq** first_contour, int header_size CV_DEFAULT(sizeof(CvContour)), int mode CV_DEFAULT(CV_RETR_LIST), int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE), CvPoint offset CV_DEFAULT(cvPoint(0_0)));
;
;
FindContours( cvimage, cvstorage, ByRef cvfirst_contour, cvheader_size, cvmode, cvmethod, cvoffset)
{
result := this.opencv_core("cvFindContours" , "ptr" , cvimage , "ptr" , cvstorage , "Ptr*" , cvfirst_contour , "int" , cvheader_size , "int" , cvmode , "int" , cvmethod , "struct" , cvoffset, "Cdecl")
return this.__wrapAround(result)
}
;------------------------------------------------
;/* wait for key event infinitely (delay<=0) or for "delay" milliseconds */
;CVAPI(int) cvWaitKey(int delay CV_DEFAULT(0));
WaitKey(delay = 0 )
{
result := this.opencv_highgui("cvWaitKey" , "int", delay, "int:cdecl")
return this.__wrapAround(result)
}
}from that github you can also get the dll's im using
Until now i have gotten to the part that is trying to create the contours Seq as that seems to return a pointer but the .FindContours call returns blank so seems i'm doing something wrong
hopefully one of you can help point out what is wrong and help me get this working
Welch ein Gruß an den Dänischen Nachbarn. 
not sure if my feeble attempts are doing anything