Draw a pixel: Difference between revisions

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

The solution of this task is tricky because of technical limitation of Atari 8-bit computer. The computer supports high resolution graphics mode of 320 pixels width, 192 pixels height and 1 bit per pixel color. The color of the pixel cannot be set independently from the background color and only different luminance can be specified. To draw a red pixel the background must be set to light-red color.

BYTE

CH=$02FC, ;Internal hardware value for last key pressed

DO UNTIL CH#$FF OD

CH=$FF

{{out}}

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

=={{header|Ada}}==

{{libheader|SDLAda}}

with SDL.Video.Renderers.Makers;

with SDL.Events.Events;

Window.Finalize;

SDL.Finalise;

 

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

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

pop {r4, lr}

bx lr

 

=={{header|AutoHotkey}}==

From [https://www.autohotkey.com/boards/viewtopic.php?p=64817#p64817 AHK Forum]

CreatePixel("FF0000", hPicture)

Gui, Show, w320 h240, Example

DllCall("Gdi32.dll\SetBitmapBits", "Ptr", hBM, "UInt", 3, "Ptr", &BMBITS)

DllCall("User32.dll\SendMessage", "Ptr", Handle, "UInt", 0x172, "Ptr", 0, "Ptr", hBM)

 

It seems that the program should be this. And the BASIC256 tutorial programs work on my ubuntu system. This program neither draws the pixel nor resizes the window. Can't see anything when I plot many spots. Oh well. I've tried the rgb(255,0,0) function as well as the fastgraphics/refresh statements.

rem http://rosettacode.org/wiki/Draw_a_pixel

 

color red

plot 100, 100

 

{{works with|BBC BASIC for Windows}}

 

 

'''Example 1:''' VIC-20 with SuperExpander Cartridge

Version 2 of Commodore BASIC, which shipped on the VIC-20 and Commodore 64, did not have any graphics support. A stock VIC didn't have enough memory for high-resolution graphics anyway, so they mostly weren't used. But Commodore shipped a "SuperExpander" cartridge for the VIC which not only included enough extra RAM to support a 160x160-pixel bitmap, but also extended BASIC to include statements for drawing on it. One oddity about the VIC's iteration of the SuperExpander is that, despite the low 160x160 resolution, it treats the screen as having 1024x1024 pixels; the below program compensates for this by asking for a dot at 640,640, which maps to the physical pixel at 100,100.

 

20 GRAPHIC 2:SCNCLR:REM SELECT HI-RES GRAPHICS AND CLEAR THE SCREEN

30 POINT 2,640,640:REM DRAW A POINT AT 640/1024*160,640/1024*160

40 GET K$:IF K$="" THEN 40: REM WAIT FOR KEYPRESS

 

 

To create graphics via manual memory manipulation, it's necessary to understand the layout of the screen. Unlike many other bitmap systems, the C64's bitmap was broken up into the 8x8-pixel cells used for text characters, even in high-resolution graphics mode. So while the first byte of video RAM unsurprisingly contains the leftmost 8 pixels on the top row of the screen, the second byte contains the 8 pixels directly ''below'' those, and so on for eight rows, before the ninth byte returns us to the top row for its 9th through 16th pixels. This requires calculation on the programmer's part to translate X,Y coordinates into a specific memory address/value combination (lines 30 through 60).

 

20 REM INITIALIZE BITMAP MODE

21 POKE 53280,0:PRINT CHR$(147);"CLEARING BITMAP... PLEASE WAIT..."

75 REM CLEAR PIXEL, RETURN TO TEXT MODE

80 POKE MEM,0:POKE 53265,PEEK(53265) AND 223:POKE 53272,PEEK(53272) AND 247

 

'''Example 3:''' Commodore 64 with SuperExpander Cartridge

Commodore released a version of the SuperExpander Cartridge for the C64 that was similar to the one for the VIC-20, but not identical. Besides some differences in the actual BASIC statements, it also does not have the artificial scale factor; graphics statements instead take physical pixel coordinates.

 

20 GRAPHIC 2,1:REM SELECT HIRES GRAPHICS AND CLEAR THE SCREEN

30 DRAW 1,100,100:REM DRAW A PIXEL AT 100,100

40 GET K$:IF K$="" THEN 40:REM WAIT FOR A KEYPRESS

 

 

'''Example 4:''' Commodore Plus/4, C-16, and 128 (40-column display)

 

 

15 GRAPHIC 1,1 : REM ENTER BITMAP GRAPHICS MODE AND CLEAR SCREEN

20 DRAW 1,100,100 : REM PLOT PIXEL AT 100,100

30 GETKEY K$: REM WAIT FOR KEYPRESS THE NEW WAY

 

'''Example 5:''' Commodore 128 (80-column display)

 

 

20 @COLOR,0,9,0:REM BACKGROUND BLACK, FOREGROUND BRIGHT RED

30 @SCREEN,0,0:REM SELECT MONOCHROME MODE

70 @DOT,100,100,0:REM DRAW DOT

80 GETKEY K$:REM WAIT FOR KEYPRESS

 

=={{header|Delphi}}==

{{libheader| SysUtils}}

Console version using windows api, thanks for RRUZ ([https://stackoverflow.com/questions/10180016/creating-forms-without-using-vcl])

program Draw_a_pixel;

 

end.

 

 

{{out}}

[https://ibb.co/VL9Qs5z]

 

=={{header|F Sharp|F#}}==

 

Uses Windows Forms

open System.Drawing

 

f.Size <- new Size(320,240)

f.Paint.Add(fun e -> e.Graphics.FillRectangle(Brushes.Red, 100, 100 ,1,1))

 

=={{header|Factor}}==

kernel literals math sequences ;

IN: rosetta-code.draw-pixel

[ set-pixel-at ] keep image-window ;

 

 

 

=={{header|Forth}}==

{{libheader|SDL2}}

 

s" SDL2" add-lib

\c #include <SDL2/SDL.h>

;

 

 

 

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

' or: fbc -s gui

WindowTitle IIf(depth = 8, "Palette","True Color") + ", hit any key to end program"

Sleep

 

=={{header|GB BASIC}}==

The resolution of the Game Boy's screen is only 160×144, so the window requirement is out, but the pixel is easy. Also, GB BASIC doesn't support displaying the color red, so the Game Boy's grayscale equivalent, dark gray, is used instead:

 

=={{header|GML}}==

 

=={{header|Go}}==

 

import (

fmt.Println("The color of the pixel at ( 0, 0) is", cmap[c1], "\b.")

fmt.Println("The color of the pixel at (100, 100) is", cmap[c2], "\b.")

 

{{out}}

</pre>

Create a PNG image?

 

import (

png.Encode(w, img)

}

GUI "window" rather than an image?

 

// first run" go get github.com/zserge/webview"

// simple GUI "window"

webview.Open("Minimal webview example",

"https://en.m.wikipedia.org/wiki/Main_Page", 320, 240, true)

 

=={{header|Icon}} and {{header|Unicon}}==

# draw-pixel.icn

#

DrawPoint(100, 100)

Event()

 

=={{header|J}}==

coinsert 'jgl2'

wd'pc Rosetta closeok;cc task isidraw; set task wh 320 200;pshow'

glpaint glpixel 100 100 [ glpen 1 1 [ glrgb 255 0 0 [ glclear ''

 

=={{header|Java}}==

Basic Implementation via subclass of JFrame:

import java.awt.Graphics;

import javax.swing.JFrame;

}

}

Advanced Implementation via subclass of JPanel (more powerful especially while repainting):

import java.awt.Graphics;

import java.awt.image.BufferedImage;

}

}

 

=={{header|Julia}}==

const can = @GtkCanvas()

signal_connect(endit, win, :destroy)

wait(cond)

 

=={{header|Kotlin}}==

This task seems very similar to the [[Bitmap]] task and so therefore is the code to accomplish it.

 

import java.awt.Color

println(if (c == Color.red) "red" else "white")

}

 

{{output}}

 

=={{header|Lambdatalk}}==

1) html/css

 

}

 

 

=={{header|Lua}}==

The luasdl2 library is required.

 

 

local ret = SDL.init { SDL.flags.Video }

 

SDL.delay(5000)

 

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

There is also a PSet statement for pixel drawing (from 9.5 version). Just replace the module call to PlotPixel with Pset.

 

 

 

}

CheckIt

[https://www.dropbox.com/s/uscltz6pwy06jxv/DrawPixelForm.png?dl=0 OutPut]

 

=={{header|Nim}}==

{{libheader|rapid}}

 

 

var

discard step # Prevent unused variable warnings

update step:

 

 

{{libheader|SDL2}}

Another version using SDL2.

 

discard sdl2.init(INIT_EVERYTHING)

renderer.present()

 

 

=={{header|Oberon}}==

With basic module XYplane, the size of the drawing plane cannot be set. Tested with [https://miasap.se/obnc OBNC].

 

 

IMPORT XYplane;

REPEAT UNTIL XYplane.Key() = "q"

END pixel.

 

=={{header|Objeck}}==

{{libheader|SDL2}}

use Game.Framework;

 

}

}

 

=={{header|OCaml}}==

Using the Graphics library provided with the standard OCaml distribution:

 

 

let () =

G.set_color G.red;

G.plot 100 100;

run with:

<pre>$ ocaml graphics.cma draw_a_pixel.ml

{{libheader|OCamlSDL2}}

 

 

let () =

Render.render_present renderer;

Timer.delay 3000;

run with:

<pre>$ ocaml -I $(ocamlfind query sdl2) sdl2.cma draw_a_pixel.ml

</pre>

 

=={{header|Ol}}==

{{libheader|OpenGL}}

(import (lib gl))

(import (OpenGL version-1-0))

(glVertex2f 100 100)

(glEnd)))

 

=={{header|Perl}}==

{{libheader|Gtk3}}

 

my $window = Gtk3::Window->new();

$cr->rectangle( 100, 100, 1, 1);

$cr->stroke;

 

=={{header|Phix}}==

{{libheader|Phix/online}}

You can run this online [http://phix.x10.mx/p2js/drawapixel.htm here].

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">include</span> <span style="color: #000000;">pGUI</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

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

 

=={{header|Processing}}==

A static-mode sketch containing setting one pixel on the canvas pixels array:

 

 

The same sketch in active mode sketch is:

 

size(320, 240);

set(100, 100, color(255,0,0));

 

Or a pixel can be manipulated through loading and modifying the pixels array. The formula to access a pixel is x + y * image width.

 

size(320, 240);

loadPixels();

pixels[width*100 + 100] = color(255,0,0);

updatePixels();

 

Processing can also draw a dot on the canvas using the `point()` command will also draw a dot on the canvas...

 

stroke(color(255,0,0));

 

...however, whether a point corresponds to a single pixel on the screen may depend on device-specific factors such as `pixelDensity()`, render features such as 2D / 3D mode or `smooth()`, or style settings such as `strokeWidth()` or `strokeCap()`.

=={{header|PureBasic}}==

 

If OpenWindow(0, 0, 0, 320, 240, "Rosetta Code Draw A Pixel in PureBasic")

If CreateImage(0, 320, 240) And StartDrawing(ImageOutput(0))

Until Event = #PB_Event_CloseWindow

EndIf

 

=={{header|Python}}==

{{works with|Python |2.7.14}}

{{libheader|PIL}}

 

img = Image.new('RGB', (320, 240))

pixels[100,100] = (255,0,0)

img.show()

 

=={{header|QB64}}==

 

=={{header|QBasic}}==

' This program can run in QBASIC, QuickBASIC, gw-BASIC (adding line numbers) and VB-DOS

SCREEN 1

COLOR , 0

PSET (100, 100), 2

 

=={{header|Racket}}==

(require racket/draw)

(let ((b (make-object bitmap% 320 240)))

(send b set-argb-pixels 100 100 1 1 (bytes 255 0 0 255))

 

=={{header|Raku}}==

Really? Draw a single pixel? Sigh.

 

use GTK::Simple::DrawingArea;

use Cairo;

 

my $ctx = $da.add-draw-handler( &rect-do );

 

=={{header|ReScript}}==

 

type context = { mutable fillStyle: string, }

 

 

 

 

let canvas = getElementById(doc, "my_canvas")

 

ctx.fillStyle = "#F00"

 

 

<html>

<head>

 

</body>

 

=={{header|REXX}}==

:::* &nbsp; PC/REXX

:::* &nbsp; Personal/REXX

parse upper version !ver .

!pcrexx= 'REXX/PERSONAL'==!ver | 'REXX/PC'==!ver /*obtain the REXX interpreter version. */

end

 

<br><br>

 

=={{header|Ring}}==

 

load "guilib.ring"

endpaint()

}

Output image:

[https://www.dropbox.com/s/gbtrkx7bx7hogxm/PixelColor.jpg?dl=0 Draw a pixel]

 

One of the requirements (fixed screen resolution) could not be met.

. "Set the sprite's reference character located at the"

. "upper-left corner of the board (char 0)"

. "Display the sprite at the given location"

put c0c Sprite p00 at "('xPos')" "('yPos')"

 

I highly recommend you check out [https://www.digitalmzx.net/wiki/index.php?title=Sprite_(Tutorial) this tutorial] for the usage of Sprites in order to get a better understanding of all this.

 

=={{header|Ruby}}==

{{libheader|gtk3}}

 

 

Width, Height = 320, 240

window.show

Gtk.main

 

=={{header|Rust}}==

 

 

extern crate image;

 

}

}

 

=={{header|Scala}}==

{{Out}}

Best experienced in your browser [https://scastie.scala-lang.org/AHtZh6zhRTWGj3M8azw28g with Scastie (remote JVM)].

import java.awt.Color

import scala.language.reflectiveCalls

println("Tests successfully completed with no errors found.")

 

 

=={{header|SmileBASIC}}==

I almost said that the 320x240 requirement was not going to happen. Then I realised the 3DS bottom screen is exactly 320x240.

DISPLAY 1

GPSET 100, 100, RGB(255, 0, 0)

 

=={{header|Standard ML}}==

Works with PolyML

open Motif ;

 

)

call

imgWindow () ;

{{works with|Tcl|8.5}}

==={{libheader|Tk}}===

package require Tk

 

pack [canvas .c -width 320 -height 240 -bg #fff] -anchor nw

 

=={{header|True BASIC}}==

SET COLOR 4

PLOT 100,100

 

=={{header|VBA}}==

Word

Dim sh As Shape, sl As Shape

Set sh = ActiveDocument.Shapes.AddCanvas(100, 100, 320, 240)

Set sl = sh.CanvasItems.AddLine(100, 100, 101, 100)

sl.Line.ForeColor.RGB = RGB(Red:=255, Green:=0, Blue:=0)

 

import gx

 

ctx.draw_pixel(100, 100, gx.red)

ctx.end()

 

=={{header|Wee Basic}}==

Since the resolution of the Nintendo DS's bottom screen is only 256×192 (the same applies to the top screen), the window requirement is out, but the pixel is easy:

plot 0 100,100,5

 

=={{header|Wren}}==

{{libheader|DOME}}

import "graphics" for Canvas, Color

 

 

static getRGB(col) { "{%(col.r), %(col.g), %(col.b)}" }

 

{{out}}

so the pixel can be seen. Borland's tasm and tlink /t were used to

create an executable .com file.

.model tiny

.code

ret ;return to OS

end start

 

=={{header|XPL0}}==

This is all that's required to plot a pixel on the Raspberry Pi version of XPL0. It can do tens of millions of them per second. (FB = Frame Buffer.)

 

=={{header|Yabasic}}==

color 255, 0, 0

 

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

The ZX Spectrum screen is only 256x224 (unless you're running one of the games like Starion or Dark Star which used scary machine code timing tricks to draw on the border), meaning the window requirement is out, but the pixel is easy: