IVT
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 // Filename: ImageProcessorCV.cpp
37 // Author: Pedram Azad
38 // Date: 2005
39 // ****************************************************************************
40 
41 
42 // ****************************************************************************
43 // Includes
44 // ****************************************************************************
45 
46 #include <new> // for explicitly using correct new/delete operators on VC DSPs
47 
48 #include "ImageProcessorCV.h"
49 
50 #include "IplImageAdaptor.h"
51 #include "ByteImage.h"
52 #include "Math/Math2d.h"
53 
54 #include <cv.h>
55 #include <stdio.h>
56 
57 
58 
59 // ****************************************************************************
60 // Functions
61 // ****************************************************************************
62 
63 void ImageProcessorCV::FlipY(CByteImage *pInputImage, CByteImage *pOutputImage)
64 {
65  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
66  pInputImage->type != pOutputImage->type)
67  return;
68 
69  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
70  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
71 
72  cvFlip(pIplInputImage, pIplOutputImage);
73 
74  cvReleaseImageHeader(&pIplInputImage);
75  cvReleaseImageHeader(&pIplOutputImage);
76 }
77 
78 void ImageProcessorCV::GaussianSmooth3x3(CByteImage *pInputImage, CByteImage *pOutputImage)
79 {
80  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
81  pInputImage->type != pOutputImage->type)
82  return;
83 
84  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
85  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
86 
87  cvSmooth(pIplInputImage, pIplOutputImage, CV_GAUSSIAN, 3, 3);
88 
89  cvReleaseImageHeader(&pIplInputImage);
90  cvReleaseImageHeader(&pIplOutputImage);
91 }
92 
93 void ImageProcessorCV::GaussianSmooth5x5(CByteImage *pInputImage, CByteImage *pOutputImage)
94 {
95  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
96  pInputImage->type != pOutputImage->type)
97  return;
98 
99  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
100  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
101 
102  cvSmooth(pIplInputImage, pIplOutputImage, CV_GAUSSIAN, 5, 5);
103 
104  cvReleaseImageHeader(&pIplInputImage);
105  cvReleaseImageHeader(&pIplOutputImage);
106 }
107 
108 void ImageProcessorCV::BilateralSmooth(CByteImage *pInputImage, CByteImage *pOutputImage, int param1, int param2)
109 {
110  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
111  pInputImage->type != pOutputImage->type)
112  return;
113 
114  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
115  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
116 
117  cvSmooth(pIplInputImage, pIplOutputImage, CV_BILATERAL, param1, param2);
118 
119  cvReleaseImageHeader(&pIplInputImage);
120  cvReleaseImageHeader(&pIplOutputImage);
121 
122 }
123 
124 void ImageProcessorCV::Laplacian3x3(CByteImage *pInputImage, CByteImage *pOutputImage)
125 {
126  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
127  pInputImage->type != pOutputImage->type)
128  return;
129 
130  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
131  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
132  IplImage *pIplTempImage = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_16S, 1);
133 
134  cvLaplace(pIplInputImage, pIplTempImage, 1);
135  cvConvertScaleAbs(pIplTempImage, pIplOutputImage);
136 
137  cvReleaseImage(&pIplTempImage);
138  cvReleaseImageHeader(&pIplInputImage);
139  cvReleaseImageHeader(&pIplOutputImage);
140 }
141 
142 void ImageProcessorCV::Laplacian5x5(CByteImage *pInputImage, CByteImage *pOutputImage)
143 {
144  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
145  pInputImage->type != pOutputImage->type || pInputImage->type != CByteImage::eGrayScale)
146  return;
147 
148  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
149  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
150  IplImage *pIplTempImage = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_16S, 1);
151 
152  cvLaplace(pIplInputImage, pIplTempImage, 5);
153  cvConvertScaleAbs(pIplTempImage, pIplOutputImage);
154 
155  cvReleaseImage(&pIplTempImage);
156  cvReleaseImageHeader(&pIplInputImage);
157  cvReleaseImageHeader(&pIplOutputImage);
158 }
159 
160 void ImageProcessorCV::Resize(const CByteImage *pInputImage, CByteImage *pOutputImage, int x, int y, int width, int height)
161 {
162  if (pInputImage->type != pOutputImage->type)
163  return;
164 
165  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
166  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
167 
168  if (x != -1)
169  cvSetImageROI(pIplInputImage, cvRect(x, y, width, height));
170 
171  cvResize(pIplInputImage, pIplOutputImage);
172 
173  cvReleaseImageHeader(&pIplInputImage);
174  cvReleaseImageHeader(&pIplOutputImage);
175 }
176 
177 void ImageProcessorCV::CalculateGradientImage(CByteImage *pInputImage, CByteImage *pOutputImage)
178 {
179  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
180  pOutputImage->type != CByteImage::eGrayScale)
181  return;
182 
183  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
184  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
185 
186  if (pInputImage->type == CByteImage::eGrayScale)
187  {
188  IplImage *diff = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_16S, 1);
189  IplImage *abs = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_8U, 1);
190 
191  cvSmooth(pIplInputImage, abs, CV_GAUSSIAN, 3, 3);
192  cvSobel(abs, diff, 1, 0, 3);
193  cvConvertScaleAbs(diff, pIplOutputImage);
194  cvSobel(abs, diff, 0, 1, 3);
195  cvConvertScaleAbs(diff, abs);
196  cvAdd(abs, pIplOutputImage, pIplOutputImage, 0);
197 
198  cvReleaseImage(&diff);
199  cvReleaseImage(&abs);
200  }
201  else if (pInputImage->type == CByteImage::eRGB24)
202  {
203  // Determine Gradient Image by Irina Wchter
204  // instead of normal norm sqrt(x*x +y*y) use |x|+|y| because it is much faster
205  IplImage *singleChannel0 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1);
206  IplImage *singleChannel1 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1);
207  IplImage *singleChannel2 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1);
208  IplImage *diff = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_16S, 1);
209  IplImage *abs = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_8U, 1);
210 
211  cvCvtPixToPlane(pIplInputImage, singleChannel0, singleChannel1, singleChannel2, NULL);
212 
213  cvSmooth(singleChannel0, singleChannel0, CV_GAUSSIAN, 3, 3);
214  cvSobel(singleChannel0, diff, 1, 0, 3);
215  cvConvertScaleAbs(diff, abs);
216  cvSobel(singleChannel0, diff, 0, 1, 3);
217  cvConvertScaleAbs(diff, singleChannel0);
218  cvAdd(abs, singleChannel0, pIplOutputImage, 0);
219 
220  cvSmooth(singleChannel1, singleChannel1, CV_GAUSSIAN, 3, 3);
221  cvSobel(singleChannel1, diff, 1, 0, 3);
222  cvConvertScaleAbs(diff, abs);
223  cvSobel(singleChannel1, diff, 0, 1, 3);
224  cvConvertScaleAbs(diff, singleChannel1);
225  cvAdd(abs, singleChannel1, singleChannel1, 0);
226  cvMax(pIplOutputImage, singleChannel1, pIplOutputImage);
227 
228  cvSmooth(singleChannel2, singleChannel2, CV_GAUSSIAN, 3, 3);
229  cvSobel(singleChannel2, diff, 1, 0, 3);
230  cvConvertScaleAbs(diff, abs);
231  cvSobel(singleChannel2, diff, 0, 1, 3);
232  cvConvertScaleAbs(diff, singleChannel2);
233  cvAdd(abs, singleChannel2, singleChannel2, 0);
234  cvMax(pIplOutputImage, singleChannel2, pIplOutputImage);
235 
236  cvReleaseImage(&singleChannel0);
237  cvReleaseImage(&singleChannel1);
238  cvReleaseImage(&singleChannel2);
239  cvReleaseImage(&diff);
240  cvReleaseImage(&abs);
241  }
242 
243  cvReleaseImageHeader(&pIplInputImage);
244  cvReleaseImageHeader(&pIplOutputImage);
245 }
246 
247 void ImageProcessorCV::CalculateGradientImageHSV(CByteImage *pInputImage, CByteImage *pOutputImage)
248 {
249  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
250  pInputImage->type != CByteImage::eRGB24 || pOutputImage->type != CByteImage::eGrayScale)
251  return;
252 
253  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
254  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
255 
256  // Determine Gradient Image by Irina Wchter
257  // instead of normal norm sqrt(x*x +y*y) use |x|+|y| because it is much faster
258  IplImage *singleChannel0 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1);
259  IplImage *singleChannel1 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1);
260  IplImage *singleChannel2 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1);
261  IplImage *diff = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_16S, 1);
262  IplImage *abs = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_8U, 1);
263 
264  cvCvtPixToPlane(pIplInputImage, singleChannel0, singleChannel1, singleChannel2, NULL);
265 
266  // calculate gradients on S-channel
267  //cvSmooth(singleChannel1, singleChannel1, CV_GAUSSIAN, 3, 3);
268  cvSobel(singleChannel1, diff, 1, 0, 3);
269  cvConvertScaleAbs(diff, abs);
270  cvSobel(singleChannel1, diff, 0, 1, 3);
271  cvConvertScaleAbs(diff, pIplOutputImage);
272  cvAdd(abs, pIplOutputImage, pIplOutputImage, 0);
273 
274  // threshold S-channel for creating a maskfor gradients of H-channel
275  cvThreshold(singleChannel1, singleChannel1, 60, 255, CV_THRESH_BINARY);
276  cvDilate(singleChannel1, singleChannel1);
277 
278  // calculate gradients on H-channel
279  //cvSmooth(singleChannel0, singleChannel0, CV_GAUSSIAN, 3, 3);
280  cvSobel(singleChannel0, diff, 1, 0, 3);
281  cvConvertScaleAbs(diff, abs);
282  cvSobel(singleChannel0, diff, 0, 1, 3);
283  cvConvertScaleAbs(diff, singleChannel0);
284  cvAdd(abs, singleChannel0, singleChannel0, 0);
285 
286  // filter gradients of H-channel with mask
287  cvAnd(singleChannel0, singleChannel1, singleChannel0);
288 
289  // combine to gradient images
290  cvMax(pIplOutputImage, singleChannel0, pIplOutputImage);
291 
292  // free memory
293  cvReleaseImage(&singleChannel0);
294  cvReleaseImage(&singleChannel1);
295  cvReleaseImage(&singleChannel2);
296  cvReleaseImage(&diff);
297  cvReleaseImage(&abs);
298 
299  cvReleaseImageHeader(&pIplInputImage);
300  cvReleaseImageHeader(&pIplOutputImage);
301 }
302 
303 void ImageProcessorCV::Canny(CByteImage *pInputImage, CByteImage *pOutputImage, int nLowThreshold, int nHighThreshold)
304 {
305  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
306  pInputImage->type != pOutputImage->type || pInputImage->type != CByteImage::eGrayScale)
307  return;
308 
309  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
310  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
311 
312  cvCanny(pIplInputImage, pIplOutputImage, nLowThreshold, nHighThreshold);
313 
314  cvReleaseImageHeader(&pIplInputImage);
315  cvReleaseImageHeader(&pIplOutputImage);
316 }
317 
318 void ImageProcessorCV::Dilate(CByteImage *pInputImage, CByteImage *pOutputImage)
319 {
320  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
321  pInputImage->type != pOutputImage->type || pInputImage->type != CByteImage::eGrayScale)
322  return;
323 
324  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
325  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
326 
327  cvDilate(pIplInputImage, pIplOutputImage);
328 
329  cvReleaseImageHeader(&pIplInputImage);
330  cvReleaseImageHeader(&pIplOutputImage);
331 }
332 
333 void ImageProcessorCV::Erode(CByteImage *pInputImage, CByteImage *pOutputImage)
334 {
335  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
336  pInputImage->type != pOutputImage->type || pInputImage->type != CByteImage::eGrayScale)
337  return;
338 
339  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
340  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
341 
342  cvErode(pIplInputImage, pIplOutputImage);
343 
344  cvReleaseImageHeader(&pIplInputImage);
345  cvReleaseImageHeader(&pIplOutputImage);
346 }
347 
348 double ImageProcessorCV::Mean(CByteImage *pImage1, CByteImage *pImage2)
349 {
350  if (pImage1->width != pImage2->width || pImage1->height != pImage2->height ||
351  pImage1->type != pImage2->type || pImage1->type != CByteImage::eGrayScale)
352  return -1;
353 
354  IplImage *pIplImage1 = IplImageAdaptor::Adapt(pImage1);
355  IplImage *pIplImage2 = IplImageAdaptor::Adapt(pImage2);
356 
357  double dRet = cvMean(pIplImage1, pIplImage2);
358 
359  cvReleaseImageHeader(&pIplImage1);
360  cvReleaseImageHeader(&pIplImage2);
361 
362  return dRet;
363 }
364 
365 void ImageProcessorCV::CalculateHSVImage(CByteImage *pInputImage, CByteImage *pOutputImage)
366 {
367  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
368  pInputImage->type != pOutputImage->type || pInputImage->type != CByteImage::eRGB24)
369  {
370  printf("error: input and output image do not match for ImageProcessorCV::CalculateHSVImage\n");
371  return;
372  }
373 
374  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
375  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
376 
377  cvCvtColor(pIplInputImage, pIplOutputImage, CV_RGB2HSV);
378 
379  cvReleaseImageHeader(&pIplInputImage);
380  cvReleaseImageHeader(&pIplOutputImage);
381 }
382 
383 void ImageProcessorCV::ConvertBayerPattern(CByteImage *pInputImage, CByteImage *pOutputImage, BayerPatternType type)
384 {
385  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
386  pInputImage->type != CByteImage::eGrayScale || pOutputImage->type != CByteImage::eRGB24)
387  {
388  printf("error: input and output image do not match for ImageProcessorCV::ConvertBayerPattern\n");
389  return;
390  }
391 
392  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
393  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
394 
395  switch (type)
396  {
397  case eBG2BGR: cvCvtColor(pIplInputImage, pIplOutputImage, CV_BayerBG2BGR); break;
398  case eGB2BGR: cvCvtColor(pIplInputImage, pIplOutputImage, CV_BayerGB2BGR); break;
399  case eRG2BGR: cvCvtColor(pIplInputImage, pIplOutputImage, CV_BayerRG2BGR); break;
400  case eGR2BGR: cvCvtColor(pIplInputImage, pIplOutputImage, CV_BayerGR2BGR); break;
401  case eBG2RGB: cvCvtColor(pIplInputImage, pIplOutputImage, CV_BayerBG2RGB); break;
402  case eGB2RGB: cvCvtColor(pIplInputImage, pIplOutputImage, CV_BayerGB2RGB); break;
403  case eRG2RGB: cvCvtColor(pIplInputImage, pIplOutputImage, CV_BayerRG2RGB); break;
404  case eGR2RGB: cvCvtColor(pIplInputImage, pIplOutputImage, CV_BayerGR2RGB); break;
405  }
406 
407  cvReleaseImageHeader(&pIplInputImage);
408  cvReleaseImageHeader(&pIplOutputImage);
409 }
410 
411 int ImageProcessorCV::CalculateFeaturePoints(const CByteImage *pImage, Vec2d *pFeaturePoints, int nMaxPoints, float fQualityLevel, float fMinDistance, bool bUseHarris)
412 {
413  if (pImage->type != CByteImage::eGrayScale)
414  {
415  printf("error: input image is not grayscale in ImageProcessorCV::CalculateFeaturePoints\n");
416  return -1;
417  }
418 
419  IplImage *pIplImage = IplImageAdaptor::Adapt(pImage);
420  IplImage *pEigenvalueImage = cvCreateImage(cvSize(pImage->width, pImage->height), IPL_DEPTH_32F, 1);
421  IplImage *pTempImage = cvCreateImage(cvSize(pImage->width, pImage->height), IPL_DEPTH_32F, 1);
422 
423  CvPoint2D32f *pCorners = new CvPoint2D32f[nMaxPoints];
424  int nCorners = nMaxPoints;
425 
426  if (bUseHarris)
427  cvGoodFeaturesToTrack(pIplImage, pEigenvalueImage, pTempImage, pCorners, &nCorners, fQualityLevel, fMinDistance, 0, 3, 1, 0.04);
428  else
429  cvGoodFeaturesToTrack(pIplImage, pEigenvalueImage, pTempImage, pCorners, &nCorners, fQualityLevel, fMinDistance, 0, 3);
430 
431  for (int i = 0; i < nCorners; i++)
432  {
433  pFeaturePoints[i].x = pCorners[i].x;
434  pFeaturePoints[i].y = pCorners[i].y;
435  }
436 
437  delete [] pCorners;
438 
439  cvReleaseImageHeader(&pIplImage);
440  cvReleaseImage(&pTempImage);
441  cvReleaseImage(&pEigenvalueImage);
442 
443  return nCorners;
444 }
445 
446 void ImageProcessorCV::ConvertImage(CByteImage *pInputImage, CByteImage *pOutputImage)
447 {
448  if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
449  pInputImage->type == pOutputImage->type)
450  {
451  printf("error: input and output image do not match for ImageProcessorCV::ConvertImage\n");
452  return;
453  }
454 
455  IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
456  IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
457 
458  if (pInputImage->type == CByteImage::eRGB24)
459  cvCvtColor(pIplInputImage, pIplOutputImage, CV_RGB2GRAY);
460  else
461  cvCvtColor(pIplInputImage, pIplOutputImage, CV_GRAY2RGB);
462 
463  cvReleaseImageHeader(&pIplInputImage);
464  cvReleaseImageHeader(&pIplOutputImage);
465 }
ImageProcessorCV::GaussianSmooth5x5
void GaussianSmooth5x5(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:93
Vec2d
Data structure for the representation of a 2D vector.
Definition: Math2d.h:82
ImageProcessorCV::CalculateGradientImageHSV
void CalculateGradientImageHSV(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:247
ImageProcessorCV::Dilate
void Dilate(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:318
ImageProcessorCV::FlipY
void FlipY(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:63
ImageProcessorCV::BilateralSmooth
void BilateralSmooth(CByteImage *pInputImage, CByteImage *pOutputImage, int param1, int param2)
Calls cvSmooth with the parameter CV_BILATERAL.
Definition: ImageProcessorCV.cpp:108
Vec2d::x
float x
Definition: Math2d.h:84
ByteImage.h
ImageProcessorCV::Canny
void Canny(CByteImage *pInputImage, CByteImage *pOutputImage, int nLowThreshold, int nHighThreshold)
Deprecated.
Definition: ImageProcessorCV.cpp:303
ImageProcessorCV::Laplacian5x5
void Laplacian5x5(CByteImage *pInputImage, CByteImage *pOutputImage)
Calls cvLaplace with size 5x5.
Definition: ImageProcessorCV.cpp:142
ImageProcessorCV::CalculateHSVImage
void CalculateHSVImage(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:365
ImageProcessorCV::Mean
double Mean(CByteImage *pImage1, CByteImage *pImage2)
Deprecated.
Definition: ImageProcessorCV.cpp:348
ImageProcessorCV::ConvertImage
void ConvertImage(CByteImage *pInputImage, CByteImage *pOutputImage)
Image processing functions using OpenCV.
Definition: ImageProcessorCV.cpp:446
IplImageAdaptor::Adapt
IplImage * Adapt(const CByteImage *pImage, bool bAllocateMemory=false)
Converts a CByteImage to an IplImage.
Definition: IplImageAdaptor.cpp:59
ImageProcessorCV::CalculateGradientImage
void CalculateGradientImage(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:177
ImageProcessorCV.h
ImageProcessorCV::Laplacian3x3
void Laplacian3x3(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:124
Vec2d::y
float y
Definition: Math2d.h:84
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:160
Math2d.h
CByteImage::type
ImageType type
The type of the image.
Definition: ByteImage.h:292
CByteImage::width
int width
The width of the image in pixels.
Definition: ByteImage.h:257
CByteImage::height
int height
The height of the image in pixels.
Definition: ByteImage.h:264
IplImageAdaptor.h
ImageProcessorCV::Erode
void Erode(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:333
ImageProcessorCV::ConvertBayerPattern
void ConvertBayerPattern(CByteImage *pInputImage, CByteImage *pOutputImage, BayerPatternType type=eRG2BGR)
Deprecated.
Definition: ImageProcessorCV.cpp:383
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:411
ImageProcessorCV::GaussianSmooth3x3
void GaussianSmooth3x3(CByteImage *pInputImage, CByteImage *pOutputImage)
Deprecated.
Definition: ImageProcessorCV.cpp:78
CByteImage
Data structure for the representation of 8-bit grayscale images and 24-bit RGB (or HSV) color images ...
Definition: ByteImage.h:80