nox filter - and multiplex (2d, 3d)

[zeffii]

"""
in verts_in v
in floats_in s
in order s d=3 n=2
out verts_out v
out floats_out s
"""

def process_component(data, order):

    order = order // 2

    fdata = []
    add = fdata.append

    # add first n
    for i in range(order+1):
        if i == 0:
            B = data[0]
        else:
            data_to_avg = data[0:i+(order+1)]
            num_items = len(data_to_avg)
            add(sum(data_to_avg)/num_items)

    # add middle n
    for i in range(order, len(data)-order):
        fk1 = data[i-order:i]
        fk2 = data[i:i+order]
        cr1 = sum(fk1) / order
        cr2 = sum(fk2) / order
        add((cr1 + cr2) / 2 )

    # add last n
    for i in range(order):
        if i == -1:
            add(data[-1])
        else:
            a = len(data)-order
            data_to_avg = data[a-(order-i):]
            num_items = len(data_to_avg)
            add(sum(data_to_avg)/num_items)                
    
    return fdata
    
def multiplexed(data, order):
    d0 = process_component([d[0] for d in data], order)
    d1 = process_component([d[1] for d in data], order)
    d2 = process_component([d[2] for d in data], order)
    return [tuple(d) for d in zip(d0, d1, d2)]



def nox_filter(data, order=2):
    """
    - order >= 2
    - data has two modes, vectors and numbers
    """
    
    if not len(data) or order in {0, 1}:
        pass
    elif isinstance(data[0], (list, tuple)) and len(data[0]) == 3:
        return multiplexed(data, order)
    elif isinstance(data[0], (float, int)):
        return process_component(data, order)
    return data


order = min(order, 40)

if verts_in:
    for val_list in verts_in:
        verts_out.append(nox_filter(val_list, order))
    
if floats_in:
    for val_list in floats_in:
        floats_out.append(nox_filter(val_list, order))