def test_group_scale(self):
lot = objects.Animation()
ref_sl = lot.add_layer(objects.ShapeLayer())
ref_rect = ref_sl.add_shape(objects.Rect())
ref_rect.position.value = NVector(128, 128)
ref_rect.size.value = NVector(256, 256)
ref_sl.add_shape(objects.Fill(Color(1, 0, 0)))
ref_sl.transform.opacity.value = 80
sl = lot.add_layer(objects.ShapeLayer())
rect = sl.add_shape(objects.Rect())
rect.position.value = NVector(128, 128)
rect.size.value = NVector(256, 256)
sl.add_shape(objects.Fill(Color(1, 1, 0)))
sl.transform.scale.value = NVector(180, 50)
sl.transform.position.value = NVector(256, 256)
sl.transform.anchor_point.value = NVector(128, 128)
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 2)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
self.assertIsInstance(sif.layers[1], api.GroupLayer)
self.assertAlmostEqual(sif.layers[0].amount.value, 1)
self.assertAlmostEqual(sif.layers[1].amount.value, 0.8)
self.assert_nvector_equal(sif.layers[0].transformation.offset.value, NVector(256, 256))
self.assert_nvector_equal(sif.layers[0].origin.value, NVector(128, 128))
self.assert_nvector_equal(sif.layers[0].transformation.scale.value, NVector(1.8, .5))
self.assert_nvector_equal(sif.layers[1].transformation.offset.value, NVector(0, 0))
self.assert_nvector_equal(sif.layers[1].origin.value, NVector(0, 0))
self.assert_nvector_equal(sif.layers[1].transformation.scale.value, NVector(1, 1))
def test_animated_real(self):
lot = objects.Animation()
ref_sl = lot.add_layer(objects.ShapeLayer())
ref_rect = ref_sl.add_shape(objects.Rect())
ref_rect.position.value = NVector(128, 128)
ref_rect.size.value = NVector(256, 256)
ref_sl.add_shape(objects.Fill(Color(1, 0, 0)))
ref_sl.transform.opacity.add_keyframe(0, 100)
ref_sl.transform.opacity.add_keyframe(30, 0)
ref_sl.transform.opacity.add_keyframe(60, 100)
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 1)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
amount = sif.layers[0].amount
self.assertAlmostEqual(amount.keyframes[0].value, 1)
self.assertAlmostEqual(amount.keyframes[1].value, 0)
self.assertAlmostEqual(amount.keyframes[2].value, 1)
self.assertEqual(amount.keyframes[0].time, api.FrameTime.frame(0))
self.assertEqual(amount.keyframes[1].time, api.FrameTime.frame(30))
self.assertEqual(amount.keyframes[2].time, api.FrameTime.frame(60))
def test_remove_layer(self):
an = objects.Animation()
l0 = objects.layers.NullLayer()
l1 = objects.layers.NullLayer()
l2 = objects.layers.NullLayer()
l3 = objects.layers.NullLayer()
an.add_layer(l0)
an.add_layer(l1)
an.add_layer(l2)
an.add_layer(l3)
l2.parent = l1
self.assertIn(l0, an.layers)
self.assertIn(l1, an.layers)
self.assertIn(l2, an.layers)
self.assertIn(l3, an.layers)
an.remove_layer(l1)
self.assertIn(l0, an.layers)
self.assertNotIn(l1, an.layers)
self.assertNotIn(l2, an.layers)
self.assertIn(l3, an.layers)
def test_star_hidden(self):
lot = objects.Animation()
sl = lot.add_layer(objects.ShapeLayer())
star = sl.add_shape(objects.Star())
star.hidden = True
star.name = "Star"
star.rotation.value = 20
star.inner_radius.value = 64
star.outer_radius.value = 128
star.position.value = NVector(256, 256)
sl.add_shape(objects.Fill(Color(1, 1, 0)))
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 1)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
grp = sif.layers[0]
self.assertEqual(len(grp.layers), 1)
self.assertIsInstance(grp.layers[0], api.RegionLayer)
self.assertTrue(grp.active)
rgl = grp.layers[0]
self.assertEqual(rgl.desc, "Star")
self.assertEqual(len(rgl.bline.points), 10)
self.assert_nvector_equal(rgl.origin.value, star.position.value)
self.assert_nvector_equal(rgl.color.value, sif.make_color(1, 1, 0, 1))
self.assertFalse(rgl.active)
def test_group_rotate(self):
lot = objects.Animation()
ref_sl = lot.add_layer(objects.ShapeLayer())
ref_rect = ref_sl.add_shape(objects.Rect())
ref_rect.position.value = NVector(128, 128)
ref_rect.size.value = NVector(256, 256)
ref_sl.add_shape(objects.Fill(Color(1, 0, 0)))
ref_sl.transform.opacity.value = 80
sl = lot.add_layer(objects.ShapeLayer())
rect = sl.add_shape(objects.Rect())
rect.position.value = NVector(128, 128)
rect.size.value = NVector(256, 256)
sl.add_shape(objects.Fill(Color(1, 1, 0)))
sl.transform.rotation.value = 20
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 2)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
self.assertIsInstance(sif.layers[1], api.GroupLayer)
self.assertAlmostEqual(sif.layers[0].amount.value, 1)
self.assertAlmostEqual(sif.layers[1].amount.value, 0.8)
self.assertAlmostEqual(sif.layers[0].transformation.angle.value, 20)
self.assertAlmostEqual(sif.layers[1].transformation.angle.value, 0)
def test_repeater(self):
lot = objects.Animation()
sl = lot.add_layer(objects.ShapeLayer())
group = sl.add_shape(objects.Group())
star = group.add_shape(objects.Star())
star.inner_radius.value = 16
star.outer_radius.value = 32
star.position.value = NVector(256, 40)
group.add_shape(objects.Fill(Color(1, 1, 0)))
group.add_shape(objects.Stroke(Color(0, 0, 0), 3))
group.name = "Star"
rep = sl.add_shape(objects.Repeater(4))
rep.name = "Repeater"
rep.transform.position.value = NVector(20, 80)
rep.transform.end_opacity.value = 20
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 1)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
self.assertEqual(len(sif.layers[0].layers), 1)
self.assertIsInstance(sif.layers[0].layers[0], api.GroupLayer)
self.assertEqual(sif.layers[0].layers[0].desc, "Repeater")
self.assertEqual(len(sif.layers[0].layers[0].layers), 2)
duplicate_lay = sif.layers[0].layers[0].layers[1]
self.assertIsInstance(duplicate_lay, api.DuplicateLayer)
self.assertEqual(duplicate_lay.desc, "Repeater")
duplicate = sif.get_object(duplicate_lay.index.id)
self.assertIsInstance(duplicate, api.Duplicate)
self.assertEqual(duplicate.from_.value, 3)
self.assertEqual(duplicate.to.value, 0)
self.assertEqual(duplicate.step.value, -1)
dup_trans = sif.layers[0].layers[0].layers[0]
self.assertIsInstance(dup_trans, api.GroupLayer)
self.assertEqual(dup_trans.desc, "Transformation for Repeater")
dup_origin = sif.get_object(dup_trans.origin.id)
self.assert_nvector_equal(dup_origin.value.value, NVector(0, 0))
trans = dup_trans.transformation
self.assertIsInstance(trans.offset, ast.SifAdd)
self.assertEqual(trans.offset.rhs.value.id, dup_origin.id)
self.assertIsInstance(trans.offset.lhs, ast.SifScale)
self.assert_nvector_equal(trans.offset.lhs.link.value, NVector(20, 80))
self.assertEqual(trans.offset.lhs.scalar.value.id, duplicate.id)
self.assertIsInstance(trans.angle, ast.SifScale)
self.assertEqual(trans.angle.link.value, 0)
self.assertEqual(trans.angle.scalar.value.id, duplicate.id)
self.assertIsInstance(dup_trans.amount, ast.SifSubtract)
self.assertEqual(dup_trans.amount.lhs.value, 1)
self.assertIsInstance(dup_trans.amount.rhs, ast.SifScale)
self.assertAlmostEqual(dup_trans.amount.rhs.link.value, 0.266666666)
self.assertEqual(dup_trans.amount.rhs.scalar.value.id, duplicate.id)
self.assertEqual(len(dup_trans.layers), 1)
self.assertEqual(dup_trans.layers[0].desc, "Star")
def test_layers(self):
an = objects.Animation()
an.add_layer(objects.NullLayer())
an.add_layer(objects.ShapeLayer())
an.insert_layer(0, objects.NullLayer())
self.assertDictEqual(
an.to_dict(), {
"ip":
0,
"op":
60,
"fr":
60,
"w":
512,
"h":
512,
"ddd":
0,
"v":
objects.Animation._version,
"layers": [{
"ty": 3,
"ks": TestTransform._plain_out,
"ao": 0,
"ddd": 0,
"st": 0,
"sr": 1,
"ind": 2,
"ip": 0,
"op": 60,
"bm": 0,
}, {
"ty": 3,
"ks": TestTransform._plain_out,
"ao": 0,
"ddd": 0,
"st": 0,
"sr": 1,
"ind": 0,
"ip": 0,
"op": 60,
"bm": 0,
}, {
"ty": 4,
"ks": TestTransform._plain_out,
"ao": 0,
"bm": 0,
"ddd": 0,
"st": 0,
"sr": 1,
"shapes": [],
"ind": 1,
"ip": 0,
"op": 60,
}],
"assets": [],
})
def test_default(self):
an = objects.Animation()
self.assertDictEqual(
an.to_dict(), {
"ip": 0,
"op": 60,
"fr": 60,
"w": 512,
"h": 512,
"ddd": 0,
"v": objects.Animation._version,
"layers": [],
"assets": [],
})
def test_empty(self):
lot = objects.Animation()
lot.width = 123
lot.height = 456
lot.frame_rate = 69
lot.in_point = 3
lot.out_point = 7
lot.name = "test"
sif = builder.to_sif(lot)
self.assertEqual(sif.width, lot.width)
self.assertEqual(sif.height, lot.height)
self.assertEqual(sif.fps, lot.frame_rate)
self.assertEqual(sif.begin_time, api.FrameTime.frame(3))
self.assertEqual(sif.end_time, api.FrameTime.frame(7))
self.assertEqual(sif.name, lot.name)
def test_clone_noalias(self):
an = objects.Animation()
nl = objects.NullLayer()
nl.in_point = 10
nl.out_point = 20
an.add_layer(nl)
an2 = an.clone()
nl.in_point = 14
nl.out_point = 24
an.width = 100
an.height = 200
an.add_layer(objects.NullLayer())
self.assertDictEqual(
an2.to_dict(), {
"ip":
0,
"op":
60,
"fr":
60,
"w":
512,
"h":
512,
"ddd":
0,
"v":
objects.Animation._version,
"layers": [
{
"ty": 3,
"ks": TestTransform._plain_out,
"ao": 0,
"ddd": 0,
"st": 0,
"sr": 1,
"bm": 0,
"ind": 0,
"ip": 10,
"op": 20,
},
],
"assets": [],
})
self.assertNotEqual(an2.to_dict(), an.to_dict())
def test_name(self):
an = objects.Animation()
an.name = "Foobar"
self.assertDictEqual(
an.to_dict(), {
"ip": 0,
"op": 60,
"fr": 60,
"w": 512,
"h": 512,
"ddd": 0,
"v": objects.Animation._version,
"layers": [],
"assets": [],
"nm": "Foobar"
})
def test_bezier(self):
lot = objects.Animation()
sl = lot.add_layer(objects.ShapeLayer())
shape = sl.add_shape(objects.Path())
sl.add_shape(objects.Fill(Color(0, .25, 1)))
shape.shape.value.closed = True
shape.shape.value.add_point(NVector(256, 0))
shape.shape.value.add_point(NVector(256+128, 256), NVector(0, 0), NVector(64, 128))
shape.shape.value.add_smooth_point(NVector(256, 512), NVector(128, 0))
shape.shape.value.add_point(NVector(256-128, 256), NVector(-64, 128), NVector(0, 0))
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 1)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
grp = sif.layers[0]
self.assertEqual(len(grp.layers), 1)
self.assertIsInstance(grp.layers[0], api.RegionLayer)
self.assertTrue(grp.active)
rgl = grp.layers[0]
self.assertEqual(len(rgl.bline.points), 4)
self.assert_nvector_equal(rgl.color.value, sif.make_color(0, .25, 1))
self.assertTrue(rgl.active)
self.assertTrue(rgl.bline.loop)
for i in range(len(rgl.bline.points)):
sp = rgl.bline.points[i]
lp = shape.shape.value.vertices[i] - NVector(256, 256)
self.assert_nvector_equal(
sp.point.value, lp,
msg="Point %s mismatch %s != %s" % (i, sp.point.value, lp)
)
lt1 = shape.shape.value.in_tangents[i] * -3
self.assert_nvector_equal(
sp.t1.value, lt1,
msg="In Tangent %s mismatch %s != %s" % (i, sp.t1.value, lt1)
)
lt2 = shape.shape.value.out_tangents[i] * 3
self.assert_nvector_equal(
sp.t2.value, lt2,
msg="Out Tangent %s mismatch %s != %s" % (i, sp.t2.value, lt2)
)
def test_animated_vector(self):
lot = objects.Animation()
ref_sl = lot.add_layer(objects.ShapeLayer())
ref_rect = ref_sl.add_shape(objects.Rect())
ref_rect.position.value = NVector(128, 128)
ref_rect.size.value = NVector(256, 256)
ref_sl.add_shape(objects.Fill(Color(1, 0, 0)))
ref_sl.transform.opacity.value = 80
sl = lot.add_layer(objects.ShapeLayer())
rect = sl.add_shape(objects.Rect())
rect.position.value = NVector(128, 128)
rect.size.value = NVector(256, 256)
sl.add_shape(objects.Fill(Color(1, 1, 0)))
sl.transform.position.add_keyframe(0, NVector(0, 0))
sl.transform.position.add_keyframe(30, NVector(256, 256))
sl.transform.position.add_keyframe(60, NVector(0, 0))
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 2)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
self.assertIsInstance(sif.layers[1], api.GroupLayer)
self.assertAlmostEqual(sif.layers[0].amount.value, 1)
self.assertAlmostEqual(sif.layers[1].amount.value, 0.8)
self.assert_nvector_equal(sif.layers[1].transformation.offset.value, NVector(0, 0))
off = sif.layers[0].transformation.offset
self.assert_nvector_equal(off.keyframes[0].value, NVector(0, 0))
self.assert_nvector_equal(off.keyframes[1].value, NVector(256, 256))
self.assert_nvector_equal(off.keyframes[2].value, NVector(0, 0))
self.assertEqual(off.keyframes[0].time, api.FrameTime.frame(0))
self.assertEqual(off.keyframes[1].time, api.FrameTime.frame(30))
self.assertEqual(off.keyframes[2].time, api.FrameTime.frame(60))
self.assertEqual(off.keyframes[0].before, api.Interpolation.Linear)
self.assertEqual(off.keyframes[1].before, api.Interpolation.Linear)
self.assertEqual(off.keyframes[2].before, api.Interpolation.Linear)
self.assertEqual(off.keyframes[0].after, api.Interpolation.Linear)
self.assertEqual(off.keyframes[1].after, api.Interpolation.Linear)
self.assertEqual(off.keyframes[2].after, api.Interpolation.Linear)
def test_circle(self):
lot = objects.Animation()
sl = lot.add_layer(objects.ShapeLayer())
ellipse = sl.add_shape(objects.Ellipse())
ellipse.position.value = NVector(256, 256)
ellipse.size.value = NVector(512, 512)
sl.add_shape(objects.Fill(Color(.25, .25, .25)))
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 1)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
grp = sif.layers[0]
self.assertEqual(len(grp.layers), 1)
self.assertIsInstance(grp.layers[0], api.RegionLayer)
self.assertTrue(grp.active)
rgl = grp.layers[0]
self.assertEqual(len(rgl.bline.points), 4)
self.assert_nvector_equal(rgl.origin.value, ellipse.position.value)
self.assert_nvector_equal(rgl.color.value, sif.make_color(.25, .25, .25))
self.assertTrue(rgl.active)
self.assert_nvector_equal(rgl.bline.points[0].point.value, NVector(0, 256))
self.assert_nvector_equal(rgl.bline.points[1].point.value, NVector(-256, 0))
self.assert_nvector_equal(rgl.bline.points[2].point.value, NVector(0, -256))
self.assert_nvector_equal(rgl.bline.points[3].point.value, NVector(256, 0))
self.assertNotAlmostEqual(rgl.bline.points[0].t1.value.x, 0)
self.assertAlmostEqual(rgl.bline.points[0].t1.value.y, 0)
self.assertNotAlmostEqual(rgl.bline.points[1].t1.value.y, 0)
self.assertAlmostEqual(rgl.bline.points[1].t1.value.x, 0)
self.assertNotAlmostEqual(rgl.bline.points[2].t1.value.x, 0)
self.assertAlmostEqual(rgl.bline.points[2].t1.value.y, 0)
self.assertNotAlmostEqual(rgl.bline.points[3].t1.value.y, 0)
self.assertAlmostEqual(rgl.bline.points[3].t1.value.x, 0)
for i in range(4):
self.assert_nvector_equal(rgl.bline.points[i].t1.value, rgl.bline.points[i].t2.value)
def test_layers_preserve(self):
an = objects.Animation()
nl = objects.NullLayer()
nl.index = 42
nl.in_point = 10
nl.out_point = 20
an.add_layer(nl)
self.assertDictEqual(
an.to_dict(), {
"ip":
0,
"op":
60,
"fr":
60,
"w":
512,
"h":
512,
"ddd":
0,
"v":
objects.Animation._version,
"layers": [
{
"ty": 3,
"ks": TestTransform._plain_out,
"ao": 0,
"ddd": 0,
"st": 0,
"sr": 1,
"bm": 0,
"ind": 42,
"ip": 10,
"op": 20,
},
],
"assets": [],
})
def test_animated_fill(self):
lot = objects.Animation()
ref_sl = lot.add_layer(objects.ShapeLayer())
ref_rect = ref_sl.add_shape(objects.Rect())
ref_rect.position.value = NVector(128, 128)
ref_rect.size.value = NVector(256, 256)
fill = ref_sl.add_shape(objects.Fill())
fill.opacity.add_keyframe(0, 100)
fill.opacity.add_keyframe(30, 50)
fill.opacity.add_keyframe(60, 100)
fill.color.add_keyframe(0, NVector(1, 0, 0))
fill.color.add_keyframe(30, NVector(0, 1, 0))
fill.color.add_keyframe(60, NVector(1, 0, 0))
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 1)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
amount = sif.layers[0].layers[0].amount
self.assertAlmostEqual(amount.keyframes[0].value, 1)
self.assertAlmostEqual(amount.keyframes[1].value, 0.5)
self.assertAlmostEqual(amount.keyframes[2].value, 1)
self.assertEqual(amount.keyframes[0].time, api.FrameTime.frame(0))
self.assertEqual(amount.keyframes[1].time, api.FrameTime.frame(30))
self.assertEqual(amount.keyframes[2].time, api.FrameTime.frame(60))
color = sif.layers[0].layers[0].color
self.assert_nvector_equal(color.keyframes[0].value, sif.make_color(1, 0, 0))
self.assert_nvector_equal(color.keyframes[1].value, sif.make_color(0, 1, 0))
self.assert_nvector_equal(color.keyframes[2].value, sif.make_color(1, 0, 0))
self.assertEqual(color.keyframes[0].time, api.FrameTime.frame(0))
self.assertEqual(color.keyframes[1].time, api.FrameTime.frame(30))
self.assertEqual(color.keyframes[2].time, api.FrameTime.frame(60))
def test_rect(self):
lot = objects.Animation()
sl = lot.add_layer(objects.ShapeLayer())
rect = sl.add_shape(objects.Rect())
rect.position.value = NVector(256, 256)
rect.size.value = NVector(128, 256)
sl.add_shape(objects.Fill(Color(1, .25, 0)))
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 1)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
grp = sif.layers[0]
self.assertEqual(len(grp.layers), 1)
self.assertIsInstance(grp.layers[0], api.RegionLayer)
self.assertTrue(grp.active)
rgl = grp.layers[0]
self.assertEqual(len(rgl.bline.points), 4)
self.assert_nvector_equal(rgl.origin.value, rect.position.value)
self.assert_nvector_equal(rgl.color.value, sif.make_color(1, .25, 0))
self.assertTrue(rgl.active)
self.assert_nvector_equal(rgl.bline.points[0].point.value, NVector(-64, -128))
self.assert_nvector_equal(rgl.bline.points[1].point.value, NVector(+64, -128))
self.assert_nvector_equal(rgl.bline.points[2].point.value, NVector(+64, +128))
self.assert_nvector_equal(rgl.bline.points[3].point.value, NVector(-64, +128))
self.assert_nvector_equal(rgl.bline.points[0].t1.value, NVector(0, 0))
self.assert_nvector_equal(rgl.bline.points[1].t1.value, NVector(0, 0))
self.assert_nvector_equal(rgl.bline.points[2].t1.value, NVector(0, 0))
self.assert_nvector_equal(rgl.bline.points[3].t1.value, NVector(0, 0))
self.assert_nvector_equal(rgl.bline.points[0].t2.value, NVector(0, 0))
self.assert_nvector_equal(rgl.bline.points[1].t2.value, NVector(0, 0))
self.assert_nvector_equal(rgl.bline.points[2].t2.value, NVector(0, 0))
self.assert_nvector_equal(rgl.bline.points[3].t2.value, NVector(0, 0))
def test_shape_group(self):
lot = objects.Animation()
sl = lot.add_layer(objects.ShapeLayer())
gr1 = sl.add_shape(objects.Group())
gr1.name = "Group Shape 1"
rect = gr1.add_shape(objects.Rect())
rect.position.value = NVector(128, 256)
rect.size.value = NVector(128, 256)
gr1.add_shape(objects.Fill(Color(1, .25, 0)))
gr2 = sl.add_shape(objects.Group())
gr2.name = "Group Shape 2"
rect = gr2.add_shape(objects.Rect())
rect.position.value = NVector(256+128, 256)
rect.size.value = NVector(128, 256)
gr2.add_shape(objects.Fill(Color(.25, 0, 1)))
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 1)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
grp = sif.layers[0]
self.assertEqual(len(grp.layers), 2)
sg1 = grp.layers[1]
sg2 = grp.layers[0]
self.assertIsInstance(sg1, api.GroupLayer)
self.assertIsInstance(sg2, api.GroupLayer)
self.assertEqual(sg1.desc, "Group Shape 1")
self.assertEqual(sg2.desc, "Group Shape 2")
self.assertEqual(len(sg1.layers), 1)
self.assertEqual(len(sg2.layers), 1)
self.assertIsInstance(sg1.layers[0], api.RegionLayer)
self.assertIsInstance(sg2.layers[0], api.RegionLayer)
self.assert_nvector_equal(sg1.layers[0].color.value, sif.make_color(1, .25, 0))
self.assert_nvector_equal(sg2.layers[0].color.value, sif.make_color(.25, 0, 1))
#!/usr/bin/env python3
import sys
import os
sys.path.insert(0, os.path.join(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
"lib"
))
from lottie.utils import script
from lottie import objects
from lottie import Point, Color
an = objects.Animation(59)
layer = objects.ShapeLayer()
an.add_layer(layer)
circle = layer.add_shape(objects.Ellipse())
circle.size.value = Point(100, 100)
circle.position.add_keyframe(0, Point(0, 256))
circle.position.add_keyframe(20, Point(256, 256))
circle.position.add_keyframe(40, Point(256, 0))
circle.position.add_keyframe(60, Point(0, 256))
fill = layer.add_shape(objects.Fill(Color(1, 1, 0)))
fill.opacity.add_keyframe(0, 100)
fill.opacity.add_keyframe(30, 10)
fill.opacity.add_keyframe(60, 100)
#!/usr/bin/env python3
import sys
import os
import math
sys.path.insert(
0,
os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
"lib"))
from lottie.utils import script
from lottie import objects
from lottie.utils import animation as anutils
from lottie import Size, Point3D, Point, Color
an = objects.Animation(120)
layer = objects.ShapeLayer()
an.add_layer(layer)
g = layer.add_shape(objects.Group())
b = g.add_shape(objects.Ellipse())
b.size.value = Size(256, 256)
b.position.value = Point(256, 256)
g.add_shape(objects.Fill(Color(1, 1, 0)))
g = layer.insert_shape(0, objects.Group())
eye1 = g.add_shape(objects.Ellipse())
eye1.size.value = Size(20, 20)
eye1.position.value = Point3D(256 - 50, 256 - 50, -100)
g.add_shape(objects.Fill(Color(0, 0, 0)))
g = layer.insert_shape(0, objects.Group())
#!/usr/bin/env python3
import sys
import os
sys.path.insert(
0,
os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
"lib"))
from lottie.utils import script
from lottie import objects
from lottie import Point, Color
image_filename = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"blep.png")
last_frame = 60
an = objects.Animation(last_frame)
image = objects.assets.Image().load(image_filename)
an.assets.append(image)
an.add_layer(objects.ImageLayer(image.id))
script.script_main(an)
#!/usr/bin/env python3
import sys
import os
sys.path.insert(
0,
os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
"lib"))
from lottie.utils import script
from lottie import objects
from lottie.utils import animation as anutils
from lottie import Point, Color
an = objects.Animation(180)
layer = objects.ShapeLayer()
an.add_layer(layer)
group = layer.add_shape(objects.Group())
bez = group.add_shape(objects.Path())
bez.shape.value.add_point(Point(256, 128), Point(0, 0), Point(64, 64))
bez.shape.value.add_smooth_point(Point(256, 256 + 120), Point(32, -32))
bez.shape.value.add_point(Point(256, 256), Point(-64, -64), Point(-64, 64))
bez.shape.value.add_point(Point(128, 256 + 120), Point(64, 64), Point(0, 0))
group.add_shape(objects.Stroke(Color(1, 0, 0), 10))
group = layer.add_shape(objects.Group())
sh = anutils.generate_path_segment(bez.shape.value, 0, 180, 60, 180, 60, True)
group.add_shape(sh)
group.add_shape(objects.Stroke(Color(0, 1, 0), 20))
script.script_main(an)
def test_sanitize_anim(self):
an = objects.Animation()
nl = an.add_layer(objects.NullLayer())
nl.transform.scale.add_keyframe(0, NVector(50, 50))
nl.transform.scale.add_keyframe(60, NVector(200, 200))
nl.transform.scale.keyframes[-1].start = None
an.width = 128
an.height = 256
an.frame_rate = 69
an.tgs_sanitize()
self.assertEqual(
an.to_dict(), {
"ip":
0,
"op":
60,
"fr":
60,
"w":
512,
"h":
512,
"ddd":
0,
"v":
objects.Animation._version,
"layers": [
{
"ty": 3,
"ks": {
"a": {
"a": 0,
"k": [0, 0]
},
"p": {
"a": 0,
"k": [0, 0]
},
"s": {
"a":
1,
"k": [
{
"s": [100, 100],
"e": [400, 400],
"t": 0,
"o": {
"x": [0],
"y": [0]
},
"i": {
"x": [1],
"y": [1]
},
},
{
"t": 60,
},
]
},
"r": {
"a": 0,
"k": 0
},
"o": {
"a": 0,
"k": 100
},
"sk": {
"a": 0,
"k": 0
},
"sa": {
"a": 0,
"k": 0
},
},
"ao": 0,
"ddd": 0,
"st": 0,
"sr": 1,
"bm": 0,
"ind": 0,
"ip": 0,
"op": 60,
},
],
"assets": [],
})
def test_sanitize_lowfr(self):
an = objects.Animation()
an.add_layer(objects.NullLayer())
an.frame_rate = 23
an.tgs_sanitize()
self.assertEqual(
an.to_dict(), {
"ip":
0,
"op":
60,
"fr":
30,
"w":
512,
"h":
512,
"ddd":
0,
"v":
objects.Animation._version,
"layers": [
{
"ty": 3,
"ks": {
"a": {
"a": 0,
"k": [0, 0]
},
"p": {
"a": 0,
"k": [0, 0]
},
"s": {
"a": 0,
"k": [100, 100]
},
"r": {
"a": 0,
"k": 0
},
"o": {
"a": 0,
"k": 100
},
"sk": {
"a": 0,
"k": 0
},
"sa": {
"a": 0,
"k": 0
},
},
"ao": 0,
"ddd": 0,
"st": 0,
"sr": 1,
"bm": 0,
"ind": 0,
"ip": 0,
"op": 60,
},
],
"assets": [],
})
import sys
import os
import math
sys.path.insert(0, os.path.join(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
"lib"
))
from lottie.utils import script
from lottie import objects
from lottie.utils import animation as anutils
from lottie import Color, Point
from lottie.objects import easing
rot_time = 45
an = objects.Animation(rot_time*4)
layer = objects.ShapeLayer()
an.add_layer(layer)
def add_shape(shape, color, parent):
g = parent.add_shape(objects.Group())
s = g.add_shape(shape)
g.add_shape(objects.Fill(color))
return s
face1 = add_shape(objects.Ellipse(), Color(1, 1, 0), layer)
face2 = add_shape(objects.Ellipse(), Color(0, 1, 0), layer)
def test_animated_bezier(self):
lot = objects.Animation()
sl = lot.add_layer(objects.ShapeLayer())
shape = sl.add_shape(objects.Path())
sl.add_shape(objects.Fill(Color(0, .25, 1)))
bez = objects.Bezier()
bez.closed = True
bez.add_point(NVector(256, 0))
bez.add_point(NVector(256+128, 256), NVector(0, 0), NVector(64, 128))
bez.add_smooth_point(NVector(256, 512), NVector(128, 0))
bez.add_point(NVector(256-128, 256), NVector(-64, 128), NVector(0, 0))
new_bez = bez.clone()
new_bez.vertices[2] = NVector(256, 256+128)
new_bez.in_tangents[2] = NVector(64, 64)
new_bez.out_tangents[2] = NVector(-64, 64)
shape.shape.add_keyframe(0, bez)
shape.shape.add_keyframe(30, new_bez)
shape.shape.add_keyframe(60, bez)
sif = builder.to_sif(lot)
self.assertEqual(len(sif.layers), 1)
self.assertIsInstance(sif.layers[0], api.GroupLayer)
grp = sif.layers[0]
self.assertEqual(len(grp.layers), 1)
self.assertIsInstance(grp.layers[0], api.RegionLayer)
self.assertTrue(grp.active)
rgl = grp.layers[0]
self.assertEqual(len(rgl.bline.points), 4)
self.assert_nvector_equal(rgl.color.value, sif.make_color(0, .25, 1))
self.assertTrue(rgl.active)
self.assertTrue(rgl.bline.loop)
for i in range(4):
sp = rgl.bline.points[i]
lp = bez.vertices[i] - NVector(256, 256)
lt1 = bez.in_tangents[i] * -3
lt2 = bez.out_tangents[i] * 3
new_lp = new_bez.vertices[i] - NVector(256, 256)
new_lt1 = new_bez.in_tangents[i] * -3
new_lt2 = new_bez.out_tangents[i] * 3
self.assertEqual(sp.point.keyframes[0].time, api.FrameTime.frame(0))
self.assert_nvector_equal(sp.point.keyframes[0].value, lp)
self.assert_nvector_equal(sp.t1.keyframes[0].value, lt1)
self.assert_nvector_equal(sp.t2.keyframes[0].value, lt2)
self.assertEqual(sp.point.keyframes[1].time, api.FrameTime.frame(30))
self.assert_nvector_equal(sp.point.keyframes[1].value, new_lp)
self.assert_nvector_equal(sp.t1.keyframes[1].value, new_lt1)
self.assert_nvector_equal(sp.t2.keyframes[1].value, new_lt2)
self.assertEqual(sp.point.keyframes[2].time, api.FrameTime.frame(60))
self.assert_nvector_equal(sp.point.keyframes[2].value, lp)
self.assert_nvector_equal(sp.t1.keyframes[2].value, lt1)
self.assert_nvector_equal(sp.t2.keyframes[2].value, lt2)
#!/usr/bin/env python3
import sys
import os
sys.path.insert(0, os.path.join(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
"lib"
))
from lottie.utils import script
from lottie import objects
from lottie.utils.animation import spring_pull
from lottie import Point, Color
an = objects.Animation(100)
layer = objects.ShapeLayer()
an.add_layer(layer)
settings = [
(Color(1, 1, 0), 128, 7),
(Color(1, 0, 0), 256, 15),
(Color(0, .5, 1), 384, 30),
]
for color, x, falloff in settings:
group = layer.add_shape(objects.Group())
ball = group.add_shape(objects.Ellipse())
ball.size.value = Point(100, 100)
group.add_shape(objects.Fill(color))
group.transform.position.value = Point(x, -100)
spring_pull(group.transform.position, Point(x, 256), 0, 60, falloff, 7)
#!/usr/bin/env python3
import sys
import os
sys.path.insert(
0,
os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
"lib"))
from lottie.utils import script
from lottie import objects
from lottie import Point, Color
an = objects.Animation(60)
layer = objects.ShapeLayer()
an.add_layer(layer)
shapes = layer.add_shape(objects.Group())
circle = shapes.add_shape(objects.Ellipse())
circle.size.add_keyframe(0, Point(100, 100))
circle.size.add_keyframe(30, Point(50, 120))
circle.size.add_keyframe(60, Point(100, 100))
circle.position.add_keyframe(0, Point(220, 110))
circle.position.add_keyframe(20, Point(180, 110))
circle.position.add_keyframe(40, Point(220, 110))
star = shapes.add_shape(objects.Star())
star.inner_radius.add_keyframe(0, 20)
star.inner_radius.add_keyframe(30, 50)
star.inner_radius.add_keyframe(60, 20)
star.outer_radius.value = 50
