def fill_buffer(self, frame_queue, buffer_size):
'''
this function is to fill the buffer with initial frames.
'''
prev_idx = self.detection_data[0][0]
j = 0
t = buffer_size
frame = None
while t > 0:
coordinates = (self.detection_data[j][1],
self.detection_data[j][2],
self.detection_data[j][3],
self.detection_data[j][4])
if (self.detection_data[j][0] != prev_idx):
image_path = join(self.detection_imgs_path,
str(prev_idx).zfill(8) + '.jpg')
# image_path = join(self.detection_imgs_path, str(prev_idx).zfill(8))
# print(image_path)
img = cv2.imread(image_path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
frame.set_img(img)
frame_queue.append(frame)
t -= 1
if self.detection_data[j][0] != prev_idx or j == 0:
frame = Frame(self.detection_data[j][0])
frame.add_box(Box(coordinates, self.detection_data[j][5]))
prev_idx = self.detection_data[j][0]
j += 1
self.last_added_frame_index = frame.frame_indx
self.last_readed_row = j - 1
def GetPose(): f = Frame() pose = pointerBody.GetPositionCartesian() if pose.GetValid(): # if visible f.FromVctFrm3(pose.Position()) f.IsValid = True #else return just the identity return f
def __init__(self, parent, game):
self.game = game
Frame.__init__(self, parent)
self.parent = parent
self.row, self.col = -1, -1
self.__initUI()
def GetReference():
f = Frame()
pose = referenceBody.measured_cp()
if pose.GetValid(): # if visible
f.FromVctFrm3(pose.Position())
f.IsValid = True
#else return just the identity
return f
def __init__(self, node, name):
self.node = node.createChild(name) # node
self.collision = None # the added collision mesh if any
self.visual = None # the added visual model if any
self.dofs = None # dofs
self.mass = None # mass
self.frame = Frame.Frame()
self.framecom = Frame.Frame()
self.fixedConstraint = None # to fix the RigidBody
def __init__(self, taxis_matrix=[]):
self.index = 0
if len(taxis_matrix) > 0:
self.frames = [Frame(taxis_coods=taxis_matrix[0])]
for i in range(1, len(taxis_matrix)):
self.add_frame(
Frame(previous_frame=self.frames[i - 1],
taxis_coods=taxis_matrix[i]))
class Game:
def __init__(self, size):
pygame.init()
self.size = size
self.screen = pygame.display.set_mode(size, 0, 32)
self.color = black
pygame.display.set_caption('PACMAN FOREVER YOUNG')
self.run = True
self.frame = Frame((50, 50, 1100, 800), cyan, 4)
self.pacman = Pacman(self.frame)
# game speed = number of operations per sec
self.game_speed = 60
self.lines = []
def escape_loop(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.run = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.run = False
def main_loop(self):
time = pygame.time.Clock()
while self.run:
# manage a speed of the game
time.tick(self.game_speed)
keys_pressed = pygame.key.get_pressed()
if keys_pressed[pygame.K_DOWN]:
self.pacman.set_direction(3)
elif keys_pressed[pygame.K_UP]:
self.pacman.set_direction(1)
if keys_pressed[pygame.K_RIGHT]:
self.pacman.set_direction(2)
elif keys_pressed[pygame.K_LEFT]:
self.pacman.set_direction(4)
if keys_pressed[pygame.K_SPACE]:
self.pacman.set_direction(0)
self.escape_loop()
# Fill the background
self.screen.fill(self.color)
# draw Frame
pygame.draw.rect(self.screen, self.frame.get_color(),
self.frame.get_prop(), self.frame.get_thickness())
# Move the Hero
self.pacman.move(self.screen)
# Draw line behind the Hero
pygame.draw.circle(self.screen, green, (170, 450), 5)
# Draw the Hero
self.screen.blit(self.pacman.show(),
(self.pacman.get_x(), self.pacman.get_y()))
pygame.display.flip()
def GetAllPoses():
trTool = Frame()
trTool.FromVctFrm3(pointerBody.measured_cp().Position())
trArm = Frame()
trArm.FromVctFrm3(armBody.measured_cp().Position())
trBase = Frame()
trBase.FromVctFrm3(referenceBody.measured_cp().Position())
return trTool, trArm, trBase
def __init__(self, size):
pygame.init()
self.size = size
self.screen = pygame.display.set_mode(size, 0, 32)
self.color = black
pygame.display.set_caption('PACMAN FOREVER YOUNG')
self.run = True
self.frame = Frame((50, 50, 1100, 800), cyan, 4)
self.pacman = Pacman(self.frame)
# game speed = number of operations per sec
self.game_speed = 60
self.lines = []
def run(self):
oldbary = [self.bary[0], self.bary[1]]
cap = cv2.VideoCapture(self.nom_video)
ret, im = cap.read()
for i in range(self.debut):
ret, im = cap.read()
frame = Frame.Frame(im, self.bary, self.bac, self.angle, self.seuil,
self.horizontal)
cpt = 0
while (cap.isOpened()):
if ret == True:
im = cv2.resize(im, (0, 0), 0, self.scale, self.scale,
cv2.INTER_AREA)
im = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
frame = Frame.Frame(im, frame.bary, self.bac, self.angle,
self.seuil, self.horizontal)
frame.mouseActualisation()
self.actualiseGrid(oldbary, frame.bary, frame.im.shape[0],
frame.im.shape[1])
self.dparc = self.dparc + np.sqrt(
(frame.bary[0] - oldbary[0])**2 +
(frame.bary[1] - oldbary[1])**2)
## Debug : voir ce qu'il se passe pour chaque Frame ##############################################################
# print("oldbary-bary")
# print(oldbary,frame.bary)
# frame.showFrame(self.l_pix)
# self.grid.plotGrid()
##################################################################################################################
oldbary = [frame.bary[0], frame.bary[1]]
else:
break
if cpt > self.fps * 15 * 60:
# if cpt > 2:
break
ret, im = cap.read()
cpt = cpt + 1
cap.release()
cv2.destroyAllWindows()
def tofile(meshfile, bodyA, bodyB, sampleData, outfile):
"""
:param meshfile: path to file that defines surface mesh
:param bodyA: path to file that defines rigid body A
:param bodyB: path to file that defines rigid body B
:param sampleData: path to file that contains frames of sample data
:param outfile: path to file to write output to
:type meshfile: str
:type bodyA: str
:type bodyB: str
:type sampleData: str
:type outfile: str
"""
vCoords, vIndices = icpf.meshDef(meshfile)
nledA, ledA, tipA = icpf.bodyDef(bodyA)
nledB, ledB, tipB = icpf.bodyDef(bodyB)
aFrames, bFrames = icpf.readSample(sampleData, nledA, nledB)
d_kPoints = icp.findTipB(aFrames, bFrames, ledA, tipA, ledB)
s_i = icp.computeSamplePoints(d_kPoints, fr.Frame(np.identity(3), np.zeros(3)))
c_kPoints = icp.ICPmatch(s_i, vCoords, vIndices)
dist = icp.calcDifference(c_kPoints, d_kPoints)
writefile(d_kPoints, c_kPoints, dist, outfile)
def register(self, b):
"""
Performs rigid-body registration with respect to another point cloud b, and returns the corresponding frame
transformation.
:param b: The point cloud being mapped to
:type b: PointCloud
:return: The Frame transformation F = [r, p] from current frame to b
:rtype: Frame.Frame
"""
# NOTE: data, b are arrays of column vectors
a_bar = np.mean(self.data, axis=1, keepdims=True)
b_bar = np.mean(b.data, axis=1, keepdims=True)
a_tilde = self.data - a_bar
b_tilde = b.data - b_bar
# Method using SVD to directly solve for R
H = a_tilde.dot(b_tilde.T)
u, s, v_t = scialg.svd(H)
u = u.T
v_t = v_t.T
correction = np.identity(v_t.shape[1])
correction[-1, -1] = scialg.det(v_t.dot(u))
r = v_t.dot(correction.dot(u))
p = b_bar - r.dot(a_bar)
return Frame.Frame(r, p)
def create(self,
maze_position=(screen_settings.screen_size[0] // 2,
screen_settings.screen_size[1]),
display_type=0,
graph_bool=False,
cell_size_constant=1):
"""
:param tuple maze_position: center of position; default: middle of screen
:param int display_type: fullscreen = 0, half screen = 1, quarter_screen = 2
:param bool graph_bool: if True displays the graph of the maze; delfault = True
"""
self.position = maze_position
self.cell_size = int(
cell_size_constant * MazeFunctions.cell_size_calculate(
display_type, self.type_value, self.size, graph_bool))
self.graph_cell_size = MazeFunctions.graph_cell_size_calculate(
self.type_value, self.cell_size)
CellList.create(self.cell_list, self.type_value, maze_position,
display_type, graph_bool, self.cell_size)
(start,
end) = MazeFunctions.cell_endpoints_calculate(self.type_value,
self.size)
self.start = self.cell_list[start]
self.end = self.cell_list[end]
self.frame_list = Frame.generation(self.type_value, self.cell_list)
def RadarDataRelateBasedonMachineLearning(realData = False, machineLearnEnable = False,mlModelType = 'KNN', totalSimuFile = 30, totalFramePerSimu = 10):
mlModel = None
if machineLearnEnable == True:#训练机器学习模型
mlModel = RadarMl.RadarML(mlModelType)
mlModel.DatasetProc(simu=True,scale_en= True, poly_en=False)
mlModel.Train()
if realData == True:#如果利用真实航迹作为数据源，则需要将真实数据进行分帧处理
Frame.FrameCreat(save_en=True, plot_en=True, fakerate=50, sample_rate=5)
for simuFileNo in range(totalSimuFile): #对每一个仿真文件进行航迹关联处理
processOutput = sys.stdout # 标准图像输出
plt.figure(figsize=(5, 40), dpi=100) # 设置输出图像画布大小
plt.vlines(x=[-5.5, -1.8, 1.8, 5.5], ymin=0, ymax=40, colors='yellow') # 画出车道线
tmpTracksList, totalTmpTracks = tmpTracksListInit() #初始化临时航迹列表
tmpStoragePoints,totalTmpStoragePoints = tmpStoragePointsInit() #初始化临时点迹列表
for frameNo in range(totalFramePerSimu): #从文件中读取每帧量测
if realData == True:
frameInfor = Frame.FrameRead(frameNo)
else:
frameInfor = Frame.SimuFrameRead(simuFileNo,frameNo)
count = frameNo / (totalFramePerSimu - 1) * 100 #计算显示每个仿真文件的处理进程
processOutput.write(f'\r PROCESSING percent:{count:.0f}%')
if machineLearnEnable == True:#机器学习模型应用于雷达量测分类
frameInfor, mlMissPoints = mlModel.Applicate(frameInfor,scale_en=True)
else:
mlMissPoints = pd.DataFrame([],columns=['Angle','Speed','X_position','Y_position','Target'])
#对雷达量测进行航迹关联
[frameInfor, tmpTracksList, tmpStoragePoints, totalTmpStoragePoints] = TrackRelate(frameInfor, tmpTracksList, totalTmpTracks, tmpStoragePoints, totalTmpStoragePoints,mlModel,machineLearnEnable = machineLearnEnable)
#删除关联失败的航迹信息
[tmpTracksList, totalTmpTracks, tmpStoragePoints, totalTmpStoragePoints, delete_points] = TrackDelet(tmpTracksList, totalTmpTracks, tmpStoragePoints, totalTmpStoragePoints)
#没有正确关联的点作为新航迹
[tmpTracksList, totalTmpTracks] = TrackNewDevelop(frameInfor, tmpTracksList, totalTmpTracks)
#绘制关联成功的航迹
[tmpStoragePoints, totalTmpStoragePoints] = TrackDraw(frameInfor, tmpTracksList, tmpStoragePoints, totalTmpStoragePoints, delete_points,mlMissPoints=mlMissPoints)
processOutput.flush
plt.xlim((-7, 7))#坐标属性设置
plt.ylim((0, 40))
plt.xlabel("X(m)")
plt.ylabel("Y(m)")
plt.show()
plt.pause(0)#暂停显示关联结果
return
def addAbsoluteOffset(self,
name,
offset=[0, 0, 0, 0, 0, 0, 1],
isMechanical=True):
## adding a offset given in absolute coordinates to the offset
return RigidBody.Offset(self.node, name,
(Frame.Frame(offset) *
self.frame.inv()).offset(), isMechanical)
def generate_frames(self):
can_create = self._memory_size % self._instructions_per_frame == 0
if can_create:
index = 0
print("Creating frames...")
for split in xrange(0, self._memory_size, self._instructions_per_frame):
self._frames.append(Frame(index, split, split + self._instructions_per_frame - 1))
index += 1
def __init__(self,**kwargs):
n = kwargs.get('n',"app")
x = kwargs.get('x',0)
y = kwargs.get('y',0)
w = kwargs.get('w',0)
h = kwargs.get('h',0)
t = kwargs.get('t',"Application")
self.main = Frame(n,x,y,w,h,t)
return
def setFromRigidInfo(self,
info,
offset=[0, 0, 0, 0, 0, 0, 1],
inertia_forces=False):
self.framecom = Frame.Frame()
self.framecom.rotation = info.inertia_rotation
self.framecom.translation = info.com
self.frame = Frame.Frame(offset) * self.framecom
self.dofs = self.frame.insert(self.node,
name='dofs',
template="Rigid3" + template_suffix)
self.mass = self.node.createObject('RigidMass',
name='mass',
mass=info.mass,
inertia=concat(
info.diagonal_inertia),
inertia_forces=inertia_forces)
def addAbsoluteMappedPoint(self,
name,
position=[0, 0, 0],
isMechanical=True):
## adding a position given in absolute coordinates to the rigid body
frame = Frame.Frame()
frame.translation = position
return RigidBody.MappedPoint(
self.node, name, (frame * self.frame.inv()).translation,
isMechanical)
def addMappedPoint(self,
name,
relativePosition=[0, 0, 0],
isMechanical=True):
## adding a relative position to the rigid body
# @warning the translation due to the center of mass offset is automatically removed. If necessary a function without this mechanism could be added
frame = Frame.Frame()
frame.translation = relativePosition
return RigidBody.MappedPoint(self.node, name,
(self.framecom.inv() * frame).translation,
isMechanical)
def addVisualModel(self,
filepath,
scale3d=[1, 1, 1],
offset=[0, 0, 0, 0, 0, 0, 1],
name_suffix=''):
## adding a visual model to the rigid body with a relative offset
# @warning the translation due to the center of mass offset is automatically removed. If necessary a function without this mechanism could be added
self.visual = RigidBody.VisualModel(
self.node, filepath, scale3d,
(self.framecom.inv() * Frame.Frame(offset)).offset(), name_suffix)
return self.visual
def addCollisionMesh(self,
filepath,
scale3d=[1, 1, 1],
offset=[0, 0, 0, 0, 0, 0, 1],
name_suffix=''):
## adding a collision mesh to the rigid body with a relative offset
# (only a Triangle collision model is created, more models can be added manually)
# @warning the translation due to the center of mass offset is automatically removed. If necessary a function without this mechanism could be added
self.collision = RigidBody.CollisionMesh(
self.node, filepath, scale3d,
(self.framecom.inv() * Frame.Frame(offset)).offset(), name_suffix)
return self.collision
def draw_summary(draw, forecast, fontpath, frame):
text = forecast.hourly().summary
font = ImageFont.truetype(fontpath, 30)
width = Frame.width(frame)
wrapped = font_utils.wrap_text_to_width(text, font, width - 20)
size = draw.textsize(wrapped, font)
draw.text((halfwidth + 10, halfheight - (size[1] / 2)),
wrapped,
font=font,
fill=0)
class Application:
def __init__(self,**kwargs):
n = kwargs.get('n',"app")
x = kwargs.get('x',0)
y = kwargs.get('y',0)
w = kwargs.get('w',0)
h = kwargs.get('h',0)
t = kwargs.get('t',"Application")
self.main = Frame(n,x,y,w,h,t)
return
def run(self):
while(self.main.Win.is_open):
self.main.Update()
self.main.Draw()
return
def setBackgroundColor(self,x):
self.main.setBackgroundColor(x)
return
def addComponent(self,x):
self.main.addComponent(x)
def move_list(data):
move_list=[]
curr_move=Move()
curr_frame=Frame()
last_frameid=None;
for row in range(0, len(data)):
if (data[row]):
#Each row represents a finger in a frame
curr_finger=Finger(data[row])
#Handle the first entry
if (row==0):
curr_frame.id=curr_finger.frame
curr_frame.Fingers.append(curr_finger)
curr_frame.numFingers+=1
else:
#A new frame has begun
if (curr_frame.id!=curr_finger.frame):
#Check if the old frame was still or stopped (i.e. fingers lifted off)
#and if so, end the last move and add it to the list of moves.
if(curr_frame.is_still()) or (curr_frame.is_stopped()):
#We don't care about collecting still-frame data so just disregard it
#but end the move accordingly.
#We know the current move has ended so added it to the list of moves
#but only if there are frames in it, this is to mitigate the fact that
#WHENEVER there is a still frame a new Move obj is created, but
#we don't care about these.
if (curr_move.Framelist):
curr_move.endAngle=curr_frame.Fingers[0].angle #Only looks at one finger
curr_move.endXVel=curr_frame.Fingers[0].xvel #Only looks at one finger
move_list.append(curr_move)
curr_move=Move()
#The last frame was neither still nor stopped, but we need to add it
#to the current move.
else:
if (not curr_move.Framelist):
curr_move.startAngle=curr_frame.Fingers[0].angle #Not actually accurate e.g. it only looks at one finger
curr_move.startXVel=curr_frame.Fingers[0].xvel #Not accurate, see above.
curr_move.Framelist.append(curr_frame)
if (curr_frame.numFingers > curr_move.maxFingers):
curr_move.maxFingers=curr_frame.numFingers
if (curr_frame.numFingers < curr_move.minFingers):
curr_move.minFingers=curr_frame.numFingers
#Update the current frame
curr_frame=Frame()
curr_frame.id=curr_finger.frame
curr_frame.Fingers.append(curr_finger)
curr_frame.numFingers+=1
#A new frame has not begun but there are more fingers to add to it.
else:
curr_frame.Fingers.append(curr_finger)
curr_frame.numFingers+=1
if (curr_move.Framelist):
curr_move.endAngle=curr_frame.Fingers[0].angle #Only looks at one finger
curr_move.endXVel=curr_frame.Fingers[0].xvel #Only looks at one finger
move_list.append(curr_move)
return move_list
def initialize(self):
'''
It's better to call this method after create all objects'''
self.timeNow = now.time()
if self.frame :
print('Frame already created')
else :
self.frame = Frame.Frame(self)
self.updateScreen()
self.mouse = Mouse.Mouse(self)
self.keyboard = Keyboard.Keyboard(self)
self.running = True
def mass_from_mesh(self, name, density=1000.0):
info = generate_rigid(name, density)
self.mass = info.mass
# TODO svd inertia tensor, extract rotation quaternion
self.inertia = [
info.inertia[0, 0], info.inertia[1, 1], info.inertia[2, 2]
]
self.offset = Frame.Frame()
self.offset.translation = info.com
def __init__(self, name="unnamed"):
self.name = name # node name
self.collision = None # collision mesh
self.visual = None # visual mesh
self.dofs = Frame.Frame() # initial dofs
self.mass = 1 # mass
self.inertia = [1, 1, 1] # inertia tensor
self.color = [1, 1, 1] # not sure this is used
self.offset = None # rigid offset for com/inertia axes
self.inertia_forces = 0 # 0: disabled, 1: explicit, 2: implicit
self.group = None
self.mu = 0 # friction coefficient
self.scale = [1, 1, 1]
def render(self, frame, boxsampler):
"""
takes a set of objects and renders the frame
boxsapmler is a sampler of bounding boxes (from the prior)
"""
renderedboxes = []
for i in frame.boundingboxes:
if random.random() < self.detectionprob:
renderedboxes.append(i)
if random.random() < self.illusionprob:
for j in range(len(np.random.poisson(self.illusionlambda))):
renderedboxes.append(boxsampler.sample())
return Frame.Frame(renderedboxes)
def setManually(self,
offset=[0, 0, 0, 0, 0, 0, 1],
mass=1,
inertia=[1, 1, 1],
inertia_forces=False):
## create the rigid body by manually giving its inertia
self.frame = Frame.Frame(offset)
self.dofs = self.frame.insert(self.node,
name='dofs',
template="Rigid3" + template_suffix)
self.mass = self.node.createObject('RigidMass',
name='mass',
mass=mass,
inertia=concat(inertia),
inertia_forces=inertia_forces)
def _FindCovFrame(self, *args):
"""
Finds the frame of this covariance tree node.
:param args: Either just the number of triangles, or the number of triangles and a list of triangles.
:type args: integer and [Triangle]
:return: The frame of this covariance tree node
:rtype: fr.Frame
"""
if len(args) == 1:
points = None
num_triangles = args[0]
for i in range(num_triangles):
if i == 0:
points = self.triangle_list[i].corners.data.tolist()
else:
for p in self.triangle_list[i].corners.data.tolist():
points.append(p)
points = np.array(points).squeeze().T
return self._FindCovFrame(points, num_triangles * 3)
elif len(args) == 2:
points = args[0][:, 0:args[1]]
c = np.mean(points, axis=1, keepdims=True)
u = points - c
A = u.dot(u.T)
evals, evecs = np.linalg.eig(A)
inds = evals.argsort()[::-1]
max_evec = evecs[inds[0]]
coeffs = np.zeros((3, 9))
coeffs[(0, 1, 2), (0, 3, 6)] = 1.0
r = np.linalg.lstsq(coeffs, max_evec)[0].reshape((3, 3))
u, s, v = np.linalg.svd(r)
correction = np.eye(3)
correction[-1, -1] = scialg.det(v.T.dot(u.T))
r = u.dot(correction.dot(v))
return fr.Frame(r, c)
def main():
parser = argparse.ArgumentParser("Extract frames from a media file\n")
parser.add_argument(
'-O',
'--out',
dest='dstfmt',
help="Set destination folder and format of frames extracted")
parser.add_argument('-N',
'--nframes',
dest='nframes_requested',
type=int,
help="Save up to nframes")
parser.add_argument('-B',
'--bulksave',
dest='bulksave',
action='store_true',
help="Enable bulk saving")
parser.add_argument('-S',
'--sepsave',
dest='sepsave',
action='store_true',
help="Enable seperated save")
parser.add_argument('-I',
'--infile',
dest='infile',
help="Media file to be extracted from")
args = parser.parse_args()
if (args.infile == None):
print(f'{sys.argv[0]}: fatal error: no input file\nTerminating.')
exit(1)
if (args.dstfmt == None):
print(
f'{sys.argv[0]}: fatal error: output format not supplied\nTerminating.'
)
exit(1)
f = Frame.Frame()
f.open(args.infile)
f.extract(dstfmt=args.dstfmt, nframes=60, skip=1)
f.extract(dstfmt=args.dstfmt,
nframes=args.nframes_requested,
bulksave=args.bulksave,
sepsave=args.sepsave)
f.close()
def main():
##########################################################
############ 通过读取帧文件获取数据 ###############
##########################################################
hough_frame = pd.DataFrame([])
#读取数据
for i in range(5):
frame_infor = Frame.SimuFrameRead(i)
infor = [hough_frame, frame_infor]
hough_frame = pd.concat(infor, ignore_index=True)
#hough_frame = SunLearn.MyClassify(hough_frame)#利用机器学习算法对点迹进行分类
x_idxs = hough_frame['X_position']
y_idxs = hough_frame['Y_position']
x_idxs.index = range(len(x_idxs))
y_idxs.index = range(len(y_idxs))
##########################################################
##########################################################
################通过自定义点获取数据######################
##########################################################
# x1 = [0, 1, 2, 3, 4, -10]
# y1 = [10, 10, 10, 10, 10, 10]
#
# x2 = [0, 1, 2, 3, 4, 5, 6]
# y2 = [7, 8, 9, 10, 11, 12, 13]
#
# x3 = [5, 5, 5, 5, 5, 5]
# y3 = [23, 24, 25, 26, 27, 28]
#
# x4 = [-8, -7, -6, -5, -4, -3, -2, -1, 0]
# y4 = [22, 21, 20, 19, 18, 17, 16, 15, 14]
#
# x_idxs = x4 + x3 + x2 + x1
# y_idxs = y4 + y3 + y2 + y1
##########################################################
[theta, rho] = hough_line(x_idxs, y_idxs, angle_step=2) #霍夫直线检测
theta, rho = theta_fuse(theta, rho, 30) #角度融合
Pointsplot(x_idxs, y_idxs) # 画出需要检测直线的点
plt.show()
Pointsplot(x_idxs, y_idxs) # 画出需要检测直线的点
lineplot(theta, rho) #根据参数画出直线
return
def performTransmissions(A, K, F, e, R, rnd):
f = Frame.Frame(K, F)
elapsed_time = 0
frames_total = 0
frames_correct = 0
while elapsed_time < R:
# transmission time is the feedback time + 1 time unit per bit
elapsed_time += A + F + f.getWastedData()
frames_total += 1
if f.performErrorChance(e, rnd):
# Successful transmission
frames_correct += 1
return [elapsed_time, frames_total, frames_correct]
from Planet import * from Spaceship import * from Frame import * import time frame = Frame() objects = [] ##Appel des fonctions pour le système solaire et le vaisseau soleil = Planet(None, "Soleil", 1.99e30, 1.39e6, 0, 0) soleil.x = frame.frame.winfo_screenwidth()/2 soleil.y = frame.frame.winfo_screenheight()/2 mercure = Planet(soleil, "Mercure", 3.29e23, 4.88e3, 5.79e7, 61.76) venus = Planet(soleil, "Venus", 4.87e24, 1.21e4, 1.08e8, -1.2) terre = Planet(soleil, "Terre", 5.97e24, 1.27e4, 1.49e8, 0) lune = Planet(terre, "Lune", 7.35e22, 3.47e3, 3.84e5, 0) mars = Planet(soleil, "Mars", 6.42e23, 6.78e3, 2.27e8, 7.37) jupiter = Planet(soleil, "Jupiter", 1.90e27, 1.40e5, 7.79e8, 82.87) saturne = Planet(soleil, "Saturne", 5.68e26, 1.16e5, 1.42e9, 5.32) uranus = Planet(soleil, "Uranus", 8.68e25, 5.07e4, 2.88e9, -54.7) neptune = Planet(soleil, "Neptune", 1.02e26, 4.92e4, 4.50e9, -96.2) vaisseau = Spaceship(soleil.x, soleil.y) objects.append(soleil) objects.append(mercure) objects.append(venus) objects.append(terre) objects.append(lune)
def cpu(self):
"""
the first main frame should return to the HALT instruction, which is the last
quadruple
"""
HALTinstIdx = len(self.code) - 1
mainMethodFrame = Frame(self.mainMethod, HALTinstIdx)
mainObject = ObjectSpace(self.mainClass)
mainMethodFrame.registers[0] = mainObject
self.callStack.push(mainMethodFrame)
quadruple = self.code[self.ip]
toBeInvokedFrame = None
while (quadruple.opCode != "HALT" and self.ip < len(self.code)):
registers = self.callStack.peek().registers #shortcut to current stack registers
self.ip = self.ip + 1 #almost all the instructions should increment the ip
#if not, the instruction should take care of it
if(quadruple.opCode == "+"):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
op3 = int(quadruple.op3)
registers[offset(op3)] = registers[offset(op1)] + registers[offset(op2)]
elif(quadruple.opCode == "-"):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
op3 = int(quadruple.op3)
registers[offset(op3)] = registers[offset(op1)] - registers[offset(op2)]
elif(quadruple.opCode == "*"):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
op3 = int(quadruple.op3)
registers[offset(op3)] = registers[offset(op1)] * registers[offset(op2)]
elif(quadruple.opCode == "/"):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
op3 = int(quadruple.op3)
registers[offset(op3)] = registers[offset(op1)] / registers[offset(op2)]
elif(quadruple.opCode == "or"):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
op3 = int(quadruple.op3)
registers[offset(op3)] = registers[offset(op1)] or registers[offset(op2)]
elif(quadruple.opCode == "and"):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
op3 = int(quadruple.op3)
registers[offset(op3)] = registers[offset(op1)] and registers[offset(op2)]
elif(quadruple.opCode == "=="):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
op3 = int(quadruple.op3)
registers[offset(op3)] = registers[offset(op1)] == registers[offset(op2)]
elif(quadruple.opCode == "!="):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
op3 = int(quadruple.op3)
registers[offset(op3)] = registers[offset(op1)] != registers[offset(op2)]
elif(quadruple.opCode == ">="):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
op3 = int(quadruple.op3)
registers[offset(op3)] = registers[offset(op1)] >= registers[offset(op2)]
elif(quadruple.opCode == ">"):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
op3 = int(quadruple.op3)
registers[offset(op3)] = registers[offset(op1)] > registers[offset(op2)]
elif(quadruple.opCode == "<="):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
op3 = int(quadruple.op3)
registers[offset(op3)] = registers[offset(op1)] <= registers[offset(op2)]
elif(quadruple.opCode == "<"):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
op3 = int(quadruple.op3)
registers[offset(op3)] = registers[offset(op1)] < registers[offset(op2)]
elif(quadruple.opCode == "PRINT"):
op1 = int(quadruple.op1)
print(str(registers[offset(op1)]), end = "")
elif(quadruple.opCode == "PRINTLINE"):
print()
elif(quadruple.opCode == "READINT"):
op1 = int(quadruple.op1)
read = input()
try:
tmp = int(read)
except ValueError:
exit("ERROR Inesperado: Se leyo una literal no valida en readint(): " + read)
registers[offset(op1)] = tmp
elif(quadruple.opCode == "READDOUBLE"):
op1 = int(quadruple.op1)
read = input()
try:
tmp = float(read)
except ValueError:
exit("ERROR Inesperado: Se leyo una literal no valida en readdouble(): " + read)
registers[offset(op1)] = tmp
elif(quadruple.opCode == "READCHAR"):
op1 = int(quadruple.op1)
read = input()
if(len(read) > 1):
exit("ERROR Inesperado: Se leyo mas de un caracter en readchar(): " + read)
registers[offset(op1)] = read
elif(quadruple.opCode == "GOTOFALSE"):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
if(not registers[offset(op1)]):
self.ip = op2
elif(quadruple.opCode == "GOTO"):
op1 = int(quadruple.op1)
self.ip = op1
elif(quadruple.opCode == "CCONST"):
op1 = quadruple.op1
op2 = int(quadruple.op2)
registers[offset(op2)] = chr(ord(op1))
elif(quadruple.opCode == "DCONST"):
op1 = float(quadruple.op1)
op2 = int(quadruple.op2)
registers[offset(op2)] = op1
elif(quadruple.opCode == "ICONST"):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
registers[offset(op2)] = op1
elif(quadruple.opCode == "="):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
registers[offset(op2)] = registers[offset(op1)]
elif(quadruple.opCode == "ERA"):
op1 = quadruple.op1
methodToBeInvoked = self.methodsDirectory[op1]
toBeInvokedFrame = Frame(methodToBeInvoked, -1) #the return address of the invokedFrame should be set in the GOSUB/GOSUBVOID.
#here we leave it pending with a -1
elif(quadruple.opCode == "PARAM"):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
toBeInvokedFrame.registers[op2] = registers[offset(op1)]
elif(quadruple.opCode == "GOSUB"):
op1 = quadruple.op1
op2 = int(quadruple.op2)
invokedMethodSymbol = self.methodsDirectory[op1]
callerFrame = self.callStack.peek()
callerFrame.tempReturned = op2 #register that will be used to store the value that invokedFrame will return. No offseted yet
toBeInvokedFrame.returnAddress = self.ip
self.callStack.push(toBeInvokedFrame)
self.ip = invokedMethodSymbol.firstQuadrupleIdx
elif(quadruple.opCode == "GOSUBVOID"):
op1 = quadruple.op1
invokedMethodSymbol = self.methodsDirectory[op1]
callerFrame = self.callStack.peek()
toBeInvokedFrame.returnAddress = self.ip
self.callStack.push(toBeInvokedFrame)
self.ip = invokedMethodSymbol.firstQuadrupleIdx
elif(quadruple.opCode == "RETURN"):
op1 = int(quadruple.op1)
returnValue = registers[offset(op1)]
popedFrame = self.callStack.pop()
callerFrame = self.callStack.peek()
callerFrame.registers[offset(callerFrame.tempReturned)] = returnValue
self.ip = popedFrame.returnAddress
elif(quadruple.opCode == "RETURNVOID"):
popedFrame = self.callStack.pop()
self.ip = popedFrame.returnAddress
elif(quadruple.opCode == "SHOULD_RETURN_SOMETHING_ERROR"):
op1 = quadruple.op1
exit("ERROR Inesperado: Metodo " + op1 + " no regreso nada...")
elif(quadruple.opCode == "OBJECT"):
op1 = int(quadruple.op1)
op2 = quadruple.op2.strip()
clase = self.classesDirectory[op2]
obj = ObjectSpace(clase)
registers[offset(op1)] = obj
elif(quadruple.opCode == "PUTFIELD"):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
op3 = int(quadruple.op3)
registers[offset(op2)].fields[op3] = registers[offset(op1)]
elif(quadruple.opCode == "GETFIELD"):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
op3 = int(quadruple.op3)
registers[offset(op1)] = registers[offset(op2)].fields[op3]
elif(quadruple.opCode == "VERIFYARRAYACCESS"):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
if(registers[offset(op1)] < 0 or registers[offset(op1)] >= op2):
exit("ERROR Inesperado: Indice " + str(registers[offset(op1)]) + " fuera de rango en acceso a elemento de arreglo.")
elif(quadruple.opCode == "GETARRAYELEM"):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
registers[offset(op2)] = registers[offset(registers[offset(op1)])]
elif(quadruple.opCode == "PUTARRAYELEM"):
op1 = int(quadruple.op1)
op2 = int(quadruple.op2)
registers[offset(registers[offset(op1)])] = registers[offset(op2)]
else:
print("Cuadruplo no reconocido: " + quadruple.opCode)
quadruple = self.code[self.ip]
from Planet import * from Spaceship import * from Frame import * from Maths import * from Point import * from File import * import time frame = Frame() objects = [] points = [] soleil = Planet(None, "Soleil", 1.99e30, 1.39e6, 0, 0, 0) soleil.x = frame.tkFrame.winfo_screenwidth()/2 soleil.y = frame.tkFrame.winfo_screenheight()/2 soleil.speedX = 0 soleil.speedY = 0 #Définition: parent, name, mass, diam, dist, speed, theta mercure = Planet(soleil, "Mercure", 3.29e23, 4.88e3, 5.79e10, 47879.56, 308) venus = Planet(soleil, "Venus", 4.87e24, 1.21e4, 1.08e11, 35057.23, 168) terre = Planet(soleil, "Terre", 5.97e24, 1.27e4, 1.49e11, 29846.70, 175) lune = Planet(terre, "Lune", 7.35e22, 3.47e3, 3.84e8, 1018.32, 113.8) mars = Planet(soleil, "Mars", 6.42e23, 6.78e3, 2.27e11, 24181.13, 313) jupiter = Planet(soleil, "Jupiter", 1.90e27, 1.40e5, 7.79e11, 13053.31, 309) saturne = Planet(soleil, "Saturne", 5.68e26, 1.16e5, 1.42e12, 30573.51, 168) uranus = Planet(soleil, "Uranus", 8.68e25, 5.07e4, 2.88e12, 6788.80, 353) neptune = Planet(soleil, "Neptune", 1.02e26, 4.92e4, 4.50e12, 5431.04, 324) vaisseau = Spaceship(200, 200)
def __init__(self):
Frame.__init__(self)
self._uniqueID = None
self._doneCallbacks = []
self._failCallbacks = []
from Planet import * from Spaceship import * from Frame import * from Maths import * import time frame = Frame() objects = [] soleil = Planet(None, "Soleil", 1.99e30, 1.39e6, 0, 0) soleil.x = frame.frame.winfo_screenwidth()/2 soleil.y = frame.frame.winfo_screenheight()/2 mercure = Planet(soleil, "Mercure", 3.29e23, 4.88e3, 5.79e7, 308) venus = Planet(soleil, "Venus", 4.87e24, 1.21e4, 1.08e8, 168) terre = Planet(soleil, "Terre", 5.97e24, 1.27e4, 1.49e8, 175) lune = Planet(terre, "Lune", 7.35e22, 3.47e3, 3.84e5, 113.8) mars = Planet(soleil, "Mars", 6.42e23, 6.78e3, 2.27e8, 313) jupiter = Planet(soleil, "Jupiter", 1.90e27, 1.40e5, 7.79e8, 309) saturne = Planet(soleil, "Saturne", 5.68e26, 1.16e5, 1.42e9, 168) uranus = Planet(soleil, "Uranus", 8.68e25, 5.07e4, 2.88e9, 353) neptune = Planet(soleil, "Neptune", 1.02e26, 4.92e4, 4.50e9, 324) vaisseau = Spaceship(300, 300) objects.append(soleil) objects.append(mercure) objects.append(venus) objects.append(terre) objects.append(lune)
def OnInit(self):
self.main = Frame.create(None)
self.main.Show()
self.SetTopWindow(self.main)
return True
