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

{{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,

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

{{libheader|JuicyPixels}}

import Data.Array ((!))

import Data.Array.ST (newArray, writeArray, readArray, runSTArray)

 

-- Library JuicyPixels:

import Codec.Picture.Types (extractLumaPlane, dropTransparency)

 

dot (x1, y1) (x2, y2) = x1 * x2 + y1 * y2

 

mag a = sqrt $ dot a a

 

sub (x1, y1) (x2, y2) = (x1 - x2, y1 - y2)

 

fromIntegralP (x, y) = (fromIntegral x, fromIntegral y)

 

xCenter = wMax `div` 2

yCenter = hMax `div` 2

lumaMap = extractLumaPlane image

gradient x y =

let orig = pixelAt lumaMap x y

-- The longest distance from the center, half the hypotenuse of the image.

distMax :: Double

distMax = (sqrt . fromIntegral $ height ^ 2 + width ^ 2) / 2

{-

The accumulation bins of the polar values.

lines that go through that point in Hough space.

-}

maxAcc = F.maximum accBin

-- The image representation of the accumulation bins.

hTransform x y =

in PixelRGB8 l l l

hImage = generateImage hTransform thetaSize distSize

 

image <- readImage path

case image of

where

doImage image = do

[path, outpath, thetaSize, distSize] ->

houghIO path outpath (read thetaSize) (read distSize)

'''Example use:'''

 

=={{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:'''

<pre>java HoughTransform pentagon.png JavaHoughTransform.png 640 480 100</pre>

<br style="clear:both" />

 

=={{header|Kotlin}}==

{{trans|Java}}

import java.io.File

 

internal class ArrayData(val dataArray: IntArray, val width: Int, val height: Int) {

 

 

operator fun get(x: Int, y: Int) = dataArray[y * width + x]

val minContrast = if (args.size >= 4) 64 else args[4].toInt()

inputData(args[2].toInt(), args[3].toInt(), minContrast).writeOutputImage(args[1])

 

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

 

Radon[image, Method -> "Hough"]

 

=={{header|MATLAB}}==

 

* see [[Example:Hough transform/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

from PIL import Image

if __name__ == "__main__": test()

 

 

{{omit from|PARI/GP}}

 

=={{header|Racket}}==

 

=={{header|Ruby}}==

 

require 'mathn'

require 'rubygems'

end

out

 

=={{header|Tcl}}==

 

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

 

=={{header|zkl}}==

Uses the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl

{{trans|D}}

fcn houghTransform(image,hx=460,hy=360){

if(hy.isOdd) hy-=1; // hy argument must be even

}

out

p:=System.popen("convert \"%s\" ppm:-".fmt(fileName),"r");

img:=PPM.readPPM(p);

}

houghTransform(readPNG2PPM("pentagon.png"))

{{out}}

The output image looks the same as in the Go solution.