Discussion :

[Ryadassakr]

Bonjour tout le monde,


J'ais besoin d'aide pour mon prog svp, j'ai des matrices qui représentent des images contenant deux couleurs principalement, noir et blanc ( true pour le noir , false pour le blanc).

ma questiion est comment agrandir la matrice contenant une image (c.a.d agrandir l'image a l'intérieur de cette matrice (les trues et les falses))?

très important pour moi, merci.

ps: je voudrai précisément agrandir le contenu de la matrice vers la taille d'une autre image dans une autre matrice (le but c'est mettre une image à la taille d'une autre image -par la matrice- pour comparaison)

[popo]

Le principe de base est que si tu applique un coefficient sur une image, il faut l'appliquer de partout
Image doublée = Matrice doublée = Coordonnées doublées.
Et puisque tu part d'une matrice, ce coefficient sera forcément un entier

Pour simplifier on part du principe que l'image est blanche avec des points noir (ou l'inverse)
Il suffit de récupérer les coordonnées des points noirs.
Cela donne (0,0), (1,3), (1,4), (2,1), (3,1) (voir première image attachée)

Ensuite on applique le coefficient sur les coordonnées (pour doubler la taille de l'image cela donne)
(0x2, 0x2) = (0,0), (1x2, 3x2) = (2, 6), (1x2, 4x2) = (2,8), (2x2, 1x2) = (4,2), (3x2, 1x2) = (6,2) (voir deuxième image attachée)

Il reste ensuite à remplir les cases contiguës. Le mode opératoire sera toujours le même (pour doubler ces cases contiguës seront toujours aux coordonnées (x,y+1), (x+1, y) et (x+1, y+1))
(0,0) => (0,1), (1,0) et (1,1)
(2,6) => (2,7), (3,6) et (3,7)
(2,8) => (2,9), (3,8) et (3,9)
etc.
Ces cases contiguës sont représentée en gris sur la troisième image attachée

[Ryadassakr]

Bonjour ,


merci pour la réponse. en pratique , je dois comparer les matrices de deux images dont l'une est plus petite que l'autre et avec des proportionalités différentes, donc la petite image doit s'agrandir vers la taille de la grande (en parlant tj matrice), peux tu me montrer comment adapter ta solution à mon problème?

[popo]

Bonjour ,


merci pour la réponse. en pratique , je dois comparer les matrices de deux images dont l'une est plus petite que l'autre et avec des proportionalités différentes, donc la petite image doit s'agrandir vers la taille de la grande (en parlant tj matrice), peux tu me montrer comment adapter ta solution à mon problème?

Ma réponse consistait justement à agrandir la première matrice.
Une fois que c'est fait, il te suffit de comparer la matrice calculée avec la matrice de la grande image.

Après, poster la théorie est plus rapide que d'écrire l'algorithme qui en découle.
C'est la raison pour laquelle j'en suis resté là. Mais j'essaierai de trouver du temps pour pondre cet algorithme.

[popo]

OK, une réunion a été annulée. J'en ai profité pour me pencher sur ton cas.

Je suis parti du principe que par "Matrice" tu parlais d'un tableau multidimensionnel (l'objet Matrix de C# ne gérant qu'une matrice affine 3-par-3).

Si je me base sur les informations que tu as donné, il te faut une méthode pour agrandir ta matrice et une autre pour comparer deux matrices.
Les code qui suit n'est pas très optimisé, je te l'accorde mais déjà, vérifie qu'il marche, on verra après si on peut l'optimiser

Code C# :

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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
namespace Matrices
{
    class Program
    {
        static void Main(string[] args)
        {
            int[,] smallSize = new int[5, 6]
                {
                    {1,0,0,0,0,0},
                    {0,0,0,1,1,0},
                    {0,1,0,1,0,0},
                    {0,1,0,0,0,0},
                    {0,0,0,0,0,0}
                };
 
            int[,] mediumSize = new int[10, 12]
                {
                    {1,1,0,0,0,0,0,0,0,0,0,0},
                    {1,1,0,0,0,0,0,0,0,0,0,0},
                    {0,0,0,0,0,0,1,1,1,1,0,0},
                    {0,0,0,0,0,0,1,1,1,1,0,0},
                    {0,0,1,1,0,0,1,1,0,0,0,0},
                    {0,0,1,1,0,0,1,1,0,0,0,0},
                    {0,0,1,1,0,0,0,0,0,0,0,0},
                    {0,0,1,1,0,0,0,0,0,0,0,0},
                    {0,0,0,0,0,0,0,0,0,0,0,0},
                    {0,0,0,0,0,0,0,0,0,0,0,0}
                };
 
            int[,] bigSize = new int[15, 18]
                {
                    {1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                    {1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                    {1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                    {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0},
                    {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0},
                    {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0},
                    {0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0},
                    {0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0},
                    {0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0},
                    {0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0},
                    {0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0},
                    {0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0},
                    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
                };
 
            int[,] resized = Resize(smallSize, 2);
 
            if (AreEquals(mediumSize, resized)) Console.WriteLine("Resize coef 2 succeeded");
            else Console.WriteLine("Resize coef 2 failed");
 
            resized = Resize(smallSize, 3);
 
            if (AreEquals(bigSize,resized)) Console.WriteLine("Resize coef 3 succeeded");
            else Console.WriteLine("Resize coef 3 failed");
 
            Console.ReadKey();
        }
 
        static int[,] Resize(int[,] source, int coef)
        {
            if (source.Length == 0) return new int[0, 0];
            else
            {
                int y = source.GetLength(0);
                int x = source.Length / y;
 
                int[,] result = new int[(y * coef), (x * coef)];
                for (int row = 0; row < y; row++)
                {
                    for (int col = 0; col < x; col++)
                    {
                        if (source[row, col] == 1)
                        {
                            int coordX = col * coef;
                            int coordY = row * coef;
 
                            FillContiguous(ref result, new Coords(coordX, coordY), coef);
                        }
                    }
                }
 
                return result;
            }
        }
 
        static void FillContiguous(ref int[,] dest, Coords coords, int coef)
        {
            int x = coords.X + coef;
            int y = coords.Y + coef;
 
            for (int row = coords.Y; row < y; row++)
            {
                for (int col = coords.X; col < x; col++)
                {
                    dest[row, col] = 1;
                }
            }
        }
 
        static Boolean AreEquals(int[,] first, int[,] second)
        {
            int y = first.GetLength(0);
            int x = first.Length / y;
 
            for (int row = 0; row < y; row++)
            {
                for (int col = 0; col < x; col++)
                {
                    if (first[row, col] != second[row, col])
                        return false;
                }
            }
            return true;
        }
    }
 
    class Coords
    {
        public int X { get; private set; }
        public int Y { get; private set; }
 
        public Coords(int x, int y)
        {
            X = x;
            Y = y;
        }
    }
}

[Ryadassakr]

salut,

merci popo pour l'algo, en réalité je pense avoir bien compris ta première réponse, mais là où il ya un os pour moi c'est la comparaison, en fait, lorsque j'ai fait mon algo j'ai remarqué dans l'image résultante un effet d'escalier qui déforme l'image, est-ce une erreur de prog ou est-ce normal.
si c'est normal, alors je pense que je ne pourrai pas faire confiance à cette technique pour comparer.

connais tu un moyen accessible pour pouvoir faire une comparaison précise (une formule maths par exemple)?

[popo]

Je pense que tu auras le même résultat avec mon code.

Ce comportement résulte de l'agrandissement pur et simple de la matrice.
Tu auras le même comportement si tu agrandis un image en basse définition avec un logiciel qui ne fait pas d'anti crénelage.

Pour bien faire, il faudrait appliquer un autre algorithme derrière l'agrandissement pour gérer cet effet d'escalier, ou alors trouver un autre algorithme pour en tenir compte lors de l'agrandissement.
Je n'ai malheureusement pas les compétences nécessaires pour t'aider plus que ça.

Peut-être que quelqu'un d'autre aura une idée.

[MABROUKI]

bonjour

S'il s'agit du class Bitmap ou du Class Image,ta matrice de booleans fait correspondre une
coord(x,y) "exprime dans le referentiel de coords pixel" ou l'unite de base => correspond à un pixel ...

Chaque matrix de boolean => rectangle (bmp.width,bmp.height)....et sera un matrix de dimension (bmp.width,bmp.height)....car ces width et height sont des pixels ....
Ton probleme si j'ai bien compris le souci(vu l'absence de code fourni par tes soins) revient à ajuster le
2eme Bmp à la meme taille que le 1er Bmp....
Avec factX & factY rapport des Widths et Heights respectifs des 2 bmps , le 2eme bmp "dilate" ou "retreci" (c'est selon) pour etre ajuste à la taille du 1er bmp est donne par le code .cs :

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
 
 
 using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Drawing.Drawing2D;
 
namespace WinAgrandirImage
{
    public partial class frmAgrandirImage : Form
    {
        Bitmap bmpCible = null;
        Bitmap secondBmp = null;
        Bitmap secondBmpDilate = null;
 
        public frmAgrandirImage()
        {
            InitializeComponent();
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            //bmp cible 
            bmpCible = new Bitmap(480, 480);
            SetColor(bmpCible);
            this.pictureBox1.Image = bmpCible;
            this.pictureBox1.SizeMode = PictureBoxSizeMode.AutoSize;
 
 
            //secondBmp
            secondBmp = new Bitmap(40, 60);
            SetColor(secondBmp);
            this.pictureBox2.Image = secondBmp;
            this.pictureBox2.SizeMode = PictureBoxSizeMode.AutoSize;
 
 
 
 
            // second Bmp "DILATE"
            int factX = (int)(bmpCible.Width / secondBmp.Width);
            int factY = (int)(bmpCible.Height / secondBmp.Height);
 
            secondBmpDilate = new Bitmap(secondBmp, secondBmp.Width * factX, secondBmp.Height * factY);
 
            this.pictureBox3.Image = secondBmpDilate;
            this.pictureBox3.SizeMode = PictureBoxSizeMode.AutoSize;
        }
        private void SetColor(Bitmap bmp)
        {
 
            for (int x = 0; x < bmp.Width; x++)
            {
                for (int y = 0; y < bmp.Height; y++)
                {
                    bmp.SetPixel(x, y, Color.White);
 
 
                    //COLORIZE EN BLACK LA DIAGONALE
                    if (x == y && x != 0 && y != 0)
                    {
                        bmp.SetPixel(x, y, Color.Black  );
 
                    }
 
                }
            }
 
        }
    }
}

Evidemment ,cela necessite de recalculer le matrix des booleans du 2eme bmp d'apres le bmp "dilate" (qui comprends "plus" de boolean true et false ) mais qui a maintenant les memes dimensions que le matrix boolean du 1er bmp...

L'espace de coordonnes physique (inch ou pouce en francais) est moins commode car les dimensions physiques des images varient d'un peripeherique à un autre.....et fait intervenir la resolution du pheriperique...
bon code....

[Ryadassakr]

Bonjour tout le monde,


merci mebrouki, en fait, ce que je fait c'est de l'OCR :
1- je crée un bitmap pour chaque lettre
2- je les mes dans un list
3- je prend un partie de l'image sujet (représentant un caractére)
4-je compare la matrice de chaque bitmap modèle (celui ci mis aux dimension de la partie de l'image) avec la partie de l'image.
5- je séléctionne le modèle, et je passe à la partie de l'image, suivante.


maintenant le traitement prend toujours trop de temps

est ce que quelqu'un sait comment faire pour accélerer le traitement ( pour la comparaion de toutes ces images avec l'image sujet )???

[MABROUKI]

Rebonjour

Avec tes questions sans aucun bout de code sur tes methodes de comparaisons d'image ou de tableaux booleans difficile de repondre...

Bref 1 : si tu compares des bitmaps qui sont des tableaux à DEUX DIMENSINS DE PIXELS ,la meilleure methode c'est d'utiliser le class Bitmap.LockBits qui utilise l'interop et travailles avec des pointeurs
Super rapide..
Bref 2 : si tu compares des tableaux à DEUX DIMENSINS DE BOLEEAN ,la meilleure methode c'est de les convertir "en vol" en tableaux MONODIMENSIONELS ,de recquerir un pointeur en code "unsafe" et et de les parcourir ....comme le class Bitmap.LockBits
Super rapide..


bon code...