Creation de layers sur image

Version imprimable

18/09/2008, 21h48
olibara

Creation de layers sur image
Bonjour

Pédale toujours un peu avec les concepts de Graphics

Actuellement je cree une image (au sens logique et physique)
Code:

1 2 3 Image monImage=new BitMap(2048,2048); Graphics gr=Graphics.FromImage(monImage); gr.Draw(plein_de_choses);
A ce stade j'ai une grosse image dont je peux afficher des morceaux
Mais j'aimerais par dessus cette image tracer des lignes et pouvoir les faire disparaitre sans reconstruire toute mon image

Est-ce possible sans devoir faire des clones de l'image qui peut etre tres grosse ?
19/09/2008, 08h35
theMonz31

salut

C'est tout à fait possible...

Ton image est dans une image :)

Ok, donc, dans ton Paint(), tu fais un DrawImage() pour l'image de fond.

Après, pour avoir une couche, il faut créer d'autres images qui auront les
éléments à dessiner et au final, tu feras un DrawImage() de ces couches là.

De toute façon, dans la mesure ou au final, tout est dessiné dans le même contexte graphique, il faudra bien faire un refresh de ton image :)

Cependant, en gérant cela par "couche", tu évites la reconstruction des images à chaque fois :)

JE crois que j'avais déja parlé de cette technique dans une autre discussion il y a 2/3 mois (voir moins)

The Monz, Toulouse
19/09/2008, 08h46
olibara

Merci theMonz31

En fait je n'utilise pas Paint

Ce que je fais actuellement

Je construit une image qui fait +/- 3 x la taille d'un PB que j'utilise pour l'affichage

J'utilise DrawImage avec deux rectangles pour afficher la portion d'image qui m'intéresse dans le PB

Grace a cette methode, je peux faire des Zoom et et des slide rapide dans l'image

Si je te suis bien tu me suggere de creer d'autres images sur lequelles je peux tracer les objets temporaires

Ensuite je ferais des DrawImages en boucle sur mon PB

Mais il me semble que DrawImage va chaque fois non pas empiler les image en transparence mais ecraser successivement la précédente

Quelque chose m'échappe ?
19/09/2008, 09h34
theMonz31

du tout

Il faut que tu te fasses ton propre controle :)

Et dans un controle, l'objet Graphics gère la transparence

Donc, si tu fais 3 drawImage de 3 images différentes ayant de la transparence,
tu auras la superposition des 3...

Par contre, si tu as 3 PB, il est clair que le résultat ne sera pas le même puisque les controles Windows gèrent par défaut la transparence par rapport au fond de la form Parent et non en ayant connaissance de controle qui se trouverait "sous" eux :) !!!

The Monz, Toulouse
19/09/2008, 09h49
olibara

Merci TheMonz31

Non non j'ai un seul PB mais effectivement je devrais supperposer 2 ou trois images dessus !

Donc d'apres toi je suis obligé de creer mon propre controle ?

Zut ! ca m'arangeait bien ce PB ....

Tu n'aurais pas un exemple sur un coin de table ;)....
19/09/2008, 10h00
Pol63

rien compris, mais tu peux utiliser plusieurs bufferedgraphics superposés

l'avantage c'est que tu passes de l'un à l'autre comme tu veux ...
19/09/2008, 10h35
theMonz31

beh, c'est pas compliqué

Tu fais un Usercontrol qui hérite de la PB si cela t'arrange :)

The Monz, Toulouse
19/09/2008, 10h35
olibara

Slut Sperot51

Rien compris ?
Qu'est ce que tu ne comprends pas ?

Je n'ai jamais non plus travaillé avec un BufferedGraphic
Donc je ne sais pas vraiment ce qu'il apporte ici

Tu a peut-etre raison mais si tu n'a rien compris je me demande comment tu peux dire qu'il faut employer un BufferedGraphics ?? :?

Allez,
t'embetes pas avec les BufferedGraphics (sinon, on trouve des exemples sur le net :)

Pour ton problème :

Tu crées une classe LayerItem genre ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
public delegate void DrawLayer(Graphics g);
 
    [Serializable]
    public class LayerItem
    {
        public int Id;
        public DrawLayer drawer;
        public bool visible = true;
 
    }

Et ensuite, tu peux créer un userControl genre ça :

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
public partial class PBLayer : UserControl
    {
        List<LayerItem> couches = null;
 
        public List<LayerItem> Couches
        {
            get { return couches; }
            set { couches = value; }
        }
 
        public void Update()
        {
            Invalidate();
        }
 
        public PBLayer()
        {
            InitializeComponent();
            couches = new List<LayerItem>();
            SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer | ControlStyles.UserPaint, true);
        }
 
        protected override void OnPaint(PaintEventArgs e)
        {
            Graphics g = e.Graphics;
 
            if (couches != null)
            {
                if (couches.Count > 0)
                {
                    for (int i = 0; i < couches.Count; i++)
                    {
                        if (couches[i].visible)
                        {
                            couches[i].drawer(g);
                        }
                    }
                }
                else
                {
                    g.Clear(Color.LightGreen);
                }
            }
            else
            {
                g.Clear(Color.LightCyan);
            }
        }
    }

Avec ce code, tu as un controle qui te gère les couches.. et qui te demander de créer des LayerItem que tu ajoutes au membre Couche...
Quand tu crées ce layerItem, il te faut lui associer la méthode pour dessiner..

Comme dans ce cas là :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private void BtnLayer1_Click(object sender, EventArgs e)
        {
            LayerItem item = new LayerItem();
            item.drawer = PaintLayer1;
            pbLayer1.Couches.Add(item);
            item = new LayerItem();
            item.drawer = PaintLayer2;
            pbLayer1.Couches.Add(item);
            pbLayer1.Update();
        }
 
        private void PaintLayer2(Graphics g)
        {
            g.DrawLine(new Pen(Color.Red, 2), new Point(0, 0), new Point(100, 100));
        }
 
        private void PaintLayer1(Graphics g)
        {
            g.DrawImage(Image.FromFile(@"c:\blue.jpg"), new Point(0, 0));
        }

Voilà, je pense qu'avec cela tu en as assez pour résoudre ton problème :)

The Monz, Toulouse

19/09/2008, 10h59
Pol63

il n'y a que très peu de cas ou un graphics peut suffire, dans tous les autres, le bufferedgraphics apporte soit plus de rapidité, soit des fonctionnalités en plus (en terme de besoin, car ca fait la meme chose qu'un graphics)

par exemple, il te faudra ptete 3 ou 4 bufferedgraphics, sur le premier tu mets ton image
sur le 2eme, tu mets le 1er plus des traits

et donc quand tu veux, soit tu dis que tu veux voir le 1er, soit le 2eme

etc...
ici ca permet de "sauvegarder" des étapes de l'image
19/09/2008, 11h03
theMonz31

cela dit sperot51, dans l'absolu, dessiner dans une image et ensuite la rendre ou pas et passer par le bufferedGraphics, revient un peu au même :)

The Monz, Toulouse
19/09/2008, 11h05
olibara

Salut TheMonz

Excuse moi je suis encore un peu novice en la matiere, mais pourquoi devoir faire un usercontrol qui va heriter du PB ?

Je n'ai pas encore bien compris ce que ca changeait par rapport a mon PB dans ma form ?
19/09/2008, 11h10
olibara

Merci beaucoup TheMonz et Sperot

Effectivement je pense que j'ai assr pour résoudre mon problème et qu'au passage j'en ai appris un peu plus

Mais je vais quand meme aussi analyser ce qu'apporte BufferedGraphics

Et peut etre réétudier l'habitude que j'ai prise de travailler sur un PB

Merci
19/09/2008, 11h17
theMonz31

salut

Pour moi, travailler avec la PB, n'apporte pas grand chose quand tu as besoin de faire du dessin à façon...

JE prefère largement me faire mon propre Usercontrol, avec surcharge du OnPaint()

Ca peut paraitre "bourrin", mais en faite, c'est rudement efficace...

ET une fois qu'on a compris les principes du zoom, etc... c'est finalement "très" simple de refaire une pictureBox like capable de gérer plusieurs images, etc...

PS : J'ai fait un test avec les BufferedGraphics, et je ne suis pas convaincu que dans le cas présent cela fonctionne :)

(en tout cas, une chose est sur, gérer la transparence avec ma méthode est bcp plus simple et plus rapide à y arriver qu'avec les bufferedGraphics qui ont l'air finalement d'être un peu plus "complexe" à exploiter :)

The Monz, Toulouse
19/09/2008, 21h52
olibara

Bonsoir TheMonz

Je viens de plonger dans l'exemple de code que tu m'a donné

Il y a quand meme un truc que je ne comprends pas

Tu done une mecanique permettant de gerer une logique de layer en liste
Dans l'exemple tu donne a PaintLayer1 une surface de dessin

Mais PaintLayer2 : il dessine ou et sur quoi ?

J'aime bien ton exemple mais il me ramene a la question initiale
a) comment definir les surfaces de dessins si l'on veut superposer des images indépendantes ?

b) admettons que les surfaces soient définie : comment se gere la transparence : comme tu me la expliqué j'ai compris que c'etait implicite
20/09/2008, 12h03
olibara

Bonjour TheMonz

En définitive, je ne suis pas certain que ta methode m'apporte la solution a mon probleme

Je me permet de l'exposer a nouveau

1- Je constitue une image, cette constitution est asser lourde, et je ne souhaire pas la recreer a tout moment. C'est d'ailleurs la raison pour laquelle je cree une image plus grande que le view port (un picture box actuellement) afin de pouvoir faire des déplacement rapides

2- Je dois pouvoir dessiner des lignes temporaires siur cette image et les faitrre disparaitre SANS redessineer toute l'image

Pour ce genre de chose, le picture Box offre une methode interessante qui est .CreateGraphics

Je peux donc avoir un graphics qui dessinera sur l'image

Code:

Graphics A=Graphics.FromImage(MonImage);

Et un Graphics qui dessinera sur la surface du pictureBox

Code:

Graphics B=PB.CreateGraphics();

A tout moment je peux faire un B.Clear(); pour effacer l'image construite sur le PB par dessus mon image de fond

Mais comment puis-je reproduire ce comportement SANS passer par un picture BOX, je devrais avoir un truc du style Image.CreateGraphics()

Si j'ai bien compris ta methode elle ne permet pas de faire ca, car tu redessine tout systématiquement.
20/09/2008, 12h43
Pol63

qu'est-ce qui ne va pas dans ta solution alors ?

si tu créé une image as image qui est un morceau de ta grande image, tu la place dans picturebox.image

ensuite avec creategraphics, tu peux dessiner

et pour effacer ton dessin et ne laisser apparaitre que le morceau d'image, tu fais monpicturebox.invalidate

à savoir que si tu dessines avec creategraphics, et que tu passes d'une appli à l'autre, ca efface le dessin

en fait, les graphics sont utilisés par tout le framework, c'est la seule chose qui peut faire du graphisme, les boutons et autre picturebox fonctionnent avec des graphics, le bouton dessine son fond avec drawimage, puis affiche son texte avec drawstring etc...
et l'event paint est appelé quand le dessin est demandé
20/09/2008, 16h36
olibara

Salut Sperot

J'aimerais etre indépendant du PB

Pour deux raison

1- Parce que je travaille sur une image qui n'a pas la meme taille que le PB
2- Les graphics desinant l'image (et les eventuels layesrs) doivent etre dotés d'un TransformMatrix indépendant du cadre du picturebox
3- Le PB n'est que la surface finale d'affichage d'une portion de l'image et de ses layer
20/09/2008, 19h13
Pol63

si tu peux trouver le courage de tester le bufferedgraphics, tu verras que c'est ce que tu cherches depuis le début ...
dans ton cas il en faut 2, le premier faisant un render sur le 2eme
20/09/2008, 21h25
olibara

Bon allez

Je me lance:traine::koi:

Mais si tu a un petit modele, je suis preneur
20/09/2008, 22h16
olibara

Merci Sperot

Bon... j'ai deja repris et compilé l'exemple de MSDN
Bonne nouvelle ca marche
Reste maintenant a dériver tout ca dans le contexte qui m'intéresse

Je résume :

J'ai un resultat et je vois quelque chose (bonne nouvelle)
Je sais pas vraiment ou je suis ??
Je ne sais pas encore vers ou je dois aller ??
Mais je sais ou je veux arriver (autre bonne nouvelle)

Donc je dois resoudre une equation a deux bonnes nouvelles et deux inconnues !

On va y arriver mais si tu a encore une piste je reste preneur !
20/09/2008, 23h15
olibara

Bonjour Sperot51

J'ai un peu analysé l'exemple de BufferedGraphics et franchement, je n'ai rien compris a ce que ca apporte sinon compliquer les choses
En plus la methode clear ne peut se faire que par remplissage d'une couleur !
A ce niveau la le clear d'un CreateGraphics sur un PB est beaucoup plus efficace

Je pense que je vais me contenter de travailler avec une premiere image constituée dont je ferai des clone a chaque fois que je veux redessiner sur un fond original

Je n'ai pas compris en quoi ni comment la methode the TheMonz31 ou la tienne pouvait me produire le meme mesultat de maniere performante

Ma solution serait donc

1- Je cree un bitmap et j'en fais une Image
2- Je dessine dessus mon fond
3- J'en fais un clone
4- Je cree un Graphics sur le clone
5- J'ajoute les elements "ephemeres"
6- A chaque clear, je dispose le clone et je repars au step 4

Est-ce une "mauvaise" solution ?
21/09/2008, 00h58
Pol63

non, ta solution est bonne

avec des bufferedgraphics, la solution serait :

de déclarer 2 bufferedgraphics, de les allouer à la taille du PB

ensuite sur le 1er, tu fais ton drawimage qui fait que t'as qu'une partie de ta grosse image
tu render le 1er sur le 2eme

quand tu veux ajouter tes elements ephemeres, tu les rajoutes sur le 2eme

quand tu veux effacer tes elements ephemeres, tu render le 1er sur le 2eme

render du 2eme sur picturebox.creategraphics affiche soit l'image, soit l'image plus les elements ephemeres selon ce que tu as fait avant

render est une instruction très rapide (0,1ms environ), surtout par rapport à des drawimage ou drawline

les drawimage et drawline sont beaucoup plus rapide sur un bufferedgraphics que sur un graphics d'un control

si ton picturebox n'a pas de transparence, il faut faire .clear(PB.backcolor)

si ton picturebox est transparent et que ton image l'utilise, ca se complique par contre, il faut soit la gérer manuellement, soit utiliser l'instruction qu'utilise les controles pour recréer la partie qu'on croit transparente (qui est en fait un redessin de la partie d'en dessous sur le control du dessus)
21/09/2008, 08h34
olibara

Merci Sperot1

Citation:

avec des bufferedgraphics, la solution serait :
de déclarer 2 bufferedgraphics, de les allouer à la taille du PB

En fait non !

Car l'image et les elements ephemere doivent se dessiner sur des surfaces identiques utilisant un meme TransFormMatrix (actuellement je fais des drawlines et elipses sur une Image)

Etape 2
La visualisation ne prends qu'un morceau de cette (ces) image pour les afficher sur une autre image de la taille de mon PB en utilisant drawimage avec un rectangle source et un rectangle destination permettant de gerer les deplacement est les zoom rapides dans l'image originale

En final je fais PB.Image=Image

(peut etre que le PB ne sert pas a grand chose mais il offre la facilité de l'assignation Image=Image)

Je commence a percevoir que je devrais jouer sur l'etape 2 pour construire l'image a afficher a partir de deux images originales distincte le fond +/- statique et et une surface egale contenant les objets ephemeres

Je ne vois pas encore bien toute la subtilité du bufferedgraphics et comment bien le mettre en place dans ce contexte mais si ca fait gagner de la performance, je suis toujours preneur !
21/09/2008, 10h16
Pol63

si tu t'en sors pas avec le bufferedgraphics, passe moi ton codeque je te le modifie (dans le pire des cas en élagant pour qu'il ne reste que le code graphique)
parce ca reste un peu flou ce que tu fais malgré les multiples descriptions :lol:
21/09/2008, 10h27
olibara

Salut Sperot51

Voici la source complete

Les fonctions utiles sont

DrawRoute : construction de l'image de fond (MapImg)
MoveImage : creation de l'image a afficher sur le PB

Je devrais pouvoir dessiner des choses par dessus MapImg en utilisant TransformMatrix mais sans alterer MapImg
21/09/2008, 14h43
Pol63

à retirer :
public Graphics cGraphics = null;
et mettre à la place :
private System.Drawing.BufferedGraphics bufferImage = null;
private System.Drawing.BufferedGraphics bufferImageEtDessin = null;

il faut allouer les buffer, à la taille des picturebox je pense, meme si tu ne dessines pas en entier dessus

à retirer :
cGraphics = Graphics.FromImage(MapImg);
et mettre à la place :
bufferImage.Graphics.Clear(PB.Backcolor)
bufferImage.Graphics.DrawImage(MapImg,0,0)

une fois que tu as fini l'image de base, tu fais
bufferImage.Render(bufferImageEtDessin.Graphics)

il faut aussi sur l'évenement paint du PB mettre
bufferImageEtDessin.Render

après j'ai pas suivi ou tu traces tes lignes, ni où tu choisis que tu ne veux plus les voir (je fais du vb à l'origine, pas du c#)

donc quand tu traces les lignes, tu le fais sur bufferImageEtDessin.Graphics
et quand tu veux les effacer, tu fais
bufferImage.Render(bufferImageEtDessin.Graphics)

et tu n'as plus besoin d'assigner PB.Image avec une image que tu créé, tu ne fais plus que dessiner et afficher le dessin via le buffer
21/09/2008, 15h51
olibara

Merci Sperot51

Je pense que je commence a comprendre
Mais je ne suis pas sur que tu a bien suivi mon mecanisme actuel

1- Dans DrawImage je construit une image d'une taille indépendante du PB disons 2048 x 2048

2- Exemple de tracage ephemere : la Methode DrawDistPnt qui actuellement recoit une liste de point en dessine directement sur l'image mais qui devrait dessiner sur une AUTRE image

3- Dans MoveImage je cree un image de la taille du PB a partir d'un morceau de l'image de base

4- Ensuite j'assigne cette image au PB

Avec ta methode qui doit remplacer 2 et 3 et 4 il me semble que je pourrais me passer du PB et travailler sur un pannel
21/09/2008, 16h50
Pol63

ton image indépendant il faut la garder as image oui

c'est pour le reste qu'on peut remplacer par des buffers

et le PB n'est plus obligatoire, avec un buffer, le rendu se fait sur n'importe quel controle, même sur le form directement si tu veux ...

Bonsoir Sperot51 et TheMonz

J'ai plogé dans les exemples de BufferedGraphics et aussi telecharge cett exemple

http://www.codeproject.com/KB/directx/dxsurfacemgr.aspx

Ma conclusion est la suivante

1- C'est vraiment pas tres souple utiliser : il faut définir un bufferedcontext un bufferedgraphics et tout ca me semble asser complexe pour finalemement faire des choses qui devraient etre simples.

2- Considérant la maniere dont je travaille il me semble que le bufferdgraphics et tout a fait superflu :
a) je construit une image en backround et un simple graphics permet de faire ca je pense de maniere plus performante

b) Pour mon probleme de layer je pense que le plus simple c'est de construire une deuxieme image

c) QUESTION : la ou je suis encore dans les choux c'est que je pense que le PictureBox est inutile mais que je devrais trouver le moyer de d'afficher le clip des images sources sur un pannel et je n'ai toujours pas bien compris comment faire ca. Avec le picturebox c'est evidemment asser simple

je definis un rectangle dans mon image source
je definis un rectangle du size de mon Picture Box
Je fais un drawimage sur une nouvelle image de la taille de mon PB
J'assigne ensuite cette image a mon PB
Code:

1 2 3 4 5 6 7 Bitmap bmp = new Bitmap(frameWidth, frameHeight); Rectangle destRect = new Rectangle(0, 0, frameWidth, frameHeight); Rectangle srcRect = new Rectangle(frameAnchor.X, frameAnchor.Y, srcWidth, srcHeight); GraphicsUnit units = GraphicsUnit.Pixel; Graphics frameGraphics = Graphics.FromImage(bmp); frameGraphics.DrawImage(MapImg, destRect, srcRect, units); PB.Image=bmp;
Si je veux faire un move, j'appelle cette methode en modifiant frameAnchor.X et frameAnchor.Y

Si je veux faire un Zoom, j'appelle cette methode en modifiant frameAnchor.X et frameAnchor.Y et aussi srcWidth, srcHeight);

Comment je devrais adapter ce code pour qu'il soit performant et qu'il fonctionne sur un pannel

Vraiment merci pour votre aide

25/09/2008, 21h58
olibara

N.B.

Maintenant, je suis toujours disposé a considerer qu'un bufferedgraphics fera mieux le travail, mais j'aimerais comprendre pourquoi ?
25/09/2008, 22h39
Pol63

parce qu'un buffer par définition, c'est un espace mémoire de travail, pendant qu'autre chose est affiché
donc les calculs sont fait en premier et le rendu est ensuite recopié en une fraction de milliseconde à l'écran
par contre je vois pas trop ou le bufferedgraphics te bloques
ce n'est qu'un graphics avec une sub "render" en plus (et une allocation nécessaire certes)
et y a pas besoin d'instancier un context, y en a un shared qui traine
25/09/2008, 22h59
olibara

Salut Sperot51

Je comprends ce que tu dis pour surface de travail
Mais a partir du moment ou je dessine sur une image et non pas directement sur l'ecran, ma surface de travail est déja toute faite non ?

Ce que je ne comprends pas bien c'est comment transferer cette image (ou une portion sur un pannel et pas un picturebox ?)

Et si je voulais jouer a l'idiot je dirais que j'ai lu l'exemple de MSDN sur les bufferedgraphics (source jointe) et que j'ai rien compris et que d'autre part le bufferedcontext semble nécessaire dixit exemple.
Mais de maniere plus pragmatique je n'ai pas l'impression que tout ceux qui fond du graphics emploient cette usine a gaz ?

vu que tu travailles sur un graphics non lié (qui lui travailles sur l'image) oui ca va plus vite que de travailler sur un graphics lié à un controle

pour le contexte :

Code:

buffer = BufferedGraphicsManager.Current.Allocate()

donc pas besoin d'avoir à instancier un contexte

donc si j'ai bien compris (tu dois te dire que je suis lent à comprendre, mais en fait moi je fais du vb et j'ai toujours un peu de mal à lire du c#)
tu créé une image via un graphics, et tu mets cette image dans PB.image

pour un panel, tu pourrais aussi mettre dans panel.backgroundimage

de toute facon que t'utilises l'un ou l'autre, ca ne change rien niveau perf, tous les controles se ressemblent ...
tu pourrais meme créer un nouveau controle hérité de control

voici en vb l'utilisation classique d'un buffer (avec pb as picturebox)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 Private buffer As BufferedGraphics Private Sub PB_SizeChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles PB.SizeChanged buffer = BufferedGraphicsManager.Current.Allocate(PB.CreateGraphics, PB.ClientRectangle) dessine_buffer() End Sub Private Sub dessine_buffer() buffer.Graphics.Clear(PB.BackColor) buffer.Graphics.DrawImage() buffer.Graphics.DrawLine() buffer.Render End Sub Private Sub PB_Paint(ByVal sender As Object, ByVal e As System.Windows.Forms.PaintEventArgs) Handles PB.Paint buffer.Render(e.Graphics) End Sub
si le controle sur lequel on utilise le buffer est transparent, ce n'est plus du meme acabit

26/09/2008, 08h55
olibara

Merci Sperot

Excuse moi d'avoir l'air de poser des questions dans tout les sens (et parfois des tres semblables) mais c'est ma maniere de digerer un sujet

Or j'ai envie de bien assimiler tout ces concepts

Pour les PB j'ai souvent entendu dire que ce n'etais pas le controle le plus performant pour le dessin

Pour ce qui est du BackroundImage, j'ai souvent entendu dire que ce n'etais pas conseillé

Mais je peux comprende que dessiner une image puis l'assigner au backroundimage demande plus de manipulation que de dessiner directement sur le control

Or je pense avoir compris que je devrais bypasser cette partie la de mon process

Je recapitule le principe actuel

1- Je cree une grande image (bitmap)
2- Je prends en clip de cette grande image dans une plus petite image en utilisant drawimage avec un rectangle source dans ma grande image un rectangle destination dans ma petite image
3- Enfin j'assigne cette petite image a mon PB

Je pense avoir compris que je pouvais rassembler 2 et 3 en dessinant directement sur le fond de mon pannel et en utilisant DoubleBuffer pour eviter le flicker

Mais je vais compliquer un peu car pour gerer les layers, je pense construire DEUX grandes images et les superposer lors de l'affichage dans le panel

J'espere bientot pouvoir vraiment maitriser ce sujet et connaitre les avantages et inconvénients de toutes les méthodes possible.
26/09/2008, 09h25
Pol63

je ne sais pas si tu connais reflector, ca permet de décompiler du .net
et le framework est composé en grande partie avec le framework :lol: (plus des appels de dll)

donc on peut voir comment ca se passe derrière tout ca ...
donc tous les controles héritent de la control, qui gère l'affichage de base (texte, backcolor, backgroundimage, fausse transparence etc...) ensuite les controles hérités rajoutent par dessus leur spécificité

pour dessiner en .net, il n'y a que graphics, donc le famework aussi utilise ca
les controles au moment de l'évenemtn paint, font du drawimage, drawstring, et autre

donc pour le backgroundimage ou image, dans les 2 cas c'est drawimage qui est utilisé, mais pour backgroundimage, il y a possibilité de modifié le rendu (étiré, zoomé, mosaique ...) et c'est des surcharges de drawimage qui font ca
donc l'un ou l'autre ca change rien

la propriété doublebuffer des controles est utile dans certains cas, mais seulement si on ne gère pas soi meme l'affichage avec des bufferedgraphics

si ta méthode fonctionne et que les perfs sont ok, pas besoin de s'embeter plus
mais il faut savoir que dès qu'on veut pousser un peu les graphisme en .net, il faut utiliser des bufferedgraphics

avec des buffers, ton traitement serait
ton image géante tu la gardes dans un System.Drainwg.Image tout le temps
il te faut un bufferMorceauImage et un bufferTotal (qui aura les traits en plus)

quand tu veux changere de morceau d'image (ou au début donc)
tu fais bufferMorceauImage .graphics.clear
bufferMorceauImage .graphics.drawimage(imageGeante,....) avec la surcharge qui sert à dire que tu veux tel morceau seulement
bufferMorceauImage.render(bufferTotal.graphics) => le buffer morceau se dessine sur le buffertotal, donc ils sont identiques niveau visuel
et pour finir buffertotal.render pourqu'on voit à l'écran le dessin

et quand tu veux dessiner des lignes dessus, tu fais buffertotal.graphics.drawlines et buffertotal.render

et ne pas oublier sur l'évenement paint du control utilisé (pb panel ou form) de faire buffertotal.render(e.graphics)

car quand windows dit à la fenetre de se rafraichir, elle appelle les evenements paint sur tous les controles, et affiche le contenu de e.graphics, donc tout ce que tu avait dessiné disparait, en disant au buffer de se peindre sur e.graphics (instantanné aussi), ca fait le rendu que tu veux

si y reste des questions n'hésite pas ...

Fuseau horaire GMT +2. Il est actuellement 16h13.