Bitmap/Bresenham's line algorithm: Difference between revisions

[[Category:Graphics algorithms]]

 

;Task:

<br><br>

 

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

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.6 algol68g-2.6].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

 

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

END # line #;

 

# -*- coding: utf-8 -*- #

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

(print OF class image)(x)

<pre>

ffffffffffffffffffffffffffffffffffffffffff000000ffffffffffffffffffffffffffffffffffffffffffffffff

ffffffffffffffffffffffffffffffffffffffffff000000ffffffffffffffffffffffffffffffffffffffffffffffff

</pre>

=={{header|Assembly}}==

16 bit Intel 8086\80486 Assembly for dos, see [http://en.wikipedia.org/wiki/X86_assembly_language x86 assembly language].

END start

</pre>

 

=={{header|AutoHotkey}}==

 

White := Color(255,255,255)

Bitmap := Bitmap(100,100,Blue) ;create a 100*100 blue bitmap

Temp1 := ErrorValue << 1, ((Temp1 > DeltaY) ? (ErrorValue += DeltaY, PosX1 += StepX) : ""), ((Temp1 < DeltaX) ? (ErrorValue += DeltaX, PosY1 += StepY) : "") ;move forward

}

 

=={{header|AutoIt}}==

 

 

Func drawBresenhamLine($iX0, $iY0, $iX1, $iY1)

EndIf

WEnd

 

=={{header|BASIC}}==

1510 REM Inputs are X1, Y1, X2, Y2: Destroys value of X1, Y1

1520 DX = ABS(X2 - X1):SX = -1:IF X1 < X2 THEN SX = 1

1590 IF E2 > -DX THEN ER = ER - DY:X1 = X1 + SX

1600 IF E2 < DY THEN ER = ER + DX:Y1 = Y1 + SY

=={{header|Batch File}}==

setlocal enabledelayedexpansion

 

)

)

=={{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 sharp|C#}}==

Port of the C version.

using System.Drawing;

using System.Drawing.Imaging;

return bitmap;

}

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

{

// Bresenham's line algorithm

const int maxX = (int)x2;

 

{

if(steep)

}

}

=={{header|Clojure}}==

 

 

(defn draw-line

(recur (inc x) (+ y y-step) (+ error (- delta-x delta-y)))

(recur (inc x) y (- error delta-y)))))))))))

=={{header|CoffeeScript}}==

 

drawBresenhamLine = (x0, y0, x1, y1) ->

dx = Math.abs(x1 - x0)

y0 += sy

null

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

 

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

(declare (type integer x1 y1 x2 y2))

(incf y y-step)

(incf error delta-x))))

=={{header|D}}==

This code uses the Image defined in [[Bitmap]] Task.

 

 

import std.algorithm, std.math, bitmap;

img.textualShow();

}

To run the demo code compile with <code>-version=bitmap_bresenhams_line_algorithm_main</code>.

{{out}}

###.###########.#########

#########################</pre>

=={{header|Delphi}}==

 

procedure drawLine (bitmap : TBitmap; xStart, yStart, xEnd, yEnd : integer; color : TAlphaColor);

// Bresenham's Line Algorithm. Byte, March 1988, pp. 249-253.

end;

end;

 

=={{header|Elm}}==

 

 

 

bresenhamLineLoop statics error_ (Position x y) positions_

 

 

=={{header|Erlang}}==

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

if

F2 = F0 + Dx,

through_y({Nx, Ny}, {Tx, Ty}, {StepX, StepY}, {Dx, Dy}, F2, [{Nx, Ny}|P]).

OR

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

SX = step(X0, X1),

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

{Y, E}.

=={{header|ERRE}}==

PROGRAM BRESENHAM

 

SCREEN(0)

END PROGRAM

=={{header|Euphoria}}==

 

{{trans|C}}

 

include std/graphics.e

include std/math.e

--

--,respectively in the last if check.

Output:

<pre>

Press Any Key to continue...

</pre>

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

1. In FBSL, successive calls to one and the same subprocedure may be concatenated to a series of argument sets as in Sub Rhombus() below.

 

'''Using pure FBSL's built-in graphics functions:'''

#DEFINE WM_CLOSE 16

 

WEND

END SUB

'''Output:''' [[File:FBSLBresenham.PNG]]

=={{header|Forth}}==

defer ystep \ 1+ or 1-

 

** *

**

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

' compile with: fbc -s console

' OR compile with: fbc -s gui

Loop Until InKey <> "" ' loop until a key is pressed

 

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

 

 

public static void main(String[] args) {

}

}

 

class BresenhamPanel extends JPanel {

 

}

 

super.paintComponent(g);

 

}

 

private void plot(Graphics g, int x, int y) {

g.setColor(Color.black);

}

 

private void drawLine(Graphics g, int x1, int y1, int x2, int y2) {

int d = 0;

 

int dx = Math.abs(x2 - x1);

 

 

int ix = x1 < x2 ? 1 : -1; // increment direction

int iy = y1 < y2 ? 1 : -1;

 

break;

d += dy2;

if (d > dx) {

d -= dx2;

}

}

} else {

break;

d += dx2;

if (d > dy) {

d -= dy2;

}

}

}

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

 

 

 

 

 

 

 

 

then

((dx = x0 - x1)); ((sx = -1))

fi

 

then

((dy = y0 - y1)); ((sy = -1))

fi

 

then

((err = dx))

((err /= 2)); ((e2 = 0))

 

do

echo $x0 $y0

((e2 = err))

done

line 0 0 3 4

(which could be piped to another program)

1 1

1 2

2 3

 

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

Note: Store this function in a file named "bresenhamLine.m" in the @Bitmap folder for the Bitmap class defined [[Bitmap#MATLAB|here]].

[[File:Bresenham.png|thumb|MATLAB sample usage output.]]

%screen = Bitmap object

%startPoint = [x0,y0]

assignin('caller',inputname(1),screen); %saves the changes to the object

end

 

Sample Usage:

>> img = Bitmap(800,600);

>> img.bresenhamLine([400 550],[200 400],[255 255 255]);

>> img.bresenhamLine([400 550],[400 150],[255 255 255]);

>> disp(img)

=={{header|MAXScript}}==

 

(

if steep then

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

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

=={{header|Metal}}==

 

For drawing lines between points in an Apple Metal compute shader.

 

 

void drawLine(texture2d<float, access::write> targetTexture, uint2 start, uint2 end)

}

}

 

=={{header|Nim}}==

 

let

dx = abs(q.x - p.x)

 

while true:

if p == q:

break

if e2 < dy:

err += dx

 

=={{header|OCaml}}==

 

 

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

in

loop x0 y0 error

=={{header|Pascal}}==

 

[[Bresenham's_line_algorithm#Delphi | Delphi]]

=={{header|Perl}}==

 

{{libheader|Imlib2}}

 

use strict;

use Image::Imlib2;

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

 

 

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

=={{header|Phix}}==

Modified copy of [[Bitmap/Bresenham%27s_line_algorithm#Euphoria|Euphoria]], with a bigger bitmap and a simpler pattern.

 

end if

if x0=x1 and y0=y1 then exit end if

end if

end while

end function

 

 

=={{header|PicoLisp}}==

(let SX

(cond

(prinl "P1")

(prinl 120 " " 90)

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

===version 1===

{{incorrect|PL/I|The sample output does not start at -1/-3!?! Pls show the complete program producing this output.}}

/* Draw a line from (x0, y0) to (x1, y1). 13 May 2010 */

/* Based on Rosetta code proforma. */

 

end draw_line;

 

Output from the statement:-

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

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

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

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

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

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

 

===version 2===

brbn:Proc Options(main);

/*********************************************************************

image(x0,y0)='X';

end;

'''output'''

<pre>11 ..|.......

-4 ..|.......

2101234567</pre>

=={{header|Prolog}}==

 

 

 

 

 

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

| |

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

 

===Not relying on floats===

Extending the example given [[Basic_bitmap_storage/Python#Alternative_version|here]].

 

from fractions import Fraction

 

 

# see test code above

=={{header|Racket}}==

Port of the Python version.

#lang racket

(require racket/draw)

(apply draw-line (cons dc points)))

bm

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

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

parse arg data /*obtain optional arguments from the CL*/

if data='' then data= "(1,8) (8,16) (16,8) (8,1) (1,8)" /* ◄──── a rhombus.*/

/* [↓] display the plot to terminal. */

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

<pre>

···│····················

</pre>

 

* 21.05.2014 Walter Pachl

* Implementing the pseudo code of

end

end

'''output'''

<pre>11 ..|.......

-4 ..|.......

2101234567</pre>

=={{header|Ring}}==

load "guilib.ring"

load "stdlib.ring"

}

label1 { setpicture(p1) show() }

Output :

[https://lh3.googleusercontent.com/-6uJvON0dAuo/V2LO2zz4zQI/AAAAAAAAALE/IjEGFuhta6oUSeG2QfuxcPBWMmCyNCjdwCLcB/s1600/CalmoSoftBresenham.jpg Bitmap/Bresenham's algorithm]

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

bm.setPixel(x, y, c)

}

=={{header|Sidef}}==

{{trans|Perl}}

 

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

img.draw_line(80, 10, 10, 80)

 

 

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

 

}

Num_Pop(31,35)

=={{header|Wart}}==

def (line x0 y0 x1 y1)

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

when (error < 0)

y += ystep

 

=={{header|XPL0}}==

Bresenham line draw is built-in.

[SetVid($112); \set 640x480 graphics in 24-bit color

Move(10, 20); \set start of line segment

if ChIn(1) then []; \wait for keystroke while viewing graphic screen

SetVid(3); \restore normal text mode

=={{header|zkl}}==

[[File:Line.zkl.jpg|200px|thumb]]

Algorithm from Wikipedia plus other functions so I can reference this code in other examples.

ppm.line(50,100, 100,190, 0);

ppm.line(100,190, 150,100, 0);

ppm.line(100,10, 50,100, 0);

 

fcn init(width,height,rgb=0){

sz:=width*height;

}

}

{{omit from|AWK}}

{{omit from|PARI/GP}}