C-Code automatisch einen Graphen zeichnen lassen

Ich habe ein Programm geschrieben, das eine Liste von Daten in eine ‘.dat’-Datei schreibt, mit der Absicht, sie dann separat mit gnuplot zu plotten. Gibt es eine Möglichkeit, meinen Code automatisch zu plotten? Meine Ausgabe hat die Form:

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

Wenn ich den Code ausführe, würde das Diagramm im Idealfall auch mit einem x-Etikett, einem y-Etikett und einem Titel gedruckt werden (der von meinem C-Code geändert werden könnte). Danke vielmals.

Ich bin darauf gestoßen, als ich nach etwas anderem in Bezug auf Gnuplot gesucht habe. Obwohl es sich um eine alte Frage handelt, dachte ich, ich würde einen Beispielcode beitragen. Ich benutze das für ein Programm von mir, und ich denke, es macht einen ziemlich ordentlichen Job. AFAIK, dieses PIPEing funktioniert nur auf Unix-Systemen (siehe die Bearbeitung unten für Windows-Benutzer). Meine Gnuplot-Installation ist die Standardinstallation aus dem Ubuntu-Repository.

#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;
}

BEARBEITEN

In meiner Anwendung bin ich auch auf das Problem gestoßen, dass der Plot erst erscheint, wenn das aufrufende Programm geschlossen wird. Um dies zu umgehen, fügen Sie a hinzu fflush(gnuplotPipe) nachdem Sie verwendet haben fprintf um ihm deinen letzten Befehl zu senden.

Ich habe auch gesehen, dass Windows-Benutzer verwenden können _popen anstelle von popen — kann ich aber nicht bestätigen, da ich kein Windows installiert habe.

BEARBEITEN 2

Man kann vermeiden, in eine Datei schreiben zu müssen, indem man gnuplot die sendet plot '-' Befehl gefolgt von Datenpunkten gefolgt vom Buchstaben “e”.

z.B

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");

Sie können entweder ein gnuplot-Skript erstellen und einen Prozess starten, der gnuplot ausführt, um dieses Skript von der Befehlszeile aus zu plotten, oder Sie können eine der bereitgestellten Schnittstellen verwenden. Für C gibt es hier eine POSIX-Pipe-basierte Schnittstelle von Nicolas Devillard:
http://ndevilla.free.fr/gnuplot/
…und eine iostream-basierte C++-Version ist über git verfügbar (siehe: http://www.stahlke.org/dan/gnuplot-iostream/ )

Der portabelste und wahrscheinlich einfachste Weg wäre jedoch immer noch der Aufruf von gnuplot, um ein Skript zu plotten. Wie in sje397 erwähnt, überprüfen Sie Ihre Dokumentation auf den system()-Aufruf in stdlib.h.

Nebenbei bemerkt gibt es auch GNU plotutils, das libplot anbietet, eine Bibliothek zum Plotten von Datensätzen, die Sie in Ihrer Anwendung verwenden können. Sehen: http://www.gnu.org/software/plotutils/

Obwohl ich viele Möglichkeiten gesehen habe, dies zu tun, wäre die einfachste Möglichkeit, die Funktion system() (aus stdlib.h) in C zu verwenden. Erstellen Sie zuerst ein gnuplot-Skript und speichern Sie es als “name. gp” (weder der Name noch die Erweiterung sind wichtig).
Ein einfaches Skript wäre,

plot 'Output.dat' with lines

Fügen Sie nach dem Speichern dieser Skriptdatei einfach hinzu
system("gnuplot -p name.gp");

am Ende Ihres Codes.
So einfach ist das.

Stellen Sie sicher, dass Sie den gnuplot-Pfad zu den Windows-Systempfadvariablen hinzufügen.

Ich habe die akzeptierte Antwort angepasst, um ein Float-Array zu zeichnen und gleichzeitig die Verwendung einer temporären Datei zu vermeiden. Drin, float* data_ ist das Array und size_t size_ seine Größe. Hoffentlich ist es für jemanden hilfreich!

Prost,
Andreas

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");
}

Ich weiß, es ist zu spät, aber ich antworte, ob es jemandem helfen kann. fputs macht wirklich den Job, den Sie wollen. Zuerst müssen Sie die Daten, die Sie plotten möchten, in eine temporäre Datei data.temp drucken.

FILE *pipe_gp = popen("gnuplot -p", "w");
fputs("set terminal png \n",pipe_gp);
fputs("set output 'abc.png' \n",pipe_gp);
fputs("set xlabel 'f' \n",pipe_gp);
fputs("set xrange [0:100] \n",pipe_gp);
fputs("set yrange [0:100] \n",pipe_gp);
fputs("plot 'data.temp' u 1:2 w circles lc rgb 'pink' notitle \n",pipe_gp);
pclose(pipe_gp);