Discussion :

[PauseKawa]

Bonjour,

Dans le cadre de ma découverte de socket (c'est un module que j'avais laisser de coté car je n'en avais pas l'utilité) et après avoir envoyer des fichiers j'aimerais maintenant faire une capture du client (capture/réduction de la taille/découpage/comparaison des morceaux différents > envoie des parties différentes > affichage dans un canvas).
Jusque la pas de problème, du moins sous tux (ImageMagic) ou windows (PIL/ImageGrab), mais sous Mac ?
J'ai bien fait une recherche sur le site et le web mais je n'ai rien trouver.
Comme la chose se complique car je n'ai pas de mac est ce que quelqu'un aurais une solution testée ? (oui, je sais : je suis gourmand)

Edit : Existe il (je n'ai trouver dans ce sens) un module multiplateforme (j'en doute) ?

Merci d'avance

[rambc]

Bonjour,
que te faut-il exactement ?

Au passage, pourrais-tu mettre ici un code minimal montrant comment tu as fait tes captures sous Linux et Windaube ? On pourrait alors tenter d'avoir une solution multi-plateforme si je trouve quelque chose qui fonctionne sous Mac.

[VinsS]

Avec PyQt tu ne devrais pas avoir de problème sous Mac.

Dans les exemples, sous-dossier desktop, il y a un script de capture, je le joins, si tu ne l'as pas.

[PauseKawa]

Bonjour,

Merci pour le QPixmap.grabWindow VinsS. Je ne suis pas trop habitué à Qt et je suis passé à coté. Bien que cela me gène un peut d'importer Qt dans le client je vais regarder cela de plus prêt.

@rambc: Pour le moment il n'y a pas grand chose et je dois dire qu'a l'heure actuelle je recherche plus a travailler en mémoire plutôt que de créer un fichier.
Mon code de base pour tester la capture:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import sys
import os
 
fichier = file
class screencap():
    def __init__(self):
        nomfichier = "scrcap.jpg"
        self.fichier = os.path.join('/tmp', nomfichier)
        if sys.platform == 'linux2':
            self.grab = self._GarbLinux
        elif sys.platform == 'win32':
            import Image, ImageGrab
            self.grab = self._GrabWin
        elif sys.platform == 'darwin':
            self.grab = self._GrabMac
        else:
            pass # TODO
 
    def _GarbLinux(self):
        #_commande = "xwd -frame | convert xwd:- -colors 8 +dither > stdout"
        # fichier = os.system(_commande)
        _commande = "import -silent -window root " + self.fichier
        os.system(_commande)
        return self.fichier
 
    def _GrabWin(self):
        ImageGrab.grab().save(self.fichier, "JPEG")
        return self.fichier
 
    def _GrabMac(self):
        # TODO
        pass
 
if __name__ == "__main__":
    sccap = screencap()
    img = sccap.grab()
    import Tkinter as Tk
    from PIL import Image, ImageTk
    root =Tk.Tk()
    c = Tk.Canvas(root)
    c.pack()
    fcapture = Image.open(img)
    photo = ImageTk.PhotoImage(fcapture)
    l = Tk.Label(image=photo)
    l.image = photo
    l.pack()
    root.mainloop()

Merci

[rambc]

Bon je ne vais pas être d'un grand secours alors car je ne me suis jamais penché sur la question.

sous tux (ImageMagic)

Via le lourding MacPort, on a Imagemagick qui s'utilise en ligne de commande.

[PauseKawa]

Merci rambc,

En fait je suis tombé sur cela:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
import sys
import os
 
fichier = file
class ScreenCap():
    def __init__(self):
        self.fichier = os.path.join(os.environ['HOME'], 'scrcap.jpg')
        if sys.platform == 'linux2':
            self.grab = self._GarbLinux
        elif sys.platform == 'win32':
            import Image, ImageGrab
            self.grab = self._GrabWin
        elif sys.platform == 'darwin':
            self.grab = self._GrabMac
        else:
            pass # TODO
 
    def _GarbLinux(self, name=None):
        if name:
            if os.path.basename(name) == name:
                _fichier = os.path.join(os.environ['HOME'], name)
            else:
                _fichier = name
        else:
            _fichier = self.fichier
        try:
            _commande = "import -silent -window root " + _fichier
            os.system(_commande)
        except:
            # Utiliser convert ?
            _commande = "xwd -frame | convert xwd:- -colors 8 +dither " + _fichier
            os.system(_commande)
        return _fichier
 
    def _GrabWin(self, name=None):
        if name:
            if os.path.basename(name) == name:
                _fichier = os.path.join(os.environ['HOME'], name)
            else:
                _fichier = name
        else:
            _fichier = self.fichier
        ImageGrab.grab().save(_fichier, "JPEG")
        return _fichier
 
    def _GrabMac(self, name=None):
        if name:
            if os.path.basename(name) == name:
                _fichier = os.path.join(os.environ['HOME'], name)
            else:
                _fichier = name
        else:
            _fichier = self.fichier
        # A partir de Darwin 6.0.
        # Est il possible d'utiliser Grab ou Preview en ligne de commande ?
        _commande = "screencapture -m -x -t jpg " + _fichier
        os.system(_commande)
        return _fichier
 
if __name__ == "__main__":
    sccap = ScreenCap()
    img = sccap.grab(name='test.jpg')
    import Tkinter as Tk
    from PIL import Image, ImageTk
    root =Tk.Tk()
    root.title('Capture')
    fcapture = Image.open(img)
    photo = ImageTk.PhotoImage(fcapture)
    c = Tk.Canvas(root, width=photo.width(), height=photo.height())
    c.pack()
    c.create_image(0, 0, image = photo, anchor=Tk.NW)
    root.mainloop()

Je ne sais pas si cela fonctionne mais ça correspondrait plus.

Bon code

[rambc]

Bonjour.

Je ne sais pas si cela fonctionne mais ça correspondrait plus.

Je viens de tester sur mon Mac. J'ai dû faire modifier from PIL import Image, ImageTk en import Image, ImageTk.

L'image est créée mais la partie Tkinter ne marche pas. photo = ImageTk.PhotoImage(fcapture) provoque l'erreur suivante :

Traceback (most recent call last):
File "/Users/moi/test.pyw", line 74, in <module>
photo = ImageTk.PhotoImage(fcapture)
File "/Library/Frameworks/Python.framework/Versions/2.6/lib/python2.6/site-packages/PIL-1.1.7-py2.6-macosx-10.3-fat.egg/ImageTk.py", line 116, in __init__
self.paste(image)
File "/Library/Frameworks/Python.framework/Versions/2.6/lib/python2.6/site-packages/PIL-1.1.7-py2.6-macosx-10.3-fat.egg/ImageTk.py", line 166, in paste
im.load()
File "/Library/Frameworks/Python.framework/Versions/2.6/lib/python2.6/site-packages/PIL-1.1.7-py2.6-macosx-10.3-fat.egg/ImageFile.py", line 189, in load
d = Image._getdecoder(self.mode, d, a, self.decoderconfig)
File "/Library/Frameworks/Python.framework/Versions/2.6/lib/python2.6/site-packages/PIL-1.1.7-py2.6-macosx-10.3-fat.egg/Image.py", line 385, in _getdecoder
raise IOError("decoder %s not available" % decoder_name)
IOError: decoder jpeg not available

[PauseKawa]

Bonsoir,

Merci pour ton aide rambc.

La partie intéressante pour moi étant la capture je n'ai pas fignoler le code de test.
J'ai presque ce que je voulais : L'écriture sur le disque est trop lourde pour que je l'utilise dans mon but premier. Je vais donc me contenter d'envoyer la capture d'écran du client (facile puisque c'est fichier) avant d'avoir le niveau (pas demain la veille...) pour me lancer dans un vnc-like.
Par contre je ne vais pas laisser ce code tel quel sur le forum et je posterai dès que possible quelque chose de propre, au cas ou cela serve à quelqu'un.

Encore merci et à bientôt.

Patrice

[rambc]

Par contre je ne vais pas laisser ce code tel quel sur le forum et je posterai dès que possible quelque chose de propre, au cas ou cela serve à quelqu'un.

Cela m'intéresse. Je voulais nettoyer ton code mais si tu le fais, je serais patient.

Tiens-nous au courant ici.

[PauseKawa]

Oups... J'avais oublier ce sujet...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
import sys
import os
 
class screencap():
    def __init__(self):
        if sys.platform == 'linux2':
            self.grab = self._garblinux
        elif sys.platform == 'win32':
            self.grab = self._grabwin
        elif sys.platform == 'darwin':
            self.grab = self._grabmac
        else:
            pass # TODO
 
    def _ficnormalyze(self, name):
        if name:
            if os.path.basename(name) == name:
                _fichier = os.path.join(os.path.expanduser('~'), name)
            else:
                _fichier = name
        else:
            _fichier = os.path.join(os.path.expanduser('~'), 'scrcap.gif')
        return _fichier
 
    def _garblinux(self, name=None):
        _fichier = self._ficnormalyze(name)
        _commande = "import -silent -window root " + _fichier
        os.system(_commande)
        return _fichier
 
    def _grabwin(self, name=None):
        import ImageGrab
        _fichier = self._ficnormalyze(name)
        ImageGrab.grab().save(_fichier, "GIF")
        return _fichier
 
    def _grabmac(self, name=None):
        _fichier = self._ficnormalyze(name)
        _commande = "screencapture -m -x -t gif " + _fichier
        os.system(_commande)
        return _fichier
 
if __name__ == "__main__":
 
    sccap = screencap()
    img = sccap.grab(name='test.gif')
 
    try:
        import tkinter as Tk
    except:
        import Tkinter as Tk
 
    root =Tk.Tk()
    root.title('screencap demo')
    photo = Tk.PhotoImage(file=img)
    label = Tk.Label(root, image=photo)
    label.image = photo
    label.pack()
    root.mainloop()

Mais bon : Comme je ne sais pas comment utiliser screencapture pour travailler avec le stdout et non un fichier (import - sous linux/cStringIO, base64 pour ImageGrab) et que je ne compte pas passer par QT ou GTK j'ai laisser tomber.

Merci en tout cas.

[rambc]

Merci.

Le code fonctionne sans souci sous Mac O$ avec Python 3.

[JeitEmgie]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
usage: screencapture [-icMPmwsWxSCUto] [files]
  -c         force screen capture to go to the clipboard
  -C         capture the cursor as well as the screen. only in non-interactive modes
  -d         display errors to the user graphically
  -i         capture screen interactively, by selection or window
               control key - causes screen shot to go to clipboard
               space key   - toggle between mouse selection and
                             window selection modes
               escape key  - cancels interactive screen shot
  -m         only capture the main monitor, undefined if -i is set
  -M         screen capture output will go to a new Mail message
  -o         in window capture mode, do not capture the shadow of the window
  -P         screen capture output will open in Preview
  -s         only allow mouse selection mode
  -S         in window capture mode, capture the screen not the window
  -t<format> image format to create, default is png (other options include pdf, jpg, tiff and other formats)
  -T<seconds> Take the picture after a delay of <seconds>, default is 5
  -w         only allow window selection mode
  -W         start interaction in window selection mode
  -x         do not play sounds
  files   where to save the screen capture, 1 file per screen

+ à compiler avec XCode (projet Application->Command line Tool + ajouter le framework AppKit)
et à installer dans le $PATH de l'utilisateur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
#import <Foundation/Foundation.h>
#import <AppKit/AppKit.h>
 
int main (int argc, const char * argv[]) {
	if (argc < 2) {
		fprintf(stderr,"Usage %s [public.png | com.adobe.pdf | public.jpeg | public.jpeg-2000 | public.tiff | com.microsoft.bmp | com.truevision.tga-image | com.compuserve.gif]\n",argv[0]) ;
		return 1 ;
	}
 
	NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
	NSString *format = [NSString stringWithCString:argv[1] encoding: NSUTF8StringEncoding] ;
 
	NSPasteboard *pb = [NSPasteboard generalPasteboard] ;
 
	for(NSPasteboardItem *item in [pb pasteboardItems]) {
		NSData *d = [item dataForType:format] ;
		if (d != nil)
			write(1, [d bytes], [d length]);
		else
			fprintf(stderr,"no data for format %s\n",argv[1]) ;
	}
 
    [pool drain];
    return 0;
}

si pbbinpaste est le nom du programme compilé ci-dessus :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
screencapture -c -tpng
pbbinpaste public.png | YOUR_TOOL

[rambc]

Bonjour,
j'ai oublié mon décodeur... Plus sérieusement, c'est à compiler pour quelle architecture ? Cela permet de résoudre quel problème ?

[JeitEmgie]

Bonjour,
j'ai oublié mon décodeur... Plus sérieusement, c'est à compiler pour quelle architecture ? Cela permet de résoudre quel problème ?

Pour Mac OS X.

Cela permet d'avoir le presse-papiers sur stdout en stream binaire après avoir utiliser screencapture pour mettre la copie d'écran dedans.
(la commande pbpaste fournie ne sortant pas du binaire sur stdout… voir man pbpaste et pbcopy)

Tout cela, si vous tenez à utiliser le presse-papiers pour ne pas avoir à manipuler de fichier explicitement dans le code… (même si le presse-papiers, lui, en utilise un dès qu'il l'estime nécessaire…)

[PauseKawa]

Une fois compilé as ton besoin du framework ?
Je m'explique : Je peux très bien inclure le binaire dans le code et le mettre dans le path si besoin.

Edit: Si oui est il possible d'avoir le fichier compilé (je n'ai pas de mac)

[JeitEmgie]

Une fois compilé as ton besoin du framework ?
Je m'explique : Je peux très bien inclure le binaire dans le code et le mettre dans le path si besoin.

Edit: Si oui est il possible d'avoir le fichier compilé (je n'ai pas de mac)

Les frameworks Foundation et AppKit sont partie intégrante de l'OS, les programmes qui les utilisent s'y lient dynamiquement.

le "ajouter le framework AppKit" ci-dessus ne concerne que la compilation via le setup du projet Xcode : pour que le path des headers du framework soit ajouté aux options de compilation et le path de la dylib ajouté aux options de link.

le zip attaché contient le binaire pour 10.6 + un autre utilitaire "pbformat" qui dump les formats de chaque item présent dans le paste board, sous forme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
Item #: space separated list of UTI strings

[PauseKawa]

Bonsoir,

Quelques questions :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
screencapture -c -tpng
pbbinpaste public.png | YOUR_TOOL

Dois je comprendre que je dois faire un pipe vers YOUR_TOOL ?
Faire un pipe avec subprocess pas de problème mais là...

Il me semble que l'utilisation du presse-papiers/paste board est hasardeuse non ? D'où le pbformat sans doute ? Les sorties de pbformat pour repérer les images ?

Merci

[JeitEmgie]

Bonsoir,

Quelques questions :


Dois je comprendre que je dois faire un pipe vers YOUR_TOOL ?
Faire un pipe avec subprocess pas de problème mais là...

Il me semble que l'utilisation du presse-papiers/paste board est hasardeuse non ? D'où le pbformat sans doute ? Les sorties de pbformat pour repérer les images ?

Merci

En Python vous devez pouvoir lancer un subprocess et récupérer via un pipe son STDOUT…
(voir : import pipes, import subprocess et Popen)

pbbinpaste est juste un outil utile dans un script shell quand il faut avoir un stream binaire sur STDOUT car le pbpaste fourni par Mac OS X ne sort que le texte, et donc RIEN si le presse-papiers ne contient qu'une image ou tout autre format binaire. (Évidemment ne pas utilisez pbbinpaste dans un Terminal sans rediriger la sortie si vous ne voulez pas risquer d'envoyer des commandes bizarres au shell courant…et par exemple vous retrouvez en mode graphique…)

pbformat est juste-là pour vérifier les UTI utilisées après un "copier" dans une application, car les applications documentent rarement à ce niveau technique les formats de presse-papiers qu'elles utilisent et comme il faut donner à pbbincopy l'UTI de ce que l'on désire…
Il permet donc aussi d'implémenter un test dans un script shell pour éviter de traiter de "mauvaises" données : si le contenu du presse-papiers n'est pas ce qu'on attend c'est qu'il y a eu une erreur à l'étape précédente…

[PauseKawa]

Bonjour,

Cela donnerais donc quelque chose comme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
import sys
import os
import base64
import cStringIO
 
class screencap():
    def __init__(self):
        if sys.platform == 'linux2':
            self.grab = self._garblinux
        elif sys.platform == 'win32':
            self.grab = self._grabwin
        elif sys.platform == 'darwin':
            self.grab = self._grabmac
        else:
            pass # TODO
 
    def _garblinux(self):
        import subprocess
        import Image
        _image = subprocess.Popen(["import -silent -windows root -"], stdout=subprocess.PIPE, universal_newlines=True, shell=True)
        _fimg = cStringIO.StringIO()
        _source = cStringIO.StringIO(_image.stdout.read())
        # La conversion du postcript avec Image.save est trop longue
        Image.open(_source).save(_fimg, 'GIF')
        return base64.encodestring(_fimg.getvalue())
 
    def _grabwin(self):
        import ImageGrab
        _image = ImageGrab.grab()
        _fimg = cStringIO.StringIO()
        _image.save(_fimg, 'GIF')
        # _fimg = cStringIO.StringIO()
        # ImageGrab.grab().save(_fimg, 'GIF')
        return base64.encodestring(_fimg.getvalue())
 
    def _writepbbinpaste(self):
        datas = """voir note"""
        # Quelle cle de os.environ utiliser ?
        with open(os.path.join(os.path.expanduser('~'), 'pbbinpaste'), 'w') as newpbbinp:
            newpbbinp.write(base64.b64decode(datas))
 
    def _writepbformat(self):
        datas = """voir note"""
        # Quelle cle de os.environ utiliser ?
        with open(os.path.join(os.path.expanduser('~'), 'pbformat'), 'w') as newpbbinp:
            newpbbinp.write(base64.b64decode(datas))
 
    def _grabmac(self):
        import Image
        # Quelle cle de os.environ utiliser ?
        if not os.path.isfile(os.path.join(os.path.expanduser('~'), 'pbbinpaste')):
            self._writepbbinpaste()
        if not os.path.isfile(os.path.join(os.path.expanduser('~'), 'pbformat')):
            self._writepbformat()
        _commande = "screencapture -c -tpng"
        os.system(_commande)
        # _testformat = subprocess.Popen(["pbformat"], stdout=subprocess.PIPE, universal_newlines=True, shell=True)
        # if ? in _testformat ?
        _image = subprocess.Popen(["pbbinpaste public.png"], stdout=subprocess.PIPE, universal_newlines=True, shell=True)
        _fimg = cStringIO.StringIO()
        _source = cStringIO.StringIO(_image.stdout.read())
        # Pas oblige. Autant envoyer le png direct.
        Image.open(_source).save(_fimg, 'GIF')
        return base64.encodestring(_fimg.getvalue())
 
if __name__ == "__main__":
    sccap = screencap()
    img = sccap.grab()
 
    try:
        import tkinter as Tk
    except:
        import Tkinter as Tk
 
    root =Tk.Tk()
    root.title('screencap demo')
    photo = Tk.PhotoImage(data=img) # data= : c'est du base64
    label = Tk.Label(root, image=photo)
    label.image = photo
    label.pack()
    root.mainloop()

Note: J'ai supprimer les datas pour la lecture. Voir le zip.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
import base64
 
#chbin = base64.b64decode(''.join(lch64))
 
out = open('pbformat.out', 'w')
ch = open('pbformat', 'rb')
ch64 = '"""'
ch64 = ch64 + base64.b64encode(ch.read())
ch64 = ch64 + '"""'
ch.close()
out.write(ch64)
out.close()

C'est cela ?

Merci

Edit 'w' et non 'wb'

[JeitEmgie]

Si c'est pour sauver finalement dans un fichier GiF, faites directement un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
screencapture -tgif PATH_TO_DESTINATION_FILE