def __init__(self):
"""
Main program core.
Calculates the correlation based on the ratio of the pattern and the sliding window
"""
self.workspace = Workspace(self.get_value_by_utc_time)
self.corr_step = 3 # distance in seconds between two correlation detections
self.wave_len = 1 # wave len in seconds
self.experimental = 0 # enable experimental futures
if 'q' in choice.lower():
print("goodbye.")
os._exit(0)
else:
try:
dev = devs[int(choice)]
except:
continue
shapeoko = XY(dev, bounds)
break
print(shapeoko.status())
ε = shapeoko.register(XY.Empty())
shapeoko.head = ε
ws = Workspace(shapeoko)
# test queuing
ws.optimise_queue(True)
ws.pause()
imcb = lambda im:im.show()
ws.enqueue(ε, [Vector(0,0)], lambda _:print(0), {}, {})
ws.enqueue(ε, [Vector(0.05,0.05)], lambda _:print(1), {}, {})
ws.enqueue(ε, [Vector(0.06,0.05)], lambda _:print(2), {}, {})
ws.enqueue(ε, [Vector(0.05,0.04)], lambda _:print(3), {}, {})
ws.enqueue(ε, [Vector(0.08,0.08)], lambda _:print(4), {}, {})
ws.enqueue(ε, [Vector(0.05,0.05)], lambda _:print(5), {}, {})
ws.enqueue(ε, [Vector(0.02,0.05)], lambda _:print(6), {}, {})
ws.play()
time.sleep(2)
def clean_report(self):
self.workspace = Workspace(self.get_value_by_utc_time)
def test_hash(self):
"""Workspace.__hash__"""
ws = Workspace("My Workspace", "123abc")
self.assertEqual(hash(ws), hash("123abc"))
def test_eq_diff_ids(self):
"""Workspace.__eq__.diff_ids"""
ws1 = Workspace("My Workspace", "123abc")
ws2 = Workspace("My Workspace", "def456")
self.assertNotEqual(ws1, ws2)
def test_eq_equal(self):
"""Workspace.__eq__.equal"""
ws1 = Workspace("My Workspace", "123abc")
ws2 = Workspace("My Workspace", "123abc")
self.assertEqual(ws1, ws2)
def test_repr(self):
"""Workspace.__repr__"""
ws = Workspace("My Workspace", "123abc")
self.assertEqual(repr(ws), "My Workspace")
def test_init(self):
"""Workspace.__init__"""
ws = Workspace("My Workspace", "123abc")
self.assertEqual(ws.name, "My Workspace")
self.assertEqual(ws.id, "123abc")
# coordinate system
side = 1.
iw, ih = im.dimensions
factor = max(iw, ih) / side
w, h = map(lambda v: v/factor, im.dimensions)
# zoom levels
z_σ = im.level_count // 2
z_μ = 0
# hardware
virtual = XY(w, h)
σ = virtual.register(Σ(Layer(im, z_σ, side)))
μ = virtual.register(Μ(Layer(im, z_μ, side), (2592,1944)))
p = virtual.register(Pen())
ws = Workspace(virtual)
# test queuing
ws.optimise_queue(True)
ws.pause()
imcb = lambda im:im.show()
ws.enqueue(σ, [Vector(0,0)], lambda _:print(0), {}, {})
ws.enqueue(μ, [Vector(0.1065,0.1432)], lambda _:print(1), {'a':1}, {})
ws.enqueue(μ, [Vector(0.2789,0.2809)], lambda _:print(2), {'a':2}, {})
ws.enqueue(μ, [Vector(0.1012,0.2544)], lambda _:print(3), {'a':2}, {})
ws.enqueue(μ, [Vector(0.1065,0.1432)], lambda _:print(4), {'a':2}, {})
ws.enqueue(μ, [Vector(0.2789,0.2809)], lambda _:print(5), {'a':1}, {})
ws.enqueue(μ, [Vector(0.1012,0.2544)], lambda _:print(6), {'a':1}, {})
ws.play()
# test canvas
