Discussion :

[merlinerick]

Salut, chers developpeurs!
J'ai un problement pour tracer sur mon graphique une sequence.
En fait, je veux representer une sequence x1[n] = {1,-1,-1,1} N fois sur l'interface; ceci sous la forme:
x[n] = {0,0,0, 1,-1,-1,1,0,0,0, 1,-1,-1,1,0,0,0, 1,-1,-1,1,.....}
Comme vous pouvez le constater, x[n] n'est que la representation de x1[n] N-fois, mais ne commencant pas à l'origine de l'axe.

Quelqu'un peut-il m'aider avec un simple code en C me resolvant le probleme?

Merci d'avance

[nicodn02]

tu veus que:
x[n] = { 1,-1,-1,1, 1,-1,-1,1, 1,-1,-1,1, ... }
?

Si oui,
_ compter le nombre d'éléments que x[n] devra contenir (si ce dernier n'est pas en statique)

_ utilisation de deux boucles for
_ une allant de 0 a N (nombre de répétition de x1[n]) ... i
_ une allant de 0 a 4 (nombre d'éléments de x1[n]) ... j

2 méthodes:
_ soit tu concatènes à chaque fois
strcat(x[n], x1[j]);
attention, x[n] doit être initialiser : x[0] = '\0';
_ soit tu te créer un compteur mémorisant la position de x[n] à remplir, qui est égal, si je ne me tromps, à (i*4+j)

[merlinerick]

Merci,Nicodn02, pour l'idée.
En fait, entre les fois il dois avoir la sequence {0,0,0}. C'est à dire, avant de dissiner {1,-1,-1,1}, je dois avoir {0,0,0} et ainsi de suite. On aura alors (dans mon exemple) {0,0,0,1,-1,-1,1,0,0,0,1,-1,-1,1,0,0,0,....} Cest ca en fait mon probleme.
Je ne parviens pas à le faire.

[darrylsite]

Salut, chers developpeurs!
J'ai un problement pour tracer sur mon graphique une sequence.
En fait, je veux representer une sequence x1[n] = {1,-1,-1,1} N fois sur l'interface; ceci sous la forme:
x[n] = {0,0,0, 1,-1,-1,1,0,0,0, 1,-1,-1,1,0,0,0, 1,-1,-1,1,.....}
Comme vous pouvez le constater, x[n] n'est que la representation de x1[n] N-fois, mais ne commencant pas à l'origine de l'axe.

Quelqu'un peut-il m'aider avec un simple code en C me resolvant le probleme?

Merci d'avance

je mentirais si je dis que j' ai compris un mot dans ton post. Si tu peux etre plus explicite et pourquoi pas donner un exemple, ça nous aidera à te proposer des solutions .

[merlinerick]

je mentirais si je dis que j' ai compris un mot dans ton post. Si tu peux etre plus explicite et pourquoi pas donner un exemple, ça nous aidera à te proposer des solutions .

Plus concret par un exemple:
J'ai un signal (Array) à n Element que je veux tracer graphiquement N fois sur le même graphe.
Ca veut dire soit x[n] = {1,-1,-1,1} à tracer. Ce signal sera representé comme suit:
Y[n] = {0,0,0,1,-1,-1,1,0,0,0,1,-1,-1,1,0,0,0,1,-1,-1,1,0,0,0,....}
vous voyez bien que Y[n] n'est que la representation N fois de x[n] mais avec decalage à droite ( c'est à dire que le tracage ne commence pas à l'origine de mes axes, le pourquoi du 0,0,0 en debut de Y[n] ). Plus explicitement, on peux imaginer qu'on commence à tracer x[n] à 3 cm de l'axe des abcisses, puis on avance de 3 cm et on retrace x[n], puis ensuite de 3 cm et on retrace x[n], encore de 3 cm et on retrace x[n], encore....et encore... N fois. C'est la raison pour laquelle j'ai voulu simplifier plus haut en disant que Y[n] est la representation N-fois de x[n]

Ce que j'ai sous la mains: Je connais le nombres d'element de x[n], le nombre de zeros (0) est au choix.

J'espère que vous me comprendrez mieux.
Merci d'avance pour votre aide

[jeroman]

Quelqu'un peut-il m'aider avec un simple code en C me resolvant le probleme?

Ton problème ne concernerait pas plutôt l'utilisation d'une librairie graphique ? Le C est un langage de programmation, pas une librairie graphique...

... ou alors j'ai pas du tout compris ta question.

[merlinerick]

Ton problème ne concernerait pas plutôt l'utilisation d'une librairie graphique ? Le C est un langage de programmation, pas une librairie graphique...

... ou alors j'ai pas du tout compris ta question.

Definitivement pas. La librairie graphique me sert à representer ma sequence certes, mais elle ne me sert pas à la representer plusieurs fois sur le meme graphique. J'ai necessairement besoin de boucle en C comme l'a suggerer nicodn02 plus haut. Mais je ne sais pas comment l'implementer. Je travaille avec CVI de National Instruments sur lequel il existe la fonction PlotY(.....) pour les representation graphiques.

[droggo]

Gae,

Definitivement pas. La librairie graphique me sert à representer ma sequence certes, mais elle ne me sert pas à la representer plusieurs fois sur le meme graphique. J'ai necessairement besoin de boucle en C comme l'a suggerer nicodn02 plus haut. Mais je ne sais pas comment l'implementer. Je travaille avec CVI de National Instruments sur lequel il existe la fonction PlotY(.....) pour les representation graphiques.

Moi je crois que si. Ton problème semble être plutôt un problème de mise en page graphique qu'un problème dû à C, qui n'a rien de standard pour faire ça.

Ou alors, explique mieux ce que tu veux faire.

[merlinerick]

Gae,

Moi je crois que si. Ton problème semble être plutôt un problème de mise en page graphique qu'un problème dû à C, qui n'a rien de standard pour faire ça.

Ou alors, explique mieux ce que tu veux faire.

Je ne sais comment je peux encore expliquer. Si tu lis toutes les explication que j'ai faites, tu vera exactement de quoi il s'agit.
Encore une fois, le probleme c'est de tracer une courbe plusieurs fois sur le meme graphique et à intervalle bien definie.

Ce n'est pas tracer la courbe qui est mon probleme, je l'ai tracée. C'est la tracer plusieur fois qui me fais probleme. C'est le pourquoi je dis bien que c'est deux boucle for au moins que je dois implementer pour le tracage: Une qui representant la nombre d'element à tracer, l'autre representant le nombre de fois à tracer ( sans superposer et sans qu'elles, les courbes, ne se touchent).

L'autre parametre qui entre en jeu est la "distance" entre les courbes ( puisqu'elles ne doivent pas se toucher ).

Je repete bien c'est des boucles for qui sont les mieux indiques ici. strcat ne marche pas. Il 'sagit dont bel et bien d'un code C. Il n'ya pas(à ce que je sache) une fonction dans la librairie graphique qui me permette de resoudre. Ne rendez pas le probleme plus complique qu'il ne l'ai s'il vous plait. Ce n'est pas simple de mon coté. Mais je trouve que pour un forum comme celui-ci,tel que j'ai expliqué le probleme, ce devrait sauter à l'oeil de beaucoup d'entre vous. J'ai dejà beaucoup éte aidés par nombreux d'entre vous sur ce forum pour des problemes très complexe d'ailleurs.

Merlinerick

[droggo]

Gao,

C'est donc bien un problème de représentation graphique.

Un dessin valant mieux que des milliers de mots, si tu nous en faisais un petit pour voir ce que tu veux faire.

Et puisqu'il y a librairie graphique, laquelle, quel OS, ... ?

[merlinerick]

Gao,

C'est donc bien un problème de représentation graphique.

Un dessin valant mieux que des milliers de mots, si tu nous en faisais un petit pour voir ce que tu veux faire.

Et puisqu'il y a librairie graphique, laquelle, quel OS, ... ?

Voici un exemple ( voir fichier ). J'ai representè un signal (Array) x[n] = {1,-1,1,-1,1,1,-1,1} de 8 Elements. Sur l'abcisse, on voit bien que le signal va de 0 à 8. Maitenent je veux representer le meme signal N fois sans superposition sur le même graphique. la representation ne dois pas commencer à l'origine mais plutôt au point 7 par exemple de l'abcisse. Ca veux dire que le sigal finirait au point
7+8=15. Puis le meme siganl doit etre representé à partir du point 15+7 = 22 et ainsi de suite jusqu'á ce que je l'ai trace autant de fois que je veux. Comment je dois programmer celà?

[merlinerick]

Voici en fait le bon fichier.
En bas vous voyez ce que j'ai tracé. En haut se trouve ce que je veux realiser ( x[n] = {1,-1,1,-1,1,1,-1,1}...8 elements); il s'agit de tracer ce que j'ai en bas plusieurs fois. Dans l'exemple, je l'ai tracé trois fois et mais en decalant d'abord de quelque carreaux à droite ( ici 4 careaux) .

J'ai realisé l'exemple ici avec Excel

[je®ome]

Peut-être que je n'ai pas bien compris la question, mais je ne vois pas du tout le problème. Si chaque point est incrémenté de 1 sur l'abscisse par rapport au précédent, voici une façon de procéder.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
x=emplacementAbscisseDepart;
pour i de 1 à nbFois faire
  pour j de 0 à nbElem-1 faire
    tracerligne(x,t[j],x+1,t[j+1])
    x++;
  ffaire
  pour j de 0 à saut faire
    tracerligne(x,0,x+1,0)
    x++;
  ffaire
ffaire

t correspond au tableau x1.
Si ce n'est pas ça, c'est que je n'ai pas compris le problème.

[valefor]

Je ne suis pas d'accord. On peut se passer de l'aspect graphique.

Tu as la taille de chaque élément (disons des int).
Tu as la taille de chaque séquences (par exemple {-1, 1, -1, 1} fait 4).
Tu as la taille de chaque espace (par exemple {0, 0, 0} fait 3).
Tu as le nombre de répétition voulues N.

Tu alloues l'espace :

Code :

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

y = malloc((taille_espace + taille_sequence) * sizeof(int) * N);

Tu boucles pour remplir :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int i;
int *y_ptr = y;
for(i = 0; i < N; i++)
{
  memcpy(y_ptr, pattern_espace, taille_espace);
  y_ptr += taille_espace;
  memcpy(y_ptr, pattern_sequence, taille_sequence);
  y_ptr += taille_sequence;
}

Et voila.

[je®ome]

Je ne suis pas d'accord. On peut se passer de l'aspect graphique.

Tu as la taille de chaque élément (disons des int).
Tu as la taille de chaque séquences (par exemple {-1, 1, -1, 1} fait 4).
Tu as la taille de chaque espace (par exemple {0, 0, 0} fait 3).
Tu as le nombre de répétition voulues N.

Tu alloues l'espace :

Code :

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

y = malloc((taille_espace + taille_sequence) * sizeof(int) * N);

Tu boucles pour remplir :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int i;
int *y_ptr = y;
for(i = 0; i < N; i++)
{
  memcpy(y_ptr, pattern_espace, taille_espace);
  y_ptr += taille_espace;
  memcpy(y_ptr, pattern_sequence, taille_sequence);
  y_ptr += taille_sequence;
}

Et voila.

Pourquoi allouer n*(nbElem+tailleSaut)*taille(elem) si on peut s'en passer ?
Le but est bien de tracer ces courbes et non de mettre tous les points dans un tableau ?
Si c'est uniquement pour tracer les courbes, pas besoin de la répétition des valeurs, c'est du gâchis mémoire.

[valefor]

Cela dépend de l'implémentation de la librairie graphique...

Si elle permet de récupérer un pointeur vers son buffer interne, pas utile d'allouer.

Parfois on peut passer un buffer aux fonctions de dessin.

L'avantage de ne pas dessiner à la volée est de ne pas à avoir à gérer le rafraichissement et toutes ces choses, très spécifiques à la vue, de manière imbriquée avec la gestion des données.

[merlinerick]

Je ne suis pas d'accord. On peut se passer de l'aspect graphique.

Tu as la taille de chaque élément (disons des int).
Tu as la taille de chaque séquences (par exemple {-1, 1, -1, 1} fait 4).
Tu as la taille de chaque espace (par exemple {0, 0, 0} fait 3).
Tu as le nombre de répétition voulues N.

Tu alloues l'espace :

Code :

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

y = malloc((taille_espace + taille_sequence) * sizeof(int) * N);

Tu boucles pour remplir :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int i;
int *y_ptr = y;
for(i = 0; i < N; i++)
{
  memcpy(y_ptr, pattern_espace, taille_espace);
  y_ptr += taille_espace;
  memcpy(y_ptr, pattern_sequence, taille_sequence);
  y_ptr += taille_sequence;
}

Et voila.

Valefor, c'est exactement par la methode que tu propose que je devrais faire. C'etait ca que j'ai essayé d'expliquer dès le debut; nicodn02 et toi avez ètes dans le sens de ma pensée. Il ne s'agissait pas de probleme de graphique, mais plutot d'un code C. Le but effectivement est de representer tous les points de la sequence.
Je vais essayer cette proposition et vous ferai part dès ce soir.
(Hors sujet), Il peut s'averer que certains ce soient sentis offensés par mes ecrits. Ceci est très loin de mes intentions, de ma personne. C'est un plaisir pour moi de venir vous lire, demander des conseil. À tous ceux là, je m'excuse.

merlinerick

[valefor]

Après relecture je m'a trompé : ce n'est pas

Code :

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

memcpy(y_ptr, pattern_espace, taille_espace);

mais

Code :

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

memcpy(y_ptr, pattern_espace, taille_espace * sizeof(int));

idem pour la séquence...

[merlinerick]

Salut!
J'ai resolu le probleme. J'ai du allouer la memoire, l'espace ici etant plus grande par rapport a celui de ma sequence (couvrant aussi l'espace vide 0,0,0,..). Et après j'ai fait deux boucle, l'une dans l'autre. Après j'ai plutôt tracé la nouvelle sequence. L'idée de Valefor allait dans le même sens que la mienne, mais mon l'implementation n'a pas été comme ce qu'il a fait.

Merci une fois de plus.

Merlinerick