Visualization Notes

Friday, March 29, 2024

📑 Histograms with Colors by Values

Histograms with Colors by Values

xxxxxxxxxx
 
dist = RealDistribution('gaussian', 1)
data = [dist.get_random_element() for _ in range(1000)]
n, x, y = 30, [], []
sdata = sorted(data)
dx = (sdata[-1] - sdata[0])/n
x = [[sdata[0]+dx*i, sdata[0]+dx*(i+1)] for i in range(n)]
i, c = 0, 0
while i < n - 1:
    if sdata[0] > x[i+1][1]: y.append(0); i += 1; c = 0
    elif sdata[0] > x[i][1]: y.append(c); i += 1; c = 0
    else: sdata = sdata[1:]; c += 1
y.append(1000-sum(y))
col = lambda i, y: colormaps.RdBu(int(255*y[i]/max(y)))[:3]
g = Graphics(); p = .02
for i in range(n):
    g += polygon([[x[i][0]+p, 0], [x[i][0]+p, y[i]], 
                  [x[i][1]-p, y[i]], [x[i][1]-p, 0]], 
                 color=col(i,y), aspect_ratio=.05, frame=True)
save(g, "SagePlots.png")
show(g)

xxxxxxxxxx
 
%%r
data <- rnorm(1000)
n <- 30
h <- hist(data, breaks=n, plot=FALSE)
pal <- colorRamp(c("midnightblue", "steelblue", "bisque", "firebrick"))
fcol <- function(x) {rgb(pal((x - min(x)) / diff(range(x))), max=255)}
fn<-'Rplots.png'
png(fn, pointsize=12, bg='whitesmoke')
plot(h, col=fcol(h$density))
dev.off()

xxxxxxxxxx
 
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap
data = np.random.randn(1000)
n = 30
hist, bins = np.histogram(data, bins=n, density=True)
colors = ['midnightblue', 'steelblue', 'bisque', 'firebrick']
cmap = LinearSegmentedColormap.from_list('custom_cmap', colors)
plt.bar(bins[:-1], hist, width=np.diff(bins)*.9,
        color=cmap((hist-hist.min())/(hist.max()-hist.min())))
plt.savefig('PythonPlots.png')
plt.show()

Thursday, January 4, 2024

📑ASCII Art

ASCII Art

xxxxxxxxxx
 
s = ['x', '.', '=', '-', '\\', '(', ')', '8', "'", '_', 
     '/', '"', ':', '#', 'q', 'p', '|', '=', 'o', '0']
c = [[255, 255, 255], [255, 71, 0], [255, 148, 0], [255, 224, 0],
     [209, 255, 0], [132, 255, 0], [61, 255, 0], [0, 255, 16],
     [0, 255, 92], [0, 255, 169], [0, 255, 246], [0, 193, 255],
     [0, 116, 255], [0, 40, 255], [37, 0, 255], [114, 0, 255],
     [185, 0, 255], [252, 0, 245], [255, 0, 172], [255, 0, 95]]
def rgb_str(rgb, a): 
    return "<b style='color:rgb("+str(rgb)[1:-1]+");'>"+a+"</"+"b>"
row01 = s[1]+2*s[2]+s[3]+s[1]+9*s[0]
row01 = row01+s[0]+row01[::-1]
row02 = s[0]+s[4]+s[5]+s[6]+s[7]+s[8]+s[3]+s[1]+s[9]+2*s[0]+s[8]+5*s[0]
row02 += s[8]+2*s[0]+s[9]+s[1]+s[3]+s[8]+s[7]+s[5]+s[6]+s[10]+s[0]
row03 = s[0]+s[5]+2*s[7]+s[11]+3*s[0]+2*s[12]+s[1]+2*s[0]+s[4]+s[1]
row03 += s[10]+2*s[0]+s[1]+2*s[12]+3*s[0]+s[11]+2*s[7]+s[6]+s[0]
row04 = 2*s[0]+s[4]+s[9]+s[1]+2*s[8]+s[3]+4*s[12]+s[1]+s[5]+s[13]
row04 += s[6]+s[1]+4*s[12]+s[3]+2*s[8]+s[1]+s[9]+s[10]+2*s[0]
row05 = 4*s[0]+s[8]+s[1]+s[9]+3*s[1]+s[0]+s[1]+s[14]+s[5]+s[9]
row05 += s[6]+s[15]+s[1]+s[0]+3*s[1]+s[9]+s[1]+s[8]+4*s[0]
row06 = 6*s[0]+2*s[11]+s[3]+2*s[1]+s[3]+s[8]+s[16]+s[17]
row06 += s[16]+s[8]+s[3]+2*s[1]+s[3]+2*s[11]+6*s[0]
row07 = 6*s[0]+s[1]+2*s[11]+s[8]+s[0]+s[1]+s[8]+s[16]+s[17]
row07 += s[16]+s[8]+s[1]+s[0]+s[8]+2*s[11]+s[1]+6*s[0]
row08 = 4*s[0]+s[1]+s[8]+s[12]+s[7]+s[5]+s[18]+s[6]+s[1]+s[10]+s[16]+s[17]
row08 += s[16]+s[4]+s[1]+s[5]+s[18]+s[6]+s[7]+s[12]+s[8]+s[1]+4*s[0]
row09 = 3*s[0]+s[5]+s[19]+s[0]+s[12]+s[7]+s[0]+2*s[12]+s[10]+s[0]+s[4]+s[9]
row09 += s[10]+s[0]+s[4]+2*s[12]+s[0]+s[7]+s[12]+s[0]+s[19]+s[6]+3*s[0]
row10 = 4*s[0]+s[4]+s[19]+s[0]+s[8]+2*s[12]+s[10]+7*s[0]
row10 += s[4]+2*s[12]+s[8]+s[0]+s[19]+s[10]+4*s[0]
row11 = 5*s[0]+2*s[11]+2*s[9]+s[8]+9*s[0]+s[8]+2*s[9]+2*s[11]+5*s[0]
for row in [row01, row02, row03, row04, row05, row06, 
            row07, row08, row09, row10, row11]:
    r = '<div style="font-family:courier;">'
    for symbol in row: 
        r += rgb_str(c[s.index(symbol)], symbol)
    display(html(r+"</"+"div>"))

Saturday, November 25, 2023

📑 Fun Random Selection of Students in the Class

Fun Random Selection of Students in the Class

Which pupil should go to the board?

xxxxxxxxxx
 
import numpy as np, time
def random_coords(class_list):
    idx = randint(1, len(class_list))
    n = ceil(sqrt(len(class_list)))
    y = (idx - 1) % n
    x = (idx - 1) // n
    return x, y, idx
def maplot(arr, st, n):
    m = matrix(arr.tolist())
    m.subdivide(list(range(1, n)), list(range(1, n)))
    mp = matrix_plot(
        m, figsize=(n, n), cmap='bone', frame=False, title=st, 
        subdivisions=True, subdivision_style=dict(color='steelblue'))
    return mp
def class_id(idx, class_list): 
    if 0 < idx < len(class_list) + 1:
        return str((idx, class_list[idx - 1])) 
    else: 
        return str((idx, 'unknown'))
class_list = ["Emily Johnson", "James Smith", "Hannah Brown", "William Davis", 
              "Olivia Wilson", "Benjamin Taylor", "Ava Martinez", 
              "Ethan Garcia", "Sophia Rodriguez", "Daniel Hernandez", 
              "Mia Lee", "Alexander Perez", "Chloe Jackson", 
              "Samuel Martin", "Isabella Anderson", "Jacob Thompson", 
              "Charlotte White", "Michael Clark", "Grace Lewis", 
              "Joseph Wright", "Lily Robinson", "David Baker"]
n, c = ceil(sqrt(len(class_list))), 0
targets = list(range(1, len(class_list) + 1))
arr = np.array(n * [n * [.1]])
mps = [maplot(arr, class_id(0, class_list), n)]
for idx in range(len(class_list) + 1, n ** 2 + 1) :
    arr[(idx - 1) // n][(idx - 1) % n] = .3
    mps += [maplot(arr,  class_id(idx, class_list), n)]
while len(targets) > 1:
    x, y, idx = random_coords(class_list)
    arr[x][y] = .3
    if idx in targets:
        targets.remove(idx)
    mps += [maplot(arr,  class_id(idx, class_list), n)]
    c += 1
animate(mps).show(delay=100)
time.sleep(c + 30)
pretty_print(html('%d random (x,y)' % c))
pretty_print(html(class_list[targets[0] - 1]))

Saturday, May 27, 2023

📑 AGG filtering

Anti-Grain Geometry (AGG) & Matplotlib Artists

xxxxxxxxxx
 
import numpy as np,pandas as pd,pylab as pl
import matplotlib.transforms as mtrans
from matplotlib.colors import LightSource
from matplotlib.artist import Artist
from matplotlib.patheffects import Normal
def smooth(data,sigma=3):
    def smooth1d(x,window_len): 
        s=np.r_[2*x[0]-x[window_len:1:-1],x,2*x[-1]-x[-1:-window_len:-1]]
        w=np.hanning(window_len)
        y=np.convolve(w/w.sum(),s,mode='same')
        return y[window_len-1:-window_len+1]
    def smooth2d(X,window_len):
        for axis in (0,1):
            X=np.apply_along_axis(smooth1d,axis,X,window_len) 
        return X
    window_len=max(int(sigma),3)*2+1
    if len(data.shape)==1:
        y=smooth1d(data,window_len)
    elif len(data.shape)==2:
        y=smooth2d(data,window_len)
    else:
        raise ValueError(f"Data must have 1 or 2 dimensions, "+\
                         f"but has {len(data.shape)} dimensions instead.")
    return y

xxxxxxxxxx
 
class BaseFilter:
    def get_pad(self,dpi):
        return 0
    def process_image(self,padded_src,dpi):
        raise NotImplementedError("Should be overridden by subclasses")
    def __call__(self,img,dpi):
        pad=self.get_pad(dpi)
        padded_img=np.pad(img,[(pad,pad),(pad,pad),(0,0)],"constant")
        return self.process_image(padded_img,dpi),-pad,-pad
class OffsetFilter(BaseFilter):
    def __init__(self,offsets=(0,0)):
        self.offsets=offsets
    def get_pad(self,dpi):
        return int(max(self.offsets)/72*dpi)
    def process_image(self,padded_img,dpi):
        ox,oy=self.offsets
        a1=np.roll(padded_img,int(ox/72*dpi),axis=1)
        a2=np.roll(a1,-int(oy/72*dpi),axis=0)
        return a2
class GaussianFilter(BaseFilter):
    def __init__(self,sigma,alpha=.5,color=(0,0,0)):
        self.sigma=sigma
        self.alpha=alpha
        self.color=color
    def get_pad(self, dpi):
        return int(self.sigma*3/72*dpi)
    def process_image(self,padded_img,dpi):
        img=np.empty_like(padded_img)
        img[:,:,:3]=self.color
        img[:,:,3] = smooth(padded_img[:,:,3]*self.alpha,self.sigma/72*dpi)
        return img

xxxxxxxxxx
 
class DropShadowFilter(BaseFilter):
    def __init__(self,sigma,alpha=.3,color=(0,0,0),offsets=(0,0)):
        self.gauss_filter=GaussianFilter(sigma,alpha,color)
        self.offset_filter=OffsetFilter(offsets)
    def get_pad(self,dpi):
        return max(self.gauss_filter.get_pad(dpi),self.offset_filter.get_pad(dpi))
    def process_image(self,padded_img,dpi):
        t1=self.gauss_filter.process_image(padded_img,dpi)
        t2=self.offset_filter.process_image(t1,dpi)
        return t2
class LightFilter(BaseFilter):
    def __init__(self,sigma,fraction=1):
        self.gauss_filter=GaussianFilter(sigma,alpha=1)
        self.light_source=LightSource()
        self.fraction=fraction
    def get_pad(self,dpi):
        return self.gauss_filter.get_pad(dpi)
    def process_image(self,padded_img,dpi):
        t1=self.gauss_filter.process_image(padded_img,dpi)
        elevation=t1[:,:,3]
        rgb=padded_img[:,:,:3]
        alpha=padded_img[:,:,3:]
        rgb2=self.light_source.shade_rgb(
            rgb,elevation,fraction=self.fraction,blend_mode="overlay")
        return np.concatenate([rgb2,alpha],-1)
class GrowFilter(BaseFilter):
    def __init__(self,pixels,color=(1,1,1)):
        self.pixels=pixels
        self.color=color
    def __call__(self,img,dpi):
        alpha=np.pad(img[...,3],self.pixels,"constant")
        alpha2=np.clip(smooth(alpha,self.pixels/72*dpi)*5,0,1)
        new_img=np.empty((*alpha2.shape,4))
        new_img[:,:,:3]=self.color
        new_img[:,:,3]=alpha2
        offsetx,offsety=-self.pixels,-self.pixels
        return new_img,offsetx,offsety
class FilteredArtistList(Artist):
    def __init__(self,artist_list,filter):
        super().__init__()
        self._artist_list =artist_list
        self._filter=filter
    def draw(self,renderer):
        renderer.start_rasterizing()
        renderer.start_filter()
        for a in self._artist_list:
            a.draw(renderer)
        renderer.stop_filter(self._filter)
        renderer.stop_rasterizing()

xxxxxxxxxx
 
def create_data(xmin,xmax,ymin,ymax,delta):
    x=np.arange(xmin,xmax,delta)
    y=np.arange(ymin,ymax,delta)
    X,Y=np.meshgrid(x,y)
    Z1=np.exp(-X**2-Y**2)
    Z2=np.exp(-(X-1)**2-(Y-1)**2)
    return Z1-Z2
def filtered_text(ax,xmin=-2.5,xmax=3,ymin=-2.5,ymax=3,delta=.025):
    Z=create_data(xmin=xmin,xmax=xmax,ymin=ymin,ymax=ymax,delta=delta)
    ax.imshow(Z,interpolation='bilinear',origin='lower',cmap=pl.cm.bwr,
              extent=(xmin,xmax,ymin,ymax),aspect='auto')
    levels=np.arange(np.min(Z),np.max(Z),.1)
    CS=ax.contour(Z,levels,origin='lower',linewidths=2,
                  extent=(xmin,xmax,ymin,ymax),cmap=pl.cm.bwr_r)
    cl=ax.clabel(CS,levels[1::2],inline=True,fmt='%1.1f',fontsize=12)
    for t in cl:
        t.set_color("k"); t.set_path_effects([Normal()])
    white_glows=FilteredArtistList(cl,GrowFilter(5))
    ax.add_artist(white_glows)
    white_glows.set_zorder(cl[0].get_zorder()-.1)
def drop_shadow_patches(
    ax,group1,group2,colors=['#3636ff','#ff3636'],edge_color='whitesmoke'):
    n=len(group1)
    width=.35  
    rects1=ax.bar(
        np.arange(n),group1,width,color=colors[0],ec=edge_color,lw=2)
    rects2=ax.bar(
        np.arange(n)+width+.1,group2,width,color=colors[1],ec=edge_color,lw=2)
    drop=DropShadowFilter(9,offsets=(1,1))
    shadow=FilteredArtistList(rects1+rects2,drop)
    ax.add_artist(shadow)
    shadow.set_zorder(rects1[0].get_zorder()-.1)
    ax.set_ylim(0,1.2*max(group1+group2))
    ax.xaxis.set_visible(False)
fix,axs=pl.subplots(1,2,figsize=(6.7,4))
drop_shadow_patches(axs[0],[.1,.35,.17,.28,.53],[.15,.42,.34,.41,.25])
filtered_text(axs[1]); pl.show()

Sunday, May 21, 2023

📑 Farewell Round A 2023 Task 5 Untie

Farewell Round A 2023. Task 5

Python Only


T=int(input())
for t in range(T):
    C=input()
    if len(set(C))==1:
        count=len(C)//2+len(C)%2
    else:
        while C[0]==C[-1]:
            C=C[1:]+C[0]
        count=C.count('PP')+C.count('SS')+C.count('RR')
    print('Case #{}: {}'.format((t+1),count))

xxxxxxxxxx
 
@interact
def untie(
    T=selector([1,2,3],default=1,label='$\\mathbb{T}$'),
    CL=input_box('PRSSP\nRRRRRRR\nRSPRPSPRS',type=str,
                 label='$\\mathbb{XL}$',width=10,height=3)):
    C=str(CL).split('\n')[T-1]
    pretty_print([T,C])
    if len(set(C))==1:
        count=len(C)//2+len(C)%2
    else:
        while C[0]==C[-1]:
            C=C[1:]+C[0]
        count=C.count('PP')+C.count('SS')+C.count('RR')
    pretty_print('Case #{}: {}'.format(T,count))