Bitmap/Midpoint circle algorithm: Difference between revisions

{{task|Raster graphics operations}}

 

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

<br><br>

=={{header|11l}}==

{{trans|Python}}

 

Byte r, g, b

 

V bitmap = Bitmap(25, 25)

bitmap.circle(x0' 12, y0' 12, radius' 12)

 

{{out}}

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

</pre>

=={{header|Action!}}==

Part of the task is available in [http://www.rosettacode.org/wiki/Category:Action!_Bitmap_tools#RGBCIRCL.ACT RGBCIRCL.ACT].

{{libheader|Action! Bitmap tools}}

 

RGB black,yellow,violet,blue

DO UNTIL CH#$FF OD

CH=$FF

{{out}}

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

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

 

</pre>

=={{header|ALGOL 68}}==

{{trans|Ada}}

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

</pre>

=={{header|Applesoft BASIC}}==

330 COLOR= 15:CX = 20:CY = 20:R = 18: GOSUB 350"CIRCLE"

340 COLOR= 0:CX = 15:CY = 15:R = 6

350 F = 1 - R:X = 0:Y = R:DX = 0:DY = - 2 * R: PLOT CX,CY + R: PLOT CX,CY - R: HLIN CX - R,CX + R AT CY: IF X > = Y THEN RETURN

360 FOR I = 0 TO 1: IF F > = 0 THEN Y = Y - 1:DY = DY + 2:F = F + DY

=={{header|bash}}==

# Based on https://en.wikipedia.org/wiki/Midpoint_circle_algorithm

 

drawcircle 13 13 11

echo -en "\e[H"

{{Out}}

<pre>------#########------

------#########------</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

=={{header|C}}==

 

Interface:

 

image img,

unsigned int x0,

color_component r,

color_component g,

 

Implementation:

 

 

void raster_circle(

}

}

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

 

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>

nil

</pre>

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

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

(( )

( ))

</pre>

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

' compile with: fbc -s gui

 

WindowTitle "hit any key to end program"

Sleep

=={{header|FutureBasic}}==

FB has native functions that handle bitmap calculations. This compiles as a stand-alone Macintosh app that allows the user to adjust the screen-centered bitmap width from a single pixel to a large circle.

_wndW = 600

_wndH = 600

 

HandleEvents

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

=={{header|Java}}==

 

import java.awt.Color;

 

 

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

int x = 0;

int y = radius;

}

}

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

x = radius - 1

y = 0

 

img = fill(Gray(255.0), 25, 25);

 

=={{header|Lua}}==

Uses Bitmap class [[Bitmap#Lua|here]], with an ASCII pixel representation, then extending..

local dx, dy, err = r, 0, 1-r

while dx >= dy do

end

end

Demo:

local hw, hh = math.floor(self.width/2), math.floor(self.height/2)

for i = 0, self.width-1 do self:set(i,hh,"-") end

bitmap:circle(12, 12, 5, "■")

bitmap:circle(12, 12, 2, "■")

{{out}}

<pre>· · · · · · · · · · · · | · · · · · · · · · · · ·

· · · · · · · · · ■ ■ ■ ■ ■ ■ ■ · · · · · · · · ·

· · · · · · · · · · · · | · · · · · · · · · · · ·</pre>

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

=={{header|Nim}}==

{{trans|Ada}}

 

proc setPixel(img: Image; x, y: int; color: Color) {.inline.} =

img.fill(White)

img.drawCircle((7, 7), 5, Black)

 

{{out}}

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

 

=={{header|Perl}}==

 

use strict;

for (@circle) { $points[$_->[0]][$_->[1]] = '#' }

 

{{out}}

<pre>

#######

</pre>

=={{header|Phix}}==

{{Trans|Go}}

Requires new_image() from [[Bitmap#Phix|Bitmap]], write_ppm() from [[Bitmap/Write_a_PPM_file#Phix|Write_a_PPM_file]]. <br>

Results may be verified with demo\rosetta\viewppm.exw

include ppm.e -- red, yellow, new_image(), write_ppm() -- (covers above requirements)

 

sequence img = new_image(400,300,yellow)

img = Circle(img, 200, 150, 100, red)

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

(formerly Perl 6)

We'll augment the Pixel and Bitmap classes from the [[Bitmap#Raku|Bitmap]] task.

 

 

class Pixel { has UInt ($.R, $.G, $.B) }

$b.fill( Pixel.new( R => 0, G => 0, B => 0) );

$b.raster-circle(16, 16, 15, Pixel.new(R=>0, G=>0, B=>100));

=={{header|REXX}}==

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

 

The program automatically shows all of the plot's points by finding the minimum and maximum &nbsp; '''X''','''Y''' &nbsp; coördinates.

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

minX= 0; maxX= 0; minY= 0; maxY= 0 /*initialize the minimums and maximums.*/

minX= min(minX,c); maxX= max(maxX,c) /*determine the minimum and maximum X.*/

minY= min(minY,r); maxY= max(maxY,r) /* " " " " " Y.*/

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

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

{{trans|Kotlin}}

{{libheader|DOME}}

import "dome" for Window

 

}

 

 

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

{{omit from|PARI/GP}}