#include <EdgeDetection.h>

Inheritance diagram for degate::EdgeDetection:

Public Member Functions
void	setup_pipe ()
unsigned int	get_width () const
unsigned int	get_height () const
void	set_directory (std::string const &path)
std::string	get_directory () const
bool	has_directory () const
void	run_edge_detection (ImageBase_shptr in)
TileImage_GS_DOUBLE_shptr	get_horizontal_edges ()
TileImage_GS_DOUBLE_shptr	get_vertical_edges ()
TileImage_GS_DOUBLE_shptr	get_edge_magnitude_image (TileImage_GS_DOUBLE_shptr probability_map)
TileImage_GS_DOUBLE_shptr	get_edge_image (TileImage_GS_DOUBLE_shptr probability_map)
	EdgeDetection (unsigned int _min_x, unsigned int _max_x, unsigned int _min_y, unsigned int _max_y, unsigned int median_filter_width=3, unsigned int _blur_kernel_size=10, double _sigma=0.5)
virtual	~EdgeDetection ()
unsigned int	get_border () const
Private Attributes
IPPipe	pipe
unsigned int	min_x
unsigned int	max_x
unsigned int	min_y
unsigned int	max_y
unsigned int	median_filter_width
unsigned int	blur_kernel_size
unsigned int	border
double	sigma
TileImage_GS_DOUBLE_shptr	i1
TileImage_GS_DOUBLE_shptr	i2
std::string	directory
bool	has_path

Detailed Description

Definition at line 38 of file EdgeDetection.h.

Constructor & Destructor Documentation

EdgeDetection::EdgeDetection	(	unsigned int	_min_x,
		unsigned int	_max_x,
		unsigned int	_min_y,
		unsigned int	_max_y,
		unsigned int	median_filter_width = `3`,
		unsigned int	_blur_kernel_size = `10`,
		double	_sigma = `0.5`
	)

Definition at line 27 of file EdgeDetection.cc.

References setup_pipe().

                                            :
  min_x(_min_x),
  max_x(_max_x),
  min_y(_min_y),
  max_y(_max_y),
  median_filter_width(_median_filter_width),
  blur_kernel_size(_blur_kernel_size),
  border(_blur_kernel_size >> 1),
  sigma(_sigma),
  has_path(false) {

  setup_pipe();
}

Here is the call graph for this function:

EdgeDetection::~EdgeDetection ( ) [virtual]

Definition at line 46 of file EdgeDetection.cc.

{
}

Member Function Documentation

unsigned int EdgeDetection::get_border ( ) const

Definition at line 49 of file EdgeDetection.cc.

References border.

Referenced by degate::ZeroCrossingEdgeDetection::analyze_edge_image(), degate::CannyEdgeDetection::hysteresis(), degate::CannyEdgeDetection::non_maximum_supression(), and degate::WireMatching::run().

                                             {
  return border;
}

Here is the caller graph for this function:

std::string EdgeDetection::get_directory ( ) const

Definition at line 102 of file EdgeDetection.cc.

References directory.

Referenced by degate::CannyEdgeDetection::non_maximum_supression().

                                             {
  return directory;
}

Here is the caller graph for this function:

TileImage_GS_DOUBLE_shptr EdgeDetection::get_edge_image ( TileImage_GS_DOUBLE_shptr probability_map )

Definition at line 168 of file EdgeDetection.cc.

References border, directory, get_height(), get_width(), has_path, i1, i2, and degate::join_pathes().

Referenced by degate::ZeroCrossingEdgeDetection::run(), and degate::CannyEdgeDetection::run().

                                                                                                 {

  if(i1 == NULL || i2 == NULL) return TileImage_GS_DOUBLE_shptr();

  TileImage_GS_DOUBLE_shptr edge_image(new TileImage_GS_DOUBLE(get_width(), get_height()));

  for(unsigned int y = border +2; y < get_height() - border -1; y++) {
    for(unsigned int x = border+2; x < get_width() - border -1; x++) {
      double gx = i1->get_pixel(x, y);
      double gy = i2->get_pixel(x, y);

      if(probability_map != NULL) {
        if(probability_map->get_pixel(x, y) > 0)
          edge_image->set_pixel(x, y, gx + gy);
      }
      else
        edge_image->set_pixel(x, y, gx + gy);
    }
  }
  if(has_path) save_normalized_image<TileImage_GS_DOUBLE>(join_pathes(directory,
                                                                      "03_edge_image.tif"),
                                                          edge_image);

  return edge_image;
}

Here is the call graph for this function:

Here is the caller graph for this function:

TileImage_GS_DOUBLE_shptr EdgeDetection::get_edge_magnitude_image ( TileImage_GS_DOUBLE_shptr probability_map )

Definition at line 140 of file EdgeDetection.cc.

References border, directory, get_height(), get_width(), has_path, i1, i2, and degate::join_pathes().

Referenced by degate::CannyEdgeDetection::run().

                                                                                                           {

  if(i1 == NULL || i2 == NULL) return TileImage_GS_DOUBLE_shptr();

  TileImage_GS_DOUBLE_shptr edge_mag_image(new TileImage_GS_DOUBLE(get_width(), get_height()));

  for(unsigned int y = border +2; y < get_height() - border -1; y++) {
    for(unsigned int x = border+2; x < get_width() - border -1; x++) {
      double gx = i1->get_pixel(x, y);
      double gy = i2->get_pixel(x, y);
      double g = sqrt(pow(gx,2) + pow(gy, 2));
      if(probability_map != NULL) {
        if(probability_map->get_pixel(x, y) > 0)
          edge_mag_image->set_pixel(x, y, g);
      }
      else
        edge_mag_image->set_pixel(x, y, g);
    }
  }

  if(has_path) save_normalized_image<TileImage_GS_DOUBLE>(join_pathes(directory,
                                                                      "03_edge_mag_image.tif"),
                                                          edge_mag_image);
  return edge_mag_image;
}

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned int EdgeDetection::get_height ( ) const

Definition at line 93 of file EdgeDetection.cc.

References max_y, and min_y.

Referenced by degate::ZeroCrossingEdgeDetection::analyze_edge_image(), get_edge_image(), get_edge_magnitude_image(), degate::ZeroCrossingEdgeDetection::overlay_result(), degate::ZeroCrossingEdgeDetection::run(), and degate::CannyEdgeDetection::run().

                                             {
  return max_y - min_y;
}

Here is the caller graph for this function:

TileImage_GS_DOUBLE_shptr EdgeDetection::get_horizontal_edges ( )

Definition at line 131 of file EdgeDetection.cc.

References i1.

Referenced by degate::CannyEdgeDetection::run().

                                                              {
  return i1;
}

Here is the caller graph for this function:

TileImage_GS_DOUBLE_shptr EdgeDetection::get_vertical_edges ( )

Definition at line 135 of file EdgeDetection.cc.

References i2.

Referenced by degate::CannyEdgeDetection::run().

                                                            {
  return i2;
}

Here is the caller graph for this function:

unsigned int EdgeDetection::get_width ( ) const

Definition at line 89 of file EdgeDetection.cc.

References max_x, and min_x.

Referenced by degate::ZeroCrossingEdgeDetection::analyze_edge_image(), get_edge_image(), get_edge_magnitude_image(), degate::ZeroCrossingEdgeDetection::overlay_result(), degate::ZeroCrossingEdgeDetection::run(), and degate::CannyEdgeDetection::run().

                                            {
  return max_x - min_x;
}

Here is the caller graph for this function:

bool EdgeDetection::has_directory ( ) const

Definition at line 106 of file EdgeDetection.cc.

References has_path.

Referenced by degate::CannyEdgeDetection::non_maximum_supression().

                                        {
  return has_path;
}

Here is the caller graph for this function:

void EdgeDetection::run_edge_detection ( ImageBase_shptr in )

Definition at line 110 of file EdgeDetection.cc.

References directory, has_path, i1, i2, degate::join_pathes(), pipe, and degate::IPPipe::run().

Referenced by degate::ZeroCrossingEdgeDetection::run(), and degate::CannyEdgeDetection::run().

                                                         {

  ImageBase_shptr out = pipe.run(in);
  assert(out != NULL);

  std::tr1::shared_ptr<SobelYOperator> SobelY(new SobelYOperator());
  std::tr1::shared_ptr<IPConvolve<TileImage_GS_DOUBLE, TileImage_GS_DOUBLE> > edge_filter_x
    (new IPConvolve<TileImage_GS_DOUBLE, TileImage_GS_DOUBLE>(SobelY) );

  std::tr1::shared_ptr<SobelXOperator> SobelX(new SobelXOperator());
  std::tr1::shared_ptr<IPConvolve<TileImage_GS_DOUBLE, TileImage_GS_DOUBLE> > edge_filter_y
    (new IPConvolve<TileImage_GS_DOUBLE, TileImage_GS_DOUBLE>(SobelX) );

  i1 = std::tr1::dynamic_pointer_cast<TileImage_GS_DOUBLE>(edge_filter_x->run(out));
  i2 = std::tr1::dynamic_pointer_cast<TileImage_GS_DOUBLE>(edge_filter_y->run(out));
  assert(i1 != NULL && i2 != NULL);

  if(has_path) save_normalized_image<TileImage_GS_DOUBLE>(join_pathes(directory, "01_sobelx.tif"), i1);
  if(has_path) save_normalized_image<TileImage_GS_DOUBLE>(join_pathes(directory, "02_sobely.tif"), i2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void EdgeDetection::set_directory ( std::string const & path )

Definition at line 97 of file EdgeDetection.cc.

References directory, and has_path.

Referenced by degate::ZeroCrossingEdgeDetection::run(), and degate::CannyEdgeDetection::run().

                                                       {
  directory = path;
  has_path = true;
}

Here is the caller graph for this function:

void EdgeDetection::setup_pipe ( )

Definition at line 54 of file EdgeDetection.cc.

References degate::IPPipe::add(), blur_kernel_size, debug(), max_x, max_y, degate::median_filter(), median_filter_width, min_x, min_y, pipe, sigma, and TM.

Referenced by EdgeDetection().

                               {

  debug(TM, "will extract background image (%d, %d) (%d, %d)", min_x, min_y, max_x, max_y);
  std::tr1::shared_ptr<IPCopy<TileImage_RGBA, TileImage_GS_DOUBLE> > copy_rgba_to_gs
    (new IPCopy<TileImage_RGBA, TileImage_GS_DOUBLE>(min_x, max_x, min_y, max_y) );

  pipe.add(copy_rgba_to_gs);

  if(median_filter_width > 0) {
    std::tr1::shared_ptr<IPMedianFilter<TileImage_GS_DOUBLE, TileImage_GS_DOUBLE> > median_filter
      (new IPMedianFilter<TileImage_GS_DOUBLE, TileImage_GS_DOUBLE>(median_filter_width));

    pipe.add(median_filter);
  }


  std::tr1::shared_ptr<IPNormalize<TileImage_GS_DOUBLE, TileImage_GS_DOUBLE> > normalizer
    (new IPNormalize<TileImage_GS_DOUBLE, TileImage_GS_DOUBLE>(0, 1) );
  pipe.add(normalizer);


  if(blur_kernel_size > 0) {
    std::tr1::shared_ptr<GaussianBlur>
      GaussianB(new GaussianBlur(blur_kernel_size, blur_kernel_size, sigma));

    GaussianB->print();
    std::tr1::shared_ptr<IPConvolve<TileImage_GS_DOUBLE, TileImage_GS_DOUBLE> > gaussian_blur
      (new IPConvolve<TileImage_GS_DOUBLE, TileImage_GS_DOUBLE>(GaussianB) );

    pipe.add(gaussian_blur);
  }

}