ImageProcessorCV.cpp
Go to the documentation of this file.
1 // ****************************************************************************
2 // This file is part of the Integrating Vision Toolkit (IVT).
3 //
4 // The IVT is maintained by the Karlsruhe Institute of Technology (KIT)
5 // (www.kit.edu) in cooperation with the company Keyetech (www.keyetech.de).
6 //
7 // Copyright (C) 2014 Karlsruhe Institute of Technology (KIT).
8 // All rights reserved.
9 //
10 // Redistribution and use in source and binary forms, with or without
11 // modification, are permitted provided that the following conditions are met:
12 //
13 // 1. Redistributions of source code must retain the above copyright
14 // notice, this list of conditions and the following disclaimer.
15 //
16 // 2. Redistributions in binary form must reproduce the above copyright
17 // notice, this list of conditions and the following disclaimer in the
18 // documentation and/or other materials provided with the distribution.
19 //
20 // 3. Neither the name of the KIT nor the names of its contributors may be
21 // used to endorse or promote products derived from this software
22 // without specific prior written permission.
23 //
24 // THIS SOFTWARE IS PROVIDED BY THE KIT AND CONTRIBUTORS “AS IS” AND ANY
25 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
26 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
27 // DISCLAIMED. IN NO EVENT SHALL THE KIT OR CONTRIBUTORS BE LIABLE FOR ANY
28 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
29 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
30 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
31 // ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
33 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 // ****************************************************************************
35 
36 
37 // ****************************************************************************
38 // Includes
39 // ****************************************************************************
40 
41 #include <new> // for explicitly using correct new/delete operators on VC DSPs
42 
43 #include "ImageProcessorCV.h"
44 
45 #include "IplImageAdaptor.h"
46 #include "ByteImage.h"
47 #include "Math/Math2d.h"
48 
49 #include <stdio.h>
50 
51 
52 
53 // ****************************************************************************
54 // Functions
55 // ****************************************************************************
56 
57 void ImageProcessorCV::FlipY(CByteImage *pInputImage, CByteImage *pOutputImage)
58 {
59  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
60  pInputImage->type != pOutputImage->type)
61  return;
62 
63  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
64  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
65 
66  cvFlip(pIplInputImage, pIplOutputImage);
67 
68  cvReleaseImageHeader(&pIplInputImage);
69  cvReleaseImageHeader(&pIplOutputImage);
70 }
71 
72 void ImageProcessorCV::GaussianSmooth3x3(CByteImage *pInputImage, CByteImage *pOutputImage)
73 {
74  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
75  pInputImage->type != pOutputImage->type)
76  return;
77 
78  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
79  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
80 
81  cvSmooth(pIplInputImage, pIplOutputImage, CV_GAUSSIAN, 3, 3);
82 
83  cvReleaseImageHeader(&pIplInputImage);
84  cvReleaseImageHeader(&pIplOutputImage);
85 }
86 
87 void ImageProcessorCV::GaussianSmooth5x5(CByteImage *pInputImage, CByteImage *pOutputImage)
88 {
89  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
90  pInputImage->type != pOutputImage->type)
91  return;
92 
93  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
94  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
95 
96  cvSmooth(pIplInputImage, pIplOutputImage, CV_GAUSSIAN, 5, 5);
97 
98  cvReleaseImageHeader(&pIplInputImage);
99  cvReleaseImageHeader(&pIplOutputImage);
100 }
101 
102 void ImageProcessorCV::BilateralSmooth(CByteImage *pInputImage, CByteImage *pOutputImage, int param1, int param2)
103 {
104  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
105  pInputImage->type != pOutputImage->type)
106  return;
107 
108  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
109  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
110 
111  cvSmooth(pIplInputImage, pIplOutputImage, CV_BILATERAL, param1, param2);
112 
113  cvReleaseImageHeader(&pIplInputImage);
114  cvReleaseImageHeader(&pIplOutputImage);
115 
116 }
117 
118 void ImageProcessorCV::Laplacian3x3(CByteImage *pInputImage, CByteImage *pOutputImage)
119 {
120  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
121  pInputImage->type != pOutputImage->type)
122  return;
123 
124  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
125  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
126  IplImage *pIplTempImage = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_16S, 1);
127 
128  cvLaplace(pIplInputImage, pIplTempImage, 1);
129  cvConvertScaleAbs(pIplTempImage, pIplOutputImage);
130 
131  cvReleaseImage(&pIplTempImage);
132  cvReleaseImageHeader(&pIplInputImage);
133  cvReleaseImageHeader(&pIplOutputImage);
134 }
135 
136 void ImageProcessorCV::Laplacian5x5(CByteImage *pInputImage, CByteImage *pOutputImage)
137 {
138  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
139  pInputImage->type != pOutputImage->type || pInputImage->type != CByteImage::eGrayScale)
140  return;
141 
142  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
143  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
144  IplImage *pIplTempImage = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_16S, 1);
145 
146  cvLaplace(pIplInputImage, pIplTempImage, 5);
147  cvConvertScaleAbs(pIplTempImage, pIplOutputImage);
148 
149  cvReleaseImage(&pIplTempImage);
150  cvReleaseImageHeader(&pIplInputImage);
151  cvReleaseImageHeader(&pIplOutputImage);
152 }
153 
154 void ImageProcessorCV::Resize(const CByteImage *pInputImage, CByteImage *pOutputImage, int x, int y, int width, int height)
155 {
156  if (pInputImage->type != pOutputImage->type)
157  return;
158 
159  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
160  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
161 
162  if (x != -1)
163  cvSetImageROI(pIplInputImage, cvRect(x, y, width, height));
164 
165  cvResize(pIplInputImage, pIplOutputImage);
166 
167  cvReleaseImageHeader(&pIplInputImage);
168  cvReleaseImageHeader(&pIplOutputImage);
169 }
170 
171 void ImageProcessorCV::CalculateGradientImage(CByteImage *pInputImage, CByteImage *pOutputImage)
172 {
173  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
174  pOutputImage->type != CByteImage::eGrayScale)
175  return;
176 
177  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
178  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
179 
180  if (pInputImage->type == CByteImage::eGrayScale)
181  {
182  IplImage *diff = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_16S, 1);
183  IplImage *abs = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_8U, 1);
184 
185  cvSmooth(pIplInputImage, abs, CV_GAUSSIAN, 3, 3);
186  cvSobel(abs, diff, 1, 0, 3);
187  cvConvertScaleAbs(diff, pIplOutputImage);
188  cvSobel(abs, diff, 0, 1, 3);
189  cvConvertScaleAbs(diff, abs);
190  cvAdd(abs, pIplOutputImage, pIplOutputImage, 0);
191 
192  cvReleaseImage(&diff);
193  cvReleaseImage(&abs);
194  }
195  else if (pInputImage->type == CByteImage::eRGB24)
196  {
197  // Determine Gradient Image by Irina Wchter
198  // instead of normal norm sqrt(x*x +y*y) use |x|+|y| because it is much faster
199  IplImage *singleChannel0 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1);
200  IplImage *singleChannel1 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1);
201  IplImage *singleChannel2 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1);
202  IplImage *diff = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_16S, 1);
203  IplImage *abs = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_8U, 1);
204 
205  cvCvtPixToPlane(pIplInputImage, singleChannel0, singleChannel1, singleChannel2, NULL);
206 
207  cvSmooth(singleChannel0, singleChannel0, CV_GAUSSIAN, 3, 3);
208  cvSobel(singleChannel0, diff, 1, 0, 3);
209  cvConvertScaleAbs(diff, abs);
210  cvSobel(singleChannel0, diff, 0, 1, 3);
211  cvConvertScaleAbs(diff, singleChannel0);
212  cvAdd(abs, singleChannel0, pIplOutputImage, 0);
213 
214  cvSmooth(singleChannel1, singleChannel1, CV_GAUSSIAN, 3, 3);
215  cvSobel(singleChannel1, diff, 1, 0, 3);
216  cvConvertScaleAbs(diff, abs);
217  cvSobel(singleChannel1, diff, 0, 1, 3);
218  cvConvertScaleAbs(diff, singleChannel1);
219  cvAdd(abs, singleChannel1, singleChannel1, 0);
220  cvMax(pIplOutputImage, singleChannel1, pIplOutputImage);
221 
222  cvSmooth(singleChannel2, singleChannel2, CV_GAUSSIAN, 3, 3);
223  cvSobel(singleChannel2, diff, 1, 0, 3);
224  cvConvertScaleAbs(diff, abs);
225  cvSobel(singleChannel2, diff, 0, 1, 3);
226  cvConvertScaleAbs(diff, singleChannel2);
227  cvAdd(abs, singleChannel2, singleChannel2, 0);
228  cvMax(pIplOutputImage, singleChannel2, pIplOutputImage);
229 
230  cvReleaseImage(&singleChannel0);
231  cvReleaseImage(&singleChannel1);
232  cvReleaseImage(&singleChannel2);
233  cvReleaseImage(&diff);
234  cvReleaseImage(&abs);
235  }
236 
237  cvReleaseImageHeader(&pIplInputImage);
238  cvReleaseImageHeader(&pIplOutputImage);
239 }
240 
241 void ImageProcessorCV::CalculateGradientImageHSV(CByteImage *pInputImage, CByteImage *pOutputImage)
242 {
243  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
244  pInputImage->type != CByteImage::eRGB24 || pOutputImage->type != CByteImage::eGrayScale)
245  return;
246 
247  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
248  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
249 
250  // Determine Gradient Image by Irina Wchter
251  // instead of normal norm sqrt(x*x +y*y) use |x|+|y| because it is much faster
252  IplImage *singleChannel0 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1);
253  IplImage *singleChannel1 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1);
254  IplImage *singleChannel2 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1);
255  IplImage *diff = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_16S, 1);
256  IplImage *abs = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_8U, 1);
257 
258  cvCvtPixToPlane(pIplInputImage, singleChannel0, singleChannel1, singleChannel2, NULL);
259 
260  // calculate gradients on S-channel
261  //cvSmooth(singleChannel1, singleChannel1, CV_GAUSSIAN, 3, 3);
262  cvSobel(singleChannel1, diff, 1, 0, 3);
263  cvConvertScaleAbs(diff, abs);
264  cvSobel(singleChannel1, diff, 0, 1, 3);
265  cvConvertScaleAbs(diff, pIplOutputImage);
266  cvAdd(abs, pIplOutputImage, pIplOutputImage, 0);
267 
268  // threshold S-channel for creating a maskfor gradients of H-channel
269  cvThreshold(singleChannel1, singleChannel1, 60, 255, CV_THRESH_BINARY);
270  cvDilate(singleChannel1, singleChannel1);
271 
272  // calculate gradients on H-channel
273  //cvSmooth(singleChannel0, singleChannel0, CV_GAUSSIAN, 3, 3);
274  cvSobel(singleChannel0, diff, 1, 0, 3);
275  cvConvertScaleAbs(diff, abs);
276  cvSobel(singleChannel0, diff, 0, 1, 3);
277  cvConvertScaleAbs(diff, singleChannel0);
278  cvAdd(abs, singleChannel0, singleChannel0, 0);
279 
280  // filter gradients of H-channel with mask
281  cvAnd(singleChannel0, singleChannel1, singleChannel0);
282 
283  // combine to gradient images
284  cvMax(pIplOutputImage, singleChannel0, pIplOutputImage);
285 
286  // free memory
287  cvReleaseImage(&singleChannel0);
288  cvReleaseImage(&singleChannel1);
289  cvReleaseImage(&singleChannel2);
290  cvReleaseImage(&diff);
291  cvReleaseImage(&abs);
292 
293  cvReleaseImageHeader(&pIplInputImage);
294  cvReleaseImageHeader(&pIplOutputImage);
295 }
296 
297 void ImageProcessorCV::Canny(CByteImage *pInputImage, CByteImage *pOutputImage, int nLowThreshold, int nHighThreshold)
298 {
299  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
300  pInputImage->type != pOutputImage->type || pInputImage->type != CByteImage::eGrayScale)
301  return;
302 
303  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
304  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
305 
306  cvCanny(pIplInputImage, pIplOutputImage, nLowThreshold, nHighThreshold);
307 
308  cvReleaseImageHeader(&pIplInputImage);
309  cvReleaseImageHeader(&pIplOutputImage);
310 }
311 
312 void ImageProcessorCV::Dilate(CByteImage *pInputImage, CByteImage *pOutputImage)
313 {
314  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
315  pInputImage->type != pOutputImage->type || pInputImage->type != CByteImage::eGrayScale)
316  return;
317 
318  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
319  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
320 
321  cvDilate(pIplInputImage, pIplOutputImage);
322 
323  cvReleaseImageHeader(&pIplInputImage);
324  cvReleaseImageHeader(&pIplOutputImage);
325 }
326 
327 void ImageProcessorCV::Erode(CByteImage *pInputImage, CByteImage *pOutputImage)
328 {
329  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
330  pInputImage->type != pOutputImage->type || pInputImage->type != CByteImage::eGrayScale)
331  return;
332 
333  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
334  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
335 
336  cvErode(pIplInputImage, pIplOutputImage);
337 
338  cvReleaseImageHeader(&pIplInputImage);
339  cvReleaseImageHeader(&pIplOutputImage);
340 }
341 
342 double ImageProcessorCV::Mean(CByteImage *pImage1, CByteImage *pImage2)
343 {
344  if (pImage1->width != pImage2->width || pImage1->height != pImage2->height ||
345  pImage1->type != pImage2->type || pImage1->type != CByteImage::eGrayScale)
346  return -1;
347 
348  IplImage *pIplImage1 = IplImageAdaptor::Adapt(pImage1);
349  IplImage *pIplImage2 = IplImageAdaptor::Adapt(pImage2);
350 
351  double dRet = cvMean(pIplImage1, pIplImage2);
352 
353  cvReleaseImageHeader(&pIplImage1);
354  cvReleaseImageHeader(&pIplImage2);
355 
356  return dRet;
357 }
358 
359 void ImageProcessorCV::CalculateHSVImage(CByteImage *pInputImage, CByteImage *pOutputImage)
360 {
361  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
362  pInputImage->type != pOutputImage->type || pInputImage->type != CByteImage::eRGB24)
363  {
364  printf("error: input and output image do not match for ImageProcessorCV::CalculateHSVImage\n");
365  return;
366  }
367 
368  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
369  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
370 
371  cvCvtColor(pIplInputImage, pIplOutputImage, CV_RGB2HSV);
372 
373  cvReleaseImageHeader(&pIplInputImage);
374  cvReleaseImageHeader(&pIplOutputImage);
375 }
376 
377 void ImageProcessorCV::ConvertBayerPattern(CByteImage *pInputImage, CByteImage *pOutputImage, BayerPatternType type)
378 {
379  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
380  pInputImage->type != CByteImage::eGrayScale || pOutputImage->type != CByteImage::eRGB24)
381  {
382  printf("error: input and output image do not match for ImageProcessorCV::ConvertBayerPattern\n");
383  return;
384  }
385 
386  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
387  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
388 
389  switch (type)
390  {
391  case eBG2BGR: cvCvtColor(pIplInputImage, pIplOutputImage, CV_BayerBG2BGR); break;
392  case eGB2BGR: cvCvtColor(pIplInputImage, pIplOutputImage, CV_BayerGB2BGR); break;
393  case eRG2BGR: cvCvtColor(pIplInputImage, pIplOutputImage, CV_BayerRG2BGR); break;
394  case eGR2BGR: cvCvtColor(pIplInputImage, pIplOutputImage, CV_BayerGR2BGR); break;
395  case eBG2RGB: cvCvtColor(pIplInputImage, pIplOutputImage, CV_BayerBG2RGB); break;
396  case eGB2RGB: cvCvtColor(pIplInputImage, pIplOutputImage, CV_BayerGB2RGB); break;
397  case eRG2RGB: cvCvtColor(pIplInputImage, pIplOutputImage, CV_BayerRG2RGB); break;
398  case eGR2RGB: cvCvtColor(pIplInputImage, pIplOutputImage, CV_BayerGR2RGB); break;
399  }
400 
401  cvReleaseImageHeader(&pIplInputImage);
402  cvReleaseImageHeader(&pIplOutputImage);
403 }
404 
405 int ImageProcessorCV::CalculateFeaturePoints(const CByteImage *pImage, Vec2d *pFeaturePoints, int nMaxPoints, float fQualityLevel, float fMinDistance, bool bUseHarris)
406 {
407  if (pImage->type != CByteImage::eGrayScale)
408  {
409  printf("error: input image is not grayscale in ImageProcessorCV::CalculateFeaturePoints\n");
410  return -1;
411  }
412 
413  IplImage *pIplImage = IplImageAdaptor::Adapt(pImage);
414  IplImage *pEigenvalueImage = cvCreateImage(cvSize(pImage->width, pImage->height), IPL_DEPTH_32F, 1);
415  IplImage *pTempImage = cvCreateImage(cvSize(pImage->width, pImage->height), IPL_DEPTH_32F, 1);
416 
417  CvPoint2D32f *pCorners = new CvPoint2D32f[nMaxPoints];
418  int nCorners = nMaxPoints;
419 
420  if (bUseHarris)
421  cvGoodFeaturesToTrack(pIplImage, pEigenvalueImage, pTempImage, pCorners, &nCorners, fQualityLevel, fMinDistance, 0, 3, 1, 0.04);
422  else
423  cvGoodFeaturesToTrack(pIplImage, pEigenvalueImage, pTempImage, pCorners, &nCorners, fQualityLevel, fMinDistance, 0, 3);
424 
425  for (int i = 0; i < nCorners; i++)
426  {
427  pFeaturePoints[i].x = pCorners[i].x;
428  pFeaturePoints[i].y = pCorners[i].y;
429  }
430 
431  delete [] pCorners;
432 
433  cvReleaseImageHeader(&pIplImage);
434  cvReleaseImage(&pTempImage);
435  cvReleaseImage(&pEigenvalueImage);
436 
437  return nCorners;
438 }
439 
440 void ImageProcessorCV::ConvertImage(CByteImage *pInputImage, CByteImage *pOutputImage)
441 {
442  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
443  pInputImage->type == pOutputImage->type)
444  {
445  printf("error: input and output image do not match for ImageProcessorCV::ConvertImage\n");
446  return;
447  }
448 
449  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
450  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
451 
452  if (pInputImage->type == CByteImage::eRGB24)
453  cvCvtColor(pIplInputImage, pIplOutputImage, CV_RGB2GRAY);
454  else
455  cvCvtColor(pIplInputImage, pIplOutputImage, CV_GRAY2RGB);
456 
457  cvReleaseImageHeader(&pIplInputImage);
458  cvReleaseImageHeader(&pIplOutputImage);
459 }
ImageProcessorCV::FlipY
void FlipY(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:57
ImageProcessorCV::GaussianSmooth3x3
void GaussianSmooth3x3(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:72
Vec2d::y
float y
Definition: Math2d.h:84
CByteImage::width
int width
The width of the image in pixels.
Definition: ByteImage.h:257
ImageProcessorCV::Canny
void Canny(CByteImage *pInputImage, CByteImage *pOutputImage, int nLowThreshold, int nHighThreshold)
Deprecated.
Definition: ImageProcessorCV.cpp:297
CByteImage
Data structure for the representation of 8-bit grayscale images and 24-bit RGB (or HSV) color images ...
Definition: ByteImage.h:80
type
GLuint GLuint GLsizei GLenum type
Definition: glext.h:3121
ImageProcessorCV::ConvertBayerPattern
void ConvertBayerPattern(CByteImage *pInputImage, CByteImage *pOutputImage, BayerPatternType type=eRG2BGR)
Deprecated.
Definition: ImageProcessorCV.cpp:377
ImageProcessorCV::CalculateFeaturePoints
int CalculateFeaturePoints(const CByteImage *pImage, Vec2d *pFeaturePoints, int nMaxPoints, float fQualityLevel=0.01f, float fMinDistance=5.0f, bool bUseHarris=false)
Deprecated.
Definition: ImageProcessorCV.cpp:405
ImageProcessorCV::Resize
void Resize(const CByteImage *pInputImage, CByteImage *pOutputImage, int x=-1, int y=-1, int width=-1, int height=-1)
Deprecated.
Definition: ImageProcessorCV.cpp:154
x
GLenum GLint x
Definition: glext.h:3125
Vec2d::x
float x
Definition: Math2d.h:84
ImageProcessorCV::CalculateGradientImage
void CalculateGradientImage(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:171
ImageProcessorCV::Laplacian5x5
void Laplacian5x5(CByteImage *pInputImage, CByteImage *pOutputImage)
Calls cvLaplace with size 5x5.
Definition: ImageProcessorCV.cpp:136
ImageProcessorCV::GaussianSmooth5x5
void GaussianSmooth5x5(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:87
CByteImage::height
int height
The height of the image in pixels.
Definition: ByteImage.h:264
ImageProcessorCV::BilateralSmooth
void BilateralSmooth(CByteImage *pInputImage, CByteImage *pOutputImage, int param1, int param2)
Calls cvSmooth with the parameter CV_BILATERAL.
Definition: ImageProcessorCV.cpp:102
width
GLenum GLsizei width
Definition: glext.h:3122
height
GLenum GLsizei GLsizei height
Definition: glext.h:3132
CByteImage::type
ImageType type
The type of the image.
Definition: ByteImage.h:292
ImageProcessorCV::Dilate
void Dilate(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:312
y
GLenum GLint GLint y
Definition: glext.h:3125
Vec2d
Data structure for the representation of a 2D vector.
Definition: Math2d.h:82
IplImageAdaptor::Adapt
IplImage * Adapt(const CByteImage *pImage, bool bAllocateMemory=false)
Converts a CByteImage to an IplImage.
Definition: IplImageAdaptor.cpp:59
ImageProcessorCV::Erode
void Erode(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:327
ImageProcessorCV::Laplacian3x3
void Laplacian3x3(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:118
ImageProcessorCV::Mean
double Mean(CByteImage *pImage1, CByteImage *pImage2)
Deprecated.
Definition: ImageProcessorCV.cpp:342
ImageProcessorCV::CalculateGradientImageHSV
void CalculateGradientImageHSV(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:241
ImageProcessorCV::CalculateHSVImage
void CalculateHSVImage(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:359
ImageProcessorCV::ConvertImage
void ConvertImage(CByteImage *pInputImage, CByteImage *pOutputImage)
Image processing functions using OpenCV.
Definition: ImageProcessorCV.cpp:440

asr_ivt
Author(s): Allgeyer Tobias, Hutmacher Robin, Kleinert Daniel, Meißner Pascal, Scholz Jonas, Stöckle Patrick
autogenerated on Mon Dec 2 2019 03:47:28