CannyEdgeDetector2d

Performs Canny's computational approach to edge detection on a two-dimensional grayscale image.

Access to parameter description

This algorithm extracts the local maxima of a smoothed gradient image by applying the following steps:

Gaussian filtering
Gradient computation
Non maximum suppression in the gradient direction

The output image is a grayscale image representing the detected contours with one pixel thickness.

To complete the Canny edge detector method, a thresholding by hysteresis must be applied on this output image afterward.
A second output provides an estimation of the two threshold values necessary to perform this step.

Reference: J.F.Canny. "A computational approach to edge detection." IEEE Transactions on Pattern Analysis and Machine Intelligence, vol.8, No 6, pp. 679-698, Nov. 1986.

See also

Function Syntax

This function returns a CannyEdgeDetector2dOutput structure containing outputImage and outputMeasurement.

// Output structure of the cannyEdgeDetector2d function.
struct CannyEdgeDetector2dOutput
{
    /// The output grayscale image representing the detected edges.
    std::shared_ptr< iolink::ImageView > outputImage;
    /// The output measurement provides the estimated parameters of the threshold values used by the hysteresis.
    CannyEdgeDetectorMsr::Ptr outputMeasurement;
};

// Function prototype
CannyEdgeDetector2dOutput
cannyEdgeDetector2d( std::shared_ptr< iolink::ImageView > inputImage,
                     iolink::Vector2d standardDeviation,
                     std::shared_ptr< iolink::ImageView > outputImage = NULL,
                     CannyEdgeDetectorMsr::Ptr outputMeasurement = NULL );

This function returns a tuple containing output_image and output_measurement.

// Function prototype.
canny_edge_detector_2d( input_image,
                        standard_deviation = [1, 1],
                        output_image = None,
                        output_measurement = None )

This function returns a CannyEdgeDetector2dOutput structure containing outputImage and outputMeasurement.

/// Output structure of the CannyEdgeDetector2d function.
public struct CannyEdgeDetector2dOutput
{
    /// The output grayscale image representing the detected edges.
    public IOLink.ImageView outputImage;
    /// 
    /// The output measurement provides the estimated parameters of the threshold values used by the hysteresis.
    /// 
    public CannyEdgeDetectorMsr outputMeasurement;
};

// Function prototype.
public static CannyEdgeDetector2dOutput
CannyEdgeDetector2d( IOLink.ImageView inputImage,
                     double[] standardDeviation = null,
                     IOLink.ImageView outputImage = null,
                     CannyEdgeDetectorMsr outputMeasurement = null );

Class Syntax

// Command constructor.
CannyEdgeDetector2d();

/// Gets the inputImage parameter.
/// The input grayscale image.
std::shared_ptr< iolink::ImageView > inputImage() const;
/// Sets the inputImage parameter.
/// The input grayscale image.
void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

/// Gets the standardDeviation parameter.
/// The gaussian filter standard deviation value.
iolink::Vector2d standardDeviation() const;
/// Sets the standardDeviation parameter.
/// The gaussian filter standard deviation value.
void setStandardDeviation( const iolink::Vector2d& standardDeviation );

/// Gets the outputImage parameter.
/// The output grayscale image representing the detected edges.
std::shared_ptr< iolink::ImageView > outputImage() const;
/// Sets the outputImage parameter.
/// The output grayscale image representing the detected edges.
void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

/// Gets the outputMeasurement parameter.
/// The output measurement provides the estimated parameters of the threshold values used by the hysteresis.
CannyEdgeDetectorMsr::Ptr outputMeasurement() const;


// Method to launch the command.
void execute();

# Property of the inputImage parameter.
CannyEdgeDetector2d.input_image
# Property of the standardDeviation parameter.
CannyEdgeDetector2d.standard_deviation
# Property of the outputImage parameter.
CannyEdgeDetector2d.output_image
# Property of the outputMeasurement parameter.
CannyEdgeDetector2d.output_measurement

// Method to launch the command.
execute()

// Command constructor.
CannyEdgeDetector2d()

// Property of the inputImage parameter.
CannyEdgeDetector2d.inputImage
// Property of the standardDeviation parameter.
CannyEdgeDetector2d.standardDeviation
// Property of the outputImage parameter.
CannyEdgeDetector2d.outputImage
// Property of the outputMeasurement parameter.
CannyEdgeDetector2d.outputMeasurement

// Method to launch the command.
Execute()

Parameters

	Description	Type	Supported Values	Default Value
inputImage	The input grayscale image.	Image	Binary, Label, Grayscale or Multispectral	nullptr
standardDeviation	The gaussian filter standard deviation value.	Vector2d	>=0.1	{1.f, 1.f}
outputImage	The output grayscale image representing the detected edges. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.	Image		nullptr
outputMeasurement	The output measurement provides the estimated parameters of the threshold values used by the hysteresis.	CannyEdgeDetectorMsr		nullptr

Description	Type	Supported Values	Default Value
input_image	The input grayscale image.	image	Binary, Label, Grayscale or Multispectral	None
standard_deviation	The gaussian filter standard deviation value.	vector2d	>=0.1	[1, 1]
output_image	The output grayscale image representing the detected edges. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.	image		None
output_measurement	The output measurement provides the estimated parameters of the threshold values used by the hysteresis.	CannyEdgeDetectorMsr		None

Description	Type	Supported Values	Default Value
inputImage	The input grayscale image.	Image	Binary, Label, Grayscale or Multispectral	null
standardDeviation	The gaussian filter standard deviation value.	Vector2d	>=0.1	{1f, 1f}
outputImage	The output grayscale image representing the detected edges. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.	Image		null
outputMeasurement	The output measurement provides the estimated parameters of the threshold values used by the hysteresis.	CannyEdgeDetectorMsr		null

Object Examples

std::shared_ptr< iolink::ImageView > polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );

CannyEdgeDetector2d cannyEdgeDetector2dAlgo;
cannyEdgeDetector2dAlgo.setInputImage( polystyrene );
cannyEdgeDetector2dAlgo.setStandardDeviation( {1, 1} );
cannyEdgeDetector2dAlgo.execute();

std::cout << "outputImage:" << cannyEdgeDetector2dAlgo.outputImage()->toString();
std::cout << "thresholdHigh: " << cannyEdgeDetector2dAlgo.outputMeasurement()->thresholdHigh( 0 ) ;

polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))

canny_edge_detector_2d_algo = imagedev.CannyEdgeDetector2d()
canny_edge_detector_2d_algo.input_image = polystyrene
canny_edge_detector_2d_algo.standard_deviation = [1, 1]
canny_edge_detector_2d_algo.execute()

print( "output_image:", str( canny_edge_detector_2d_algo.output_image ) )
print( "thresholdHigh: ", str( canny_edge_detector_2d_algo.output_measurement.threshold_high( 0 ) ) )

ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );

CannyEdgeDetector2d cannyEdgeDetector2dAlgo = new CannyEdgeDetector2d
{
    inputImage = polystyrene,
    standardDeviation = new double[]{1, 1}
};
cannyEdgeDetector2dAlgo.Execute();

Console.WriteLine( "outputImage:" + cannyEdgeDetector2dAlgo.outputImage.ToString() );
Console.WriteLine( "thresholdHigh: " + cannyEdgeDetector2dAlgo.outputMeasurement.thresholdHigh( 0 ) );

Function Examples

std::shared_ptr< iolink::ImageView > polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );

auto result = cannyEdgeDetector2d( polystyrene, {1, 1} );

std::cout << "outputImage:" << result.outputImage->toString();
std::cout << "thresholdHigh: " << result.outputMeasurement->thresholdHigh( 0 ) ;

polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))

result_output_image, result_output_measurement = imagedev.canny_edge_detector_2d( polystyrene, [1, 1] )

print( "output_image:", str( result_output_image ) )
print( "thresholdHigh: ", str( result_output_measurement.threshold_high( 0 ) )  )

ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );

Processing.CannyEdgeDetector2dOutput result = Processing.CannyEdgeDetector2d( polystyrene, new double[]{1, 1} );

Console.WriteLine( "outputImage:" + result.outputImage.ToString() );
Console.WriteLine(  "thresholdHigh: " + result.outputMeasurement.thresholdHigh( 0 )  );