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

legend gnuplot

Question

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.

Answer 1

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.

Answer 2

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.

Answer 3

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.

Answer 4

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 '''' (sintaxis gnuplot, sintaxis NOT Bash)

Answer 5

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 sintaxis:

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

Answer 6

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

Answer 7

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 sintaxis 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.

Answer 8

Puede usar truco en el entorno de Unix / Linux:

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

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

Answer 9

También puede pasar información a través del entorno tal como se sugiere here . 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