Ferramenta para selecionar facilmente um pixel na tela e obter coordenadas absolutas e em cores

Estou procurando uma ferramenta que permita selecionar qualquer pixel na tela e obter sua cor RGB e localização absoluta (x, y).

Usei ferramentas no Windows que mostram um quadrado grande e ampliado com uma mira, permitindo que eu selecione com facilidade o pixel desejado e obtenha os detalhes.

Existe algo assim para o ubuntu?

O melhor ajuste é ... uma pequena ferramenta do Windows chamada ColorPix (via WINE)

Após uma pesquisa longa e árdua, parece que nenhuma das ferramentas disponíveis para Ubuntu / Linux atende aos seus critérios, como ampliação e exibição de coordenadas .

Por isso, optamos por uma pequena ferramenta do Windows que - criticamente - funciona apenas com uma instalação padrão do WINE, sem configuração, instalação, DLLs, etc.

• Possui zoom ajustável, cópia com um clique em vários formatos e coordena a exibição:

  

1. Instale o Wine

sudo apt-get install wine

(é isso aí!)

2. Faça o download do ColorPix

O ColorPix pode ser baixado oficialmente como um minúsculo portátil de 600 KB aqui

Sugiro fazer o download diretamente para o diretório de binários local com:

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

3. Crie um iniciador para o ColorPix

• Vamos pegar um ícone primeiro:

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

• Pressione Alt+F2agora e digite gksudo gedit /usr/share/applications/colorpix.desktop, cole o abaixo e salve o arquivo:

  [Entrada na área de trabalho]
  Nome = ColorPix
  GenericName = ColorPix
  Comment = ColorPicker via WINE
  Exec = wine /usr/local/bin/ColorPix.exe
  Terminal = false
  Ícone = / usr / share / icons / colorpix.png
  Tipo = Aplicação
  StartupNotify = true
  

• Em um terminal, execute:

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

• Em alguns segundos, ele estará disponível no iniciador como:

  

4. Usando o ColorPix

Inicie e, na primeira vez, pode demorar alguns segundos enquanto o WINE é inicializado.

A captura de tela abaixo mostra em ação, com:

• As coordenadas no topo
• Valores de cores em diferentes formatos abaixo (clique para copiar para a área de transferência)
• Lupa ajustável abaixo

• Pressione qualquer tecla quando estiver no pixel desejado para bloquear os valores

  

Existe uma ferramenta chamada gpick .

Aqui você pode ver uma imagem da ferramenta. Com o gpick, você pode selecionar pixels, ver o código HTML, adicionar cores à paleta e gerar cores.

Para usá-lo, clique com o botão direito do mouse no meio do hexágono e use a barra de espaço para salvar cores na paleta.

Isso fará com que você acredite. É certo que são alguns passos, mas parece pior do que é desde que mostrei cada pequeno passo.

Configuração

Instale o ImageMagick & Shutter.

sudo apt-get install imagemagick shutter

Como obter as coordenadas x, y e cor

A. Abra o Obturador e clique no botão de seleção

B. Observe que quando você move o mouse, ele mostra as coordenadas x, y que você está procurando.

Quando estiver no lugar certo, clique com o botão do mouse e desenhe um quadrado para capturar uma imagem. (Realmente não importa o tamanho da sua imagem, contanto que você a inicie (canto superior esquerdo) no pixel de seu interesse.)

C. Feche a imagem no obturador

D. Execute o seguinte comando no terminal. Isso fornecerá os valores de cores do pixel superior esquerdo.

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

E. Enquanto estiver na linha de comando, vá em frente e exclua a imagem para que, na próxima vez que o obturador tire uma foto, ele dê o mesmo nome. (Caso contrário, você precisará ajustar o nome na etapa anterior (D).

rm ~/Pictures/Selection_001.png

Cole esse código em um editor de texto, torne-o executável e execute-o. Quando você escolhe uma cor com o conta-gotas, as coordenadas x e y aparecem na parte superior.

Editar : Escreveu código para adicionar uma janela de zoom. Para que ele pegue pixels fora da janela, clique no botão (não no conta-gotas). Clique no botão novamente para parar de pegar o ponteiro. Ainda não descobri como desenhar uma mira com cairo, mas você provavelmente pode usá-lo como está. Deixei um código cairo lá, caso alguém possa me dizer por que meu retângulo não desenha…

#!/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()

Se alguém quiser fazer isso no futuro, você não precisará baixar nada (certamente não centenas de megabytes de material do Windows, como sugere outra resposta). Uma solução simples que o Ubuntu vem é xmag. O Xmag faz parte do pacote x11-apps, que já deve estar instalado por padrão.

É fácil. Execute xmag, clique para selecionar uma região da tela e mantenha pressionado o botão do mouse na visualização ampliada para ver as coordenadas exatas dos pixels.

Você pode ler o manual xmag digitando man xmag.

Tente visualizar , ele mostra coordenadas.

Você pode fazer o download da página do Doc e da página do manual aqui .