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>

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

{{works with|BBC BASIC for Windows}}

Height% = 200

dx% = ABS(x2% - x1%) : sx% = SGN(x2% - x1%)

dy% = ABS(y2% - y1%) : sy% = SGN(y2% - y1%)

REPEAT

PROCsetpixel(x1%,y1%,r%,g%,b%)

GCOL 1

LINE x%*2,y%*2,x%*2,y%*2

[[File:bresenham_bbc.gif]]

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

const int maxX = (int)x2;

 

{

if(steep)

else

}

}

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

steep (> dist-y dist-x)]

(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])]

(let [delta-x (- x2 x1)

y-step (if (< y1 y2) 1 -1)]

 

#(.setRGB buffer (int %2) (int %1) pixel))]

(plot x y)

(if (< x x2)

(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))

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

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

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

}

 

 

 

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

 

 

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

in

loop x0 y0 error

 

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

(let SX

(cond

(prinl "P1")

(prinl 120 " " 90)

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

/* 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:

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

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

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

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

 

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

 

 

 

 

 

 

 

 

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

}

}

 

bm.setPixel(x, y, c)

}

 

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

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

withs (deltax x1-x0

deltay (abs y1-y0)

ystep (if (y0 < y1) 1 -1)

y y0)

if steep

plot y x

plot x y

error -= deltay

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

 

{{omit from|PARI/GP}}