#----------------------------------------------------------------------
# Linear Blending between two points in space
#
# Copyright (C) April 11, 2018 -- Dr. William T. Verts
#----------------------------------------------------------------------

#----------------------------------------------------------------------
# Function to blend between two numeric values.  P0, P1, and T may
# all be either ints or floats.  The return value is a float.
# The value is somewhere between P0 and P1 based on T.  If T=0 then
# the return value is P0 and if T=1 the return value is P1.
# If 0<T<1 the value returned is on the line between P0 and P1.
#----------------------------------------------------------------------

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

#----------------------------------------------------------------------
# Blend between points P0 and P1, where both P0 and P1 are lists of
# numeric values.  For two dimensions, P0 and P1 are [X,Y] lists.
# For three dimensions, P0 and P1 are [X,Y,Z] lists.
# For four dimensions, P0 and P1 are [X,Y,Z,W] lists.
# Blending between the points means that each dimension needs to
# be blended separately
#----------------------------------------------------------------------

def BlendPoints2D(P0,P1,T):                # P0,P1 are [X,Y], T is int/float
    X = Blend(P0[0], P1[0], T)
    Y = Blend(P0[1], P1[1], T)
    return [X,Y]                           # Returns a list of floats

        
def BlendPoints3D(P0,P1,T):                # P0,P1 are [X,Y,Z], T is int/float
    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]                         # Returns a list of floats

        
def BlendPoints4D(P0,P1,T):                # P0,P1 are [X,Y,Z,W], T is int/float
    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]                       # Returns a list of floats
    
#----------------------------------------------------------------------
# Unfortunately, the functions above are specific to a certain number
# of dimensions.  We would like to have one function that can handle
# any number of dimensions, even if P0 and P1 have a *different* number
# of dimensions.  Here is the first attempt.
#----------------------------------------------------------------------

def BlendPoints2(P0,P1,T):                    # P0,P1 are points of arbitrary dimension, T is int/float
    Limit  = min(len(P0),len(P1))             # Pick the smaller number of dimensions
    Count  = 0                                # Count through the dimensions
    Result = []                               # Start with an empty result list
    while (Count < Limit):                    # More dimensions to process?
        Value  = Blend(P0[Count],P1[Count],T) # Blend the current dimension
        Result = Result + [Value]             # Add the value to the end of the result list
        Count  = Count + 1                    # Go to the next dimension
    return Result                             # Return the result list [X,Y,...]
    
#----------------------------------------------------------------------
# First optimization: replace the while-loop with a for-loop
#----------------------------------------------------------------------

def BlendPoints3(P0,P1,T):                    # P0,P1 are points of arbitrary dimension, T is int/float
    Limit  = min(len(P0),len(P1))
    Result = []
    for Count in range(Limit):
        Value  = Blend(P0[Count],P1[Count],T)
        Result = Result + [Value]
    return Result
    
#----------------------------------------------------------------------
# Next optimization: pack down single-use variables
#----------------------------------------------------------------------
    
def BlendPoints4(P0,P1,T):                    # P0,P1 are points of arbitrary dimension, T is int/float
    Result = []
    for Count in range(min(len(P0),len(P1))): Result = Result + [Blend(P0[Count],P1[Count],T)]
    return Result
    
#----------------------------------------------------------------------
# Final optimization: Refactor into a list comprehension.
# Also, use default parameter value for T so that if T is omitted,
# the result is the average of P0 and P1.
#----------------------------------------------------------------------

def BlendPoints(P0,P1,T=0.5):                 # P0,P1 are points of arbitrary dimension, T is int/float
    return [Blend(P0[Count],P1[Count],T) for Count in range(min(len(P0),len(P1)))]