Discussion :

[Crayon]

Salut, juste pour être certain est-ce que tu peux mettre l'image que tu as créé à ma disposition.

[Crayon]

En passant, j'avais dis un bitmap de 1x256 pas 256x256 pixels:

Code :

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

1
2
3
// Dimension du bitmap
Gradient->Width=256;
Gradient->Height=256;

En plus, tu ne charges jamais ton fichier bmp dans le TBitmap. Il faut faire quelques chose du genre:

Code :

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

Gradient->LoadFromFile("MonFichier.bmp");

[henderson]

Salut !

Tu peux aussi construire une palette.
Pour représenter cette palette, il suffira d'un TPaintBox placé sur la fiche (Height = 256 et Width = 32).
Cette paintbox dessinera son contenu graphique grace au code qu'on placera dans sa OnPaint.
En voici l'exemple (en partant d'un nouveau projet et une simple fiche avec une TPaintBox) :

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
 
//--
#include <vcl.h>
#include <math.h>
#pragma hdrstop
 
#include "Unit1.h"
//--
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
 
#define pi 3.14159265358979
TColor Palette[256];
 
//--
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
// Initialisation de la palette
double dr, dg, db;
int r, g, b;
for(int c = 0; c < 256; c++)
    {
    dr = c / 512.0 * pi;
    dr = sin(dr) * 255.0;
    r = dr;
 
    db = c / 512.0 * pi;
    db = (1.0 - sin(db)) * 255.0;
    b = db;
 
    dg = c / 256.0 * pi;
    dg = sin(dg) * 255.0;
    g = dg;
 
    Palette[c] = (TColor)RGB(r,g,b);
    }
}
 
//-- OnPaint de PaintBox1
 
void __fastcall TForm1::PaintBox1Paint(TObject *Sender)
{
for(int y =0; y < 256; y++)
    {
    for(int x =0; x < PaintBox1->Width; x++)
        {
        PaintBox1->Canvas->Pixels[x][y] = Palette[y];
        }
    }
}
//--

Par rapport à ton problème graphique, on va considérer que les valeurs des coefficients ont été ramenées dans un intervalle connu.
Par exemple [0.0 ... 1.0] ou bien [0.0 ... 256.0[ c'est à dire de 0 >= a < 256.0 ... ce qui serait très pratique.
On va considérer que l'écran est suffisamment grand pour tout représenter.
On part donc sur les bases suivantes :

Code :

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

1
2
3
4
 
int max_f;
int max_t;
double coefficients[max_f][max_t]; //valeurs telles que 0.0 <= a < 256.0

Donc on va avoir à faire :

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
 
int f,t;
Image1->Width = max_t;
Image1->Height = max_f;
//On récupère le bitmap
Graphics::TBitmap *Bitmap = Image1->Picture->Bitmap;
// Pour lui donner les bonnes dimensions
Bitmap->PixelFormat = pf24bit;
Bitmap->Width = max_t;
Bitmap->Height = max_f; 
 
// L'algo de la colorisation des pixels
// REM : valeurs des coefficients tels que  0.0 <= a < 256.0
 
for(f =0; f < max_f; f++)
    {
    for(t=0; t < max_t; t++)
        {
        Image1->Canvas->Pixels[t][f] = Palette[ (int)coefficients[f][t] ];
        }
    }

A ce stade il n'y a rien d'autre à faire.

Si par contre, le programme doit aussi tourner avec des écrans plus petits, dans ce cas on peut placer Image1 dans un TScrollBox pour ne faire glisser que Image1 dans la zone client de la scrollbox.
Parce que je n'ose même pas te proposer de manoeuvrer le scrolling manuellement dans une zone client à dimensions fixes, et ce à l'aide soit de la souris soit d'un TScrollBar !

A plus !

[Crayon]

henderson, je ne savais pas comment générer la palette. Ton code est super

PS: à la place d'utiliser ton propre define pour pi, tu peux utiliser M_PI qui est dans math.h

[kheira]

j'ai cré une image bitmap dans le fichiers de projet que j'ai nomé result avec 0 octet et j'ai executé le code mai ça mai ça donne toujour du noir sur ma frame : je comprant pas pourquoit ::

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// création du bitmap
Graphics::TBitmap* Gradient = new Graphics::TBitmap();
// Dimension du bitmap
Gradient->Width=1;
Gradient->Height=256;
Gradient->LoadFromFile("result.bmp");
for(int i = 0; i<freq  ; i++){
for(int j =0; j<longSignal ; j++)  {
int c=int(a*f[i][j]+b);
Gradient->Canvas->MoveTo(i,j*4);
Gradient->Canvas->LineTo(i,j*4+4);
TColor Macouleur = Gradient->Canvas->Pixels[0][c];
Image1->Canvas->Pixels[i][j]= Macouleur ;
                          }}

je suis débutante et je comprent pas ou est le probleme !!

[henderson]

Salut !

Tu sembles faire n'importe quoi !
As-tu regardé ce que je viens de proposer ?

A plus !

[kheira]

j'ai fait ce que ta donner dans le premiers exemple de la palette , j'ai ouvre un nouveau projet et je voulez executé ton premier code sur la palette :

mai il me donne cette erreur lors de l'execution !!

Code :

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

[Lieur Erreur fatale] Fatal: Could not open C:\Program Files\Borland\CBuilder6\Projects\Project2.exe (error code 5)

[Crayon]

j'ai cré une image bitmap dans le fichiers de projet que j'ai nomé result avec 0 octet

Je pense que tu n'as pas compris le principe de capture d'écran

J'pense que le message d'erreur que tu obtiens est celui qui apparait quand le fichier exe est ouvert et qu'il ne peut pas compiler.

EDIT:
Le plus drôle c'est que tu as compressé ton bitmap de 0 octet en rar pour faire un fichier de 69 octets.

[henderson]

Salut !

On peut modifier :

- les bleus s'évanouissent rapidement à cause de 1-sin (de 0 à pi/2)
Il en résulte une prédominance de vert dans le centre de la bande qui lui évolue de 0 -> 1 -> 0 (de 0 à pi)
Le code à l'origine :

Code :

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

1
2
3
4
 
db = c / 512.0 * pi;
db = (1.0 - sin(db)) * 255.0;
b = db;

- les bleus mettent plus de temps à s'évanouir à cause de cos (de 0 à pi/2)
Il en résulte une pâleur bleu/verte au centre de la bande :

Code :

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

1
2
3
4
 
db = c / 512.0 * pi;
db = cos(db) * 255.0;
b = db;

Et à ce stade là, on peut aussi intervertir r,g,b ... donc "à vos palettes" !

A plus !

[kheira]

Alors voila quant j’ai essayé ce que vous m’avez donné avec le code suivant ça ma donner une image bleus avec du noir , ( 1ere image ) !!

Code :

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

1
2
 
Image1->Canvas->Pixels[j][i] = Palette[int coef[i](j]];

Je mai a votre savoir que les valeur de coefficient d’ondelette appartient a l’intervalle |[-50 +50] il existe aussi dans ma matrice des valeur négatif !!

Âpre j’ai essayé ce code la tel que mine est la valeur la plus petite dans la matrice des coefficient e t maxe et la valeur maximale dans la matrice des coefficient ? ET ça ma donner la deuxieme image :

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
mine =coef[0][0] ;
 maxe = coef[0][0];
for(int i = 0; i<freq  ; i++){
for(int j =0; j<longSignal ; j++) {
 
        if (coef[i][j]<mine) { mine=f[i][j];}
          if (coef[i][j]>maxe){ maxe=f[i][j];  }
 
                     }}
 
b=(255*mine)/(mine-maxe);
a=(255-b)/maxe ;
Image1->Width = 1875;
Image1->Height = 64;
 
//On récupère le bitmap
Graphics::TBitmap *Bitmap = Image1->Picture->Bitmap;
 
// Pour lui donner les bonnes dimensions
Bitmap->PixelFormat = pf24bit;
Bitmap->Width = 1875;
Bitmap->Height = 64;
for(int i = 0; i<freq  ; i++) {
for(int j =0; j<longSignal ; j++)  {
int c=int(a*coef[i][j]+b);
Image1->Canvas->Pixels[j][i] = Palette[c];
}
}

et je veux bien votre avié ,car ça na pas donnée des résultat comme celui dans ma premier image dans mon premier message poster comme celle de matlab

[henderson]

Salut !

Je mai a votre savoir que les valeur de coefficient d’ondelette appartient a l’intervalle |[-50 +50] il existe aussi dans ma matrice des valeur négatif !!

Ok !

Si 0 (zéro) signifie une amplitude nulle (pas de signal) que signifie alors une valeur négative ?
Tu es bien sûr qu'il n'y a pas d'imaginaires mélangés à des réels ?

Si on prend pour argent comptant l'intervalle [-50, +50] : ambitus = 100.0
Alors tu n'a pas besoin de détecter min ou max puisqu'ils te sont définis par l'intervalle :

l'index de la couleur dans la palette ( Palette[256] ) vaut : ( Coefficients[][] + 50.0) * 255.0 / 100.0

Donc zéro d'amplitude ... ça correspondrait à un coefficient de -50 ?

A plus !

[kheira]

tu c j'ai pas vraiment comprié votre réponce !!

es que tu veux dire que je doit remplacer

Code :

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

1
2
int c=int(a*coef[i][j]+b);
Image1->Canvas->Pixels[j][i] = Palette[c];

par

Code :

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

Image1->Canvas->Pixels[j][i] = Palette[(Coefficients[][] + 50.0) * 255.0 / 100.0];

ou dans la déclaration de TClor Plaette [256] ..!!

on ce qui concerne ta question je voulez te dire une amplitude ou une fréquence peut avoir une coefficient négative ou postive je ne c(est pas pourquoi ta dit que amplitude 0 correspondait a -50 ( exemple la frequence 20 peut avoir comme coeffisiant -50 ) !!

[henderson]

Salut !

C'est pour avoir une idée du référentiel !
Par exemple, imaginons un EEG plat (ton patient est cliniquement mort).
Quelles valeurs va t-on trouver dans ta matrice : -50.0 ou 0.0 ???
Quelle couleur à l'écran ?

Parce que si je représente ça sous forme d'un plan de mailles en 3D (incliné et en rotation), je sais parfaitement tracer mes positives et négatives depuis le plancher (le 0.0) pour créer des bosses et des creux !

A plus !

[kheira]

alors a votre avie je utilise quelle code pour resoudre ce probleme d'intervalle !! et je vous remercié pour votre aide

[henderson]

Salut !

Voici un exemple purement graphique qui n'utilise qu'une simple fiche (Form1).
On va dessiner pour représenter :
- un cadre et le signal
- un cadre temps/fréquences et les amplitudes
- un cadre pour les teintes de la palette
A noter que le contenu des deux premiers cadres est compressé (stretch).

C'est juste une base.

Donc à toi de positionner et dessiner du texte !!! (TCanvas:: => Font, TextWidth, TextHeight et TextOut)
Et plus globalement à toi de trouver comment améliorer ce code pour qu'il réponde à tes besoins.

Note que tu peux utiliser des TPaintBox pour placer tes cadres sur la fiche et y dessiner.
Ce sera plus simple pour toi de raisonner dans chaque zone client !

Comme mon code est une "usine à gaz", on peut objétiser pour rendre tout ça plus lisible.
Donc l'astuce consisterait à dériver de TPaintBox, de TGraphicControl ou de TCustomControl voire même de TImage ou carrément de TCustomForm.
Sans compter qu'une classe dédiée pour la matrice serait pas mal non plus !
Pour finir : je teste sur BCB3 Pro donc ... peut-être que ça se simplifie sur d'autres versions de BCB !

Dans ce qui suit, les courbes (pour donner vie au test) ne sont que pure anecdote (le "patient" à pensé profondément à de la "tôle ondulée") !

Voici comment se résente le .h

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
 
//----
#ifndef Unit1H
#define Unit1H
//---
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
//---
 
#define pi 3.14159265358979
 
// au lieu d'utiliser TColor, voici une classe RGB plus pratique
// pour ce qui va suivre ...
class jRgb
{
public :
Byte Blue;
Byte Green;
Byte Red;
};
 
//--- la déclaration de la classe TForm1
class TForm1 : public TForm
{
__published :	// Composants gérés par l'EDI
    void __fastcall FormPaint(TObject *Sender);
    void __fastcall FormResize(TObject *Sender);
 
private:	// Déclarations de l'utilisateur
Graphics::TBitmap *Bitmap;
Graphics::TBitmap *Temp;
public:		// Déclarations de l'utilisateur
 
// Notre palette (un tableau de jRgb)
jRgb Palette[256];
 
// Le signal source
UINT NbSamples;
double *Samples;
 
// La matrice
UINT Max_F;
UINT Max_T;
UINT NbGradients;
double *TabGradients;
double **Gradients;
 
// De quoi positionner les éléments du graphisme
TPoint SignalPos; (position du coin : top/left)
TPoint GradientsPos;
TPoint PalettePos;
 
    __fastcall TForm1(TComponent* Owner);
    // je rajoute un destructeur pour TForm1
    __fastcall ~TForm1();
 
    // Une méthode supplémentaire que l'on déclare ici
    void __fastcall DrawBitmap();
};
//----
extern PACKAGE TForm1 *Form1;
//----
#endif

Et voici maintenant le .cpp :

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
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
 
//---
#include <vcl.h>
#include <math.h>
#pragma hdrstop
 
#include "Unit1.h"
//---
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//----- Constructeur de TForm1
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
UINT f, i, j;
double d, r;
 
Brush->Style = bsClear;
 
Bitmap = new Graphics::TBitmap;
Bitmap->PixelFormat = pf24bit;
 
// Le tableau de samples (le signal source)
NbSamples = 1800;
Samples = new double[NbSamples];
// remplissage pour donner vie
for(i=0; i < NbSamples; i++)
    {
    // signal sinus
    j = i % 300;
    d = j / 150.0;
    Samples[i] = sin(d * pi);
    }
 
// La matrice
Max_F = 64;
Max_T = NbSamples;
NbGradients = Max_F * Max_T;
TabGradients = new double[ NbGradients ];
Gradients = new double*[ Max_F ];
for(f = 0; f < Max_F; f++) Gradients[f] = &TabGradients[f * Max_T];
// remplissage pour donner vie
for(i=0; i < NbGradients; i++)
    {
    r = (i % Max_T);
    r = ((r / Max_T) - 0.5) * 3.0;
    j = i % 300;
    d = j / 150.0;
    TabGradients[i] = sin(d * pi) * 25.0 * r  ;
    }
 
// Positions des objets graphiques sur la fiche
SignalPos = Point(40, 10); // x ==> left et y ==> top
GradientsPos = Point(40, 100);
PalettePos = Point(600, 100);
 
// Teintes de la palette
for(int c = 0; c < 256; c++)
    {
    d = c / 512.0 * pi;
    d = cos(d) * 255.0;
    i = d;
    Palette[c].Blue = (Byte)i;
 
    d = c / 512.0 * pi;
    d = sin(d) * 255.0;
    i = d;
    Palette[c].Red = (Byte)i;
 
    d = c / 256.0 * pi;
    d = sin(d) * 255.0;
    i = d;
    Palette[c].Green = (Byte)i;
    }
 
}
//----- Le destructeur de TForm1
__fastcall TForm1::~TForm1()
{
delete Bitmap;
Bitmap = NULL;
if(Samples != NULL) delete [] Samples;
if(Gradients != NULL) delete [] Gradients;
}
//----- OnPaint de Form1
void __fastcall TForm1::FormPaint(TObject *Sender)
{
DrawBitmap();
}
//----- OnResize de Form1
void __fastcall TForm1::FormResize(TObject *Sender)
{
DrawBitmap();
}
//----- Une méthode pour dessiner les 3 objets graphiques
void __fastcall TForm1::DrawBitmap()
{
jRgb *S;
double d;
UINT i, x,y;
if(Bitmap != NULL)
    {
    int we = ClientWidth;
    int he = ClientHeight;
 
    // un bitmap temporaire
    Temp = new Graphics::TBitmap;
    Temp->PixelFormat = pf24bit;
    Temp->Width = NbSamples;
    Temp->Height = 64;
    TCanvas *T = Temp->Canvas;
 
    // le bitmap principal
    if(Bitmap->Width != we) Bitmap->Width = we;
    if(Bitmap->Height != he) Bitmap->Height = he;
    TCanvas *C = Bitmap->Canvas;
 
    // Initialisation des outils
    C->Pen->Color = clGray;
    C->Pen->Mode = pmCopy;
    C->Pen->Style = psSolid;
    C->Brush->Style = bsSolid;
    C->Brush->Color = Color;
    // On efface le bitmap principal
    C->FillRect(ClientRect);
 
// Dessin des samples (le signal source)
 
    //Initialisation des outils du bitmap temporaire
    T->Pen->Mode = pmCopy;
    T->Pen->Style = psSolid;
    T->Pen->Color= clGray;
    T->Brush->Style = bsSolid;
    T->Brush->Color = clBlack;
    // On efface le bitmap
    T->FillRect(Rect(0,0,Temp->Width, Temp->Height));
    // calcul et traçage de l'axe
    int axe = Temp->Height / 2;
    // Gain pour mes samples (avec une bonne marge anti-bavures)
    int a = axe - 4;
    T->MoveTo(0, axe); T->LineTo(Temp->Width, axe);
 
    //Changemet d'outil pour dessiner les samples
    T->Pen->Color = clLime;
    // REM : intervalle de mes samples : [-1.0 à +1.0] (courbe sinus)
    // on se positionne sur le premier sample
    // REM : les y graphiques sont vus inversés donc on redresse
    T->MoveTo(0, axe - (Samples[0]* a) );
    // et on trace de sample en sample
    for(x = 1; x < NbSamples; x++)
        {
        T->LineTo(x, axe - (Samples[x] * a));
        }
    // On va appliquer un Stretch
    TRect D = Rect(SignalPos.x, SignalPos.y,
                   SignalPos.x + 512, SignalPos.y + 64);
    //Copie du bitmap temporaire sur le bitmap principal
    C->StretchDraw(D, Temp);
 
// les gradients
    // REM : le Temp fait 64 * 1800
    // On va tout remplir
    for(y = 0; y < 64; y++)
        {
        // On utilise Scanline à la place de Pixels pour booster le graphisme
        S = (jRgb*)Temp->ScanLine[y]; // la ligne [y]
        // Remplissage d'une ligne
        for(x = 0; x < Max_T; x++)
            {
            // alors ici ... je fais comme ça (???)
            d = (Gradients[y][x] + 50.0) * 2.55 ;
            i = d;
            S[x].Blue  = Palette[i].Blue;
            S[x].Green = Palette[i].Green;
            S[x].Red   = Palette[i].Red;
            }
        }
    // On va appliquer un Stretch
    D = Rect(GradientsPos.x, GradientsPos.y,
             GradientsPos.x + 512, GradientsPos.y + 256 + 128);
    C->StretchDraw(D, Temp);
 
// la palette
 
    // On réduit les dimensions du bitmap temporaire
    Temp->Width = 16;
    Temp->Height = 256;
    // on rempli
    for(y=0; y < 256; y++)
        {
        S = (jRgb*)Temp->ScanLine[y];
        for(x=0; x < 16; x++)
            {
            S[x].Blue  = Palette[y].Blue;
            S[x].Green = Palette[y].Green;
            S[x].Red   = Palette[y].Red;
            }
        }
    // On copie tel quel
    C->Draw(PalettePos.x, PalettePos.y, Temp);
 
    // Il ne reste plus qu'à dessiner le bitmap principal sur la form
    Canvas->Draw(0,0, Bitmap);
 
    // Le bitmap temporaire n'est plus utile
    delete Temp;
    }
}
//-----

A plus et bon courage !