Hough transform: Difference between revisions

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)

_ ->

putStrLn $

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

require 'media/platimg' NB. addon required pre J8

Img=: readimg_jqtide_ jpath '~temp/pentagon.png'

<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

import javax.imageio.ImageIO

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

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

 

=={{header|Maple}}==

img := Read("pentagon.png")[..,..,1]:

img_x := Convolution (img, Matrix ([[1,2,1], [0,0,0],[-1,-2,-1]])):

end proc:

result :=HoughTransform(img,row,col);

 

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

{{trans|Kotlin}}

import java.io.File

import javax.imageio._

 

private val dataArray = Array.ofDim[Int](width, height)

 

=={{header|SequenceL}}==

{{trans|Java}}

'''Tail-Recursive SequenceL Code:'''<br>

import <Utilities/Math.sl>;

 

j within x-1 ... x+1;

in

 

'''C++ Driver Code:'''<br>

{{libheader|CImg}}

#include "CImg.h"

 

sl_done();

return 0;

 

{{out}}

=={{header|Sidef}}==

{{trans|Python}}

 

func hough(im, width=460, height=360) {

var img = %s|Imager|.new(file => 'Pentagon.png')

var ht = hough(img)

 

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