[C#] Screenshot et flux

Version imprimable

Bonsoir,
a tous je realiser des screenshots grace a ce code :
Code:

1 2 3 4 5 Bitmap bmpScreenshot = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height, PixelFormat.Format32bppArgb); Graphics gfxScreenshot = Graphics.FromImage(bmpScreenshot); gfxScreenshot.CopyFromScreen(Screen.PrimaryScreen.Bounds.X, Screen.PrimaryScreen.Bounds.Y, 0, 0, Screen.PrimaryScreen.Bounds.Size, CopyPixelOperation.SourceCopy); bmpScreenshot.Save("img.png", ImageFormat.Png);
J'aurai voulu savoir comment stocker l'image dans un string afin que je puisse l'envoyer par socket ?

Merci d'avance,
Cordialement,
NeoKript

01/12/2009, 22h14
Pol63

tu doit pouvoir l'envoyer en tant que variable image avec .net remoting par socket

sinon tu peux transformer l'image en tableau d'octets avec .save et la surcharge qui demande un string je crois
02/12/2009, 11h01
alexadvance

Sinon, tu peux regarder du coté de la classe MemoryStream qui te permet de stocker le flux mémoire d'une image.

http://msdn.microsoft.com/fr-fr/libr...8VS.95%29.aspx

La classe System.Drawing.Image à une fonction Save() permettant de stocker l'image dans un MemoryStream.

Bonjour et merci pour vos réponses.

J'ai essayé ceci d'un côté

Code:

1
2
3
4
5
6
7
8
9
10
11
        private void    ScreenShot(String Destinataire, String Commande, String Elem)
        {
            Bitmap bmpScreenshot = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height, PixelFormat.Format32bppArgb);
            Graphics gfxScreenshot = Graphics.FromImage(bmpScreenshot);
            gfxScreenshot.CopyFromScreen(Screen.PrimaryScreen.Bounds.X, Screen.PrimaryScreen.Bounds.Y, 0, 0, Screen.PrimaryScreen.Bounds.Size, CopyPixelOperation.SourceCopy);
            MemoryStream m = new MemoryStream();
            bmpScreenshot.Save(m, ImageFormat.Png);
            String content = Convert.ToString(m);
            String packet = Packet.BuildPacket(Destinataire, Commande, content);
            this.PushSend(packet);
        }

et ce la de l'autre :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
        private void ScreenShot(String Content)
        {
            try
            {
                MemoryStream m = new MemoryStream(System.Text.Encoding.ASCII.GetBytes(Content));
                Bitmap bmp = new Bitmap(m);
                bmp.Save("C:\\coucou.png");
            }
            catch (Exception e)
            {
                String test = e.Message;
            }
        }

Cependant j'ai une exception test vaut

Citation:

"Le paramètre n'est pas valide.."

a cette ligne =>

Code:

Bitmap bmp = new Bitmap(m);

Si vous avez une idée.
Merci d'avance.

Cordialement,
NeoKript

02/12/2009, 15h06
Pol63

l'erreur vient surement du fait que les octets obtenus et les octets récupérés de l'autre coté ne sont pas les même

si tu as plus de 8ko à transférer, le socket coupe la trame en plusieurs partie

Bonjour,
Pour un transfert via le réseau en mode texte, passé par un encoding en base 64 peut être une idée ;)
Code:

1 2 3 4 MemoryStream ms = new MemoryStream(); // Save to memory using the Jpeg format bmp.Save (ms, ImageFormat.Jpeg); string base64String = System.Convert.ToBase64String(ms.GetBuffer(),0,ms.GetBuffer().Length

02/12/2009, 15h10
NeoKript

Concernant la trame elle est complète...

J'ai un buffer tournant et pour chaque trame, j'envoie la taille du packet en début de packet (codé sur 3 octects).

Pour l'encodage en base 64 je ne voit pas trop l'intérêt pourrais-tu développer ?

EDIT ->

En fait le souci cést que :

Code:

Convert.ToString(m);

renvoie

Citation:

"System.IO.MemoryStream"

Merci !

J'ai corriger cela maintenant j'ai les bonnes trames avec les bon caractères
"?PNG\n\t\0\0->" ... etc

Voici le code ...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
        private void    ScreenShot(String Destinataire, String Commande, String Elem)
        {
            Bitmap bmpScreenshot = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height, PixelFormat.Format32bppArgb);
            Graphics gfxScreenshot = Graphics.FromImage(bmpScreenshot);
            gfxScreenshot.CopyFromScreen(Screen.PrimaryScreen.Bounds.X, Screen.PrimaryScreen.Bounds.Y, 0, 0, Screen.PrimaryScreen.Bounds.Size, CopyPixelOperation.SourceCopy);
            DateTime d = DateTime.Now;
            String name = Convert.ToString(d.Year) + "-" + Convert.ToString(d.Month).PadLeft(2, '0') + "-" + Convert.ToString(d.Day).PadLeft(2, '0') + "__" + Convert.ToString(d.Hour).PadLeft(2, '0') + "-" + Convert.ToString(d.Minute).PadLeft(2, '0') + "-" + Convert.ToString(d.Second).PadLeft(2, '0') + ".png";
            MemoryStream m = new MemoryStream();
            bmpScreenshot.Save(m, ImageFormat.Png);
            String content = System.Text.Encoding.ASCII.GetString(m.GetBuffer());
            String packet = Packet.BuildPacket(Destinataire, Commande, content);
            this.PushSend(packet);
        }

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
        private void ScreenShot(String Content)
        {
            try
            {
                MemoryStream m = new MemoryStream((System.Text.Encoding.ASCII.GetBytes(Content)));
                Bitmap bmp = new Bitmap(m);
                bmp.Save("C:\\coucou.png");
            }
            catch (Exception e)
            {
                String test = e.Message;
            }
        }

Si vous avez une idée ...
Merci

02/12/2009, 15h37
jesus144

Bonjour,
Je passais sur le poste et j'ai posté un peu vite sans voir les derniers messages qui sont arrivés pendant ma rédaction ;)

Je me disais juste qu'une conversion en base 64 permettrait de passer vite fait d'un byte[] en string en étant sur de finir avec quelque chose de facile à envoyer (être sur de n'avoir que des caractères affichables, pas d'octet à zéro...)

Dac mais le fait d'encoder en base 64 on perd de la place du coup .. non ?

bon j'ai fait un projet de test et cela ne passe pas ...

Code:

1
2
3
4
5
6
7
8
9
10
 
            Bitmap bmpScreenshot = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height, PixelFormat.Format32bppArgb);
            Graphics gfxScreenshot = Graphics.FromImage(bmpScreenshot);
            gfxScreenshot.CopyFromScreen(Screen.PrimaryScreen.Bounds.X, Screen.PrimaryScreen.Bounds.Y, 0, 0, Screen.PrimaryScreen.Bounds.Size, CopyPixelOperation.SourceCopy);
            MemoryStream m = new MemoryStream();
            bmpScreenshot.Save(m, ImageFormat.Png);
            String content = System.Text.Encoding.ASCII.GetString(m.GetBuffer());
            MemoryStream mem = new MemoryStream(System.Text.Encoding.ASCII.GetBytes(content));
            Bitmap t = new Bitmap(mem);
            t.Save("C:\\rtyui.png");

Ça lance une exception a la ligne

Code:

Bitmap t = new Bitmap(mem);

....

02/12/2009, 15h52
alexadvance

Attention, tu converti un PNG, peut-être faut-il dire qu'il s'agit d'un PNG lorsque tu recrée ta nouvelle image, non ?
02/12/2009, 15h54
NeoKript

J'avais penser a cela mais il n'y a pas de surcharges qui prend en param un ImageFormat ...
02/12/2009, 15h59
Pol63

pas de soucis la dessus, ca se débrouille à regarder dans le stream ce que c'est je pense

essaie de comparer avant le départ et après l'arrivée le nombre d'octets, le début et la fin pour voir si ca a l'air de concorder

ou sinon comme j'ai du le dire plus haut, passer par .net remoting permet de faire abstraction du codage du transfert, une propriété as image arrive de l'autre coté as image directement ...
02/12/2009, 16h00
alexadvance

Ah oui, il y a ca aussi :

System..::.ArgumentException sera lancée lorsque :

Citation:

stream contains a PNG image file with a single dimension greater than 65,535 pixels.

http://msdn.microsoft.com/en-us/library/z7ha67kw.aspx
02/12/2009, 16h06
NeoKript

Citation:

Envoyé par alexadvance

Ah oui, il y a ca aussi :

System..::.ArgumentException sera lancée lorsque :
stream contains a PNG image file with a single dimension greater than 65,535 pixels.

http://msdn.microsoft.com/en-us/library/z7ha67kw.aspx

Ma résolution est 1680x1050 => 1 764 000 pixel ...
Donc ca ne peut pas être cela.
JPEG -> Pas mieu

Citation:

Envoyé par Pol63

pas de soucis la dessus, ca se débrouille à regarder dans le stream ce que c'est je pense

essaie de comparer avant le départ et après l'arrivée le nombre d'octets, le début et la fin pour voir si ca a l'air de concorder

ou sinon comme j'ai du le dire plus haut, passer par .net remoting permet de faire abstraction du codage du transfert, une propriété as image arrive de l'autre coté as image directement ...

Le problème c'est que ne pourrai plus utliser mon protocole...
02/12/2009, 16h14
Pol63

Citation:

Envoyé par NeoKript

Le problème c'est que ne pourrai plus utliser mon protocole...

c'est bien le but oui, que ca soit microsoft qui code tout à ta place (comme un peu tout dans le framework d'ailleurs)
02/12/2009, 16h34
NeoKript

Oui je sais bien mais je ne m'y connais pas du tout ... moi je suis plus bas niveau d'ordinaire.
Je ne vois pas comment faire et ca ferais bcp de changement..
Serveur .. client..

Surtout que cela ne doit pas être infaisable.
Au pire, j'enregistre l'image, je l'ouvre j'envoie le ficher .. je le reconstruit de l'autre cote .. mais bon ca m'embête un peu.
02/12/2009, 18h59
NeoKript

Bon je vais me débrouiller avec les fichiers...

Cependant il n'y a pas de méthode en C# qui lit un fichier binaire et qui retourne tout sont contenu dans un string ??
Car je ne vois cette méthode que dans le StreamReader et nom dans le inary reader.

Merci
02/12/2009, 19h09
Pol63

system.io.file.readalltext
system.io.file.readallbytes
etc...

Salut a tous et merci pour readallbyte / all text je ne connaissais pas.

Bon il semblerait que le problème viennent du protocole en fait des que la taille tu paquet dépasse 256 octets je reçois un paquet avec une mauvaise taille.

Cependant je ne vois pas l'erreur voici comment sont codé mes paquet :

Code:

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
    class Packet
    {
        public static String PacketSize(Int32 Size)
        {
            Char c1 = Convert.ToChar(Size / Convert.ToInt32(Math.Pow(2, 16)));
            Size -= Convert.ToInt32(Math.Pow(2, 16)) * Convert.ToInt32(c1);
            Char c2 = Convert.ToChar(Size / Convert.ToInt32(Math.Pow(2, 8)));
            Size -= Convert.ToInt32(Math.Pow(2, 8)) * Convert.ToInt32(c2);
            Char c3 = Convert.ToChar(Size);
            String test = Convert.ToString(c1) + Convert.ToString(c2) + Convert.ToString(c3);
            return (test);
        }
        public static Int32 PacketSize(String Size)
        {
            return (Convert.ToInt32(Size[0]) * Convert.ToInt32(Math.Pow(2, 16)) + Convert.ToInt32(Size[1]) * Convert.ToInt32(Math.Pow(2, 8)) + Convert.ToInt32(Size[2]));
        }
        public static Boolean ParsePacket(ref String Pack, ref String Destinataire, ref String Commande, ref String Content)
        {
            String current = Pack;
            if (current.Length > 3)
            {
                Int32 Size = Packet.PacketSize(current.Substring(0, 3));
                MessageBox.Show(Convert.ToString(Size));
                if (current.Length < 3 + Size)
                    return (false);
                String cur = current.Substring(3, Size);
                Pack = current.Substring(3 + Size);
                Size = Packet.PacketSize(cur.Substring(0, 3));
                String Header = cur.Substring(3, Size);
                String[] tab = Header.Split('\0');
                Destinataire = tab[0];
                Commande = tab[1];
                Content = cur.Substring(Size + 3);
                return (true);
            }
            return (false);
        }
        public static String BuildPacket(String Destinataire, String Commande, String Content)
        {
            String pack = Packet.PacketSize(Destinataire.Length + Commande.Length + Content.Length + 3 + 1) + Packet.PacketSize(Destinataire.Length + Commande.Length + 1) + Destinataire + "\0" + Commande + Content;
            return (pack);
        }
        public static String BuildPacket(String Destinataire, String Commande)
        {
            String pack = Packet.PacketSize(Destinataire.Length + Commande.Length + 3 + 1) + Packet.PacketSize(Destinataire.Length + Commande.Length + 1) + Destinataire + "\0" + Commande;
            return (pack);
        }
 
    }

Merci d'avance