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