-
Notifications
You must be signed in to change notification settings - Fork 13
/
cvWrapLEO.h
344 lines (261 loc) · 13.1 KB
/
cvWrapLEO.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
//@+leo-ver=4-thin
//@+node:aleator.20050908101148.2:@thin cvWrapLEO.h
//@@language c
#ifndef __CVWRAP__
#define __CVWRAP__
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
#include <stdio.h>
#include <opencv2/core/core_c.h>
#include <opencv2/imgproc/imgproc_c.h>
#include <opencv2/highgui/highgui_c.h>
#include <opencv2/features2d/features2d.hpp>
#include <opencv2/video/tracking.hpp>
#include <opencv2/calib3d/calib3d.hpp>
#include <opencv2/legacy/compat.hpp>
#include <complex.h>
IplImage* wrapCreateImage32F(const int width, const int height, const int channels);
IplImage* wrapCreateImage64F(const int width, const int height, const int channels);
IplImage* wrapCreateImage8U(const int width, const int height, const int channels);
IplImage *wrapCopyMakeBorder(IplImage* src, const int top, const int bottom, const int left, const int right, const int borderType, const float value);
void wrapSubRS(const CvArr *src, double s,CvArr *dst);
void wrapSubS(const CvArr *src, double s,CvArr *dst);
void wrapAddS(const CvArr *src, double s, CvArr *dst);
double wrapAvg(const CvArr *src, const CvArr *mask);
double wrapStdDev(const CvArr *src);
double wrapStdDevMask(const CvArr *src,const CvArr *mask);
double wrapSum(const CvArr *src);
void wrapMinMax(const CvArr *src,const CvArr *mask
,double *minVal, double *maxVal);
void wrapAbsDiffS(const CvArr *src, double s, CvArr *dst);
void wrapSetImageROI(IplImage *i,int x, int y, int w, int h);
IplImage* wrapSobel(IplImage *src,int dx
,int dy,int size);
IplImage* wrapLaplace(IplImage *src,int size);
IplImage* ensure8U(const IplImage *src);
IplImage* ensure32F(const IplImage *src);
void wrapSet32F2D(CvArr *arr, int x, int y, double value);
double wrapGet32F2D(CvArr *arr, int x, int y);
uint8_t wrapGet8U2DC(IplImage *arr, int x, int y,int c);
void wrapDrawCircle(CvArr *img, int x, int y, int radius, float r,float g,float b, int thickness);
void wrapDrawLine(CvArr *img, int x, int y, int x1, int y1, double r, double g, double b, int thickness);
void wrapFillPolygon(IplImage *img, int pc, int *xs, int *ys, float r, float g, float b);
void wrapDrawEllipse(IplImage *img, int x, int y, int r1, int r2, float a, float a1, float a2, float r, float g, float b, int thickness);
void wrapMatMul(int w, int h, double *mat
, double *vec, double *t);
// Utils. Place them in another file
IplImage* rotateImage(IplImage* src,double scale,double angle);
CvHistogram* calculateHistogram(IplImage *img,int bins);
void wrapReleaseHist(CvHistogram *hist);
double getHistValue(CvHistogram *h,int bin);
void get_histogram(IplImage *img,IplImage *mask
,float a, float b,int isCumulative
,int binCount
,double *values);
//void get_weighted_histogram(IplImage *img,IplImage *mask);
// ,float a, float b
// ,int binCount
// ,double *values);
IplImage* getSubImage(IplImage *img, int sx,int sy,int w,int h);
int getImageHeight(IplImage *img);
int getImageWidth(IplImage *img);
IplImage* susanSmooth(IplImage *src, int w, int h
,double t, double sigma);
IplImage* susanEdge(IplImage *src,int w,int h,double t);
IplImage* getNthCentralMoment(IplImage *src, int n, int w, int h);
IplImage* getNthAbsCentralMoment(IplImage *src, int n, int w, int h);
IplImage* getNthMoment(IplImage *src, int n, int w, int h);
double calcGabor(double x, double y
,double stdX, double stdY
,double theta, double phase
,double cycles);
void gaborFilter(const CvArr *src, CvArr *dst
,int maskWidth, int maskHeight
,double stdX, double stdY
,double theta,double phase
,double cycles);
void radialGaborFilter(const CvArr *src, CvArr *dst
,int maskWidth, int maskHeight
,double sigma
,double phase,double center
,double cycles);
void renderRadialGabor(CvArr *dst,int width, int height
,double sigma
,double phase, double center
,double cycles);
void render_gaussian(IplImage *dst
,double stdX, double stdY);
void renderGabor(CvArr *dst,int width, int height
,double dx, double dy
,double stdX, double stdY
,double theta, double phase
,double cycles);
void smb(IplImage *image,double t);
void smab(IplImage *image,int w, int h,double t);
IplImage* selectiveAvgFilter(IplImage *src,double t
,int wwidth, int wheight);
IplImage* wrapFilter2D(IplImage *src, int ax,int ay,
int w, int h, double *kernel);
IplImage* wrapFilter2DImg(IplImage *src
,IplImage *mask
,int ax,int ay);
void wrapFloodFill(IplImage *i, int x, int y, double c
,double low, double high,int fixed);
void sqrtImage(IplImage *src,IplImage *dst);
void weighted_localBinaryPattern(IplImage *src,int offsetX,int offsetXY
, IplImage* weights, double *LBP);
void localBinaryPattern(IplImage *src, int *LBP);
void localBinaryPattern3(IplImage *src, int *LBP);
void localBinaryPattern5(IplImage *src, int *LBP);
void localHorizontalBinaryPattern(IplImage *src, int *LBP);
void localVerticalBinaryPattern(IplImage *src, int *LBP);
void get_weighted_histogram(IplImage *src, IplImage *weights,
double start, double end,
int bins, double *histo);
void eigenValsViaSVD(double *A, int size, double *eVals
,double *eVects);
IplImage* sizeFilter(const IplImage *src, double minSize, double maxSize, int mode);
int blobCount(const IplImage *src);
IplImage *acquireImage(int w, int h, double *d);
void wrapProbHoughLines(IplImage *img, double rho, double theta
, int threshold, double minLength
, double gapLength
, int *maxLines
, int *xs, int *ys
, int *xs1, int *ys1);
double average_of_line(int x0, int y0
,int x1, int y1
,IplImage *src);
IplImage* adaUpdateDistrImage(IplImage *target
,IplImage *weigths
,IplImage *test
,double at);
double adaFitness1(IplImage *target
,IplImage *weigths
,IplImage *test);
CvMoments* getMoments(IplImage *src, int isBinary);
void freeCvMoments(CvMoments *x);
void getHuMoments(CvMoments *src,double *hu);
void freeCvHuMoments(CvHuMoments *x);
void haarFilter(IplImage *intImg,
int a, int b, int c, int d,
IplImage *target);
double haar_at(IplImage *intImg,
int x1, int y1, int w, int h);
void wrapDrawRectangle(CvArr *img, int x1, int y1,
int x2, int y2, float r, float g, float b,
int thickness);
void calculateAtan(IplImage *src, IplImage *dst);
void calculateAtan2(IplImage *src1,IplImage *src2, IplImage *dst);
double calcSelectiveAvg(IplImage *img, double t , int x, int y , int wwidth, int wheight);
// Contours
typedef struct {
CvMemStorage *storage;
CvSeq *contour;
CvSeq *start;
int refCount;
} FoundContours;
typedef struct {
FoundContours * fc;
CvSeq *thisContour;
} FoundContour;
CvMoments* contour_moments(const FoundContour *c);
void contour_points(const FoundContour *f, int *xs, int *ys);
double contour_area(const FoundContour *c);
int cur_contour_size(const FoundContour *c);
double contour_perimeter(const FoundContour *c);
int more_contours(FoundContours *f);
int next_contour(FoundContours *f);
int reset_contour(FoundContours *f);
void free_found_contours(FoundContours *f);
void get_next_contour(FoundContours *fc);
void print_contour(const FoundContour *fc);
FoundContours* get_contours(const IplImage *src, int mode);
FoundContour* get_contour(FoundContours *);
void draw_contour( IplImage *src, FoundContour *con, int color
, int holeColor, int level, int thinkness, int linetype
, int dx, int dy);
void free_found_contour(FoundContour *f);
double juliaF(double a, double b,double x, double y);
void simpleMatchTemplate(const IplImage* target, const IplImage* template, int* x, int* y, double *val, int type);
IplImage* templateImage(const IplImage* target, const IplImage* template);
IplImage* simpleMergeImages(IplImage *a, IplImage *b,int offset_x, int offset_y);
void alphaBlit(IplImage *a, IplImage *aAlpha, IplImage *b, IplImage *bAlpha, int offset_x, int offset_y);
void blitImg(IplImage *a, IplImage *b,int offset_x, int offset_y);
IplImage* fadedEdges(int w, int h, int edgeW);
IplImage* rectangularDistance(int w, int h);
void radialRemap(IplImage *source, IplImage *dest, double k);
void plainBlit(IplImage *a, IplImage *b, int offset_y, int offset_x);
void wrapMinMaxLoc(const IplImage* target, int* minx, int* miny, int* maxx, int* maxy, double *minval, double *maxval);
void incrImageC(void);
IplImage* vignettingModelCos4(int w, int h) ;
IplImage* vignettingModelCos4XCyl(int w, int h) ;
IplImage* vignettingModelX2Cyl(int w, int h,double m, double s, double c);
void wrapDrawText(CvArr *img, char *text, float s, int x, int y,float r,float g,float b);
IplImage* vignettingModelB3(int w, int h,double b1, double b2, double b3);
IplImage* vignettingModelP(int w, int h,double scalex, double scaley, double max);
IplImage* wrapPerspective(IplImage* src, double a1, double a2, double a3
, double a4, double a5, double a6
, double a7, double a8, double a9);
IplImage* simplePerspective(double k,IplImage *src);
double bilinearInterp(IplImage *tex, double u, double v);
void findHomography(double* srcPts, double *dstPts, int noPts, double *homography);
void masked_merge(IplImage *src1, IplImage *mask, IplImage *src2, IplImage *dst);
IplImage* makeEvenUp(IplImage *src);
IplImage* padUp(IplImage *src,int right, int bottom);
IplImage* makeEvenDown(IplImage *src);
void vertical_average(IplImage *src1, IplImage *dst);
IplImage* composeMultiChannel(IplImage* img0
,IplImage* img1
,IplImage* img2
,IplImage* img3
,const int channels);
IplImage *acquireImageSlow(int w, int h, double *d);
IplImage *acquireImageSlowF(int w, int h, float *d);
void exportImageSlow(IplImage *img, double *d);
void exportImageSlowF(IplImage *img, float *d);
IplImage *acquireImageSlowComplex(int w, int h, complex double *d);
void exportImageSlowComplex(IplImage *img, complex double *d);
void subpixel_blit(IplImage *a, IplImage *b, double offset_y, double offset_x);
double bicubicInterp(IplImage *tex, double u, double v);
CvVideoWriter* wrapCreateVideoWriter(char *fn, int fourcc, double fps,int w, int h, int color);
double wrapGet32F2DC(CvArr *arr, int x, int y,int c);
void maximal_covering_circle(int ox,int oy, double or, IplImage *distmap
,int *max_x, int *max_y, double *max_r);
int wrapFindChessBoardCorners(const void* image, int pw, int ph, CvPoint2D32f* corners, int* cornerCount, int flags);
int wrapDrawChessBoardCorners(void* image, int pw, int ph, CvPoint2D32f* corners, int cornerCount, int wasFound);
double wrapCalibrateCamera2(const CvMat* objectPoints, const CvMat* imagePoints, const CvMat* pointCounts, CvSize *imageSize, CvMat* cameraMatrix, CvMat* distCoeffs, CvMat* rvecs, CvMat* tvecs, int flags);
void wrapFitEllipse(CvArr* pts, CvBox2D *out);
int wrapCamShift(const CvArr* prob_image, CvRect *window, CvTermCriteria *criteria, CvConnectedComp* comp, CvBox2D* box);
void wrapExtractSURF(const CvArr* image, const CvArr* mask, CvSeq** keypoints, CvSeq** descriptors, CvMemStorage* storage, CvSURFParams *param, int useProvidedKeyPts){
return cvExtractSURF(image, mask, keypoints, descriptors, storage, *param, useProvidedKeyPts);
};
#ifndef OpenCV24
void wrapExtractMSER( CvArr* _img, CvArr* _mask, CvSeq** contours, CvMemStorage* storage, CvMSERParams *params );
#endif
void wrapEllipseBox(CvArr* img, CvBox2D *box, CvScalar *color
,int thickness, int lineType, int shift)
{
cvEllipseBox(img, *box, *color, thickness, lineType, shift);
};
void extractCVSeq(const CvSeq* seq,void *dest);
void printSeq(const CvSeq *seq) {
printf("Seq:\n flags %d\nheader_size %d\n total %d\n ptr %p",
seq->flags, seq->header_size, seq->total, (void*)seq->ptr);
}
int wrapMeanShift(const CvArr* prob_image, CvRect *window, CvTermCriteria *criteria, CvConnectedComp* comp)
{
return cvMeanShift(prob_image, *window, *criteria, comp);
};
void wrapMinAreaRect2(const CvArr* points, CvMemStorage* storage, CvBox2D *r)
{ *r = cvMinAreaRect2(points, storage); }
void wrapBoundingRect(CvArr* points, int update, CvRect *r)
{ *r = cvBoundingRect(points, update); }
void wrapWarpPerspective(const CvArr* src, CvArr* dst, const CvMat* mapMatrix )
{ cvWarpPerspective( src, dst, mapMatrix, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS, cvScalarAll(0)); }
void blitShadow(IplImage *a, IplImage *b);
IplImage* ensure64F(const IplImage *src);
#endif
//@-node:aleator.20050908101148.2:@thin cvWrapLEO.h
//@-leo