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 (

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

 

=={{header|Julia}}==

 

img = fill(false,5,5)

 

println(hough_transform_standard(img))

Tuple{Float64,Float64}[(3.0, 1.5708)]

</pre>

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

{{libheader|nimPNG}}

We use the modules from tasks “Bitmap” and “Grayscale image”, adding necessary conversions to read and write PNG files.

import grayscale_image

 

for color in houghImage.pixels:

data.add([color.r, color.g, color.b])

 

=={{header|Perl}}==

{{trans|Sidef}}

use warnings;

 

my $ht = hough($img);

$ht->write(file => 'hough_transform.png');

 

=={{header|Phix}}==

{{libheader|Phix/pGUI}}

{{trans|Sidef}}

 

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

The <code>GD</code> module the output palette to 255 colors, so only transform darker pixels in the image.

{{trans|Perl}}

 

my $filename = 'pentagon.ppm';

my $y = floor $pixel / $xsize;

 

my $th = $dth*$k;

my $r = ($x*cos($th) + $y*sin($th));

my $png_fh = $image.open("hough-transform.png", "wb");

$image.output($png_fh, GD_PNG);

See [https://github.com/thundergnat/rc/blob/master/img/hough-transform.png Hough Transform] (offsite .png image)

 

=={{header|Ruby}}==

 

require 'mathn'

require 'rubygems'

end

out

 

=={{header|Rust}}==

//! Contributed by Gavin Baker <gavinb@antonym.org>

//! Adapted from the Go version

}

 

 

 

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