Línea de comandos Herramienta de gráficos/trazado ASCII basada en ASCII

Question

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

Solo para aclarar, estoy buscando algo que va a la salida de un gráfico en ASCII (como el estilo ASCII-art), por lo que se puede utilizar más de una sesión de shell interactivo sin necesidad de X.

Answer 1

Trate gnuplot. Tiene posibilidades gráficas muy poderosas.

Se puede dar salida 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 

Answer 2

Una solución muy pesado y dominado sería instalar y utilizar cernlibpaw.

Answer 3

gnuplot es la respuesta definitiva a su pregunta.

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

Answer 4

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

 

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

que se ve mejor en 79x24 (no utilice la columna número 80 en una Pantalla de 80x24: algunas implementaciones de curses no siempre se comportan bien alrededor de la última columna).

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

Answer 5

Mientras que gnuplot es potente, también es realmente irritante cuando solo quiere conectar un montón de puntos y obtener un gráfico.

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

No parece tener una opción para forzar gráficos de terminal; Remendé que de este modo:

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

Answer 6

Otra opción que acabo de correr a través de es bashplotlib. He aquí un ejemplo ejecutar en (más o menos) los mismos datos que my eplot example:

[$]> 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| 
----------------------- 

Ajuste de los contenedores de ayuda a la resolución de un poco:

[$]> 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 
    -------------------------------------------------------------------------------- 

Answer 7

Parcelas en una sola línea son muy simples, y pueden ayudar a uno ver patrones de altas y bajas.
Véase también pysparklines.
(¿alguien sabe de líneas inclinadas Unicode, lo que podría ser encajan entre sí para hacer línea, no bar, parcelas?)

#!/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) 

Answer 8

feedgnuplot es otra interfaz de gnuplot, que se ocupa de 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 

Answer 9

Aquí es mi parche para ePlot que añade una opción -T de salida del 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 

El uso de este se puede ejecutar como eplot -T para obtener ASCII gráficos resultan en lugar de una ventana de gnuplot.