import numpy as np
import holoviews as hv
import datashader as ds
from holoviews.operation.datashader import datashade, shade, dynspread, rasterize
from holoviews.operation import decimate
hv.extension('bokeh','matplotlib')
decimate.max_samples=1000
dynspread.max_px=20
dynspread.threshold=0.5

def random_walk(n, f=5000):
    """Random walk in a 2D space, smoothed with a filter of length f"""
    xs = np.convolve(np.random.normal(0, 0.1, size=n), np.ones(f)/f).cumsum()
    ys = np.convolve(np.random.normal(0, 0.1, size=n), np.ones(f)/f).cumsum()
    xs += 0.1*np.sin(0.1*np.array(range(n-1+f))) # add wobble on x axis
    xs += np.random.normal(0, 0.005, size=n-1+f) # add measurement noise
    ys += np.random.normal(0, 0.005, size=n-1+f)
    return np.column_stack([xs, ys])

def random_cov():
    """Random covariance for use in generating 2D Gaussian distributions"""
    A = np.random.randn(2,2)
    return np.dot(A, A.T)

def time_series(T = 1, N = 100, mu = 0.1, sigma = 0.1, S0 = 20):  
    """Parameterized noisy time series"""
    dt = float(T)/N
    t = np.linspace(0, T, N)
    W = np.random.standard_normal(size = N) 
    W = np.cumsum(W)*np.sqrt(dt) # standard brownian motion
    X = (mu-0.5*sigma**2)*t + sigma*W 
    S = S0*np.exp(X) # geometric brownian motion
    return S

np.random.seed(1)
points = hv.Points(np.random.multivariate_normal((0,0), [[0.1, 0.1], [0.1, 1.0]], (1000,)),label="Points")
paths = hv.Path([random_walk(2000,30)], label="Paths")

points + paths

np.random.seed(1)
points = hv.Points(np.random.multivariate_normal((0,0), [[0.1, 0.1], [0.1, 1.0]], (1000000,)),label="Points")
paths = hv.Path([0.15*random_walk(100000) for i in range(10)],label="Paths")

#points + paths  ## Danger! Browsers can't handle 1 million points!

decimate(points) + datashade(points) + datashade(paths)

rasterize(points).hist() + shade(rasterize(points)) + datashade(points)

datashade(points) + dynspread(datashade(points))

datashade(paths) + dynspread(datashade(paths))

%%opts RGB [width=400] {+axiswise}

np.random.seed(3)
kdims=['d1','d2']
num_ks=8

def rand_gauss2d():
    return 100*np.random.multivariate_normal(np.random.randn(2), random_cov(), (100000,))

gaussians = {i: hv.Points(rand_gauss2d(), kdims) for i in range(num_ks)}
lines = {i: hv.Curve(time_series(N=10000, S0=200+np.random.rand())) for i in range(num_ks)}

gaussspread = dynspread(datashade(hv.NdOverlay(gaussians, kdims='k'), aggregator=ds.count_cat('k')))
linespread  = dynspread(datashade(hv.NdOverlay(lines,     kdims='k'), aggregator=ds.count_cat('k')))

gaussspread + linespread

%%opts RGB [width=600]

# definition copied here to ensure independent pan/zoom state for each dynamic plot
gaussspread = dynspread(datashade(hv.NdOverlay(gaussians, kdims=['k']), aggregator=ds.count_cat('k')))

from datashader.colors import Sets1to3 # default datashade() and shade() color cycle
color_key = list(enumerate(Sets1to3[0:num_ks]))
color_points = hv.NdOverlay({k: hv.Points([0,0], label=str(k)).options(color=v) for k, v in color_key})

color_points * gaussspread

%%opts RGB [width=300] {+axiswise}

datashade(hv.HoloMap(gaussians, kdims='k')) + datashade(hv.HoloMap(lines, 'k'))

%%opts RGB [width=800]
import pandas as pd
dates = pd.date_range(start="2014-01-01", end="2016-01-01", freq='1D') # or '1min'
curve = hv.Curve((dates, time_series(N=len(dates), sigma = 1)))
datashade(curve, cmap=["blue"])

%%opts Overlay [width=800] 
%%opts Scatter [tools=['hover', 'box_select']] (line_color="black" fill_color="red" size=10)
from holoviews.operation.timeseries import rolling, rolling_outlier_std
smoothed = rolling(curve, rolling_window=50)
outliers = rolling_outlier_std(curve, rolling_window=50, sigma=2)

datashade(curve, cmap=["blue"]) * dynspread(datashade(smoothed, cmap=["red"]),max_px=1) * outliers

%%opts QuadMesh [tools=['hover']] (alpha=0 hover_alpha=0.2)
from holoviews.streams import RangeXY

fixed_hover = datashade(points, width=400, height=400) * \
    hv.QuadMesh(rasterize(points, width=10, height=10, dynamic=False))

dynamic_hover = datashade(points, width=400, height=400) * \
    hv.util.Dynamic(rasterize(points, width=10, height=10, streams=[RangeXY]), operation=hv.QuadMesh)

fixed_hover + dynamic_hover

%%output backend='matplotlib'
%%opts Layout [vspace=0.1 hspace=0.1]
np.random.seed(12)
N=100
pts = [(10*i/N, np.sin(10*i/N)) for i in range(N)]

x = y = np.linspace(0, 5, int(np.sqrt(N)))
xs,ys = np.meshgrid(x,y)
z = np.sin(xs)*np.cos(ys)

r = 0.5*np.sin(0.1*xs**2+0.05*ys**2)+0.5
g = 0.5*np.sin(0.02*xs**2+0.2*ys**2)+0.5
b = 0.5*np.sin(0.02*xs**2+0.02*ys**2)+0.5

opts2 = dict(filled=True, edge_color_index='z')
tri = hv.TriMesh.from_vertices(hv.Points(np.random.randn(N,3), vdims='z')).options(**opts2)
(tri + tri.edgepaths + datashade(tri, aggregator=ds.mean('z')) + datashade(tri.edgepaths)).cols(2)

shadeable  = [elemtype(pts) for elemtype in [hv.Curve, hv.Scatter, hv.Points]]
shadeable += [hv.Path([pts])]
shadeable += [hv.Image((x,y,z)), hv.QuadMesh((x,y,z))]
shadeable += [hv.Graph(((np.zeros(N), np.arange(N)),))]
shadeable += [tri.edgepaths]
shadeable += [tri]
shadeable += [hv.operation.contours(hv.Image((x,y,z)), levels=10)]

rasterizable = [hv.RGB(np.dstack([r,g,b])), hv.HSV(np.dstack([g,b,r]))]

opts = dict(sublabel_format="", yaxis='bare', xaxis='bare', aspect=1, axiswise=True)

hv.Layout([dynspread(datashade(e.relabel(e.__class__.name)).options(**opts)) for e in shadeable] + 
          [          rasterize(e.relabel(e.__class__.name)).options(**opts)  for e in rasterizable]).cols(6)

%%output backend='matplotlib'
%%opts Layout [vspace=0.1 hspace=0.1]

hv.Layout([e.relabel(e.__class__.name).options(**opts) for e in shadeable + rasterizable]).cols(6)

%%output backend='matplotlib'
%%opts RGB [aspect=1 yaxis=None xaxis=None] TriMesh [filled=False]

curves = {'+':hv.Curve(pts),'-':hv.Curve([(x,-1.0*y) for x,y in pts])}

supported = [hv.HoloMap(curves,'sign'), hv.Overlay(list(curves.values())), hv.NdOverlay(curves), hv.GridSpace(hv.NdOverlay(curves))]
hv.Layout([datashade(e.relabel(e.__class__.name)) for e in supported]).cols(4)

dynspread(datashade(hv.NdLayout(curves,'sign')))