import re

import sys

import math

import inkex

from simplestyle import *

COLOUR_TABLE = {

"red": ["#460101", "#980101", "#d40000", "#f44800", "#fb8b00", "#eec73e", "#d9bb7a", "#fdd99b"],

"blue": ["#000442", "#0F1781", "#252FB7", "#3A45E1", "#656DDE", "#8A91EC"],

"gray": ["#222222", "#444444", "#666666", "#888888", "#aaaaaa", "#cccccc", "#eeeeee"],

"contrast": ["#0000FF", "#FF0000", "#00FF00", "#CF9100", "#FF00FF", "#00FFFF"],

"sap": ["#f8d753", "#5c9746", "#3e75a7", "#7a653e", "#e1662a", "#74796f", "#c4384f",

"#fff8a3", "#a9cc8f", "#b2c8d9", "#bea37a", "#f3aa79", "#b5b5a9", "#e6a5a5"]

}

def get_color_scheme(name="default"):

return COLOUR_TABLE.get(name.lower(), COLOUR_TABLE['red'])

class NiceChart(inkex.Effect):

"""

def __init__(self):

"""

# Call the base class constructor.

inkex.Effect.__init__(self)

# Define string option "--what" with "-w" shortcut and default chart values.

self.OptionParser.add_option('-w', '--what', action='store',

type='string', dest='what', default='22,11,67',

help='Chart Values')

# Define string option "--type" with "-t" shortcut.

self.OptionParser.add_option("-t", "--type", action="store",

type="string", dest="type", default='',

help="Chart Type")

# Define bool option "--blur" with "-b" shortcut.

self.OptionParser.add_option("-b", "--blur", action="store",

type="inkbool", dest="blur", default='True',

help="Blur Type")

# Define string option "--file" with "-f" shortcut.

self.OptionParser.add_option("-f", "--filename", action="store",

type="string", dest="filename", default='',

help="Name of File")

# Define string option "--input_type" with "-i" shortcut.

self.OptionParser.add_option("-i", "--input_type", action="store",

type="string", dest="input_type", default='file',

help="Chart Type")

# Define string option "--delimiter" with "-d" shortcut.

self.OptionParser.add_option("-d", "--delimiter", action="store",

type="string", dest="csv_delimiter", default=';',

help="delimiter")

# Define string option "--colors" with "-c" shortcut.

self.OptionParser.add_option("-c", "--colors", action="store",

type="string", dest="colors", default='default',

help="color-scheme")

# Define string option "--colors_override"

self.OptionParser.add_option("", "--colors_override", action="store",

type="string", dest="colors_override", default='',

help="color-scheme-override")

self.OptionParser.add_option("", "--reverse_colors", action="store",

type="inkbool", dest="reverse_colors", default='False',

help="reverse color-scheme")

self.OptionParser.add_option("-k", "--col_key", action="store",

type="int", dest="col_key", default='0',

help="column that contains the keys")

self.OptionParser.add_option("-v", "--col_val", action="store",

type="int", dest="col_val", default='1',

help="column that contains the values")

self.OptionParser.add_option("", "--encoding", action="store",

type="string", dest="encoding", default='utf-8',

help="encoding of the CSV file, e.g. utf-8")

self.OptionParser.add_option("", "--headings", action="store",

type="inkbool", dest="headings", default='False',

help="the first line of the CSV file consists of headings for the columns")

self.OptionParser.add_option("-r", "--rotate", action="store",

type="inkbool", dest="rotate", default='False',

help="Draw barchart horizontally")

self.OptionParser.add_option("-W", "--bar-width", action="store",

type="int", dest="bar_width", default='10',

help="width of bars")

self.OptionParser.add_option("-p", "--pie-radius", action="store",

type="int", dest="pie_radius", default='100',

help="radius of pie-charts")

self.OptionParser.add_option("-H", "--bar-height", action="store",

type="int", dest="bar_height", default='100',

help="height of bars")

self.OptionParser.add_option("-O", "--bar-offset", action="store",

type="int", dest="bar_offset", default='5',

help="distance between bars")

self.OptionParser.add_option("", "--stroke-width", action="store",

type="float", dest="stroke_width", default='1')

self.OptionParser.add_option("-o", "--text-offset", action="store",

type="int", dest="text_offset", default='5',

help="distance between bar and descriptions")

self.OptionParser.add_option("", "--heading-offset", action="store",

type="int", dest="heading_offset", default='50',

help="distance between chart and chart title")

self.OptionParser.add_option("", "--segment-overlap", action="store",

type="inkbool", dest="segment_overlap", default='False',

help="work around aliasing effects by letting pie chart segments overlap")

self.OptionParser.add_option("-F", "--font", action="store",

type="string", dest="font", default='sans-serif',

help="font of description")

self.OptionParser.add_option("-S", "--font-size", action="store",

type="int", dest="font_size", default='10',

help="font size of description")

self.OptionParser.add_option("-C", "--font-color", action="store",

type="string", dest="font_color", default='black',

help="font color of description")

#Dummy:

self.OptionParser.add_option("","--input_sections")

self.OptionParser.add_option("-V", "--show_values", action="store",

type="inkbool", dest="show_values", default='False',

help="Show values in chart")

def effect(self):

"""

# Get script's "--what" option value and process the data type --- i concess the if term is a little bit of magic

what = self.options.what

keys = []

values = []

orig_values = []

keys_present = True

pie_abs = False

cnt = 0

csv_file_name = self.options.filename

csv_delimiter = self.options.csv_delimiter

input_type = self.options.input_type

col_key = self.options.col_key

col_val = self.options.col_val

show_values = self.options.show_values

encoding = self.options.encoding.strip() or 'utf-8'

headings = self.options.headings

heading_offset = self.options.heading_offset

if input_type == "\"file\"":

csv_file = open(csv_file_name, "r")

for linenum, line in enumerate(csv_file):

value = line.decode(encoding).split(csv_delimiter)

#make sure that there is at least one value (someone may want to use it as description)

if len(value) >= 1:

# allow to parse headings as strings

if linenum == 0 and headings:

heading = value[col_val]

else:

keys.append(value[col_key])

# replace comma decimal separator from file by colon,

# to avoid file editing for people whose programs output

# values with comma

values.append(float(value[col_val].replace(",",".")))

csv_file.close()

elif input_type == "\"direct_input\"":

what = re.findall("([A-Z|a-z|0-9]+:[0-9]+\.?[0-9]*)", what)

for value in what:

value = value.split(":")

keys.append(value[0])

values.append(float(value[1]))

# warn about negative values (not yet supported)

for value in values:

if value < 0:

inkex.errormsg("Negative values are currently not supported!")

return

# Get script's "--type" option value.

charttype = self.options.type

if charttype == "pie_abs":

pie_abs = True

charttype = "pie"

# Get access to main SVG document element and get its dimensions.

svg = self.document.getroot()

# Get the page attibutes:

width = self.getUnittouu(svg.get('width'))

height = self.getUnittouu(svg.attrib['height'])

# Create a new layer.

layer = inkex.etree.SubElement(svg, 'g')

layer.set(inkex.addNS('label', 'inkscape'), 'Chart-Layer: %s' % (what))

layer.set(inkex.addNS('groupmode', 'inkscape'), 'layer')

# Check if a drop shadow should be drawn:

draw_blur = self.options.blur

if draw_blur:

# Get defs of Document

defs = self.xpathSingle('/svg:svg//svg:defs')

if defs == None:

defs = inkex.etree.SubElement(self.document.getroot(), inkex.addNS('defs', 'svg'))

# Create new Filter

filt = inkex.etree.SubElement(defs,inkex.addNS('filter', 'svg'))

filtId = self.uniqueId('filter')

self.filtId = 'filter:url(#%s);' % filtId

for k, v in [('id', filtId), ('height', "3"),

('width', "3"),

('x', '-0.5'), ('y', '-0.5')]:

filt.set(k, v)

# Append Gaussian Blur to that Filter

fe = inkex.etree.SubElement(filt, inkex.addNS('feGaussianBlur', 'svg'))

fe.set('stdDeviation', "1.1")

# Set Default Colors

self.options.colors_override.strip()

if len(self.options.colors_override) > 0:

colors = self.options.colors_override

else:

colors = self.options.colors

if colors[0].isalpha():

colors = get_color_scheme(colors)

else:

colors = re.findall("(#[0-9a-fA-F]{6})", colors)

#to be sure we create a fallback:

if len(colors) == 0:

colors = get_color_scheme()

color_count = len(colors)

if self.options.reverse_colors:

colors.reverse()

# Those values should be self-explanatory:

bar_height = self.options.bar_height

bar_width = self.options.bar_width

bar_offset = self.options.bar_offset

# offset of the description in stacked-bar-charts:

# stacked_bar_text_offset=self.options.stacked_bar_text_offset

text_offset = self.options.text_offset

# prevents ugly aliasing effects between pie chart segments by overlapping

segment_overlap = self.options.segment_overlap

# get font

font = self.options.font

font_size = self.options.font_size

font_color = self.options.font_color

# get rotation

rotate = self.options.rotate

pie_radius = self.options.pie_radius

stroke_width = self.options.stroke_width

if charttype == "bar":

#########

###BAR###

#########

# iterate all values, use offset to draw the bars in different places

offset = 0

color = 0

# Normalize the bars to the largest value

try:

value_max = max(values)

except ValueError:

value_max = 0.0

for x in range(len(values)):

orig_values.append(values[x])

values[x] = (values[x]/value_max) * bar_height

# Draw Single bars with their shadows

for value in values:

# draw drop shadow, if necessary

if draw_blur:

# Create shadow element

shadow = inkex.etree.Element(inkex.addNS("rect", "svg"))

# Set chart position to center of document. Make it horizontal or vertical

if not rotate:

shadow.set('x', str(width/2 + offset + 1))

shadow.set('y', str(height/2 - int(value) + 1))

shadow.set("width", str(bar_width))

shadow.set("height", str(int(value)))

else:

shadow.set('y', str(width/2 + offset + 1))

shadow.set('x', str(height/2 + 1))

shadow.set("height", str(bar_width))

shadow.set("width", str(int(value)))

# Set shadow blur (connect to filter object in xml path)

shadow.set("style", "filter:url(#filter)")

# Create rectangle element

rect = inkex.etree.Element(inkex.addNS('rect', 'svg'))

# Set chart position to center of document.

if not rotate:

rect.set('x', str(width/2 + offset))

rect.set('y', str(height/2 - int(value)))

rect.set("width", str(bar_width))

rect.set("height", str(int(value)))

else:

rect.set('y', str(width/2 + offset))

rect.set('x', str(height/2))

rect.set("height", str(bar_width))

rect.set("width", str(int(value)))

rect.set("style", "fill:" + colors[color % color_count])

# If keys are given, create text elements

if keys_present:

text = inkex.etree.Element(inkex.addNS('text', 'svg'))

if not rotate: #=vertical

text.set("transform", "matrix(0,-1,1,0,0,0)")

#y after rotation:

text.set("x", "-" + str(height/2 + text_offset))

#x after rotation:

text.set("y", str(width/2 + offset + bar_width/2 + font_size/3))

else: #=horizontal

text.set("y", str(width/2 + offset + bar_width/2 + font_size/3))

text.set("x", str(height/2 - text_offset))

text.set("style", "font-size:" + str(font_size)\

+ "px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:"\

+ font + ";-inkscape-font-specification:Bitstream Charter;text-align:end;text-anchor:end;fill:"\

+ font_color)

text.text = keys[cnt]

# Increase Offset and Color

#offset=offset+bar_width+bar_offset

color = (color + 1) % 8

# Connect elements together.

if draw_blur:

layer.append(shadow)

layer.append(rect)

if keys_present:

layer.append(text)

if show_values:

vtext = inkex.etree.Element(inkex.addNS('text', 'svg'))

if not rotate: #=vertical

vtext.set("transform", "matrix(0,-1,1,0,0,0)")

#y after rotation:

vtext.set("x", "-"+str(height/2+text_offset-value-text_offset-text_offset))

#x after rotation:

vtext.set("y", str(width/2+offset+bar_width/2+font_size/3))

else: #=horizontal

vtext.set("y", str(width/2+offset+bar_width/2+font_size/3))

vtext.set("x", str(height/2-text_offset+value+text_offset+text_offset))

vtext.set("style", "font-size:"+str(font_size)\

+ "px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:"\

+ font + ";-inkscape-font-specification:Bitstream Charter;text-align:start;text-anchor:start;fill:"\

+ font_color)

vtext.text = str(int(orig_values[cnt]))

layer.append(vtext)

cnt = cnt+1

offset = offset + bar_width + bar_offset

# set x position for heading line

if not rotate:

heading_x = width/2 # TODO: adjust

else:

heading_x = width/2 # TODO: adjust

elif charttype == "pie":

#########

###PIE###

#########

# Iterate all values to draw the different slices

color = 0

# Create the shadow first (if it should be created):

if draw_blur:

shadow = inkex.etree.Element(inkex.addNS("circle", "svg"))

shadow.set('cx', str(width/2))

shadow.set('cy', str(height/2))

shadow.set('r', str(pie_radius))

shadow.set("style", "filter:url(#filter);fill:#000000")

layer.append(shadow)

# Add a grey background circle with a light stroke

background = inkex.etree.Element(inkex.addNS("circle", "svg"))

background.set("cx", str(width/2))

background.set("cy", str(height/2))

background.set("r", str(pie_radius))

background.set("style", "stroke:#ececec;fill:#f9f9f9")

layer.append(background)

#create value sum in order to divide the slices

try:

valuesum = sum(values)

except ValueError:

valuesum = 0

if pie_abs:

valuesum = 100

num_values = len(values)

# Set an offsetangle

offset = 0

# Draw single slices

for i in range(num_values):

value = values[i]

# Calculate the PI-angles for start and end

angle = (2*3.141592) / valuesum * float(value)

start = offset

end = offset + angle

# proper overlapping

if segment_overlap:

if i != num_values-1:

end += 0.09 # add a 5° overlap

if i == 0:

start -= 0.09 # let the first element overlap into the other direction

#then add the slice

pieslice = inkex.etree.Element(inkex.addNS("path", "svg"))

pieslice.set(inkex.addNS('type', 'sodipodi'), 'arc')

pieslice.set(inkex.addNS('cx', 'sodipodi'), str(width/2))

pieslice.set(inkex.addNS('cy', 'sodipodi'), str(height/2))

pieslice.set(inkex.addNS('rx', 'sodipodi'), str(pie_radius))

pieslice.set(inkex.addNS('ry', 'sodipodi'), str(pie_radius))

pieslice.set(inkex.addNS('start', 'sodipodi'), str(start))

pieslice.set(inkex.addNS('end', 'sodipodi'), str(end))

pieslice.set("style", "fill:"+ colors[color % color_count] + ";stroke:none;fill-opacity:1")

#If text is given, draw short paths and add the text

if keys_present:

path = inkex.etree.Element(inkex.addNS("path", "svg"))

path.set("d", "m "

+ str((width/2) + pie_radius * math.cos(angle/2 + offset)) + ","

+ str((height/2) + pie_radius * math.sin(angle/2 + offset)) + " "

+ str((text_offset - 2) * math.cos(angle/2 + offset)) + ","

+ str((text_offset - 2) * math.sin(angle/2 + offset)))

path.set("style", "fill:none;stroke:"

+ font_color + ";stroke-width:" + str(stroke_width)

+ "px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1")

layer.append(path)

text = inkex.etree.Element(inkex.addNS('text', 'svg'))

text.set("x", str((width/2) + (pie_radius + text_offset) * math.cos(angle/2 + offset)))

text.set("y", str((height/2) + (pie_radius + text_offset) * math.sin(angle/2 + offset) + font_size/3))

textstyle = "font-size:" + str(font_size) \

+ "px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:" \

+ font + ";-inkscape-font-specification:Bitstream Charter;fill:" + font_color

# check if it is right or left of the Pie

if math.cos(angle/2 + offset) > 0:

text.set("style", textstyle)

else:

text.set("style", textstyle + ";text-align:end;text-anchor:end")

text.text = keys[cnt]

if show_values:

text.text = text.text + "(" + str(values[cnt])

if pie_abs:

text.text = text.text + " %"

text.text = text.text + ")"

cnt = cnt + 1

layer.append(text)

# increase the rotation-offset and the colorcycle-position

offset = offset + angle

color = (color + 1) % 8

# append the objects to the extension-layer

layer.append(pieslice)

# set x position for heading line

heading_x = width/2 - pie_radius # TODO: adjust

elif charttype == "stbar":

#################

###STACKED BAR###

#################

# Iterate over all values to draw the different slices

color = 0

#create value sum in order to divide the bars

try:

valuesum = sum(values)

except ValueError:

valuesum = 0.0

for value in values:

valuesum = valuesum + float(value)

# Init offset

offset = 0

if draw_blur:

# Create rectangle element

shadow = inkex.etree.Element(inkex.addNS("rect", "svg"))

# Set chart position to center of document.

if not rotate:

shadow.set('x', str(width/2))

shadow.set('y', str(height/2 - bar_height/2))

else:

shadow.set('x', str(width/2))

shadow.set('y', str(height/2))

# Set rectangle properties

if not rotate:

shadow.set("width", str(bar_width))

shadow.set("height", str(bar_height/2))

else:

shadow.set("width",str(bar_height/2))

shadow.set("height", str(bar_width))

# Set shadow blur (connect to filter object in xml path)

shadow.set("style", "filter:url(#filter)")

layer.append(shadow)

i = 0

# Draw Single bars

for value in values:

# Calculate the individual heights normalized on 100units

normedvalue = (bar_height / valuesum) * float(value)

# Create rectangle element

rect = inkex.etree.Element(inkex.addNS('rect', 'svg'))

# Set chart position to center of document.

if not rotate:

rect.set('x', str(width / 2 ))

rect.set('y', str(height / 2 - offset - normedvalue))

else:

rect.set('x', str(width / 2 + offset ))

rect.set('y', str(height / 2 ))

# Set rectangle properties

if not rotate:

rect.set("width", str(bar_width))

rect.set("height", str(normedvalue))

else:

rect.set("height", str(bar_width))

rect.set("width", str(normedvalue))

rect.set("style", "fill:" + colors[color % color_count])

#If text is given, draw short paths and add the text

# TODO: apply overlap workaround for visible gaps in between

if keys_present:

if not rotate:

path = inkex.etree.Element(inkex.addNS("path", "svg"))

path.set("d","m " + str((width + bar_width)/2) + ","

+ str(height/2 - offset - (normedvalue / 2)) + " "

+ str(bar_width/2 + text_offset) + ",0")

path.set("style", "fill:none;stroke:" + font_color

+ ";stroke-width:" + str(stroke_width)

+ "px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1")

layer.append(path)

text = inkex.etree.Element(inkex.addNS('text', 'svg'))

text.set("x", str(width/2 + bar_width + text_offset + 1))

text.set("y", str(height/ 2 - offset + font_size/3 - (normedvalue/2)))

text.set("style", "font-size:" + str(font_size)

+ "px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:"

+ font + ";-inkscape-font-specification:Bitstream Charter;fill:" + font_color)

text.text = keys[cnt]

cnt = cnt + 1

layer.append(text)

else:

path = inkex.etree.Element(inkex.addNS("path", "svg"))

path.set("d","m " + str((width)/2 + offset + normedvalue/2) + ","

+ str(height / 2 + bar_width/2) + " 0,"

+ str(bar_width/2 + (font_size * i) + text_offset)) #line

path.set("style", "fill:none;stroke:" + font_color

+ ";stroke-width:" + str(stroke_width)

+ "px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1")

layer.append(path)

text = inkex.etree.Element(inkex.addNS('text', 'svg'))

text.set("x", str((width)/2 + offset + normedvalue/2 - font_size/3))

text.set("y", str((height/2) + bar_width + (font_size * (i + 1)) + text_offset))

text.set("style", "font-size:" + str(font_size)

+ "px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:"

+ font + ";-inkscape-font-specification:Bitstream Charter;fill:" + font_color)

text.text = keys[color]

layer.append(text)

# Increase Offset and Color

offset = offset + normedvalue

color = (color + 1) % 8

# Draw rectangle

layer.append(rect)

i += 1

# set x position for heading line

if not rotate:

heading_x = width/2 + offset + normedvalue # TODO: adjust

else:

heading_x = width/2 + offset + normedvalue # TODO: adjust

if headings and input_type == "\"file\"":

headingtext = inkex.etree.Element(inkex.addNS('text', 'svg'))

headingtext.set("y", str(height/2 + heading_offset))

headingtext.set("x", str(heading_x))

headingtext.set("style", "font-size:" + str(font_size + 4)\

+ "px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:"\

+ font + ";-inkscape-font-specification:Bitstream Charter;text-align:end;text-anchor:end;fill:"\

+ font_color)

headingtext.text = heading

layer.append(headingtext)

def getUnittouu(self, param):

try:

return inkex.unittouu(param)

except AttributeError:

return self.unittouu(param)

if __name__ == '__main__':

# Create effect instance and apply it.

effect = NiceChart()

effect.affect()