Bitmap/Midpoint circle algorithm: Difference between revisions

([[wp:Midpoint_circle_algorithm|definition on Wikipedia]]).

 

=={{header|Ada}}==

( Picture : in out Image;

Center : Point;

Picture (Center.X - Y, Center.Y - X) := Color;

end loop;

The following illustrates use:

begin

Fill (X, White);

Circle (X, (8, 8), 5, Black);

{{out}}

<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''.}}

 

circle OF class image :=

END # circle #;

 

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

(circle OF class image)(x, (8, 8), 5, (black OF class image));

(print OF class image)(x)

{{out}}

<pre>

ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff

</pre>

clg

color red

end while

return 0

{{Out}}

[http://s16.postimg.org/ge0ndfs9h/Output.jpg http://s16.postimg.org/ge0ndfs9h/Output.jpg]

 

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

setlocal enabledelayedexpansion

 

goto circle_loop

)

{{Out}}

<pre> █ █

███████

</pre>

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

{{works with|BBC BASIC for Windows}}

[[Image:circle_bbc.gif|right]]

Height% = 200

GCOL 1

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

 

Interface:

 

image img,

unsigned int x0,

color_component r,

color_component g,

 

Implementation:

 

 

void raster_circle(

}

}

 

This extension method extends GenericImage which is very similar to [http://rosettacode.org/wiki/Bitmap#C.23 Bitmap] but instead of using a SetPixel method it uses a "Color this[int x, int y] { get; set; }" property to get and set pixels.

 

/// <summary>

/// Draws a circle.

} while (x <= y);

}

=={{header|Clojure}}==

Based upon the Common Lisp version.

(letfn [(put [x y m]

(let [x+ (+ x0 x)

y

(+ m 4 (* 8 x)))))))]

(letfn [(draw-fn [x y]

(swap! circle-points #(conj % [x y])))]

@circle-points)]

(doseq [line grid]

<pre>

Based upon the OCaml version.

 

(labels ((foo (x y)

(funcall draw-function x y))

(+ m 4 (* 8 x))))))))

(put 0 radius (- 5 (* 4 radius)))

:element-type 'bit)))

(draw-circle (lambda (x y)

(setf (bit buffer x y) 1)) 15 15 10)

<pre>;; edited for your convenience

(( )

=={{header|D}}==

Uses the bitmap module from the Bitmap Task.

 

void circle(Color)(Image!Color img, in int x0, in int y0,

circle(img, 12, 12, 12, RGB.black);

img.textualShow;

{{out}}

<pre>.........#######.........

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

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

 

=={{header|ERRE}}==

 

!$INCLUDE="PC.LIB"

BCircle(100,100,80)

END PROGRAM

 

=={{header|FBSL}}==

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

#DEFINE WM_CLOSE 16

 

WEND

END SUB

'''Ouptut:''' [[File:FBSLMidpoint.PNG]]

=={{header|Forth}}==

1 r - 0 r 2* negate 0 r { f ddx ddy dx dy }

color x y r + bmp b!

0 test bfill

6 6 5 blue test circle

=={{header|Fortran}}==

 

This code should be inside <tt>RCImagePrimitive</tt> (see [[Bresenham's line algorithm#Fortran|here]]). The private subroutine <code>draw_circle_toch</code>, which writes to a ''channel'', is used by both <code>draw_circle_rgb</code> and <code>draw_circle_sc</code> and the interface allows to use <code>draw_circle</code> with ''[[Basic bitmap storage#Fortran|rgb]]'' images and [[Grayscale image#Fortran|grayscale images]].

 

module procedure draw_circle_sc, draw_circle_rgb

end interface

 

 

integer, dimension(:,:), intent(out) :: ch

type(point), intent(in) :: p

call draw_circle_toch(img%channel, c, radius, lum)

=={{header|FreeBASIC}}==

 

Sub circle_(x0 As Integer, y0 As Integer , radius As Integer, Col As Integer)

 

 

End Sub

 

' ------=< MAIN >=------

Dim As Integer w, h, depth

Randomize Timer

ScreenInfo w, h

 

Next

 

 

' empty keyboard buffer

Sleep

 

=={{header|Go}}==

This produces identical results to the C code in the WP article, but with more compact code.

 

// Circle plots a circle with center x, y and radius r.

func (b *Bitmap) CircleRgb(x, y, r int, c Rgb) {

b.Circle(x, y, r, c.Pixel())

Demonstration program:

 

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

fmt.Println(err)

}

=={{header|Haskell}}==

The basic algorithm can be implemented generically.

 

import Data.List

ddf_x' = ddf_x + 2

x' = x + 1

An example using regular 2d arrays of characters to represent a bitmap:

 

import Circle

-- Converts a surface to a string and prints it

printSurface = putStrLn . showSurface

Using the Image type from the Bitmap module defined [[Basic_bitmap_storage|here]]:

 

import Circle

forM_ pixels $ \pixel -> setPix image pixel colour

return image

=={{header|J}}==

'''Solution:'''<br>

Using definitions from [[Basic bitmap storage#J|Basic bitmap storage]]. (Note that viewRGB is at the bottom of the entry - separate from the rest of the definitions.)

NB. y is: y0 x0 radius

getBresenhamCircle=: monad define

NB.*drawCircles v Draws circle(s) (x) on image (y)

NB. x is: 2-item list of boxed (y0 x0 radius) ; (color)

 

'''Example usage:'''

myimg=: (12 12 12 ; 255 0 0) drawCircles myimg NB. draw red circle with radius 12

 

import java.awt.Color;

 

 

private void drawCircle(final int centerX, final int centerY, final int radius) {

int x = 0;

int y = radius;

}

}

 

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

drawcircle[img_, {x0_, y0_}, r_, color_: White] :=

Module[{f = 1 - r, ddfx = 1, ddfy = -2 r, x = 0, y = r,

pixels = Join[pixels, {{x, y}, {x, -y}, {-x, y}, {-x, -y},

{y, x}, {y, -x}, {-y, x}, {-y, -x}}]];

Example usage（it will draw a circle on Lena's face.）:

=={{header|Modula-3}}==

 

IMPORT Bitmap;

color: Bitmap.Pixel);

 

 

IMPORT Bitmap;

 

BEGIN

 

Example (outputs a [[Write_ppm_file | PPM]] image):

 

IMPORT Circle, Bitmap, PPM;

Circle.Draw(testpic, Bitmap.Point{16, 16}, 10, Bitmap.Black);

PPM.Create("testpic.ppm", testpic);

 

 

 

 

let plot = put_pixel img color in

let x = 0

in

loop x y m

 

=={{header|Phix}}==

{{Trans|Go}}

 

and y>=1 and y<=length(img[x]) then

img[x][y] = colour

end function

 

if r>=0 then

-- Bresenham algorithm

 

sequence img = new_image(400,300,yellow)

=={{header|PicoLisp}}==

(let (F (- 1 Rad) DdFx 0 DdFy (* -2 Rad) X 0 Y Rad)

(set (nth Img (+ CY Rad) CX) 1)

(prinl "P1")

(prinl 120 " " 120)

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

/* Plot three circles. */

 

 

END CIRCLE;

{{out}} for three circles centered at the origin.

<pre>

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

</pre>

=={{header|PureBasic}}==

;circle must lie completely within the image boundaries

Protected f= 1 - r

ImageGadget(0, 0, 0, 0, 0, ImageID(0))

 

=={{header|Python}}==

{{works with|Python|3.1}}

 

Extending the example given [[Basic_bitmap_storage#Alternative_version|here]]

f = 1 - radius

ddf_x = 1

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

'''

=={{header|Racket}}==

Port of the Pyhton solution.

 

#lang racket

(require racket/draw)

(draw-circle dc 12 12 12)

bm

 

=={{header|REXX}}==

Programming note: &nbsp; because of character output to a terminal screen, a circle appears to be elongated in the

<br>a good aspect ratio.

 

@.= '·' /*fill the array with middle─dots char.*/

call drawCircle 0, 0, 8, '#' /*plot 1st circle with pound character.*/

call drawCircle 0, 0, 11, '$' /* " 2nd " " dollar " */

call drawCircle 0, 0, 19, '@' /* " 3rd " " commercial at. */

/*define the plot's horizontal grid──┐ */

/*define the plot's vertical grid───┘ */

do y=maxY by -1 to minY; _= /* [↓] draw grid from top ──► bottom.*/

end /*x*/ /* [↑] a grid row should be finished. */

say _ /*display a single row of the grid. */

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

drawCircle: procedure expose @. minX maxX minY maxY

return

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

<pre>

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

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

</pre>

=={{header|Ruby}}==

 

class Pixmap

 

bitmap = Pixmap.new(30, 30)

=={{header|Scala}}==

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

def midpoint(bm:RgbBitmap, x0:Int, y0:Int, radius:Int, c:Color)={

var f=1-radius

}

}

=={{header|Tcl}}==

{{libheader|Tk}}

ref [[Basic bitmap storage#Tcl]] and [[Assertions#Tcl]]

package require Tk

 

fill $img black

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

// Draw a circle using Bresenham's circle algorithm.

// #21 = center x, #22 = center y; #23 = radius

 

return

 

=={{header|XPL0}}==

 

proc Circle(X0, Y0, Radius, Color); \Display a circle

if ChIn(1) then []; \wait for keystroke

SetVid(3); \restore normal text mode

=={{header|zkl}}==

Image cribbed from the BBC BASIC entry. Algorithm from Wikipedia article.<br/>

[[Image:circle_bbc.gif|right]]

This is the code from the PPM class:

x:=r; y:=0; radiusError:=1-x;

while(x >= y){

else{ x-=1; radiusError+=2*(y - x + 1); }

}

ppm.circle(100,100,40,00); // black circle

ppm.circle(100,100,80,0xFF|00|00); // red circle

 

{{omit from|PARI/GP}}