Bitmap/Bresenham's line algorithm: Difference between revisions

 

 

=={{header|Ada}}==

DX : constant Float := abs Float (Stop.X - Start.X);

DY : constant Float := abs Float (Stop.Y - Start.Y);

end if;

Picture (X, Y) := Color; -- Ensure dots to be drawn

The test program's

begin

Fill (X, White);

Line (X, (16, 8), ( 8, 1), Black);

Line (X, ( 8, 1), ( 1, 8), Black);

sample output

<pre>

=={{header|ALGOL 68}}==

{{trans|Ada}}

 

line OF class image := (REF IMAGE picture, POINT start, stop, PIXEL color)VOID:

END # line #;

 

REF IMAGE x = INIT LOC[1:16, 1:16]PIXEL;

(fill OF class image)(x, white OF class image);

(line OF class image)(x, ( 8, 1), ( 1, 8), black OF class image);

(print OF class image)(x)

<pre>

ffffffffffffffffffffffffffffffffffffffffff000000ffffffffffffffffffffffffffffffffffffffffffffffff

ffffffffffffffffffffffffffffffffffffffffff000000ffffffffffffffffffffffffffffffffffffffffffffffff

</pre>

 

=={{header|C}}==

 

Instead of swaps in the initialisation use error calculation for both directions x and y simultaneously:

 

int dx = abs(x1-x0), sx = x0<x1 ? 1 : -1;

if (e2 < dy) { err += dx; y0 += sy; }

}

=={{header|C++}}==

{

// Bresenham's line algorithm

 

 

 

 

}

=={{header|Clojure}}==

 

(defn draw-line

"Draw a line from x1,y1 to x2,y2 using Bresenham's, to a java BufferedImage in the colour of pixel."

[buffer x1 y1 x2 y2 pixel]

(let [[x1 y1 x2 y2] (if steep [y1 x1 y2 x2] [x1 y1 x2 y2])]

(let [[x1 y1 x2 y2] (if (> x1 x2) [x2 y2 x1 y1] [x1 y1 x2 y2])]

 

 

=={{header|Common Lisp}}==

 

(declare (type rgb-pixel-buffer buffer))

(declare (type integer x1 y1 x2 y2))

(declare (type rgb-pixel pixel))

(let* ((dist-x (abs (- x1 x2)))

(when steep

(psetf x1 y1 y1 x1

(when (> x1 x2)

(psetf x1 x2 x2 x1

(let* ((delta-x (- x2 x1))

(loop

=={{header|D}}==

 

 

 

 

 

 

}

 

}

 

 

=={{header|E}}==

 

{{trans|C}}

 

def t := left

left := right

}

}

 

drawLine(i, 1, 1, 3, 18, makeColor.fromFloat(0,1,1))

 

=={{header|Erlang}}==

build_path({Sx, Sy}, {Tx, Ty}) ->

 

through_x({Tx, _}, {Tx, _}, _, _, _, P) -> P;

through_x({Sx, Sy}, {Tx, Ty}, {StepX, StepY}, {Dx, Dy}, F0, P) when F0 >= 0 ->

F2 = F1 + Dy,

through_x({Sx, Sy}, {Tx, Ty}, {StepX, StepY}, {Dx, Dy}, F0, P) when F0 < 0 ->

F2 = F0 + Dy,

 

through_y({_, Ty}, {_, Ty}, _, _, _, P) -> P;

through_y({Sx, Sy}, {Tx, Ty}, {StepX, StepY}, {Dx, Dy}, F0, P) when F0 >= 0 ->

F2 = F1 + Dx,

through_y({Sx, Sy}, {Tx, Ty}, {StepX, StepY}, {Dx, Dy}, F0, P) when F0 < 0 ->

F2 = F0 + Dx,

OR

line({X0, Y0}, {X1, Y1}) ->

line({X1, Y1}, {X1, Y1}, _, _, _, Acc) ->

line({X, Y}, {X1, Y1}, {SX, SY}, {DX, DY}, Err, Acc) ->

step(P0, P1) when P0 < P1 ->

step(_, _) ->

next_x(X, SX, DY, E, DE) when DE > -DY ->

next_x(X, _SX, _DY, E, _DE) ->

 

next_y(Y, SY, DX, E, DE) when DE < DX ->

next_y(Y, _SY, _DX, E, _DE) ->

 

=={{header|F Sharp|F#}}==

let steep = abs(y1 - y0) > abs(x1 - x0)

let x0, y0, x1, y1 =

else

loop (e-dy) (x+1) y

The following program tests the above bresenham function by drawing 100 lines into an image and visualizing the result using

{{libheader|Windows Presentation Foundation}}:

open System.Windows.Media.Imaging

 

BitmapSource.Create(n, n, 1.0, 1.0, format, null, pixel, n)

Window(Content=image, Title="Bresenham's line algorithm")

=={{header|Factor}}==

A very ugly imperative implementation similar to the wikipedia pseudocode..

math.ranges math.vectors rosettacode.raster.display

rosettacode.raster.storage sequences ui.gadgets ;

: draw-line ( {R,G,B} pt1 pt2 image -- )

[ line-points ] dip

 

=={{header|Forth}}==

defer ystep \ 1+ or 1-

 

2dup - abs >r

2over - abs r> <

else 2swap ['] noop

then is steep

( y0 y1 x0 x1 )

2dup >

else 2swap

then

** *

**

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

{{trans|C}}

use RCImageBasic

 

end subroutine draw_line

 

 

Usage example:

 

use RCImageBasic

use RCImageIO

call free_img(animage)

 

=={{header|Go}}==

 

// Line draws line by Bresenham's algorithm.

func (b *Bitmap) LineRgb(x0, y0, x1, y1 int, c Rgb) {

b.Line(x0, y0, x1, y1, c.Pixel())

A demonstration program:

 

// Files required to build supporting package raster are found in:

fmt.Println(err)

}

=={{header|Haskell}}==

 

import Bitmap

deltax = x2 - x1

deltay = abs $ y2 - y1

=={{header|J}}==

'''Solution:'''

 

Using definitions from [[Basic bitmap storage#J|Basic bitmap storage]].

 

NB.*getBresenhamLine v Returns points for a line given start and end points

NB.*drawLines v Draws lines (x) on image (y)

NB. x is: 2-item list (start and end points) ; (color)

 

'''Example Usage:'''

myimg=: ((1 1 ,: 5 11) ; 255 0 0 ) drawLines myimg NB. draw red line from xy point 1 1 to 11 5

 

viewRGB myimg=: (Diamond;255 0 0) drawLines myimg NB. draw 4 red lines to form a diamond

viewRGB myimg=: (Square;0 0 255) drawLines myimg NB. draw 4 blue lines to form a square

 

=={{header|JavaScript}}==

Instead of swaps in the initialisation use error calculation for both directions x and y simultaneously:

 

var dx = Math.abs(x1 - x0), sx = x0 < x1 ? 1 : -1;

if (e2 < dy) { err += dx; y0 += sy; }

}

 

=={{header|Maple}}==

 

local deltax, deltay, x, y, ystep, steep, err, img2, x02, y02, x12, y12;

x02, x12, y02, y12 := y0, y1, x0, x1;

end do;

return img2;

 

=={{header|MAXScript}}==

 

(

if steep then

(

local steep = (abs (end.y - start.y)) > (abs (end.x - start.x))

if steep then

(

swap end.x end.y

)

if start.x > end.x then

(

swap start.y end.y

)

local deltaX = end.x - start.x

local deltaY = abs (end.y - start.y)

local yStep = -1

local y = start.y

if start.y < end.y then

(

yStep = 1

)

for x in start.x to end.x do

(

myBitmap = bitmap 512 512 color:(color 0 0 0)

myBitmap = drawLine myBitmap [0, 511] [511, 0] #((color 255 255 255))

 

=={{header|OCaml}}==

 

 

let steep = abs(y1 - y0) > abs(x1 - x0) in

in

loop x0 y0 error

 

=={{header|Perl}}==

 

{{libheader|Imlib2}}

 

use strict;

use Image::Imlib2;

my $steep = (abs($y1 - $y0) > abs($x1 - $x0));

if ( $steep ) {

}

if ( $x0 > $x1 ) {

}

my $deltax = $x1 - $x0;

$ystep = ( $y0 < $y1 ) ? 1 : -1;

for( $x = $x0; $x <= $x1; $x += 1 ) {

}

}

$img->save("test1.png");

 

 

Images <tt>test0.png</tt> and <tt>test1.png</tt> look different since Imlib2 draw lines with antialiasing.

 

=={{header|PL/I}}==

/* Based on Rosetta code proforma. */

draw_line: procedure (xi, yi, xf, yf );

declare (xi, yi, xf, yf) fixed binary (31) nonassignable;

 

end draw_line;

 

Output from the statement:-

call draw_line(-1, -3, 6, 10);

for a -10:10 x -10:10 grid:

..........|..........

..........|..........

..........|..........

..........|..........

 

 

 

=={{header|PureBasic}}==

If Abs(y1 - y0) > Abs(x1 - x0);

steep =#True

Until Event = #PB_Event_CloseWindow

EndIf

=={{header|Python}}==

{{works with|Python|3.1}}

Extending the example given [[Basic_bitmap_storage/Python#Alternative_version|here]] and using the algorithm from the Ada solution:

 

"Bresenham's line algorithm"

dx = abs(x1 - x0)

| |

+-----------------+

 

=={{header|RapidQ}}==

 

Use this routine together with the code from [[Basic_bitmap_storage#RapidQ|Basic bitmap storage]] to create a full application.

 

x_dist = abs(x2-x1)

y_dist = abs(y2-y1)

IF y2-y1 < -x_dist OR x2-x1 <= -y_dist THEN

END IF

IF x1 < x2 THEN x_step = 1 ELSE x_step = -1

IF y1 < y2 THEN y_step = 1 ELSE y_step = -1

error = x_dist/2

END IF

 

Example usage:

 

draw_line 200, 10, 100, 200, &H00ff00

draw_line 100, 200, 200, 400, &H00ff00

draw_line 200, 400, 300, 200, &H00ff00

draw_line 300, 200, 200, 10, &H00ff00

 

=={{header|Ruby}}==

 

class Pixmap

bitmap.draw_line(Pixel[10, 10], Pixel[a,490], RGBColour::YELLOW)

end

 

=={{header|Scala}}==

Uses the [[Basic_bitmap_storage#Scala|Scala Basic Bitmap Storage]] class.

def bresenham(bm:RgbBitmap, x0:Int, y0:Int, x1:Int, y1:Int, c:Color)={

val dx=math.abs(x1-x0)

res;

}

}

 

for((x,y) <- it)

}

 

=={{header|Tcl}}==

{{libheader|Tk}}

ref [[Basic bitmap storage#Tcl]]

package require Tk

 

fill $img black

drawLine $img yellow {20 20} {180 80}

=={{header|TI-89 BASIC}}==

 

{{trans|E}}

 

Prgm

Local steep, x, y, dx, dy, ystep, error, tmp

EndIf

EndFor

 

=={{header|Vedit macro language}}==

 

// #1=x1, #2=y1; #3=x2, #4=y2

 

:DRAW_LINE:

Num_Push(31,35)

if (#4-#2 < -#31 || #3-#1 <= -#32) {

#99=#2; #2=#4; #4=#99

}

 

while (#2 <= #4) {

}

#33 = #31 / 2

while (#1 <= #3) {

}

}

Num_Pop(31,35)

 

{{omit from|PARI/GP}}