def addPlayer(self, player):
"""
Adds a player in this room
"""
#we look for the first free racket to give to the player, if there was 3 players and the second one left
#the new player will play in second position
#TODO : it would be better to search for the None value and insert there instead of for-break !!! check : no
#regression !
for axisID in self.players.keys():
if self.players[axisID] == None:
#free racket found
self.players[axisID] = player
newPseudo = False
#if the new player uses a name which is already in use, we add some random digits at the end and tell
#him !
if player.name == self.players[axisID ^ 1].name:
newPseudo = True
player.name += str(random.randint(1, 9))
if player.name != "" and newPseudo:
player.msgNewPseudo(player.name)
#restart the trajectory (we must because the number of players has changed so have the rules)
self.trajectory.stop()
del self.trajectory
self.trajectory = Trajectory(self)
break
def crd2traj( self ):
"""
Convert coordinates into a Trajectory object.
@return: trajectory object
@rtype: Trajectory
"""
## skip first empty line
self.crd.readline()
xyz = []
i = 0
if self.verbose: self.log.write( "Reading frames .." )
try:
while 1==1:
xyz += [ self.nextFrame() ]
i += 1
if i % 100 == 0 and self.verbose:
self.log.write( '#' )
except EOFError:
if self.verbose: self.log.add("Read %i frames." % i)
t = Trajectory( refpdb=self.ref )
t.frames = N.array( xyz ).astype(N.Float32)
t.setRef( self.ref )
t.ref.disconnect()
return t
def __init__(self, parent, machine):
super(TrajectoryWidget, self).__init__(parent, machine)
self.name = "TrajectoryWidget"
self.icon = os.path.join(os.path.realpath(os.path.dirname(__file__)),
'resources', 'icons',
'format-text-direction-ltr.png')
self.tooltip = "Trajectory workspace"
self.machine.add_listener(self)
self.trajectory = Trajectory()
self.trajectory_controller = TrajectoryControllerThread()
self.limits = None
# References to widgets
self.calibrationFileButton = None
self.calibrationFileLineEdit = None
self.pointsFileButton = None
self.pointsFileLineEdit = None
self.loadButton = None
self.graphicsView = None
self.trajectoryComboBox = None
self.indexComboBox = None
self.stepSpinBox = None
self.xScaleSpinBox = None
self.yScaleSpinBox = None
self.xOffsetSpinBox = None
self.yOffsetSpinBox = None
self.stopButton = None
self.runButton = None
# Image-related
self.pixmap = QtGui.QPixmap()
self.original_rect = None
self.loadUI()
self.update()
def __init__(self, pdbs=None, refpdb=None, n_members=10, **kw):
"""
Create EnsembleTraj from PDB files or pickled PDBModels. The file names
are used for alphabetical sorting and must lead to an ordering first
by time then by member (i.e. frame_10_01.pdb where 10 is the time step
and 01 is the member index). Unlike normal alphabetical order,
frame_2_2 sorts before frame_10_10, i.e. we attempt to interprete
numbers contained in the frame name strings.
@param pdbs: file names of all conformations OR PDBModels
@type pdbs: [ str ] OR [ PDBModel ]
@param refpdb: file name of reference pdb
@type refpdb: str
@param n_members: number or tjajectories in the ensemble
@type n_members: int
@param kw: optional key=value pairs, see L{Biskit.Trajectory}.
@type kw: key=value
@raise EnsembleTrajError: if member trajectories don't have
equal number of frame
"""
Trajectory.__init__(self, pdbs, refpdb, **kw)
self.n_members = n_members
if self.frameNames is not None:
self.sortFrames()
if self.n_members and self.frames is not None and \
len( self ) % self.n_members != 0:
raise EnsembleTrajError,\
'Member trajectories must have equal number of frames.'
def __init__(self, pdbs=None, refpdb=None, n_members=10, **kw ):
"""
Create EnsembleTraj from PDB files or pickled PDBModels. The file names
are used for alphabetical sorting and must lead to an ordering first
by time then by member (i.e. frame_10_01.pdb where 10 is the time step
and 01 is the member index). Unlike normal alphabetical order,
frame_2_2 sorts before frame_10_10, i.e. we attempt to interprete
numbers contained in the frame name strings.
@param pdbs: file names of all conformations OR PDBModels
@type pdbs: [ str ] OR [ PDBModel ]
@param refpdb: file name of reference pdb
@type refpdb: str
@param n_members: number or tjajectories in the ensemble
@type n_members: int
@param kw: optional key=value pairs, see L{Biskit.Trajectory}.
@type kw: key=value
@raise EnsembleTrajError: if member trajectories don't have
equal number of frame
"""
Trajectory.__init__( self, pdbs, refpdb, **kw )
self.n_members = n_members
if self.frameNames != None:
self.sortFrames()
if self.n_members and self.frames is not None and \
len( self ) % self.n_members != 0:
raise EnsembleTrajError,\
'Member trajectories must have equal number of frames.'
def get_traj_set(self):
""" generated source for method get_traj_set """
result = []
prev_id = 1
try:
tmp = None
index = 0
for line in self.reader:
if index == 0:
index = index + 1
continue
obj_id = int(line[0])
if tmp == None:
tmp = Trajectory(obj_id)
if tmp != None and obj_id != prev_id:
result.append(tmp)
tmp = Trajectory(obj_id)
prev_id = obj_id
point = STPoint(obj_id, float(line[1]), float(line[2]),
float(line[3]))
tmp.points.append(point)
except Exception as e:
print(e.message)
return result
def shrinkUniverse(universe, temperature=300.*Units.K, trajectory=None,
scale_factor=0.95):
"""Shrinks |universe|, which must have been scaled up by
Function:MMTK.Solvation.addSolvent, back to its original size.
The compression is performed in small steps, in between which
some energy minimization and molecular dynamics steps are executed.
The molecular dynamics is run at the given |temperature|, and
an optional |trajectory| (a MMTK.Trajectory.Trajectory object or
a string, interpreted as a file name) can be specified in which
intermediate configurations are stored.
"""
# Set velocities and initialize trajectory output
universe.initializeVelocitiesToTemperature(temperature)
if trajectory is not None:
if type(trajectory) == type(''):
trajectory = Trajectory(universe, trajectory, "w",
"solvation protocol")
close_trajectory = 1
else:
close_trajectory = 0
actions = [TrajectoryOutput(trajectory, ["configuration"], 0, None, 1)]
snapshot = SnapshotGenerator(universe, actions=actions)
snapshot()
# Do some minimization and equilibration
minimizer = SteepestDescentMinimizer(universe, step_size = 0.05*Units.Ang)
actions = [VelocityScaler(temperature, 0.01*temperature, 0, None, 1),
TranslationRemover(0, None, 20)]
integrator = VelocityVerletIntegrator(universe, delta_t = 0.5*Units.fs,
actions = actions)
for i in range(5):
minimizer(steps = 40)
integrator(steps = 200)
# Scale down the system in small steps
i = 0
while universe.scale_factor > 1.:
if trajectory is not None and i % 1 == 0:
snapshot()
i = i + 1
step_factor = max(scale_factor, 1./universe.scale_factor)
for object in universe:
object.translateTo(step_factor*object.position())
universe.scaleSize(step_factor)
universe.scale_factor = universe.scale_factor*step_factor
for i in range(3):
minimizer(steps = 10)
integrator(steps = 50)
del universe.scale_factor
if trajectory is not None:
snapshot()
if close_trajectory:
trajectory.close()
def test_discretize_path(self):
traj = Trajectory()
traj.load_paths_from_svg(self.svg_filepath)
self.assertEqual(len(traj.paths), 2)
discrete_traj = traj.discretize(traj.paths[0], 1)
self.assertEqual(len(discrete_traj), 377)
for point in discrete_traj:
self.assertEqual(len(point), 2)
def test_discretize_path(self):
traj = Trajectory()
traj.load_paths_from_svg(self.svg_filepath)
self.assertEqual(len(traj.paths), 2)
discrete_traj = traj.discretize(traj.paths[0], 1)
self.assertEqual(len(discrete_traj), 377)
for point in discrete_traj:
self.assertEqual(len(point), 2)
def test_path_is_homogeneously_sampled(self):
test_path = Path(Line(start=(0+0j), end=(5+0j)))
expected_result = [(0,0), (1,0), (2,0), (3,0), (4,0), (5,0)]
traj = Trajectory()
traj.paths.append(test_path)
result = traj.get_path(0, 0, 1)
for (x1, y1), (x2, y2) in zip(result, expected_result):
self.assertAlmostEqual(x1, x2, delta=0.01)
self.assertAlmostEqual(y1, y2, delta=0.01)
def test_path_is_homogeneously_sampled(self):
test_path = Path(Line(start=(0 + 0j), end=(5 + 0j)))
expected_result = [(0, 0), (1, 0), (2, 0), (3, 0), (4, 0), (5, 0)]
traj = Trajectory()
traj.paths.append(test_path)
result = traj.get_path(0, 0, 1)
for (x1, y1), (x2, y2) in zip(result, expected_result):
self.assertAlmostEqual(x1, x2, delta=0.01)
self.assertAlmostEqual(y1, y2, delta=0.01)
def replaceContent( self, traj ):
"""
Replace content of this trajectory by content of given traj.
No deep-copying, only references are taken.
@param traj: trajectory
@type traj: trajectory
@note: Overrides Trajectory method.
"""
Trajectory.replaceContent( self, traj )
self.n_members = traj.n_members
def replaceContent(self, traj):
"""
Replace content of this trajectory by content of given traj.
No deep-copying, only references are taken.
@param traj: trajectory
@type traj: trajectory
@note: Overrides Trajectory method.
"""
Trajectory.replaceContent(self, traj)
self.n_members = traj.n_members
def test_extract_paths_from_svg(self):
traj = Trajectory()
path_strings = traj._extract_paths_from_svg(self.svg_filepath)
self.assertEqual(len(path_strings), 2)
self.assertEqual(
path_strings[0],
"M 99.75,67.46875 C 71.718268,67.468752 73.46875,79.625 73.46875,79.625 L 73.5,92.21875 L 100.25,92.21875 L 100.25,96 L 62.875,96 C 62.875,96 44.9375,93.965724 44.9375,122.25 C 44.937498,150.53427 60.59375,149.53125 60.59375,149.53125 L 69.9375,149.53125 L 69.9375,136.40625 C 69.9375,136.40625 69.433848,120.75 85.34375,120.75 C 101.25365,120.75 111.875,120.75 111.875,120.75 C 111.875,120.75 126.78125,120.99096 126.78125,106.34375 C 126.78125,91.696544 126.78125,82.125 126.78125,82.125 C 126.78125,82.124998 129.04443,67.46875 99.75,67.46875 z M 85,75.9375 C 87.661429,75.937498 89.8125,78.088571 89.8125,80.75 C 89.812502,83.411429 87.661429,85.5625 85,85.5625 C 82.338571,85.562502 80.1875,83.411429 80.1875,80.75 C 80.187498,78.088571 82.338571,75.9375 85,75.9375 z "
)
self.assertEqual(
path_strings[1],
"M 100.5461,177.31485 C 128.57784,177.31485 126.82735,165.1586 126.82735,165.1586 L 126.7961,152.56485 L 100.0461,152.56485 L 100.0461,148.7836 L 137.4211,148.7836 C 137.4211,148.7836 155.3586,150.81787 155.3586,122.53359 C 155.35861,94.249323 139.70235,95.252343 139.70235,95.252343 L 130.3586,95.252343 L 130.3586,108.37734 C 130.3586,108.37734 130.86226,124.03359 114.95235,124.03359 C 99.042448,124.03359 88.421098,124.03359 88.421098,124.03359 C 88.421098,124.03359 73.514848,123.79263 73.514848,138.43985 C 73.514848,153.08705 73.514848,162.6586 73.514848,162.6586 C 73.514848,162.6586 71.251668,177.31485 100.5461,177.31485 z M 115.2961,168.8461 C 112.63467,168.8461 110.4836,166.69503 110.4836,164.0336 C 110.4836,161.37217 112.63467,159.2211 115.2961,159.2211 C 117.95753,159.2211 120.1086,161.37217 120.1086,164.0336 C 120.10861,166.69503 117.95753,168.8461 115.2961,168.8461 z "
)
def test_get_path_not_starting_at_0(self):
test_path = Path(Line(start=(0+0j), end=(2+2j)),
Line(start=(2+2j), end=(7+1j)),
Line(start=(7+1j), end=(0+0j)))
expected_result = Trajectory.discretize(Path(Line(start=(2+2j), end=(7+1j)),
Line(start=(7+1j), end=(0+0j)), Line(start=(0+0j), end=(2+2j))), 1)
traj = Trajectory()
traj.paths.append(test_path)
result = traj.get_path(0, 1, 1)
self.assertEqual(result, expected_result)
def run(self):
env = gym.make("CartPole-v0") # Create the environment
episode_done = True
trajectory = Trajectory()
next_state = []
episode_num = 0
episode_reward = 1 # TODO: check for alternative init rewards
while True:
if self.stop: # Check if we need to stop the current thread
print("Worker:",self.worker_id, "STOP")
break
if episode_done: # Check if the episode is done
state = env.reset() # Reset the environment and recover initial state
episode_done = False
template = "in worker {}, episode {} done after {} steps" # Template for print
print(template.format(self.worker_id, episode_num, episode_reward))
self.res_queue.put(episode_reward)
episode_num += 1
episode_reward = 1
for i in range(LOOKAHEAD):
#print("I=",i)
if self.is_eval(): # Render curretn state of the environement
env.render()
state = tf.convert_to_tensor(state) # Convert state to tensor
state = tf.expand_dims(state, 0)
action = self.act(state) # Select action based on the current policy.
trajectory.store(s=state, a=action)
state, reward, episode_done, _ = env.step(action) # Recover next state, reward and if the episode is done.
#print("|New state\n",state,"\n|reward: \n",reward," \n|episode done \n",episode_done)
if episode_done: # If the agent fails the task
reward = -1
# Store the reward
trajectory.store(r=reward)
episode_reward += reward
next_state = state # update current state
if episode_done:
next_state = []
break
if episode_done and self.is_eval():
if self.is_eval():
env.close()
template = "in worker {}, episode {} done after {} steps" # Template for print
print(template.format(self.worker_id, episode_num, episode_reward))
break
if not self.is_eval():
self.train(trajectory, next_state)# Update network using the trajectory
trajectory.clear()
def test_get_path_not_starting_at_0(self):
test_path = Path(Line(start=(0 + 0j), end=(2 + 2j)),
Line(start=(2 + 2j), end=(7 + 1j)),
Line(start=(7 + 1j), end=(0 + 0j)))
expected_result = Trajectory.discretize(
Path(Line(start=(2 + 2j), end=(7 + 1j)),
Line(start=(7 + 1j), end=(0 + 0j)),
Line(start=(0 + 0j), end=(2 + 2j))), 1)
traj = Trajectory()
traj.paths.append(test_path)
result = traj.get_path(0, 1, 1)
self.assertEqual(result, expected_result)
def test_bounding_box(self):
discrete_traj = [(0, 0), (2, 2), (7, 1)]
test_bounding_box = [(0, 0), (7, 2)]
bounding_box = Trajectory.bounding_box(discrete_traj)
self.assertEqual(bounding_box, test_bounding_box)
def __init__(self, parent, machine):
super(TrajectoryWidget, self).__init__(parent, machine)
self.name = "TrajectoryWidget"
self.icon = os.path.join(os.path.realpath(os.path.dirname(__file__)), 'resources', 'icons', 'format-text-direction-ltr.png')
self.tooltip = "Trajectory workspace"
self.machine.add_listener(self)
self.trajectory = Trajectory()
self.trajectory_controller = TrajectoryControllerThread()
self.limits = None
# References to widgets
self.calibrationFileButton = None
self.calibrationFileLineEdit = None
self.pointsFileButton = None
self.pointsFileLineEdit = None
self.loadButton = None
self.graphicsView = None
self.trajectoryComboBox = None
self.indexComboBox = None
self.stepSpinBox = None
self.xScaleSpinBox = None
self.yScaleSpinBox = None
self.xOffsetSpinBox = None
self.yOffsetSpinBox = None
self.stopButton = None
self.runButton = None
# Image-related
self.pixmap = QtGui.QPixmap()
self.original_rect = None
self.loadUI()
self.update()
def __init__(self,dir):
self.dir = dir
self.learning_network = Network(49,128)
self.learning_network.load_state_dict(torch.load(self.dir))
self.learning_network.eval()
self.curr_network = Network(49, 128)
self.curr_network.load_state_dict(torch.load(self.dir))
self.curr_network.eval()
self.env = Environment()
self.trajectory_size = 5000
self.trajectory = Trajectory(self.trajectory_size)
self.optimizer = torch.optim.SGD(self.learning_network.parameters(), lr=1e-3,weight_decay=10e-4, momentum=0.9)
self.tree = Tree(self.curr_network)
def test_bounding_box(self):
discrete_traj = [(0,0), (2,2), (7,1)]
test_bounding_box = [(0,0), (7,2)]
bounding_box = Trajectory.bounding_box(discrete_traj)
self.assertEqual(bounding_box, test_bounding_box)
def addPlayer(self,player):
"""
Adds a player in this room
"""
#we look for the first free racket to give to the player, if there was 3 players and the second one left
#the new player will play in second position
#TODO : it would be better to search for the None value and insert there instead of for-break !!! check : no
#regression !
for axisID in self.players.keys():
if self.players[axisID] == None:
#free racket found
self.players[axisID] = player
newPseudo = False
#if the new player uses a name which is already in use, we add some random digits at the end and tell
#him !
if player.name == self.players[axisID ^ 1].name:
newPseudo = True
player.name += str(random.randint(1, 9))
if player.name != "" and newPseudo:
player.msgNewPseudo(player.name)
#restart the trajectory (we must because the number of players has changed so have the rules)
self.trajectory.stop()
del self.trajectory
self.trajectory = Trajectory(self)
break
def version( self ):
"""
Version of class.
@return: version
@rtype: str
"""
return Trajectory.version(self) + '; EnsembleTraj $Revision$'
def version(self):
"""
Version of class.
@return: version
@rtype: str
"""
return Trajectory.version(self) + '; EnsembleTraj $Revision$'
def getUpTrajectory(self, coords):
lineM = LineMovement(270, 800)
movements = []
movements.append(lineM)
trajectory = Trajectory(self.gameParams, movements, coords, incr=10)
trajectories = []
trajectories.append(trajectory)
return trajectories
def removePlayer(self, player):
"""
Delete a player from the room.
"""
self.players[player.axis] = None
player.msgGstat() #tells the players that there is one player less
if self.player_nb() == 0: #empty room => deleted room
self.trajectory.stop()
del self.trajectory
self.rooms.remove(self)
self.site.msgTotalNumberOfRooms(
) #tells the player that there is one room less
elif self.player_nb() == 1:
#we try to pair the player left alone with an other solo player
for room in self.rooms[:]:
if room.player_nb() == 1 and room != self:
#we have found a game "room" with 1 player ("room!=self" allows not to choose the previous game of the player)
playerToMove = self.players[
player.axis ^
1] #player.axis ^ 1 gives the other player of the room
self.trajectory.stop()
del self.trajectory
self.rooms.remove(self)
#playerToMove.reset() #use it if we want that the coming player beginns with score = 0
playerToMove.room = room
playerToMove.axis = room.players.values().index(None)
room.addPlayer(playerToMove)
playerToMove.msgGstat()
playerToMove.msgSyncJ()
self.rooms.remove(room)
self.rooms.append(room)
self.site.msgTotalNumberOfRooms()
break
else:
otherPlayer = self.players[player.axis ^ 1]
self.trajectory.stop()
del self.trajectory
self.trajectory = Trajectory(self)
#if otherPlayer.axis == 1:
# self.players[1]= None
# otherPlayer.axis =0
# self.players[0] = otherPlayer
otherPlayer.msgGstat()
otherPlayer.msgSyncJ()
self.site.msgTotalNumberOfRooms(otherPlayer)
def test_scale_path(self):
discrete_traj = [(0,0), (2, 2), (7, 1)]
discrete_test_traj = [(0,0), (4, 1), (14,0.5)]
scaled_traj = Trajectory.scale(discrete_traj, 2, 0.5)
for (x, y) , (test_x, test_y) in zip(scaled_traj, discrete_test_traj):
self.assertAlmostEqual(x, test_x, delta=0.01)
self.assertAlmostEqual(y, test_y, delta=0.01)
def test_translate_path(self):
discrete_traj = [(0,0), (2, 2), (7, 1)]
discrete_test_traj = [(3,3.5), (5, 5.5), (10,4.5)]
translated_traj = Trajectory.translate(discrete_traj, 3, 3.5)
for (x, y) , (test_x, test_y) in zip(translated_traj, discrete_test_traj):
self.assertAlmostEqual(x, test_x, delta=0.01)
self.assertAlmostEqual(y, test_y, delta=0.01)
def update(self, trajectories_key):
for el in trajectories_key:
if el.has_key("trajectory"):
rid = el["robot_id"]
self.trajectories[rid] = Trajectory(json_file=el["trajectory"])
if el.has_key("discrete_path"):
rid = el["robot_id"]
self.discrete_paths[rid] = DiscretePath(
json=el["discrete_path"])
def test_scale_path(self):
discrete_traj = [(0, 0), (2, 2), (7, 1)]
discrete_test_traj = [(0, 0), (4, 1), (14, 0.5)]
scaled_traj = Trajectory.scale(discrete_traj, 2, 0.5)
for (x, y), (test_x, test_y) in zip(scaled_traj, discrete_test_traj):
self.assertAlmostEqual(x, test_x, delta=0.01)
self.assertAlmostEqual(y, test_y, delta=0.01)
def test_translate_path(self):
discrete_traj = [(0, 0), (2, 2), (7, 1)]
discrete_test_traj = [(3, 3.5), (5, 5.5), (10, 4.5)]
translated_traj = Trajectory.translate(discrete_traj, 3, 3.5)
for (x, y), (test_x, test_y) in zip(translated_traj,
discrete_test_traj):
self.assertAlmostEqual(x, test_x, delta=0.01)
self.assertAlmostEqual(y, test_y, delta=0.01)
def simulate_trajectory(self, robot, vx, vtheta):
poses = []
current_pose = [robot.pose.x, robot.pose.y, robot.pose.theta]
for i in range(0, int(self.time / self.timestep)):
current_pose[0] += (vx * math.cos(current_pose[2])) * self.timestep
current_pose[1] += (vx * math.sin(current_pose[2])) * self.timestep
current_pose[2] += vtheta * self.timestep
new_pose = Pose(current_pose[0], current_pose[1], current_pose[2])
poses.append(new_pose)
return Trajectory(poses=poses, velocity=Velocity(vx, vtheta), cost=0)
def align_trajectory(trajectory0: Trajectory,
trajectory1: Trajectory) -> Trajectory:
# Align trajectory1 to trajectory0
assert isinstance(trajectory0, Trajectory)
assert isinstance(trajectory1, Trajectory)
t0 = max(trajectory0.begin_time(), trajectory1.begin_time())
t1 = min(trajectory0.end_time(), trajectory1.end_time())
if t0 >= t1:
return Trajectory()
num_points = 100
times = np.linspace(t0, t1, num_points).tolist()
points0 = [trajectory0[t].x() for t in times]
points1 = [trajectory1[t].x() for t in times]
S = umeyama(points0, points1).to_SE3()
trajectoryA = S * trajectory0
return trajectoryA
def getTrajectory(self,
stepselection=[],
usealigned=True,
framestep=1,
frameselection=[]):
"""
Get Trajectory object for current replica. If stepselection is given, only
files corresponding to those steps will be returned. If usealigned is True,
will try to use aligned trajectory if it exists.
:arg list stepselection: List of ints identifying steps to return as trajectory. Will return all if empty.
:arg bool usealigned: Use aligned trajectory if possible.
:return: :class:`Trajectory.Trajectory` object
"""
from Trajectory import Trajectory
if not stepselection: stepselection = range(1, self.ntrajfiles + 1)
else: self.log.info("Trajectory selected steps: %s" % stepselection)
if usealigned:
if not self.isAligned(stepselection): usealigned = False
if usealigned:
path = self.alignpath
checkext = self.checkAlignExtension
self.log.debug("Using aligned trajectory")
else:
if not self.isProductionFinished(stepselection):
raise ReplicaError, "Cannot retrieve trajectory for non-finished steps: %s" % stepselection
path = self.mdpath
checkext = self.checkProductionExtension
self.log.debug("Using not aligned trajectory")
# Build File list to parse
flist = []
stepselection.sort()
self.log.debug("Selected steps for trajectory: %s" % stepselection)
for step in stepselection:
extension = checkext(step)[step]
if not extension:
self.log.warn("File for step %i not found" % step)
continue
f = self.mdoutfiletemplate.format(step=step, extension=extension)
flist.append(osp.join(path, f))
self.log.debug("Filelist for trajectory: %s" % flist)
#Build Trajectory object
self.log.debug(
"Replica %s Trajectory: stepselection - %s ; framestep - %i " %
(self.name, stepselection, framestep))
return Trajectory(flist,
self.getPDB(),
step=framestep,
frameselection=frameselection)
def test_get_normalized_path(self):
traj = Trajectory()
test_path = Path(Line(start=(0 + 0j), end=(2 + 2j)),
Line(start=(2 + 2j), end=(7 + 1j)),
Line(start=(7 + 1j), end=(0 + 0j)))
expected_path = Trajectory.scale(
Trajectory.discretize(
Path(Line(start=(0 + 0j), end=(2 + 2j)),
Line(start=(2 + 2j), end=(7 + 1j)),
Line(start=(7 + 1j), end=(0 + 0j))), 1), 1 / 7.0, 1 / 2.0)
traj.paths.append(test_path)
normalized_trajectory = traj.get_normalized_path(0)
self.assertGreater(len(normalized_trajectory), 3)
for (x1, y1), (x2, y2) in zip(normalized_trajectory, expected_path):
self.assertAlmostEqual(x1, x2, delta=0.01)
self.assertAlmostEqual(y1, y2, delta=0.01)
def test_get_normalized_path(self):
traj = Trajectory()
test_path = Path(Line(start=(0+0j), end=(2+2j)),
Line(start=(2+2j), end=(7+1j)),
Line(start=(7+1j), end=(0+0j)))
expected_path = Trajectory.scale(Trajectory.discretize(Path(Line(start=(0+0j), end=(2+2j)),
Line(start=(2+2j), end=(7+1j)),
Line(start=(7+1j), end=(0+0j))), 1),
1/7.0, 1/2.0)
traj.paths.append(test_path)
normalized_trajectory = traj.get_normalized_path(0)
self.assertGreater(len(normalized_trajectory), 3)
for (x1, y1), (x2, y2) in zip(normalized_trajectory, expected_path):
self.assertAlmostEqual(x1, x2, delta=0.01)
self.assertAlmostEqual(y1, y2, delta=0.01)
def generate(self):
t = array([0.0])
phi = array([[0.0, 0.0, 0.0]])
eps = array([[self.elevation * deg, 0.0, 0.0, 0.0, 0.0]])
lamb = array([[self.travel * deg, 0.0, 0.0, 0.0, 0.0]])
_, vf_vb = compute_pitch_and_inputs_flatness_centripetal(
eps[0], lamb[0])
vf = array([[vf_vb[0]]])
vb = array([[vf_vb[1]]])
return Trajectory(t, phi, eps, lamb, vf, vb)
def main():
pts1 = [[1, 2], [3, 3], [2, 1], [3, 2], [5, 5], [14, 4]]
pts2 = [[0, -2], [1, 1], [4, 1], [3, 5], [7, 5], [10, 9]]
lines1 = []
for i in range(len(pts1) - 1):
l = Line(np.asarray(pts1[i]), np.asarray(pts1[i + 1]))
lines1.append(l)
lines2 = []
for i in range(len(pts2) - 1):
l = Line(np.asarray(pts2[i]), np.asarray(pts2[i + 1]))
lines2.append(l)
t1 = Trajectory(lines1)
t2 = Trajectory(lines2)
Q = [
np.array([0, 0]),
np.array([1, -2]),
np.array([4, 0]),
np.array([12, -3])
]
d = DistanceMetric(Q)
dist = d.calc_trajectorydst(Q, t1, t2)
print(dist)
def takeFrames( self, indices ):
"""
Return a copy of the trajectory containing only the specified frames.
@param indices: positions to take
@type indices: [int]
@return: copy of this Trajectory (fewer frames, semi-deep copy of ref)
@rtype: Trajectory
"""
r = Trajectory.takeFrames( self, indices )
r.n_members = self.n_members
return r
def takeFrames(self, indices):
"""
Return a copy of the trajectory containing only the specified frames.
@param indices: positions to take
@type indices: [int]
@return: copy of this Trajectory (fewer frames, semi-deep copy of ref)
@rtype: Trajectory
"""
r = Trajectory.takeFrames(self, indices)
r.n_members = self.n_members
return r
def getRightTrajectories(self):
lineM = LineMovement(random.randrange(75, 100), 250)
lineM2 = LineMovement(random.randrange(30, 60), 250)
lineM3 = LineMovement(random.randrange(0, 15), 250)
lineM4 = LineMovement(random.randrange(300, 1330), 250)
movements = []
movements.append(lineM)
movements.append(lineM2)
movements.append(lineM3)
movements.append(lineM4)
trajectory = Trajectory(
self.gameParams,
movements,
(random.randrange(150,
self.gameParams.getWidth() - 400), -50),
incr=4)
trajectories = []
trajectories.append(trajectory)
return trajectories
def getLeftTrajectories(self):
lineM = LineMovement(random.randrange(75, 100), 250)
lineM2 = LineMovement(random.randrange(115, 150), 250)
lineM3 = LineMovement(random.randrange(165, 195), 250)
lineM4 = LineMovement(random.randrange(210, 1240), 250)
movements = []
movements.append(lineM)
movements.append(lineM2)
movements.append(lineM3)
movements.append(lineM4)
trajectory = Trajectory(
self.gameParams,
movements,
(random.randrange(400,
self.gameParams.getWidth() - 150), -50),
incr=4)
trajectories = []
trajectories.append(trajectory)
return trajectories
def run(self):
env = gym.make("CartPole-v0")
episode_done = True
trajectory = Trajectory()
next_state = []
episode_num = 0
episode_reward = 1
while True:
if episode_done:
state = env.reset()
episode_done = False
template = "in worker {}, episode {} done after {} steps"
print(
template.format(self.worker_id, episode_num,
episode_reward))
self.res_queue.put(episode_reward)
episode_num += 1
episode_reward = 1
for i in range(LOOKAHEAD):
# env.render()
state = tf.convert_to_tensor(state)
state = tf.expand_dims(state, 0)
action = self.act(state)
trajectory.store(s=state, a=action)
state, reward, episode_done, _ = env.step(action)
if episode_done:
reward = -1
trajectory.store(r=reward)
episode_reward += reward
next_state = state
if episode_done:
next_state = []
break
self.train(trajectory, next_state)
trajectory.clear()
def removePlayer(self, player):
"""
Delete a player from the room.
"""
self.players[player.axis] = None
player.msgGstat() #tells the players that there is one player less
if self.player_nb() == 0: #empty room => deleted room
self.trajectory.stop()
del self.trajectory
self.rooms.remove(self)
self.site.msgTotalNumberOfRooms() #tells the player that there is one room less
elif self.player_nb() == 1:
#we try to pair the player left alone with an other solo player
for room in self.rooms[:]:
if room.player_nb() == 1 and room != self:
#we have found a game "room" with 1 player ("room!=self" allows not to choose the previous game of the player)
playerToMove = self.players[player.axis ^ 1] #player.axis ^ 1 gives the other player of the room
self.trajectory.stop()
del self.trajectory
self.rooms.remove(self)
#playerToMove.reset() #use it if we want that the coming player beginns with score = 0
playerToMove.room = room
playerToMove.axis = room.players.values().index(None)
room.addPlayer(playerToMove)
playerToMove.msgGstat()
playerToMove.msgSyncJ()
self.rooms.remove(room)
self.rooms.append(room)
self.site.msgTotalNumberOfRooms()
break
else:
otherPlayer = self.players[player.axis ^ 1]
self.trajectory.stop()
del self.trajectory
self.trajectory = Trajectory(self)
#if otherPlayer.axis == 1:
# self.players[1]= None
# otherPlayer.axis =0
# self.players[0] = otherPlayer
otherPlayer.msgGstat()
otherPlayer.msgSyncJ()
self.site.msgTotalNumberOfRooms(otherPlayer)
def test_extract_paths_from_svg(self):
traj = Trajectory()
path_strings = traj._extract_paths_from_svg(self.svg_filepath)
self.assertEqual(len(path_strings), 2)
self.assertEqual(path_strings[0], "M 99.75,67.46875 C 71.718268,67.468752 73.46875,79.625 73.46875,79.625 L 73.5,92.21875 L 100.25,92.21875 L 100.25,96 L 62.875,96 C 62.875,96 44.9375,93.965724 44.9375,122.25 C 44.937498,150.53427 60.59375,149.53125 60.59375,149.53125 L 69.9375,149.53125 L 69.9375,136.40625 C 69.9375,136.40625 69.433848,120.75 85.34375,120.75 C 101.25365,120.75 111.875,120.75 111.875,120.75 C 111.875,120.75 126.78125,120.99096 126.78125,106.34375 C 126.78125,91.696544 126.78125,82.125 126.78125,82.125 C 126.78125,82.124998 129.04443,67.46875 99.75,67.46875 z M 85,75.9375 C 87.661429,75.937498 89.8125,78.088571 89.8125,80.75 C 89.812502,83.411429 87.661429,85.5625 85,85.5625 C 82.338571,85.562502 80.1875,83.411429 80.1875,80.75 C 80.187498,78.088571 82.338571,75.9375 85,75.9375 z ")
self.assertEqual(path_strings[1], "M 100.5461,177.31485 C 128.57784,177.31485 126.82735,165.1586 126.82735,165.1586 L 126.7961,152.56485 L 100.0461,152.56485 L 100.0461,148.7836 L 137.4211,148.7836 C 137.4211,148.7836 155.3586,150.81787 155.3586,122.53359 C 155.35861,94.249323 139.70235,95.252343 139.70235,95.252343 L 130.3586,95.252343 L 130.3586,108.37734 C 130.3586,108.37734 130.86226,124.03359 114.95235,124.03359 C 99.042448,124.03359 88.421098,124.03359 88.421098,124.03359 C 88.421098,124.03359 73.514848,123.79263 73.514848,138.43985 C 73.514848,153.08705 73.514848,162.6586 73.514848,162.6586 C 73.514848,162.6586 71.251668,177.31485 100.5461,177.31485 z M 115.2961,168.8461 C 112.63467,168.8461 110.4836,166.69503 110.4836,164.0336 C 110.4836,161.37217 112.63467,159.2211 115.2961,159.2211 C 117.95753,159.2211 120.1086,161.37217 120.1086,164.0336 C 120.10861,166.69503 117.95753,168.8461 115.2961,168.8461 z " )
def test_load_paths_from_svg(self):
traj = Trajectory()
traj.load_paths_from_svg(self.svg_filepath)
self.assertEqual(len(traj.paths), 2)
def createTrajectories(self, hwynet, storefile, inkey, outkey):
"""
Takes the sequence of points, and converts each into a
trajectory object.
storefile - HDF datastore with GPS points in it.
"""
# open the data store
store = pd.HDFStore(storefile)
# get the list of dates and cab_ids to process
dates = store.select_column(inkey, 'date').unique()
dates.sort_values()
print ('Retrieved a total of %i days to process' % len(dates))
# loop through the dates
rowsWritten = 0
for date in dates:
print ('Processing ', date)
# get the data and sort
gps_df = store.select(inkey, where='date==Timestamp(date)')
# loop through each trip
last_cab_id = 0
groups = gps_df.groupby(['cab_id','trip_id','status'])
for group in groups:
(cab_id, trip_id, status) = group[0]
if (cab_id != last_cab_id):
print (' Processing cab_id: ', cab_id)
# group[0] is the index, group[1] is the records
traj = Trajectory(hwynet, group[1])
# check for empty set
if (len(traj.candidatePoints)==0):
continue
# determine most likely paths and points
traj.calculateMostLikely()
# for debugging
if (cab_id, trip_id) in self.debugCabTripIds:
traj.printDebugInfo(self.debugFile, ids=(cab_id, trip_id))
# allocate trajectory travel times to links
(link_ids, traversalRatios, startTimes, travelTimes) = \
self.allocateTrajectoryTravelTimeToLinks(hwynet, traj)
# create a dataframe
data = {'link_id': link_ids,
'traversal_ratio': traversalRatios,
'start_time': startTimes,
'travel_time': travelTimes}
link_df = pd.DataFrame(data)
link_df['date'] = date
link_df['cab_id'] = cab_id
link_df['trip_id'] = trip_id
link_df['status'] = status
last_cab_id = cab_id
# set the index
link_df.index = rowsWritten + pd.Series(range(0,len(link_df)))
rowsWritten += len(link_df)
# write the data
store.append(outkey, link_df, data_columns=True)
# all done
store.close()
class Room():
def __init__(self, site):
self.players = { 0 : None , 1 : None} #0 is left axis and 1 is right axis
self.site = site #site is the websocket's lib entity used to talk with the player
self.rooms = site.rooms #all the rooms
#self.trajectory = Trajectory(self)
def addPlayer(self,player):
"""
Adds a player in this room
"""
#we look for the first free racket to give to the player, if there was 3 players and the second one left
#the new player will play in second position
#TODO : it would be better to search for the None value and insert there instead of for-break !!! check : no
#regression !
for axisID in self.players.keys():
if self.players[axisID] == None:
#free racket found
self.players[axisID] = player
newPseudo = False
#if the new player uses a name which is already in use, we add some random digits at the end and tell
#him !
if player.name == self.players[axisID ^ 1].name:
newPseudo = True
player.name += str(random.randint(1, 9))
if player.name != "" and newPseudo:
player.msgNewPseudo(player.name)
#restart the trajectory (we must because the number of players has changed so have the rules)
self.trajectory.stop()
del self.trajectory
self.trajectory = Trajectory(self)
break
def removePlayer(self, player):
"""
Delete a player from the room.
"""
self.players[player.axis] = None
player.msgGstat() #tells the players that there is one player less
if self.player_nb() == 0: #empty room => deleted room
self.trajectory.stop()
del self.trajectory
self.rooms.remove(self)
self.site.msgTotalNumberOfRooms() #tells the player that there is one room less
elif self.player_nb() == 1:
#we try to pair the player left alone with an other solo player
for room in self.rooms[:]:
if room.player_nb() == 1 and room != self:
#we have found a game "room" with 1 player ("room!=self" allows not to choose the previous game of the player)
playerToMove = self.players[player.axis ^ 1] #player.axis ^ 1 gives the other player of the room
self.trajectory.stop()
del self.trajectory
self.rooms.remove(self)
#playerToMove.reset() #use it if we want that the coming player beginns with score = 0
playerToMove.room = room
playerToMove.axis = room.players.values().index(None)
room.addPlayer(playerToMove)
playerToMove.msgGstat()
playerToMove.msgSyncJ()
self.rooms.remove(room)
self.rooms.append(room)
self.site.msgTotalNumberOfRooms()
break
else:
otherPlayer = self.players[player.axis ^ 1]
self.trajectory.stop()
del self.trajectory
self.trajectory = Trajectory(self)
#if otherPlayer.axis == 1:
# self.players[1]= None
# otherPlayer.axis =0
# self.players[0] = otherPlayer
otherPlayer.msgGstat()
otherPlayer.msgSyncJ()
self.site.msgTotalNumberOfRooms(otherPlayer)
def getPlayers(self):
"""
Returns all players, without the empty slots (where player left).
"""
return filter(lambda x : x!=None, self.players.values())
def player_nb(self):
"""
How many players do we have ?
"""
return len(self.getPlayers())
class TrajectoryWidget(WorkspaceWidget, CoreXYEventListener):
def __init__(self, parent, machine):
super(TrajectoryWidget, self).__init__(parent, machine)
self.name = "TrajectoryWidget"
self.icon = os.path.join(os.path.realpath(os.path.dirname(__file__)), 'resources', 'icons', 'format-text-direction-ltr.png')
self.tooltip = "Trajectory workspace"
self.machine.add_listener(self)
self.trajectory = Trajectory()
self.trajectory_controller = TrajectoryControllerThread()
self.limits = None
# References to widgets
self.calibrationFileButton = None
self.calibrationFileLineEdit = None
self.pointsFileButton = None
self.pointsFileLineEdit = None
self.loadButton = None
self.graphicsView = None
self.trajectoryComboBox = None
self.indexComboBox = None
self.stepSpinBox = None
self.xScaleSpinBox = None
self.yScaleSpinBox = None
self.xOffsetSpinBox = None
self.yOffsetSpinBox = None
self.stopButton = None
self.runButton = None
# Image-related
self.pixmap = QtGui.QPixmap()
self.original_rect = None
self.loadUI()
self.update()
def loadUI(self):
# Load UI file
main_widget = load_ui(os.path.join(os.path.realpath(os.path.dirname(__file__)), 'TrajectoryWidget.ui'), self)
layout = QtGui.QVBoxLayout()
layout.addWidget(main_widget)
self.setLayout(layout)
# Find references to controls
self.calibrationFileButton = self.findChild(QtGui.QToolButton, "calibrationFileButton")
self.pointsFileButton = self.findChild(QtGui.QToolButton, "pointsFileButton")
self.loadButton = self.findChild(QtGui.QPushButton, "loadButton")
self.stopButton = self.findChild(QtGui.QPushButton, "stopButton")
self.runButton = self.findChild(QtGui.QPushButton, "runButton")
self.calibrationFileLineEdit = self.findChild(QtGui.QLineEdit, "calibrationFileLineEdit")
self.pointsFileLineEdit = self.findChild(QtGui.QLineEdit, "pointsFileLineEdit")
self.graphicsView = self.findChild(QtGui.QGraphicsView, "graphicsView")
self.trajectoryComboBox = self.findChild(QtGui.QComboBox, "trajectoryComboBox")
self.indexComboBox = self.findChild(QtGui.QComboBox, "indexComboBox")
self.stepSpinBox = self.findChild(QtGui.QDoubleSpinBox, "stepSpinBox")
self.xScaleSpinBox = self.findChild(QtGui.QDoubleSpinBox, "xScaleSpinBox")
self.yScaleSpinBox = self.findChild(QtGui.QDoubleSpinBox, "yScaleSpinBox")
self.xOffsetSpinBox = self.findChild(QtGui.QDoubleSpinBox, "xOffsetSpinBox")
self.yOffsetSpinBox = self.findChild(QtGui.QDoubleSpinBox, "yOffsetSpinBox")
# Set spinBox limits:
float_max = sys.float_info.max
self.stepSpinBox.setMaximum(float_max)
self.xScaleSpinBox.setMaximum(float_max)
self.yScaleSpinBox.setMaximum(float_max)
self.xOffsetSpinBox.setMaximum(float_max)
self.yOffsetSpinBox.setMaximum(float_max)
self.stepSpinBox.setMinimum(0)
self.xScaleSpinBox.setMinimum(0)
self.yScaleSpinBox.setMinimum(0)
self.xOffsetSpinBox.setMinimum(-float_max)
self.yOffsetSpinBox.setMinimum(-float_max)
# Connect signals
self.calibrationFileButton.clicked.connect(self.onCalibrationButtonClicked)
self.pointsFileButton.clicked.connect(self.onPointsButtonClicked)
self.loadButton.clicked.connect(self.onLoadButtonClicked)
self.stopButton.clicked.connect(self.onStopButtonClicked)
self.runButton.clicked.connect(self.onRunButtonClicked)
self.trajectoryComboBox.currentIndexChanged.connect(self.onTrajectorySelectedChanged)
self.indexComboBox.currentIndexChanged.connect(self.updateImage)
self.stepSpinBox.valueChanged.connect(self.updateImage)
self.xOffsetSpinBox.valueChanged.connect(self.updateImage)
self.yOffsetSpinBox.valueChanged.connect(self.updateImage)
self.xScaleSpinBox.valueChanged.connect(self.updateImage)
self.yScaleSpinBox.valueChanged.connect(self.updateImage)
self.runButton.setEnabled(False)
self.stopButton.setEnabled(False)
self.setTrajectoryControlsEnabled(False)
self.trajectory_controller.finished.connect(self.onTrajectoryFinish)
def update(self):
self.updateImage()
# def resetInputValues(self):
# self.stepSpinBox.setValue(1)
# self.xOffsetSpinBox.setValue(0)
# self.yOffsetSpinBox.setValue(0)
# self.xScaleSpinBox.setValue(1)
# self.yScaleSpinBox.setValue(1)
def resetInputValues(self):
self.stepSpinBox.setValue(20)
self.xOffsetSpinBox.setValue(0)
self.yOffsetSpinBox.setValue(-10)
self.xScaleSpinBox.setValue(0.8)
self.yScaleSpinBox.setValue(0.8)
@staticmethod
def _currentComboBoxIndex(combobox):
try:
return combobox.findText(combobox.currentText())
except (IndexError, AttributeError) as e:
print str(e)
return None
def loadImage(self, calibration):
if calibration.image_name:
self.pixmap.loadFromData(calibration.image, os.path.splitext(calibration.image_name)[1])
self.original_rect = self.pixmap.rect()
self.pixmap = self.pixmap.scaled(480, 339)
return True
else:
return False
def calculateTrajectoryFromParams(self):
# Get data from form
current_trajectory = self._currentComboBoxIndex(self.trajectoryComboBox)
current_starting_point = self._currentComboBoxIndex(self.indexComboBox)
step = self.stepSpinBox.value()
x_scale, y_scale = self.xScaleSpinBox.value(), self.yScaleSpinBox.value()
x_offset, y_offset = self.xOffsetSpinBox.value(), self.yOffsetSpinBox.value()
# Transform trajectory
try:
discrete_trajectory = self.trajectory.get_normalized_path(current_trajectory, current_starting_point, step)
print "Path length: %d points" % len(discrete_trajectory)
discrete_trajectory = self.trajectory.scale(discrete_trajectory, 480*x_scale, 339*y_scale)
discrete_trajectory = self.trajectory.translate(discrete_trajectory, x_offset, y_offset)
except ArithmeticError, e:
print e
return False
return discrete_trajectory
