########################################################################################
# name: t-SNE plot
# author: Marc Bickle 
# category: dimensionality reduction
# preview: 

t-SNE (TSNE) converts affinities of data points to probabilities. The affinities in the original space are represented by Gaussian joint probabilities and the affinities in the embedded space are represented by Student’s t-distributions. This allows t-SNE to be particularly sensitive to local structure and has a few other advantages over existing techniques:
	Revealing the structure at many scales on a single map
	Revealing data that lie in multiple, different, manifolds or clusters
	Reducing the tendency to crowd points together at the center
online help:
http://scikit-learn.org/stable/modules/generated/sklearn.manifold.TSNE.html
http://scikit-learn.org/stable/modules/manifold.html#t-sne
https://distill.pub/2016/misread-tsne/


Inputs:
1) Features of interest: choose parameters to test
2) Parametrise t-SNE algorithm (for tips see:https://distill.pub/2016/misread-tsne/)


######

<rgg>

<!--1. Title and short description -->

<h3 text="t-SNE plot" aligment="center" span="full"/>
<separator label="Description" span="full"/>
<labelarea span="full"> t-SNE (TSNE) converts affinities of data points to probabilities.

Parametrization:
http://scikit-learn.org/stable/modules/generated/sklearn.manifold.TSNE.html
</labelarea>
<gaprow height="1"/>


<!-- 2. Configuration-->

<separator label="Options" span="full"/>
<gaprow height="2"/>

<group>

# 1) Define the group column

groupingColumns = <panellistbox label="Category column" items="$$$STR_ATTRIBUTES$$$" span="full"/>

# 2) Define what numerical values to use
features = [<panellistbox label="Features of interest" items="$$$NUM_ATTRIBUTES$$$" visible-row-count="5" span="full"/>]

# 3) Parametrise the t-SNE algorithm

comp = int(<textfield label="Number of Dimensions" var="" data-type="number" default-value="2" size="10" span="full"/>)
per = int(<textfield label="Perplexity" var="" data-type="number" default-value="30" size="10" span="full"/>)
earl = int(<textfield label="Early Exaggeration" var="" data-type="number" default-value="12" size="10" span="full"/>)
ler =  int(<textfield label="Learning Rate" var="" data-type="number" default-value="200" size="10" span="full"/>)
iter = int(<textfield label="Number of Iterations" var="" data-type="number" default-value="1000" size="10" span="full"/>)
iter_n = int(<textfield label="Number of Iterations without Progress" var="" data-type="number" default-value="300" size="10" span="full"/>)
Distance = <combobox label="Distance" items="euclidean, l2, l1, manhattan, cityblock, braycurtis, canberra, chebyshev, correlation, cosine, dice, hamming, jaccard, kulsinski, mahalanobis, matching, minkowski, rogerstanimoto, russellrao, seuclidean, sokalmichener, sokalsneath, sqeuclidean, yule, wminkowski" span="full"/>;
meth = <textfield label="Method" var="" data-type="string" default-value="barnes_hut" size="10" span="full"/>



</group>

<![CDATA[
#load modules

import numpy as np
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
from scipy.cluster.hierarchy import dendrogram, linkage


# prepare data

DF = pd.DataFrame(kIn.values(), index = kIn.keys()).T
DF = DF.convert_objects(convert_numeric=True)

# perform t-SNE

DF_embedded = TSNE(n_components=comp, perplexity = per, early_exaggeration = earl, learning_rate = ler, n_iter = iter, n_iter_without_progress = iter_n, min_grad_norm = 1e-7, metric = Distance, init = "random", verbose = 0, random_state = None, method = meth, angle = 0.5 ).fit_transform(DF[features])

# add categories

DF_embedded = pd.DataFrame(DF_embedded)
DF_final = pd.concat([DF_embedded, DF[groupingColumns]], axis =1)


# plot the data

groups = DF_final.groupby(groupingColumns)
fig, ax = plt.subplots()
for name, group in groups:
    ax.plot(group[0], group[1], marker='o', linestyle='', ms=12, label=name)
ax.legend()


]]>

</rgg>

########################################################################################
# name: Venn Diagram
# author: Marc Bickle
# category: relations
# preview: venn.png

Creates a Venn Diagram of 2 or 3 sets. Accepts at most 3 columns with the option to draw the circles approximately proportional to the size of the data.
python script from Chris DeBoever, http://nbviewer.ipython.org/github/ucsd-scientific-python/user-group/blob/master/presentations/20131016/hierarchical_clustering_heatmaps_gridspec.ipynb



######
<rgg>

<!--1. Title and short description -->

<h3 text="$$$TEMPLATE_NAME$$$" aligment="center" span="full"/>
<separator label="Description" span="full"/>
<labelarea span="full">$$$TEMPLATE_DESC$$$</labelarea>
<gaprow height="1"/>


<!-- 2. Configuration-->

<separator label="Options" span="full"/>
<gaprow height="2"/>

<group>

# b) Define what values to use
features = [<panellistbox label="Features of interest" items="$$$ALL_ATTRIBUTES$$$" visible-row-count="5" span="full"/>]

Title = <textfield label="Title" data-type="text" default-value= "Venn diagram" size="10" span="full"/>

prop ="<checkbox label="Draw areas proportionally?" selected="False" span="full"/>"

</group>

<!-- 3. Script-->

<![CDATA[

from matplotlib import pyplot as plt
import numpy as np
from matplotlib_venn import venn2, venn2_unweighted, venn3, venn3_unweighted

kIn = pd.DataFrame(kIn.values(), index = kIn.keys()).T
DF = kIn[features]

set1 = set(DF[features[0]].dropna())
set2 = set(DF[features[1]].dropna())
if len(features) == 3:
	set3 = set(DF[features[2]].dropna())

plt.figure(figsize=(4,4))

if len(features) == 2:
	if prop == "TRUE":
		v = venn2([set1,set2], set_labels = (features[0], features[1]))
	else:
		v = venn2_unweighted([set1,set2], set_labels = (features[0], features[1]))
if len(features) == 3:
	if prop == "TRUE":
		v = venn3([set1,set2,set3], set_labels = (features[0], features[1], features[2]))
	else:
		v = venn3_unweighted([set1,set2,set3], set_labels = (features[0], features[1], features[2]))

plt.title(Title)
plt.show()


]]>

</rgg>


########################################################################################
# name: Stream plot
# author: Felix Meyenhofer (python script from Anand Patil, Steam plot method by Lee Bryon)
# category: experimental
# preview: stream-plot.png

Creates a stream plot (stacked histogram) from several input parameter

Inputs:
1) Features of interest: choose parameters to form the stream plot (stacked histogram)
2) Number of bins: binning of the data
3) Color chooser: method to pick the colors for the different parameter

######

<rgg>

<!--1. Title and short description -->

<h3 text="$$$TEMPLATE_NAME$$$" aligment="center" span="full"/>
<separator label="Description" span="full"/>
<labelarea span="full">$$$TEMPLATE_DESC$$$</labelarea>
<gaprow height="1"/>


<!-- 2. Configuration-->

<separator label="Options" span="full"/>
<gaprow height="2"/>

# 1. Parameter selection
<group>
# 1) select the readouts that span the phenotypic space
keys = <panellistbox label="Features of interest" items="$$$NUM_ATTRIBUTES$$$" visible-row-count="6" span="full"/>
Nbins = int(<textfield label="Number of bins" var="" data-type="number" default-value= "30" size="10" span="full"/>)
colorSequence = <combobox items="random,linear" label="color chooser"/>
</group>


# Script
<![CDATA[

import matplotlib.pyplot as pl
import numpy as np

def symmetric(sorted_streams, stream_bounds):
   """Symmetric baseline"""
   lb, ub = np.min(stream_bounds[:,0,:],axis=0), np.max(stream_bounds[:,1,:],axis=0)
   return .5*(lb+ub)
def pos_only(sorted_streams, stream_bounds):
   """Lumps will only be positive"""
   lb, ub = np.min(stream_bounds[:,0,:],axis=0), np.max(stream_bounds[:,1,:],axis=0)
   return lb
def zero(sorted_streams, stream_bounds):
   """Zero baseline"""
   return np.zeros(stream_bounds.shape[2])
def min_weighted_wiggles(sorted_streams, stream_bounds):
   """Baseline recommended by Byron and Wattenberg"""
   lb, ub = np.min(stream_bounds[:,0,:],axis=0), np.max(stream_bounds[:,1,:],axis=0)
   weight = ub-lb

   sorted_streams = np.abs(sorted_streams)
   for i in xrange(len(sorted_streams)):
       sorted_streams[i,:] *= (-1)**i
   cusum_f = np.vstack((np.zeros(sorted_streams.shape[1]),
                       np.cumsum(sorted_streams[:-1,:], axis=0)))
   f_prime = np.diff(sorted_streams, axis=1)
   cusum_f_prime = np.diff(cusum_f, axis=1)
   g_prime = np.hstack(([0],-np.sum((f_prime*.5  + cusum_f_prime)*sorted_streams[:,1:],axis=0) / weight[1:]))
   g_prime[np.where(weight==0)] = 0
   g = np.cumsum(g_prime)

   return g


def stacked_graph(streams, cmap=pl.cm.bone, color_seq='linear', baseline_fn=min_weighted_wiggles):
   """
   Produces stacked graphs using matplotlib.

   Reference: 'Stacked graphs- geometry & aesthetics' by Byron and Wattenberg
   http://www.leebyron.com/else/streamgraph/download.php?file=stackedgraphs_byron_wattenberg.pdf

   Parameters:
     - streams: A list of time-series of positive values. Each element must be of the same length.
     - cmap: A matplotlib color map. Defaults to 'bone'.
     - colo_seq: 'linear' or 'random'.
     - baseline_fn: Current options are symmetric, pos_only, zero and min_weighted_wiggles.
   """
   # Sort by onset times
   onset_times = [np.where(np.abs(stream)>0)[0][0] for stream in streams]
   order = np.argsort(onset_times)
   streams = np.asarray(streams)
   sorted_streams = streams[order]

   t = np.arange(streams.shape[1])

   # Establish bounds
   stream_bounds = [np.vstack((np.zeros(streams.shape[1]), sorted_streams[0])),
                   np.vstack((-sorted_streams[1], (np.zeros(streams.shape[1]))))]
   side = -1
   for stream in sorted_streams[2:]:
       side *= -1
       if side==1:
           stream_bounds.append(np.vstack((stream_bounds[-2][1], stream_bounds[-2][1]+stream)))
       else:
           stream_bounds.append(np.vstack((stream_bounds[-2][0]-stream, stream_bounds[-2][0])))

   stream_bounds = np.array(stream_bounds)

   # Compute baseline
   baseline = baseline_fn(sorted_streams, stream_bounds)

   # Choose colors
   t_poly = np.hstack((t,t[::-1]))
   if color_seq=='linear':
       colors = np.linspace(0,1,streams.shape[1])
   elif color_seq=='random':
       colors = np.random.random(size=streams.shape[1])
   else:
       raise ValueError, 'Color sequence %s unrecognized'%color_seq

   # Plot
   pl.axis('off')
   for i in xrange(len(stream_bounds)):
       bound = stream_bounds[i]
       color = cmap(colors[i])
       pl.fill(t_poly, np.hstack((bound[0]-baseline,(bound[1]-baseline)[::-1])), facecolor=color, linewidth=0.,edgecolor='none')


# Demo
if __name__ == '__main__':
    v = []
    for key in keys:
        v.extend(kIn[key])
    mi = min(v)
    ma = max(v)
    dsets = []
    for key in keys:
        c,s,trash = pl.hist(kIn[key], Nbins, range=(mi, ma))
        dsets.append(c)
    pl.clf()
    stacked_graph(dsets, baseline_fn=symmetric, color_seq=colorSequence)
    pl.show()

]]>

</rgg>




########################################################################################
# name: estimate gaussian intersection
# author: Felix Meyenhofer
# category: univariate
# preview: gaussian-intersection.png

compute the histograms of random variables, fit a gaussian and compute the intersection points.
This version can only deal with TWO groups. Make sure there are no more and no less to be found in the "Grouping column".

Inputs:
1) Features of interest: choose parameters to form the stream plot (stacked histogram)
2) Number of bins: binning of the data
3) Color chooser: method to pick the colors for the different parameter

######

<rgg>

<!--1. Title and short description -->

<h3 text="$$$TEMPLATE_NAME$$$" aligment="center" span="full"/>
<separator label="Description" span="full"/>
<labelarea span="full">$$$TEMPLATE_DESC$$$</labelarea>
<gaprow height="1"/>


<!-- 2. Configuration-->

<separator label="Options" span="full"/>
<gaprow height="2"/>

<group>
# a) Define your treatments of interest
strColName = <combobox label="Grouping column" items="$$$STR_ATTRIBUTES$$$" span="full"/>

# b) Define what numerical values to use
numColName = <combobox label="Numerical values" items="$$$NUM_ATTRIBUTES$$$" span="full"/>

# c) number of bins.
nBins = int(<textfield label="Number of bins" var="" data-type="number" default-value= "30" size="10" span="full"/>)

</group>


<!-- 3. Script-->
<![CDATA[

import numpy as np
from scipy import optimize, integrate
from matplotlib import pyplot
from scipy.optimize import fsolve


# Objective function to solve intersection
def fun(xy, f1, f2):
    x, y = xy
    z = np.array([y - f1(x), y - f2(x)])
    return z


def findIntersection(vect1, vect2):

    # make the histogram
    y1,x1,trash = pyplot.hist(vect1, bins=nBins, normed=True, alpha=0.5, edgecolor='none')
    y2,x2,trash = pyplot.hist(vect2, bins=nBins, normed=True, alpha=0.5, edgecolor='none')

    # calculate the center of the bins
    x1 = np.mean(np.column_stack((x1[:-1], x1[1:])).T,0)
    x2 = np.mean(np.column_stack((x2[:-1], x2[1:])).T,0)

    # estimate the parameter of the gaussian function
    mue1 = sum(x1*y1)/sum(y1)
    sig1 = np.sqrt(abs(sum((x1-mue1)**2*y1)/sum(y1)))
    a1 = y1.max()
    mue2 = sum(x2*y2)/sum(y2)
    sig2 = np.sqrt(abs(sum((x2-mue1)**2*y2)/sum(y2)))
    a2 = y2.max()

    # Fit
    fitfunc = lambda p, x: p[0]*np.exp(-(x-p[1])**2/(2*p[2]**2))       # Target function
    errfunc = lambda p, x, y: fitfunc(p, x) - y                     # Distance to the target function

    p0 = [a1, mue1, sig1]
    p1, success = optimize.leastsq(errfunc, p0[:], args=(x1, y1))
    g1 = lambda x : p1[0]*np.exp(-(x-p1[1])**2/(2*p1[2]**2))

    p0 = [a2, mue2, sig2]
    p2, success = optimize.leastsq(errfunc, p0[:], args=(x2, y2))
    g2 = lambda x : p2[0]*np.exp(-(x-p2[1])**2/(2*p2[2]**2))


    # Find the instersection.
    x0 = np.mean([mue1, mue2])
    y0 = g1(x0)
    intersection = fsolve(fun, [x0, y0], (g1, g2))

    # Compute overlap
    sig15 = sig1*5
    i1 = integrate.quad(g1, mue1-sig15, mue1+sig15)
    if mue1 > intersection[0]:
        o1 = integrate.quad(g1, mue1-sig15, intersection[0])
    else:
        o1 = integrate.quad(g1, intersection[0], mue1+sig15)

    sig25 = sig2*5
    i2 = integrate.quad(g2, mue1-sig25, mue1+sig25)
    if mue2 > intersection[0]:
        o2 = integrate.quad(g2, mue2-sig25, intersection[0])
    else:
        o2 = integrate.quad(g2, intersection[0], mue2+sig15)

    overlap = (o1[0] + o2[0]) / (i1[0] + i2[0])

    # plot the fitted cureves and the intersection.
    sigm = np.max([sig1, sig2])*3
    muemi = np.min([mue1, mue2])
    muema = np.max([mue1, mue2])
    x = np.linspace(muemi-sigm, muema+sigm, 100)
    pyplot.plot(x, g1(x), 'b', x, g2(x), 'g', intersection[0], intersection[1], 'r.', markersize=10)
    pyplot.title("Relative overlap = %s" % overlap)


# Main
vec = kIn[numColName]
cat = kIn[strColName]

sets = {}
for index in range(0,len(vec)-1):
    if sets.has_key(cat[index]):
        sets[cat[index]].append(vec[index])
    else:
        sets[cat[index]] = [vec[index]]

keys = sets.keys()
numSets = len(keys)
if numSets == 2:
    data = findIntersection(sets[keys[0]], sets[keys[1]])
else:
    raise Exception

]]>

</rgg>




########################################################################################
# name: 2D scatter plot
# author: Felix Meyenhofer
# category: scatter-plots
# preview: scatterplot_2d.png

Make a 2D scatter plot form 2 variables.

Parameter:
grouping column: column assotiating each measurement to a particular group.
                 Per default this attribute is empty -> all measurments blong to the same group.
x values: values displayed on the x-axis
y values: values displayed on the y-axis

######

<rgg>

<!--1. Title and short description -->

<h3 text="$$$TEMPLATE_NAME$$$" aligment="center" span="full"/>
<separator label="Description" span="full"/>
<labelarea span="full">$$$TEMPLATE_DESC$$$</labelarea>
<gaprow height="1"/>


<!-- 2. Configuration-->

<separator label="Options" span="full"/>
<gaprow height="2"/>

<group>
# a) Grouping column
gColName = <combobox label="Grouping column" items=" ,$$$STR_ATTRIBUTES$$$" span="full"/>

# b) Define what numerical values to use
xColName = <combobox label="X values" items="$$$NUM_ATTRIBUTES$$$" span="full"/>
yColName = <combobox label="Y values" items="$$$NUM_ATTRIBUTES$$$" span="full"/>

# c) Title.
title = <textfield label="Title" var="" data-type="number" default-value= "scatter plot" size="10" span="full"/>

# d) Legend control
show_legend = "<checkbox label="show legend" selected="true" span="full"/>"
</group>


<!-- 3. Script-->

<![CDATA[
from pylab import hold
import matplotlib.pyplot as plt

# ensure the f. label does not find a reason to throw an error.
if not title:
    title = ' '

# Prepare the data
data = {}
if kIn.has_key(gColName):
    for group, xValue, yValue in zip(kIn[gColName], kIn[xColName], kIn[yColName]):
        if data.has_key(group):
            data[group][0].append(xValue)
            data[group][1].append(yValue)
        else:
            data[group] = [[xValue], [yValue]]
else:
    data['data'] = [kIn[xColName], kIn[yColName]]

# Get the group names
groups = data.keys()
numberOfGroups = len(groups)

# Plot the data
ax = plt.subplot(111)
plt.hsv()
for index, group in enumerate(groups):
    x = data[group][0]
    y = data[group][1]
    color = [index for n in range(len(x))]
    plt.scatter(x, y, c=color, s=20, vmin=0, vmax=numberOfGroups, label=group)

ax.autoscale(tight=True)
plt.xlabel(xColName)
plt.ylabel(yColName)
plt.title(title)
plt.draw()
if show_legend == "TRUE":
    leg = plt.legend(loc='best', fancybox=True)
    leg.get_frame().set_alpha(0.65)
    #box = ax.get_position()
    #ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])
    #ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))
plt.show()
]]>

</rgg>




########################################################################################
# name: 3D scatter plot
# author: Felix Meyenhofer
# category: scatter-plots
# preview: scatterplot_3d.png

Make a 3D scatter plot form 3 variables.

Parameter:
grouping column: column assotiating each measurement to a particular group.
                 Per default this attribute is empty -> all measurments blong to the same group.
x values: values displayed on the x-axis
y values: values displayed on the y-axis
z values: values displayed ...

######

<rgg>

<!--1. Title and short description -->

<h3 text="$$$TEMPLATE_NAME$$$" aligment="center" span="full"/>
<separator label="Description" span="full"/>
<labelarea span="full">$$$TEMPLATE_DESC$$$</labelarea>
<gaprow height="1"/>


<!-- 2. Configuration-->

<separator label="Options" span="full"/>
<gaprow height="2"/>

<group>
# a) Grouping column
gColName = <combobox label="Grouping column" items=" ,$$$STR_ATTRIBUTES$$$" span="full"/>

# b) Define what numerical values to use
xColName = <combobox label="X values" items="$$$NUM_ATTRIBUTES$$$" span="full"/>
yColName = <combobox label="Y values" items="$$$NUM_ATTRIBUTES$$$" span="full"/>
zColName = <combobox label="Z values" items="$$$NUM_ATTRIBUTES$$$" span="full"/>

# c) Title.
title = <textfield label="Title" var="" data-type="number" default-value= "scatter plot" size="10" span="full"/>

# d) Legend control
show_legend = "<checkbox label="show legend" selected="true" span="full"/>"
</group>


<!-- 3. Script-->

<![CDATA[
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import matplotlib.cm as cm

# ensure the f. label does not find a reason to throw an error.
if not title:
    title = ' '

# Prepare the data
data = {}
if kIn.has_key(gColName):
    for group, xValue, yValue, zValue in zip(kIn[gColName], kIn[xColName], kIn[yColName], kIn[zColName]):
        if data.has_key(group):
            data[group][0].append(xValue)
            data[group][1].append(yValue)
            data[group][2].append(zValue)
        else:
            data[group] = [[xValue], [yValue], [zValue]]
else:
    data['data'] = [kIn[xColName], kIn[yColName], kIn[zColName]]

# Get the group names
groups = data.keys()
numberOfGroups = len(groups)

# Plot the data
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

for index, group in enumerate(groups):
    x = data[group][0]
    y = data[group][1]
    z = data[group][2]
    ind = index*32#numberOfGroups/(index+1)
    ax.scatter(x, y, z, s=20, c=cm.hsv(ind))
    plt.plot([0.], [0.], ms=1,  c=cm.hsv(ind), label=group)

ax.autoscale(tight=True)
ax.set_xlabel(xColName)
ax.set_ylabel(yColName)
ax.set_zlabel(zColName)
plt.title(title)
plt.draw()
if show_legend == "TRUE":
    leg = plt.legend(loc='upper left', fancybox=True)
    leg.get_frame().set_alpha(0.65)
plt.show()
]]>

</rgg>


########################################################################################
# name: 3D PCA scatter plot
# author: Felix Meyenhofer
# category: scatter-plots
# preview: pca_scatterplot_3d.png

Take any number of numerical features, project it into an orthogonal space using
principal componant analysis (PCA) and use the first three componants to create a 3D
scatter plot.

Parameter:
features of interest: The featuers included into the PCA
grouping column: column assotiating each measurement to a particular group.
                 Per default this attribute is empty -> all measurments blong to the same group.


######

<rgg>

<!--1. Title and short description -->

<h3 text="$$$TEMPLATE_NAME$$$" aligment="center" span="full"/>
<separator label="Description" span="full"/>
<labelarea span="full">$$$TEMPLATE_DESC$$$</labelarea>
<gaprow height="1"/>


<!-- 2. Configuration-->

<separator label="Options" span="full"/>
<gaprow height="2"/>

<group>
# a) Grouping column
gColName = <combobox label="Grouping column" items=" ,$$$STR_ATTRIBUTES$$$" span="full"/>

# b) Define what numerical values to use
features = <panellistbox label="Features of interest" items="$$$NUM_ATTRIBUTES$$$" visible-row-count="5" span="full"/>

# c) Title.
title = <textfield label="Title" var="" data-type="number" default-value= "scatter plot" size="10" span="full"/>

# d) Legend control
show_legend = "<checkbox label="show legend" selected="true" span="full"/>"
</group>


<!-- 3. Script-->

<![CDATA[
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from matplotlib import mlab
from numpy import array, vstack

# ensure the f. label does not find a reason to throw an error.
if not title:
    title = ' '

# Create matrix from the data
for f,feature in enumerate(features):
    if f == 0:
        x = array(kIn[feature])
    else:
        x = vstack((x, array(kIn[feature])))
x = x.transpose()

# Principal componant analysis
pca = mlab.PCA(x)
expVar =pca.fracs[0:3].sum()

# Prepare the data
data = {}
if kIn.has_key(gColName):
    for group, xValue, yValue, zValue in zip(kIn[gColName], pca.Y[:,0], pca.Y[:,1], pca.Y[:,2]):
        if data.has_key(group):
            data[group][0].append(xValue)
            data[group][1].append(yValue)
            data[group][2].append(zValue)
        else:
            data[group] = [[xValue], [yValue], [zValue]]
else:
    data['data'] = [pca.Y[:,0], pca.Y[:,1], pca.Y[:,2]]

# Get the group names
groups = data.keys()
numberOfGroups = len(groups)

# Plot the componant scatter plot
fig = plt.figure(figsize=(10,4))
ax = fig.add_subplot(121, projection='3d')
for index, group in enumerate(groups):
    x = data[group][0]
    y = data[group][1]
    z = data[group][2]
    ind = index*32
    ax.scatter(x, y, z, s=20, c=cm.hsv(ind))
    plt.plot([0.], [0.], ms=1,  c=cm.hsv(ind), label=group)
plt.draw()
ax.autoscale(tight=True)
for a in ax.w_xaxis.get_ticklabels()+ax.w_yaxis.get_ticklabels()+ax.w_zaxis.get_ticklabels():
    a.set_fontsize(8)
plt.draw()
if show_legend == "TRUE":
    leg = plt.legend(loc='upper left', fancybox=True)
    plt.setp(leg.get_texts(), fontsize="small")
    leg.get_frame().set_alpha(0.5)

# Plot the loadings
axl = fig.add_subplot(122, projection='3d')
for feature, w in zip(features, pca.Wt):
    axl.plot([0., w[0]], [0., w[1]], [0., w[2]], 'b-')
    axl.plot([w[0]], [w[1]], [w[2]], 'b.')
    axl.text(w[0], w[1], w[2], feature, fontsize=8)
plt.draw()
# cosmetics
for a in axl.w_xaxis.get_ticklines()+axl.w_xaxis.get_ticklabels()+axl.w_yaxis.get_ticklines()+axl.w_yaxis.get_ticklabels()+axl.w_zaxis.get_ticklines()+axl.w_zaxis.get_ticklabels():
    a.set_visible(False)
axl.set_xlabel("component 1", fontsize=10, color='b')
axl.set_ylabel("component 2", fontsize=10, color='b')
axl.set_zlabel("component 3", fontsize=10, color='b')
title = "PCA plot (explains %s%% of the variance)" % int(expVar*100)
axl.text2D(1.2, 0.96, title, verticalalignment='bottom', transform=ax.transAxes)
plt.show()
]]>

</rgg>

############################################################
# name: Violin Plot
# author: Felix Meyenhofer
# category: distributions
# preview: pandas-violinplot.png

Creates a violing plot.

Note: the Seaborn module has to be installed.

######
<rgg>

<!--1. Title and short description -->

<h3 text="$$$TEMPLATE_NAME$$$" aligment="center" span="full"/>
<separator label="Description" span="full"/>
<labelarea span="full">$$$TEMPLATE_DESC$$$</labelarea>
<gaprow height="1"/>

<!-- 2. Configuration-->

<separator label="Options" span="full"/>
<gaprow height="2"/>

<group>
# a) Define grouping
grp = <combobox label="Categorical variable (group)" items="$$$STR_ATTRIBUTES$$$" span="full"/>
sec = <combobox label="Binary variable (ignored if it's the same as above)" items="$$$STR_ATTRIBUTES$$$" span="full"/>

# b) Define what numerical values to use
amp = <combobox label="Numeric variable" items="$$$NUM_ATTRIBUTES$$$" span="full"/>

# c) Graph title
tit = <textfield label="Title" data-type="text" default-value="None" size="10" span="full"/>

# d) Orientation
ori = <combobox items="vertical,horizontal" label="Orientation"/>;

# e) Inner glyphs
gly = <combobox items="None,box,point,quartile,stick" label="Inner glyphs"  default-value="None" span="full"/>
</group>

<!-- 3. Python script-->

<![CDATA[
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pan

# Parse into a pandas DataFrame
df = pan.DataFrame(kIn)

# deternine the secondairy category
if sec != grp:
	col = sec
	spl = True
else:
	col = None
	spl = False

if gly == 'None':
	gly = None

if ori == 'vertical':
	xvar = grp
	yvar = amp
else: 
	xvar = amp
	yvar = grp

fi, ax = plt.subplots()
sns.violinplot(x=xvar, y=yvar, data=df, hue=col, split=spl, inner=gly)

if tit != 'None':
	plt.title(tit)

plt.subplots_adjust(bottom=0.15, left=0.15)
plt.show()

]]>
</rgg>