#----------------------------------------------------------------------
# Introduction to linear blending
#
# Copyright (C) November 10, 2017 -- Dr. William T. Verts
#----------------------------------------------------------------------

#----------------------------------------------------------------------
# Core blending function.  P0,P1 are the numeric values to blend,
# T is the "knob" to turn (all variables can be ints or floats,
# but a float result is always returned).  Returns P0 when T=0,
# returns P1 when T=1, can interpolate between P0 and P1 when 0<T<1.
#----------------------------------------------------------------------

def Blend (P0,P1,T):
    return (P1 - P0) * float(T) + P0

#----------------------------------------------------------------------
# First attempt at blending two 2D points.  Problem is that coordinates
# going in are simple numeric variables, but the result is a list that
# contains a pair.  This is not a consistent usage of variables.
#----------------------------------------------------------------------

def BlendPoints0 (X0,Y0,X1,Y1,T):
    X = Blend(X0,X1,T)
    Y = Blend(Y0,Y1,T)
    return [X,Y]

#----------------------------------------------------------------------
# Second attempt.  P0 and P1 are now both [X,Y] lists, the same as the
# return result.  This is perfectly adequate for 2D points.
#----------------------------------------------------------------------

def BlendPoints2D (P0,P1,T):
    X = Blend(P0[0],P1[0],T)
    Y = Blend(P0[1],P1[1],T)
    return [X,Y]

#----------------------------------------------------------------------
# Blending in 3D.  P0 and P1 are now both [X,Y,Z] lists, the same as
# the return result.  This is perfectly adequate for 3D points.
#----------------------------------------------------------------------

def BlendPoints3D (P0,P1,T):
    X = Blend(P0[0],P1[0],T)
    Y = Blend(P0[1],P1[1],T)
    Z = Blend(P0[2],P1[2],T)
    return [X,Y,Z]

#----------------------------------------------------------------------
# Blending in 4D.  P0 and P1 are now both [X,Y,Z,W] lists, the same as
# the return result.  This is perfectly adequate for 4D points.
#----------------------------------------------------------------------

def BlendPoints4D (P0,P1,T):
    X = Blend(P0[0],P1[0],T)
    Y = Blend(P0[1],P1[1],T)
    Z = Blend(P0[2],P1[2],T)
    W = Blend(P0[3],P1[3],T)
    return [X,Y,Z,W]

#----------------------------------------------------------------------
# By recognizing that the actions are the same for each dimension,
# we can write a single function that handles blending of points in
# any number of dimensions.  The only constraint is that the points
# **must** have the same dimension (that is, the lengths of the lists
# are the same), or else the result will have the smallest dimension
# of the two points.
#----------------------------------------------------------------------

def BlendPoints1 (P0,P1,T):
    Result = []
    for I in range(min(len(P0),len(P1))):
        Value = Blend(P0[I],P1[I],T)
        Result = Result + [Value]
    return Result
    
#----------------------------------------------------------------------
# Finally, the general form can be rewritten to use a list
# comprehension to accomplish the same thing.  This is the final form.
#----------------------------------------------------------------------
        
def BlendPoints (P0,P1,T):
    return [Blend(P0[I],P1[I],T) for I in range(min(len(P0),len(P1)))]