Discussion :

[olibara]

Bonjour

Pédale toujours un peu avec les concepts de Graphics

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

Code :

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

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 ?

[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

[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 ?

[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

[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 ....

[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 ...

[theMonz31]

beh, c'est pas compliqué

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

The Monz, Toulouse

[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 ??

[theMonz31]

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 :

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

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 :

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
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 :

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
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

[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

[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

[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 ?

[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

[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

[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

[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 :

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

Graphics A=Graphics.FromImage(MonImage);

Et un Graphics qui dessinera sur la surface du pictureBox

Code :

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

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.

[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é

[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

[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

[olibara]

Bon allez

Je me lance

Mais si tu a un petit modele, je suis preneur