Herramienta para seleccionar fácilmente un píxel en la pantalla y obtener color y coordenadas absolutas

Estoy buscando una herramienta que me permita seleccionar cualquier píxel en la pantalla y obtener su color RGB y su ubicación absoluta (x, y).

He usado herramientas en Windows que muestran un gran cuadrado ampliado con una cruz que me permite seleccionar fácilmente el píxel que quiero y obtener sus detalles.

¿Hay algo como esto para ubuntu?

El mejor ajuste es ... una pequeña herramienta de Windows llamada ColorPix (a través de WINE)

Después de buscar mucho, parece que ninguna de las herramientas disponibles para Ubuntu / Linux cumple con ambos criterios, es decir, aumento y visualización de coordenadas .

Entonces, buscamos una pequeña herramienta de Windows que, críticamente , simplemente funciona con una instalación WINE predeterminada, no se necesita configuración, instalación, DLL, etc.

• Cuenta con zoom ajustable, copia con un clic en múltiples formatos y visualización coordinada:

  

1. Instalar Wine

sudo apt-get install wine

(¡Eso es!)

2. Descarga ColorPix

ColorPix se puede descargar oficialmente como un pequeño y portátil 600KB exe aquí

Sugiero descargar directamente a su directorio local de binarios con:

sudo wget -O/usr/local/bin/ColorPix.exe http://www.colorschemer.com/ColorPix.exe

3. Crear un lanzador para ColorPix

• Primero obtengamos un icono:

  sudo wget -O/usr/share/icons/colorpix.png http://cdn.alternativeto.net/i/22e49edc-efa7-e011-979d-0025902c7e73_11865.png
  

• Presione Alt+F2ahora y escriba gksudo gedit /usr/share/applications/colorpix.desktop, y pegue el siguiente y guarde el archivo:

  [Entrada de escritorio]
  Nombre = ColorPix
  GenericName = ColorPix
  Comentario = ColorPicker a través de WINE
  Exec = wine /usr/local/bin/ColorPix.exe
  Terminal = falso
  Icon = / usr / share / icons / colorpix.png
  Tipo = Aplicación
  StartupNotify = true
  

• Desde una terminal, ejecute:

  sudo chmod +x /usr/share/applications/colorpix.desktop
  

• En unos segundos, estará disponible en el iniciador como:

  

4. Usando ColorPix

Comience, y la primera vez puede tomar unos segundos mientras se inicializa WINE.

La siguiente captura de pantalla lo muestra en acción, con:

• Las coordenadas en la parte superior
• Valores de color en diferentes formatos a continuación (haga clic para copiar al portapapeles)
• Lupa ajustable a continuación

• Presione cualquier tecla una vez que esté en el píxel deseado para bloquear valores

  

Hay una herramienta llamada gpick .

Aquí puedes ver una imagen de la herramienta. Con gpick puede seleccionar píxeles, ver el código HTML, agregar colores a la paleta y generar colores.

Para usarlo, haga clic derecho en el centro del hexágono y luego use la barra espaciadora para guardar los colores en la paleta.

Esto te dará lo que quieres, creo. Es cierto que son unos pocos pasos, pero se ve peor de lo que es desde que mostré cada pequeño paso.

Preparar

Instale ImageMagick & Shutter.

sudo apt-get install imagemagick shutter

Cómo obtener las coordenadas x, y color y

A. Abra Shutter y haga clic en el botón de selección.

B. Tenga en cuenta que a medida que mueve el mouse, le mostrará las coordenadas x, y que está buscando.

Cuando tengas el lugar correcto, haz clic con el botón del mouse y dibuja un cuadrado para capturar una imagen. (Realmente no importa qué tan grande sea su imagen siempre que la inicie (esquina superior izquierda) en el píxel de interés).

C. Cerrar la imagen en el obturador

D. Ejecute el siguiente comando desde la terminal. Esto le dará los valores de color del píxel superior izquierdo.

convert ~/Pictures/Selection_001.png -crop 1x1+1+1 txt:- | sed -n 's/.* \(#.*\)/\1/p' 

E. Mientras está en la línea de comando, continúe y elimine la imagen para que la próxima vez que el obturador tome una foto le dé el mismo nombre. (De lo contrario, deberá ajustar el nombre en el paso anterior (D).

rm ~/Pictures/Selection_001.png

Pegue este código en un editor de texto, hágalo ejecutable y ejecútelo. Cuando elige un color con el cuentagotas, las coordenadas xey aparecerán en la parte superior.

Editar : escribió el código para agregar una ventana de zoom. Para que tome píxeles fuera de la ventana, haga clic en el botón (no en el cuentagotas). Vuelva a hacer clic en el botón para dejar de tomar el puntero. No he descubierto cómo dibujar una cruz con el cairo, pero probablemente puedas usarlo como está. Dejé un código de cairo allí en caso de que alguien pueda decirme por qué mi rectángulo no se dibuja ...

#!/usr/bin/python
from gi.repository import Gtk,Gdk, GdkPixbuf
import cairo

class picker(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.connect('delete-event', Gtk.main_quit)
        self.connect('motion-notify-event', self.motion_cb)
        self.connect('button-press-event',self.button_press)
        box=Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)

        #Setup area for coordinates and zoom window
        coordbox=Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.xcoor=Gtk.Label("x: ")
        coordbox.pack_start(self.xcoor, True, False, 1)
        self.ycoor=Gtk.Label("y: ")
        coordbox.pack_start(self.ycoor, True, False, 1)
        self.zoomwin=Gtk.Image()
        #Trying to draw on Gtk.Image with cairo for crosshairs... Not working
        self.zoomwin.connect('draw', self.draw) 
        self.zoomwin.set_app_paintable(True)
        coordbox.pack_start(self.zoomwin,True,True,1)
        self.buttongo=Gtk.Button("Pick Color")
        self.buttongo.connect('clicked',self.gobutton_activate)
        coordbox.pack_start(self.buttongo,True,True,1)
        box.pack_start(coordbox, True, False, 5)

        #Put in color wheel for tweaking color
        self.cp=Gtk.ColorSelection()
        self.cp.connect('color-changed', self.on_color_changed)
        box.pack_start(self.cp, True, True, 5)
        self.add(box)
        self.show_all()

        #Set some initial parameters
        self.w,self.h=10,10 #Size of zoomed image in pixels
        self.count=0
        self.window=self.get_window()
        #set initial zoom image
        self.zoomwin.set_from_pixbuf(self.get_image().scale_simple(240,240,GdkPixbuf.InterpType.TILES))
        self.grabbing=False

    def on_color_changed(self,widget=None, data=None):
        #Print out x,y to widgets
        display=Gdk.Display.get_default()
        (screen,x,y,modifier)=display.get_pointer()
        self.xcoor.set_text("x: %i" %x)
        self.ycoor.set_text("y: %i" %y)


    def get_image(self,w=None,h=None):
        #Get a pixbuff image under pointer
        if w==None: w=self.w
        if h==None: h=self.h
        display=Gdk.Display.get_default()
        (screen,self.x,self.y,modifier)=display.get_pointer()
        window=Gdk.get_default_root_window()
        screenshot = Gdk.pixbuf_get_from_window(window,
            self.x-int(w/2), self.y-int(h/2), int(w), int(h))
        return screenshot

    def motion_cb(self, widget, data):
        #What to do while mouse pointer is moving
        #DONT capture every event! Causes too much backup
        if self.count==5:
            self.pixbuf=self.get_image().scale_simple(240,240,GdkPixbuf.InterpType.TILES)
            self.zoomwin.set_from_pixbuf(self.pixbuf)
            self.zoomwin.queue_draw()
            self.count=0
        self.count+=1

    def grab_start(self):
        #Grab control of pointer outside of window
        self.grabbing = True
        Gdk.pointer_grab(self.window, 
                        True, #allow passage of pointer events to children
                        Gdk.EventMask.POINTER_MOTION_MASK | Gdk.EventMask.BUTTON_PRESS_MASK | Gdk.EventMask.BUTTON_RELEASE_MASK,
                        None,
                        None,# could put a custom cursor here
                        0L)

    def button_press(self,widget,data):
        #capture color under the pointer and set the color selection
        cenpx=self.get_image(1,1)
        color=tuple(map(ord, cenpx.get_pixels()[:3]))
        col=Gdk.RGBA(float(color[0])/256.,float(color[1])/256.,float(color[2])/256.)
        self.cp.set_current_rgba(col)

    def grab_stop(self):
        #Stop Grabbing the pointer
        Gdk.pointer_ungrab(0)
        self.grabbing=False     

    def gobutton_activate(self, widget, data=None):
        #Button control
        if self.grabbing==False:
            self.grab_start()
            widget.set_label("Stop Picking")
        else:
            self.grab_stop()
            widget.set_label("Pick Color")

    def draw(self, widget, cr):
        #this gets called, but nothing is drawn that I can see...
        cr.set_operator(cairo.OPERATOR_SOURCE)
        cr.set_source_rgba(1,1,1,1)
        w = self.w
        h = self.h
        cr.set_source_rgba(1,1,1,1)
        cr.set_line_width(10)
        cr.rectangle(w/2-1,h/2-1,w/2+1,h/2+1)
        cr.stroke()
        cr.set_operator(cairo.OPERATOR_OVER)


if __name__=="__main__":
    win=picker()
    Gtk.main()

Si alguien quiere hacer esto en el futuro, no necesita descargar nada (ciertamente no cientos de megabytes de material de Windows como sugiere otra respuesta). Una solución simple que viene con Ubuntu es xmag. Xmag es parte del paquete x11-apps que ya debería estar instalado por defecto.

Es fácil. Ejecute xmag, haga clic para seleccionar una región de la pantalla, luego mantenga presionado el botón del mouse en la vista ampliada para ver las coordenadas exactas de los píxeles.

Puede leer el manual de xmag escribiendo man xmag.

Prueba imview , muestra coordenadas.

Puede descargar su página Doc y su página man aquí .