Color of a screen pixel: Difference between revisions

The mouse cursor may or may not have to be active in a GUI created by your program. These functions are OS related.

<br><br>

 

=={{header|App Inventor}}==

In the app's display below, the purple Ball sprite was touched on the left canvas, but the pixel color (green) returned was from the area below it.

[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] & _

{{Out}}

<pre>

 

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

 

=={{header|BASIC}}==

 

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

[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

[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.

 

100 REM GET HCOLOR

110 REM PARAMETERS: X Y

X = 267 : Y = 166 : GOSUB 100

HCOLOR= C

 

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

 

==={{header|Commodore BASIC}}===

The Commodore 64 hires bitmap is 320&times;200, subdivided into 8&times;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);

1220 bit=7-(x and 7):byte=base+ro*320+char*8+li:cb=1024+ro+ch

1230 return

 

'''Example 2:''' Commodore Plus 4 and 128

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

 

 

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

 

' Sleep before the program closes

 

==={{header|QuickBASIC}}===

 

In a graphics mode (for instance, <tt>SCREEN 13</tt> or <tt>SCREEN 12</tt>)

 

==={{header|Integer BASIC}}===

 

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

Struct point, x As long, y As long

 

Function GetPixel(hDC, x, y)

CallDLL #gdi32, "GetPixel", hDC As uLong, x As long, y As long, GetPixel As long

 

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

 

20 color=TEST(x,y)

 

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

 

hDC = GetDC_(0)

Color = GetPixel_(hDC, x, y)

 

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: ")

Until event=#PB_Event_CloseWindow

ReleaseDC_(0, hDC)

 

==={{header|SmileBASIC}}===

PCOL=GSPOIT(X,Y)

RGBREAD PCOL OUT R,G,B

 

==={{header|TI-89 BASIC}}===

Only the graph screen can be read.

 

 

==={{header|Visual Basic .NET}}===

 

Dim b As New Bitmap(1, 1)

Return b.GetPixel(0, 0)

 

 

==={{header|VBA}}===

This code should be adapted for 64 bits versions...

 

Option Explicit

 

Get_Color_Under_Cursor = GetPixel(lngDc, Pos.x, Pos.y)

End Function

 

==={{header|Yabasic}}===

backcolor 255, 0, 0

clear window

red = dec(left$(s$, 2))

 

 

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

=={{header|C}}==

{{libheader|Xlib}}

#include <X11/Xlib.h>

void

get_pixel_color (display, 30, 40, &c);

printf ("%d %d %d\n", c.red, c.green, c.blue);

 

{{works with|Windows}}

(Linux users, see [http://www.muquit.com/muquit/software/grabc/grabc.html grabc].)

 

COLORREF getColorAtCursor(void) {

 

return color;

 

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

using System.Drawing;

using System.Windows.Forms;

Console.WriteLine(GetPixel(Cursor.Position));

}

Sample output:

 

=={{header|C++/CLI}}==

using namespace System::Drawing;

using namespace System::Windows::Forms;

Console::WriteLine("G: "+color.G.ToString());

Console::WriteLine("B: "+color.B.ToString());

 

=={{header|Clojure}}==

 

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

Using Allegro and their Common Graphics package

 

(defun print-hex (n)

(get-pixel (position-x pos) (position-y pos))))

 

 

Sample output: (values are in RGBA order):

 

=={{header|Delphi}}==

 

program ScreenPixel;

 

 

end.

 

Example output:

 

=={{header|F_Sharp|F#}}==

open System.Windows.Forms

 

let GetPixelAtMouse () =

let pt = Cursor.Position

 

=={{header|Go}}==

{{libheader|RobotGo}}

 

import (

color := robotgo.GetPixelColor(x, y)

fmt.Printf("Color of pixel at (%d, %d) is 0x%s\n", x, y, color)

 

{{out}}

Color of pixel at (659, 253) is 0x300a24

</pre>

 

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

WDone(W) # q to exit

end

 

{{libheader|Icon Programming Library}}

x=658,y=610 pixel=47802,0,65535

x=934,y=487 pixel=0,0,0</pre>

 

=={{header|Java}}==

{{uses from|AWT|Robot}}

return new Robot().getPixelColor(x, y);

 

=={{header|Julia}}==

# Windows GDI version

function getpixelcolors(x, y)

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 {

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)

 

=={{header|Logo}}==

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

Module CheckColor {

\\ Print hex code for color, and html code for color

}

CheckColor

 

 

=={{header|Nim}}==

{{libheader|GTK2}}

gtk2.nim_init()

 

var p = pixbufNew(COLORSPACE_RGB, false, 8, 1, 1)

discard p.getFromDrawable(getDefaultRootWindow().Drawable,

getDefaultScreen().getSystemColormap(), x, y, 0, 0, 1, 1)

 

 

=={{header|Perl}}==

This example works with MacOS, customize with the appropriate <tt>screencapture</tt> utility for other OSes.

use warnings;

use GD;

print "RGB: $red, $green, $blue\n";

 

{{out}}

<pre>RGB: 20, 2, 124</pre>

=={{header|Phix}}==

{{libheader|Phix/pGUI}}

An example of this in use can be found in demo/pGUI/simple_paint.exw

 

{{works with|Windows}}

{{libheader|GD}}

$color = imagecolorat($im, 10, 50);

 

=={{header|PicoLisp}}==

Using '[http://www.muquit.com/muquit/software/grabc/grabc.html grabc]'

as recommended in the C solution

Output:

<pre>73,61,205

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()

return (i_colour & 0xff), ((i_colour >> 8) & 0xff), ((i_colour >> 16) & 0xff)

 

 

{{libheader|PIL}}

 

{{works_with|Windows}}

import PIL.ImageGrab

return PIL.ImageGrab.grab().load()[i_x, i_y]

 

{{libheader|PIL}}

{{libheader|python-xlib}}

import PIL.Image # python-imaging

import PIL.ImageStat # python-imaging

return tuple(map(int, lf_colour))

 

{{libheader|PyGTK}}

import gtk # python-gtk2

o_gdk_pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, 1, 1)

return tuple(o_gdk_pixbuf.get_pixels_array().tolist()[0][0])

 

{{libheader|PyQt}}

import PyQt4.QtGui # python-qt4

app = PyQt4.QtGui.QApplication([])

return ((i_colour >> 16) & 0xff), ((i_colour >> 8) & 0xff), (i_colour & 0xff)

 

 

=={{header|Racket}}==

 

This example works with MacOS, customize with the appropriate <tt>screencapture</tt> utility for other OSes.

 

my $file = '/tmp/one-pixel-screen-capture.png';

 

fclose($fh);

{{out}}

<pre>RGB: 20, 2, 124</pre>

Alternately, a version that should work in any X11 environment. Needs X11::xdo and MagickWand installed.

 

 

multi MAIN () {

}

 

 

=={{header|REXX}}==

 

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. */

 

if hue=='0E'x then color= 'yellow' /*or bright yellow. */

if hue=='0F'x then color= 'white' /*or bright, brite white. */

{{out|output}}

<pre>

 

=={{header|Ring}}==

# Project : Color of a screen pixel

 

b = bytes2float(b)

return [r,g,b]

Output:

<pre>

</pre>

 

=={{header|Ruby}}==

This example requires ImageMagick >= 6.2.10 (works on X11, unsure about other platforms).

 

IMPORT_COMMAND = '/usr/bin/import'

 

end

end

 

=={{header|Scala}}==

{{libheader|Scala}}

 

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

Works with PolyML

val disp = XOpenDisplay "" ;

 

end;

 

result

val it = 6371827: int

{{libheader|Tk}}

Works only on X11 or OSX with Xquartz.

package require Tk

 

# Demo...

puts [format "pixel at mouse: (%d,%d,%d)" \

 

=={{header|XPL0}}==

graphics.

 

int Color, X, Y;

 

{{omit from|ACL2}}

{{omit from|Blast}}

{{omit from|Brainf***}}

{{omit from|GUISS}}

{{omit from|Lilypond}}