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

Quiero usar gnuplot para dibujar figuras del archivo de datos, digamos foo.data . Actualmente, codifiqué el nombre del archivo de datos en el archivo de comandos, digamos foo.plt , y ejecuté el comando gnuplot foo.plgpara trazar datos. Sin embargo, quiero pasar el nombre del archivo de datos como un argumento de comando, por ejemplo, ejecutar un comando gnuplot foo.plg foo.data. ¿Cómo analizar los argumentos de la línea de comandos 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, use un condicional:

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

Tenga en cuenta que -etiene que preceder al nombre del archivo; de lo contrario, el archivo se ejecuta antes de las -edeclaraciones. En particular, ejecutar un shebang gnuplot #!/usr/bin/env gnuplotcon ./foo.plg -e ...argumentos CLI ignorará el uso de los argumentos proporcionados.

Puede pasar argumentos a un script gnuplot desde la versión 5.0, con la bandera -c. Estos argumentos se accede a través de las variables ARG0a ARG9, ARG0siendo el guión, y ARG1para ARG9las variables de cadena. El número de argumentos viene dado 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 

puede ser llamado 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 versiones anteriores, existe un callmecanismo con una sintaxis diferente (ahora obsoleta). Los argumentos se accede 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

Observe que no hay una variable para el nombre del script, por lo que $0es 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 como se sugiere aquí . El ejemplo de Ismail Amin se repite aquí:

En la cáscara:

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 punto y coma (como en los scripts bash), pero las variables de cadena NECESITAN encapsularse con '' (sintaxis gnuplot, sintaxis Bash)

Puede usar truco en entorno unix / linux:

1. en el programa gnuplot: trama "/ dev / stdin" ...

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

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 de alguien que busque en Google esto como lo hice yo. La respuesta de vagoberto me dio lo que necesitaba para resolver mi versión de este problema y compartiré mi solución aquí.

Desarrollé un guión de trama en un entorno actualizado que me permitió hacer:

#!/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 bien 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). La cuña a continuación 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 en cualquier * nix.

Incluso podrías 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, reemplazar algunas fichas mágicas en la llamada sed, mientras ya estoy en eso ...), pero simplifiqué este ejemplo para una mejor comprensión. También podría hacerlo aún más simple ... YMMV.

En el shell escribe

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

y consecutivamente los archivos que quieras. -persist se usa para hacer que la pantalla gnuplot permanezca siempre que el usuario no salga de ella manualmente.

Otra forma más es esta:

Tiene un script gnuplot llamado scriptname.gp:

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

plot FILENAME

Ahora puede llamar al script gnuplot scriptname.gppor esta complicada sintaxis de paz:

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

La respuesta de @ vagoberto parece la mejor en mi humilde opinión si necesita argumentos posicionales , y tengo una pequeña mejora para agregar.

sugerencia de vagoberto:

#!/usr/local/bin/gnuplot --persist

THIRD=ARG3
print "script name        : ", ARG0
print "first argument     : ", ARG1
print "third argument     : ", THIRD 
print "number of arguments: ", ARGC 

que recibe la llamada de:

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

para esos tipos flojos como yo, uno podría hacer que el script sea ejecutable ( chmod 755 script.gp)

luego use lo siguiente:

#!/usr/bin/env gnuplot -c

THIRD=ARG3
print "script name        : ", ARG0
print "first argument     : ", ARG1
print "third argument     : ", THIRD
print "number of arguments: ", ARGC

y ejecutarlo como:

$ ./imb.plot a b c d
script name        : ./imb.plot
first argument     : a
third argument     : c
number of arguments: 4