Conseil: Quel composant pour générer une Heatmap (matrice thermique)

Version imprimable

05/02/2013, 15h22
dz_robotix

Conseil: Quel composant pour générer une Heatmap (matrice thermique)

Bonjour,

Je vous donne un exemple d'une Heatmap
elle se présente sous forme de Matrice[n,m];
on associe à chaque cellule Matrice[i,j] une intensité de couleur selon la valeur contenu dans cette cellule.

D'après vous quel composant je pourrais utiliser pour générer une figure comme celle-ci en BCB.

Merci pour votre aide.

http://kb.fusioncharts.com/images/Sa...ap%20chart.JPG

http://kb.fusioncharts.com/images/Sa...ap%20chart.JPG
05/02/2013, 15h45
ShaiLeTroll

Si c'est pour imprimer, j'ignore si TeeChart est aussi puissant, c'est possible en jouant sur les Series en bidouillant un peu tes matrices, c'est toi à la main qui fera le dispatch de couleur

Si c'est pour de l'affichage, avec quelques sacrifices, une TStringGrid (ou même TDrawGrid) pourra faire l'affaire, idem, tu devras gérer le dispatch de couleur
05/02/2013, 15h51
dz_robotix

merci pour ta réponse

j'ai pensé à TDrawGrid mais en fait j'ai des matrice de taille énorme (> 1000) donc point de vue visibilité avec TDrawGrid sa sera limite.
05/02/2013, 16h48
ShaiLeTroll

La DrawGrid gère le défilement, tu pourras ajouter une ScrollBar V et H pour améliorer le confort de l'utilisation

1000 Cellules = Enorme ? :mouarf:
Donc 1000 Cellules, ce n'est que 40 x 25, sur un écran en 1024 x 768, cela fait 25 x 30 pixel pour chaque cellule ce qui n'est pas éloigné de ton image, bon il faut retirer la légende, on doit pouvoir sortir un 20 x 20, cela reste lisible

Si c'est 1000 Lignes x n colonne, oui là c'est difficile, d'où le Scroll comme si tu avais plusieurs pages de graphique
05/02/2013, 17h19
dz_robotix

:D
Oui je veux dire plus de 1000 lignes x 1000 colonnes
et en plus sa devrait être visible sans scroll car je dois l'exporter en image :cry:

Citation:

Envoyé par ShaiLeTroll

La DrawGrid gère le défilement, tu pourras ajouter
une ScrollBar V et H pour améliorer le confort de l'utilisation

1000 Cellules = Enorme ? :mouarf:
Donc 1000 Cellules, ce n'est que 40 x 25, sur un écran en 1024 x 768, cela fait 25 x 30 pixel pour chaque cellule ce qui n'est pas éloigné de ton image, bon il faut retirer la légende, on doit pouvoir sortir un 20 x 20, cela reste lisible

Si c'est 1000 Lignes x n colonne, oui là c'est difficile, d'où le Scroll comme si tu avais plusieurs pages de graphique
05/02/2013, 18h03
yarp

Dans ce cas si j'étais toi je ne m'embêterais pas et je dessinerais tout dans un TPaintBox et tu dessine toi-même dans le Paint.
L'objet à dessiner serait une image. 1000x1000 pour une image cela ne pose pas de problème de perf, et tu peux rafraichir des parties seulement de l'image.
Quand je dessine directement sur l'écran je ne passe pas par TPicture, ni TBitmap, je passe directement par un DIB.
05/02/2013, 18h13
dz_robotix

Merci Yarp pour la proposition.

Sinon si je reviens à TDrawGrid , j'ai fais ce que m'a proposé ShaiLeTroll,
sa génère une matrice de couleur, par contre quand je fais passer le pointeur de la souris sur une cell(i,j) sa couleur devient blanche, le même phénomène arrive quand je minimise/maximise ou cache la fenêtre principale :calim2::calim2:8O8O8O

Je suis dans la totale confusion.

Une idée??

merci par avance
06/02/2013, 08h31
yarp

Désolé je n'ai pas de CBuilder sous la main. Je pense que c'est une option du composant sur le MouseOver. Tu aura le même problème avec le select.
Avec le DrawGrid il estmiuex d'overrider le OnDrawCell et dessiner la cellule soi-même.
Vu que la couleur de chaque cellule est uniforme ce n'est pas compliqué (TCanvas->FillRect).
Pour le focus si l'événement est de type gdSelect (gdFocus ?) tu dessine un rectangle autour de le cellule (TCanvas->FrameRect).

oui exactement,
un aperçu de ce que j'ai fais !
Code:

1 2 3 4 5 6 7 8 9 for(int i=0;i<N;i++){ for(int j=0;j<M;j++){ TRect DestRect; DestRect=DrawGrid1->CellRect(j+1,i+1);//matrice(i,j) DrawGrid1->Canvas->Brush->Color =scalcolor* MAtrice[i,j]; DrawGrid1->Canvas->FillRect(DestRect); }//for j }//for i
Même problème quand je sélectionne une case (par click): elle devient blanche
pareil quand je réduit la fenêtre dans la barre des tache puis je la maximise.

06/02/2013, 10h30
ShaiLeTroll

une boucle ???
Il est clair que tu n'as pas codé l'affichage correctement !

TDrawGrid doit être dessiner dans un gestionnaire d'évènement de OnDrawCell
Je te conseille la lecture de Grilles de dessin et Un démineur dans une TDrawGrid.
06/02/2013, 12h32
dz_robotix

je crois que je suis en mode saturé.
l’évènement OnDrawCell c'est moi qui devrais l'invoquer quelque part dans le code, car je dois parcourir ma matrice et transformer son contenu en une couleur dans le DrawGrid1.

????
06/02/2013, 16h58
ShaiLeTroll

As-tu comme je te l'ai conseillé lu le tutoriel C++Builder : Un démineur dans une TDrawGrid.

Je suis plus habitué à la TStringGrid que la TDrawGrid mais pas chance cela fonctionne exactement de la même façon, la seule différence c'est que la TDrawGrid ne gère au contenu mais juste du dessin, alors que la TStringGrid gère un tableau de chaine et d'objet, évidemment bien trop lourd pour 1 millions de cellule

Tu affectes ColCount et RowCount selon la taille de ta matrice (pense aussi au FixedRow...)

Ensuite, tout seul la TDrawGrid va appeler DrawCell qui va appeler ton gestionnaire pour OnDrawCell dont le prototype est TDrawCellEvent

Le Dessin n'est fait QUE pour les parties visibles, lors d'un Scroll cela va appeler de nouveau DrawCell pour les nouvelles parties visibles (c'est le blanc que tu voyais)
Donc sur ton million de cellule, seul un millier seront dessinés à un instant T, c'est un évident un gain de performance

Rien à ajouter à ce qu'à écrit ShaiLeTroll, sinon un exemple de OnDrawCell.

Code:

1
2
3
4
5
6
7
8
9
void __fastcall frmMain::DrawGrid1DrawCell(TObject *Sender, int ACol, int ARow,
   TRect &Rect, TDgDrawState State)
{
   // Ou TRect est le rectangle de la cellule qui est redessinée
   // ACol et ARow les indices de la colonne courant (Attention ACol et Arow peuvent être < 0 !!!)
 
   DrawGrid1->Canvas->Brush->Color = scalcolor* MAtrice[ACol,ARow];
   DrawGrid1->Canvas->FillRect(Rect);
}

Salut !

Ne pas oublier qu'on dispose d'un outil de développement qui permet de concevoir des classes.
Ici, on pouvait très facilement dériver de TCustomControl pour modéliser une classe HeatMap.
Le graphisme est alors réalisé à l'aide des primitives de TCanvas sans que ce soit plus compliqué que ce qui nous est montré dans la OnDrawCell.
Voici ma propre classe :

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
class jHeatMap : public TCustomControl
{
private :
//=======
Byte *FMatrix;
Graphics::TBitmap *Bitmap;
 
TPanel *HPanel;
TPanel *Panel;
TScrollBar *HScroll;
TScrollBar *VScroll;
 
TColor Palette[256];
 
UINT FCellWidth;
UINT FCellHeight;
 
protected :
//=========
TPoint TopLeft;
UINT MaxRow;
UINT MaxCol;
 
void __fastcall Init(UINT AMaxCol, UINT AMaxRow);
void __fastcall VertScrolling(TObject *Sender);
void __fastcall HorzScrolling(TObject *Sender);
 
BYTE __fastcall GetMatrix(UINT Col, UINT Row);
void __fastcall SetMatrix(UINT Col, UINT Row, BYTE Value);
 
void __fastcall SetCellWidth(UINT Value);
void __fastcall SetCellHeight(UINT Value);
 
public :
//======
__fastcall jHeatMap(TComponent *AOwner);
__fastcall jHeatMap(TComponent *AOwner, UINT AMaxCol, UINT AMaxRow);
__fastcall ~jHeatMap();
void __fastcall Paint();
 
__property BYTE Matrix[UINT Col][UINT Row] = {read=GetMatrix, write = SetMatrix};
__property UINT CellWidth = {read=FCellWidth, write = SetCellWidth};
__property UINT CellHeight = {read=FCellHeight, write = SetCellHeight};
 
};

A ce stade ce n'est que de la poésie informatique... avec BCB3 Pro !

La propriété Matrix sert à exploiter le tableau FMatrix (1D) comme un tableau 2D.

Voici la méthode Paint :

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
void __fastcall jHeatMap::Paint()
{
if(Bitmap != NULL)
    {
    int we = VScroll->Left;
    int he = HPanel->Top;
    if(Bitmap->Width != we) Bitmap->Width = we;
    if(Bitmap->Height != he) Bitmap->Height = he;
 
    TCanvas *C = Bitmap->Canvas;
    C->Brush->Style = bsSolid;
    C->Brush->Color = clWhite;
    C->FillRect( Rect(0,0,we,he) );
 
    int xe;
    int ye=0;
    UINT col;
    UINT row = TopLeft.y;
 
    while(ye < he)
        {
        xe = 0;
        col = TopLeft.x;
        while(xe  < we)
            {
            if((col < MaxCol) && (row < MaxRow))
                {
                C->Brush->Color = Palette[ Matrix[col][row] ];
                C->FillRect(Rect(xe,ye, xe+CellWidth, ye+CellHeight));
                }
            xe = xe + CellWidth;
            col++;
            }
        ye = ye + CellHeight;
        row++;
        }
 
    Canvas->Draw(0,0, Bitmap);
    }
}

A noter que la palette est initialisée (depuis le constructeur de cette classe) comme suit :

Code:

1
2
3
4
5
6
for(int i=0; i < 256; i++)
    {
    // du vert (min) au rouge (max)
    // il y a d'autres algos tout aussi simplistes
    Palette[ i ] = (TColor)RGB(i, 255-i, 0);
    }

A plus !