tracer une courbe avec GtkCurve ou autre

Version imprimable

bonjours,
je me suis docummenté sur le manuel des fonctions permettant de dessiner un graphe , j'ai vu qu'il existe le widget GtkCurve, par contre j'arrive pas a m'en servire pour dessiner un graphe de points se trouvant dans un tableau ...
je comprend pas tres bien les fonctions du manuel ..gtk_set_vector .. gtk_get_vector ...
voila mon code qui fait pas grande chose ...
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 #include <stdlib.h> #include <gtk/gtk.h> void OnDestroy(GtkWidget *pWidget, gpointer pData); int main(int argc,char **argv) { // Declaration du widget GtkWidget * pWindow; GtkWidget * pVbox; GtkWidget * pCurve; int veclen=5; gfloat vector[5]={0,2,4,5,8}; gtk_init(&argc,&argv); // Creation de la fenetre pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(GTK_WINDOW(pWindow), 500, 300); // Connexion du signal "destroy" g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(OnDestroy), NULL); pVbox=gtk_vbox_new(TRUE,10); // Ajout de la GtkVBox dans la fenetre gtk_container_add(GTK_CONTAINER(pWindow), pVbox); pCurve=gtk_curve_new(); gtk_box_pack_start(GTK_BOX(pVbox), pCurve, TRUE, TRUE, 10); //gtk_curve_set_range(GTK_CURVE(pCurve),0,10,0,10); //gtk_widget_set_sensitive(pCurve,TRUE); gtk_curve_set_vector(GTK_CURVE(pCurve),veclen,vector); gtk_widget_show_all(pWindow); // Demarrage de la boucle evenementielle gtk_main(); return EXIT_SUCCESS; } void OnDestroy(GtkWidget *pWidget, gpointer pData) { gtk_main_quit(); }
quand je fais gtk_set_vector : ca ne fais pas entrer mes points dans le graphe .
et j'aimerai que je ne peux pas modifier le graphe avec la souris ,donc j'ai utilisé gtk_widget_set_sensitive(pCurve,TRUE); mais ca dessine rien...

merci pour votre aide ..

02/04/2007, 15h26
coax81

:( personne ne s'y connais dans GtkCurve ?!!!

j'arrive a tracer , mais il trace pas des points mais des lignes horizontales..!!

j'ai essayer de changer le type de graphe en LINEAR OU SPLINE , mais il fait des beugs !!!!

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
46
47
48
49
50
51
 
#include <stdlib.h>
#include <gtk/gtk.h>
 
void OnDestroy(GtkWidget *pWidget, gpointer pData);
int main(int argc,char **argv)
{
    // Declaration du widget
    GtkWidget * pWindow;
    GtkWidget * pVbox;
    GtkWidget * pCurve;
    int veclen=10;
    gfloat vector[10]={1,10,2,5,5,1,10,2,5,5};
 
    gtk_init(&argc,&argv);
 
    // Creation de la fenetre
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 500, 300);
    // Connexion du signal "destroy"
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(OnDestroy), NULL);
 
    pVbox=gtk_vbox_new(TRUE,10);
    // Ajout de la GtkVBox dans la fenetre
    gtk_container_add(GTK_CONTAINER(pWindow), pVbox);
 
    pCurve=gtk_curve_new();
    gtk_box_pack_start(GTK_BOX(pVbox), pCurve, TRUE, TRUE, 0);
 
    //gtk_curve_set_curve_type(GTK_CURVE(pCurve),GTK_CURVE_TYPE_LINEAR);
    gtk_curve_reset(GTK_CURVE(pCurve));
    gtk_curve_set_range(GTK_CURVE(pCurve),0,10,0,10);
    //gtk_curve_reset(GTK_CURVE(pCurve));
    gtk_widget_set_sensitive(pCurve,FALSE);
    //gtk_curve_get_vector(GTK_CURVE(pCurve),veclen,vector);
    gtk_curve_set_vector(GTK_CURVE(pCurve),veclen,vector);
 
 
 //   GTK_CURVE_TYPE_LINEAR,       /* linear interpolation
 // GTK_CURVE_TYPE_SPLINE,       /* spline interpolation
 // GTK_CURVE_TYPE_FREE          /* free form curve
 
    gtk_widget_show_all(pWindow);
    // Demarrage de la boucle evenementielle
    gtk_main();
    return EXIT_SUCCESS;
}
void OnDestroy(GtkWidget *pWidget, gpointer pData)
{
    gtk_main_quit();
}

03/04/2007, 11h14
Franck.H

Citation:

Envoyé par coax81

j'ai essayer de changer le type de graphe en LINEAR OU SPLINE , mais il fait des beugs !!!!

Déjà vu ce cas mais malheureusement je ne connais encore personne qui a réussi à faire fonctionner correctement ce widget, d'où le manque de réponses :aie:
03/04/2007, 11h23
coax81

y'a t'il une autre solution pour tracer les graphes ?avec des axes??
03/04/2007, 11h28
Franck.H

Citation:

Envoyé par coax81

y'a t'il une autre solution pour tracer les graphes ?avec des axes??

J'avais entendu parler de GtkPlot qui fait parti de GtkExtra mais je ne saurais t'en dire plus désolé, d'ailleurs je ne sais même quelle est sa spécialité :oops:
03/04/2007, 12h09
insa59

Salut

J'ai eu aussi les meme soucis en utilisant la classe GtkCurve.
Lorsque je mettais un type d'interpolation linear ou free, j'avais un probleme d'allocation memoire.
Malheureusement je n'ai pas pu le résoudre.
Pour répondre a ta question tu peux essayer d'utiliser gtkplot comme te le precise franck. Moi j'ai essayer mais je n'ai pas reussi.
Sinon trouve une bibliothèque qui te permette de faire un tracer et ensuite incorpore le dans une fentere GTK (plplot ou gnuplot par ex)
c'est une méthode que je dois essayer prochainement

bon courage;)

ps : Pour les traits, il faut d'apres moi que tu augmente ta fenetre te visualisation

j'ai trouvé un outil avec pixbuf , mais tu doit tout refaire pixel par pixel :
voila mon code actuel , si il y a des gens qui veulent m'aider afin de développer
un outil d'affichage graphique de fonctions mathématiques avec les axes ce sera tres sympas , voila le code actuel :

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
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
 
#include <gtk/gtk.h>
#include <math.h>
 
void dessin(guchar *pixel,guint width, guint height)
{
 
    gint x,y;
    gfloat j;
    guint n_coord;
 
 
    y=0;j=0;
    //for(x=0; x<=width; x++)
int n=30 ,i;
    for(x=10; x<=width-10; x++)
    {
        y=(height) - 10 ;
        if(y<=height)
        {
        n_coord = ((x*3)+(3*y*640));
        pixel[n_coord]      = 255;
        pixel[n_coord+1]    = 255;
        pixel[n_coord+2]    = 255;
        }
        if(x==n)
        {
            n=n+20;
            for(i=0;i<=5;i++)
            {
                y=(height) - 8-i ;
                if(y<=height)
                {
                    n_coord = ((x*3)+(3*y*640));
                    pixel[n_coord]      = 255;
                    pixel[n_coord+1]    = 255;
                    pixel[n_coord+2]    = 255;
                }
            }
        }
    }
 
int m=30;
    for(y=10; y<=height-10; y++)
    {
        x=10 ;
 
        if(y<=width)
        {
            n_coord = ((x*3)+(3*y*640));
            pixel[n_coord] = 255;
            pixel[n_coord+1] = 255;
            pixel[n_coord+2] = 255;
        }
        if(y==m)
        {
            m=m+20;
 
            for(i=0;i<=5;i++)
            {
                 x=8+i ;
                if(y<=width)
                {
                    n_coord = ((x*3)+(3*y*640));
                    pixel[n_coord] = 255;
                    pixel[n_coord+1] = 255;
                    pixel[n_coord+2] = 255;
                }
            }
        }
    }
 
 
 
 
 
    for(x=10; x<=width; x++)
    {
       // y=(gint)((height/2) + (sin(j)*(height/2)));
 
 
       y=(height) - (x) ;
 
        if((y>=10))
        {
        n_coord = ((x*3)+(3*y*640));
        pixel[n_coord] = 255;
        pixel[n_coord+1] = 158;
        pixel[n_coord+2] = 120;
 
        }
 
    }
 
}
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *graph;
    GdkPixbuf *pxgraph;
    guchar * pixel;
 
    // Initialisation des librairies GTK+
    gtk_init(&argc, &argv);
 
    // Création d'une fenêtre principale.
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Fenêtre principale");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 640,480);
 
    pxgraph = gdk_pixbuf_new(GDK_COLORSPACE_RGB,FALSE,8,640,480);
    pixel = gdk_pixbuf_get_pixels(pxgraph);
 
    dessin(pixel, 640, 480);
 
    graph = gtk_image_new_from_pixbuf(pxgraph);
    gtk_container_add(GTK_CONTAINER(pWindow),graph);
 
    // Signaux associés à la fenêtre principale pour quitter.
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    g_signal_connect(G_OBJECT(pWindow), "delete_event", G_CALLBACK(gtk_main_quit), NULL);
 
    // Boucle principale GTK+
    gtk_widget_show_all(pWindow);
    gtk_main();
 
    return 0;
}

j'attend vos commentaire et vos conseils .:)

03/04/2007, 13h58
coax81

desole ya une erreure sur l'equation de la droite la voila la bonne :

y=(height-10) - ((x-10));

on fais toujours y=(height-décalage_nouvelle_origine) - (équation);

avec dans équation on remlace les x par (x-décalage_origine_axes).

j'aimerai bien avoir des gens qui veulent développer avec moi cet outil d'affichage vu que c'est pas fourni par GTK , ca peux aider un grand monde a mon avis ...

amélioration de code :

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
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
 
#include <gtk/gtk.h>
#include <math.h>
 
void dessin(guchar *pixel,guint width, guint height)
{
 
    gint x,y,equation;
    gfloat j;
    guint n_coord;
 
 
    y=0;j=0;
 
int n=40 ,i;
    for(x=20; x<=width-20; x++)
    {
        y=(height) - 20 ;
        if(y<=height)
        {
        n_coord = ((x*3)+(3*y*640));
        pixel[n_coord]      = 255;
        pixel[n_coord+1]    = 255;
        pixel[n_coord+2]    = 255;
        }
 
 
        y=20;
        n_coord = ((x*3)+(3*y*640));
        pixel[n_coord]      = 255;
        pixel[n_coord+1]    = 255;
        pixel[n_coord+2]    = 255;
 
 
        if(x==n)
        {
            n=n+20;
            for(i=0;i<=5;i++)
            {
                y=(height) - 18-i ;
                if(y<=height)
                {
                    n_coord = ((x*3)+(3*y*640));
                    pixel[n_coord]      = 255;
                    pixel[n_coord+1]    = 255;
                    pixel[n_coord+2]    = 255;
                }
 
                y=18+i ;
                n_coord = ((x*3)+(3*y*640));
                pixel[n_coord]      = 255;
                pixel[n_coord+1]    = 255;
                pixel[n_coord+2]    = 255;
            }
        }
    }
 
int m=40;
    for(y=20; y<=height-20; y++)
    {
        x=20 ;
        if(y<=width)
        {
            n_coord = ((x*3)+(3*y*640));
            pixel[n_coord] = 255;
            pixel[n_coord+1] = 255;
            pixel[n_coord+2] = 255;
        }
 
        x=width-20;
        n_coord = ((x*3)+(3*y*640));
        pixel[n_coord] = 255;
        pixel[n_coord+1] = 255;
        pixel[n_coord+2] = 255;
 
 
 
        if(y==m)
        {
            m=m+20;
 
            for(i=0;i<=5;i++)
            {
                 x=18+i ;
                if(y<=width)
                {
                    n_coord = ((x*3)+(3*y*640));
                    pixel[n_coord] = 255;
                    pixel[n_coord+1] = 255;
                    pixel[n_coord+2] = 255;
                }
                x=width-(18+i) ;
                n_coord = ((x*3)+(3*y*640));
                pixel[n_coord] = 255;
                pixel[n_coord+1] = 255;
                pixel[n_coord+2] = 255;
            }
        }
    }
/*_____________________equation:_______________________________*/
    for(x=20; x<=width-20; x++)
    {
        //equation de la droite en fesant un changement de variable x->x-10
       equation = (x-20) ;
 
       y=(height-20) - equation;
 
        if((y>=20) && (y<=height-20))
        {
        n_coord = ((x*3)+(3*y*640));
        pixel[n_coord] = 255;
        pixel[n_coord+1] = 158;
        pixel[n_coord+2] = 120;
 
        }
    }
/*______________________________________________________*/
}
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *graph;
    GdkPixbuf *pxgraph;
    guchar * pixel;
 
    // Initialisation des librairies GTK+
    gtk_init(&argc, &argv);
 
    // Création d'une fenêtre principale.
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Fenêtre principale");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 640,480);
 
    pxgraph = gdk_pixbuf_new(GDK_COLORSPACE_RGB,FALSE,8,640,480);
    pixel = gdk_pixbuf_get_pixels(pxgraph);
 
    dessin(pixel, 640, 480);
 
    graph = gtk_image_new_from_pixbuf(pxgraph);
    gtk_container_add(GTK_CONTAINER(pWindow),graph);
 
    // Signaux associés à la fenêtre principale pour quitter.
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    g_signal_connect(G_OBJECT(pWindow), "delete_event", G_CALLBACK(gtk_main_quit), NULL);
 
    // Boucle principale GTK+
    gtk_widget_show_all(pWindow);
    gtk_main();
 
    return 0;
}

:pc:
j'aimerai bien avoir des gens qui veulent développer avec moi cet outil d'affichage vu que c'est pas fourni par GTK , ca peux aider un grand monde a mon avis ...

07/06/2007, 15h40
mescles

moi j'aimerais bien t'aider, et j'aimerais aussi savoir ce que tu as obtenu de ton coté : je suis en train de galérer pour essayer de faire marcher gtkplot parce que j'ai absolument besoin d'un truc de ce genre là mais pour l'instant rien ne marche moi...
07/06/2007, 15h47
coax81

j'ai abandoné le probléme pour l'instant , j'y reviens plus tard, je suis sur un autre projet , mais si tu peux faire des recherches ca sera pas mal , tu peu prendre mon prog comme base , et l'améliorer .