Draw a sphere: Difference between revisions

{{trans|Python}}

 

 

F dotp(v1, v2)

V light = normalize((30.0, 30.0, -50.0))

draw_sphere(20, 4, 0.1, light)

 

{{out}}

 

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

0 4 9 13 18 22 27 31 36 40 44 49 53 58 62 66 71 75 79 83

88 92 96 100 104 108 112 116 120 124 128 132 136 139 143

DO UNTIL CH#$FF OD

CH=$FF

{{out}}

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

Uses the Cairo component of GtkAda to create and save as png

[[File:SphereAda.png|thumb|right]]

with Cairo; use Cairo;

with Cairo.Png; use Cairo.Png;

Status_Out := Write_To_Png (Surface, "SphereAda.png");

pragma Assert (Status_Out = Cairo_Status_Success);

 

{{libheader|Display}}

This uses a very loose binding to SDL as found in any GPS installation. For it to work, you must choose New Project From Templte|Empty Game

 

with Display; use Display;

with Display.Basic; use Display.Basic;

null;

end Main;

 

=={{header|ALGOL W}}==

{{Trans|AWK}} with some changes inspired by other samples.

% draw a sphere %

% returns the next integer larger than x or x if x is an integer %

drawSphere( 10, 2, 0.4, light, ".:!*oe#%&@" )

end test

{{out}}

<pre>

 

=={{header|ATS}}==

(*

** Solution to Draw_a_sphere.dats

 

(* ****** ****** *)

 

=={{header|AutoHotkey}}==

{{libheader|GDIP}}

SetBatchLines, -1

#SingleInstance, Force

; gdi+ may now be shutdown on exiting the program

Gdip_Shutdown(pToken)

 

=={{header|AWK}}==

# syntax: GAWK -f DRAW_A_SPHERE.AWK

# converted from VBSCRIPT

return(n)

}

{{out}}

<pre>

This is based, but not exactly, on the [http://rosettacode.org/wiki/Draw_a_sphere#Tcl Tcl] implementation.

Thus, the output is almost the same to the output of Tcl implementation below.

color white

rect 0,0,graphwidth, graphheight

color rgb(2*n,2*n,2*n)

circle 150-2*n/3,150-n/2,150-n

 

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

{{works with|BBC BASIC for Windows}}

Using Direct3D.

INSTALL @lib$+"D3DLIB"

D3DTS_VIEW = 2

SYS "FreeLibrary", d3dx%

END

{{out}}

[[File:Sphere_BBC.jpeg]]

Some simple 3D objects are built into DarkBASIC. Creating a sphere only takes 1 line:

 

 

==={{header|FreeBASIC}}===

' "/" = a floating point division (FPU)

' the compiler takes care of the conversion between floating point and integer

Print : Print "hit any key to end program"

Sleep

{{works with|FreeBASIC}}

needs #Lang "fblite", #Lang "qb" or #Lang "deprecated" to compile.

'spherefb4.bas

'Sphere using XPL0 code from rosetacode sphere page

Print "Enter any key to exit "

sleep

 

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

WindowWidth =420

WindowHeight =460

close #w

end

 

==={{header|Locomotive Basic}}===

Translated from ERRE version, this will print a 39x20 text sphere onscreen.

The variables in line 80 can be used to adjust size (r), spotlight (k), reflective light (ambient).

10 MODE 2:s$=".:!*oe&#%@"

20 DIM v(2),vec(2)

3010 IF d<0 THEN d=-d ELSE d=0

3020 RETURN

 

==={{header|PureBasic}}===

3D Sphere animation.

;

; Updated/Formated by Fluid Byte @ March.24,2009

SetMeshData(0,#PB_Mesh_Face,*IBuffer,Length)

[[image:PB_Animated_sphere.png]]

 

===[[QBasic]]===

 

 

' sets palette colors B/N

' wait until keypress

DO: LOOP WHILE INKEY$ = ""

 

==={{header|Run BASIC}}===

'runbasic.com

graphic #win, 300, 300

next X

next Y

 

graphic #g, 300, 300 'create a graphic object

#g place(100,100) 'place the drawing pen at 100,100

#g circle(75) 'make a circle with radius 75

 

==={{header|Sinclair ZX81 BASIC}}===

Works with 1k of RAM. A screenshot of the output is [http://www.edmundgriffiths.com/zx81sphere.jpg here].

20 LET J=2

30 FOR K=-PI TO PI STEP 0.07

70 LET I=I-J

80 LET J=J+1

 

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

Since Batch Files do not support floating point, the input parameters for drawing the sphere are limited to integers only. The ''k'' parameter has been hardcoded to 2. The <code>ambient</code> variable for this code is scaled up 10 times of its value in C implementation. For example, <code>ambient = 0.1</code> in C code corresponds to <code>ambient = 1</code> here.

Lastly, the variables used in calculations are scaled up 100 times of the actual values in C implementation, and then scaled down 100 times back for determination of shades.

:: Batch File Implementation

rem more info: https://www.dostips.com/forum/viewtopic.php?f=3&t=6744

 

rem source: https://www.dostips.com/forum/viewtopic.php?f=3&t=5819&start=30#p44016

set "sqrt(N)=( M=(N),j=M/(11*1024)+40, j=(M/j+j)>>1, j=(M/j+j)>>1, j=(M/j+j)>>1, j=(M/j+j)>>1, j=(M/j+j)>>1, j+=(M-j*j)>>31 )"

set /a "sqrdR=R*R*100*100" %== R*R is mult. by 100*100 ==%

set "k=2" %== k is hardcoded to 2 ==%

rem start draw line-by-line

for /l %%i in (%negR%, 1, %R%) do (

echo(!line!

)

{{Out}}

<pre> eeeeeeeeee&&&&&##

Also note that the z-coordinate of the light vector is negated at runtime to more closely match the C defaults. This is preferable to making the initial constant negative since negative data values aren't supported across all Befunge implementations.

 

>60p140g->:::*00g50g*60g40g-:*-\-v0>1

^_@#`\g0<|`\g04:+1, <*84$$_v#`\0:<>p^

^>#0 *#12#<0g:^>+::"~~"90g*80g+*70gv|

g-10g*+:9**00gv|!*`\2\`-20::/2-\/\+<>

 

{{out}}

=={{header|Brlcad}}==

 

units cm # Set the unit of measure

 

=={{header|C}}==

The lighting calculation is somewhere between crude and bogus, but hey, I'm shading it with ASCII characters, don't expect too much.

#include <stdlib.h>

#include <string.h>

 

return 0;

{{out}}

<pre> #############%%%%

===Fun with 3D noise texture===

[[file:sphere-perlin.png]]

#include <stdlib.h>

#include <math.h>

 

return 0;

 

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

{{trans|C}}

 

namespace Sphere {

}

}

 

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

{{libheader|Qt}}

 

#include <QImage>

image.save("sphere.png");

return 0;

 

{{out}}

 

=={{header|Clojure}}==

{{libheader|quil}}

(use 'quil.core)

 

:draw draw

:renderer :opengl)

 

{{out}}

Saved as a png file and rendered in a X-Window. Unfortunately the file upload isn't working anymore for like four years so I cannot show my results directly.

 

(eval-when (:compile-toplevel :load-toplevel)

(ql:quickload '("cl-cairo2" "cl-cairo2-xlib")))

(set-source pat)

(arc *middle* *middle* 180 0 (* 2 pi))

 

=={{header|ContextFree}}==

startshape SPHERE

 

SPHERE[x 0.1% y 0.1%s 0.99 0.99 b 0.05]

}

 

=={{header|D}}==

{{trans|C}}

 

alias V3 = double[3];

drawSphere(20, 4, 0.1);

drawSphere(10, 2, 0.4);

 

=={{header|Delphi}}==

'''Steps:''' Run the CMD Windows shell. Then follow this path to setup the new width: '''Main Menu-> Properties -> Layout -> Window Size -> Width'''.

 

program DrawASphere;

 

Readln;

end.

 

{{out}}

[[image:DWScript-sphere.pbm.png|thumb|right|PBM output magnified 5 times]]

{{trans|C}} but adapted to spit out a [[wp:Netpbm_format|PGM]] image

type

TFloat3 = array[0..2] of Float;

normalize(light);

drawSphere(19, 4, 0.1);

 

=={{header|ERRE}}==

Using ASCII art: output is written to 'SPHERE.PRN' sequential file.

 

CONST SHADES$=".:!*oe&#%@"

CLOSE(1)

END PROGRAM

{{out}}

<pre> !::::::!!!**o

</pre>

 

=={{header|Factor}}==

{{libheader|raylib}}

{{works with|Factor|0.99 2020-03-02}}

640 480 "sphere" init-window

end-mode-3d

end-drawing

{{out}}

[https://i.imgur.com/FXHkZm6.png]

 

===ASCII output===

 

: sqrt ( u -- sqrt ) ( Babylonian method )

 

20 draw

 

{{out}}

===PGM output===

The same program as the ASCII one is translated to produce a PGM portable pixmap image file.

 

: sqrt ( u -- sqrt ) ( Babylonian method )

1000 +loop drop image-close ;

 

 

=={{header|Frink}}==

This program not only draws a sphere and renders it onscreen projected on the x,y, and z axes but also outputs a <CODE>.stl</CODE> file for 3-D printing or display in a 3-D modeling package like MeshLab! Frink has [https://frinklang.org/3d/frink/graphics/package-summary.html built-in routines for 3-D modeling] and can emit STL files or Wavefront OBJ files natively! Frink will let you print a sphere that you can hold in your hand!

v = callJava["frink.graphics.VoxelArray", "makeSphere", [1/2 inch res]]

 

w.println[v.toSTLFormat["sphere", 1/(res mm)]]

w.close[]

 

=={{header|FutureBasic}}==

 

 

 

end fn

 

 

HandleEvents

 

=={{header|Go}}==

{{trans|C}}

Using image library rather than ASCII art.

 

import (

fmt.Println(err)

}

 

=={{header|Haskell}}==

[[File:Sphere_Haskell.png|thumb|right]]

import Graphics.UI.GLUT.Objects

import Graphics.UI.GLUT

setMaterial

displayCallback $= display

 

=== ASCII art ===

{{trans|Python}}

 

 

shades = ".:!*oe%#&@"

else ' '

| y <- map (/2.12) [- 2*r - 0.5 .. 2*r + 0.5] ]

 

<pre>λ> putStrLn $ sphere 10 4 0.1 (normalize [30,30,-50])

Unicon provides a built-in interface to openGL including some higher level abstractions (for more information see [[Icon%2BUnicon/Intro#Graphics.2C_Network_Messaging.2C_etc.|Unicon Technical References, 3D Graphics]]). The example below draws a blue sphere on a black background and waits for input to quit.[[File:Sphere_unicon.PNG|thumb|Unicon Sphere]]

 

W := open("Demo", "gl", "size=400,400", "bg=black") | stop("can't open window!")

WAttrib(W, "slices=40", "rings=40", "light0=on, ambient white; diffuse gold; specular gold; position 5, 0, 0" )

DrawSphere(W, 0, 0, -5, 1)

Event(W)

<div style="border: 1px solid #000000; overflow: auto; width: 100%"></div>

 

But bringing up the example with a line of code is trivial enough:

 

 

(Note that this example has been removed from recent versions of J, but still works for J version 5 and version 6.)

Here's a version using raytracing computed in J. luminosity is an array of luminosity values with theoretical maximum 1 and minimum 0, and viewmat is used to display this.

 

light =. (% +/&.:*:) 30 30 _50

pts =. (0&*^:(0={:))@:(,,(0>.(*:R)-+)&.*:)"0/~ i:15j200

load 'viewmat'

torgb =. 256 #. [: <. 255 255 255 *"1 0 ]

 

=={{header|Java}}==

{{trans|C}}

static char[] shades = {'.', ':', '!', '*', 'o', 'e', '&', '#', '%', '@'};

 

drawSphere(10, 2, .4);

}

{{out}}

<pre> &&&&&&&&&&#######

This Javascript entry uses an HTML wrapper to offer easy running and some interactivity. It is made as such, though, that the entire HTML wrapper can be removed (except for a canvas with id <code>c</code>) and still work. If you remove the HTML, call the <code>draw_sphere</code> function to draw the thing.

 

<html>

<head>

<canvas id="c">Unsupportive browser...</canvas><br>

</body>

 

=={{header|jq}}==

{{works with|jq|1.4}}

The approach adopted here is to generate an SVG file, which may then be viewed, for example, in a web browser.

"<svg width='100%' height='100%' version='1.1'

xmlns='http://www.w3.org/2000/svg'

 

def sphere(cx; cy; r; gradientId):

 

'''Example:'''

svg,

"<title>Teal sphere</title>",

"</svg>" ;

{{out}}

 

One way to view the output as an image is to point your browser to the generated SVG.

===ASCII Text===

{{trans|C}}

shades = ('.', ':', '!', '*', 'o', 'e', '&', '#', '%', '@')

for i in floor(Int, -r):ceil(Int, r)

draw_sphere(20, 4, 0.1, light)

draw_sphere(10, 2, 0.4, light)

===Graphical===

 

using Makie

 

surface(x, y, z, backgroundcolor = :black, show_axis = false)

 

=={{header|Kotlin}}==

{{trans|C}}

 

const val shades = ".:!*oe&#%@"

drawSphere(20.0, 4.0, 0.1)

drawSphere(10.0, 2.0, 0.4)

 

{{out}}

 

=={{header|Lingo}}==

-- Draw a circle

-- @param {image} img

props[#color] = drawColor

img.draw(x-r, y-r, x+r, y+r, props)

 

=={{header|Logo}}==

{{works with|MSWlogo}}

 

cs perspective ht ;making the room ready to use

repeat 180 [polystart circle :r polyend down 1]

polyview

 

=={{header|Lua}}==

{{trans|C}}

{{works with|Lua|5.1.4}}

 

shades = {'.', ':', '!', '*', 'o', 'e', '&', '#', '%', '@'}

 

draw_sphere (20, 4, 0.1)

{{out}}

<pre> &&&&&&&&&&&&#####

 

=={{header|M2000 Interpreter}}==

Module CheckIt {

Er$="Pset is a new statement"

}

Checkit

 

[[https://2.bp.blogspot.com/-ZWy2xDxXbzg/W98lAuNSY9I/AAAAAAAAHZ0/DFYluvWtz_cwwAUKfblujnW6mTC5XVs1QCLcBGAs/s1600/sphere.png]image]

=={{header|Maple}}==

[[File:Sphere_Maple.png|thumb]]

 

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

Mathematica has many 3D drawing capabilities. To create a sphere with radius one centered at (0,0,0):

 

=={{header|MATLAB}}==

To create the unit sphere:

 

=={{header|Maxima}}==

plot3d(1, [theta, 0, %pi], [phi, 0, 2 * %pi],

[transform_xy, spherical_to_xyz], [grid, 30, 60],

sin(phi)*sin(theta),

cos(theta),

 

=={{header|Nim}}==

{{trans|C}}

 

type Point = tuple[x,y,z: float]

 

drawSphere 20, 4.0, 0.1

{{out}}

<pre> &&&&&&&&&&#######

=={{header|Ol}}==

{{libheader|OpenGL}}

(import (lib gl))

(import (OpenGL version-1-0))

(gluSphere quadric 0.4 32 10)

))

 

=={{header|Openscad}}==

Drawing a sphere is easy in openscad:

 

 

[[Category:Geometric Primitives]]

=={{header|OxygenBasic}}==

Using an OpenGl-based console

% Title "Sphere"

'% Animated

 

EndScript

 

=={{header|Pascal}}==

This produces a PGM image which can't be uploaded on rosettacode at the moment. It looks similar as the Raku solution, though.

 

use warnings;

 

},

q{""} => sub { sprintf "Vector:[%s]", join ' ', @{shift()} };

 

=={{header|Phix}}==

Sphere will resize to match the window.

You can run this online [http://phix.x10.mx/p2js/drawsphere.htm here]. Note fullscreen redraw can be quite slow.

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

-- demo\rosetta\Draw_a_sphere.exw

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

 

=={{header|PicoLisp}}==

{{libheader|GLUT}}

This is for the 64-bit version.

 

(glutInit)

# Exit upon mouse click

(mouseFunc '((Btn State X Y) (bye)))

 

{{trans|C}}

 

 

(setq *Shades

(setq *Light (normalize *Light))

(drawSphere 20.0 4 0.1)

{{out}}

<pre> ##############%%%

=={{header|PostScript}}==

Gradient filled circle:

%%BoundingBox 0 0 300 300

 

showpage

%%EOF

 

=={{header|POV-Ray}}==

This is what POVray was made for. An example with a sky, surface and transparency:

 

camera { location <0.0 , .8 ,-3.0> look_at 0}

interior { ior 1.5}

}

 

Yields this:

3D rendering is built into Processing.

 

size(500, 500, P3D);

}

// draw sphere

sphere(200);

A sphere build from triangles (to for instance allow distortion)

 

PVector[][] sphere;

rotY -= (mouseX - pmouseX) * 0.01;

rotX -= (mouseY - pmouseY) * 0.01;

 

=={{header|Python}}==

===Ascii-Art===

{{trans|C}}

 

shades = ('.',':','!','*','o','e','&','#','%','@')

light = normalize((30,30,-50))

draw_sphere(20,4,0.1, light)

{{out}}

<pre> &&&&&&&&&&######

This code contains unnecessary functions which are part of a 3D graphics library I wrote. <br>

Uses Pygame and Python 3.2.2

import pygame

from pygame.locals import *

import random

import math

class Tricubic:

def __init__(self,pts):

if event.type == KEYDOWN:

pass

 

==={{libheader|VPython}}===

{{works with|Python|2.7.5}}

'''Short version''':

scene.title = "VPython: Draw a sphere"

 

'''Regular version''', with some window-dressing:

from __future__ import print_function, division

from visual import *

rate(100)

pass # no animation in this demo

 

=={{header|Racket}}==

Using the Typed Racket language with the plot library:

 

#lang typed/racket

 

(require plot/typed)

(plot3d (polar3d (λ (θ ρ) 1)) #:altitude 25)

 

=={{header|Raku}}==

 

[[File:Sphere-perl6.png|thumb]]

 

my @light = normalize([ 3, 2, -5 ]);

}

flat |@pixels.map: *.list;

 

===Cairo graphics library===

 

given Cairo::Image.create(Cairo::FORMAT_ARGB32, 256, 256) {

};

.write_png('sphere2-perl6.png');

See [https://github.com/thundergnat/rc/blob/master/img/sphere2-perl6.png sphere2-perl6.png] (offsite .png image)

 

 

Programming note: &nbsp; the output will appear slightly different when executed on an EBCDIC machine &nbsp; (due to different dithering characters).

call drawSphere 19, 4, 2/10, '30 30 -50' /*draw a sphere with a radius of 19. */

call drawSphere 10, 2, 4/10, '30 30 -50' /* " " " " " " " ten. */

numeric form; m.=9; parse value format(x,2,1,,0) 'E0' with g "E" _ .; g= g*.5'e'_%2

do j=0 while h>9; m.j=h; h=h%2+1; end /*j*/

{{out|output|text=&nbsp; when using the default input and executed on an '''ASCII''' machine:}}

(Shown at &nbsp; <big>'''¹/₂'''</big> &nbsp; size.)

Shoes comes with this sample program.

[[File:sphere.shoes.png|thumb|right]]

image 400, 470, :top => 30, :left => 50 do

nostroke

end

end

 

=={{header|Rust}}==

{{trans|Go}}

// image = "0.23"

 

Err(error) => eprintln!("{}", error),

}

 

{{out}}

 

=={{header|Scala}}==

private val (shades, light) = (Seq('.', ':', '!', '*', 'o', 'e', '&', '#', '%', '@'), Array(30d, 30d, -50d))

 

drawSphere(10, 2, .4)

 

{{Out}}See it in running in your browser by [https://scalafiddle.io/sf/uSm8bJ9/0 ScalaFiddle (JavaScript)] or by [https://scastie.scala-lang.org/TtVHUp3aS0eDEB6YCW4gKg Scastie (JVM)].

 

{{trans|Raku}}

Produces a PGM image.

func dot (x, y) { -(x »*« y -> sum) `max` 0 }

 

out.say("P5\n#{x} #{y}\n#{depth}") # .pgm header

out.print(draw_sphere((x-1)/2, .9, .2).map{.chr}.join)

 

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

although there is a Point3 class in some loadable library, here is some self contained code, defining a local anon Point3D class.

Point3D :=

Point subclass:#Point3D

 

main value.

[[file:sphere-smalltalk.png]]

 

=={{header|Swift}}==

In Playground for example:

class Sphere: UIView{

 

var s = Sphere(frame: CGRectMake(0, 0, 200, 200))

 

In SwiftUI:

struct ContentView: View {

 

}

}

 

=={{header|Tcl}}==

Assuming the task is to draw a <i>likeness</i> of a sphere, this would usually do:

 

 

pack [canvas .c -height 400 -width 640 -background white]

.c create arc [expr {100+$i/5}] [expr {50+$i/5}] [expr {400-$i/1.5}] [expr {350-$i/1.5}] \

-start 0 -extent 359 -fill $h -outline $h

Results in this image:

 

The PGF <code>shadings</code> library includes a "ball" for a 3-D style highlight.

 

\usepackage{tikz}

\usetikzlibrary{shadings}

\shade[ball color=black] (0,0) circle (4);

\end{tikzpicture}

 

=={{header|Turing}}==

Translated and optimized from the Algol W solution and others posted here.

 

% Light intensity to character map

% Draw some spheres

drawSphere (20, 4, lightsource, brightness)

 

{{Out}}

=={{header|VBScript}}==

{{trans|C}}

light = Array(30, 30, -50)

 

Normalize light

DrawSphere 20, 4, 0.1

{{Out}}

<pre> &&&&&&&&&&#######

eeeeeeeeeeeeeeeeeeeee

eeeeeeeeeeeee</pre>

 

=={{header|Wren}}==

{{trans|C}}

var light = [30, 30, -50]

 

normalize.call(light)

drawSphere.call(20, 4, 0.1)

 

{{out}}

=={{header|XPL0}}==

[[File:SphereXPL0.png|right]]

def R=100, R2=R*R; \radius, in pixels; radius squared

def X0=640/2, Y0=480/2; \coordinates of center of screen

repeat until KeyHit; \wait for keystroke

SetVid($03); \restore normal text mode

 

=={{header|Yabasic}}==

open window 640,480

backcolor 16,16,16

fill circle ancho/2-2*n/3, alto/2-n/2, 150-n

next n

 

=={{header|zkl}}==

{{trans|XPL0}}

[[File:Sphere.zkl.jpg|200px|thumb|right]]

R:=100; R2:=R*R; //radius, in pixels; radius squared

X0:=640/2; Y0:=480/2; //coordinates of center of screen

}

}

The radius of 100 is the max before the color calculation overflows 24 bits so for a radius (R) of, say 200, use

Perhaps a more useful solution is to use GnuPlot (I grabbed the code from http://ayapin-film.sakura.ne.jp/Gnuplot/):

[[File:GnuplotSphere.zkl.png|250px|thumb|right]]

cmd:=0'|

set term wxt

gnuplot:=System.popen("gnuplot","w");

gnuplot.write(cmd); gnuplot.flush();

Where "term wxt" is X11 on my Linux box. A window pops up and stays until the pipe is closed.

 

=={{header|ZX Spectrum Basic}}==

50 REM spheer with hidden lines and rotation

100 CLS

1050 LET yy=bx*x+by*y+bz*z

1060 LET zz=cx*x+cy*y+cz*z

 

[[Category:Geometry]]