Canny edge detector: Difference between revisions

=={{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}}==

 

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

 

 

 

 

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}}==

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|Perl}}==

Used a [https://raw.githubusercontent.com/abend/Image-EdgeDetect/master/lib/Image/EdgeDetect.pm non-CPAN module] by [https://github.com/abend Sasha Kovar]

 

use strict;

 

my $detector = Image::EdgeDetect->new();

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

 

=={{header|PHP}}==

PHP implementation

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

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

imagedestroy($im);

 

 

=={{header|Phix}}==

{{libheader|Phix/pGUI}}

Ported from demo\Arwen32dibdemo\manip.exw (menu entry Manipulate/Filter/Detect Edges, windows-32-bit only) to pGUI.

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Canny_Edge_Detection.exw

<span style="color: #7060A8;">IupMainLoop</span><span style="color: #0000FF;">()</span>

<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>

 

=={{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}}==

 

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

=={{header|Tcl}}==

{{libheader|crimp}}

package require crimp::pgm

 

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

}

 

=={{header|Wren}}==

{{libheader|DOME}}

{{libheader|Wren-check}}

import "graphics" for Canvas, Color, ImageData

import "math" for Math

draw(alpha) {}

}

 

=={{header|Yabasic}}==

{{trans|Phix}}

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

 

dot x, y

next