Hacer que el código C trace un gráfico automáticamente

He escrito un programa que escribe una lista de datos en un archivo ‘.dat’ con la intención de trazarlo por separado usando gnuplot. ¿Hay alguna manera de hacer que mi código lo trace automáticamente? Mi salida es de la forma:

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

Idealmente, cuando ejecuto el código, el gráfico también se imprimiría con una etiqueta x, una etiqueta y y un título (que podría cambiarse de mi código C). Muchas gracias.

Encontré esto mientras buscaba algo más sobre gnuplot. Aunque es una pregunta antigua, pensé en contribuir con un código de muestra. Lo uso para un programa mío, y creo que hace un trabajo bastante ordenado. AFAIK, este PIPEing solo funciona en sistemas Unix (consulte la edición a continuación para usuarios de Windows). Mi instalación de gnuplot es la instalación predeterminada del repositorio de Ubuntu.

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

EDITAR

En mi aplicación, también me encontré con el problema de que la trama no aparece hasta que se cierra el programa de llamada. Para evitar esto, agregue un fflush(gnuplotPipe) después de haber usado fprintf para enviarle su comando final.

También he visto que los usuarios de Windows pueden usar _popen en lugar de popen — sin embargo, no puedo confirmar esto porque no tengo Windows instalado.

EDITAR 2

Uno puede evitar tener que escribir en un archivo enviando gnuplot el plot '-' comando seguido de puntos de datos seguidos de la letra “e”.

p.ej

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

Puede crear un script gnuplot y generar un proceso que ejecute gnuplot para trazar este script desde la línea de comandos, o puede usar una de las interfaces provistas. Para C, hay una interfaz basada en tubería POSIX de Nicolas Devillard disponible aquí:
http://ndevilla.free.fr/gnuplot/
…y una versión de C++ basada en iostream está disponible a través de git (ver: http://www.stahlke.org/dan/gnuplot-iostream/ )

Sin embargo, la forma más portátil y probablemente la más fácil sería llamar a gnuplot para trazar un script. Como se mencionó en sje397, consulte su documentación para la llamada system() en stdlib.h.

En una nota al margen, también está GNU plotutils, que ofrece libplot, una biblioteca para trazar conjuntos de datos, que podría usar en su aplicación. Ver: http://www.gnu.org/software/plotutils/

Aunque he visto muchas maneras de hacer esto, la forma más sencilla de hacerlo sería usando la función system() (de stdlib.h) en C. Primero haga un script gnuplot y guárdelo como “name. gp” (ni el nombre ni la extensión importan).
Un guión simple sería,

plot 'Output.dat' with lines

Después de guardar este archivo de script, simplemente agregue
system("gnuplot -p name.gp");

al final de su código.
Es tan simple como eso.

Asegúrese de agregar la ruta gnuplot a las variables de ruta del sistema de Windows.

He adaptado la respuesta aceptada para trazar una matriz flotante y evitar el uso de un archivo temporal. En eso, float* data_ es la matriz y size_t size_ su tamaño. ¡Ojalá sea útil para alguien!

Salud,
Andrés

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

Sé que es demasiado tarde, pero responder si puede ayudar a alguien. fputs realmente hace el trabajo que quieres. primero debe imprimir los datos que desea trazar en un archivo temporal data.temp.

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