class Bowling (object):
def __init__(self):
self.frame = Frame()
self.frames = []
def roll(self, pins):
current_score = 0
if len(self.frame.bowls) == 2:
next_frame = Frame()
self.frame.next_frame = next_frame
self.frames.append(self.frame)
self.frame = next_frame
self.frame.add_bowl(pins)
def score(self):
score = 0
for frame in self.frames:
score += frame.get_score()
score += self.frame.get_bowl_total()
return score
def save_frame(num, img_name):
f = Frame()
num = int(num)
num = (num * ((240*416)+(120*208)+(120*208)))
f.create_matrix(num)
grey = f.matrixY.astype('uint8')
grey = Im.fromarray(grey, "L")
grey.save("saved_img/" + img_name + ".bmp")
def __init__(self, name, **kwargs):
if kwargs.has_key('Element'):
div = kwargs.pop('Element')
else:
div = DOM.createDiv()
DOM.setInnerHTML(div, "<iframe name='" + name + "'>")
iframe = DOM.getFirstChild(div)
Frame.__init__(self, None, iframe, **kwargs)
class History:
# CONSTRUCTOR.........................
def __init__(self, particles, longRun = False):
# Save particle properties
self.maxMass = particles.movers[0].maxMass
self.maxVelocity = particles.movers[0].maxVelocity
self.masses = [particles.movers[i].mass for i in range(len(particles.movers))]
self.longRun = longRun # To toogle saving history (useful for long, continuous runs)
if longRun:
self.frames = Frame(particles)
else:
self.frames = []
self.currentFrameNo = 0
#.....................................
def addFrame(self, frame):
self.frames.append(frame)
#.....................................
def saveFrame(self, particles):
currentFrame = Frame(particles)
self.addFrame(currentFrame)
#.....................................
def saveSimulation(self, particleSystem, connectedness, steps=100):
if self.longRun:
particleSystem.update(connectedness)
self.frames.update(particleSystem)
else:
self.saveFrame(particleSystem)
for i in range(steps):
particleSystem.update(connectedness)
self.saveFrame(particleSystem)
#.....................................
def hasNext(self):
if self.longRun:
return False
else:
return ( self.currentFrameNo+1 < len(self.frames) )
#.....................................
def drawStep(self, drawParticles, drawConnections, drawClusters):
if self.longRun:
frame = self.frames
else:
frame = self.frames[self.currentFrameNo]
self.currentFrameNo = self.currentFrameNo + 1
frame.draw(drawParticles, drawConnections, drawClusters, self.masses, self.maxVelocity)
#.....................................
def restartPlayback(self):
self.currentFrameNo = 0
def testIds(self):
""" Test if getFrameById works """
f1 = Frame(command = "cmd1", response = "rsp1")
f2 = Frame(command = "cmd2", response = "rsp2")
self.movie.addFrame(f1)
self.movie.addFrame(f2)
f1ById = self.movie.getFrameById(f1.getId())
self.assertEqual(f1, f1ById)
def run (self, frame, functionFrame): (jmenaargumentu, block) = functionFrame.get(self.name) novyframe = Frame(frame) for i in range(0, len(jmenaargumentu)): novyframe.set(jmenaargumentu[i], self.arrgs[i], functionFrame) try: block.run(novyframe, functionFrame) except Literal, e: return e #print novyframe.locals
def test_pin_count_ok(self):
frame = Frame()
self.assertFalse(frame.is_pin_count_ok(11))
self.assertTrue(frame.is_pin_count_ok(8))
frame.add_ball(8)
self.assertFalse(frame.is_pin_count_ok(3))
self.assertTrue(frame.is_pin_count_ok(2))
self.assertTrue(frame.is_pin_count_ok(1))
frame.add_ball(1)
self.assertFalse(frame.is_pin_count_ok(2))
self.assertFalse(frame.is_pin_count_ok(1))
def visitFuncDecl(self, ast, o):
#frame: Frame
#sym: List[Symbol]
frame = Frame(ast.name, ast.returnType)
sym = []
for x in ast.param:
index = frame.getNewIndex()
sym+= [Symbol(x.variable, self.visit(x.varType,o), Index(index))]
#[Symbol(x.variable, self.visit(x.varType,o), CName(self.className))]
d = [sym, o.sym]
subctxt = o
self.genMETHOD(ast, d, frame)
return None
def process_response(frame: Frame, outstanding_frames: dict) -> None:
print(
f"{NAME} Received response frame {frame.to_string()}\nfrom {frame.src}\n"
)
try:
for resp in outstanding_frames[frame.dest]:
if (
resp.frame.seqno == frame.seqno
and resp.frame.origin == frame.dest
):
response = resp
response.remaining_responses -= 1
if response.time == -1 and frame.time > -1:
# If we have found a route, select it
response.time = frame.time
if frame.time < response.time and frame.time > 0:
# We've found a faster route
response.time = frame.time
if response.remaining_responses == 0:
# We've received all the responses we expect
if response.frame.origin == NAME:
# End of the line send the TCP response
print("We are at the end of the line friends")
else:
# Send UDP response to requesting station
response_frame = Frame(
frame.origin,
frame.dest,
NAME,
frame.seqno,
frame.time,
frame.type,
)
out_port = None
for port, name in NEIGHBOURS.items():
if name == response.frame.src:
out_port = port
break
if not out_port:
print(
f"Received frame from {response.frame.src},"
f" not a neighbour, exiting."
)
sys.exit(0)
UDP_SOCKET.sendto(response_frame.to_bytes(), (HOST, out_port))
except KeyError:
print(f"Received a response for something we haven't forwarded")
sys.exit(0)
def prepare(self):
for frameIndex in Utils.progressbar(range(0,self.gif.n_frames), prefix="Processing frames...", size=self.gif.n_frames):
# Locate current frame
self.gif.seek(frameIndex)
access = self.gif.load()
# Initialize and process current frame
frame = Frame(access=access,sizeX=self.sizeX,sizeY=self.sizeY,compFactor=self.compressionFactor,duration=self.gif.info['duration'])
frame.process()
# Save for later presenting
self.frames.append(frame)
def __init__(self, name_serial, nop):
'''
:param nameSerial: name of serial port exp. 'COM10' or '/tty/ttyUSB'
:param nop: number of packet in frame
'''
self.frame = Frame(nop)
self.serial = serial.Serial(port=name_serial,
baudrate=115200,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
bytesize=serial.EIGHTBITS,
timeout=1)
if self.serial.isOpen():
print('[{}]: {} is open..'.format(__name__, name_serial))
def testBackoff1(self):
#Test retransmission after one collision, using specified
#rather than random backoff
simulator = CSMA_CD_Simulator.CSMA_CD_Simulator(500)
station1 = Station.Station(1, 20.0)
simulator.addStation(station1)
msg1 = Frame(1, 'Hello Station 2', 1, 2)
evt1 = Event(Event.ARRIVAL, 123.45, 1, msg1)
station2 = Station.Station(2, 40.0)
simulator.addEvent(evt1)
simulator.addStation(station1)
simulator.addStation(station2)
msg2 = Frame(2, 'Hello Station 1', 2, 1)
evt2 = Event(Event.ARRIVAL, 123.50, 2, msg2)
simulator.addEvent(evt2)
simulator.processSingleEvent()
self.assertAlmostEquals(simulator.simTime, 123.45)
simulator.processSingleEvent() #should transmit msg2
#and schedule collision detection
evtQ = simulator.evtQ
self.assertEquals(evtQ._qsize(), 2)
evt3 = evtQ.get()
self.assertEquals(evt3.eventType, Event.COLLISION_DETECT)
self.assertAlmostEquals(evt3.time, 123.45, 0)
self.assertEquals(evt3.stationId, 2)
evt4 = evtQ.get()
self.assertEquals(evt4.eventType, Event.COLLISION_DETECT)
self.assertAlmostEquals(evt4.time, 126.45, 0)
self.assertEquals(evt4.stationId, 1)
simulator.processSingleEvent()
evt4 = evtQ.get()
self.assertEquals(evt4.eventType, Event.JAMMING_END)
simulator.processSingleEvent()
evt5 = evtQ.get()
self.assertEquals(evt5.eventType, Event.JAMMING_END)
simulator.processSingleEvent()
simulator.set_back_off_time(1.5)
evt6 = evtQ.get()
self.assertEquals(evt6.eventType, Event.TRANSMIT_ATTEMPT)
self.assertAlmostEquals(evt6.time, 126.45 + 1.5)
simulator.processSingleEvent()
simulator.set_back_off_time(.9)
evt7 = evtQ.get()
self.assertEquals(evt7.eventType, Event.TRANSMIT_ATTEMPT)
self.assertAlmostEquals(evt7.time, 126.45 + .9)
def test_score(self):
frame = Frame()
self.assertEqual(0, frame.score())
frame.add_ball(8)
self.assertEqual(8, frame.score())
frame.add_ball(1)
self.assertEqual(9, frame.score())
def ident_throw(self, num_pins, actual_name, i):
if (num_pins >= 0) and (num_pins < 10) and i < 9:
num_pins2 = int(input('Frame №{} Enter the number of pins hit. Second throw:'.format(i + 1)))
if num_pins + num_pins2 == 10:
print('SPARE')
Frame.save_score(self, actual_name, str(num_pins) + '/', i)
else:
print('OPEN')
Frame.save_score(self, actual_name, str(num_pins) + str(num_pins2), i)
elif num_pins == 10 and i < 9:
print('STRIKE')
Frame.save_score(self, actual_name, 'X', i)
elif i == 9:
frame10 = ""
num_pins2 = int(input('Frame №{} Enter the number of pins hit. Second throw:'.format(i + 1)))
if num_pins == 10 or num_pins2 == 10 or num_pins + num_pins2 == 10:
num_pins3 = int(input('Frame №{} Enter the number of pins hit. Second throw:'.format(i + 1)))
if num_pins == 10:
frame10 += 'X'
else:
frame10 += str(num_pins)
if num_pins2 == 10:
frame10 += 'X'
else:
frame10 += str(num_pins2)
if num_pins3 == 10:
frame10 += 'X'
else:
frame10 += str(num_pins3)
else:
frame10 += str(num_pins) + str(num_pins2)
Frame.save_score(self, actual_name, frame10, i)
def __init__(self, Root, Y, X, W, **properties):
Frame.__init__(self, Root, Y, X, Y+1, X + W - 1,
border=0, dropshadow=0, **properties)
GDebug.printMesg(0,'WIDTH=%s' % W)
self.rootwin = Root
self.CANGETFOCUS = 0
self.Y = Y
self.X = X
self.H = 1
self.W = W
self.STATUSBAR = None
self.STATUSBAR_INDEX = 0
self.Controls = []
self.SetColor('MENUBAR')
self.VISIBLE = 1
def visitProgram(self, ast, c):
#ast: Program
#c: Any
# Create header
self.emit.printout(self.emit.emitPROLOG(
self.className, "java.lang.Object"))
# Get all decl init
for decl in ast.decl:
if isinstance(decl, VarDecl):
self.emit.printout(self.emit.emitATTRIBUTE(
decl.variable, decl.varType))
temp = Symbol(decl.variable, decl.varType)
c.sym.append(temp)
else:
temp = Symbol(decl.name.name, MType(
[x.varType for x in decl.param], decl.returnType), CName(self.className))
c.sym.append(temp)
# Initial class method (object constructor)
init_frame = Frame('<clinit>', VoidType())
self.emit.printout(self.emit.emitMETHOD(
'<clinit>', MType([], VoidType()), False, init_frame))
# generate default constructor
for x in ast.decl:
if isinstance(x, VarDecl) and isinstance(x.varType, ArrayType):
self.emit.printout(self.emit.emitPUSHICONST(
x.varType.dimen, init_frame))
self.emit.printout(self.emit.emitNEWARRAY(x.varType.eleType))
self.emit.printout(self.emit.emitPUTSTATIC(
self.className + '.' + x.variable, x.varType, init_frame))
self.emit.printout(self.emit.emitLIMITSTACK(
init_frame.getMaxOpStackSize()))
self.emit.printout(self.emit.emitLIMITLOCAL(init_frame.getMaxIndex()))
self.emit.printout(self.emit.emitRETURN(VoidType(), init_frame))
self.emit.printout(self.emit.emitENDMETHOD(init_frame))
#start visit others
for decl in ast.decl:
if isinstance(decl, FuncDecl):
self.visit(decl, c)
self.emit.emitEPILOG()
return
def visitProgram(self, ast, c):
#ast: Program
#c: Any
self.emit.printout(
self.emit.emitPROLOG(self.className, "java.lang.Object"))
lsFunc = list(filter(lambda x: type(x) is FuncDecl, ast.decl))
for x in ast.decl:
if type(x) is VarDecl:
self.emit.printout(
self.emit.emitATTRIBUTE(x.variable.name, x.varType, False,
""))
symbol = Symbol(x.variable.name, x.varType,
CName(self.className))
self.env.append(symbol)
else:
typeFunc = MType([y.varType for y in x.param], x.returnType)
symbol = Symbol(x.name.name, typeFunc, CName(self.className))
self.env.append(symbol)
e = SubBody(None, self.env)
for x in lsFunc:
self.visit(x, e)
# generate default constructor
self.genMETHOD(FuncDecl(Id("<init>"), list(), list(), list(), None), c,
Frame("<init>", VoidType))
self.emit.emitEPILOG()
return c
def visitProgram(self, ast, c):
#ast: Program
#c: Any
self.emit.printout(
self.emit.emitPROLOG(self.className, "java.lang.Object"))
e = SubBody(None, self.env)
var_lst = [x for x in ast.decl if type(x) is VarDecl]
func_lst = [x for x in ast.decl if type(x) is FuncDecl]
for x in var_lst:
e = self.visit(x, e)
for i in func_lst:
lst = [x.varType for x in i.param]
e.sym.append(
Symbol(i.name.name, MType(lst, i.returnType),
CName(self.className)))
for x in func_lst:
self.visit(x, e)
# generate default constructor
self.genMETHOD(FuncDecl(Id("<init>"), list(), list(), list(), None), c,
Frame("<init>", VoidType))
self.emit.emitEPILOG()
return c
def visitProgram(self, ast, c):
#ast: Program
#c: Any
self.emit.printout(
self.emit.emitPROLOG(self.className, "java.lang.Object"))
declList = self.env
# e = SubBody(None, self.env)
# for x in ast.decl:
# e = self.visit(x, e)
for x in ast.decl:
if type(x) is FuncDecl:
declList = [
Symbol(x.name.name,
MType([y.varType for y in x.param], x.returnType),
CName(self.className))
] + declList
else:
symbol = self.visit(x, (SubBody(None, None), "Global"))
declList = [symbol] + declList
e = SubBody(None, declList)
[self.visit(x, e) for x in ast.decl if type(x) is FuncDecl]
# generate default constructor
self.genMETHOD(FuncDecl(Id("<init>"), list(), None, Block(list())), c,
Frame("<init>", VoidType))
self.emit.emitEPILOG()
return c
def visitArrayType(self,ast,o):
lower = ast.lower
upper = ast.upper
arraySize = upper - lower + 1
eleType = ast.eleType
frame = o[0].frame
#label1 = frame.getNewLabel()
#label2 = frame.getNewLabel()
#if type(x.varType) == ArrayType:
frameInit = Frame("<clinit>",VoidType)
self.emit.printout(self.emit.emitMETHOD("<clinit>", MType(list(),VoidType()), False, frameInit))
#frameInit.enterScope(True)
#self.emit.printout(self.emit.emitVAR(frameInit.getNewIndex(), "this", ClassType(self.className), frameInit.getStartLabel(), frameInit.getEndLabel(), frameInit))
#self.emit.printout(self.emit.emitLABEL(frameInit.getStartLabel(), frameInit))
#self.emit.printout(self.emit.emitREADVAR("this", ClassType(self.className), 0, frameInit))
#self.emit.printout(self.emit.emitINVOKESPECIAL(frameInit))
#self.emit.printout(self.emit.emitREADVAR("this",ClassType(self.className), 0, frameInit))
self.emit.printout(self.emit.emitPUSHICONST(arraySize,frameInit))
self.emit.printout(self.emit.jvm.emitNEWARRAY(self.emit.getFullType(eleType)))
self.emit.printout(self.emit.emitPUTSTATIC(self.className + "." + o[1],ast,frameInit))
#self.emit.printout(self.emit.emitLABEL(frameInit.getEndLabel(), frameInit))
self.emit.printout(self.emit.emitRETURN(VoidType(), frameInit))
self.emit.printout(self.emit.emitENDMETHOD(frameInit))
def detect_Car(self, frame_no, frame):
ObjectsInFrame = []
image = Image.fromarray(frame) # Get each frame of video
r_image, object_boxes, time_value = self.yolo.detect_image(
image
) #Detect objects from frame and retun image and coordinates with class
result = np.asarray(r_image) #Save resulting image
#print('Size of box {}'.format((object_boxes))) #Print Box size
#cv2.imshow("Yolo Test", result) #Show the result image with detected object.
# Use Q to quit from the window
bounding_boxes = []
rectangles = []
for object_box in object_boxes: #For each object in given frame
if object_box[
'class'] == 'car': #Select object with only car as class
#print('Found a car in frame')
top = object_box['top']
left = object_box['left']
bottom = object_box['bottom']
right = object_box['right']
bounding_box = frame[top:bottom,
left:right] # Resulting image of car
bounding_boxes.append(bounding_box)
start_point = (top, bottom)
end_point = (left, right)
rect = [start_point, end_point]
rectangles.append(rect)
#Car=CarObject(bounding_box,'car')
#ObjectsInFrame.append(Car)
frame_details = Frame(frame_no, bounding_boxes, rectangles)
return frame_details
def __init__(self, port=None, baud=115200, timeout=1):
if not port:
possible_devices = [
dev for dev in os.listdir('/dev/')
if ('usb' in dev or 'ACM' in dev)
and dev.startswith('tty')
]
if len(possible_devices) == 1:
device = possible_devices.pop()
else:
print "Possible devices:"
print possible_devices
device = raw_input("Please enter your usb device for the ardunio: ")
port = os.path.join('/dev', device)
self.port = port
self.baud = baud
self.timeout = timeout
print "Initializing..."
time.sleep(3)
self.serial = serial.Serial(port, baud, timeout=timeout)
print "USB connection established..."
time.sleep(3)
self._frame = Frame()
self.write_frame()
print "Lights reset"
def visitClassDecl(self, ast, c):
#ast:ClassDecl
#c:Any
emit = Emitter(self.path + "/" + ast.classname.name + ".j")
parentname = ast.parentname.name if ast.parentname else "java.lang.Object"
emit.printout(emit.emitPROLOG(ast.classname.name, parentname))
e = MethodEnv(emit, ast.classname.name, parentname, [])
#genAttribute
for x in self.env:
if ast.classname.name == x.cname:
for y in reversed(x.mem):
if type(y.mtype) is not MType:
isFinal = False if y.value is None else True
if type(y.sikind) is Static:
emit.printout(
emit.emitATTRIBUTE(y.name, y.mtype, isFinal,
""))
else:
emit.printout(
emit.emitATTRIBUTE(y.name, y.mtype, isFinal,
""))
break
### ------------
lstMethod = list(filter(lambda x: type(x) is MethodDecl, ast.memlist))
list(map(lambda x: self.visit(x, e), lstMethod))
# generate default constructor
self.genMETHOD(
MethodDecl(Instance(), Id("<init>"), list(), None,
Block(list(), list())), e, Frame("<init>", VoidType()))
emit.emitEPILOG()
return c
def testScheduleCompletion(self):
#Verify scheduling completion of an arrival
simulator = CSMA_CD_Simulator.CSMA_CD_Simulator(500)
#create first station
station1 = Station.Station(1, 20.0)
#create second station
station2 = Station.Station(2, 40.0)
#add stations to simulator
simulator.addStation(station1)
simulator.addStation(station2)
#create frame
msg1 = Frame(1, 'Hello Station 2', 1, 2)
#create event
evt1 = Event(Event.ARRIVAL, 123.45, 1, msg1)
#add event to q
simulator.addEvent(evt1)
#process event
simulator.processSingleEvent()
evtQ = simulator.evtQ
self.assertEquals(evtQ._qsize(), 2)
#evt2 = evtQ[0]
evt2 = evtQ.get()
self.assertEquals(evt2.eventType, Event.TRANSMIT_COMPLETE)
self.assertAlmostEquals(evt2.time, 126.73)
self.assertEquals(evt2.stationId, 1)
#evt3 = evtQ[1]
evt3 = evtQ.get()
def __init__(self, video_name):
self.filename = video_name
with open(self.filename, "rb") as header:
self.header = (header.readline()).decode("utf-8")
header_info = self.header.split(" ")
for info in header_info:
if info[0] == "W":
self.width = int(info[1:])
elif info[0] == "H":
self.height = int(info[1:])
elif info[0] == "F":
fps = info.split(":")
self.framerate = int(fps[0][1:])
self.frame = Frame(self.width, self.height)
def visitProgram(self, ast, c):
#ast: Program
#c: Any
self.emit.printout(
self.emit.emitPROLOG(self.className, "java.lang.Object"))
e = SubBody(None, self.env)
lsVar = list(filter(lambda x: type(x) is VarDecl, ast.decl))
lsArray = list(filter(lambda x: type(x.varType) is ArrayType, lsVar))
lsFunction = list(filter(lambda x: type(x) is FuncDecl, ast.decl))
#print static field and add to self.env
reduce(
lambda x, y: self.VarGlobal(y, x)
if type(y) is VarDecl else self.FuncGlobal(y, x), ast.decl,
self.env if self.env else [])
#visit FuncDecl
reduce(lambda x, y: self.visit(y, x), lsFunction,
SubBody(None, self.env))
#generate defaule constructor
self.genMETHOD(FuncDecl(Id("<init>"), [], None, Block([])), c,
Frame("<init>", VoidType))
# if lsArray:
# self.emit.printout(self.emit.emitCLINIT())
self.emit.emitEPILOG()
return c
def visitFuncDecl(self, ast, o):
glenv, isFirstTime = o
if isFirstTime:
inType = [x.varType for x in ast.param]
return [Symbol(ast.name.name, MType(inType, ast.returnType), CName(self.className))] + glenv
frame = Frame(ast.name.name, ast.returnType)
self.genMETHOD(ast, glenv, frame)
def handle_greeting_reguest(self, frame):
if self.is_tail:
#stop sending data, it overflows udp receive buffer
self.stop_sending_thread()
peer = frame.src_addr
#when this host was the first
if not self.peers:
self.is_head = True
#append self to the end once? while this host is tail
self.peers.append(self.host_as_peer)
self.group_sock.send_frame_to(
Frame(dst_addr=peer,
src_addr=self.host_as_peer,
type=FrameType.GreetingReply,
data=self.peers), (self.group, self.group_port))
#put new tail to the peers
self.reg_unknown_peer(peer)
#change topology
self.peer_sendto = peer
self.resume_sending_thread()
if self.is_head:
self.stop_sending_thread()
#change topology
self.peer_recvfrom = peer
self.resume_sending_thread()
def testAddEvent(self):
#test adding events to the simulator
simulator = CSMA_CD_Simulator.CSMA_CD_Simulator(
500) #500 meters diameter
station1 = Station.Station(1, 20.0)
station2 = Station.Station(2, 80.0)
simulator.addStation(station1)
simulator.addStation(station2)
msg1 = Frame(1, 'Hello Station 2', 1, 2)
msg2 = Frame(2, 'Hello Station 1', 2, 1)
evt1 = Event(Event.ARRIVAL, 123.45, 1, msg1)
evt2 = Event(Event.ARRIVAL, 234.56, 2, msg2)
simulator.addEvent(evt2)
simulator.addEvent(evt1) # not in time order
evtQ = simulator.evtQ
self.assertEquals(evtQ._qsize(), 2)
def process_request_frame(
in_frame: Frame,
seqno_table: dict,
timetables: dict,
frames_outstanding: dict,
) -> None:
print(
f"{NAME} received request frame {in_frame.to_string()}\nfrom {in_frame.src}"
)
origin_port = None
for port, name in NEIGHBOURS.items():
if name == in_frame.src:
origin_port = port
if not origin_port:
print(f"Couldn't find the port number of neighbour {in_frame.src}")
sys.exit(0)
if in_frame.dest == NAME:
# You've got mail!
response_frame = Frame(
NAME,
in_frame.origin,
NAME,
in_frame.seqno,
in_frame.time,
FrameType.RESPONSE
)
print(f"{NAME} received request for itself, responding")
UDP_SOCKET.sendto(response_frame.to_bytes(), (HOST, origin_port))
elif not seen_before(in_frame.origin, in_frame.seqno, seqno_table):
# Only forward the frame if we haven't seen it before
if len(NEIGHBOURS) > 1:
send_frame_to_neighbours(in_frame, timetables, frames_outstanding)
else:
# We have no other neighbours, respond immediately
response_frame = Frame(
in_frame.dest,
in_frame.origin,
NAME,
in_frame.seqno,
-1,
FrameType.RESPONSE
)
UDP_SOCKET.sendto(response_frame.to_bytes(), (HOST, origin_port))
seqno_table[in_frame.origin] = in_frame.seqno
else:
response_frame = Frame(
in_frame.dest,
in_frame.src,
NAME,
in_frame.seqno,
-1,
FrameType.RESPONSE
)
print(f"{NAME} dropping frame {in_frame.to_string()}")
def add_ball(self, pins):
for frame in self.frames:
if frame.is_pin_count_ok(pins):
frame.add_ball(pins)
current_frame = self.frames[-1]
if current_frame.is_full() and len(self.frames) < 10:
self.frames.append(Frame())
def setVideo(self, direccion):
cap = cv2.VideoCapture(direccion)
ret = True
while (ret):
ret, frame = cap.read()
f = Frame(frame)
self.frames.append(f)
cap.release()
def _on_message(self, msg):
if msg.startswith('a["') and msg.endswith("\u0000\"]"):
msg = u'\u0000'.join(msg.rsplit(
'\u0000', 1)).encode('utf-8').decode('string-escape')[3:-3]
msg = Frame.read_message_to_frame(msg)
if msg.cmd == 'MESSAGE':
if self.mh:
self.mh(msg)
def visitProgram(self, ast, c):
self.emit.printout(self.emit.emitPROLOG(self.className, "java/lang/Object"))
funcDecls = []
for d in ast.decl:
if isinstance(d, VarDecl):
self.env = self.visit(d, self.env)
if type(d.varType) is ArrayType:
self.arrayGlobals.append(d)
else:
funcDecls.append(d)
self.env = self.visit(d, (self.env, True))
for d in funcDecls:
self.visit(d, (self.env, False))
self.genCONSTRUCTOR(Frame("<init>", VoidType()))
if len(self.arrayGlobals) > 0:
self.genSTATICCONSTRUCTOR(Frame("<clinit>", VoidType()))
self.emit.emitEPILOG()
def visitFuncDecl(self, ast, o):
#ast: FuncDecl
#o: Any
subctxt = o
frame = Frame(ast.name, ast.returnType)
self.genMETHOD(ast, subctxt.sym, frame)
return SubBody(None, [Symbol(ast.name, MType(list(), ast.returnType), CName(self.className))] + subctxt.sym)
def visitFuncDecl(self, ast, o):
#ast: FuncDecl
#o: Any
subctxt = o
frame = Frame(ast.name, ast.returnType)
self.genMETHOD(ast, subctxt.sym, frame)
return
def pop_frame_from_stack(self):
if not self.stack_empty:
return Frame(self.get_frame_img(self.stack.pop()),
self.stack.pop())
else:
print(f' Source {self.ecam} is empty')
sys.exit(' Source Ended')
self.stack_empty_check()
def genMain(self, o):
methodname, methodtype = "main", MType([ArrayType(StringType())],
VoidType())
frame = Frame(methodname, methodtype.rettype)
self.emit.printout(
self.emit.emitMETHOD(methodname, methodtype, True, frame))
frame.enterScope(True)
varname, vartype, varindex = "args", methodtype.partype[
0], frame.getNewIndex()
startLabel, endLabel = frame.getStartLabel(), frame.getEndLabel()
self.emit.printout(
self.emit.emitVAR(varindex, varname, vartype, startLabel, endLabel,
frame))
self.emit.printout(self.emit.emitLABEL(startLabel, frame))
self.emit.printout(self.emit.emitPUSHICONST(120, frame))
sym = next(filter(lambda x: x.name == "string_of_int", o.sym))
self.emit.printout(
self.emit.emitINVOKESTATIC(sym.value.value + "/string_of_int",
sym.mtype, frame))
sym = next(filter(lambda x: x.name == "print", o.sym))
self.emit.printout(
self.emit.emitINVOKESTATIC(sym.value.value + "/print", sym.mtype,
frame))
self.emit.printout(self.emit.emitLABEL(endLabel, frame))
self.emit.printout(self.emit.emitRETURN(methodtype.rettype, frame))
self.emit.printout(self.emit.emitENDMETHOD(frame))
def get_frames_df(self, mongo_doc):
"""
sets self.frames_df to be a more complete index of
which frames, including which has what items already
"""
rows = []
for frame_dict in mongo_doc['frames'].values():
frame = Frame(self.db, frame_dict, frame_dict['root_dir'])
d = {k:frame.item_exists(k) for k in frame.keys() if not k == '_id'}
d['_id'] = frame_dict['_id']
d['root'] = frame_dict['root_dir']
rows.append(d)
df = pd.DataFrame(rows)
df.index = df['_id'].astype(int)
df.drop('_id', axis=1, inplace=True)
df.sort(inplace=True)
return df
def visitFuncDecl(self, ast, ctxt):
if ctxt.frame is None:
return SubBody(None, [
Symbol(ast.name.name,
MType([x.varType for x in ast.param], ast.returnType),
CName(self.className))
] + ctxt.sym)
else:
self.genMETHOD(ast, ctxt.sym, Frame(ast.name, ast.returnType))
def __init__(self, json_path):
self.frames = []
self.times = []
with open(json_path) as fl:
js = json.load(fl)
rc = js["robot_count"]
self.frame_dt = js["frame_dt"]
frames = js["frames"]
old_frame = Frame(
numRobots=rc,
robot_radius=js["robot_radius"],
frame_dt=self.frame_dt) #create empty frame for size rc robots
for f in frames:
new_frame = Frame(copy=old_frame) #set new frame as copy of old
new_frame.update(f) #update new frame with json
self.frames.append(new_frame) #append updated frame to self
self.times.append(float(self.frame_dt) * float(new_frame.step))
old_frame = new_frame #set new frame as old frame
def toxml(self, doc):
""" Convert this frame to XML. """
frame_xml = Frame.toxml(self, doc)
tag = Tag(doc, TAG_COQDOC)
if self._command_coqdoc:
map(tag.append, self._command_coqdoc)
frame_xml.append(tag)
return frame_xml
def __init__(self, particles, longRun = False):
# Save particle properties
self.maxMass = particles.movers[0].maxMass
self.maxVelocity = particles.movers[0].maxVelocity
self.masses = [particles.movers[i].mass for i in range(len(particles.movers))]
self.longRun = longRun # To toogle saving history (useful for long, continuous runs)
if longRun:
self.frames = Frame(particles)
else:
self.frames = []
self.currentFrameNo = 0
def set_gui():
gui = Tk()
frame_num = IntVar()
img_name = StringVar()
dicio = Frame.video_specifications()
gui.title(" Video Frame Manipulation")
Label(text="Video Frame Manipulation").grid(row=0, column=0, columnspan=2)
Label(text=" ").grid(row=1, column=0, columnspan=2)
Label(text=(dicio['size'], "Bytes")).grid(row=2, column=0, columnspan=2)
Label(text=(dicio['frames'], "Frames")).grid(row=3, column=0, columnspan=2)
Label(text=(dicio['time'], "Seconds")).grid(row=4, column=0, columnspan=2)
Label(text="Frame: ").grid(row=5, column=0)
Entry(gui, textvariable=frame_num, width=6).grid(row=5, column=1)
Label(text="Img Name: ").grid(row=6, column=0)
Entry(gui, textvariable=img_name, width=12).grid(row=6, column=1)
Label(text=" ").grid(row=7, column=0, columnspan=2)
Button(text="Show Frame", command=lambda: save_frame((frame_num.get()), img_name.get()).grid(row=8, column=0, columnspan=2))
gui.mainloop()
def test_AddFrame(self):
""" Addition of a frame in order should yield correct IDs """
frame1 = Frame(command = "command1", response = "response1")
self.movie.addFrame(frame1)
frame2 = Frame(command = "command2", response = "response2")
self.movie.addFrame(frame2)
frame3 = Frame(command = "command3", response = "response3")
self.movie.addFrame(frame3)
self.assertEquals(self.movie.getLength(), 3)
self.assertEquals(frame1.getId(), 0)
self.assertEquals(frame2.getId(), 1)
self.assertEquals(frame3.getId(), 2)
from _dbus_bindings import Boolean
from JLVideo import JLVideo
from extractor.Int16ImageExtractor import Int16ImageExtractor
# check for command-line file, use default if none given
parser = argparse.ArgumentParser()
parser.add_argument('-s', '--stream', help='the video file to stream', metavar='S', type=str, required=True)
parser.add_argument('--fps', help="frames per second", metavar='F', default=30, type=int)
parser.add_argument('--processor', help="processor to use", metavar='P', default='firemask', type=str)
parser.add_argument('--fullscreen', help="set output to fullsceen", action='store_true')
args = vars(parser.parse_args(sys.argv[1:]))
VIDEO_FILE = args['stream']
stack = True
if args['processor'] == 'firemask':
processor = SimpleTransformationProcessor(FireMask())
stack = False
#processor = MotionProcessor()
frame = Frame(processor, args['fps'], n=2, fullscreen=args['fullscreen'], stack=stack)
frame.addStream('rgb', VIDEO_FILE)
#video = JLVideo('SWIRCamera', '%05d_snap_SWIR.jl', Int16ImageExtractor(), n=2)
#frame.videoManager.videos['swir'] = video
#video.open('SWIRCamera')
frame.run()
frame.close()
def test_frame_init(self):
frame = Frame()
self.assertFalse(frame.is_full())
def __init__(self, id = -1, command = None,
command_cd = None,
response = None):
Frame.__init__(self, id = id, command = command, response = response)
self._command_coqdoc = command_cd or []
def test_invalid_frame(self):
frame = Frame()
frame.add_ball(3)
self.assertRaises(Exception, frame.add_ball, 8)
def fromxml(self, element):
""" Instantiate the data using the given element.
"""
Frame.fromxml(self, element)
map(self._command_coqdoc.append, element.find(TAG_COQDOC))
def get_strike_frame(self):
frame = Frame()
frame.add_ball(10)
return frame
def test_pin_count_ok_tooMany(self):
frame = Frame()
frame.add_ball(8)
self.assertFalse(frame.is_pin_count_ok(3))
def test_is_full_False_AfterOneBall(self):
frame = Frame()
frame.add_ball(7)
self.assertFalse(frame.is_full())
def __init__(self, *args): self.totalScore = 0 for Frame in args: self.totalScore += Frame.getScore()
def get_spare_frame(self):
frame = Frame()
frame.add_ball(3)
frame.add_ball(7)
return frame
def test_is_strike_True(self):
frame = Frame()
frame.add_ball(10)
self.assertTrue(frame.is_strike())
def test_is_strike_False(self):
frame = Frame()
frame.add_ball(7)
self.assertFalse(frame.is_strike())
frame.add_ball(3)
self.assertFalse(frame.is_strike())
def test_is_spare(self):
frame = Frame()
frame.add_ball(7)
self.assertFalse(frame.is_spare())
frame.add_ball(3)
self.assertTrue(frame.is_spare())
def fromxml(self, document):
""" Load the movie frames from the given xml document """
for element in document.movie.film:
frame = Frame()
frame.fromxml(element)
self.addFrame(frame)
def __init__(self):
self.frame = Frame()
self.frames = []
