def __init__(self, speed_limit: int, num_lanes: int,
road_length_meters: float, road_name: str):
""" The road object will contain all """
self.road_name = road_name
self.__begin_intersection = Intersection(self)
self.end_intersection = Intersection()
self.speed_limit = speed_limit
self.num_lanes = num_lanes
self.lanes = self._init_lanes()
self.road_length_meters = road_length_meters
self.capacity = None
def my_constructor(self, SF_STATION_MAT, RAY_START_HEIGHT):
# attributes
## @var activated
# Indicates if the ground following algorithm is activated or deactivated. In the last case,
# the input matrix is simply passed through.
self.activated = False
## @var falling
# A boolean indicating if the user is currently falling. Used for fall speed computations.
self.falling = False
## @var initial_fall_velocity
# The starting velocity when the user is falling in meters per frame. Is increased the longer the falling process goes on.
self.initial_fall_velocity = 0.05
## @var height_modification_factor
# Scaling factor used for the modification of up and down vectors.
self.height_modification_factor = 0.15
# fall velocity in meter per frame
## @var fall_velocity
# Speed when the user is falling in meters per frame.
self.fall_velocity = self.initial_fall_velocity
# pick length in meter
## @var ground_pick_length
# Length of the ground following ray.
self.ground_pick_length = 100.0
## @var ground_pick_direction_mat
# Direction of the ground following ray.
self.ground_pick_direction_mat = avango.gua.make_identity_mat()
## @var SCENEGRAPH
# Reference to the scenegraph to intersect the ground following ray with.
self.SCENEGRAPH = scenegraphs[0]
## @var ray_start_height
# Starting height of the ground following ray.
self.ray_start_height = RAY_START_HEIGHT
# initialize shoot and output matrices
self.sf_abs_output_mat.value = self.sf_abs_input_mat.value
self.set_pick_direction(avango.gua.Vec3(0.0, -1.0, 0.0))
# init field connections
self.sf_station_mat.connect_from(SF_STATION_MAT)
# init internal class
## @var ground_intersection
# Intersection class to determine the intersections of the ground following ray with the objects in the scenegraph.
self.ground_intersection = Intersection()
self.ground_intersection.my_constructor(self.SCENEGRAPH,
self.sf_gf_start_mat,
self.ground_pick_length,
"gf_pick_group")
self.mf_ground_pick_result.connect_from(
self.ground_intersection.mf_pick_result)
def parseSgfToken(token, board_size=19):
''' Takes in a single SGF token and returns an Intersection object
representing that token.
'''
try:
if token == ")":
return None
if len(token) > 5 and token[5] not in (")", "C"):
SgfParser.raiseInvalidSgf(token)
if token[0] == 'B':
stoneColor = StoneColor.BLACK
elif token[0] == 'W':
stoneColor = StoneColor.WHITE
else:
SgfParser.raiseInvalidSgf(token)
if token[1] != '[':
SgfParser.raiseInvalidSgf(token)
if token[2] == ']':
coordinate = [-1, -1]
elif board_size <= 19 and token[2] == 't' and token[
3] == 't': # Part of SGF standard
coordinate = [-1, -1]
else:
coordinate = [
ord(token[3]) - ord('a'),
ord(token[2]) - ord('a')
]
except IndexError:
SgfParser.raiseInvalidSgf(token)
return Intersection(coordinate, stoneColor)
def __init__(self):
self.super(MultiTouchDevice).__init__()
self._sceneGraph = None
self._display = None
self._worldMat = avango.gua.make_identity_mat()
self._transMat = avango.gua.make_identity_mat()
self._rotMat = avango.gua.make_identity_mat()
self._scaleMat = avango.gua.make_identity_mat()
""" Scene transform matrix """
self._globalMatrix = avango.gua.make_identity_mat()
""" last cursor position """
self._lastPos = None
""" params to evaluate object / navigation mode """
self._sceneName = None
self._objectName = None
self._objectMode = False
self._headPosition1 = avango.gua.Vec3(0, 0, 0)
""" params to evaluate intersection """
self._intersection = Intersection(
) # ray intersection for target identification
self._intersectionFound = False
self._intersectionPoint = avango.gua.Vec3(0, 0, 0)
self._intersectionObject = None
self._lastIntersectionCounter = 0
""" ray representation"""
self.ray_length = 10
self.ray_thickness = 0.0075
self.intersection_sphere_size = 0.025
self.highlighted_object = None
self.hierarchy_selection_level = -1
self.always_evaluate(True)
def addNeighbor(self, currentWord, currentWordIsAcross, neighborWord,
board):
for current_i in range(len(currentWord)):
for neighbor_i in range(len(neighborWord)):
if currentWord[current_i] == neighborWord[neighbor_i]:
# generate an intersection object
if currentWordIsAcross:
intersection = Intersection(currentWord, current_i,
neighborWord, neighbor_i)
else:
intersection = Intersection(neighborWord, neighbor_i,
currentWord, current_i)
# if this is a valid intersection, add it to crossword and break out of the second loop
if board.addIfValid(intersection, not currentWordIsAcross):
return True
return False
def generateMap(self):
for i in range(len(self.intersectionCount)):
# Procedurarly position intersection count:
if (len(self.intersectionCount) == 1):
print("Map has one intersection")
# We will generate one intersection in the middle of the map. This is the base case
currIntersection = Intersection(length=40,
wid=40,
posX=490,
posY=490)
elif (len(self.intersectionCount) == 2):
print("Map has two intersections")
elif (len(self.intersectionCount) == 3):
print("Map has three intersections")
elif (len(self.intersectionCount == 5)):
print("Map has three intersectoins")
def getOrientamentWay(idWay, soup):
#ottengo la lista di tutti i nodi, cerco quelli più a nord e più a sud e calcolo l'angolazione
listIntersectionID = getListIntersection(idWay, soup)
listIntersection = []
for i in range(len(listIntersectionID)):
obj = Intersection(listIntersectionID[i], soup)
listIntersection.append(obj)
nodeNord = getNodeNord(listIntersection)
nodeSud = getNodeSud(listIntersection)
latNord = math.radians(float(nodeNord.lat))
latSud = math.radians(float(nodeSud.lat))
lonNord = math.radians(float(nodeNord.lon))
lonSud = math.radians(float(nodeSud.lon))
objA = (latNord, lonNord)
objB = (latSud, lonSud)
x = calculate_initial_compass_bearing(objA, objB)
return x
# Read which input to choose
selectedInput = "a"
if len(sys.argv) > 1:
candidate = sys.argv[1]
if len(candidate) == 1 and candidate in "abcdef":
selectedInput = candidate
else:
print(f"! Invalid input {candidate}, using default")
print(f"Selected input: {selectedInput}")
# Read input
with open(f"input/{selectedInput}.in", "r") as file:
firstLine = file.readline().strip()
D, I, S, V, F = list(map(int, firstLine.split(" ")))
allIntersections = [Intersection(id) for id in range(I)]
allStreets = {}
for s in range(S):
street = Street.fromString(file.readline().strip())
allStreets[street.name] = street
allIntersections[street.start].addOutgoing(street)
allIntersections[street.end].addIncoming(street)
# print(street)
for v in range(V):
car = Car.fromString(file.readline().strip(), allStreets, D)
# print(car)
# for street in allStreets.values():
# print(street)
#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
#AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
#LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
#OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
#SOFTWARE.
###########################################################################################
import socket # Import socket module
import gopigo
from Intersection import *
s = socket.socket() # Create a socket object
host = socket.gethostname() # Get local machine name
turnList = [
Intersection(True, False, False, False),
Intersection(False, True, False, False),
Intersection(True, False, False, False)
]
port = 12345 # Reserve a port for your service.
s.bind(('192.168.1.109', port)) # Bind to the port
print(host)
s.listen(5) # Now wait for client connection.
while True:
c, addr = s.accept() # Establish connection with client.
print 'Got connection from', addr
c.send(turnList)
c.close()
def bruteForce(self, graph):
# get a random word to start with
keys = list(graph.keys())
randomIndex0 = random.randint(0, len(keys) - 1)
randomLetter = keys[
randomIndex0] # Gives us a list of words from graph[some random letter]
wordList = graph[randomLetter]
randomIndex1 = random.randint(0, len(wordList) - 1)
startWord = wordList[randomIndex1]
Q = deque(
[]
) # initialize a queue that will store each word that has been added to the crossword
Q.append(startWord)
allWords = []
allWords.append(startWord)
# initialize a crossword that contains that start word
crossword = CrosswordRepresentation({startWord: None}, {})
board = Board(crossword)
# this outer loop continues until we have the desired number of words in our crossword
currentWordIsAcross = True
while len(Q) > 0: # while Q is not empty
currentWord = Q.popleft(
) # removes the first element in the Queue.
# updates currentWordIsAcross depending on whether or not
# the current word is in the across or down dictionary keys.
if currentWord in board.crossword.across.keys():
currentWordIsAcross = True
elif currentWord in board.crossword.down.keys():
currentWordIsAcross = False
# loops through each letter in the current word and try's to add a word on each letter.
for x in range(0, len(currentWord), 2):
neighbors = graph[currentWord[
x]] # list of all words that have the letter of currentWord[x] in them.
for neighbor in neighbors: # Searches through all the neighbors for a potentially valid word to add.
newWord = neighbor
if currentWordIsAcross and newWord not in Q and newWord not in allWords:
intersection = Intersection(
currentWord, newWord, x,
newWord.find(currentWord[x]))
# print("Current word: " + currentWord + ", list: " + str(board.crossword.across))
firstCell = board.crossword.across[currentWord]
interCell = board.getCellAt(firstCell.xCoord + x,
firstCell.yCoord)
if interCell is not None and board.addIfValid(
interCell, intersection, False):
Q.append(newWord)
allWords.append(newWord)
board.terminalRepresentationOfCrossword(
) # prints the crossword in the terminal as it is.
print("--------------")
break # We don't want to keep looping through all the neighbors if we found a valid one.
elif not currentWordIsAcross and newWord not in Q and newWord not in allWords:
intersection = Intersection(
newWord, currentWord, newWord.find(currentWord[x]),
x)
# print("Current word: "+currentWord+", list: "+str(board.crossword.down))
firstCell = board.crossword.down[currentWord]
interCell = board.getCellAt(firstCell.xCoord,
firstCell.yCoord + x)
if interCell is not None and board.addIfValid(
interCell, intersection, True):
Q.append(newWord)
allWords.append(newWord)
board.terminalRepresentationOfCrossword(
) # prints the crossword in the terminal as it is.
print("--------------")
break
return board
def my_constructor(self, WORKSPACE_INSTANCE, USER_ID, VIP,
AVATAR_VISIBILITY_TABLE, HEADTRACKING_TARGET_NAME,
EYE_DISTANCE, NO_TRACKING_MAT):
self.table_constructor(AVATAR_VISIBILITY_TABLE)
# flags
## @var is_vip
# Boolean indicating if this user has vip status.
self.is_vip = VIP
## @var is_active
# Boolean indicating if this user is currently active.
self.is_active = True
## @var eye_distance
# The eye distance of the user to be applied.
self.eye_distance = EYE_DISTANCE
# variables
## @var WORKSPACE_INSTANCE
# Workspace instance at which this user is registered.
self.WORKSPACE_INSTANCE = WORKSPACE_INSTANCE
## @var id
# Identification number of the user within the workspace, starting from 0.
self.id = USER_ID
## @var headtracking_target_name
# Name of the headtracking station as registered in daemon.
self.headtracking_target_name = HEADTRACKING_TARGET_NAME
## @var headtracking_reader
# TrackingTargetReader for the user's glasses.
if self.headtracking_target_name == None:
self.headtracking_reader = TrackingDefaultReader()
self.headtracking_reader.set_no_tracking_matrix(NO_TRACKING_MAT)
else:
self.headtracking_reader = TrackingTargetReader()
self.headtracking_reader.my_constructor(HEADTRACKING_TARGET_NAME)
self.headtracking_reader.set_transmitter_offset(
self.WORKSPACE_INSTANCE.transmitter_offset)
self.headtracking_reader.set_receiver_offset(
avango.gua.make_identity_mat())
## @var user_representations
# List of UserRepresentation instances for all display groups in the user's workspace.
self.user_representations = []
# toggles activity
self.toggle_user_activity(self.is_active)
## @var intersection_tester
# Instance of Intersection to determine intersection points of user with screens.
self.intersection_tester = Intersection()
self.intersection_tester.my_constructor(
scenegraphs[0], self.headtracking_reader.sf_abs_mat, 5.0,
"screen_proxy_group", False)
self.mf_screen_pick_result.connect_from(
self.intersection_tester.mf_pick_result)
## @var last_seen_display_group
# DisplayGroup instance for which the user's viewing ray lastly hit a screen proxy geometry.
self.last_seen_display_group = None
self.always_evaluate(True)