bool IPLMorphologicalEdge::processInputData(IPLImage* image , int, bool) { // delete previous result delete _result; _result = NULL; int width = image->width(); int height = image->height(); _result = new IPLImage( image->type(), width, height ); // get properties int window = getProcessPropertyInt("window"); int progress = 0; int maxProgress = image->height() * image->getNumberOfPlanes() * 2; int nrOfPlanes = image->getNumberOfPlanes(); int w2 = window/2; int area = window*window; #pragma omp parallel for for( int planeNr=0; planeNr < nrOfPlanes; planeNr++ ) { IPLImagePlane* plane = image->plane( planeNr ); IPLImagePlane* newplane = _result->plane( planeNr ); IPLImagePlane* average = new IPLImagePlane(width, height); for(int x=w2; x<width-w2; x++) { // progress notifyProgressEventHandler(100*progress++/maxProgress); for(int y=w2; y<height-w2; y++) { ipl_basetype sum = 0; for( int kx=-w2; kx<=w2; kx++ ) { for( int ky=-w2; ky<=w2; ky++ ) { if( kx || ky ) sum += plane->p(x+kx, y+ky); } } average->p(x,y) = sum; } } for(int x=w2; x<width-w2; x++) { // progress notifyProgressEventHandler(100*progress++/maxProgress); for(int y=w2; y<height-w2; y++) { float minc = (area-1); float maxc = 0; for( int kx=-w2; kx<=w2; kx++ ) { for( int ky=-w2; ky<=w2; ky++ ) { ipl_basetype img = average->bp(x+kx, y+ky); if( img > maxc) maxc = img; if( img < minc) minc = img; } } ipl_basetype img = average->p(x,y); ipl_basetype d1 = img - minc; ipl_basetype d2 = maxc - img; ipl_basetype min = (d1 < d2)? d1 : d2; min = (min<1.0)? min : 1.0; min = (min>0.0)? min : 0.0; newplane->p(x,y) = min; } } delete average; } return true; }
bool IPLConvolutionFilter::processInputData(IPLImage* image , int, bool useOpenCV) { // delete previous result delete _result; _result = NULL; int width = image->width(); int height = image->height(); // get properties _kernel = getProcessPropertyVectorInt("kernel"); _divisor = getProcessPropertyInt("divisor"); _offset = getProcessPropertyDouble("offset"); _normalize = getProcessPropertyBool("normalize"); _borders = getProcessPropertyInt("borders"); if(_normalize) { int sum = 0; for(size_t i=0; i<_kernel.size(); i++) { sum += _kernel[i]; } _divisor = (sum != 0 ? sum : 1); } if (_divisor == 0) { addError("Invalid divisor: 0"); return false; } float divFactor = 1.0f/_divisor; int kernelWidth = (int)sqrt((float)_kernel.size()); int kernelOffset = kernelWidth / 2; int progress = 0; int maxProgress = image->height() * image->getNumberOfPlanes(); if (!useOpenCV) { _result = new IPLImage( image->type(), width, height ); #pragma omp parallel for default(shared) for( int planeNr=0; planeNr < image->getNumberOfPlanes(); planeNr++ ) { IPLImagePlane* plane = image->plane( planeNr ); IPLImagePlane* newplane = _result->plane( planeNr ); for(int y=0; y<plane->height(); y++) { // progress notifyProgressEventHandler(100*progress++/maxProgress); for(int x=0; x<plane->width(); x++) { float sum = 0; int i = 0; for( int ky=-kernelOffset; ky<=kernelOffset; ky++ ) { for( int kx=-kernelOffset; kx<=kernelOffset; kx++ ) { int h = _kernel[i++]; if( h ) { if(_borders == 0) { // Crop borders sum += plane->cp(x+kx, y+ky) * h; } else if(_borders == 1) { // Extend borders sum += plane->bp(x+kx, y+ky) * h; } else { // Wrap borders sum += plane->wp(x+kx, y+ky) * h; } } } } sum = sum * divFactor + _offset; sum = (sum>1.0) ? 1.0 : (sum<0) ? 0.0 : sum; // clamp to 0.0 - 1.0 newplane->p(x,y) = sum; } } } } else { notifyProgressEventHandler(-1); cv::Mat src = image->toCvMat(); cv::Mat dst; cv::Mat kernel(kernelWidth, kernelWidth, CV_32FC1 ); int i = 0; for( int y=0; y < kernelWidth; y++ ) for( int x=0; x < kernelWidth; x++ ) kernel.at<float>(cv::Point(x,y)) = _kernel[i++]; kernel *= divFactor; static const int BORDER_TYPES[3] = { cv::BORDER_CONSTANT, cv::BORDER_REPLICATE, cv::BORDER_WRAP }; cv::filter2D(src, dst, -1, kernel, cv::Point(-1,-1), _offset, BORDER_TYPES[_borders]); _result = new IPLImage(dst); } return true; }
bool IPLMedian::processInputData(IPLImage* image , int, bool useOpenCV) { // delete previous result delete _result; _result = NULL; int width = image->width(); int height = image->height(); // get properties int window = getProcessPropertyInt("window"); int progress = 0; int maxProgress = image->height() * image->getNumberOfPlanes(); int nrOfPlanes = image->getNumberOfPlanes(); int w2 = window/2; int area = window*window; if (!useOpenCV) { _result = new IPLImage( image->type(), width, height ); #pragma omp parallel for for( int planeNr=0; planeNr < nrOfPlanes; planeNr++ ) { IPLImagePlane* plane = image->plane( planeNr ); IPLImagePlane* newplane = _result->plane( planeNr ); ipl_basetype* list = new ipl_basetype[area]; for(int y=0; y<height; y++) { // progress notifyProgressEventHandler(100*progress++/maxProgress); for(int x=0; x<width; x++) { int i =0; for( int ky=-w2; ky<=w2; ky++ ) { for( int kx=-w2; kx<=w2; kx++ ) { list[i++] = plane->bp(x+kx, y+ky); } } // insert sort list for( int k=area; k>=0; k--) { int j = k+1; ipl_basetype temp = list[k]; while( j < area && temp > list[j] ) { list[j-1] = list[j]; j++; } list[j-1] = temp; } newplane->p(x,y) = list[area/2]; } } } } else { notifyProgressEventHandler(-1); auto src = image->toCvMat(); cv::Mat dst; cv::medianBlur(src,dst,window); _result = new IPLImage(dst); } return true; }
bool IPLCanny::processInputData(IPLImage* image , int, bool useOpenCV) { // delete previous result delete _result; _result = NULL; delete _binaryImage; _binaryImage = NULL; int width = image->width(); int height = image->height(); _result = new IPLImage( image->type(), width, height ); _binaryImage = new IPLImage( IPLData::IMAGE_BW, width, height ); // get properties int window = getProcessPropertyInt("window"); double sigma = getProcessPropertyDouble("sigma"); double lowThreshold = getProcessPropertyDouble("lowThreshold"); double highThreshold = getProcessPropertyDouble("highThreshold"); std::stringstream s; s << "Window: "; s << window; addInformation(s.str()); //! @todo currently only the opencv implementation works if(useOpenCV || true) { notifyProgressEventHandler(-1); cv::Mat input; cv::Mat output; cvtColor(image->toCvMat(), input, CV_BGR2GRAY); cv::Canny(input, output, lowThreshold*255, highThreshold*255, window); delete _result; _result = new IPLImage(output); return true; } return false; // Create a Gaussian 1D filter int N = ceil( sigma * sqrt( 2.0*log( 1.0/0.015 ) ) + 1.0 ); double ssq = sigma*sigma; double* gau = new double [window]; double* dgau = new double [window]; for( int k = -N; k <= N; ++k ) { gau[k+N] = gauss ( (double)k, ssq ); dgau[k+N] = dGauss ( (double)k, 0, ssq ); } // Create a directional derivative of 2D Gaussian (along X-axis) // Since the result is symmetric along X, we can get the derivative along // Y-axis simply by transposing the result for X direction. // DoubleImage* dgau = new DoubleImage( window, window ); // for( int y = -N; y <= N; ++y ) // for( int x = -N; x <= N; ++x ) // dgau->f(x+N, y+N) = dGauss( x, y, ssq ); int progress = 0; int maxProgress = width * image->getNumberOfPlanes(); int nrOfPlanes = image->getNumberOfPlanes(); //#pragma omp parallel for for( int planeNr=0; planeNr < nrOfPlanes; planeNr++ ) { IPLImagePlane* plane = image->plane( planeNr ); IPLImagePlane* newplane = _result->plane( planeNr ); // ******** Gaussian filtering of input image IPLImagePlane* gI = new IPLImagePlane( width, height ); // horizontal run (normalizing original image) IPLImagePlane* tmpI = new IPLImagePlane( width, height ); for(int x=0; x<width; x++) { // progress notifyProgressEventHandler(100*progress++/maxProgress); for(int y=0; y<height; y++) { double sum = 0; int i = 0; for( int kx=-N; kx<=N; kx++ ) { double img = (double) plane->bp(x+kx, y); sum += (img * gau[i++]); } tmpI->p(x,y) = (double) (sum); } } // vertiacl run for(int x=0; x<width; x++) { for(int y=0; y<height; y++) { double sum = 0; int i = 0; for( int ky=-N; ky<=N; ky++ ) { double img = tmpI->bp(x, y+ky); sum += (img * gau[i++]); } gI->p(x,y) = sum; } } //delete tmpI; // ******** Apply directional derivatives ... // ... in x-direction IPLImagePlane* dx = new IPLImagePlane( width, height ); for(int x=0; x<width; x++) { for(int y=0; y<height; y++) { dx->p(x,y) = 0.0; for( int k=1; k<N; k++ ) { dx->p(x,y) += ( gI->bp(x-k,y) - gI->bp(x+k,y) ) * dgau[k]; } } } // double maxVal = 0.0; // for(int x=0; x<width; x++) // for(int y=0; y<height; y++) // if( dx->f(x,y) > maxVal ) maxVal = dx->f(x,y); // ... in y-direction IPLImagePlane* dy = new IPLImagePlane( width, height ); for(int x=0; x<width; x++) { for(int y=0; y<height; y++) { dy->p(x,y) = 0.0; for( int k=1; k<N; k++ ) { dy->p(x,y) += ( gI->bp(x,y-k) - gI->bp(x,y+k) ) * dgau[k]; } } } // ******** Compute magnitude and binarization thresholds IPLImagePlane* mag = new IPLImagePlane( width, height ); double magMax = 0.0; double magMin = 999999999.0; for(int x=0; x<width; x++) { for(int y=0; y<height; y++) { double val = sqrt( dx->p(x,y)*dx->p(x,y) + dy->p(x,y)*dy->p(x,y) ); mag->p(x,y) = val; if( val > magMax ) magMax = val; if( val < magMin ) magMin = val; } } //// ******** Non-maxima suppression - edge pixels should be a local maximum _orientedImage = new IPLOrientedImage( width, height ); for(int x=0; x<width; x++) { for(int y=0; y<height; y++) { double ix = dx->p(x,y); double iy = dy->p(x,y); double g = mag->p(x,y); // determine 4-neighbor direction of gradient int dir4 = 0; if( (iy<=0.0 && ix>-iy) || (iy>=0.0 && ix<-iy) ) dir4 = 1; else if( (ix>0.0 && -iy>=ix) || (ix<0.0 && -iy<=ix) ) dir4 = 2; else if( (ix<=0.0 && ix>iy) || (ix>=0.0 && ix<iy) ) dir4 = 3; else if( (iy<0.0 && ix<=iy) || (iy>0.0 && ix>=iy) ) dir4 = 4; else continue; double gradmag1, gradmag2, d; switch(dir4) { case 1: d = std::fabs(iy/ix); gradmag1 = mag->bp(x+1,y)*(1-d) + mag->bp(x+1,y-1)*d; gradmag2 = mag->bp(x-1,y)*(1-d) + mag->bp(x-1,y+1)*d; break; case 2: d = std::fabs(ix/iy); gradmag1 = mag->bp(x,y-1)*(1-d) + mag->bp(x+1,y-1)*d; gradmag2 = mag->bp(x,y+1)*(1-d) + mag->bp(x-1,y+1)*d; break; case 3: d = std::fabs(ix/iy); gradmag1 = mag->bp(x,y-1)*(1-d) + mag->bp(x-1,y-1)*d; gradmag2 = mag->bp(x,y+1)*(1-d) + mag->bp(x+1,y+1)*d; break; case 4: d = std::fabs(iy/ix); gradmag1 = mag->bp(x-1,y)*(1-d) + mag->bp(x-1,y-1)*d; gradmag2 = mag->bp(x+1,y)*(1-d) + mag->bp(x+1,y+1)*d; break; } if( g > gradmag1 && g > gradmag2 ) { _orientedImage->magnitude(x,y) = g; _orientedImage->phase(x,y) = atan2(iy,ix); } } } for(int x=0; x<width; x++) { for(int y=0; y<height; y++) { _orientedImage->magnitude(x,y) /= magMax; double val = _orientedImage->magnitude(x,y)*255.0; // double val = mag->f(x,y)/magMax*255.0; if (val > 255.0 ) val = 255.0; if (val < 0.0 ) val = 0.0; newplane->p(x,y) = (unsigned char ) val; } } // ******** Binarize with hysteresis threshold double hist[ 256 ]; for( int i=0; i<256; ++i ) hist[i] = 0; int pixCount = 0; for(int x=0; x<width; x++) { for(int y=0; y<height; y++) { if( _orientedImage->magnitude(x,y) > 0.0 ) { int index = floor( _orientedImage->magnitude(x,y)*256.0+0.5 ); ++hist[ index ]; ++pixCount; } } } double PercentOfPixelsNotEdges = 0.7*pixCount; double highThresh = 0.0; double cumsum = 0.0; for( int i=0; i<256; ++i ) { cumsum += hist[i]; if( cumsum > PercentOfPixelsNotEdges ) { highThresh = (double)i / 256.0; break; } } double lowThresh = 0.4 * highThresh; IPLImagePlane* binPlane = _binaryImage->plane( 0 ); for(int x=0; x<width; x++) { for(int y=0; y<height; y++) { if(_orientedImage->magnitude(x,y) >= highThresh) trace(x, y, lowThresh, _orientedImage, binPlane); } } //delete dx; //delete dy; //delete gI; thinning(_orientedImage, binPlane, newplane ); } //delete [] gau; //delete [] dgau; return true; }