Xiaolin Wu's line algorithm: Difference between revisions

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

 

REAL one

DO UNTIL CH#$FF OD

CH=$FF

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Xiaolin_Wu's_line_algorithm.png Screenshot from Atari 8-bit computer]

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

FBVARSCinfo_fin:

 

 

=={{header|AutoHotkey}}==

{{libheader|GDIP}}

#NoEnv

SetBatchLines, -1

DllCall("msvcrt\_i64to" U, "Int64",n, "Str",S, "Int",Base)

return, S

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

END

GCOL 1

LINE X%*2, Y%*2, X%*2, Y%*2

 

=={{header|C}}==

This implementation follows straightforwardly the pseudocode given on Wikipedia. (Further analysis of the code could give suggestions for improvements).

 

image img,

unsigned int x0, unsigned int y0,

color_component r,

color_component g,

 

rgb_color_p to, float br)

{

#undef round_

#undef rfpart_

 

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

 

#include <functional>

#include <algorithm>

}

}

 

=={{header|C#}}==

public class Line

{

}

}

 

=={{header|D}}==

{{trans|Go}}

This performs the mixing of the colors, both in grey scale and RGB.

 

/// Plots anti-aliased line by Xiaolin Wu's line algorithm.

im2.aaLine(177.4, 12.3, 127, 222.5, red);

im2.savePPM6("xiaolin_lines2.ppm");

 

=={{header|FreeBASIC}}==

Only changed xend=round() in xend=ipart() to make it more in line with FreeBASIC's own line drawing routine. Rfpart give me some trouble so I changed if somewhat.

The small functions where all converted into macro's

' compile with: fbc -s console or fbc -s gui

' Xiaolin Wu’s line-drawing algorithm

While Inkey <> "" : Wend

Sleep

 

=={{header|Go}}==

 

import "math"

intery = intery + gradient

}

Demonstration program:

 

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

g.AaLine(177.4, 12.3, 127, 222.5)

g.Bitmap().WritePpmFile("wu.ppm")

 

=={{header|Haskell}}==

Example makes use of [http://hackage.haskell.org/package/JuicyPixels <tt>JuicyPixels</tt>] for serialization to PNG format and and [http://hackage.haskell.org/package/primitive <tt>primitive</tt>] to abstract away memory-related operations. This is a fairly close translation of the algorithm as described on [https://en.wikipedia.org/wiki/Xiaolin_Wu%27s_line_algorithm Wikipedia]:

 

 

module Main (main) where

 

-- Write it out to a file on disc

 

Building and running this program will generate an output PNG file named <code>xiaolin-wu-algorithm.png</code> showing a white antialiased diagonal line.

=={{header|J}}==

'''Solution:'''

coinsert'jgl2'

 

weights=. ((2&}.,~ xgap*2&{.)&.(_1&|.) (,.~-.) 1|ylist)

weights (drawpt r)"1 2 (,:+&0 1)"1 xlist,.<.ylist

 

'''Example use:'''

wd'pc win closeok; minwh 600 400;cc g isidraw flush; pshow;' NB. J802 or later

glpaint glclear ''

 

=={{header|Java}}==

[[File:xiaolinwu_java.png|200px|thumb|right]]

{{works with|Java|8}}

import static java.lang.Math.*;

import javax.swing.*;

});

}

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

fpart(x) = mod(x, one(x))

 

img = fill(Gray(1.0N0f8), 250, 250);

 

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.awt.*

f.isVisible = true

}

 

=={{header|Liberty BASIC}}==

NoMainWin

WindowWidth = 270

Loop

End Function

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

ReverseFractionalPart[x_] := 1 - FractionalPart[x]

ReplacePixelWithAlpha[img_Image, pos_ -> colvals : {_, _, _},

]

image = ConstantImage[Black, {100, 100}];

 

=={{header|Nim}}==

Simple translation of the Wikipedia algorithm.

import imageman

 

for x1 in countup(100, 700, 60):

img.drawLine(400, 700, x1.toFloat, 100)

 

=={{header|Pascal}}==

Based on Wikipwdia pseudocode with some optimizations and alpha handling.

 

program wu;

uses

until false;

end.

 

=={{header|Perl}}==

This is mostly a translation of the pseudo-code on Wikipedia, except that the <code>$plot</code> trick was inspired by the Raku example.

use strict;

use warnings;

}

__END__

{{out}}

<pre>plot 0 1 0.5

{{libheader|Phix/online}}

You can run this online [http://phix.x10.mx/p2js/wuline.htm here], with caveats as below. Resize the window to show lines at any angle

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\XiaolinWuLine.exw

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

 

=={{header|PicoLisp}}==

 

(de plot (Img X Y C)

(prinl 120 " " 90)

(prinl 100)

 

=={{header|PureBasic}}==

Plot(x, y, RGB(Red(Color) * (b), Green(Color) * (b), Blue(Color) * (b)))

EndMacro

Repeat

event = WaitWindowEvent()

 

=={{header|Python}}==

algorithm

 

filename = sys.argv[1]

img.save(filename)

 

=={{header|Racket}}==

 

(require 2htdp/image)

 

img-2

(save-image img-1 "images/xiaolin-wu-racket-1.png")

 

Output files:

=={{header|Raku}}==

(formerly Perl 6)

sub fpart(\x) { x - floor(x) }

}

 

{{out}}

<pre>plot 0 1 1

<br>Also, it takes in account (that can easily be overlooked) of the note after the description of the algorithm:

<br>'''Note''': &nbsp; If at the beginning of the routine &nbsp; abs(''dx'') < abs(''dy'') &nbsp; is true, then all plotting should be done with &nbsp; '''x''' &nbsp; and &nbsp; '''y''' &nbsp; reversed.

background= '·' /*background character: a middle-dot. */

image.= background /*fill the array with middle-dots. */

plotXY: parse arg xx,yy,bc,switchYX; if switchYX then parse arg yy,xx

image.xx.yy=bc; minX=min(minX, xx); maxX=max(maxX,xx)

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

=={{header|Ruby}}==

{{trans|Tcl}}

def fpart(n); n - ipart(n); end

def rfpart(n); 1.0 - fpart(n); end

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

end

 

=={{header|Scala}}==

Uses [[Bitmap#Scala]].

import math.{floor => ipart, round, abs}

 

intery = intery + gradient

}

'''Example:'''

 

Test line drawing in various directions including vertical, horizontal, 45° and oblique (such lines are drawn multiple times to test swapped parameters).

val img = new RgbBitmap(r*2+1, r*2+1)

val line = drawLine(plotter(img, Color.GRAY)_)_

line(a, b)

}

{{out}}

View the PNG, available at the following URL because RosettaCode image uploads were disabled:

=={{header|Sidef}}==

{{trans|Perl}}

c && printf("plot %d %d %.1f\n", x, y, c);

}

}

 

{{out}}

<pre>

 

=={{header|Swift}}==

// apply pixel of color at x,y with an OVER blend to the bitmap

public func pixel(color: Color, x: Int, y: Int) {

}

}

 

=={{header|Tcl}}==

{{libheader|Tk}}

Uses code from [[Basic bitmap storage#Tcl]]

package require Tk

 

toplevel .wu

label .wu.l -image $img

 

=={{header|Wren}}==

{{trans|Kotlin}}

{{libheader|DOME}}

import "dome" for Window

import "math" for Math

}

 

 

=={{header|Yabasic}}==

{{trans|Phix}}

rB = 255 : gB = 255 : bB = 224

draw_line(w, 0, 200, 200)

draw_line(0, h, 200, 200)

 

[[Category:Geometry]]