Creation de layers sur image

Version imprimable

Voir 40 message(s) de cette discussion en une page

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

Voir 40 message(s) de cette discussion en une page