Subversion Repositories OpenCV2-Cookbook

/*------------------------------------------------------------------------------------------*\

   This file contains material supporting chapter 6 of the cookbook:  

   Computer Vision Programming using the OpenCV Library.

   by Robert Laganiere, Packt Publishing, 2011.

   This program is free software; permission is hereby granted to use, copy, modify,

   and distribute this source code, or portions thereof, for any purpose, without fee,

   subject to the restriction that the copyright notice may not be removed

   or altered from any source or altered source distribution.

   The software is released on an as-is basis and without any warranties of any kind.

   In particular, the software is not guaranteed to be fault-tolerant or free from failure.

   The author disclaims all warranties with regard to this software, any use,

   and any consequent failure, is purely the responsibility of the user.

   Copyright (C) 2010-2011 Robert Laganiere, www.laganiere.name

\*------------------------------------------------------------------------------------------*/

#if !defined LAPLACEZC

#define LAPLACEZC

#include <opencv2/core/core.hpp>

#include <opencv2/imgproc/imgproc.hpp>

class LaplacianZC {

  private:

          // original image

          cv::Mat img;

          // 32-bit float image containing the Laplacian

          cv::Mat laplace;

          // Aperture size of the laplacian kernel

          int aperture;

  public:

          LaplacianZC() : aperture(3) {}

          // Set the aperture size of the kernel

          void setAperture(int a) {

                  aperture= a;

          }

          // Get the aperture size of the kernel

          int getAperture() const {

                  return aperture;

          }

          // Compute the floating point Laplacian

          cv::Mat computeLaplacian(const cv::Mat& image) {

                  // Compute Laplacian

                  cv::Laplacian(image,laplace,CV_32F,aperture);

                  // Keep local copy of the image

                  // (used for zero-crossings)

                  img= image.clone();

                  return laplace;

          }

          // Get the Laplacian result in 8-bit image 

          // zero corresponds to gray level 128

          // if no scale is provided, then the max value will be

          // scaled to intensity 255

          // You must call computeLaplacian before calling this method

          cv::Mat getLaplacianImage(double scale=-1.0) {

                  if (scale<0) {

                          double lapmin, lapmax;

                          cv::minMaxLoc(laplace,&lapmin,&lapmax);

                          scale= 127/ std::max(-lapmin,lapmax);

                  }

                  cv::Mat laplaceImage;

                  laplace.convertTo(laplaceImage,CV_8U,scale,128);

                  return laplaceImage;

          }

          // Get a binary image of the zero-crossings

          // if the product of the two adjascent pixels is

          // less than threshold then this zero-crossing will be ignored

          cv::Mat getZeroCrossings(float threshold=1.0) {

                  // Create the iterators

                  cv::Mat_<float>::const_iterator it= laplace.begin<float>()+laplace.step1();

                  cv::Mat_<float>::const_iterator itend= laplace.end<float>();

                  cv::Mat_<float>::const_iterator itup= laplace.begin<float>();

                  // Binary image initialize to white

                  cv::Mat binary(laplace.size(),CV_8U,cv::Scalar(255));

                  cv::Mat_<uchar>::iterator itout= binary.begin<uchar>()+binary.step1();

                  // negate the input threshold value

                  threshold *= -1.0;

                  for ( ; it!= itend; ++it, ++itup, ++itout) {

                          // if the product of two adjascent pixel is negative

                          // then there is a sign change

                          if (*it * *(it-1) < threshold)

                                  *itout= 0; // horizontal zero-crossing

                          else if (*it * *itup < threshold)

                                  *itout= 0; // vertical zero-crossing

                  }

                  return binary;

          }

          // Get a binary image of the zero-crossings

          // if the product of the two adjacent pixels is

          // less than threshold then this zero-crossing will be ignored

          cv::Mat getZeroCrossingsWithSobel(float threshold) {

                  cv::Mat sx;

                  cv::Sobel(img,sx,CV_32F,1,0,1);

                  cv::Mat sy;

                  cv::Sobel(img,sy,CV_32F,0,1,1);

                  // Create the iterators

                  cv::Mat_<float>::const_iterator it= laplace.begin<float>()+laplace.step1();

                  cv::Mat_<float>::const_iterator itend= laplace.end<float>();

                  cv::Mat_<float>::const_iterator itup= laplace.begin<float>();

                  cv::Mat_<float>::const_iterator itx= sx.begin<float>()+sx.step1();

                  cv::Mat_<float>::const_iterator ity= sy.begin<float>()+sy.step1();

                  // Binary image initialize to white

                  cv::Mat binary(laplace.size(),CV_8U,cv::Scalar(255));

                  cv::Mat_<uchar>::iterator itout= binary.begin<uchar>()+binary.step1();

                  for ( ; it!= itend; ++it, ++itup, ++itout, ++itx, ++ity) {

                          // if the product of two adjacent pixel is negative

                          // then there is a sign change

                          if (*it * *(it-1) < 0.0 && fabs(*ity) > threshold)

                                  *itout= 0; // horizontal zero-crossing

                          else if (*it * *itup < 0.0 && fabs(*ity) > threshold)

                                  *itout= 0; // vertical zero-crossing

                  }

                  return binary;

          }

};

#endif