¿Cómo pasar el argumento de línea de comando a gnuplot?

Quiero usar gnuplot para dibujar la figura del archivo de datos, digamos foo.data . Actualmente, he codificado el nombre del archivo de datos en el archivo de comandos, digamos foo.plt , y ejecuto el comando gnuplot foo.plg para trazar los datos. Sin embargo, quiero pasar el nombre del archivo de datos como un argumento de comando, por ejemplo, ejecutando el comando gnuplot foo.plg foo.data . ¿Cómo analizar los argumentos de la línea de comando en el archivo de script gnuplot? Gracias.

Puede ingresar variables a través del interruptor -e

 $ gnuplot -e "filename='foo.data'" foo.plg 

En foo.plg puedes usar esa variable

 $ cat foo.plg plot filename pause -1 

Para hacer que “foo.plg” sea un poco más genérico, usa un condicional:

 if (!exists("filename")) filename='default.dat' plot filename pause -1 

Puede pasar argumentos a un script gnuplot desde la versión 5.0, con el indicador -c . Se accede a estos argumentos a través de las variables ARG0 a ARG9 , ARG0 es la secuencia de comandos y las variables de cadena ARG1 a ARG9 . La cantidad de argumentos viene dada por ARGC .

Por ejemplo, el siguiente script (“script.gp”)

 #!/usr/local/bin/gnuplot --persist THIRD=ARG3 print "script name : ", ARG0 print "first argument : ", ARG1 print "third argument : ", THIRD print "number of arguments: ", ARGC 

se puede llamar como:

 $ gnuplot -c script.gp one two three four five script name : script.gp first argument : one third argument : three number of arguments: 5 

o dentro de gnuplot como

 gnuplot> call 'script.gp' one two three four five script name : script.gp first argument : one third argument : three number of arguments: 5 

En gnuplot 4.6.6 y anteriores, existe un mecanismo de call con una syntax diferente (ahora en desuso). Se accede a los argumentos a través de $# , $0 , …, $9 . Por ejemplo, el mismo script anterior se ve así:

 #!/usr/bin/gnuplot --persist THIRD="$2" print "first argument : ", "$0" print "second argument : ", "$1" print "third argument : ", THIRD print "number of arguments: ", "$#" 

y se llama dentro de gnuplot como (recuerde, versión <4.6.6)

 gnuplot> call 'script4.gp' one two three four five first argument : one second argument : two third argument : three number of arguments: 5 

Tenga en cuenta que no hay ninguna variable para el nombre del script, por lo que $0 es el primer argumento, y las variables se llaman entre comillas. No hay forma de usar esto directamente desde la línea de comandos, solo a través de trucos como el sugerido por @con-fu-se.

También puede pasar información a través del entorno tal como se sugiere aquí . El ejemplo de Ismail Amin se repite aquí:

En el caparazón:

 export name=plot_data_file 

En un script de Gnuplot:

 #! /usr/bin/gnuplot name=system("echo $name") set title name plot name using ($16 * 8):20 with linespoints notitle pause -1 

La respuesta de Jari Laamanen es la mejor solución. Solo quiero explicar cómo usar más de 1 parámetro de entrada con variables de shell:

 output=test1.png data=foo.data gnuplot -e "datafile='${data}'; outputname='${output}'" foo.plg 

y foo.plg:

 set terminal png set outputname f(x) = sin(x) plot datafile 

Como puede ver, se pasan más parámetros con puntos y coma (como en los scripts bash), pero las variables de cadena NECESITAN encapsularse con ” (syntax gnuplot, syntax NOT Bash)

Puede usar truco en el entorno de Unix / Linux:

  1. en el progtwig gnuplot: plot “/ dev / stdin” …

  2. En la línea de comando: gnuplot program.plot

Esta pregunta está bien respondida, pero creo que puedo encontrar un nicho para llenar aquí independientemente, aunque solo sea para reducir la carga de trabajo en alguien buscando en Google como lo hice. La respuesta de vagoberto me dio lo que necesitaba para resolver mi versión de este problema y entonces compartiré mi solución aquí.

Desarrollé un guión argumental en un entorno actualizado que me permitió:

 #!/usr/bin/gnuplot -c set terminal png truecolor transparent crop set output ARG1 set size 1, 0.2 rrLower = ARG2 rrUpper = ARG3 rrSD = ARG4 resultx = ARG5+0 # Type coercion required for data series resulty = 0.02 # fixed # etc. 

Esto se ejecuta perfectamente desde la línea de comandos en un entorno con un gnuplot reciente (5.0.3 en mi caso).

 $ ./plotStuff.gp 'output.png' 2.3 6.7 4.3 7 

Cuando se cargó en mi servidor y se ejecutó, falló porque la versión del servidor era 4.6.4 (actual en Ubuntu 14.04 LTS). El shim abajo resolvió este problema sin requerir ningún cambio en el script original.

 #!/bin/bash # GPlot v<4.6.6 doesn't support direct command line arguments. #This script backfills the functionality transparently. SCRIPT="plotStuff.gp" ARG1=$1 ARG2=$2 ARG3=$3 ARG4=$4 ARG5=$5 ARG6=$6 gnuplot -e "ARG1='${ARG1}'; ARG2='${ARG2}'; ARG3='${ARG3}'; ARG4='${ARG4}'; ARG5='${ARG5}'; ARG6='${ARG6}'" $SCRIPT 

La combinación de estos dos scripts permite que los parámetros pasen de scripts bash a gnuplot sin tener en cuenta la versión de gnuplot y básicamente cualquier * nix.

Incluso podría hacer algo de magia de concha, por ejemplo, así:

 #!/bin/bash inputfile="${1}" #you could even do some getopt magic here... ################################################################################ ## generate a gnuplotscript, strip off bash header gnuplotscript=$(mktemp /tmp/gnuplot_cmd_$(basename "${0}").XXXXXX.gnuplot) firstline=$(grep -m 1 -n "^#!/usr/bin/gnuplot" "${0}") firstline=${firstline%%:*} #remove everything after the colon sed -e "1,${firstline}d" < "${0}" > "${gnuplotscript}" ################################################################################ ## run gnuplot /usr/bin/gnuplot -e "inputfile=\"${inputfile}\"" "${gnuplotscript}" status=$? if [[ ${status} -ne 0 ]] ; then echo "ERROR: gnuplot returned with exit status $?" fi ################################################################################ ## cleanup and exit rm -f "${gnuplotscript}" exit ${status} #!/usr/bin/gnuplot plot inputfile using 1:4 with linespoints #... or whatever you want 

Mi implementación es un poco más compleja (por ejemplo, reemplazando algunos tokens mágicos en la llamada sed, mientras que yo ya estoy en ello …), pero simplifiqué este ejemplo para una mejor comprensión. También podrías hacerlo aún más simple … YMMV.

En el shell escribe

 gnuplot -persist -e "plot filename1.dat,filename2.dat" 

y consecutivamente los archivos que desea. -persist se usa para hacer que la pantalla gnuplot permanezca mientras el usuario no la salga manualmente.

Otra forma más es esto:

Usted tiene un script de gnuplot llamado scriptname.gp :

 #!/usr/bin/gnuplot -p # This code is in the file 'scriptname.gp' EPATH = $0 FILENAME = $1 plot FILENAME 

Ahora puede invocar el script script scriptname.gp por esta complicada paz de syntax:

 echo "call \"scriptname.gp\" \"'.'\" \"'data.dat'\"" | gnuplot