Faire code C de tracer un graphique automatiquement

J'ai écrit un programme qui écrit une liste de données pour un".dat fichier avec l'intention de les tracer séparément à l'aide de gnuplot. Est-il un moyen de rendre mon code de la parcelle il automatiquement? Mon résultat est de la forme:

x-coord    analytic    approximation
x-coord    analytic    approximation
x-coord    analytic    approximation
x-coord    analytic    approximation
x-coord    analytic    approximation
 ....

Idéalement, lorsque j'exécute le code, le graphique sera également être imprimés avec un x-label, y-étiquette et le titre (qui peut être modifié à partir de mon code C). Merci beaucoup.

Peut-être vérifier les system fonction.

OriginalL'auteur JMzance | 2010-08-19

c gnuplot numerical-methods piping

35

Je suis tombé sur ce lors de la recherche de quelque chose d'autre concernant gnuplot. Même si c'est une vieille question, j'ai pensé que je voudrais vous apporter quelques exemples de code. - Je l'utiliser pour un programme de la mienne, et je pense que c'est un joli travail bien rangé. Autant que je sache, ce PIPEing ne fonctionne que sur les systèmes Unix (voir l'édition ci-dessous pour les utilisateurs de Windows). Mon gnuplot installation l'installation par défaut d'Ubuntu référentiel.
```
#include <stdlib.h>
#include <stdio.h>
#define NUM_POINTS 5
#define NUM_COMMANDS 2

int main()
{
    char * commandsForGnuplot[] = {"set title \"TITLEEEEE\"", "plot 'data.temp'"};
    double xvals[NUM_POINTS] = {1.0, 2.0, 3.0, 4.0, 5.0};
    double yvals[NUM_POINTS] = {5.0 ,3.0, 1.0, 3.0, 5.0};
    FILE * temp = fopen("data.temp", "w");
    /*Opens an interface that one can use to send commands as if they were typing into the
     *     gnuplot command line.  "The -persistent" keeps the plot open even after your
     *     C program terminates.
     */
    FILE * gnuplotPipe = popen ("gnuplot -persistent", "w");
    int i;
    for (i=0; i < NUM_POINTS; i++)
    {
    fprintf(temp, "%lf %lf \n", xvals[i], yvals[i]); //Write the data to a temporary file
    }

    for (i=0; i < NUM_COMMANDS; i++)
    {
    fprintf(gnuplotPipe, "%s \n", commandsForGnuplot[i]); //Send commands to gnuplot one by one.
    }
    return 0;
}
```
MODIFIER

Dans mon application, j'ai aussi couru le problème que l'intrigue n'apparaît pas jusqu'à ce que le programme appelant est fermé. Pour contourner ce problème, ajoutez un fflush(gnuplotPipe) après que vous avez utilisé fprintf envoyer votre commande finale.

J'ai aussi vu que les utilisateurs de Windows peuvent utiliser _popen en place de popen -- cependant je ne peux pas confirmer ce que je n'ai pas de Windows installé.

EDIT 2

On peut éviter d'avoir à écrire dans un fichier en envoyant gnuplot le plot '-' commande suivie de points de données, suivie de la lettre "e".

par exemple
```
fprintf(gnuplotPipe, "plot '-' \n");
int i;

for (int i = 0; i < NUM_POINTS; i++)
{
  fprintf(gnuplotPipe, "%lf %lf\n", xvals[i], yvals[i]);
}

fprintf(gnuplotPipe, "e");
```
Je sais qu'il a été un long temps depuis que cette réponse a été publiée, mais j'ai utilisé le code à partir de votre deuxième édition, plus la boucle avec le commandsForGnuplot en elle pour ajouter des commandes, et il les parcelles, mais il n'est pas ajouter des commandes (title, xlabel ou ylabel). Comment puis-je ajouter si pas de cette façon? S'il vous plaît.

OriginalL'auteur BenB
5

Vous pouvez créer un script gnuplot et de lancer un processus en cours d'exécution gnuplot pour tracer ce script à partir de la ligne de commande, ou vous pouvez utiliser l'une des interfaces fournies. Pour le C, il y a une POSIX pipe interface à base de Nicolas Devillard disponible ici:
http://ndevilla.free.fr/gnuplot/
...et un iostream à base de C++ version est disponible via git (voir: http://www.stahlke.org/dan/gnuplot-iostream/ )

Le plus portable et probablement la façon la plus simple serait encore de l'appel de gnuplot pour tracer un script, cependant. Comme sje397 mentionné, consultez votre documentation pour l'appel system() dans stdlib.h.

Sur une note, il est également GNU plotutils, qui offre libplot, une bibliothèque pour tracer les bases de données, vous pouvez utiliser dans votre application. Voir: http://www.gnu.org/software/plotutils/

Je ne suis pas fantastique à comprendre toute cette documentation trucs, mais j'ai trouvé la déclaration pour le système(): int system(const char *command); Est-il seulement en cas d'ajout de quelque chose comme ça?: système(gnuplot parcelle "data_set.dat" avec 1:2 à l'aide de lignes);
Finalement, je suis allé quelque chose comme ceci:
#include "gnuplot_i.h" int main(void) { FILE outFile; outFile = fopen("Flight_Path.dat", "w"); / boucle Itérative qui s'imprime dans un fichier de sortie: exemple.dat */ fclose(outFile); gnuplot_ctrl *k; k = gnuplot_init(); gnuplot_set_xlabel(k, "x"); gnuplot_set_ylabel(k, "y"); gnuplot_cmd(k,input_x); gnuplot_cmd(k,input_y); gnuplot_cmd(k, "titre du jeu \"Trajectoire avec un Glisser -\""); gnuplot_cmd(k, "tracer \"Flight_Path.dat\" using 1:2 titre \"de la Trajectoire de Vol\" avec des lignes, des \ sommeil(7); gnuplot_close(k); return 0; }
Je suis sûr qu'il vous manque quelques bouts de code, c'est à dire que vous êtes d'ouverture et de fermeture du fichier immédiatement après. Aussi, la mise en forme dans les commentaires suce juste. Merci d'éditer votre post original et ajoutez le code pour que je le fais moi-même, mais comme je l'ai dit, je crois que votre code est en manque de quelque chose.

OriginalL'auteur Jim Brissom
2

Bien que j'ai vu beaucoup de façons de le faire, la plus simple façon de faire, ce serait en utilisant le système() (à partir de stdlib.h) fonction en C.
D'abord faire un script gnuplot et l'enregistrer en tant que "nom.gp" (ni le nom, ni l'extension de la matière).

Un script simple serait,
```
plot 'Output.dat' with lines
```
Après l'enregistrement de ce fichier de script, il suffit d'ajouter

system("gnuplot -p 'name.gp'");

à la fin de votre code.

C'est aussi simple que cela.

OriginalL'auteur Nidish Narayanaa

J'ai adapté la accepté de répondre à tracer un float array tout en évitant l'utilisation d'un fichier temporaire. En elle, float* data_ est la matrice et size_t size_ sa taille. J'espère que c'est utile pour quelqu'un!

Acclamations,

Andres

void plot(const char* name="FloatSignal"){
  //open persistent gnuplot window
  FILE* gnuplot_pipe = popen ("gnuplot -persistent", "w");
  //basic settings
  fprintf(gnuplot_pipe, "set title '%s'\n", name);
  //fill it with data
  fprintf(gnuplot_pipe, "plot '-'\n");
  for(size_t i=0; i<size_; ++i){
    fprintf(gnuplot_pipe, "%zu %f\n", i, data_[i]);
  }
  fprintf(gnuplot_pipe, "e\n");
  //refresh can probably be omitted
  fprintf(gnuplot_pipe, "refresh\n");
}

OriginalL'auteur fr_andres

Vous devez vous connecter pour publier un commentaire.