Bitmap/Bresenham's line algorithm: Difference between revisions
Content deleted Content added
Added solution for Action! |
|||
(20 intermediate revisions by 11 users not shown) | |||
Line 1:
[[Category:Graphics algorithms]]
[[Category:Geometry]]
{{task|Raster graphics operations}}
;Task:
Line 6 ⟶ 7:
<br>draw a line given two points with [[wp:Bresenham's line algorithm|Bresenham's line algorithm]].
<br><br>
=={{header|11l}}==
{{trans|Python}}
<
V black = Colour(0, 0, 0)
Line 85 ⟶ 76:
L(x0, y0, x1, y1) ((1, 8, 8, 16), (8, 16, 16, 8), (16, 8, 8, 1), (8, 1, 1, 8))
bitmap.line(x0, y0, x1, y1)
bitmap.chardisplay()</
{{out}}
Line 112 ⟶ 103:
=={{header|360 Assembly}}==
{{trans|Rexx}}
<
BRESENH CSECT
USING BRESENH,R13 base register
Line 299 ⟶ 290:
PG DC CL80' ' buffer
REGEQU
END BRESENH </
{{out}}
<pre>
Line 323 ⟶ 314:
...|....................
</pre>
=={{header|Action!}}==
Part of the task is available in [http://www.rosettacode.org/wiki/Category:Action!_Bitmap_tools#RGBLINE.ACT RGBLINE.ACT].
{{libheader|Action! Bitmap tools}}
<
RGB black,yellow,violet,blue
Line 400 ⟶ 390:
DO UNTIL CH#$FF OD
CH=$FF
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Bresenham's_line_algorithm.png Screenshot from Atari 8-bit computer]
=={{header|Ada}}==
<
DX : constant Float := abs Float (Stop.X - Start.X);
DY : constant Float := abs Float (Stop.Y - Start.Y);
Line 444 ⟶ 433:
end if;
Picture (X, Y) := Color; -- Ensure dots to be drawn
end Line;</
The test program's
<
begin
Fill (X, White);
Line 453 ⟶ 442:
Line (X, (16, 8), ( 8, 1), Black);
Line (X, ( 8, 1), ( 1, 8), Black);
Print (X);</
sample output
<pre>
Line 473 ⟶ 462:
H
</pre>
=={{header|ALGOL 68}}==
{{trans|Ada}}
Line 479 ⟶ 467:
{{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''.}}
'''File: prelude/Bitmap/Bresenhams_line_algorithm.a68'''<
line OF class image := (REF IMAGE picture, POINT start, stop, PIXEL color)VOID:
Line 520 ⟶ 508:
END # line #;
SKIP</
# -*- coding: utf-8 -*- #
Line 535 ⟶ 523:
(line OF class image)(x, ( 8, 1), ( 1, 8), black OF class image);
(print OF class image)(x)
)</
<pre>
ffffffffffffffffffffffffffffffffffffffffff000000ffffffffffffffffffffffffffffffffffffffffffffffff
Line 554 ⟶ 542:
ffffffffffffffffffffffffffffffffffffffffff000000ffffffffffffffffffffffffffffffffffffffffffffffff
</pre>
=={{header|Applesoft BASIC}}==
<syntaxhighlight lang="gwbasic"> 10 HGR :FULLSCREEN = PEEK (49234)
20 HCOLOR= 3
30 FOR N = 3 TO 279 STEP 4
40 X1 = 276:Y1 = 189:X2 = N:Y2 = 1: GOSUB 100"PLOT LINE"
50 NEXT N
60 FOR N = 3 TO 191 STEP 3
70 X1 = 276:Y1 = 190:X2 = 2:Y2 = N: GOSUB 100"PLOT LINE"
80 NEXT N
90 END
100 DX = ABS (X2 - X1)
110 SX = SGN (X2 - X1)
120 DY = - ABS (Y2 - Y1)
130 SY = SGN (Y2 - Y1)
140 ERR = DX + DY
150 FOR WHILE = 0 TO 1 STEP 0
160 HPLOT X1,Y1
170 IF X1 = X2 AND Y1 = Y2 THEN RETURN
180 E2 = 2 * ERR
190 IF E2 > = DY AND X1 = X2 THEN RETURN
200 IF E2 > = DY THEN ERR = ERR + DY:X1 = X1 + SX
210 IF E2 < = DX AND Y1 = Y2 THEN RETURN
220 IF E2 < = DX THEN ERR = ERR + DX:Y1 = Y1 + SY
230 NEXT WHILE</syntaxhighlight>
=={{header|Assembly}}==
16 bit Intel 8086\80486 Assembly for dos, see [http://en.wikipedia.org/wiki/X86_assembly_language x86 assembly language].
Line 754 ⟶ 765:
END start
</pre>
=={{header|ATS}}==
See [[Bresenham_tasks_in_ATS]].
=={{header|AutoHotkey}}==
<
White := Color(255,255,255)
Bitmap := Bitmap(100,100,Blue) ;create a 100*100 blue bitmap
Line 775 ⟶ 788:
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)
Line 801 ⟶ 814:
EndIf
WEnd
EndFunc ;==>drawBresenhamLine</
=={{header|bash}}==
<
function line {
Line 866 ⟶ 878:
line $((COLS/2)) $LINS $((COLS/4*3)) $((LINS/2))
line $((COLS/4*3)) $((LINS/2)) $((COLS/2)) 1
echo -e "\e[${LINS}H"</
=={{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
Line 880 ⟶ 891:
1590 IF E2 > -DX THEN ER = ER - DY:X1 = X1 + SX
1600 IF E2 < DY THEN ER = ER + DX:Y1 = Y1 + SY
1610 GOTO 1560</
=={{header|Batch File}}==
<
setlocal enabledelayedexpansion
Line 1,010 ⟶ 1,020:
)
)
goto :eof</
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
Height% = 200
Line 1,047 ⟶ 1,056:
GCOL 1
LINE x%*2,y%*2,x%*2,y%*2
ENDPROC</
[[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;
Line 1,066 ⟶ 1,074:
if (e2 < dy) { err += dx; y0 += sy; }
}
}</
=={{header|C sharp|C#}}==
Port of the C version.
<
using System.Drawing;
using System.Drawing.Imaging;
Line 1,096 ⟶ 1,103:
return bitmap;
}
}</
=={{header|C++}}==
<
void Line( float x1, float y1, float x2, float y2, const Color& color )
{
Line 1,144 ⟶ 1,150:
}
}
</syntaxhighlight>
=={{header|Clojure}}==
<
(defn draw-line
Line 1,173 ⟶ 1,178:
(recur (inc x) (+ y y-step) (+ error (- delta-x delta-y)))
(recur (inc x) y (- error delta-y)))))))))))
</syntaxhighlight>
=={{header|CoffeeScript}}==
<
drawBresenhamLine = (x0, y0, x1, y1) ->
dx = Math.abs(x1 - x0)
Line 1,196 ⟶ 1,200:
y0 += sy
null
</syntaxhighlight>
=={{header|Commodore BASIC}}==
<syntaxhighlight lang="basic">
10 rem bresenham line algorihm
20 rem translated from purebasic
Line 1,238 ⟶ 1,241:
2050 if sl<(sw*sh) then poke sc+sl,pc
2060 return
</syntaxhighlight>
[https://www.worldofchris.com/assets/c64-bresenham-line.png C64 Example screenshot]
=={{header|Common Lisp}}==
<
(declare (type rgb-pixel-buffer buffer))
(declare (type integer x1 y1 x2 y2))
Line 1,270 ⟶ 1,272:
(incf y y-step)
(incf error delta-x))))
buffer))</
=={{header|D}}==
This code uses the Image defined in [[Bitmap]] Task.
<
import std.algorithm, std.math, bitmap;
Line 1,326 ⟶ 1,327:
img.textualShow();
}
}</
To run the demo code compile with <code>-version=bitmap_bresenhams_line_algorithm_main</code>.
{{out}}
Line 1,351 ⟶ 1,352:
###.###########.#########
#########################</pre>
=={{header|Delphi}}==
<
procedure drawLine (bitmap : TBitmap; xStart, yStart, xEnd, yEnd : integer; color : TAlphaColor);
// Bresenham's Line Algorithm. Byte, March 1988, pp. 249-253.
Line 1,427:
end;
end;
</syntaxhighlight>
=={{header|E}}==
{{trans|C}}
<
def t := left
left := right
Line 1,462 ⟶ 1,461:
}
}
}</
<
drawLine(i, 1, 1, 3, 18, makeColor.fromFloat(0,1,1))
i.writePPM(<import:java.io.makeFileOutputStream>(<file:~/Desktop/Bresenham.ppm>))</
=={{header|EasyLang}}==
[https://easylang.online/show/#cod=XZHNboMwEITvPMUeG0W4NrSHSnHehQRHQkoJMiRl3z6zePkrAsv7MTNe2118XKnrw0AjMRkyGRH9Pl4B9Sd9gWEUFsN1IGuK72nITNaJs47V371pobbElkZH7OaUeiRP1aWnD+AcioPQXmjuZNrcxHaCS6r531SkAJ4DWAJYA3gbwBLASwDvAkKMokVO3byoUAv6OiNbLUkDtkhM2m4XqkE16Xxkhwqe7dDchXjZctXW0odf+wgFKiRriUVBzuhkVKIL535tBA8Cjx6noMTs7KedVNxH6XtFnNy8dRtc1HJHhbXk5LUyXbmC6St/7N4AQOV/R7lxOJu9AQ== Run it]
{{trans|C}}
<syntaxhighlight>
proc pset x y . .
move x / 4 y / 4
rect 0.25 0.25
.
proc drawline x0 y0 x1 y1 . .
dx = abs (x1 - x0)
sx = -1
if x0 < x1
sx = 1
.
dy = abs (y1 - y0)
sy = -1
if y0 < y1
sy = 1
.
err = -dy div 2
if dx > dy
err = dx div 2
.
repeat
pset x0 y0
until x0 = x1 and y0 = y1
e2 = err
if e2 > -dx
err -= dy
x0 += sx
.
if e2 < dy
err += dx
y0 += sy
.
.
.
drawline 200 10 100 200
drawline 100 200 200 390
drawline 200 390 300 200
drawline 300 200 200 10
</syntaxhighlight>
=={{header|Elm}}==
<
Line 1,527 ⟶ 1,571:
bresenhamLineLoop statics error_ (Position x y) positions_
</syntaxhighlight>
=={{header|Erlang}}==
<
build_path({Sx, Sy}, {Tx, Ty}) ->
if
Line 1,576 ⟶ 1,620:
F2 = F0 + Dx,
through_y({Nx, Ny}, {Tx, Ty}, {StepX, StepY}, {Dx, Dy}, F2, [{Nx, Ny}|P]).
</syntaxhighlight>
OR
<
line({X0, Y0}, {X1, Y1}) ->
SX = step(X0, X1),
Line 1,609 ⟶ 1,653:
next_y(Y, _SY, _DX, E, _DE) ->
{Y, E}.
</syntaxhighlight>
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
PROGRAM BRESENHAM
Line 1,643 ⟶ 1,686:
SCREEN(0)
END PROGRAM
</syntaxhighlight>
=={{header|Euphoria}}==
{{trans|C}}
<
include std/graphics.e
include std/math.e
Line 1,763 ⟶ 1,805:
--
--,respectively in the last if check.
--*/</
Output:
<pre>
Line 1,785 ⟶ 1,827:
Press Any Key to continue...
</pre>
=={{header|F Sharp|F#}}==
<
let steep = abs(y1 - y0) > abs(x1 - x0)
let x0, y0, x1, y1 =
Line 1,802 ⟶ 1,843:
else
loop (e-dy) (x+1) y
loop (dx/2) x0 y0</
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
Line 1,821 ⟶ 1,862:
BitmapSource.Create(n, n, 1.0, 1.0, format, null, pixel, n)
Window(Content=image, Title="Bresenham's line algorithm")
|> (Application()).Run |> ignore</
=={{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 ;
Line 1,861 ⟶ 1,901:
: draw-line ( {R,G,B} pt1 pt2 image -- )
[ line-points ] dip
[ set-pixel ] curry with each ;</
=={{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.
Line 1,869 ⟶ 1,908:
'''Using pure FBSL's built-in graphics functions:'''
<
#DEFINE WM_CLOSE 16
Line 1,903 ⟶ 1,942:
WEND
END SUB
END SUB</
'''Output:''' [[File:FBSLBresenham.PNG]]
=={{header|Forth}}==
<
defer ystep \ 1+ or 1-
Line 1,954 ⟶ 1,992:
** *
**
ok</
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
{{trans|C}}
<
use RCImageBasic
Line 2,028 ⟶ 2,065:
end subroutine draw_line
end module RCImagePrimitive</
Usage example:
<
use RCImageBasic
use RCImageIO
Line 2,058 ⟶ 2,095:
call free_img(animage)
end program BasicImageTests</
=={{header|FreeBASIC}}==
<
' compile with: fbc -s console
' OR compile with: fbc -s gui
Line 2,099 ⟶ 2,135:
Loop Until InKey <> "" ' loop until a key is pressed
End</
=={{header|Go}}==
<
// Line draws line by Bresenham's algorithm.
Line 2,147 ⟶ 2,182:
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:
Line 2,171 ⟶ 2,206:
fmt.Println(err)
}
}</
=={{header|Haskell}}==
<
import Bitmap
Line 2,206 ⟶ 2,240:
deltax = x2 - x1
deltay = abs $ y2 - y1
ystep = if y1 < y2 then 1 else -1</
=={{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
Line 2,227 ⟶ 2,260:
NB.*drawLines v Draws lines (x) on image (y)
NB. x is: 2-item list (start and end points) ; (color)
drawLines=: (1&{:: ;~ [: ; [: <@getBresenhamLine"2 (0&{::))@[ setPixels ]</
'''Example Usage:'''
<
myimg=: ((1 1 ,: 5 11) ; 255 0 0 ) drawLines myimg NB. draw red line from xy point 1 1 to 11 5
Line 2,238 ⟶ 2,271:
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
viewRGB (Diamond;255 0 0) drawLines (Square;0 0 255) drawLines myimg</
=={{header|Java}}==
<
import java.awt.Dimension;
import java.awt.Graphics;
Line 2,355 ⟶ 2,387:
}
}
}</
=={{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;
Line 2,372 ⟶ 2,403:
if (e2 < dy) { err += dx; y0 += sy; }
}
}</
=={{header|Julia}}==
{{works with|Julia|0.6}}
<
δx = abs(x1 - x0)
δy = abs(y1 - y0)
Line 2,402 ⟶ 2,432:
drawline!(img, 1, 1, 5, 5, Gray(0.0));
println("\nModified image:")
display(img); println()</
{{out}}
Line 2,422 ⟶ 2,452:
Gray{Float64}(255.0) Gray{Float64}(255.0) Gray{Float64}(255.0) Gray{Float64}(255.0) Gray{Float64}(0.0) </pre>
=={{header|
<syntaxhighlight lang="ksh">function line {
typeset x0=$1 y0=$2 x1=$3 y1=$4
if ((
then
((dx = x0 - x1)); ((sx = -1))
Line 2,434 ⟶ 2,463:
fi
if ((
then
((dy = y0 - y1)); ((sy = -1))
Line 2,441 ⟶ 2,470:
fi
if ((
then
((err = dx))
Line 2,449 ⟶ 2,478:
((err /= 2)); ((e2 = 0))
while
do
echo $x0 $y0
((
((e2 = err))
((
((
done
}</
Output from the statement:
line 0 0 3 4
(which could be piped to another program)
<
1 1
1 2
2 3
3 4</
=={{header|Lua}}==
{{trans|C}}
{{works with|Lua 5.1 (or above, tested on: 5.1.5, 5.2.3, 5.3.5)}}
<syntaxhighlight lang="lua">
-----------------------------------------------
-- Bitmap replacement
Line 2,558 ⟶ 2,585:
bitmap:line(60,10,30,20)
bitmap:line(30,20,0,10)
bitmap:render({[0x000000]='.', [0xFFFFFFFF]='X'})</
{{out}}<pre>.............................XXX.............................
..........................XXX...XXX..........................
Line 2,581 ⟶ 2,608:
.............................XXX.............................
</pre>
=={{header|Maple}}==
<
local deltax, deltay, x, y, ystep, steep, err, img2, x02, y02, x12, y12;
x02, x12, y02, y12 := y0, y1, x0, x1;
Line 2,619 ⟶ 2,645:
end do;
return img2;
end proc:</
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
=={{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.]]
<syntaxhighlight lang="matlab">
%screen = Bitmap object
%startPoint = [x0,y0]
Line 2,689 ⟶ 2,713:
assignin('caller',inputname(1),screen); %saves the changes to the object
end
</syntaxhighlight>
Sample Usage:
<syntaxhighlight lang="matlab">
>> img = Bitmap(800,600);
>> img.bresenhamLine([400 550],[200 400],[255 255 255]);
Line 2,701 ⟶ 2,725:
>> img.bresenhamLine([400 550],[400 150],[255 255 255]);
>> disp(img)
</syntaxhighlight>
=={{header|MAXScript}}==
<
(
if steep then
Line 2,756 ⟶ 2,779:
myBitmap = bitmap 512 512 color:(color 0 0 0)
myBitmap = drawLine myBitmap [0, 511] [511, 0] #((color 255 255 255))
display myBitmap</
=={{header|Metal}}==
For drawing lines between points in an Apple Metal compute shader.
<
void drawLine(texture2d<float, access::write> targetTexture, uint2 start, uint2 end)
Line 2,800 ⟶ 2,822:
}
}
}</
=={{header|MiniScript}}==
This GUI implementation is for use with [http://miniscript.org/MiniMicro Mini Micro].
<syntaxhighlight lang="miniscript">
drawLine = function(img, x0, y0, x1, y1, colr)
sign = function(a, b)
if a < b then return 1
return -1
end function
dx = abs(x1 - x0)
sx = sign(x0, x1)
dy = abs(y1 - y0)
sy = sign(y0, y1)
if dx > dy then
err = dx
else
err = -dy
end if
err = floor(err / 2)
while true
img.setPixel x0, y0, colr
if x0 == x1 and y0 == y1 then break
e2 = err
if e2 > -dx then
err -= dy
x0 += sx
end if
if e2 < dy then
err += dx
y0 += sy
end if
end while
end function
img= Image.create(320, 320)
drawLine img, 0, 0, 250, 300, color.red
gfx.clear
gfx.drawImage img, 0, 0
</syntaxhighlight>
=={{header|Nim}}==
<
proc drawLine*(img: Image; p, q: Point; color: Color) =
Line 2,837 ⟶ 2,902:
img.drawLine((15, 7), (7, 0), Black)
img.drawLine((7, 0), (0, 7), Black)
img.print()</
{{out}}
Line 2,856 ⟶ 2,921:
......H.H.......
.......H........</pre>
=={{header|OCaml}}==
<
let steep = abs(y1 - y0) > abs(x1 - x0) in
Line 2,898 ⟶ 2,962:
in
loop x0 y0 error
;;</
=={{header|Pascal}}==
[[Bresenham's_line_algorithm#Delphi | Delphi]]
=={{header|Perl}}==
{{libheader|Imlib2}}
<
use strict;
use Image::Imlib2;
Line 2,970 ⟶ 3,032:
$img->save("test1.png");
exit 0;</
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.
Requires new_image() from [[Bitmap#Phix|Bitmap]], write_ppm() from [[Bitmap/Write_a_PPM_file#Phix|Write_a_PPM_file]]. <br>
Note that demo\rosetta\Bresenham_line.exw is just the last 6 lines below preceded by include ppm.e since that contains bresLine() which is also used by several other examples, and covers the above requirements, as shown commented out. Results may be verified with demo\rosetta\viewppm.exw
<
global function bresLine(sequence image, integer x0, y0, x1, y1, colour)
Line 3,017 ⟶ 3,078:
screenData = bresLine(screenData,200,1,400,150,white)
screenData = bresLine(screenData,195,1,205,300,blue)
write_ppm("bresenham.ppm",screenData)</
=={{header|PicoLisp}}==
<
(let SX
(cond
Line 3,058 ⟶ 3,118:
(prinl "P1")
(prinl 120 " " 90)
(mapc prinl Img) ) )</
=={{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.}}
<syntaxhighlight lang="pl/i">
/* Draw a line from (x0, y0) to (x1, y1). 13 May 2010 */
/* Based on Rosetta code proforma. */
Line 3,100 ⟶ 3,159:
end draw_line;
</syntaxhighlight>
Output from the statement:-
call draw_line(-1, -3, 6, 10);
for a -10:10 x -10:10 grid:
<syntaxhighlight lang="text">
..........|..........
..........|..........
Line 3,127 ⟶ 3,186:
..........|..........
..........|..........
</syntaxhighlight>
===version 2===
<
brbn:Proc Options(main);
/*********************************************************************
Line 3,180 ⟶ 3,239:
image(x0,y0)='X';
end;
end;</
'''output'''
<pre>11 ..|.......
Line 3,199 ⟶ 3,258:
-4 ..|.......
2101234567</pre>
=={{header|Prolog}}==
<syntaxhighlight lang="prolog">
:- use_module(bitmap).
:- use_module(bitmapIO).
Line 3,240 ⟶ 3,298:
draw_line(NB,B,[0,0,0],2,2,10,90),
write_ppm_p6('line.ppm',NB).
</syntaxhighlight>
=={{header|PureBasic}}==
<
If Abs(y1 - y0) > Abs(x1 - x0);
steep =#True
Line 3,301 ⟶ 3,358:
Until Event = #PB_Event_CloseWindow
EndIf
EndIf</
=={{header|Python}}==
{{works with|Python|3.1}}
Line 3,308 ⟶ 3,364:
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)
Line 3,365 ⟶ 3,421:
| |
+-----------------+
'''</
===Not relying on floats===
Extending the example given [[Basic_bitmap_storage/Python#Alternative_version|here]].
<
from fractions import Fraction
Line 3,387 ⟶ 3,443:
# see test code above
</syntaxhighlight>
=={{header|Racket}}==
Port of the Python version.
<
#lang racket
(require racket/draw)
Line 3,425 ⟶ 3,480:
(apply draw-line (cons dc points)))
bm
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|2018.03}}
Bitmap class from [[Bitmap#Raku|Bitmap]] task.
<syntaxhighlight lang="raku"
class Bitmap {
has UInt ($.width, $.height);
Line 3,482 ⟶ 3,536:
}
}
}</
=={{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)
Line 3,522 ⟶ 3,575:
END IF
END SUB</
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
END SUB</
=={{header|REXX}}==
=== version 1 ===
Line 3,539 ⟶ 3,591:
<br>command line, displays a (background) plot field, uses an infinite field, and
it also handles multiple line segments.
<
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.*/
Line 3,578 ⟶ 3,630:
if err2 > -dy then do; err= err - dy; x= x + sx; end
if err2 < dx then do; err= err + dx; y= y + sy; end
end /*forever*/</
{{out|output|text= when using the default input:}}
<pre>
Line 3,604 ⟶ 3,656:
=== version 2 ===
<
* 21.05.2014 Walter Pachl
* Implementing the pseudo code of
Line 3,647 ⟶ 3,699:
end
end
Return</
'''output'''
<pre>11 ..|.......
Line 3,666 ⟶ 3,718:
-4 ..|.......
2101234567</pre>
=={{header|Ring}}==
<
load "guilib.ring"
load "stdlib.ring"
Line 3,725 ⟶ 3,776:
}
label1 { setpicture(p1) show() }
</syntaxhighlight>
Output :
[https://lh3.googleusercontent.com/-6uJvON0dAuo/V2LO2zz4zQI/AAAAAAAAALE/IjEGFuhta6oUSeG2QfuxcPBWMmCyNCjdwCLcB/s1600/CalmoSoftBresenham.jpg Bitmap/Bresenham's algorithm]
=={{header|Ruby}}==
<
class Pixmap
Line 3,777 ⟶ 3,827:
bitmap.draw_line(Pixel[10, 10], Pixel[a,490], RGBColour::YELLOW)
end
bitmap.draw_line(Pixel[10, 10], Pixel[490,490], RGBColour::YELLOW)</
=={{header|Rust}}==
<syntaxhighlight lang="rust">
struct Point {
x: i32,
Line 3,787 ⟶ 3,836:
fn main() {
let
points.append(&mut get_coordinates(1, 20, 20, 28));
points.append(&mut get_coordinates(20, 28, 69, 0));
draw_line(points, 70, 30);
}
fn get_coordinates(x1: i32, y1: i32, x2: i32, y2: i32) -> Vec<Point> {
let mut coordinates: Vec<Point> = vec![];
let dx:i32 = i32::abs(x2 - x1);
let dy:i32 = i32::abs(y2 - y1);
let sx:i32 = { if x1 < x2 { 1 } else { -1 } };
let sy:i32 = { if
let mut error:i32 = (if dx > dy { dx } else { -dy }) / 2 ;
let mut current_x:i32 = x1;
let mut current_y:i32 = y1;
loop {
coordinates.push(Point { x : current_x, y: current_y });
if
let error2:i32 = error;
if error2 > -dx {
error -= dy;
current_x += sx;
}
error
current_y += sy;
}
}
Line 3,833 ⟶ 3,876:
let is_point_in_line = line.iter().any(| point| point.x == row && point.y == col);
match is_point_in_line {
true => print!("
_ =>
};
}
Line 3,846 ⟶ 3,883:
}
}
</syntaxhighlight>
'''Output:'''
<pre>
.....................................................................@
......................................................................
</pre>
=={{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)
Line 3,906 ⟶ 3,942:
bm.setPixel(x, y, c)
}
}</
=={{header|Sidef}}==
{{trans|Perl}}
<
var steep = (abs(y1 - y0) > abs(x1 - x0))
Line 3,962 ⟶ 3,997:
img.draw_line(80, 10, 10, 80)
img.save("test1.png")</
=={{header|SparForte}}==
As a structured script.
<syntaxhighlight lang="ada">#!/usr/local/bin/spar
pragma annotate( summary, "DrawLine" )
@( description, "Draw a line given 2 points with the Bresenham's algorithm." )
@( see_also, "http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm" )
@( author, "Ken O. Burtch" );
pragma license( unrestricted );
pragma restriction( no_external_commands );
procedure drawline is
-- Spar 1.x has only single-dimensional arrays but we can simulate a
-- two dimensional array that has been folded into a 1D array
width : constant positive := 20;
height : constant positive := 20;
type image_array is array(1..400) of character;
Picture : image_array;
-- Line
-- Draw a line between two coordinates using the given character
procedure Line ( Start_X : positive; Start_Y : positive; Stop_X : positive; Stop_Y : positive; Color : character) is
-- at this point, formal parameters are defined but the actual values aren't defined!
-- but creating a dummy Line in a test script works?
DX : constant float := abs( float( Stop_X ) - float( Start_X ) );
DY : constant float := abs( float( Stop_Y ) - float( Start_Y ) );
Err : float;
X : positive := Start_X;
Y : positive := Start_Y;
Step_X : integer := 1;
Step_Y : integer := 1;
begin
if Start_X > Stop_X then
Step_X := -1;
end if;
if Start_Y > Stop_Y then
Step_Y := -1;
end if;
if DX > DY then
Err := DX / 2.0;
while X /= Stop_X loop
Picture (X + width*(Y-1)) := Color;
Err := @ - DY;
if Err < 0.0 then
Y := positive( integer(@) + Step_Y);
Err := @ + DX;
end if;
X := positive( integer(@) + Step_X );
end loop;
else
Err := DY / 2.0;
while Y /= Stop_Y loop
Picture (X + height*(Y-1)) := Color;
Err := @ - DX;
if Err < 0.0 then
X := positive( integer(@) + Step_X );
Err := @ + DY;
end if;
Y := positive( integer(@) + Step_Y );
end loop;
end if;
Picture (X + width*(Y-1)) := Color;
end Line;
-- new_picture
-- Erase the picture by filling it with spaces.
procedure new_picture is
begin
for i in arrays.first( Picture )..arrays.last( Picture ) loop
Picture(i) := ' ';
end loop;
end new_picture;
-- render
-- Draw the contents of the picture area.
procedure render is
begin
for i in arrays.first( Picture )..arrays.last( Picture ) loop
put( Picture(i) );
if i mod width = 0 then
new_line;
end if;
end loop;
end render;
begin
new_picture;
Line( 1, 8, 8, 16, 'X' );
Line( 8,16,16, 8, 'X' );
Line(16, 8, 8, 1, 'X' );
Line( 8, 1, 1, 8, 'X' );
render;
end drawline;</syntaxhighlight>
=={{header|Tcl}}==
{{libheader|Tk}}
ref [[Basic bitmap storage#Tcl]]
<
package require Tk
Line 4,005 ⟶ 4,141:
fill $img black
drawLine $img yellow {20 20} {180 80}
drawLine $img yellow {180 20} {20 80}</
=={{header|TI-89 BASIC}}==
Line 4,013 ⟶ 4,148:
{{trans|E}}
<
Prgm
Local steep, x, y, dx, dy, ystep, error, tmp
Line 4,046 ⟶ 4,181:
EndIf
EndFor
EndPrgm</
=={{header|VBScript}}==
{{trans|Rexx}}
<
Dim map(48,40), list(10), ox, oy
data=Array(1,8, 8,16, 16,8, 8,1, 1,8)
Line 4,102 ⟶ 4,236:
If err2< dx Then err=err+dx: y=y+sy
Loop
End Sub 'draw_line </
{{out}}
<pre>
Line 4,126 ⟶ 4,260:
...|....................
</pre>
=={{header|Vedit macro language}}==
<
// #1=x1, #2=y1; #3=x2, #4=y2
Line 4,167 ⟶ 4,300:
}
Num_Pop(31,35)
return</
=={{header|Wart}}==
<
def (line x0 y0 x1 y1)
let steep ((> abs) y1-y0 x1-x0)
Line 4,191 ⟶ 4,323:
when (error < 0)
y += ystep
error += deltax</
=={{header|Wren}}==
{{libheader|DOME}}
Requires version 1.3.0 of DOME or later.
<
import "dome" for Window
Line 4,252 ⟶ 4,383:
static draw(alpha) {}
}</
=={{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
Line 4,262 ⟶ 4,393:
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);
Line 4,273 ⟶ 4,403:
ppm.line(100,10, 50,100, 0);
ppm.writeJPGFile("line.jpg");</
<
fcn init(width,height,rgb=0){
sz:=width*height;
Line 4,363 ⟶ 4,493:
}
}
}</
{{omit from|AWK}}
{{omit from|PARI/GP}}
|