00001
00018 #include "vetDigitalFilter.h"
00019
00020
00027 vetDigitalFilter::vetDigitalFilter(vetDigitalFilterParameters* initParams) : vetFilter()
00028 {
00029 setParameters(initParams);
00030 reset();
00031
00032 setName("Digital Filter");
00033 setDescription("Lowpass, gaussian, highpass....");
00034 setVersion(1.0);
00035 }
00036
00037
00041 vetDigitalFilter::~vetDigitalFilter()
00042 {
00043 if (myParams != NULL)
00044 delete myParams;
00045 myParams = NULL;
00046
00047 }
00048
00049
00050 VETRESULT vetDigitalFilter::reset()
00051 {
00052 INFO("VETRESULT vetDigitalFilter::reset() [SET DEFAULT PARAMETERS]")
00053
00054 releaseBuffers();
00055
00056 if (myParams != NULL)
00057 {
00058 myParams->reset();
00059 allocateBuffer(myParams->currentBuffer);
00060 }
00061 else
00062 setParameters(NULL);
00063
00064 return VETRET_OK;
00065 }
00066
00067
00068
00069 VETRESULT vetDigitalFilter::setParameters (vetDigitalFilterParameters* initParams)
00070 {
00071
00072 if ( initParams == NULL )
00073 myParams = new vetDigitalFilterParameters();
00074 else
00075 myParams = initParams;
00076
00077 allocateBuffer(myParams->currentBuffer);
00078
00079 return VETRET_OK;
00080 }
00081
00082
00083 VETRESULT vetDigitalFilter::setDefaultKernel(int index)
00084 {
00085
00086 if (myParams->currentKernel != NULL)
00087 delete myParams->currentKernel;
00088
00089 myParams->currentKernel = vetDFMatrix::createKernel_3x3(index);
00090
00091 return VETRET_OK;
00092
00093 }
00094
00095
00096
00098
00099
00100
00101
00102 VETRESULT vetDigitalFilter::importFrom(vetFrameYUV420& img)
00103 {
00104 DEBUGMSG("VETRESULT vetDigitalFilter::importFrom(vetFrameYUV420& img) [reading data]", myParams->runMode)
00105
00106 int ret = VETRET_OK;
00107
00108 if ( !isBufferYUV() )
00109 {
00110 useBufferYUV(img.width, img.height);
00111 ret = VETRET_OK_DEPRECATED;
00112 }
00113
00114 if (myParams->currentKernel == NULL)
00115 {
00116 *bufferYUV = img;
00117 return ret;
00118 }
00119 else
00120 ret += doProcessing(img, *bufferYUV, *myParams->currentKernel, myParams->clampNegative);
00121
00122 return ret;
00123 }
00124
00125 VETRESULT vetDigitalFilter::importFrom(vetFrameRGB24& img)
00126 {
00127 DEBUGMSG("VETRESULT vetDigitalFilter::importFrom(vetFrameYUV420& img) [reading data]", myParams->runMode)
00128
00129 int ret = VETRET_OK;
00130
00131 if ( !isBufferRGB() )
00132 {
00133 useBufferRGB(img.width, img.height);
00134 ret = VETRET_OK_DEPRECATED;
00135 }
00136
00137 if (myParams->currentKernel == NULL)
00138 {
00139 *bufferRGB = img;
00140 return ret;
00141 }
00142 else
00143 ret += doProcessing(img, *bufferRGB, *myParams->currentKernel, myParams->clampNegative);
00144
00145 return ret;
00146 }
00147
00148
00149 VETRESULT vetDigitalFilter::importFrom(vetFrameT<unsigned char>& img)
00150 {
00151 DEBUGMSG("VETRESULT vetDigitalFilter::importFrom(vetFrameT& img) [reading data]", myParams->runMode)
00152
00153 return VETRET_NOT_IMPLEMENTED;
00154 }
00155
00156
00157
00158
00159
00160
00164
00165
00166
00167 VETRESULT vetDigitalFilter::doProcessing(vetFrameRGB24& source, vetFrameRGB24& dest, vetDFMatrix& kernel, bool clamp)
00168 {
00169 if (source.width != dest.width || source.height != dest.height)
00170 dest.reAllocCanvas(source.width, source.height);
00171
00172 signed long numb;
00173 unsigned int src_w = source.width;
00174
00175 if (kernel.getDim() == 3)
00176 {
00177 for(unsigned int x=0; x < src_w; x++)
00178 for(unsigned int y=0; y < source.height; y++)
00179 {
00180 if ( x && y && (x != src_w-1) && (y != source.height-1))
00181 {
00182 for(int ch=0; ch < 3; ch++)
00183 {
00184 numb = (long) ( (long) source.data[(y-1) * src_w + (x-1)][ch] * kernel[0] +
00185 (long) source.data[(y-1) * src_w + x ][ch] * kernel[1] +
00186 (long) source.data[(y-1) * src_w + (x+1)][ch] * kernel[2] +
00187 (long) source.data[ y * src_w + (x-1)][ch] * kernel[3] +
00188 (long) source.data[ y * src_w + x ][ch] * kernel[4] +
00189 (long) source.data[ y * src_w + (x+1)][ch] * kernel[5] +
00190 (long) source.data[(y+1) * src_w + (x-1)][ch] * kernel[6] +
00191 (long) source.data[(y+1) * src_w + x ][ch] * kernel[7] +
00192 (long) source.data[(y+1) * src_w + (x+1)][ch] * kernel[8] );
00193
00194 if ( numb )
00195 numb /= (long)kernel[9];
00196
00197 dest.data[y * src_w + x][ch] = (unsigned char)numb;
00198 }
00199 }
00200 else
00201 {
00202 dest.data[y * src_w + x][0] = source.data[y * src_w + x][0];
00203 dest.data[y * src_w + x][1] = source.data[y * src_w + x][1];
00204 dest.data[y * src_w + x][2] = source.data[y * src_w + x][2];
00205 }
00206 }
00207 }
00208 else if (kernel.getDim() == 5)
00209 {
00210 for(unsigned int x=0; x < src_w; x++)
00211 for(unsigned int y=0; y < source.height; y++)
00212 {
00213 if ( (x-2) && (y-2) && (x != src_w-2) && (y != source.height-2))
00214 {
00215 for(int ch=0; ch < 3; ch++)
00216 {
00217 numb = (long) (
00218 (long) source.data[(y-2) * src_w + (x-2)][ch] * kernel[0] +
00219 (long) source.data[(y-2) * src_w + (x-1)][ch] * kernel[1] +
00220 (long) source.data[(y-2) * src_w + x ][ch] * kernel[2] +
00221 (long) source.data[(y-2) * src_w + (x+1)][ch] * kernel[3] +
00222 (long) source.data[(y-2) * src_w + (x+2)][ch] * kernel[4] +
00223 (long) source.data[(y-1) * src_w + (x-2)][ch] * kernel[5] +
00224 (long) source.data[(y-1) * src_w + (x-1)][ch] * kernel[6] +
00225 (long) source.data[(y-1) * src_w + x ][ch] * kernel[7] +
00226 (long) source.data[(y-1) * src_w + (x+1)][ch] * kernel[8] +
00227 (long) source.data[(y-1) * src_w + (x+2)][ch] * kernel[9] +
00228 (long) source.data[ y * src_w + (x-2)][ch] * kernel[10] +
00229 (long) source.data[ y * src_w + (x-1)][ch] * kernel[11] +
00230 (long) source.data[ y * src_w + x ][ch] * kernel[12] +
00231 (long) source.data[ y * src_w + (x+1)][ch] * kernel[13] +
00232 (long) source.data[ y * src_w + (x+2)][ch] * kernel[14] +
00233 (long) source.data[(y+1) * src_w + (x-2)][ch] * kernel[15] +
00234 (long) source.data[(y+1) * src_w + (x-1)][ch] * kernel[16] +
00235 (long) source.data[(y+1) * src_w + x ][ch] * kernel[17] +
00236 (long) source.data[(y+1) * src_w + (x+1)][ch] * kernel[18] +
00237 (long) source.data[(y+1) * src_w + (x+2)][ch] * kernel[19] +
00238 (long) source.data[(y+2) * src_w + (x-2)][ch] * kernel[20] +
00239 (long) source.data[(y+2) * src_w + (x-1)][ch] * kernel[21] +
00240 (long) source.data[(y+2) * src_w + x ][ch] * kernel[22] +
00241 (long) source.data[(y+2) * src_w + (x+1)][ch] * kernel[23] +
00242 (long) source.data[(y+2) * src_w + (x+2)][ch] * kernel[24] );
00243
00244 if ( numb )
00245 numb /= (long)kernel[25];
00246
00247 dest.data[y * src_w + x][ch] = (unsigned char)numb;
00248 }
00249 }
00250 else
00251 {
00252 dest.data[y * src_w + x][0] = source.data[y * src_w + x][0];
00253 dest.data[y * src_w + x][1] = source.data[y * src_w + x][1];
00254 dest.data[y * src_w + x][2] = source.data[y * src_w + x][2];
00255 }
00256 }
00257 }
00258 else if (kernel.getDim() == 7)
00259 {
00260 for(unsigned int x=0; x < src_w; x++)
00261 for(unsigned int y=0; y < source.height; y++)
00262 {
00263 if ( (x-3) && (y-3) && (x != src_w-3) && (y != source.height-3))
00264 {
00265 for(int ch=0; ch < 3; ch++)
00266 {
00267 numb = (long) (
00268 (long) source.data[(y-3) * src_w + (x-3)][ch] * kernel[0] +
00269 (long) source.data[(y-3) * src_w + (x-2)][ch] * kernel[1] +
00270 (long) source.data[(y-3) * src_w + (x-1)][ch] * kernel[2] +
00271 (long) source.data[(y-3) * src_w + x ][ch] * kernel[3] +
00272 (long) source.data[(y-3) * src_w + (x+1)][ch] * kernel[4] +
00273 (long) source.data[(y-3) * src_w + (x+2)][ch] * kernel[5] +
00274 (long) source.data[(y-3) * src_w + (x+3)][ch] * kernel[6] +
00275 (long) source.data[(y-2) * src_w + (x-3)][ch] * kernel[7] +
00276 (long) source.data[(y-2) * src_w + (x-2)][ch] * kernel[8] +
00277 (long) source.data[(y-2) * src_w + (x-1)][ch] * kernel[9] +
00278 (long) source.data[(y-2) * src_w + x ][ch] * kernel[10] +
00279 (long) source.data[(y-2) * src_w + (x+1)][ch] * kernel[11] +
00280 (long) source.data[(y-2) * src_w + (x+2)][ch] * kernel[12] +
00281 (long) source.data[(y-2) * src_w + (x+3)][ch] * kernel[13] +
00282 (long) source.data[(y-1) * src_w + (x-3)][ch] * kernel[14] +
00283 (long) source.data[(y-1) * src_w + (x-2)][ch] * kernel[15] +
00284 (long) source.data[(y-1) * src_w + (x-1)][ch] * kernel[16] +
00285 (long) source.data[(y-1) * src_w + x ][ch] * kernel[17] +
00286 (long) source.data[(y-1) * src_w + (x+1)][ch] * kernel[18] +
00287 (long) source.data[(y-1) * src_w + (x+2)][ch] * kernel[19] +
00288 (long) source.data[(y-1) * src_w + (x+3)][ch] * kernel[20] +
00289 (long) source.data[ y * src_w + (x-3)][ch] * kernel[21] +
00290 (long) source.data[ y * src_w + (x-2)][ch] * kernel[22] +
00291 (long) source.data[ y * src_w + (x-1)][ch] * kernel[23] +
00292 (long) source.data[ y * src_w + x ][ch] * kernel[24] +
00293 (long) source.data[ y * src_w + (x+1)][ch] * kernel[25] +
00294 (long) source.data[ y * src_w + (x+2)][ch] * kernel[26] +
00295 (long) source.data[ y * src_w + (x+3)][ch] * kernel[27] +
00296 (long) source.data[(y+1) * src_w + (x-3)][ch] * kernel[28] +
00297 (long) source.data[(y+1) * src_w + (x-2)][ch] * kernel[29] +
00298 (long) source.data[(y+1) * src_w + (x-1)][ch] * kernel[30] +
00299 (long) source.data[(y+1) * src_w + x ][ch] * kernel[31] +
00300 (long) source.data[(y+1) * src_w + (x+1)][ch] * kernel[32] +
00301 (long) source.data[(y+1) * src_w + (x+2)][ch] * kernel[33] +
00302 (long) source.data[(y+1) * src_w + (x+3)][ch] * kernel[34] +
00303 (long) source.data[(y+2) * src_w + (x-3)][ch] * kernel[35] +
00304 (long) source.data[(y+2) * src_w + (x-2)][ch] * kernel[36] +
00305 (long) source.data[(y+2) * src_w + (x-1)][ch] * kernel[37] +
00306 (long) source.data[(y+2) * src_w + x ][ch] * kernel[38] +
00307 (long) source.data[(y+2) * src_w + (x+1)][ch] * kernel[39] +
00308 (long) source.data[(y+2) * src_w + (x+2)][ch] * kernel[40] +
00309 (long) source.data[(y+2) * src_w + (x+3)][ch] * kernel[41] +
00310 (long) source.data[(y+3) * src_w + (x-3)][ch] * kernel[42] +
00311 (long) source.data[(y+3) * src_w + (x-2)][ch] * kernel[43] +
00312 (long) source.data[(y+3) * src_w + (x-1)][ch] * kernel[44] +
00313 (long) source.data[(y+3) * src_w + x ][ch] * kernel[45] +
00314 (long) source.data[(y+3) * src_w + (x+1)][ch] * kernel[46] +
00315 (long) source.data[(y+3) * src_w + (x+2)][ch] * kernel[47] +
00316 (long) source.data[(y+3) * src_w + (x+3)][ch] * kernel[48] );
00317
00318 if ( numb )
00319 numb /= (long)kernel[49];
00320
00321 dest.data[y * src_w + x][ch] = (unsigned char)numb;
00322 }
00323 }
00324 else
00325 {
00326 dest.data[y * src_w + x][0] = source.data[y * src_w + x][0];
00327 dest.data[y * src_w + x][1] = source.data[y * src_w + x][1];
00328 dest.data[y * src_w + x][2] = source.data[y * src_w + x][2];
00329 }
00330 }
00331 }
00332 else
00333 return VETRET_NOT_IMPLEMENTED;
00334
00335 return VETRET_OK;
00336 }
00337
00338
00339 VETRESULT vetDigitalFilter::doProcessing(vetFrameYUV420& source, vetFrameYUV420& dest, vetDFMatrix& kernel, bool clamp)
00340 {
00341 if (source.width != dest.width || source.height != dest.height)
00342 dest.reAllocCanvas(source.width, source.height);
00343
00344 return VETRET_NOT_IMPLEMENTED;
00345
00346 }
00347
00348 VETRESULT vetDigitalFilter::doProcessing(vetFrameT<unsigned char>& source, vetFrameT<unsigned char>& dest, vetDFMatrix& kernel, bool clamp)
00349 {
00350 if (source.width != dest.width || source.height != dest.height)
00351 dest.reAllocCanvas(source.width, source.height);
00352
00353 return VETRET_NOT_IMPLEMENTED;
00354
00355 }
00356
00357
00358 VETRESULT vetDigitalFilter::doRotateKernel(vetDFMatrix& kernel)
00359 {
00360 if (&kernel == NULL)
00361 return VETRET_PARAM_ERR;
00362
00363 char tmpVal;
00364
00365 if (kernel.getDim() == 3)
00366 {
00367 tmpVal = kernel[0];
00368 kernel[0] = kernel[3];
00369 kernel[3] = kernel[6];
00370 kernel[6] = kernel[7];
00371 kernel[7] = kernel[8];
00372 kernel[8] = kernel[5];
00373 kernel[5] = kernel[2];
00374 kernel[2] = kernel[1];
00375 kernel[1] = tmpVal;
00376 }
00377 else if (kernel.getDim() == 3)
00378 {
00379 tmpVal = kernel[0];
00380 kernel[0] = kernel[10];
00381 kernel[10] = kernel[20];
00382 kernel[20] = kernel[22];
00383 kernel[22] = kernel[24];
00384 kernel[24] = kernel[14];
00385 kernel[14] = kernel[4];
00386 kernel[4] = kernel[2];
00387 kernel[2] = tmpVal;
00388
00389 tmpVal = kernel[5];
00390 kernel[5] = kernel[15];
00391 kernel[15] = kernel[21];
00392 kernel[21] = kernel[23];
00393 kernel[23] = kernel[19];
00394 kernel[19] = kernel[9];
00395 kernel[9] = kernel[3];
00396 kernel[3] = kernel[1];
00397 kernel[1] = tmpVal;
00398
00399 tmpVal = kernel[6];
00400 kernel[6] = kernel[11];
00401 kernel[11] = kernel[16];
00402 kernel[16] = kernel[17];
00403 kernel[17] = kernel[18];
00404 kernel[18] = kernel[13];
00405 kernel[13] = kernel[8];
00406 kernel[8] = kernel[7];
00407 kernel[7] = tmpVal;
00408 }
00409 else if (kernel.getDim() == 3)
00410 {
00411 tmpVal = kernel[2];
00412 kernel[2] = kernel[7];
00413 kernel[7] = kernel[28];
00414 kernel[28] = kernel[43];
00415 kernel[43] = kernel[46];
00416 kernel[46] = kernel[41];
00417 kernel[41] = kernel[20];
00418 kernel[20] = kernel[5];
00419 kernel[5] = tmpVal;
00420
00421 tmpVal = kernel[1];
00422 kernel[1] = kernel[14];
00423 kernel[14] = kernel[35];
00424 kernel[35] = kernel[44];
00425 kernel[44] = kernel[47];
00426 kernel[47] = kernel[34];
00427 kernel[34] = kernel[13];
00428 kernel[13] = kernel[4];
00429 kernel[4] = tmpVal;
00430
00431 tmpVal = kernel[0];
00432 kernel[0] = kernel[21];
00433 kernel[21] = kernel[42];
00434 kernel[42] = kernel[45];
00435 kernel[45] = kernel[48];
00436 kernel[48] = kernel[27];
00437 kernel[27] = kernel[6];
00438 kernel[6] = kernel[3];
00439 kernel[3] = tmpVal;
00440
00441 tmpVal = kernel[9];
00442 kernel[9] = kernel[15];
00443 kernel[15] = kernel[29];
00444 kernel[29] = kernel[37];
00445 kernel[37] = kernel[39];
00446 kernel[39] = kernel[33];
00447 kernel[33] = kernel[19];
00448 kernel[19] = kernel[11];
00449 kernel[11] = tmpVal;
00450
00451 tmpVal = kernel[8];
00452 kernel[8] = kernel[22];
00453 kernel[22] = kernel[36];
00454 kernel[36] = kernel[38];
00455 kernel[38] = kernel[40];
00456 kernel[40] = kernel[26];
00457 kernel[26] = kernel[12];
00458 kernel[12] = kernel[10];
00459 kernel[10] = tmpVal;
00460
00461 tmpVal = kernel[16];
00462 kernel[16] = kernel[23];
00463 kernel[23] = kernel[30];
00464 kernel[30] = kernel[31];
00465 kernel[31] = kernel[32];
00466 kernel[32] = kernel[25];
00467 kernel[25] = kernel[18];
00468 kernel[18] = kernel[17];
00469 kernel[17] = tmpVal;
00470 }
00471 else
00472 return VETRET_NOT_IMPLEMENTED;
00473 return VETRET_OK;
00474 }
00475
00476
00477
00481
00482
00483
00484
00485
00486
00487
00488 vetDigitalFilterParameters::vetDigitalFilterParameters()
00489 {
00490 currentKernel = NULL;
00491 reset();
00492 }
00493
00494 void vetDigitalFilterParameters::reset()
00495 {
00496 currentBuffer = vetFilterParameters::NONE;
00497 clampNegative = true;
00498
00499 }
00500
00501 void vetDigitalFilterParameters::setCurrentKernel(vetDFMatrix* data)
00502 {
00503 currentKernel = data;
00504 }
00505
00506 void vetDigitalFilterParameters::setClampNegative(bool value)
00507 {
00508 clampNegative = value;
00509 }
00510
00511
00512 int vetDigitalFilterParameters::saveToStreamXML(FILE *fp)
00513 {
00514 int ret = VETRET_OK;
00515
00516 if ( fp == NULL )
00517 return VETRET_PARAM_ERR;
00518
00519 if( fprintf(fp, "<vetDigitalFilterParameters>\n") == EOF )
00520 return VETRET_INTERNAL_ERR;
00521
00522 if ( fprintf(fp, " <internalBufferType value=\"%u\" />\n", (int)currentBuffer) == EOF)
00523 return VETRET_INTERNAL_ERR;
00524
00525
00526 if (currentKernel != NULL)
00527 {
00528 if( fprintf(fp, " <KernelData>\n") == EOF )
00529 return VETRET_INTERNAL_ERR;
00530
00531 ret = currentKernel->saveToStream(fp);
00532
00533 if( fprintf(fp, " </KernelData>\n") == EOF )
00534 return VETRET_INTERNAL_ERR;
00535 }
00536
00537 if( fprintf(fp, "</vetDigitalFilterParameters>\n") == EOF )
00538 return VETRET_INTERNAL_ERR;
00539
00540 return ret;
00541 }
00542
00543
00544 int vetDigitalFilterParameters::loadFromStreamXML(FILE *fp)
00545 {
00546 if ( fscanf(fp, "<vetDigitalFilterParameters>\n") == EOF )
00547 throw "error in XML file, unable to import data.";
00548
00549 int cB = (int)currentBuffer;
00550 if ( fscanf(fp, " <internalBufferType value=\"%u\" />\n", &cB) == EOF )
00551 throw "error in XML file, unable to import data.";
00552 currentBuffer = (BUFFER_TYPE)cB;
00553
00554 int ret = VETRET_OK;
00555
00556 if ( fscanf(fp, " <KernelData>\n") != EOF )
00557 {
00558 if (currentKernel == NULL)
00559 currentKernel = new vetDFMatrix();
00560
00561 ret = currentKernel->loadFromStream(fp);
00562 }
00563
00564
00565
00566 return ret;
00567 }
00568
00569
00570
00571
