Hough transform: Difference between revisions

 

The transform maps each point in the target image, <math>(\rho,\theta)</math>, to the average color of the pixels on the corresponding line of the source image (in <math>(x,y)</math>-space, where the line corresponds to points of the form <math>x\cos\theta + y\sin\theta = \rho</math>). The idea is that where there is a straight line in the original image, it corresponds to a bright (or dark, depending on the color of the background field) spot; by applying a suitable filter to the results of the transform, it is possible to extract the locations of the lines in the original image.

 

There is also a spherical Hough transform, which is more suited to identifying planes in 3D data.

 

=={{header|BBC BASIC}}==

BBC BASIC uses Cartesian coordinates so the image is 'upside down' compared with some other solutions.

[[Image:hough_bbc.gif|right]]

Height% = 240

REPEAT

WAIT 1

 

=={{header|C}}==

 

 

=={{header|D}}==

{{trans|Go}}

This uses the module from the Grayscale image Task. The output image is the same as in the Go solution.

 

Image!Gray houghTransform(in Image!Gray im,

in size_t hx=460, in size_t hy=360)

assert(im !is null);

assert(hx > 0 && hy > 0);

foreach (immutable y; 0 .. im.ny) {

foreach (immutable x; 0 .. im.nx) {

continue;

foreach (immutable iTh; 0 .. hx) {

 

void main() {

.rgb2grayImage()

.houghTransform()

.savePGM("Pentagon_hough.pgm");

 

=={{header|Go}}==

[[file:GoHough.png|right|thumb|Output png]]

{{trans|Python}}

 

import (

nimx := im.Bounds().Max.X

mimy := im.Bounds().Max.Y

him := image.NewGray(image.Rect(0, 0, ntx, mry))

draw.Draw(him, him.Bounds(), image.NewUniform(color.White),

 

rmax := math.Hypot(float64(nimx), float64(mimy))

fmt.Println(err)

}

 

=={{header|J}}==

'''Solution:'''

NB. y is picture as an array with 1 at non-white points,

NB. x is resolution (width,height) of resulting image

rho=. <. 0.5+ h * (rho-min) % max-min NB. Rescale rho from 0 to h and round to int

|.([: <:@(#/.~) (i.h)&,)"1&.|: rho NB. consolidate into picture

[[Image:JHoughTransform.png|320px200px|thumb|right|Resulting viewmat image from J implementation of Hough Transform on sample pentagon image]]'''Example use:'''

<br style="clear:both" />

 

=={{header|Java}}==

'''Code:'''

import java.io.File;

import java.io.IOException;

return;

}

 

[[Image:JavaHoughTransform.png|640px480px|thumb|right|Output from example pentagon image]]'''Example use:'''

<br style="clear:both" />

 

 

Radon[image, Method -> "Hough"]

 

=={{header|MATLAB}}==

 

 

 

 

 

 

 

=={{header|Python}}==

{{libheader|PIL}}

This is the classical Hough transform as described in wikipedia. The code does not compute averages; it merely makes a point on the transformed image darker if a lot of points on the original image lie on the corresponding line. The output is almost identical to that of the Tcl code. The code works only with gray-scale images, but it is easy to extend to RGB.

from math import hypot, pi, cos, sin

 

 

if __name__ == "__main__": test()

 

 

{{omit from|PARI/GP}}

 

=={{header|Ruby}}==

 

require 'mathn'

require 'rubygems'

end

out

 

=={{header|Tcl}}==

 

* See [[Example:Hough transform/Tcl]]

 

{{omit from|PARI/GP}}