Công cụ vẽ biểu đồ / biểu đồ dựa trên dòng lệnh Unix ASCII

Có một công cụ vẽ biểu đồ / vẽ đồ thị UNIX dòng lệnh tốt không? Tôi đang tìm kiếm thứ gì đó sẽ vẽ các điểm xy trên biểu đồ ASCII.

Để làm rõ, tôi đang tìm kiếm thứ gì đó sẽ tạo ra một biểu đồ trong ASCII (như phong cách nghệ thuật ascii), vì vậy tôi có thể sử dụng nó qua phiên shell tương tác mà không cần X.

Hãy thử gnuplot . Nó có khả năng vẽ đồ thị rất mạnh.

Nó có thể xuất ra thiết bị đầu cuối của bạn theo cách sau:

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

Mặc dù gnuplotmạnh mẽ nhưng nó cũng thực sự gây khó chịu khi bạn chỉ muốn xếp hàng loạt điểm và lấy biểu đồ.

Rất may, ai đó đã tạo ra eplot (cốt truyện dễ dàng), xử lý tất cả những điều vô nghĩa cho bạn.

Nó dường như không có tùy chọn để buộc các đồ thị đầu cuối; Tôi đã vá nó như vậy:

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

Một ví dụ về sử dụng:

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

Một tùy chọn khác tôi vừa chạy qua là bashplotlib . Đây là một ví dụ chạy trên (khoảng) dữ liệu giống như ví dụ eplot của tôi :

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

Điều chỉnh các thùng giúp độ phân giải một chút:

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

Cốt truyện trong một dòng duy nhất thực sự đơn giản và có thể giúp người ta nhìn thấy các mẫu cao và thấp.
Xem thêm pysparklines .
(Có ai biết các đường xiên unicode, có thể khớp với nhau để tạo đường, không phải thanh, lô không?)

#!/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 là một mặt trước khác của gnuplot, xử lý đường ống trong dữ liệu.

    $ 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

Xem thêm: asciichart (được triển khai trong Node.js, Python, Java, Go và Haskell)

gnuplot là câu trả lời dứt khoát cho câu hỏi của bạn.

Cá nhân tôi cũng là một fan hâm mộ lớn của API biểu đồ google , có thể được truy cập từ dòng lệnh với sự trợ giúp của wget (hoặc curl) để tải xuống tệp png (và xem bằng xview hoặc một cái gì đó tương tự). Tôi thích tùy chọn này vì tôi thấy các biểu đồ sẽ đẹp hơn một chút (nghĩa là khử răng cưa tốt hơn).

Bạn nên sử dụng gnuplot và chắc chắn ban hành lệnh "set cumb term" sau khi khởi động. Bạn cũng có thể đưa ra một hàng và số lượng cột. Đây là đầu ra từ gnuplot nếu bạn phát hành "set term cumb 64 ​​10" và sau đó "cốt truyện sin (x)":

 

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

Nó trông tốt hơn ở 79x24 (không sử dụng cột thứ 80 trên màn hình 80x24: một số cách thực hiện lời nguyền không luôn luôn hoạt động tốt xung quanh cột cuối cùng).

Tôi đang sử dụng gnuplot v4, nhưng điều này sẽ hoạt động trên các phiên bản cũ hơn hoặc mới hơn một chút.

Một thay thế đơn giản / nhẹ hơn cho gnuplot là ervy , một công cụ biểu đồ đầu cuối dựa trên NodeJS.

Các loại được hỗ trợ: phân tán (điểm XY), thanh, bánh, đạn, bánh rán và máy đo.

Các ví dụ sử dụng với các tùy chọn khác nhau có thể được tìm thấy trên các dự án GitHub repo

Kiểm tra gói plotext cho phép để vẽ dữ liệu trực tiếp trên thiết bị đầu cuối sử dụng python3. Nó rất trực quan vì việc sử dụng nó rất giống với gói matplotlib .

Đây là một ví dụ cơ bản:

Bạn có thể cài đặt nó bằng lệnh sau:

sudo -H pip install plotext

Đối với matplotlib, các chức năng chính là phân tán (đối với các điểm đơn), cốt truyện (đối với các điểm được nối bởi các dòng) và hiển thị (để thực sự in biểu đồ trên thiết bị đầu cuối). Thật dễ dàng để xác định kích thước lô, kiểu điểm và đường và bất cứ điều gì để hiển thị các trục, đánh dấu số và phương trình cuối cùng, được sử dụng để chuyển đổi tọa độ được vẽ thành giá trị thực ban đầu.

Đây là mã để sản xuất cốt truyện được hiển thị ở trên:

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)

Tùy chọn clear=Truebên trong showđược sử dụng để xóa thiết bị đầu cuối trước khi vẽ: điều này rất hữu ích, ví dụ, khi vẽ một luồng dữ liệu liên tục. Một ví dụ về vẽ sơ đồ luồng dữ liệu liên tục được hiển thị ở đây:

Các mô tả gói cung cấp thêm thông tin làm thế nào để tùy chỉnh cốt truyện. Gói đã được thử nghiệm trên Ubuntu 16, nơi nó hoạt động hoàn hảo. Các phát triển trong tương lai có thể (theo yêu cầu) có thể liên quan đến việc mở rộng cho python2 và các giao diện đồ họa khác (ví dụ: jupiter). Xin vui lòng cho tôi biết nếu bạn có bất kỳ vấn đề sử dụng nó. Cảm ơn.

Tôi hy vọng điều này trả lời vấn đề của bạn.

Ngoài ra, tia lửa là một biểu đồ thanh nhỏ đẹp trong vỏ của bạn.

Đây là bản vá của tôi cho eplot có thêm tùy chọn -T cho đầu ra thiết bị đầu cuối:

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

Sử dụng cái này bạn có thể chạy nó eplot -Tđể lấy kết quả đồ họa ASCII thay vì cửa sổ gnuplot.