Visualization Notes: 2023

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))

📑 Farewell Round A 2023 Task 4 ASCII Art

Farewell Round A 2023. Task 4

Python Only


# Competition Variant 1 (All Points)
letters='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def count26down(number):
    diff1,i,j=number,1,0
    while number>0:
        diff1=number; k1=i
        number-=i*26; i+=1
    while diff1>0:
        diff2=diff1; k2=j
        diff1-=k1; j+=1
    return k2
T=int(input())
for t in range(T):
    N=int(input())
    L=letters[count26down(N)]
    print('Case #{}: {}'.format((t+1),L))

xxxxxxxxxx
 
letters='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def count26down(number):
    diff1,i,j=number,1,0
    while number>0:
        diff1=number; k1=i
        number-=i*26; i+=1
    while diff1>0:
        diff2=diff1; k2=j
        diff1-=k1; j+=1
    return k2
@interact
def ascii_art(
    T=selector([1,2,3],default=1,label='$\\mathbb{T}$'),
    NL=input_box('5 31 1001',type=str,
                 label='$\\mathbb{N}$',width=10)):
    N=int(str(NL).split()[T-1])
    L=letters[count26down(N)]
    pretty_print('Case #{}: {}'.format(T,L))

Saturday, May 20, 2023

📑 Farewell Round A 2023 Task 3 Rainbow Sort

Farewell Round A 2023. Task 3

Python Only


# Competition Variant 1 (All Points)
T=int(input())
for t in range(T):
    N=int(input())
    cards=input().split()
    cards_set=set()
    result=[]
    for i in range(N):
        if cards[i] not in cards_set:
            cards_set.update([cards[i]])
            result.append(cards[i])
        elif result[-1]!=cards[i]:
            result='IMPOSSIBLE'
            break
 #       print(i,result)
    if result!='IMPOSSIBLE': result=' '.join(result)
    print('Case #{}: {}'.format((t+1),result))

xxxxxxxxxx
 
@interact
def rainbow_sort(
    T=selector([1,2],default=1,label='$\\mathbb{T}$'),
    NL=input_box('4 5',type=str,label='$\\mathbb{N}$',width=10),
    CL=input_box('3 8 8 2\n3 8 2 2 8',type=str,
                 label='$\\mathbb{cards}$',width=10,height=3)):
    N=int(str(NL).split()[T-1])
    cards=(str(CL).split('\n')[T-1]).split()
    pretty_print([T,N,cards])
    cards_set=set()
    result=[]
    for i in range(N):
        if cards[i] not in cards_set:
            cards_set.update([cards[i]])
            result.append(cards[i])
        elif result[-1]!=cards[i]:
            result='IMPOSSIBLE'
            break
    if result!='IMPOSSIBLE': result=' '.join(result)
    pretty_print('Case #{}: {}'.format(T,result))

Saturday, April 29, 2023

📑 Farewell Round A 2023 Task 2 Illumination Optimization

Farewell Round A 2023. Task 2

Python Only


def update(i,start,end,radius,condition,answer):
    while (i < N):
        if X[i]-start > radius: break
        else: end=X[i]
        i+=1
    if end!=condition: 
        answer+=[end]
        start=end
    else:
        answer=[]
    return i,start,end,answer
T=int(input())
for t in range(T):
    [M,R,N]=list(map(int,input().split()))
    X=list(map(int,input().split()))
    i,start,end,answer=0,0,-1,[]
    i,start,end,answer=update(i,start,end,R,-1,answer)
    while ((i < N) and (answer!=[]) and (end+R < M)):
        i,start,end,answer=update(i,start,end,2*R,start,answer)
    if M-end > R: answer=[]
    if answer!=[]:
        print('Case #{}: {}'.format((t+1),len(answer)))
    else: 
        print('Case #{}: IMPOSSIBLE'.format(t+1))

xxxxxxxxxx
 
@interact
def illumination_optimization(
    T=selector([1,2,3],default=1,label='$\\mathbb{T}$'),
    MRN=input_box('10 3 3\n10 2 3\n10 2 4',type=str,
                  label='$\\mathbb{MRN}$',width=10,height=3),
    XL=input_box('2 7 9\n2 7 9\n2 3 7 9',type=str,
                 label='$\\mathbb{XL}$',width=10,height=3)):
    [M,R,N]=list(map(int,(str(MRN).split('\n')[T-1]).split()))
    X=list(map(int,(str(XL).split('\n')[T-1]).split()))
    pretty_print([T,M,R,N,X])
    
    def update(i,start,end,radius,condition,answer,N=N,X=X):
        while (i < N):
            if X[i]-start > radius: break
            else: end=X[i]
            i+=1
        if end!=condition: 
            answer+=[end]
            start=end
        else:
            answer=[]
        return i,start,end,answer   
    
    i,start,end,answer=0,0,-1,[]
    i,start,end,answer=update(i,start,end,R,-1,answer)
    while ((i < N) and (answer!=[]) and (end+R < M)):
        i,start,end,answer=update(i,start,end,2*R,start,answer)
    if M-end > R: answer=[]
    if answer!=[]:
        pretty_print('Case #{}: {}'.format((T),len(answer)))
    else: 
        pretty_print('Case #{}: IMPOSSIBLE'.format(T))

📑 Farewell Round A 2023 Task 1 Colliding Encoding

Farewell Round A 2023. Task 1

Python Only


T=int(input())
letters='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
for t in range(T):
    D=input().replace(' ','')
    N=int(input())
    numbers=set()
    words=set()
    for i in range(N):
        w=input()
        words.update([w])
        n=''.join([D[letters.find(s)] for s in w])
        numbers.update([n])
    if len(numbers) < len(words):
        print('Case #{}: YES'.format(t+1))
    else:
        print('Case #{}: NO'.format(t+1))

xxxxxxxxxx
 
@interact
def colliding_encoding(
    T=selector([1,2],default=1,label='$\\mathbb{T}$'),
    D=input_box('0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3\n'+\
                '0 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3',
                type=str,label='$\\mathbb{D}$',width=50,height=3),
    N=input_box('4|3',type=str,label='$\\mathbb{N}$',width=50),
    W=input_box('ABC BC BCD CDE|CDE DEF EFG',
                type=str,label='$\\mathbb{W}$',width=50)):
    letters='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    numbers=set(); words=set()
    DS=str(D).split('\n')[T-1]
    DS=DS.replace(' ','')
    N=int(str(N).split('|')[T-1])
    WS=(str(W).split('|')[T-1]).split()
    pretty_print([T,DS,N,WS])
    for i in range(N):
        w=WS[i]
        words.update([w])
        n=''.join([DS[letters.find(s)] for s in w])
        numbers.update([n])
    if len(numbers) < len(words):
        pretty_print('Case #{}: YES'.format(T))
    else:
        pretty_print('Case #{}: NO'.format(T))

Monday, March 13, 2023

SageMathCell Text Coloring

Text Coloring

xxxxxxxxxx
 
import numpy as np,random,functools
from IPython.display import display,HTML
def coloring(f):
    @functools.wraps(f)
    def wrapped(*args, **kwargs):
        link = f"""<style>
        @import 'https://fonts.googleapis.com/css?family=Roboto';
        </style>"""
        col=(f"color:#{random.randint(0,0xAAAAFF):06x};" 
             for i in range(len(args)))
        font='font-size:16px; font-family:Roboto;'
        return f(*(HTML(link+f"<p style='{next(col)} {font}'>{a}</p>")
                   for i,a in enumerate(args)), **kwargs)
    return wrapped
@coloring
def print(*args, **kwargs):
    return display(*args, **kwargs)
print('hello','hi','hey','hiya','ahoy')