Alat bantu charting / ploting berbasis Unix ASCII

Apakah ada alat charting / graphing / plotting UNIX baris perintah yang baik? Saya mencari sesuatu yang akan memplot poin xy pada grafik ASCII.

Hanya untuk memperjelas, saya mencari sesuatu yang akan menampilkan grafik dalam ASCII (seperti gaya ascii-art), jadi saya bisa menggunakannya pada sesi shell interaktif tanpa perlu X.

Coba gnuplot . Ini memiliki kemungkinan grafik yang sangat kuat.

Ini dapat keluar ke terminal Anda dengan cara berikut:

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

Meskipun gnuplotkuat, itu juga sangat menjengkelkan ketika Anda hanya ingin menyalurkan banyak poin dan mendapatkan grafik.

Untungnya, seseorang membuat eplot (plot mudah), yang menangani semua omong kosong untuk Anda.

Tampaknya tidak memiliki opsi untuk memaksa grafik terminal; Saya menambalnya seperti:

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

Contoh penggunaan:

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

Opsi lain yang baru saja saya temui adalah bashplotlib . Berikut ini contoh yang dijalankan pada (kira-kira) data yang sama dengan contoh eplot saya :

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

Menyesuaikan nampan membantu resolusi sedikit:

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

Plot dalam satu baris benar-benar sederhana, dan dapat membantu seseorang melihat pola tinggi dan rendah.
Lihat juga pysparklines .
(Apakah ada yang tahu tentang garis miring unicode, yang bisa cocok untuk membuat garis, bukan bar, plot?)

#!/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 adalah ujung depan lain dari gnuplot, yang menangani pemipaan data.

    $ 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

Lihat juga: asciichart (diimplementasikan dalam Node.js, Python, Java, Go dan Haskell)

gnuplot adalah jawaban pasti untuk pertanyaan Anda.

Saya pribadi juga penggemar berat API grafik google , yang dapat diakses dari baris perintah dengan bantuan wget (atau curl) untuk mengunduh file png (dan melihat dengan xview atau yang serupa). Saya suka opsi ini karena saya menemukan grafik menjadi sedikit lebih cantik (yaitu antialiasing yang lebih baik).

Anda harus menggunakan gnuplot dan pastikan untuk mengeluarkan perintah "set term dumb" setelah memulai. Anda juga dapat memberikan jumlah baris dan kolom. Ini adalah output dari gnuplot jika Anda mengeluarkan "set term dumb 64 ​​10" dan kemudian "plot sin (x)":

 

    1 ++ ----------- **** ----------- + - *** ------- + ------ * *** - ++
  0,6 * + ** + * + ** * sin (x) ******* ++
  0,2 + * * * ** ** * ** ++
    0 ++ * ** * ** * ** * ++
 -0,4 ++ ** * ** ** * * * +
 -0,8 ++ ** * + * ** + * + ** + *
   -1 ++ - **** ------ + ------- *** --- + ---------- **** ----- ------ ++
     -10 -5 0 5 10

Itu terlihat lebih baik di 79x24 (jangan gunakan kolom ke-80 pada tampilan 80x24: beberapa implementasi kutukan tidak selalu berperilaku baik di sekitar kolom terakhir).

Saya menggunakan gnuplot v4, tetapi ini seharusnya bekerja pada versi yang sedikit lebih lama atau lebih baru.

Alternatif lain yang lebih sederhana / lebih ringan untuk gnuplot adalah ervy , alat bagan terminal berbasis NodeJS.

Jenis yang didukung: scatter (poin XY), bar, pai, peluru, donat, dan pengukur.

Contoh penggunaan dengan berbagai opsi dapat ditemukan pada proyek repo GitHub

Periksa plotext paket yang memungkinkan untuk memplot data secara langsung di terminal menggunakan python3. Ini sangat intuitif karena penggunaannya sangat mirip dengan paket matplotlib .

Ini adalah contoh dasarnya:

Anda dapat menginstalnya dengan perintah berikut:

sudo -H pip install plotext

Sedangkan untuk matplotlib, fungsi utamanya adalah sebar (untuk titik tunggal), plot (untuk titik yang digabungkan dengan garis) dan menunjukkan (untuk benar-benar mencetak plot di terminal). Sangat mudah untuk menentukan dimensi plot, gaya titik dan garis, dan apa pun untuk menunjukkan sumbu, kutu bilangan, dan persamaan akhir, yang digunakan untuk mengonversi koordinat yang diplot ke nilai riil aslinya.

Berikut adalah kode untuk menghasilkan plot yang ditunjukkan di atas:

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)

Opsi clear=Truedi dalam showdigunakan untuk menghapus terminal sebelum memplot: ini berguna, misalnya, ketika memplot aliran data yang kontinu. Contoh merencanakan aliran data berkelanjutan ditunjukkan di sini:

The deskripsi paket menyediakan informasi lebih lanjut bagaimana untuk menyesuaikan plot. Paket ini telah diuji pada Ubuntu 16 di mana ia bekerja dengan sempurna. Kemungkinan pengembangan di masa depan (berdasarkan permintaan) dapat melibatkan ekstensi ke python2 dan ke antarmuka grafis lainnya (misalnya jupiter). Tolong beri tahu saya jika Anda memiliki masalah dalam menggunakannya. Terima kasih.

Saya harap ini menjawab masalah Anda.

Juga, percikan adalah grafik batang kecil yang bagus di shell Anda.

Ini patch saya untuk eplot yang menambahkan opsi -T untuk output 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

Dengan ini, Anda dapat menjalankannya eplot -Tuntuk mendapatkan hasil grafis ASCII alih-alih jendela gnuplot.