First of all let me thank you for this tool. I've been using it to graph a lot of things lately, and it rocks!

Something that I've noticed in many of my graphs is that the X axis values quickly become unreadable. An example of a graph I'm seeing now:

0.00000   178.77778 357.55556 536.33333 715.11111 893.88889 1072.666671251.444441430.222221609.00000

I was wondering if it would be possible to tell plotille to just print the integer values for the X axis (without the decimal part) and set a min spacing (2 spaces maybe?) between the values.

Versions: plotille 3.6 Python 3.6.4 :: Anaconda custom (64-bit) Windows 10 Version 1809

Environment: Jupyter Lab Version 0.35.3

When plotting many points axes separators tend to become misaligned. Below is an example running a provided example script. This looks like a fantastic tool, would appreciate any help. Thank you.

Background, Context

A lot of Python libraries such as OpenTelemetry Metrics API (https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/metrics/sdk.md) support histograms.

The problem is that those libraries expose pre-aggregated data (counts for each bucket) and not raw data. This is done intentionally since storing raw data could be very expensive in terms of memory usage in case there are a lot of samples.

Here is an example of data available by OpenTelemetry metrics Histogram view:

 {
  'attributes': {},
   'bucket_counts': [1945, 0, 0, 0, 0, 0, 10555, 798, 0, 28351, 0],
   'count': 41649,
   'explicit_bounds': [10, 50, 100, 200, 300, 500, 800, 1000, 2000, 10000],
 }

As you can see, we get we get counts for each bucket. Buckets go from (n[i], n[i+1]) whereas first item is -infinity and the last item is +infinity. In this example, buckets would look something like this: [(-inf, 10), (11, 20), (21, 50), ..., (10000, +inf)].

Proposed Change / Implementation

In this change I added a new function for graphing data which is already split into counts and bins.

This pull request is not final (I just copied the existing code + made small change to show how it should work), I just wanted to get the discussion going (with some code and examples) so we can agree on the API which should be exposed.

With the sample data above, this new function and bins which look like this:

counts = bucket_counts
bins = [float("+inf")]
bins.extend(explicit_bounds)
bins.append(float("+inf"))

We get the following histogram:

        bucket       | ________________________________________________________________________________ Total Counts
[inf     ,       10) | ⣿⣿⣿⣿⣿⣿⣿⣿⣿⠆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 3269
[10      ,       50) | ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 0
[50      ,      100) | ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 0
[100     ,      200) | ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 0
[200     ,      300) | ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 0
[300     ,      500) | ⣿⣿⣿⣿⣿⠆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 1890
[500     ,      800) | ⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 9706
[800     ,     1000) | ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 0
[1000    ,     2000) | ⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡗⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 8709
[2000    ,    10000) | ⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀ 28213
[10000   ,      inf) | ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ 0
‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾

Feedback is welcome, especially on naming and things like that.

TODO

• [ ] Agree on the API / implementation
• [ ] Finish implementing changes
• [ ] Tests
• [ ] Documentation
• [ ] Examples

For time series plotting, python's built in datetime.datetime class is much appreciated! However, sometimes datetime.date is more convenient. Could these be accepted as input as well?

I have the Issue, that the y-values spread unevenly, so that I have no clue what the actual values are. Here is the output

 (Usage)   ^
      1042 |
       975 | ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
       908 | ⠀⡖⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠒⠁⠀⠀⠀⠀
       840 | ⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
       773 | ⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
       706 | ⢀⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
       639 | ⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
       571 | ⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
       504 | ⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
       437 | ⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
       370 | ⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
       302 | ⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
       235 | ⡜⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
       168 | ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
       101 | ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
        34 | ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-----------|-|---------|---------|---------|---------|---------|-> (Time)
           | 20:37:58  21:41:04  22:44:11  23:47:17  00:50:24  01:53:30 

In my case I have values in Megabytes and I want to spread them over datetime objects, which works perfectly fine, but as you see, it looks like the usage in MB stagnates at 908, which is not true, because it stagnates at 945 MB.

It would be nice to have an option which makes the y-ticks around those values in a certain range. My attempt would be to check which values appear more often and then to adjust a y-value at that point which should be something like the average of all points 5-10% of the total range .

for example [0, 10, 20, 20, 21, 25, 30, 32, 40, 44, 50]

the range is 50-0 = 50 10% of 50 is 5

for 0 and 10 nothing needs to be changed (20+20+21+25)/4 = 21.5 , now remove those four values (30+32)/2 = 31, same here (40+44)/2 = 42, same here 50 stays like it is

the y-values should look like [0, 10, 21.5 , 21, 42, 50]

I think an option for this would smoothen a lot of plots

Sir, I am searching for a library to draw graph in terminal and I found this library and used this, but the output is not getting as required. Please help out.

The code I used (which is given in readme of your library)

import  plotille
import numpy as np 
X = np.sort(np.random.normal(size=1000))
fig = plotille.Figure() 
fig.width = 60 
fig.height = 30 
fig.set_x_limits(min_=-3, max_=3)
fig.set_y_limits(min_=-1, max_=1) 
fig.color_mode = 'byte' 
fig.plot([-0.5, 1], [-1, 1], lc=25, label='First line')
fig.scatter(X, np.sin(X), lc=100, label='sin')  
fig.plot(X, (X+2)**2 , lc=200, label='square')
print(fig.show(legend=True))

The output what I got

The actual output (shown in read me)

Why I am getting the extra braille dots? Please help me. Waiting for your replay.

Thank you.

Hi! I found this package very useful, thank you!

There is one thing I actually try to figure out without any success. How do I print two plots side-by-side, I mean like :framed_picture: :framed_picture:

Here is my code, but I have no success in making all lines same length:(

import os, sys

import plotille
import numpy as np

x = np.linspace(0, 1, 100)

y = 2*x
plot1 = plotille.plot(x, y,
    lc='red', height=5, width=40, X_label='x', Y_label='T',
    x_min=0, x_max=1, y_min=np.min(y), y_max=np.max(y))

y = np.exp(-x)
plot2 = plotille.plot(x, y,
    lc='green', height=5, width=40, X_label='t', Y_label='T',
    x_min=0, x_max=1, y_min=np.min(y), y_max=np.max(y))

print(plot1)
print(plot2)

plot = (os.linesep).join(l1.ljust(60) + l2.ljust(60) for (l1, l2) in zip(plot1.split(os.linesep), plot2.split(os.linesep)))

print(plot)

and here is what I get

Drawing arbitrary vertical or horizontal lines on plot (scatter plots or histograms) is generally very useful, something analogous to this in matplotlib.

Cool library! I'm trying to plot some simple data, but the result has an odd spike at 0 on the x-axis: sys.stderr.write(plotille.plot(np.arange(len(diff)).tolist(), diff.tolist(), x_min=0, height=20, X_label="Frame #", Y_label='Lag-Time (ms)'))

(Lag-Time (ms)) ^
180.205040 |
172.148096 | ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
164.091152 | ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
156.034208 | ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
147.977264 | ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
139.920320 | ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
131.863376 | ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
123.806432 | ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
115.749488 | ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
107.692544 | ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
99.6356000 | ⡇⠀⠀⠀⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠀⠀⡀⠀⠀⡀⡀⠀⠀⠀⢸⢀⠀⡀⠀⠀⠀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⠀⠀⡀⠀⠀⣀⠀⣀⢀⣀⣀⠀⡀⠀⢀⢀⠀⠀⢀⣀⡀⠀⡀⠀⠀⠀⠀⠀⠀⠀
91.5786560 | ⡇⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⡇⠀⠀⡇⡇⠀⠀⠀⢸⣿⠀⡇⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⠀⠀⡇⠀⠀⣿⠀⣿⢸⣿⣿⠀⡇⠀⢸⢸⠀⠀⢸⣿⡇⠀⡇⠀⠀⠀⠀⠀⠀⠀
83.5217120 | ⡇⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⡇⠀⠀⡇⡇⠀⠀⠀⢸⣿⠀⡇⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⠀⠀⡇⠀⠀⣿⠀⣿⢸⣿⣿⠀⡇⠀⢸⢸⠀⠀⢸⣿⡇⠀⡇⠀⠀⠀⠀⠀⠀⠀
75.4647680 | ⡇⠀⠀⠀⢸⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⡇⠀⠀⡇⡇⠀⠀⠀⢸⣿⠀⡇⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⠀⠀⡇⠀⠀⣿⠀⣿⢸⣿⣿⠀⡇⠀⢸⢸⠀⠀⢸⣿⡇⠀⡇⠀⠀⠀⠀⠀⠀⠀
67.4078240 | ⡇⢀⡀⢀⢸⠀⣀⠀⢀⠀⠀⡀⢀⠀⣀⠀⡀⣀⣀⢀⣸⣀⣀⣇⣀⣀⣇⣇⣀⣀⣀⣸⣿⣀⡇⣀⢀⢀⣇⣀⣀⣀⣀⣀⣀⣀⣀⣀⣿⣿⣀⣀⣇⣀⣀⣿⡀⣿⣸⣿⣿⡀⣇⣀⣸⣸⣀⣀⣸⣿⡇⣀⣇⠀⠀⠀⠀⠀⠀⠀
59.3508800 | ⡇⢸⡇⢸⢸⠀⣿⠀⢸⠀⠀⣿⣿⡇⣿⢸⡇⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⣿⢸⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⣿⣿⠀⠀⠀⠀⠀⠀⠀
51.2939360 | ⡇⢸⡇⢸⢸⠀⣿⠀⢸⠀⠀⣿⣿⡇⣿⢸⡇⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⣿⢸⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⣿⣿⠀⠀⠀⠀⠀⠀⠀
43.2369920 | ⡇⢸⡇⢸⢸⠀⣿⠀⢸⠀⠀⣿⣿⡇⣿⢸⡇⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⣿⢸⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⣿⣿⠀⠀⠀⠀⠀⠀⠀
35.1800480 | ⡇⢸⣇⢸⢸⠀⣿⢀⢸⠀⣀⣿⣿⡇⣿⣸⡇⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⣿⣸⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⣿⣿⠀⠀⠀⠀⠀⠀⠀
27.1231040 | ⡏⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠀⠀⠀⠀⠀⠀⠀
19.0661600 | ⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
-----------|-|---------|---------|---------|---------|---------|---------|---------|---------|-> (Frame #)
           | 0         869.96250 1739.9250 2609.8875 3479.8500 4349.8125 5219.7750 6089.7375 6959.7000

Compared to matplotlib: plt.plot(np.arange(len(diff)).tolist(), diff.tolist())

Well, I've made a small library for resampling data to use on functions plot and scatter of plotille. https://github.com/carlosplanchon/plotilleresample """ Rationale:

• I want to optimize plot and scatter function of plotille. """ I came up with two ideas for you and plotille. 1 - Make optimizations before rendering to avoid useless computations. 2 - Separate Canvas module so it can be used as a dependency on plotille, maybe drawille, and potentially on other projects.

Hi, we are trying to figure out why we are not getting hex values for the plotille results when parsing the output with hd on a terminal, do you know why this might happen ?

example :

I plot, setting all lines to 4bit "names" / "bright-green" the output on the terminal is correct, with all lines in green.

But when I parse it with hd I get no color code in hex :

echo ⢀⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀⠀⢰⠃⡎⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ | hd
00000000  e2 a2 80 e2 a1 8f e2 a0  80 e2 a0 80 e2 a0 80 e2  |................|
00000010  a0 80 e2 a0 80 e2 a0 80  e2 a0 80 e2 a0 80 e2 a0  |................|
00000020  80 e2 a0 80 e2 a0 80 e2  a0 80 e2 a0 80 e2 a1 87  |................|
00000030  e2 a0 80 e2 a0 80 e2 a2  b0 e2 a0 83 e2 a1 8e e2  |................|
00000040  a0 80 e2 a0 80 e2 a0 80  e2 a0 80 e2 a0 80 e2 a0  |................|
00000050  80 e2 a0 80 e2 a0 80 e2  a0 80 e2 a0 80 0a        |..............|
0000005e

do you know why this happens ?

I suggest adding treemap as a type of graph that plotille can draw with a single utility function, akin to scatter and hist. If this sounds like something that would suit the project, I'd gladly work on this, so feel free to assign the issue to me.