Color of a screen pixel: Difference between revisions
Content deleted Content added
Puppydrum64 (talk | contribs) |
Thundergnat (talk | contribs) m syntax highlighting fixup automation |
||
Line 13:
===easy6502/6502js===
Video memory is mapped into $0200-$05ff, and the bottom 4 bits of each byte represent the pixel's color.
<
LDA $05FF ;get the color of the bottom-right pixel of the screen.</
===Nintendo Entertainment System===
The NES can't determine the color of a single pixel. The closest you can get is a 16 pixel by 16 pixel section of graphics. And that only tells you the palette in use at that location, not the actual color. Color cells are 2 bits per 16x16 section, in the order of top-left, top-right, bottom-left, bottom-right.
<
;address $23C0 = first color cell of nametable $2000
LDA #$23
Line 27:
LDA $2007
AND #%11000000 ;00------ = top-left corner uses palette 0, 01------ = top-left corner uses palette 1, etc.</
This code assumes no scrolling has taken place, as it only reads the color cells from the top-left nametable. Generally speaking, reading VRAM in this way is not a good practice, as it's very slow and can only be done during vBlank when you have better things to do. For an actual game, it's much easier to keep a shadow of this data in normal RAM and read that instead, and pretend that VRAM is write-only.
Line 34:
===With Interrupts===
MS-DOS has a built-in way to calculate the color of a pixel on-screen.
<
mov ah,0Dh
int 10h</
The color is returned in AL.
=={{header|Action!}}==
<
BYTE POINTER ptr
BYTE
Line 86:
FI
OD
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Color_of_a_screen_pixel.png Screenshot from Atari 8-bit computer]
Line 97:
[https://lh4.googleusercontent.com/-Gw0xm7RIEck/Uute2nQSGsI/AAAAAAAAJ90/rq3UuWYE9Yw/s1600/Capture.PNG <VIEW THE BLOCKS AND ANDROID APP DISPLAY>]
=={{header|AutoHotkey}}==
<
=={{header|AutoIt}}==
<
$pos = MouseGetPos()
$c = PixelGetColor($pos[0], $pos[1])
ConsoleWrite("Color at x=" & $pos[0] & ",y=" & $pos[1] & _
" ==> " & $c & " = 0x" & Hex($c) & @CRLF)</
{{Out}}
<pre>
Line 111:
=={{header|Axe}}==
<
=={{header|BaCon}}==
BaCon can make use of the High Performance Canvas include. Outside this canvas it needs to access XLib API functions.
<
FULLSCREEN
color = GETINK(100, 100, 4)
WAITKEY</
=={{header|BASIC}}==
Line 124:
==={{header|AmigaBASIC}}===
<
WHILE 1
m=MOUSE(0)
PRINT POINT(MOUSE(1),MOUSE(2))
WEND</
(The color index is -1 if the mouse pointer is outside the Basic window.)
Line 135:
[http://en.wikipedia.org/wiki/Apple_II_graphics#Low-Resolution_.28Lo-Res.29_graphics Low-Resolution (Lo-Res) graphics] 40x48, 16 colors, page 1
<
Y = PDL (1) * 3 / 16
COLOR= SCRN( X,Y)</
[http://en.wikipedia.org/wiki/Apple_II_graphics#High-Resolution_.28Hi-Res.29_graphics Hi-Resolution (Hi-Res) graphics] 280x192, 6 colors
There is no HSCRN( X,Y) function in Applesoft. What follows is an elaborate subroutine that determines the hi-res color at the location given by variables X and Y on the current hi-res page. A color value in the range from 0 to 7 is returned in the variable C. The color is determined by peeking at adjacent pixels and the Most Significant Bit [http://en.wikipedia.org/wiki/Most_significant_bit MSB]. The VTAB routine is used as an aid to calculate the address of pixels. Other colors beyond the 6 hi-res colors can be displayed by positioning pixels at byte boundaries using the MSB. This routine is limited to the eight hi-res colors.
<syntaxhighlight lang="applesoft basic">
100 REM GET HCOLOR
110 REM PARAMETERS: X Y
Line 184:
X = 267 : Y = 166 : GOSUB 100
HCOLOR= C
</syntaxhighlight>
==={{header|BBC BASIC}}===
In [[BBC BASIC for Windows]] you can read either the 'logical colour' (palette index) or the 'true colour' (24-bit RGB value).
<
RGB24b_colour% = TINT(x%, y%)</
==={{header|Commodore BASIC}}===
Line 199:
The Commodore 64 hires bitmap is 320×200, subdivided into 8×8 cells starting at the top left and moving right. Each cell is addressed top to bottom by 8 bytes. Each byte controls a horizontal row of 8 bits. This requires calculation on the programmer's part to translate X,Y coordinates into a specific memory address/value combination (lines 1210 through 1220).
<
10 base=2*4096:x=100:y=50:poke53280,0
20 gosub 1000:print chr$(147);
Line 225:
1220 bit=7-(x and 7):byte=base+ro*320+char*8+li:cb=1024+ro+ch
1230 return
</syntaxhighlight>
'''Example 2:''' Commodore Plus 4 and 128
Line 231:
On both machines, there is a split graphics-text screen that can be used, and the extended BASIC provides functions for reading pixel and color values from the bitmap.
<
15 graphic 2,1: rem enter split graphics/text mode and clear screen
20 draw 1,100,50 : rem plot pixel at 100,50
30 print "pixel color at";rdot(0);",";rdot(1);"is";rclr(rdot(2))
40 get k$:if k$="" then 40
50 graphic 0,1 : rem return to text mode</
Line 242:
This is a very simple example from the FreeBASIC documentation. To obtain the color of an arbitrary screen pixel (i.e. outside
the graphics screen controlled by FB) one would need to use API functions.
<
' Set an appropriate screen mode - 320 x 240 x 8bpp indexed color
Line 254:
' Sleep before the program closes
Sleep</
==={{header|QuickBASIC}}===
Line 260:
In a graphics mode (for instance, <tt>SCREEN 13</tt> or <tt>SCREEN 12</tt>)
<
==={{header|Integer BASIC}}===
Line 267:
==={{header|Liberty BASIC}}===
<
Struct point, x As long, y As long
Line 291:
Function GetPixel(hDC, x, y)
CallDLL #gdi32, "GetPixel", hDC As uLong, x As long, y As long, GetPixel As long
End Function</
==={{header|Locomotive Basic}}===
<
20 color=TEST(x,y)
30 PRINT "Pen color at"; x; y; "is"; color</
==={{header|PureBasic}}===
Return the color used at the x,y position in the current output. If the current output has an alpha channel then the result will be a 32bit RGBA value, otherwise it will be a 24bit RGB value. The color can be split in their RGB and alpha values by using the Red(), Green(), Blue() and Alpha() functions.
<
To get the colour of a pixel on the screen when it is not managed by PureBasic (ie. from other programs' windows), it is necessary to use Windows API. This works only under Windows.
<syntaxhighlight lang="purebasic">
hDC = GetDC_(0)
Color = GetPixel_(hDC, x, y)
ReleaseDC_(0, hDC)</
This work fine!!
<
If OpenWindow(0,0,0,100,45,"Get pixel color at cursor position",#PB_Window_MinimizeGadget)
TextGadget(0,0,0,50,12,"Red: ")
Line 335:
Until event=#PB_Event_CloseWindow
ReleaseDC_(0, hDC)
EndIf</
=={{header|QBasic}}==
<syntaxhighlight lang="qbasic">
'Example: Find color of a screen pixel in QBasic (adapted from QBasic Help file).
' POINT(x%, y%) returns color of pixel at coordinates x,y.
Line 351:
NEXT y%
END
</syntaxhighlight>
==={{header|BASIC256}}===
<
rect 50, 50, 75, 75
Line 367:
azul = (c & 0xff)
print rojo; " "; verde; " "; azul</
==={{header|SmileBASIC}}===
<
PCOL=GSPOIT(X,Y)
RGBREAD PCOL OUT R,G,B
END</
==={{header|TI-89 BASIC}}===
Only the graph screen can be read.
<
==={{header|Visual Basic .NET}}===
<
Dim b As New Bitmap(1, 1)
Line 390:
Return b.GetPixel(0, 0)
End Function</
==={{header|VBA}}===
Line 397:
This code should be adapted for 64 bits versions...
<syntaxhighlight lang="vb">
Option Explicit
Line 421:
Get_Color_Under_Cursor = GetPixel(lngDc, Pos.x, Pos.y)
End Function
</syntaxhighlight>
==={{header|Yabasic}}===
<
backcolor 255, 0, 0
clear window
Line 437:
red = dec(left$(s$, 2))
print red, " ", green, " ", blue</
==={{header|ZX Spectrum Basic}}===
Line 444:
=={{header|C}}==
{{libheader|Xlib}}
<syntaxhighlight lang="c">
#include <X11/Xlib.h>
void
Line 460:
get_pixel_color (display, 30, 40, &c);
printf ("%d %d %d\n", c.red, c.green, c.blue);
</syntaxhighlight>
{{works with|Windows}}
(Linux users, see [http://www.muquit.com/muquit/software/grabc/grabc.html grabc].)
<
COLORREF getColorAtCursor(void) {
Line 489:
return color;
}</
=={{header|C sharp|C#}}==
<
using System.Drawing;
using System.Windows.Forms;
Line 514:
Console.WriteLine(GetPixel(Cursor.Position));
}
}</
Sample output:
<syntaxhighlight lang="text">Color [A=255, R=243, G=242, B=231]</
=={{header|C++/CLI}}==
<
using namespace System::Drawing;
using namespace System::Windows::Forms;
Line 536:
Console::WriteLine("G: "+color.G.ToString());
Console::WriteLine("B: "+color.B.ToString());
}</
=={{header|Clojure}}==
<
(.getPixelColor (java.awt.Robot.) x y))</
=={{header|Common Lisp}}==
Using Allegro and their Common Graphics package
<
(defun print-hex (n)
Line 561:
(get-pixel (position-x pos) (position-y pos))))
(print-hex (get-mouse-pixel))</
Sample output: (values are in RGBA order):
<
=={{header|Delphi}}==
<syntaxhighlight lang="delphi">
program ScreenPixel;
Line 640:
end.
</syntaxhighlight>
Example output:
Line 663:
=={{header|F_Sharp|F#}}==
<
open System.Windows.Forms
Line 675:
let GetPixelAtMouse () =
let pt = Cursor.Position
GetPixel pt.X pt.Y</
=={{header|Go}}==
{{libheader|RobotGo}}
<
import (
Line 693:
color := robotgo.GetPixelColor(x, y)
fmt.Printf("Color of pixel at (%d, %d) is 0x%s\n", x, y, color)
}</
{{out}}
Line 702:
=={{header|Groovy}}==
<
class GetPixelColor {
Line 713:
}
}
</syntaxhighlight>
=={{header|Icon}} and {{header|Unicon}}==
Icon and Unicon don't have direct access to the screen; however, we can read the colour of of a maximal sized window instead. The graphics procedure generates all pixels from a rectangular selection as a comma separated string with RGB values.
<
procedure main()
Line 741:
WDone(W) # q to exit
end
</syntaxhighlight>
{{libheader|Icon Programming Library}}
Line 757:
Assuming the OS is Windows (Windows being an operating system with fairly wide adoption, which also guarantees a specific concept of "screen"):
<
GetPixel=: 'gdi32.dll GetPixel >l i i i'&cd NB. rgb: GetPixel hdc x y
GetCursorPos=: 'user32.dll GetCursorPos i *i'&cd NB. success: point</
Task example -- reading the color of the pixel at the mouse cursor:
<
121 91 213</
Breaking this down:
<
1325469620
GetCursorPos<0 0
Line 779:
13982585
|.(3#256)#:13982585
121 91 213</
(The windows color result is packed as 0x00bbggrr. So, after splitting the integer result into bytes we need to reverse their order to get red,green,blue.)
Line 785:
=={{header|Java}}==
{{uses from|AWT|Robot}}
<
return new Robot().getPixelColor(x, y);
}</
=={{header|Julia}}==
<
# Windows GDI version
function getpixelcolors(x, y)
Line 802:
cols = getpixelcolors(x, y)
println("At screen point (x=$x, y=$y) the color RGB components are red: $(cols[1]), green: $(cols[2]), and blue: $(cols[3])")
</
At screen point (x=120, y=100) the color RGB components are red: 1, green: 36, and blue: 86
</pre>
=={{header|Kotlin}}==
<
fun getMouseColor(): Color {
Line 816:
fun getColorAt(x: Int, y: Int): Color {
return Robot().getPixelColor(x, y)
}</
=={{header|Lingo}}==
{{libheader|ScrnXtra3 Xtra}}
<
sx = xtra("ScrnXtra3").new()
img = sx.ScreenToImage(rect(x, y, x+1, y+1))
return img.getPixel(0, 0)
end</
=={{header|Logo}}==
Line 835:
=={{header|M2000 Interpreter}}==
Colors is M2000 have a negative value for RGB, or positive for default colors (0 to 15 are the default colors). Also numbers above 0x80000000 (is a positive number), are Windows colors too. Point return a negative value so we have to make it positive to get the RGB value where Red is the least significant byte. Html color has R as the most significant byte (of three), so to display properly we have to use a mix of Right$(),Mid$() and Left$() functions on string representation on color$.
<syntaxhighlight lang="m2000 interpreter">
Module CheckColor {
\\ Print hex code for color, and html code for color
Line 847:
}
CheckColor
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
=={{header|Nim}}==
===Using GTK2===
{{libheader|GTK2}}
<
type Color = tuple[r, g, b: byte]
Line 867:
result = cast[ptr Color](p.getPixels)[]
echo getPixelColor(0, 0)</
===Using GTK3===
{{libheader|gintro}}
<
type Color = tuple[r, g, b: byte]
Line 887:
discard run(app)
echo getPixelColor(1500, 800)</
=={{header|Perl}}==
This example works with MacOS, customize with the appropriate <tt>screencapture</tt> utility for other OSes.
<
use warnings;
use GD;
Line 904:
print "RGB: $red, $green, $blue\n";
unlink $file;</
{{out}}
<pre>RGB: 20, 2, 124</pre>
Line 910:
=={{header|Phix}}==
{{libheader|Phix/pGUI}}
<
An example of this in use can be found in demo/pGUI/simple_paint.exw
Line 917:
{{works with|Windows}}
{{libheader|GD}}
<
$color = imagecolorat($im, 10, 50);
imagedestroy($im);</
=={{header|PicoLisp}}==
Using '[http://www.muquit.com/muquit/software/grabc/grabc.html grabc]'
as recommended in the C solution
<
(mapcar hex (cdr (line NIL 1 2 2 2))) )</
Output:
<pre>73,61,205
Line 933:
Access any pixel value on the sketch canvas. A color in Processing is a 32-bit int, organized in four components, alpha red green blue, as AAAAAAAARRRRRRRRGGGGGGGGBBBBBBBB. Each component is 8 bits (a number between 0 and 255), and can be accessed with alpha(), red(), green(), blue().
<
color c = get(mouseX,mouseY);
println(c, red(c), green(c), blue(c));
}</
For greater speed, pixels may be looked up by index in the pixels[] array, and color components may be retrieved by bit-shifting.
<
loadPixels();
color c = pixels[mouseY * width + mouseX];
println(c, c >> 16 & 0xFF, c >> 8 & 0xFF, c >> 8 & 0xFF);
}</
=={{header|Python}}==
{{libheader|PyWin32}}
{{works_with|Windows}}
<
import win32gui
i_desktop_window_id = win32gui.GetDesktopWindow()
Line 958:
return (i_colour & 0xff), ((i_colour >> 8) & 0xff), ((i_colour >> 16) & 0xff)
print (get_pixel_colour(0, 0))</
{{libheader|PIL}}
{{works_with|Windows}}
<
import PIL.ImageGrab
return PIL.ImageGrab.grab().load()[i_x, i_y]
print (get_pixel_colour(0, 0))</
{{libheader|PIL}}
{{libheader|python-xlib}}
<
import PIL.Image # python-imaging
import PIL.ImageStat # python-imaging
Line 980:
return tuple(map(int, lf_colour))
print (get_pixel_colour(0, 0))</
{{libheader|PyGTK}}
<
import gtk # python-gtk2
o_gdk_pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, 1, 1)
Line 988:
return tuple(o_gdk_pixbuf.get_pixels_array().tolist()[0][0])
print (get_pixel_colour(0, 0))</
{{libheader|PyQt}}
<
import PyQt4.QtGui # python-qt4
app = PyQt4.QtGui.QApplication([])
Line 998:
return ((i_colour >> 16) & 0xff), ((i_colour >> 8) & 0xff), (i_colour & 0xff)
print (get_pixel_colour(0, 0))</
=={{header|Racket}}==
Line 1,008:
This example works with MacOS, customize with the appropriate <tt>screencapture</tt> utility for other OSes.
<syntaxhighlight lang="raku"
my $file = '/tmp/one-pixel-screen-capture.png';
Line 1,025:
fclose($fh);
unlink $file;</
{{out}}
<pre>RGB: 20, 2, 124</pre>
Line 1,031:
Alternately, a version that should work in any X11 environment. Needs X11::xdo and MagickWand installed.
<syntaxhighlight lang="raku"
multi MAIN () {
Line 1,083:
}
sub cleanup { print "\e[0m\e[?25h" }</
=={{header|REXX}}==
Line 1,093:
The REXX program converts the hexadecimal attribute of the character at the location of the cursor to a familiar name of a color.
<
parse value cursor() with r c . /*get cursor's location in DOS screen. */
Line 1,113:
if hue=='0E'x then color= 'yellow' /*or bright yellow. */
if hue=='0F'x then color= 'white' /*or bright, brite white. */
say 'screen location ('r","c') color is:' color /*display color of char at row, column.*/</
{{out|output}}
<pre>
Line 1,120:
=={{header|Ring}}==
<
# Project : Color of a screen pixel
Line 1,155:
b = bytes2float(b)
return [r,g,b]
</syntaxhighlight>
Output:
<pre>
Line 1,167:
This example requires ImageMagick >= 6.2.10 (works on X11, unsure about other platforms).
<
IMPORT_COMMAND = '/usr/bin/import'
Line 1,178:
end
end
end</
=={{header|Scala}}==
{{libheader|Scala}}
<
=={{header|Smalltalk}}==
{{works with|Smalltalk/X}}
<
Display rootView colorAt:(Display pointerPosition)</
=={{header|Standard ML}}==
Works with PolyML
<
val disp = XOpenDisplay "" ;
Line 1,201:
end;
XGetPixel disp im (XPoint {x=0,y=0}) ;</
result
val it = 6371827: int
Line 1,207:
{{libheader|Tk}}
Works only on X11 or OSX with Xquartz.
<
package require Tk
Line 1,228:
# Demo...
puts [format "pixel at mouse: (%d,%d,%d)" \
{*}[getPixelAtPoint {*}[winfo pointerxy .]]]</
=={{header|Wren}}==
{{libheader|DOME}}
<
import "graphics" for Canvas, Color
import "input" for Mouse
Line 1,257:
static getRGB(col) { "{%(col.r), %(col.g), %(col.b)}" }
}</
{{out}}
Line 1,271:
graphics.
<
int Color, X, Y;
Color:= ReadPix(X, Y);</
{{omit from|ACL2}}
|