zhangyiss/YouPlot
1
0
Fork 0
mirror of https://github.com/red-data-tools/YouPlot.git synced 2025-10-29 23:15:11 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Rename uplot to youplot

Browse Source
This commit is contained in:
kojix2
2020-11-23 13:09:16 +09:00
parent d85be56521
commit e831fa93f4
17 changed files with 50 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

79
lib/youplot/command.rb Normal file
View File

@@ -0,0 +1,79 @@
# frozen_string_literal: true
require_relative 'preprocessing'
require_relative 'command/parser'
module YouPlot
Data = Struct.new(:headers, :series)
class Command
attr_accessor :params
attr_reader :data, :fmt, :parser
def initialize
@params = Params.new
@parser = Parser.new
end
def run
parser.parse_options
command = parser.command
params = parser.params
delimiter = parser.delimiter
transpose = parser.transpose
headers = parser.headers
pass = parser.pass
output = parser.output
fmt = parser.fmt
@debug = parser.debug
if command == :colors
Plot.colors(parser.color_names)
exit
end
# Sometimes the input file does not end with a newline code.
while (input = Kernel.gets(nil))
input.freeze
@data = Preprocessing.input(input, delimiter, headers, transpose)
pp @data if @debug
plot = case command
when :bar, :barplot
Plot.barplot(data, params)
when :count, :c
Plot.barplot(data, params, count: true)
when :hist, :histogram
Plot.histogram(data, params)
when :line, :lineplot
Plot.line(data, params)
when :lines, :lineplots
Plot.lines(data, params, fmt)
when :scatter, :s
Plot.scatter(data, params, fmt)
when :density, :d
Plot.density(data, params, fmt)
when :box, :boxplot
Plot.boxplot(data, params)
else
raise "unrecognized plot_type: #{command}"
end
if output.is_a?(IO)
plot.render(output)
else
File.open(output, 'w') do |f|
plot.render(f)
end
end
if pass.is_a?(IO)
print input
elsif pass
File.open(pass, 'w') do |f|
f.print(input)
end
end
end
end
end
end

37
lib/youplot/command/params.rb Normal file
View File

@@ -0,0 +1,37 @@
# frozen_string_literal: true
module YouPlot
class Command
# UnicodePlot parameters.
# * Normally in a Ruby program, you might use hash for the parameter object.
# * Here, I use Struct for 2 safety reason.
# * The keys are static in Struct.
# * Struct does not conflict with keyword arguments. Hash dose.
Params = Struct.new(
# Sort me!
:title,
:width,
:height,
:border,
:margin,
:padding,
:color,
:xlabel,
:ylabel,
:labels,
:symbol,
:xscale,
:nbins,
:closed,
:canvas,
:xlim,
:ylim,
:grid,
:name
) do
def to_hc
to_h.compact
end
end
end
end

261
lib/youplot/command/parser.rb Normal file
View File

@@ -0,0 +1,261 @@
# frozen_string_literal: true
require 'optparse'
require_relative 'params'
module YouPlot
class Command
class Parser
attr_reader :command, :params,
:delimiter, :transpose, :headers, :pass, :output, :fmt,
:color_names, :debug
def initialize
@command = nil
@params = Params.new
@delimiter = "\t"
@transpose = false
@headers = nil
@pass = false
@output = $stderr
@fmt = 'xyy'
@debug = false
@color_names = false
end
def create_default_parser
OptionParser.new do |opt|
opt.program_name = 'YouPlot'
opt.version = YouPlot::VERSION
opt.summary_width = 24
opt.on_tail('') # Add a blank line at the end
opt.separator('')
opt.on('Common options:')
opt.on('-O', '--pass [VAL]', 'file to output standard input data to [stdout]',
'for inserting YouPlot in the middle of Unix pipes') do |v|
@pass = v || $stdout
end
opt.on('-o', '--output VAL', 'file to output results to [stderr]') do |v|
@output = v
end
opt.on('-d', '--delimiter VAL', String, 'use DELIM instead of TAB for field delimiter') do |v|
@delimiter = v
end
opt.on('-H', '--headers', TrueClass, 'specify that the input has header row') do |v|
@headers = v
end
opt.on('-T', '--transpose', TrueClass, 'transpose the axes of the input data') do |v|
@transpose = v
end
opt.on('-t', '--title VAL', String, 'print string on the top of plot') do |v|
params.title = v
end
opt.on('-x', '--xlabel VAL', String, 'print string on the bottom of the plot') do |v|
params.xlabel = v
end
opt.on('-y', '--ylabel VAL', String, 'print string on the far left of the plot') do |v|
params.ylabel = v
end
opt.on('-w', '--width VAL', Integer, 'number of characters per row') do |v|
params.width = v
end
opt.on('-h', '--height VAL', Numeric, 'number of rows') do |v|
params.height = v
end
opt.on('-b', '--border VAL', String, 'specify the style of the bounding box') do |v|
params.border = v.to_sym
end
opt.on('-m', '--margin VAL', Numeric, 'number of spaces to the left of the plot') do |v|
params.margin = v
end
opt.on('-p', '--padding VAL', Numeric, 'space of the left and right of the plot') do |v|
params.padding = v
end
opt.on('-c', '--color VAL', String, 'color of the drawing') do |v|
params.color = v =~ /\A[0-9]+\z/ ? v.to_i : v.to_sym
end
opt.on('--[no-]labels', TrueClass, 'hide the labels') do |v|
params.labels = v
end
opt.on('--fmt VAL', String, 'xyxy : header is like x1, y1, x2, y2, x3, y3...', 'xyy : header is like x, y1, y2, y2, y3...') do |v|
@fmt = v
end
# Optparse adds the help option, but it doesn't show up in usage.
# This is why you need the code below.
opt.on('--help', 'print sub-command help menu') do
puts opt.help
exit
end
opt.on('--debug', TrueClass, 'print preprocessed data') do |v|
@debug = v
end
yield opt if block_given?
end
end
def main_parser
@main_parser ||= create_default_parser do |main_parser|
# Here, help message is stored in the banner.
# Because help of main_parser may be referred by `sub_parser`.
main_parser.banner = \
<<~MSG
Program: YouPlot (Tools for plotting on the terminal)
Version: #{YouPlot::VERSION} (using UnicodePlot #{UnicodePlot::VERSION})
Source: https://github.com/kojix2/youplot
Usage: uplot <command> [options] <in.tsv>
Commands:
barplot bar draw a horizontal barplot
histogram hist draw a horizontal histogram
lineplot line draw a line chart
lineplots lines draw a line chart with multiple series
scatter s draw a scatter plot
density d draw a density plot
boxplot box draw a horizontal boxplot
colors show the list of available colors
count c draw a baplot based on the number of
occurrences (slow)
General options:
--help print command specific help menu
--version print the version of YouPlot
MSG
# Actually, main_parser can take common optional arguments.
# However, these options dose not be shown in the help menu.
# I think the main help should be simple.
main_parser.on('--help', 'print sub-command help menu') do
puts main_parser.banner
puts
exit
end
end
end
def sub_parser
@sub_parser ||= create_default_parser do |parser|
parser.banner = <<~MSG
Usage: YouPlot #{command} [options] <in.tsv>
Options for #{command}:
MSG
case command
# If you type only `uplot` in the terminal.
when nil
warn main_parser.banner
warn "\n"
exit 1
when :barplot, :bar
parser.on_head('--symbol VAL', String, 'character to be used to plot the bars') do |v|
params.symbol = v
end
parser.on_head('--xscale VAL', String, 'axis scaling') do |v|
params.xscale = v
end
when :count, :c
parser.on_head('--symbol VAL', String, 'character to be used to plot the bars') do |v|
params.symbol = v
end
when :histogram, :hist
parser.on_head('-n', '--nbins VAL', Numeric, 'approximate number of bins') do |v|
params.nbins = v
end
parser.on_head('--closed VAL', String) do |v|
params.closed = v
end
parser.on_head('--symbol VAL', String, 'character to be used to plot the bars') do |v|
params.symbol = v
end
when :lineplot, :line
parser.on_head('--canvas VAL', String, 'type of canvas') do |v|
params.canvas = v
end
parser.on_head('--xlim VAL', Array, 'plotting range for the x coordinate') do |v|
params.xlim = v.take(2)
end
parser.on_head('--ylim VAL', Array, 'plotting range for the y coordinate') do |v|
params.ylim = v.take(2)
end
when :lineplots, :lines
parser.on_head('--canvas VAL', String) do |v|
params.canvas = v
end
parser.on_head('--xlim VAL', Array, 'plotting range for the x coordinate') do |v|
params.xlim = v.take(2)
end
parser.on_head('--ylim VAL', Array, 'plotting range for the y coordinate') do |v|
params.ylim = v.take(2)
end
when :scatter, :s
parser.on_head('--canvas VAL', String) do |v|
params.canvas = v
end
parser.on_head('--xlim VAL', Array, 'plotting range for the x coordinate') do |v|
params.xlim = v.take(2)
end
parser.on_head('--ylim VAL', Array, 'plotting range for the y coordinate') do |v|
params.ylim = v.take(2)
end
when :density, :d
parser.on_head('--grid', TrueClass) do |v|
params.grid = v
end
parser.on_head('--xlim VAL', Array, 'plotting range for the x coordinate') do |v|
params.xlim = v.take(2)
end
parser.on_head('--ylim VAL', Array, 'plotting range for the y coordinate') do |v|
params.ylim = v.take(2)
end
when :boxplot, :box
parser.on_head('--xlim VAL', Array, 'plotting range for the x coordinate') do |v|
params.xlim = v.take(2)
end
when :colors
parser.on_head('-n', '--names', 'show color names only', TrueClass) do |v|
@color_names = v
end
else
warn "uplot: unrecognized command '#{command}'"
exit 1
end
end
end
def parse_options(argv = ARGV)
begin
main_parser.order!(argv)
rescue OptionParser::ParseError => e
warn "uplot: #{e.message}"
exit 1
end
@command = argv.shift&.to_sym
begin
sub_parser.parse!(argv)
rescue OptionParser::ParseError => e
warn "uplot: #{e.message}"
exit 1
end
end
end
end
end

165
lib/youplot/plot.rb Normal file
View File

@@ -0,0 +1,165 @@
# frozen_string_literal: true
require 'unicode_plot'
module YouPlot
# plotting functions.
module Plot
module_function
def barplot(data, params, count: false)
headers = data.headers
series = data.series
# `uplot count`
if count
series = Preprocessing.count_values(series[0])
params.title = headers[0] if headers
end
if series.size == 1
# If there is only one series, use the line number for label.
params.title ||= headers[0] if headers
labels = Array.new(series[0].size) { |i| (i + 1).to_s }
values = series[0].map(&:to_f)
else
params.title ||= headers[1] if headers
labels = series[0]
values = series[1].map(&:to_f)
end
UnicodePlot.barplot(labels, values, **params.to_hc)
end
def histogram(data, params)
headers = data.headers
series = data.series
params.title ||= data.headers[0] if headers
values = series[0].map(&:to_f)
UnicodePlot.histogram(values, **params.to_hc)
end
def line(data, params)
headers = data.headers
series = data.series
if series.size == 1
# If there is only one series, it is assumed to be sequential data.
params.ylabel ||= headers[0] if headers
y = series[0].map(&:to_f)
UnicodePlot.lineplot(y, **params.to_hc)
else
# If there are 2 or more series,
# assume that the first 2 series are the x and y series respectively.
if headers
params.xlabel ||= headers[0]
params.ylabel ||= headers[1]
end
x = series[0].map(&:to_f)
y = series[1].map(&:to_f)
UnicodePlot.lineplot(x, y, **params.to_hc)
end
end
def get_method2(method1)
"#{method1}!".to_sym
end
def plot_xyy(data, method1, params)
headers = data.headers
series = data.series
method2 = get_method2(method1)
series.map! { |s| s.map(&:to_f) }
if headers
params.name ||= headers[1]
params.xlabel ||= headers[0]
end
params.ylim ||= series[1..-1].flatten.minmax # why need?
plot = UnicodePlot.public_send(method1, series[0], series[1], **params.to_hc)
2.upto(series.size - 1) do |i|
UnicodePlot.public_send(method2, plot, series[0], series[i], name: headers&.[](i))
end
plot
end
def plot_xyxy(data, method1, params)
headers = data.headers
series = data.series
method2 = get_method2(method1)
series.map! { |s| s.map(&:to_f) }
series = series.each_slice(2).to_a
params.name ||= headers[0] if headers
params.xlim = series.map(&:first).flatten.minmax # why need?
params.ylim = series.map(&:last).flatten.minmax # why need?
x1, y1 = series.shift
plot = UnicodePlot.public_send(method1, x1, y1, **params.to_hc)
series.each_with_index do |(xi, yi), i|
UnicodePlot.public_send(method2, plot, xi, yi, name: headers&.[]((i + 1) * 2))
end
plot
end
def plot_fmt(data, fmt, method1, params)
case fmt
when 'xyy'
plot_xyy(data, method1, params)
when 'xyxy'
plot_xyxy(data, method1, params)
else
raise "Unknown format: #{fmt}"
end
end
def lines(data, params, fmt = 'xyy')
check_series_size(data, fmt)
plot_fmt(data, fmt, :lineplot, params)
end
def scatter(data, params, fmt = 'xyy')
check_series_size(data, fmt)
plot_fmt(data, fmt, :scatterplot, params)
end
def density(data, params, fmt = 'xyy')
check_series_size(data, fmt)
plot_fmt(data, fmt, :densityplot, params)
end
def boxplot(data, params)
headers = data.headers
series = data.series
headers ||= (1..series.size).map(&:to_s)
series.map! { |s| s.map(&:to_f) }
UnicodePlot.boxplot(headers, series, **params.to_hc)
end
def colors(color_names = false)
UnicodePlot::StyledPrinter::TEXT_COLORS.each do |k, v|
print v
print k
unless color_names
print "\t"
print ' ●'
end
print "\033[0m"
print "\t"
end
puts
end
def check_series_size(data, fmt)
series = data.series
if series.size == 1
warn 'youplot: There is only one series of input data. Please check the delimiter.'
warn ''
warn " Headers: \e[35m#{data.headers.inspect}\e[0m"
warn " The first item is: \e[35m\"#{series[0][0]}\"\e[0m"
warn " The last item is : \e[35m\"#{series[0][-1]}\"\e[0m"
exit 1
end
if fmt == 'xyxy' && series.size.odd?
warn 'YouPlot: In the xyxy format, the number of series must be even.'
warn ''
warn " Number of series: \e[35m#{series.size}\e[0m"
warn " Headers: \e[35m#{data.headers.inspect}\e[0m"
exit 1
end
end
end
end

86
lib/youplot/preprocessing.rb Normal file
View File

@@ -0,0 +1,86 @@
# frozen_string_literal: true
require 'csv'
module YouPlot
module Preprocessing
module_function
def input(input, delimiter, headers, transpose)
arr = parse_as_csv(input, delimiter)
headers = get_headers(arr, headers, transpose)
series = get_series(arr, headers, transpose)
if headers.nil?
Data.new(headers, series)
else
if headers.include?(nil)
warn "\e[35mHeaders contains nil in it.\e[0m"
elsif headers.include? ''
warn "\e[35mHeaders contains \"\" in it.\e[0m"
end
h_size = headers.size
s_size = series.size
if h_size == s_size
Data.new(headers, series)
elsif h_size > s_size
warn "\e[35mThe number of headers is greater than the number of series.\e[0m"
exit 1
elsif h_size < s_size
warn "\e[35mThe number of headers is less than the number of series.\e[0m"
exit 1
end
end
end
def parse_as_csv(input, delimiter)
CSV.parse(input, col_sep: delimiter)
.delete_if do |i|
i == [] or i.all? nil
end
end
# Transpose different sized ruby arrays
# https://stackoverflow.com/q/26016632
def transpose2(arr)
Array.new(arr.map(&:length).max) { |i| arr.map { |e| e[i] } }
end
def get_headers(arr, headers, transpose)
if headers
if transpose
arr.map(&:first)
else
arr[0]
end
end
end
def get_series(arr, headers, transpose)
if transpose
if headers
arr.map { |row| row[1..-1] }
else
arr
end
elsif headers
transpose2(arr[1..-1])
else
transpose2(arr)
end
end
def count_values(arr)
# tally was added in Ruby 2.7
if Enumerable.method_defined? :tally
arr.tally
else
# https://github.com/marcandre/backports
arr.each_with_object(Hash.new(0)) { |item, res| res[item] += 1 }
.tap { |h| h.default = nil }
end
.sort { |a, b| a[1] <=> b[1] }
.reverse
.transpose
end
end
end

5
lib/youplot/version.rb Normal file
View File

@@ -0,0 +1,5 @@
# frozen_string_literal: true
module YouPlot
VERSION = '0.3.0'
end