def _on_connection_success(self):
print('Connected!')
conn_frame = Frame(CMD_CONNECT,
headers={'accept=version': '1.1,1.0', 'heart-beat': '10000,10000'})
sub_frame = Frame(CMD_SUBSCRIBE, headers={'id': 'sub-0', 'destination': self.sub_topic})
self.send(conn_frame.convert_to_data())
self.send(sub_frame.convert_to_data())
def visitFuncDecl(self, ast, c):
method_header = ''
frame = None
if (ast.name.name == 'main'):
frame = Frame('main', VoidType())
method_header = self.emit.emitMETHOD('main', MType(
[ArrayPointerType(StringType())], VoidType()), True, frame)
c.is_main = True
else:
c.is_main = False
frame = Frame(ast.name.name, ast.returnType)
method_header = self.emit.emitMETHOD(ast.name.name, MType(
[x.varType for x in ast.param], ast.returnType), True, frame)
self.emit.printout(method_header)
c.frame = frame
c.func_param = ast.param
c.is_body = True
c.return_type = ast.returnType
result = self.visit(ast.body, c)
self.emit.printout(self.emit.emitLIMITSTACK(frame.getMaxOpStackSize()))
self.emit.printout(self.emit.emitLIMITLOCAL(frame.getMaxIndex()))
self.emit.printout(result)
self.emit.printout(self.emit.emitENDMETHOD(frame))
def visitProgram(self, ast, c):
#ast: Program
#c: Any
self.emit.printout(self.emit.emitPROLOG(self.className, "java.lang.Object"))
staticDecl = self.env
for x in ast.decl:
if type(x) is FuncDecl:
paramType = [y.varType for y in x.param]
staticDecl = [Symbol(x.name.name.lower(), MType(paramType, x.returnType), CName(self.className))] + staticDecl
else:
newSymbol = self.visit(x, SubBody(None, None, isGlobal=True))
staticDecl = [newSymbol] + staticDecl
e = SubBody(None, staticDecl)
for x in ast.decl:
if type(x) is FuncDecl:
e = self.visit(x, e)
# generate default constructor
self.genMETHOD(FuncDecl(Id("<init>"), [], None, Block([])), c, Frame("<init>", VoidType))
self.genMETHOD(FuncDecl(Id("<clinit>"), [], None, Block([])), c, Frame("<clinit>", 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"))
lsVar = list(filter(lambda x: type(x) is VarDecl, ast.decl))
lsArrayVar = list(filter(lambda x: type(x.varType) is ArrayType,
lsVar))
lsFun = list(filter(lambda x: type(x) is FuncDecl, ast.decl))
# printout static field and add them to self.env
functools.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 func decl
functools.reduce(lambda a, b: self.visit(b, a), lsFun,
SubBody(None, self.env))
# generate default constructor
self.genMETHOD(FuncDecl(Id("<init>"), [], None, Block([])), c,
Frame("<init>", VoidType()))
if lsArrayVar:
self.emit.printout(
self.emit.emitCLINIT(self.className, lsArrayVar,
Frame("<clinit>", VoidType())))
self.emit.emitEPILOG()
return c
def visitProgram(self, ast, gloenvi):
'''
*print lines of directives
1. visit all vardecls in global and set static field
2. visit funcdecls
'''
gloenvi=self.env
self.emit.printout(self.emit.emitPROLOG(self.className, "java.lang.Object"))
#in global: frame = None
subBody = SubBody(None,gloenvi )
#visit Declarations:
'''
1. visit all var declarations in global
2. add func declarations in global to env (for calling inter functions)
3. visit all all func declarations
'''
for x in filter(lambda x: isinstance(x,VarDecl), ast.decl):
subBody = self.visit(x, subBody)
for x in filter(lambda x: isinstance(x,FuncDecl), ast.decl):
subBody.sym = [Symbol(x.name.name, MType([y.varType for y in x.param],x.returnType),CName(self.className))]+subBody.sym
for x in filter(lambda x: isinstance(x,FuncDecl), ast.decl):
subBody = self.visit(x, subBody)
# generate default constructor
initConstructor = FuncDecl(Id("<init>"), list(), None, Block(list()))
initClass = FuncDecl(Id("<clinit>"), list(), None, Block(list()))
self.genMETHOD(initConstructor, subBody.sym, Frame("<init>", VoidType))
self.genMETHOD(initClass, subBody.sym, Frame("<clinit>", VoidType))
self.emit.emitEPILOG()
return gloenvi
def runVideo(cap):
Frame.frame_width = cap.get(cv2.CAP_PROP_FRAME_WIDTH)
Frame.frame_height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
first_go = True
frame = None
current_frame = None
previous_frame = None
while (True):
if first_go != True:
previous_frame = Frame(current_frame.getFrame())
ret, frame = cap.read()
if ret == False:
break
else:
current_frame = Frame(frame)
if first_go != True:
difference_frame = current_frame.getDifferenceFrame(previous_frame)
thresholded_frame = difference_frame.getBinary(threshold=100)
dilated_frame = thresholded_frame.getDilated(iterations=10)
valid_contours = dilated_frame.findObjects(
minContourZone=settings.MIN_COUNTOUR_ZONE)
Tracker.registerNewObjects(valid_contours, current_frame)
# set which frame to display for user
ready_frame = current_frame
ready_frame.addBoundingBoxesFromContours(Tracker)
st.write("test")
ready_frame.putText("Threads: " + str(threading.active_count()),
(7, 20))
ready_frame.putText(
"Object Bufor size: " + str(len(Tracker.objectsToClassify)),
(7, 50))
ready_frame.putText("FPS: " + FPS.tick(), (7, 80))
ready_frame.putText(
"Cars passed: " + str(len(Tracker.lostObjects)), (7, 110))
ready_frame.putText("Test var: " + str(12), (7, 140))
ready_frame.show()
else:
first_go = False
current_frame.show()
if cv2.waitKey(1) & 0xFF == ord('q'):
logger('cars found: ' + str(Tracker.lostObjects), settings.LOG)
break
cap.release()
cv2.destroyAllWindows()
stopThreads()
def visitProgram(self, ast, c):
self.emit.printout(
self.emit.emitPROLOG(self.className, 'java.lang.Object'))
lstVarDecl = []
lstFuncDecl = []
for x in ast.decl:
if type(x) is VarDecl:
lstVarDecl += [x]
elif type(x) is FuncDecl:
lstFuncDecl += [x]
for x in ast.decl:
self.env += self.visitVarGlobal(
x, self.env) if type(x) is VarDecl else self.visitFunGlobal(
x, self.env)
for funDecl in lstFuncDecl:
self.visit(funDecl, SubBody(None, self.env))
self.genMETHOD(FuncDecl(Id("<init>"), [], None, []), c,
Frame("<init>", VoidType))
lstArrayType = []
for item in lstVarDecl:
if type(item.varType) is ArrayType:
lstArrayType += [item]
if lstArrayType:
self.emit.printout(
self.emit.emitCLINIT(self.className, lstArrayType,
Frame("<clinit>", 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(Frame(None, None), self.env)
list_fun = []
#visit de tao sym
for x in ast.decl:
if type(x) is FuncDecl:
list_fun = list_fun + [x]
else:
e = self.visit(x, e)
# print(','.join(str(x) for x in e.sym))
# visit doi voi fun_decl de tao constructor
# print(','.join(str(x) for x in list_fun))
for x in list_fun:
e = self.visit(x, e)
# print(','.join(str(x) for x in e.sym))
en_sym = e.sym
for func in list_fun:
# print(func)
e.frame.name = func.name
e.frame.returnType = func.returnType
self.genMETHOD(func, en_sym, e.frame)
# generate default constructor
self.genMETHOD(FuncDecl(Id("<init>"), list(), list(), list(), None),
e.sym, 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"))
lst_VarDecl = []
for x in ast.decl:
if type(x) is VarDecl:
self.visit(x, SubBody(None, self.env))
lst_VarDecl.insert(
0,
Symbol(x.variable, self.visit(x.varType, c),
CName(self.className)))
else:
isMain = x.name.name == "main"
intype = [ArrayPointerType(StringType())] if isMain else [
self.visit(i.varType, c) for i in x.param
]
self.env.insert(
0,
Symbol(x.name.name, MType(intype, x.returnType),
CName(self.className)))
# list(map(lambda x: self.visit(x, SubBody(None, self.env)) if type(x) is FuncDecl else None, ast.decl))
[
self.visit(x, SubBody(None, self.env)) 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))
#generate function for static array global
self.genMETHOD(FuncDecl(Id("<clinit>"), list(), None, Block(list())),
lst_VarDecl, Frame("<clinit>", VoidType))
self.emit.emitEPILOG()
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 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 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_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)
def send_command(self, cmd):
if self.cmds["send"]:
m = self.cmds["send"].match(cmd)
if m:
analogue = m.group("analogue") == "a"
digital = not analogue
try:
f = Frame()
f.setValue(
int(m.group("node")),
int(m.group("index")),
m.group("aValue") if analogue else int(
m.group("dValue")),
decimals=int(m.group("decimals"))
if analogue else False,
analogue=analogue,
digital=digital,
)
self.udp_server.sendFrame(f)
except Exception as e:
logging.error(e)
return False
return True
return False
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 parsing(self):
with open(self.sampleFilePath, 'r') as f:
frameCount = f.readline().split(' ')
frameCount = int(frameCount[0])
for frameIte in range(frameCount):
currentFrame = Frame(frameIte)
bodyCount = f.readline().split(' ')
bodyCount = int(bodyCount[0])
for _ in range(bodyCount):
metaData = f.readline().strip().split(' ')
jointCount = f.readline().strip().split(' ')
jointCount = int(jointCount[0])
currentSkeleton = Skeleton(jointCount, metaData)
for jointIte in range(jointCount):
jointInfoLine = f.readline()
jointInfo = np.array(jointInfoLine.strip().split(' '),
dtype='float')
currentSkeleton.appendJoint(jointIte,
jointVec=jointInfo)
#jointList.append(Joint(jointInfo))
currentFrame.appendSkeleton(currentSkeleton)
self.frameList.append(currentFrame)
self.frameNum += 1
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 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 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 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 main(filename, outname, nframes=-1, natoms=-1):
"""
Perform analysis of dipoles in LAMMPS trajectory
:param lammpstrj: Filename of LAMMPS trajectory
:return: Number of frames in trajectory
"""
reader = FrameReader(filename)
if natoms < 0:
natoms = reader.total_atoms
else:
natoms = min(natoms, reader.total_atoms)
if nframes < 0:
nframes = reader.total_frames
else:
nframes = min(nframes, reader.total_frames)
frame = Frame(natoms)
with FrameWriter(outname) as writer:
for i in xrange(nframes):
# Read in frame from trajectory and process
progressBar(i, nframes)
reader.readFrame(i, frame)
frame.centreOnMolecule(1)
writer.writeFrame(i, frame)
return nframes
def process_image(image):
lanes_found = True
leftx_pixel_pos = []
lefty_pixel_pos = []
rightx_pixel_pos = []
righty_pixel_pos = []
frame = Frame(l_line, r_line, mtx, dist)
# call method to return lane line pixels
lanes_found, leftx_pixel_pos, lefty_pixel_pos, \
rightx_pixel_pos, righty_pixel_pos = frame.get_raw_line_pixels(image)
l_line.set_ploty(frame.ploty)
r_line.set_ploty(frame.ploty)
# if a lane was found....
if lanes_found:
left_fit = l_line.fit_poly_lines(leftx_pixel_pos, lefty_pixel_pos)
right_fit = r_line.fit_poly_lines(rightx_pixel_pos, righty_pixel_pos)
left_fitx = l_line.get_line_poly_pix(left_fit)
right_fitx = r_line.get_line_poly_pix(right_fit)
l_line.addline(left_fit, left_fitx)
r_line.addline(right_fit, right_fitx)
# frame.visualise_poly()
else:
print('no lines found')
image_with_marking = frame.create_output_drive_view(frame.image_undistorted, \
l_line, r_line, frame.Minv)
return image_with_marking
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 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 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 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 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 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 __init__(self, frame_g):
self.mass = 1500 # mass of car
self.frame_a = Frame() # local frame
self.frame_a.v[0] = 20
self.frame_g = frame_g # non inertial frame for whole sim
self.frame_ag = self.frame_a.transform(self.frame_g) # veh with respect to non inertial frmae
self.izz = 3500.0
self.ics = np.array([self.frame_a.pos[0], self.frame_a.v[0], self.frame_a.pos[1], self.frame_a.v[1], self.frame_a.theta, self.frame_a.omega])
self.result = {'f_fy': [],
'r_fy': [],
'steer': [],
'theta': [],
'beta': [],
'omega': [],
'alpha': [],
'f_sa': [],
'r_sa': [],
'time': [],
'vx': [],
'vy': [],
'ax': [],
'ay': [],
'rax': [],
'ray': [],
'x': [],
'y': []}
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()
