Discussion :

[LaurentC33]

Bonjour à tous,

Je suis bloqué sur un algo qui ce révèle pas évident...
J'ai une liste de points qui correspondent aux valeurs max d'une image.

Code C# :

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

1
2
 
public IEnumerable<Point> DetectedPoints { get; private set; }

Si j'affiche ces points dans un bitmap, ça correspond aux zones rouges:



J'aimerais récupérer une liste de Rectangles (l'objet défini par sa position et sa taille de System.Drawing) qui encadre les zones les plus denses de points (avec un paramétrage de densité) pour les afficher dans ma vue en WPF sur l'image.
J'ai tenté une méthode, mais qui je pense est une impasse et un "bouffe ressources"...

Dans une méthode je boucle sur tous mes points:

Code C# :

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

1
2
3
4
5
6
7
8
9
10
11
 
                List<Rectangle> _zonesRects = new List<Rectangle>();
                foreach (var point in DetectedPoints)
                {
                    var rectangle = ComputePoint(DetectedPoints, point);
 
                    if (rectangle != null)
                        _zonesRects.Add((Rectangle)rectangle);
                }
 
                _onDetectionRectanglesComputed?.Invoke(_zonesRects);

Et je recherche des zones:

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
 
 private List<Rectangle> _zoneDetected = new List<Rectangle>();
 private Rectangle? ComputePoint(IEnumerable<Point> detectionPoints, Point originPoint, int minSize = 6)
 {
     foreach (var zoneDetected in _zoneDetected)
       if (zoneDetected.Contains(originPoint))
             return null;
 
     int rectHeight = int.MaxValue;
     int xDelta = 0;
 
     while (true)
     {
         int yDelta = 0;
 
         bool processYLine = true;
 
         while (processYLine)
         {
             bool pointExist = detectionPoints.Any(point => point.X == originPoint.X + xDelta && point.Y == originPoint.Y + yDelta);
 
             if(!pointExist && yDelta >= minSize && yDelta < rectHeight)
             {
                 rectHeight = yDelta+1;
             }
             if (!pointExist && yDelta < minSize && xDelta < minSize)
             {
                 return null;
             }
             else if(!pointExist && yDelta >= minSize && xDelta >= minSize)
             {
                 var rect = new Rectangle(originPoint.X, originPoint.Y, xDelta+1, rectHeight);
                 _zoneDetected.Add(rect);
 
                 return rect;
             }
 
             processYLine = pointExist;
 
             yDelta++;
         }
 
         xDelta++;
     }
 }

Mais ça ne fonctionne pas, et c'est pour moi une impasse...

J'espère être clair, si certains peuvent m'aiguiller c'est super !

[umfred]

Tu pourrais nous indiquer ce que tu voudrais approximativement en résultat final à partir de ton image?

Je procéderai peut-être en comparant les distances entre les points et conservant les x/y min et max pour déterminer mon rectangle ensuite

[LaurentC33]

Merci umfred

Le but est d'afficher des rectangles entourant les zones de points les plus denses



Il faut pour ça des critères de largeur min, longueur min et de densité. Pas évident ...

[umfred]

Je ne dis pas que c'est une bonne solution (ni simple), mais avec mon raisonnement précédent, on obtient un rectangle d'une certaine taille, donc on pourrait lui appliquer les critères de largeur/longueur, puis si ok, compter le nombre de points présents pour établir et vérifier le critère de densité ?
Et ensuite passer au point suivant hors de ce rectangle (dans tous les cas)

[LaurentC33]

C'est une idée...Je vais tenter ce que je peux, merci à toi
Je te tiens au courant !

[PixelJuice]

Hello,

Je pense qu'il doit avoir un algo bien précis pour ce genre de problème mais perso de but en blanc je ferai comme ça :

Je diviserais ça par cellule. D'abord des grosses pour repérer grosso-modo les convergences. Ensuite additionner les cellules prometteuses (au cas ou l'algo a tranché dans un nuage de points). Et refaire la même chose, avec une taille moindre, etc ... Ainsi affiner les points et ne travailler que là ou on sait qu'il y a de la densité. En plus il y aurai une notion d'affinage donc possiblement encore + de contrôle.