Herramienta de trazado / trazado basada en ASCII de Unix de línea de comandos

¿Existe una buena herramienta de trazado / gráfico / trazado de UNIX en la línea de comandos? Estoy buscando algo que trazará puntos xy en un gráfico ASCII.

Solo para aclarar, estoy buscando algo que genere un gráfico en ASCII (como el estilo ascii-art), para poder usarlo en una sesión de shell interactiva sin necesidad de X.

Prueba gnuplot . Tiene posibilidades gráficas muy poderosas.

Puede salir a su terminal de la siguiente manera:

gnuplot> set terminal dumb
Terminal type set to 'dumb'
Options are 'feed 79 24'
gnuplot> plot sin(x)

   1 ++----------------**---------------+----**-----------+--------**-----++
     +                *+ *              +   *  *          +  sin(x) ****** +
 0.8 ++              *    *                *    *                *    *   ++
     |               *    *                *    *                *    *    |
 0.6 ++              *     *              *      *              *      *  ++
     *              *       *             *       *             *      *   |
 0.4 +*             *       *             *       *             *      *  ++
     |*            *        *            *        *            *        *  |
 0.2 +*            *        *            *        *            *        * ++
     | *          *          *          *          *          *          * |
   0 ++*          *          *          *          *          *          *++
     |  *         *           *         *           *         *           *|
-0.2 ++ *         *           *         *           *         *           *+
     |   *       *            *        *            *        *            *|
-0.4 ++  *       *            *        *            *        *            *+
     |   *      *              *      *              *      *              *
-0.6 ++  *      *              *      *              *      *             ++
     |    *     *               *     *               *    *               |
-0.8 ++    *   *                 *   *                *    *              ++
     +     *  *        +         *  *   +              *  *                +
  -1 ++-----**---------+----------**----+---------------**+---------------++
    -10               -5                0                 5                10

Si bien gnuplotes poderoso, también es realmente irritante cuando solo quieres canalizar un montón de puntos y obtener un gráfico.

Afortunadamente, alguien creó eplot (trama fácil), que maneja todas las tonterías por ti.

No parece tener una opción para forzar gráficos terminales; Lo parcheé así:

--- eplot.orig  2012-10-12 17:07:35.000000000 -0700
+++ eplot       2012-10-12 17:09:06.000000000 -0700
@@ -377,6 +377,7 @@
                # ---- print the options
                com="echo '\n"+getStyleString+@oc["MiscOptions"]
                com=com+"set multiplot;\n" if doMultiPlot
+               com=com+"set terminal dumb;\n"
                com=com+"plot "+@oc["Range"]+comString+"\n'| gnuplot -persist"
                printAndRun(com)
                # ---- convert to PDF

Un ejemplo de uso:

[$]> git shortlog -s -n | awk '{print $1}' | eplot 2> /dev/null


  3500 ++-------+-------+--------+--------+-------+--------+-------+-------++
       +        +       +        "/tmp/eplot20121012-19078-fw3txm-0" ****** +       *                                                                    |  3000 +*                                                                  ++       |*                                                                   |       | *                                                                  |  2500 ++*                                                                 ++       | *                                                                  |
       |  *                                                                 |
  2000 ++ *                                                                ++
       |  **                                                                |
  1500 ++   ****                                                           ++
       |        *                                                           |
       |         **                                                         |
  1000 ++          *                                                       ++
       |            *                                                       |
       |            *                                                       |
   500 ++            ***                                                   ++
       |                **************                                      |
       +        +       +        +    **********  +        +       +        +
     0 ++-------+-------+--------+--------+-----***************************++
       0        5       10       15       20      25       30      35       40

Otra opción que acabo de encontrar es bashplotlib . Aquí hay un ejemplo que se ejecuta en (aproximadamente) los mismos datos que mi ejemplo de eplot :

[$]> git shortlog -s -n | awk '{print $1}' | hist

 33|   o
 32|   o
 30|   o
 28|   o
 27|   o
 25|   o
 23|   o
 22|   o
 20|   o
 18|   o
 16|   o
 15|   o
 13|   o
 11|   o
 10|   o
  8|   o
  6|   o
  5|   o
  3|   o o     o
  1|   o o     o o       o
  0|   o o o o o o       o
    ----------------------

-----------------------
|       Summary       |
-----------------------
|   observations: 50  |
| min value: 1.000000 |
|  mean : 519.140000  |
|max value: 3207.000000|
-----------------------

Ajustar los contenedores ayuda un poco a la resolución:

[$]> git shortlog -s -n | awk '{print $1}' | hist --nosummary --bins=40

 18|   o
   |   o
 17|   o
 16|   o
 15|   o
 14|   o
 13|   o
 12|   o
 11|   o
 10|   o
  9|   o
  8|   o
  7|   o
  6|   o
  5|   o   o
  4|   o   o o
  3|   o o o o   o
  2|   o o o o   o
  1|   o o o o   o                     o       o
  0|   o o o o o o           o     o   o o   o o                                 o
   |   o o o o o o           o     o   o o   o o                                 o
    --------------------------------------------------------------------------------

Las gráficas en una sola línea son realmente simples y pueden ayudar a ver patrones de altibajos.
Ver también pysparklines .
(¿Alguien sabe de líneas inclinadas unicode, que podrían encajar juntas para hacer líneas, no barras, tramas?)

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from __future__ import division
import numpy as np

__version__ = "2015-01-02 jan  denis"


#...............................................................................
def onelineplot( x, chars=u"▁▂▃▄▅▆▇█", sep=" " ):
    """ numbers -> v simple one-line plots like

f ▆ ▁ ▁ ▁ █ ▁ ▁ ▁ ▁ ▁ ▁ ▁ ▁ ▁ ▁ ▁ ▁ ▁ ▁ ▁  osc 47  ▄ ▁ █ ▇ ▄ ▆ ▅ ▇ ▇ ▇ ▇ ▇ ▄ ▃ ▃ ▁ ▃ ▂  rosenbrock
f █ ▅ █ ▅ █ ▅ █ ▅ █ ▅ █ ▅ █ ▅ █ ▅ ▁ ▁ ▁ ▁  osc 58  ▂ ▁ ▃ ▂ ▄ ▃ ▅ ▄ ▆ ▅ ▇ ▆ █ ▇ ▇ ▃ ▃ ▇  rastrigin
f █ █ █ █ ▁ ▁ ▁ ▁ ▁ ▁ ▁ ▁ ▁ ▁ ▁ ▁ ▁ ▁ ▁ ▁  osc 90  █ ▇ ▇ ▁ █ ▇ █ ▇ █ ▇ █ ▇ █ ▇ █ ▇ █ ▇  ackley

Usage:
    astring = onelineplot( numbers [optional chars= sep= ])
In:
    x: a list / tuple / numpy 1d array of numbers
    chars: plot characters, default the 8 Unicode bars above
    sep: "" or " " between plot chars

How it works:
    linscale x  ->  ints 0 1 2 3 ...  ->  chars ▁ ▂ ▃ ▄ ...

See also: https://github.com/RedKrieg/pysparklines
    """

    xlin = _linscale( x, to=[-.49, len(chars) - 1 + .49 ])
        # or quartiles 0 - 25 - 50 - 75 - 100
    xints = xlin.round().astype(int)
    assert xints.ndim == 1, xints.shape  # todo: 2d
    return sep.join([ chars[j] for j in xints ])


def _linscale( x, from_=None, to=[0,1] ):
    """ scale x from_ -> to, default min, max -> 0, 1 """
    x = np.asanyarray(x)
    m, M = from_ if from_ is not None \
        else [np.nanmin(x), np.nanmax(x)]
    if m == M:
        return np.ones_like(x) * np.mean( to )
    return (x - m) * (to[1] - to[0]) \
        / (M - m)  + to[0]


#...............................................................................
if __name__ == "__main__":  # standalone test --
    import sys

    if len(sys.argv) > 1:  # numbers on the command line, may be $(cat myfile)
        x = map( float, sys.argv[1:] )
    else:
        np.random.seed( 0 )
        x = np.random.exponential( size=20 )

    print onelineplot( x )

feedgnuplot es otro front-end para gnuplot, que maneja las tuberías en los datos.

    $ seq 5 | awk '{print 2*$1, $1*$1}' |
      feedgnuplot --lines --points --legend 0 "data 0" --title "Test plot" --y2 1
                  --terminal 'dumb 80,40' --exit

                                     Test plot

     10 ++------+--------+-------+-------+-------+--------+-------+------*A 25
        +       +        +       +       +       +        +       +    **#+
        |       :        :       :       :       :        : data 0+**A*** |
        |       :        :       :       :       :        :       :** #   |
      9 ++.......................................................**.##....|
        |       :        :       :       :       :        :    ** :#      |
        |       :        :       :       :       :        :  **   #       |
        |       :        :       :       :       :        :**   ##:      ++ 20
      8 ++................................................A....#..........|
        |       :        :       :       :       :      **:   #   :       |
        |       :        :       :       :       :    **  : ##    :       |
        |       :        :       :       :       :  **    :#      :       |
        |       :        :       :       :       :**      B       :       |
      7 ++......................................**......##................|
        |       :        :       :       :    ** :    ##  :       :      ++ 15
        |       :        :       :       :  **   :   #    :       :       |
        |       :        :       :       :**     : ##     :       :       |
      6 ++..............................*A.......##.......................|
        |       :        :       :    ** :     ##:        :       :       |
        |       :        :       :  **   :    #  :        :       :       |
        |       :        :       :**     :  ##   :        :       :      ++ 10
      5 ++......................**........##..............................|
        |       :        :    ** :      #B       :        :       :       |
        |       :        :  **   :    ## :       :        :       :       |
        |       :        :**     :  ##   :       :        :       :       |
      4 ++...............A.......###......................................|
        |       :      **:     ##:       :       :        :       :       |
        |       :    **  :   ##  :       :       :        :       :      ++ 5
        |       :  **    : ##    :       :       :        :       :       |
        |       :**    ##B#      :       :       :        :       :       |
      3 ++.....**..####...................................................|
        |    **####      :       :       :       :        :       :       |
        |  **## :        :       :       :       :        :       :       |
        B**     +        +       +       +       +        +       +       +
      2 A+------+--------+-------+-------+-------+--------+-------+------++ 0
        1      1.5       2      2.5      3      3.5       4      4.5      5

Ver también: asciichart (implementado en Node.js, Python, Java, Go y Haskell)

gnuplot es la respuesta definitiva a su pregunta.

Personalmente, también soy un gran admirador de la API de gráficos de Google , a la que se puede acceder desde la línea de comandos con la ayuda de wget (o curl) para descargar un archivo png (y ver con xview o algo similar). Me gusta esta opción porque encuentro que los gráficos son un poco más bonitos (es decir, mejor antialiasing).

Debe usar gnuplot y asegúrese de emitir el comando "set term dumb" después de iniciar. También puede dar un recuento de filas y columnas. Aquí está la salida de gnuplot si emite "set term dumb 64 ​​10" y luego "plot sin (x)":

 

    1 ++ ----------- **** ----------- + - *** ------- + ------ * *** - ++
  0.6 * + ** + * + ** * sin (x) ******* ++
  0.2 + * * * ** ** * ** ++
    0 ++ * ** * ** * ** * ++
 -0.4 ++ ** * ** ** * * * +
 -0.8 ++ ** * + * ** + * + ** + *
   -1 ++ - **** ------ + ------- *** --- + ---------- **** ----- ------ ++
     -10-5 0 5 10

Se ve mejor a 79x24 (no use la columna 80 en una pantalla de 80x24: algunas implementaciones de maldiciones no siempre se comportan bien alrededor de la última columna).

Estoy usando gnuplot v4, pero esto debería funcionar en versiones ligeramente más antiguas o más nuevas.

Otra alternativa más simple / más ligera a gnuplot es ervy , una herramienta de gráficos de terminales basada en NodeJS.

Tipos admitidos: dispersión (puntos XY), barra, pastel, bala, rosquilla y calibre.

Se pueden encontrar ejemplos de uso con varias opciones en los proyectos de repositorio de GitHub

Verifique el paquete de texto que permite graficar datos directamente en la terminal usando python3. Es muy intuitivo ya que su uso es muy similar al paquete matplotlib .

Aquí hay un ejemplo básico:

Puede instalarlo con el siguiente comando:

sudo -H pip install plotext

En cuanto a matplotlib, las funciones principales son dispersión (para puntos individuales), trazado (para puntos unidos por líneas) y espectáculo (para imprimir realmente el trazado en el terminal). Es fácil especificar las dimensiones de la trama, los estilos de punto y línea y lo que sea para mostrar los ejes, las marcas numéricas y las ecuaciones finales, que se utilizan para convertir las coordenadas trazadas a los valores reales originales.

Aquí está el código para producir la trama que se muestra arriba:

import plotext.plot as plx
import numpy as np

l=3000
x=np.arange(0, l)
y=np.sin(4*np.pi/l*np.array(x))*np.exp(-0.5*np.pi/l*x)

plx.scatter(x, y, rows = 17, cols = 70)
plx.show(clear = 0)

La opción clear=Truedentro showse usa para borrar el terminal antes de trazar: esto es útil, por ejemplo, al trazar un flujo continuo de datos. Aquí se muestra un ejemplo de trazado de un flujo continuo de datos:

La descripción del paquete proporciona más información sobre cómo personalizar la trama. El paquete ha sido probado en Ubuntu 16 donde funciona perfectamente. Los posibles desarrollos futuros (previa solicitud) podrían incluir la extensión a python2 y a otras interfaces gráficas (por ejemplo, júpiter). Avíseme si tiene algún problema para usarlo. Gracias.

Espero que esto responda a tu problema.

Además, la chispa es un pequeño gráfico de barras agradable en su caparazón.

Aquí está mi parche para eplot que agrega una opción -T para salida de terminal:

--- eplot       2008-07-09 16:50:04.000000000 -0400
+++ eplot+      2017-02-02 13:20:23.551353793 -0500
@@ -172,7 +172,10 @@
                                        com=com+"set terminal postscript color;\n"
                                        @o["DoPDF"]=true

-                               # ---- Specify a custom output file
+                               when /^-T$|^--terminal$/
+                                       com=com+"set terminal dumb;\n"
+
+                                # ---- Specify a custom output file
                                when /^-o$|^--output$/
                                        @o["OutputFileSpecified"]=checkOptArg(xargv,i)
                                        i=i+1

                                    i=i+1

Con esto, puede ejecutarlo eplot -Tpara obtener un resultado de gráficos ASCII en lugar de una ventana gnuplot.