def gen_bline_outline(lottie, bline_point):
"""
Generates the bline corresponding to outline layer by adding some vertices
to bline and converting it to region layer
Some parts are common with gen_bline_shapePropKeyframe(), which will be
placed in a common function latter
Args:
lottie (dict) : Lottie format outline layer will be stored in this
bline_point (common.Param.Param) : Synfig format bline points
Returns:
(None)
"""
################### SECTION 1 #########################
# Inserting waypoints if not animated and finding the first and last frame
window = {}
window["first"] = sys.maxsize
window["last"] = -1
bline = Bline(bline_point[0], bline_point)
for entry in bline.get_entry_list():
pos = entry["point"]
origin = entry["origin"]
width = entry["width"]
t1 = entry["t1"]
t2 = entry["t2"]
split_r = entry["split_radius"]
split_a = entry["split_angle"]
pos.update_frame_window(window)
# Empty the pos and fill in the new animated pos
pos.animate("vector")
origin.update_frame_window(window)
origin.animate("real")
width.update_frame_window(window)
width.animate("real")
split_r.update_frame_window(window)
split_r.animate_without_path("bool")
split_a.update_frame_window(window)
split_a.animate_without_path("bool")
animate_tangents(t1, window)
animate_tangents(t2, window)
# Open up the window if bline points are animated
entry["ActivepointList"].update_frame_window(window)
layer = bline.get_layer().get_layer()
outer_width = layer.get_param("width")
sharp_cusps = layer.get_param("sharp_cusps")
expand = layer.get_param("expand")
r_tip0 = layer.get_param("round_tip[0]")
r_tip1 = layer.get_param("round_tip[1]")
homo_width = layer.get_param("homogeneous_width")
origin = layer.get_param("origin")
# Animating the origin
origin.update_frame_window(window)
origin.animate("vector")
# Animating the outer width
outer_width.update_frame_window(window)
outer_width.animate("real")
# Animating the sharp_cusps
sharp_cusps.update_frame_window(window)
sharp_cusps.animate_without_path("bool")
# Animating the expand param
expand.update_frame_window(window)
expand.animate("real")
# Animating the round tip 0
r_tip0.update_frame_window(window)
r_tip0.animate_without_path("bool")
# Animating the round tip 1
r_tip1.update_frame_window(window)
r_tip1.animate_without_path("bool")
# Animating the homogeneous width
homo_width.update_frame_window(window)
homo_width.animate_without_path("bool")
# Minimizing the window size
if window["first"] == sys.maxsize and window["last"] == -1:
window["first"] = window["last"] = 0
################# END OF SECTION 1 ###################
################ SECTION 2 ###########################
# Generating values for all the frames in the window
lottie_st_list, lottie_en_list = [], []
fr = window["first"]
while fr <= window["last"]:
st_val, en_val = insert_dict_at(lottie, -1, fr, False) # This loop needs to be considered somewhere down
lottie_st_list.append(st_val)
lottie_en_list.append(en_val)
synfig_outline(bline, st_val, origin, outer_width, sharp_cusps, expand, r_tip0, r_tip1, homo_width, fr)
synfig_outline(bline, en_val, origin, outer_width, sharp_cusps, expand, r_tip0, r_tip1, homo_width, fr + 1)
fr += 1
equalize_length(lottie_st_list, lottie_en_list)
# Setting the final time
lottie.append({})
lottie[-1]["t"] = fr
def gen_bline_outline_constant(lottie, bline_point, layer, transformation, idx):
"""
"""
index = Count()
lottie["ty"] = "gr"
lottie["nm"] = "Shape "+ str(idx)
lottie["np"] = 3
lottie["cix"] = 2
lottie["bm"] = 0
lottie["ix"] = idx
lottie["mn"] = "ADBE Vector Group " +str(idx)
lottie["hd"] = "false"
lottie["it"] = []
lottie["it"].append({})
lottie["it"].append({})
lottie["it"].append({})
bline = Bline(bline_point[0], bline_point)
#Creating transformation dictionary
lottie["it"][2]["ty"] = "tr"
lottie["it"][2]["nm"] = "Transform"
lottie["it"][2].update(transformation)
#Creating stroke dictionary
lottie["it"][1]["ty"] = "st"
lottie["it"][1]["lc"] = 2
lottie["it"][1]["lj"] = 1
lottie["it"][1]["ml"] = 37
lottie["it"][1]["bm"] = 0
lottie["it"][1]["nm"] = "Stroke " + str(idx)
lottie["it"][1]["mn"] = "ADBE Vector Graphic - Stroke " +str(idx)
lottie["it"][1]["hd"] = "false"
lottie["it"][1]["c"] = {}
lottie["it"][1]["o"] = {}
lottie["it"][1]["w"] = {}
#Color
color = layer.get_param("color").get()
is_animate = is_animated(color[0])
if is_animate == settings.ANIMATED:
gen_value_Keyframed(lottie["it"][1]["c"], color[0], index.inc())
else:
if is_animate == settings.NOT_ANIMATED:
val = color[0]
else:
val = color[0][0][0]
red = float(val[0].text)
green = float(val[1].text)
blue = float(val[2].text)
red, green, blue = red ** (1/settings.GAMMA[0]), green ** (1/settings.GAMMA[1]), blue ** (1/ settings.GAMMA[2])
alpha = float(val[3].text)
gen_properties_value(lottie["it"][1]["c"],
[red, green, blue, alpha],
index.inc(),
settings.DEFAULT_ANIMATED,
settings.NO_INFO)
#Opacity
opacity = layer.get_param("amount")
opacity.animate("opacity")
opacity.fill_path(lottie["it"][1],"o")
#Constant width
loop = bline.get_loop()
width = layer.get_param("width")
width.scale_convert_link(1)
width.animate("real")
width.fill_path(lottie["it"][1],"w")
#Creating shape dictionary
lottie["it"][0]["ind"] = 0
lottie["it"][0]["ty"] = "sh"
lottie["it"][0]["ix"] = 1
lottie["it"][0]["ks"] = {}
lottie["it"][0]["nm"] = "Path 1"
lottie["it"][0]["mn"] = "ADBE Vector Shape - Group"
lottie["it"][0]["hd"] = "false"
lottie["it"][0]["ks"]["a"] = 1
lottie["it"][0]["ks"]["ix"] = lottie["it"][0]["ix"] + 1
lottie["it"][0]["ks"]["k"] = []
window = {}
window["first"] = sys.maxsize
window["last"] = -1
for entry in bline.get_entry_list():
pos = entry["point"]
width = entry["width"]
t1 = entry["t1"]
t2 = entry["t2"]
split_r = entry["split_radius"]
split_a = entry["split_angle"]
pos.update_frame_window(window)
# Empty the pos and fill in the new animated pos
pos.animate("vector")
width.update_frame_window(window)
width.animate("real")
split_r.update_frame_window(window)
split_r.animate_without_path("bool")
split_a.update_frame_window(window)
split_a.animate_without_path("bool")
animate_tangents(t1, window)
animate_tangents(t2, window)
outer_width = layer.get_param("width")
sharp_cusps = layer.get_param("sharp_cusps")
expand = layer.get_param("expand")
r_tip0 = layer.get_param("round_tip[0]")
r_tip1 = layer.get_param("round_tip[1]")
homo_width = layer.get_param("homogeneous_width")
origin = layer.get_param("origin")
# Animating the origin
origin.update_frame_window(window)
origin.animate("vector")
# Animating the outer width
outer_width.update_frame_window(window)
outer_width.animate("real")
# Animating the sharp_cusps
sharp_cusps.update_frame_window(window)
sharp_cusps.animate_without_path("bool")
# Animating the expand param
expand.update_frame_window(window)
expand.animate("real")
# Animating the round tip 0
r_tip0.update_frame_window(window)
r_tip0.animate_without_path("bool")
# Animating the round tip 1
r_tip1.update_frame_window(window)
r_tip1.animate_without_path("bool")
# Animating the homogeneous width
homo_width.update_frame_window(window)
homo_width.animate_without_path("bool")
# Minimizing the window size
if window["first"] == sys.maxsize and window["last"] == -1:
window["first"] = window["last"] = 0
frames = list(set(settings.WAYPOINTS_LIST))
length = bline.get_len()
flag = False
if loop:
flag = True
for fr in frames:
if fr!=1:
st_val = insert_dict_at(lottie["it"][0]["ks"]["k"], -1, fr, flag,True)
cur_origin = origin.get_value(fr)
for point in range(0,length):
pos_ret, width, t1, t2, split_r_val, split_a_val = get_outline_param_at_frame(bline[point],fr)
cubic_to(pos_ret,t1,t2,st_val,cur_origin,False,True)
def gen_dynamic_list_polygon(lottie, dynamic_list):
"""
Generates the bline corresponding to polygon layer
Args:
lottie (dict) : Lottie format polygon layer will be stored here
dynamic_list (common.Param.Param) : Synfig format points of polygon
Returns:
(None)
"""
################## SECTION 1 ################
# Inserting the waypoints if not animated, finding the first and last frame
# Calculating the path after this
window = {}
window["first"] = sys.maxsize
window["last"] = -1
dynamic_list = Bline(dynamic_list[0], dynamic_list)
for entry in dynamic_list.get_entry_list():
pos = entry["vector"]
pos.update_frame_window(window)
z = Param(pos.getparent(), pos.getparent().getparent())
z.animate("vector", True)
entry["vector"] = z
layer = dynamic_list.get_layer().get_layer()
origin = layer.get_param("origin")
# Animating the origin
origin.update_frame_window(window)
origin.animate("vector")
if window["first"] == sys.maxsize and window["last"] == -1:
window["first"] = window["last"] = 0
################ END OF SECTION 1 ##############
################ SECTION 2 #####################
# Generating values for all the frames in the window
fr = window["first"]
while fr <= window["last"]:
st_val, en_val = insert_dict_at(lottie, -1, fr, False)
for entry in dynamic_list.get_entry_list():
pos_cur = entry["vector"].get_value(fr)
pos_next = entry["vector"].get_value(fr + 1)
tangent1_cur, tangent2_cur = Vector(0, 0), Vector(0, 0)
tangent1_next, tangent2_next = Vector(0, 0), Vector(0, 0)
# Adding origin to each vertex
origin_cur = origin.get_value(fr)
origin_next = origin.get_value(fr + 1)
for i in range(len(pos_cur)):
pos_cur[i] += origin_cur[i]
for i in range(len(pos_next)):
pos_next[i] += origin_next[i]
# Store values in dictionary
st_val["i"].append(tangent1_cur.get_list())
st_val["o"].append(tangent2_cur.get_list())
st_val["v"].append(pos_cur)
en_val["i"].append(tangent1_next.get_list())
en_val["o"].append(tangent2_next.get_list())
en_val["v"].append(pos_next)
fr += 1
# Setting the final time
lottie.append({})
lottie[-1]["t"] = fr
def gen_bline_region(lottie, bline_point):
"""
Generates the dictionary corresponding to properties/shapePropKeyframe.json,
given a bline/spline
Args:
lottie (dict) : Lottie generated keyframes will be stored here for shape/path
bline_path (common.Param.Param) : shape/path store in Synfig format
Returns:
(None)
"""
################### SECTION 1 #########################
# Inserting waypoints if not animated and finding the first and last frame
window = {}
window["first"] = sys.maxsize
window["last"] = -1
bline = Bline(bline_point[0], bline_point)
loop = bline.get_loop()
for entry in bline.get_entry_list():
pos = entry["point"]
origin = entry["origin"]
t1 = entry["t1"]
t2 = entry["t2"]
split_r = entry["split_radius"]
split_a = entry["split_angle"]
width = entry["width"] # Not needed, but required by Bline class
# Hence we do not update the window also
width.animate("real")
origin.update_frame_window(window)
origin.animate("real")
# Necassary to update this before inserting new waypoints, as new
# waypoints might include there on time: 0 seconds
pos.update_frame_window(window)
pos.animate("vector", True)
split_r.update_frame_window(window)
split_r.animate_without_path("bool")
split_a.update_frame_window(window)
split_a.animate_without_path("bool")
animate_tangents(t1, window)
animate_tangents(t2, window)
entry["ActivepointList"].update_frame_window(window)
layer = bline.get_layer().get_layer()
origin = layer.get_param("origin")
# Animating the origin
origin.update_frame_window(window)
origin.animate("vector")
# Minimizing the window size
if window["first"] == sys.maxsize and window["last"] == -1:
window["first"] = window["last"] = 0
################# END OF SECTION 1 ###################
################ SECTION 2 ###########################
# Generating values for all the frames in the window
fr = window["first"]
lottie_st_list = []
lottie_en_list = []
while fr <= window["last"]:
st_val, en_val = insert_dict_at(lottie, -1, fr, loop)
lottie_st_list.append(st_val)
lottie_en_list.append(en_val)
synfig_region(bline, st_val, origin, fr)
synfig_region(bline, en_val, origin, fr + 1)
fr += 1
equalize_length(lottie_st_list, lottie_en_list)
# Setting final time
lottie.append({})
lottie[-1]["t"] = fr
def gen_bline_region(lottie, bline_point):
"""
Generates the dictionary corresponding to properties/shapePropKeyframe.json,
given a bline/spline
Args:
lottie (dict) : Lottie generated keyframes will be stored here for shape/path
bline_path (common.Param.Param) : shape/path store in Synfig format
Returns:
(None)
"""
################### SECTION 1 #########################
# Inserting waypoints if not animated and finding the first and last frame
window = {}
window["first"] = sys.maxsize
window["last"] = -1
bline = Bline(bline_point[0], bline_point)
loop = bline.get_loop()
for entry in bline.get_entry_list():
pos = entry["point"]
t1 = entry["t1"]
t2 = entry["t2"]
split_r = entry["split_radius"]
split_a = entry["split_angle"]
# Necassary to update this before inserting new waypoints, as new
# waypoints might include there on time: 0 seconds
pos.update_frame_window(window)
pos.animate("vector", True)
split_r.update_frame_window(window)
split_r.animate_without_path("bool")
split_a.update_frame_window(window)
split_a.animate_without_path("bool")
animate_tangents(t1, window)
animate_tangents(t2, window)
layer = bline.get_layer().get_layer()
origin = layer.get_param("origin")
# Animating the origin
origin.update_frame_window(window)
origin.animate("vector")
# Minimizing the window size
if window["first"] == sys.maxsize and window["last"] == -1:
window["first"] = window["last"] = 0
################# END OF SECTION 1 ###################
################ SECTION 2 ###########################
# Generating values for all the frames in the window
fr = window["first"]
while fr <= window["last"]:
st_val, en_val = insert_dict_at(lottie, -1, fr, loop)
for entry in bline.get_entry_list():
pos = entry["point"]
pos_cur, pos_next = pos.get_value(fr), pos.get_value(fr + 1)
t1 = entry["t1"]
t2 = entry["t2"]
split_r = entry["split_radius"]
split_a = entry["split_angle"]
tangent1_cur, tangent2_cur = get_tangent_at_frame(
t1, t2, split_r, split_a, fr)
tangent1_next, tangent2_next = get_tangent_at_frame(
t1, t2, split_r, split_a, fr + 1)
tangent1_cur, tangent2_cur = convert_tangent_to_lottie(
tangent1_cur, tangent2_cur)
tangent1_next, tangent2_next = convert_tangent_to_lottie(
tangent1_next, tangent2_next)
# Adding origin to each vertex
origin_cur, origin_next = origin.get_value(fr), origin.get_value(
fr + 1)
for i in range(len(pos_cur)):
pos_cur[i] += origin_cur[i]
for i in range(len(pos_next)):
pos_next[i] += origin_next[i]
# Store values in dictionary
st_val["i"].append(tangent1_cur.get_list())
st_val["o"].append(tangent2_cur.get_list())
st_val["v"].append(pos_cur)
en_val["i"].append(tangent1_next.get_list())
en_val["o"].append(tangent2_next.get_list())
en_val["v"].append(pos_next)
fr += 1
# Setting final time
lottie.append({})
lottie[-1]["t"] = fr