Canny edge detector: Difference between revisions

# '''Tracing edges with hysteresis.''' &nbsp; <br>At this stage two thresholds for the values of &nbsp; <math>G</math> &nbsp; are introduced: &nbsp; <math>T_{min}</math> &nbsp; and &nbsp; <math>T_{max}</math>. &nbsp; <br>Starting from pixels with &nbsp; <math>N(p) \geqslant T_{max}</math>, &nbsp; <br>find all paths of pixels with &nbsp; <math>N(p) \geqslant T_{min}</math> &nbsp; and put them to the resulting image.

<br><br>

=={{header|C}}==

The following program reads an 8 bits per pixel grayscale [[wp:BMP file format|BMP]] file and saves the result to `out.bmp'. Compile with `-lm'.

#include <stdio.h>

#include <stdlib.h>

free((pixel_t*)out_bitmap_data);

return 0;

=={{header|D}}==

{{trans|C}}

This version retains some of the style of the original C version. This code is faster than the C version, even with the DMD compiler. This version loads and saves PGM images, using the module of the Grayscale image Task.

std.algorithm, std.ascii, std.array, bitmap, grayscale_image;

 

printf("Image size: %d x %d\n", imIn.nx, imIn.ny);

imIn.cannyEdgeDetection(45, 50, 1.0f).savePGM("lena_canny.pgm");

=={{header|Go}}==

{{libheader|Imger}}

 

Note that on Linux the extension of the example image file name needs to be changed from .PNG to .png in order for the library used to recognize it.

 

import (

log.Fatal("Could not write Canny image to disk")

}

=={{header|J}}==

<p>In this solution images are represented as 2D arrays of pixels, with first and second axes representing down and right respectively. Each processing step has a specific pixel representation. In the original and Gaussian-filtered images, array elements represent monochromatic intensity values as numbers ranging from 0 (black) to 255 (white). In the intensity gradient image, gradient values are vectors, and are represented as complex numbers, with real and imaginary components representing down and right respectively. </p>

<p>Detected edge and non-edge points are represented as ones and zeros respectively. An edge is a set of connected edge points (points adjacent horizontally, vertically, or diagonally are considered to be connected). In the final image, each edge is represented by assigning its set of points a common unique value. </p>

 

convolve =: 4 : 'x apply (($x) partition y)'

canny =: step5 @ step4 @ step3 @ step2 @ step1

 

<p>The above implementation solves the 'inner problem' of Canny Edge Detection in the J language, with no external dependencies. J's Qt IDE provides additional support including interfaces to image file formats, graphic displays, and the user. The following code exercises these features</p>

 

<p>The file 'valve.png' referenced in this code is from one of several Wikipedia articles on edge detection. It can be viewed at [https://upload.wikimedia.org/wikipedia/commons/2/2e/Valve_gaussian_%282%29.PNG[https://upload.wikimedia.org/wikipedia/commons/2/2e/Valve_gaussian_%282%29.PNG]]</p>

require 'gl2'

coclass 'edge'

form_close=: exit bind 0

 

=={{header|Java}}==

El código es de Tom Gibara [The code is from Tom Gibara] (http://www.tomgibara.com/)

 

Se implementa utilizando una sola clase Java. [It is implemented using a single Java class.]

import java.util.Arrays;

 

}

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Mathematica uses canny edge detection by default. This seems so cheaty next to all of these giant answers...

=={{header|MATLAB}} / {{header|Octave}}==

There is a function in the image processing toolbox [http://www.mathworks.com/help/images/ref/edge.html edge], that has Canny Edge Detection as one of its options.

=={{header|Nim}}==

{{trans|D}}

We use the PNG image present on Wikipedia article as input and produce a PNG grayscale image as result.

 

import math

import nimPNG

echo "File ", Input, " processed. Result is available in file ", Output

else:

 

=={{header|PHP}}==

PHP implementation

// input: r,g,b in range 0..255

function RGBtoHSV($r, $g, $b) {

imagedestroy($im);

 

=={{header|Python}}==

 

In Python, Canny edge detection would normally be done using [http://scikit-image.org/docs/dev/auto_examples/plot_canny.html scikit-image] or OpenCV-Python. Here is an approach using numpy/scipy:

 

import numpy as np

from scipy.ndimage.filters import convolve, gaussian_filter

im = imread("test.jpg", mode="L") #Open image, convert to greyscale

finalEdges = CannyEdgeDetector(im)

=={{header|Raku}}==

Admittedly laziness always prevails so an off-the-shelf function from ImageMagick is used instead.

 

cannyedge.c

#include <string.h>

#include <magick/MagickCore.h>

 

return 0;

cannyedge.raku

use NativeCall;

CArray[uint8].new( 'output.jpg'.encode.list, 0),

0e0, 2e0, 0.05e0, 0.05e0

{{out}}

<pre>export PKG_CONFIG_PATH=/usr/lib/pkgconfig

raku -c cannyedge.raku && ./cannyedge.raku</pre>

Output: [https://drive.google.com/file/d/1k9F53egoFP0Sl4uBR85nai8IwC43BkYZ/view (Offsite image file) ]

=={{header|Tcl}}==

{{libheader|crimp}}

package require crimp::pgm

 

writePGM $outputFile [crimp filter canny sobel [readPGM $inputFile]]

}

=={{header|Wren}}==

{{trans|C}}

{{libheader|DOME}}

{{libheader|Wren-check}}

import "graphics" for Canvas, Color, ImageData

import "math" for Math

construct new(inFile, outFile) {

Window.title = "Canny edge detection"

var w = image1.width

var h = image1.height

draw(alpha) {}

}

 

=={{header|Yabasic}}==

{{trans|Phix}}

// Adapted from Phix to Yabasic by Galileo, 01/2022

 

dot x, y

next