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 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 __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
class Road: """ The road object contains most objects in the system and store road data. """ 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 _init_lanes(self): lanes = [] out = "{:4}{:4}{:4}|\n".format("|", "|", "|") print(out * 2, end="") out = "{:4}{:4}{:4}\n".format("| 1 |", " 2 |", " 3 |") print(out) for i in range(1, self.num_lanes + 1): is_turnlight = input("Is lane number: " + str(i) + " a turning lane? y/n: ") if is_turnlight == "y": lanes.append(Lane("turn")) lanes.append(Lane("straight")) return lanes def _setBeginIntersection(self, intersection: Intersection): self.__begin_intersection = intersection def setEndIntersection(self, intersection: Intersection): self.end_intersection = intersection self.end_intersection.setIntersectionName(self.road_name) def getBeginIntersection(self): return self.__begin_intersection def getEndIntersection(self): return self.end_intersection def getRoadName(self): return self.road_name def __str__(self): out = "Road name: {:<32} Speed Limit: {:<4} Length: {:<8}".format( self.road_name, str(self.speed_limit) + "km/h", str(self.road_length_meters) + "m") return out def calculateCapacity(self): pass
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 my_constructor(self, SCENEGRAPH, 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.1 # 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 = SCENEGRAPH ## @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(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 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 collision_test(self, start_point, end_point): ''' returns if path of drop collided with `self.collider_a` and `self.collider_b` c and d should be `tuple` or `list`: (x,y) or [x,y] ''' start_x = int(start_point[0]) start_y = int(start_point[1]) end_x = int(end_point[0]) end_y = int(end_point[1]) start_point = (start_x, start_y) end_point = (end_x, end_y) # in case a drop gets reset from ground to top so doesnt count as a hit if start_point[1] < end_point[1]: return False if Intersection.closed_segment_intersect(self.collider_a, self.collider_b, start_point, end_point): self.collider_hits += 1
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
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)
class MultiTouchDevice(avango.script.Script): """ Base class for multi touch devices. rayOrientation: orientation matrix (start position + direction) of ray fingerCenterPos: the center of finger position in interval from -display-size to +display-size """ _rayOrientation = avango.gua.SFMatrix4() _fingerCenterPos = avango.gua.SFVec3() 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 my_constructor(self, graph, display, NET_TRANS_NODE, SCENE_MANAGER, APPLICATION_MANAGER): """ Initialize multi-touch device. @param graph: the scene graph on which to operate @param display: the physical display """ self._sceneGraph = graph self._display = display self._sceneManager = SCENE_MANAGER """ original matrix of the scene """ self._origMat = graph.Root.value.Transform.value """ """ self._applicationManager = APPLICATION_MANAGER self._intersection.my_constructor( self._sceneGraph, self._rayOrientation, self.ray_length, "" ) # parameters: SCENEGRAPH, SF_PICK_MATRIX, PICK_LENGTH, PICKMASK """ parent node of ray node """ _parent_node = self._sceneGraph["/net"] """ # init scenegraph node ## @var ray_transform # Transformation node of the pointer's ray. """ self.ray_transform = avango.gua.nodes.TransformNode( Name="ray_transform") _parent_node.Children.value.append(self.ray_transform) _loader = avango.gua.nodes.TriMeshLoader() """ ## @var ray_geometry # Geometry node representing the ray graphically. """ self.ray_geometry = _loader.create_geometry_from_file( "ray_geometry", "data/objects/cylinder.obj", "data/materials/White.gmd", avango.gua.LoaderFlags.DEFAULTS) self.ray_transform.Children.value.append(self.ray_geometry) self.ray_geometry.GroupNames.value = ["do_not_display_group"] self.ray_geometry.Transform.value = avango.gua.make_trans_mat(0,0,0) * \ avango.gua.make_rot_mat(0,0,0,0) * \ avango.gua.make_scale_mat(0,0,0) """ @var intersection_point_geometry Geometry node representing the intersection point of the ray with an object in the scene. """ self.intersection_point_geometry = _loader.create_geometry_from_file( "intersection_point_geometry", "data/objects/sphere.obj", "data/materials/White.gmd", avango.gua.LoaderFlags.DEFAULTS) NET_TRANS_NODE.Children.value.append(self.intersection_point_geometry) self.intersection_point_geometry.GroupNames.value = [ "do_not_display_group" ] # set geometry invisible self.ray_transform.Transform.connect_from(self._rayOrientation) """ representation of fingercenterpos """ self.fingercenterpos_geometry = _loader.create_geometry_from_file( "fingercenterpos", "data/objects/sphere.obj", "data/materials/Red.gmd", avango.gua.LoaderFlags.DEFAULTS) NET_TRANS_NODE.Children.value.append(self.fingercenterpos_geometry) self.fingercenterpos_geometry.GroupNames.value = [ "do_not_display_group" ] """ hand representation """ self.handPos_geometry = _loader.create_geometry_from_file( "handpos", "data/objects/cube.obj", "data/materials/Red.gmd", avango.gua.LoaderFlags.DEFAULTS) NET_TRANS_NODE.Children.value.append(self.handPos_geometry) self.handPos_geometry.GroupNames.value = ["do_not_display_group"] """ define Input display size """ #111,5cm x 75,8 self._inputDisplaySize = avango.gua.Vec2(1.115, 0.758) def getDisplay(self): return self._display def getSceneGraph(self): return self._sceneGraph def mapInputPosition(self, Pos): """ Map input position to display size """ point = Pos """ map points from interval [0, 1] to [-0.5, 0.5] """ mappedPosX = point[0] * 1 - 0.5 mappedPosY = point[1] * 1 - 0.5 """ map point to display intervall ([-1/2*display-size] -> [+1/2*display-size]) """ mappedPos = avango.gua.Vec3(mappedPosX * self._inputDisplaySize.x, 0.0, mappedPosY * self._inputDisplaySize.y) return mappedPos def setFingerCenterPos(self, fingerPos): self._fingerCenterPos.value = fingerPos """ update fingercenterpos representation """ self.fingercenterpos_geometry.GroupNames.value = [] self.fingercenterpos_geometry.Transform.value = avango.gua.make_trans_mat(self._fingerCenterPos.value) * \ avango.gua.make_scale_mat( 0.025, 0.025 , 0.025 ) def visualisizeHandPosition(self, handPos): """ update hand representation """ self.handPos_geometry.GroupNames.value = [] self.handPos_geometry.Transform.value = avango.gua.make_trans_mat(handPos) * \ avango.gua.make_scale_mat( 0.1, 0.005 , 0.1 ) def setObjectMode(self, active): """ Evaluate object mode. object mode activated only if an intersection was found @param active: toggle active state of object mode """ if active and self._intersectionFound: self._objectMode = True self._objectName = self._intersectionObject.Parent.value.Name.value return True else: self._objectMode = False self._objectName = None return False def addLocalTranslation(self, transMat): """ Add local translation. @param transMat: the (relative) translation matrix """ self._transMat *= transMat def addLocalRotation(self, rotMat): """ Add local rotation. @param rotMat: the (relative) rotation matrix """ self._rotMat *= rotMat def addLocalScaling(self, scaleMat): """ Add local scaling. @param scaleMat: the (relative) scaling matrix """ self._scaleMat *= scaleMat def intersectSceneWithFingerPos(self): """ Intersect Scene with ray from head to finger position. works only for first user. @param transMat: the (relative) translation matrix """ #TODO: decide between displays with tracking and not #for no tracking use this: #self._rayOrientation.value = avango.gua.make_trans_mat(self._fingerCenterPos.value.x , 0.5 , self._fingerCenterPos.value.z) * avango.gua.make_rot_mat(-90,1,0,0) #do this only once per gesture #do this only once per gesture if (1 < (self._frameCounter - self._lastIntersectionCounter)): """ ray orientation from fingerPos down """ self._rayOrientation.value = avango.gua.make_trans_mat( self._fingerCenterPos.value.x, 1, self._fingerCenterPos.value.z) * avango.gua.make_rot_mat( -90, 1, 0, 0) """intersection found""" if len(self._intersection.mf_pick_result.value) > 0: self._intersectionFound = True """first intersected object""" _pick_result = self._intersection.mf_pick_result.value[0] self._intersectionPoint = _pick_result.Position.value self._intersectionObject = _pick_result.Object.value """update intersectionObject until you insert object Mode""" if not self._objectMode: self._lastIntersectionObject = self._intersectionObject """ transform point into world coordinates """ self._intersectionPoint = self._intersectionObject.WorldTransform.value * self._intersectionPoint """make Vec3 from Vec4""" self._intersectionPoint = avango.gua.Vec3( self._intersectionPoint.x, self._intersectionPoint.y, self._intersectionPoint.z) if (self._objectMode and not self._objectName == self._intersectionObject.Parent.value.Name.value): #print "same object" self._intersectionPoint = avango.gua.Vec3(0, 0, 0) """ VISUALISATION """ """update intersection sphere""" self.intersection_point_geometry.Transform.value = avango.gua.make_trans_mat(self._intersectionPoint) * \ avango.gua.make_scale_mat(self.intersection_sphere_size, self.intersection_sphere_size, self.intersection_sphere_size) """set sphere and ray visible""" #self.intersection_point_geometry.GroupNames.value = [] #self.ray_geometry.GroupNames.value = [] """update ray""" _distance = ( self._intersectionPoint - self.ray_transform.WorldTransform.value.get_translate() ).length() self.ray_geometry.Transform.value = avango.gua.make_trans_mat(0.0, 0.0, _distance * -0.5) * \ avango.gua.make_rot_mat(-90.0,1,0,0) * \ avango.gua.make_scale_mat(self.ray_thickness, _distance, self.ray_thickness) else: """set geometry invisible""" self.intersection_point_geometry.GroupNames.value = [ "do_not_display_group" ] self.ray_geometry.GroupNames.value = ["do_not_display_group"] """set to default ray length""" self.ray_geometry.Transform.value = avango.gua.make_trans_mat(0.0,0.0,self.ray_length * -0.5) * \ avango.gua.make_rot_mat(-90.0,1,0,0) * \ avango.gua.make_scale_mat(self.ray_thickness, self.ray_length, self.ray_thickness) self._intersectionFound = False self._intersectionPoint = avango.gua.Vec3(0, 0, 0) self._lastIntersectionCounter = self._frameCounter def update_object_highlight(self): """highlight active object:""" if self._objectMode: _node = self._lastIntersectionObject if _node.has_field("InteractiveObject") == True: _object = _node.InteractiveObject.value if self.hierarchy_selection_level >= 0: _object = _object.get_higher_hierarchical_object( self.hierarchy_selection_level) if _object == None: """ evtl. disable highlight of prior object""" if self.highlighted_object != None: self.highlighted_object.enable_highlight(False) else: if _object != self.highlighted_object: # new object hit """evtl. disable highlight of prior object""" if self.highlighted_object != None: self.highlighted_object.enable_highlight(False) self.highlighted_object = _object """enable highlight of new object""" self.highlighted_object.enable_highlight(True) else: """evtl. disable highlight of prior object""" if self.highlighted_object != None: self.highlighted_object.enable_highlight(False) self.highlighted_object = None def applyTransformations(self): """ Apply calculated world matrix to scene graph. Requires the scene graph to have a transform node as root node. """ """ Reguires the scnene Name of actually scene to change dynamically """ sceneName = self._sceneManager.getActiveSceneName() """ to avoid errors until the scenen Name is set """ if (None != sceneName): sceneNode = "/net/" + sceneName self._globalMatrix = self._sceneGraph[sceneNode].Transform.value """ object Mode """ if self._objectMode: objectNode = "/net/" + sceneName + "/" + self._objectName scenePos = self._sceneGraph[ objectNode].Transform.value.get_translate() TransformMatrix = self._sceneGraph[objectNode].Transform.value else: scenePos = self._sceneGraph[ sceneNode].Transform.value.get_translate() TransformMatrix = self._sceneGraph[sceneNode].Transform.value """ distance between finger position and scene position (object position) """ translateDistance = self._fingerCenterPos.value - scenePos """transform world-space to object-space""" translateDistance = avango.gua.make_inverse_mat( avango.gua.make_rot_mat( TransformMatrix.get_rotate_scale_corrected()) ) * translateDistance translateDistance = avango.gua.Vec3(translateDistance.x, translateDistance.y, translateDistance.z) #print (self._transMat) """ TransfotmMatrix: 1. translate and rotate to origin, 2. calculate new position, 3. translate and rotate back """ """ object mode """ if self._objectMode: TransformMatrix = avango.gua.make_trans_mat(TransformMatrix.get_translate()) * \ avango.gua.make_rot_mat(TransformMatrix.get_rotate_scale_corrected()) * \ avango.gua.make_inverse_mat(avango.gua.make_rot_mat(self._globalMatrix.get_rotate_scale_corrected())) * \ avango.gua.make_inverse_mat(avango.gua.make_rot_mat(TransformMatrix.get_rotate_scale_corrected())) * \ self._rotMat * \ self._scaleMat * \ self._transMat * \ avango.gua.make_rot_mat(TransformMatrix.get_rotate_scale_corrected()) * \ avango.gua.make_rot_mat(self._globalMatrix.get_rotate_scale_corrected()) * \ avango.gua.make_scale_mat(TransformMatrix.get_scale()) else: TransformMatrix = avango.gua.make_trans_mat(TransformMatrix.get_translate()) * \ avango.gua.make_rot_mat(TransformMatrix.get_rotate_scale_corrected()) *\ avango.gua.make_trans_mat(translateDistance * 1.0) * \ avango.gua.make_trans_mat(avango.gua.Vec3(0, self._intersectionPoint.y * -1.0 , 0)) * \ avango.gua.make_inverse_mat(avango.gua.make_rot_mat(TransformMatrix.get_rotate_scale_corrected())) * \ self._rotMat * \ self._scaleMat * \ self._transMat * \ avango.gua.make_rot_mat(TransformMatrix.get_rotate_scale_corrected()) * \ avango.gua.make_trans_mat(avango.gua.Vec3(0, self._intersectionPoint.y * 1.0 , 0)) * \ avango.gua.make_trans_mat(translateDistance * -1.0) * \ avango.gua.make_scale_mat(TransformMatrix.get_scale()) """ object mode """ if self._objectMode: self._sceneGraph[objectNode].Transform.value = TransformMatrix else: self._sceneGraph[sceneNode].Transform.value = TransformMatrix """ reset all data """ self._transMat = avango.gua.make_identity_mat() self._rotMat = avango.gua.make_identity_mat() self._scaleMat = avango.gua.make_identity_mat() self._globalMatrix = avango.gua.make_identity_mat()
def intersections(self, ray): i = Intersection.Intersections() for object in self.objects: i += object.intersects(ray) return i.sort()
def my_constructor(self , APPLICATION_MANAGER , USER_ID , VIP , GLASSES_ID , HEADTRACKING_TARGET_NAME , PLATFORM_ID , AVATAR_MATERIAL): # 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 # variables ## @var APPLICATION_MANAGER # Reference to the ApplicationManager instance from which the user is created. self.APPLICATION_MANAGER = APPLICATION_MANAGER ## @var id # Identification number of the user, starting from 0. self.id = USER_ID ## @var platform_id # ID of the platform the user is belonging to. self.platform_id = PLATFORM_ID ## @var platform # Instance of the platform the user is belonging to. self.platform = self.APPLICATION_MANAGER.navigation_list[self.platform_id].platform ## @var current_display # Display instance on which the user physically is currently looking at. self.current_display = self.platform.displays[0] ## @var transmitter_offset # The transmitter offset to be applied. self.transmitter_offset = self.platform.transmitter_offset ## @var no_tracking_mat # The matrix to be applied when no tracking is available. self.no_tracking_mat = self.platform.no_tracking_mat ## @var avatar_material # Material of the user's avatar. self.avatar_material = AVATAR_MATERIAL ## @var headtracking_target_name # Name of the headtracking station as registered in daemon. self.headtracking_target_name = HEADTRACKING_TARGET_NAME ## @var glasses_id # ID of the shutter glasses worn by the user. Used for frequency updates. self.glasses_id = GLASSES_ID ## @var headtracking_reader # Instance of a child class of TrackingReader to supply translation input. if HEADTRACKING_TARGET_NAME == None: self.headtracking_reader = TrackingDefaultReader() self.headtracking_reader.set_no_tracking_matrix(self.no_tracking_mat) else: self.headtracking_reader = TrackingTargetReader() self.headtracking_reader.my_constructor(HEADTRACKING_TARGET_NAME) self.headtracking_reader.set_transmitter_offset(self.transmitter_offset) self.headtracking_reader.set_receiver_offset(avango.gua.make_identity_mat()) # create avatar representation if self.platform.avatar_type == "joseph" or self.platform.avatar_type == "None": self.create_avatar_representation(self.headtracking_reader.sf_avatar_head_mat, self.headtracking_reader.sf_avatar_body_mat) else: if self.platform.avatar_type == "joseph_table": print_warning("Avatar type jospeh_table is deprecated. The creation of table avatars are now handled by the " + \ "device automatically. Use avatar type jospeh instead.") print_error("Error: Unknown avatar type " + self.platform.avatar_type, True) # toggles avatar display and activity self.toggle_user_activity(self.is_active, False) # init intersection class for proxy geometry hit test ## @var pick_length # Length of the picking ray in meters to check for screen intersections. self.pick_length = 5.0 ## @var intersection_tester # Instance of Intersection to determine intersection points of user with screens. self.intersection_tester = Intersection() self.intersection_tester.my_constructor(self.APPLICATION_MANAGER.SCENEGRAPH , self.headtracking_reader.sf_global_mat , self.pick_length , "screen_proxy_group") self.mf_screen_pick_result.connect_from(self.intersection_tester.mf_pick_result) ## @var looking_outside_start # If the user is not facing a screen, the start time of this behaviour is saved to open glasses after a certain amount of time. self.looking_outside_start = None ## @var open_threshold # Time in seconds after which shutter glasses should open when no screen is hit by the viewing ray. self.open_threshold = 2.0 ## @var timer # Time sensor to handle time events. self.timer = avango.nodes.TimeSensor() # set evaluation policy self.always_evaluate(True)
import cv2, selectivesearch import numpy as np import Intersection as union candidates = set() while True: image = cv2.imread('image/dog.337.jpg') img_lbl, regions = selectivesearch.selective_search(image) for r in regions: candidates.add(r['rect']) for x, y, w, h in candidates: iou = union.get_union([71, 63, 189, 199], [x, y, x + w, y + h]) if iou > .7: cv2.rectangle(image, (x, y), (x + w, y + h), (0, 233, 12), 1) cv2.putText(image, 'Dog', (x - 2, y - 2), 1, 1, (1, 22, 121), 1) cv2.imshow('', image) if cv2.waitKey(1) & 0xFF == ord('q'): break cv2.destroyAllWindows()
class User(VisibilityHandler2D): ## @var mf_screen_pick_result # Intersections of the viewing ray with the screens in the setup. mf_screen_pick_result = avango.gua.MFPickResult() ## Default constructor. def __init__(self): self.super(User).__init__() ## Custom constructor. # @param WORKSPACE_INSTANCE Workspace instance in which this user is active. # @param USER_ID Global user ID to be applied. # @param VIP Boolean indicating if the user to be created is a vip. # @param AVATAR_VISIBILITY_TABLE A matrix containing visibility rules according to the DisplayGroups' visibility tags. # @param HEADTRACKING_TARGET_NAME Name of the headtracking station as registered in daemon. # @param EYE_DISTANCE The eye distance of the user to be applied. # @param NO_TRACKING_MAT Matrix to be applied when HEADTRACKING_TARGET_NAME is None. 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) ## Evaluated every frame. def evaluate(self): # evaluate viewing ray intersections with screen proxy geometries for _i in range(len(self.mf_screen_pick_result.value)): _pick_object = self.mf_screen_pick_result.value[_i].Object.value # only consider own workspace geometries if _pick_object.Name.value.startswith("proxy_w" + str(self.WORKSPACE_INSTANCE.id)): _display_group_id = int(_pick_object.Name.value.split("_")[2].replace("dg", "")) self.last_seen_display_group = self.WORKSPACE_INSTANCE.display_groups[_display_group_id] break _track_vec = self.headtracking_reader.sf_abs_vec.value if _track_vec.x < -1.5 and _track_vec.x > -2.4 and \ _track_vec.y < 1.05 and _track_vec.y > 0.95 and \ _track_vec.z < 1.35 and _track_vec.z > 0.16: self.toggle_user_activity(False) else: self.toggle_user_activity(True) ## Changes the visibility table during runtime. # @param VISIBILITY_TABLE A matrix containing visibility rules according to the DisplayGroups' visibility tags. def change_visiblity_table(self, VISIBILITY_TABLE): self.visibility_table = VISIBILITY_TABLE for _display_group in self.WORKSPACE_INSTANCE.display_groups: self.handle_correct_visibility_groups_for(_display_group) ## Creates a UserRepresentation instance for a given display group. # @param DISPLAY_GROUP Reference to the DisplayGroup instance to create the user representation for. # @param VIEW_TRANSFORM_NODE Transform node to be filled by one navigation of the display group. # @param HEAD_NODE_NAME Name of the UserRepresentation's head node in the scenegraph. # @param COMPLEX_SETUP If activated, the transformation policy is evaluated every frame to update head. If deactivated, # a standard mono viewing setup is assumed. def create_user_representation_for(self, DISPLAY_GROUP, VIEW_TRANSFORM_NODE, HEAD_NODE_NAME = "head", COMPLEX_SETUP = True): _user_repr = UserRepresentation() _user_repr.my_constructor(self, DISPLAY_GROUP, VIEW_TRANSFORM_NODE, HEAD_NODE_NAME, COMPLEX_SETUP) self.user_representations.append(_user_repr) return _user_repr ## Returns the UserRepresentation instance at a given DISPLAY_GROUP. # @param DISPLAY_GROUP The DisplayGroup to retrieve the UserRepresentation for. def get_user_representation_at(self, DISPLAY_GROUP): for _user_repr in self.user_representations: if _user_repr.DISPLAY_GROUP == DISPLAY_GROUP: return _user_repr ## Switches the navigation for a display group. # @param DISPLAY_GROUP_ID Identification number of the display group to switch the navigation for. # @param NAVIGATION_ID Identification number of the navigation to be used within the display group. # @param WORKSPACE_USERS A list of all Users active in the workspace. def switch_navigation_at_display_group(self, DISPLAY_GROUP_ID, NAVIGATION_ID, WORKSPACE_USERS): if DISPLAY_GROUP_ID < len(self.user_representations): # switch navigation to desired one for DISPLAY_GROUP_ID _old_nav_id = self.user_representations[DISPLAY_GROUP_ID].connected_navigation_id self.user_representations[DISPLAY_GROUP_ID].connect_navigation_of_display_group(NAVIGATION_ID) _display_group_instance = self.user_representations[DISPLAY_GROUP_ID].DISPLAY_GROUP # trigger correct tool visibilities at display group for _tool in self.WORKSPACE_INSTANCE.tools: _tool.handle_correct_visibility_groups_for(_display_group_instance) # trigger correct avatar and screen visibilities #for _user in WORKSPACE_USERS: # _user.handle_correct_visibility_groups_for(_display_group_instance) # trigger correct video visibilites at both navigations if self.WORKSPACE_INSTANCE.video_3D != None and ApplicationManager.current_avatar_mode == "VIDEO": _old_nav = self.WORKSPACE_INSTANCE.display_groups[DISPLAY_GROUP_ID].navigations[_old_nav_id] _new_nav = self.WORKSPACE_INSTANCE.display_groups[DISPLAY_GROUP_ID].navigations[NAVIGATION_ID] self.WORKSPACE_INSTANCE.video_3D.handle_correct_visibility_groups_for(_old_nav) self.WORKSPACE_INSTANCE.video_3D.handle_correct_visibility_groups_for(_new_nav) else: for _user in WORKSPACE_USERS: _user.handle_correct_visibility_groups_for(_display_group_instance) else: print_error("Error. Display Group ID does not exist.", False) ## Sets the user's active flag. # @param ACTIVE Boolean to which the active flag should be set. def toggle_user_activity(self, ACTIVE): if ACTIVE: self.is_active = True else: self.is_active = False ## Handles the correct GroupNames of all UserRepresentations at a display group. # @param DISPLAY_GROUP The DisplayGroup to be handled. def handle_correct_visibility_groups_for(self, DISPLAY_GROUP): # All UserRepresentation instances at DISPLAY_GROUP # normally, this list should just contain one user representation # in case of portals, however, a display group may have more than one user representation _user_representations_at_display_group = [] for _user_repr in self.user_representations: if _user_repr.DISPLAY_GROUP == DISPLAY_GROUP: _user_representations_at_display_group.append(_user_repr) # for all found user representations in the given display group for _user_repr_at_display_group in _user_representations_at_display_group: # display group instance belonging to DISPLAY_GROUP _handled_display_group_instance = _user_repr_at_display_group.DISPLAY_GROUP _all_user_reprs_at_display_group = [] for _user_repr in ApplicationManager.all_user_representations: if _user_repr.DISPLAY_GROUP == _handled_display_group_instance: _all_user_reprs_at_display_group.append(_user_repr) ## determine which group names have to be added to the user representations ## _user_visible_for = [] # when video avatars are enabled, do not make josephs visible if ApplicationManager.current_avatar_mode == "JOSEPH": # append all names of user representations which are not on same navigation for _user_repr in _all_user_reprs_at_display_group: if _user_repr.connected_navigation_id != _user_repr_at_display_group.connected_navigation_id: _user_visible_for.append(_user_repr.view_transform_node.Name.value) # check for all user representations outside the handled display group for _user_repr in ApplicationManager.all_user_representations: if _user_repr.DISPLAY_GROUP != _handled_display_group_instance: # consider visibility table _handled_display_group_tag = _handled_display_group_instance.visibility_tag _user_repr_display_group_tag = _user_repr.DISPLAY_GROUP.visibility_tag try: _visible = self.visibility_table[_user_repr_display_group_tag][_handled_display_group_tag] except: _visible = False if _visible: if _user_repr.is_in_virtual_display(): _user_visible_for.append(_user_repr.view_transform_node.Parent.value.Name.value + "_" + _user_repr.head.Name.value) else: _user_visible_for.append(_user_repr.view_transform_node.Name.value) # apply the obtained group names to the user representation if len(_user_visible_for) == 0: # prevent wildcard from rendering the avatar _user_repr_at_display_group.set_avatar_group_names(["do_not_display_group"]) else: for _string in _user_visible_for: _user_repr_at_display_group.set_avatar_group_names(_user_visible_for)
class GroundFollowing(avango.script.Script): # input field ## @var sf_abs_input_mat # The input matrix to be corrected by the ground following algorithm. sf_abs_input_mat = avango.gua.SFMatrix4() sf_abs_input_mat.value = avango.gua.make_identity_mat() # output field ## @var sf_abs_output_mat # The corrected matrix after the ground following algorithm was applied. sf_abs_output_mat = avango.gua.SFMatrix4() sf_abs_output_mat.value = avango.gua.make_identity_mat() # internal fields ## @var sf_gf_start_mat # The matrix representing the position where the sent ray to the ground starts. sf_gf_start_mat = avango.gua.SFMatrix4() sf_gf_start_mat.value = avango.gua.make_identity_mat() ## @var sf_station_mat # The matrix representing the position of the device belonging to the platform. sf_station_mat = avango.gua.SFMatrix4() sf_station_mat.value = avango.gua.make_identity_mat() ## @var sf_scale # The current scaling factor of the Navigation. sf_scale = avango.SFFloat() sf_scale.value = 1.0 ## @var mf_ground_pick_result # Intersections of the ground following ray with the objects in the scene. mf_ground_pick_result = avango.gua.MFPickResult() ## Default constructor. def __init__(self): self.super(GroundFollowing).__init__() ## Custom constructor. # @param SCENEGRAPH Reference to the scenegraph of the currently displayed scene. # @param SF_STATION_MAT The field containing the current position of the device belonging to the platform. # @param RAY_START_HEIGHT A height from which the ground following ray will originate. def my_constructor(self, SCENEGRAPH, 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.1 # 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 = SCENEGRAPH ## @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(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) ## Evaluated every frame. def evaluate(self): if self.activated == True: # platform translation in the world _platform_trans_vec = self.sf_abs_input_mat.value.get_translate() # tracked device translation on the platform _device_trans_vec = self.sf_station_mat.value.get_translate() # prepare ground following matrix _gf_start_pos = self.sf_station_mat.value.get_translate() _gf_start_pos.y = self.ray_start_height _gf_start_pos *= self.sf_scale.value _gf_start_pos = self.sf_abs_input_mat.value * _gf_start_pos _gf_start_pos = avango.gua.Vec3(_gf_start_pos.x, _gf_start_pos.y, _gf_start_pos.z) self.sf_gf_start_mat.value = avango.gua.make_trans_mat(_gf_start_pos) * self.ground_pick_direction_mat if len(self.mf_ground_pick_result.value) > 0: # an intersection with the ground was found # get first intersection target _pick_result = self.mf_ground_pick_result.value[0] #print _pick_result.Object.value, _pick_result.Object.value.Name.value # compare distance to ground and ray_start_height _distance_to_ground = _pick_result.Distance.value * self.ground_pick_length _difference = _distance_to_ground - (self.ray_start_height * self.sf_scale.value) _difference = round(_difference, 3) if _difference < 0: # climb up # end falling when necessary if self.falling: self.falling = False self.fall_velocity = self.initial_fall_velocity # move player up _up_vec = avango.gua.Vec3(0.0, _difference * -1.0 * self.height_modification_factor, 0.0) self.sf_abs_output_mat.value = avango.gua.make_trans_mat(_up_vec) * self.sf_abs_input_mat.value elif _difference > 0: if _difference > (self.ray_start_height * self.sf_scale.value): # falling # make player fall down faster every time self.falling = True _fall_vec = avango.gua.Vec3(0.0, -self.fall_velocity, 0.0) self.sf_abs_output_mat.value = avango.gua.make_trans_mat(_fall_vec) * self.sf_abs_input_mat.value self.fall_velocity += 0.005 else: # climb down # end falling when necessary if self.falling: self.falling = False self.fall_velocity = self.initial_fall_velocity # move player down _down_vec = avango.gua.Vec3(0.0, _difference * -1.0 * self.height_modification_factor, 0.0) self.sf_abs_output_mat.value = avango.gua.make_trans_mat(_down_vec) * self.sf_abs_input_mat.value else: self.sf_abs_output_mat.value = self.sf_abs_input_mat.value # player remains on ground else: #print "None" self.sf_abs_output_mat.value = self.sf_abs_input_mat.value # no intersection with ground was found else: self.sf_abs_output_mat.value = self.sf_abs_input_mat.value # ground following is deactivated ## Sets the pick_direction attribute. # @param PICK_DIRECTION New pick direction. def set_pick_direction(self, PICK_DIRECTION): PICK_DIRECTION.normalize() _ref = avango.gua.Vec3(0.0,0.0,-1.0) _angle = math.degrees(math.acos(_ref.dot(PICK_DIRECTION))) _axis = _ref.cross(PICK_DIRECTION) self.ground_pick_direction_mat = avango.gua.make_rot_mat(_angle, _axis) ## Activates the ground following algorithm. def activate(self): self.activated = True self.ground_intersection.activate(True) ## Deactivates the ground following algorithm. The input matrix is just passed through after calling this method. def deactivate(self): self.activated = False self.ground_intersection.activate(False)
class GroundFollowing(avango.script.Script): # input field ## @var sf_abs_input_mat # The input matrix to be corrected by the ground following algorithm. sf_abs_input_mat = avango.gua.SFMatrix4() sf_abs_input_mat.value = avango.gua.make_identity_mat() # output field ## @var sf_abs_output_mat # The corrected matrix after the ground following algorithm was applied. sf_abs_output_mat = avango.gua.SFMatrix4() sf_abs_output_mat.value = avango.gua.make_identity_mat() # internal fields ## @var sf_gf_start_mat # The matrix representing the position where the sent ray to the ground starts. sf_gf_start_mat = avango.gua.SFMatrix4() sf_gf_start_mat.value = avango.gua.make_identity_mat() ## @var sf_station_mat # The matrix representing the position of the device belonging to the platform. sf_station_mat = avango.gua.SFMatrix4() sf_station_mat.value = avango.gua.make_identity_mat() ## @var sf_scale # The current scaling factor of the Navigation. sf_scale = avango.SFFloat() sf_scale.value = 1.0 ## @var mf_ground_pick_result # Intersections of the ground following ray with the objects in the scene. mf_ground_pick_result = avango.gua.MFPickResult() ## Default constructor. def __init__(self): self.super(GroundFollowing).__init__() ## Custom constructor. # @param SF_STATION_MAT The field containing the current position of the device belonging to the platform. # @param RAY_START_HEIGHT A height from which the ground following ray will originate. 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) ## Evaluated every frame. def evaluate(self): if self.activated == True: # platform translation in the world _platform_trans_vec = self.sf_abs_input_mat.value.get_translate() # tracked device translation on the platform _device_trans_vec = self.sf_station_mat.value.get_translate() # prepare ground following matrix _gf_start_pos = self.sf_station_mat.value.get_translate() _gf_start_pos.y = self.ray_start_height _gf_start_pos *= self.sf_scale.value _gf_start_pos = self.sf_abs_input_mat.value * _gf_start_pos _gf_start_pos = avango.gua.Vec3(_gf_start_pos.x, _gf_start_pos.y, _gf_start_pos.z) self.sf_gf_start_mat.value = avango.gua.make_trans_mat( _gf_start_pos) * self.ground_pick_direction_mat if len(self.mf_ground_pick_result.value ) > 0: # an intersection with the ground was found # get first intersection target _pick_result = self.mf_ground_pick_result.value[0] #print _pick_result.Object.value, _pick_result.Object.value.Name.value # compare distance to ground and ray_start_height _distance_to_ground = _pick_result.Distance.value * self.ground_pick_length _difference = _distance_to_ground - (self.ray_start_height * self.sf_scale.value) _difference = round(_difference, 3) if _difference < 0: # climb up # end falling when necessary if self.falling: self.falling = False self.fall_velocity = self.initial_fall_velocity # move player up _up_vec = avango.gua.Vec3( 0.0, _difference * -1.0 * self.height_modification_factor, 0.0) self.sf_abs_output_mat.value = avango.gua.make_trans_mat( _up_vec) * self.sf_abs_input_mat.value elif _difference > 0: if _difference > (self.ray_start_height * self.sf_scale.value): # falling # make player fall down faster every time self.falling = True _fall_vec = avango.gua.Vec3(0.0, -self.fall_velocity, 0.0) self.sf_abs_output_mat.value = avango.gua.make_trans_mat( _fall_vec) * self.sf_abs_input_mat.value self.fall_velocity += 0.005 else: # climb down # end falling when necessary if self.falling: self.falling = False self.fall_velocity = self.initial_fall_velocity # move player down _down_vec = avango.gua.Vec3( 0.0, _difference * -1.0 * self.height_modification_factor, 0.0) self.sf_abs_output_mat.value = avango.gua.make_trans_mat( _down_vec) * self.sf_abs_input_mat.value else: self.sf_abs_output_mat.value = self.sf_abs_input_mat.value # player remains on ground else: #print "None" self.sf_abs_output_mat.value = self.sf_abs_input_mat.value # no intersection with ground was found else: self.sf_abs_output_mat.value = self.sf_abs_input_mat.value # ground following is deactivated ## Sets the pick_direction attribute. # @param PICK_DIRECTION New pick direction. def set_pick_direction(self, PICK_DIRECTION): PICK_DIRECTION.normalize() _ref = avango.gua.Vec3(0.0, 0.0, -1.0) _angle = math.degrees(math.acos(_ref.dot(PICK_DIRECTION))) _axis = _ref.cross(PICK_DIRECTION) self.ground_pick_direction_mat = avango.gua.make_rot_mat(_angle, _axis) ## Activates the ground following algorithm. def activate(self): self.activated = True self.ground_intersection.activate(True) ## Deactivates the ground following algorithm. The input matrix is just passed through after calling this method. def deactivate(self): self.activated = False self.ground_intersection.activate(False)
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
class User(VisibilityHandler2D): ## @var mf_screen_pick_result # Intersections of the viewing ray with the screens in the setup. mf_screen_pick_result = avango.gua.MFPickResult() ## Default constructor. def __init__(self): self.super(User).__init__() ## Custom constructor. # @param WORKSPACE_INSTANCE Workspace instance in which this user is active. # @param USER_ID Global user ID to be applied. # @param VIP Boolean indicating if the user to be created is a vip. # @param AVATAR_VISIBILITY_TABLE A matrix containing visibility rules according to the DisplayGroups' visibility tags. # @param HEADTRACKING_TARGET_NAME Name of the headtracking station as registered in daemon. # @param EYE_DISTANCE The eye distance of the user to be applied. # @param NO_TRACKING_MAT Matrix to be applied when HEADTRACKING_TARGET_NAME is None. 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) ## Evaluated every frame. def evaluate(self): # evaluate viewing ray intersections with screen proxy geometries for _i in range(len(self.mf_screen_pick_result.value)): _pick_object = self.mf_screen_pick_result.value[_i].Object.value # only consider own workspace geometries if _pick_object.Name.value.startswith( "proxy_w" + str(self.WORKSPACE_INSTANCE.id)): _display_group_id = int( _pick_object.Name.value.split("_")[2].replace("dg", "")) self.last_seen_display_group = self.WORKSPACE_INSTANCE.display_groups[ _display_group_id] break _track_vec = self.headtracking_reader.sf_abs_vec.value if _track_vec.x < -1.5 and _track_vec.x > -2.4 and \ _track_vec.y < 1.05 and _track_vec.y > 0.95 and \ _track_vec.z < 1.35 and _track_vec.z > 0.16: self.toggle_user_activity(False) else: self.toggle_user_activity(True) ## Changes the visibility table during runtime. # @param VISIBILITY_TABLE A matrix containing visibility rules according to the DisplayGroups' visibility tags. def change_visiblity_table(self, VISIBILITY_TABLE): self.visibility_table = VISIBILITY_TABLE for _display_group in self.WORKSPACE_INSTANCE.display_groups: self.handle_correct_visibility_groups_for(_display_group) ## Creates a UserRepresentation instance for a given display group. # @param DISPLAY_GROUP Reference to the DisplayGroup instance to create the user representation for. # @param VIEW_TRANSFORM_NODE Transform node to be filled by one navigation of the display group. # @param VIRTUAL_USER_REPR_DISPLAY_INDEX If this is a portal user representation, ID giving the display index within the display group. -1 otherwise. # @param HEAD_NODE_NAME Name of the UserRepresentation's head node in the scenegraph. # @param COMPLEX_SETUP If activated, the transformation policy is evaluated every frame to update head. If deactivated, # a standard mono viewing setup is assumed. def create_user_representation_for(self, DISPLAY_GROUP, VIEW_TRANSFORM_NODE, VIRTUAL_USER_REPR_DISPLAY_INDEX=-1, HEAD_NODE_NAME="head", COMPLEX_SETUP=True): _user_repr = UserRepresentation() _user_repr.my_constructor(self, DISPLAY_GROUP, VIEW_TRANSFORM_NODE, VIRTUAL_USER_REPR_DISPLAY_INDEX, HEAD_NODE_NAME, COMPLEX_SETUP) self.user_representations.append(_user_repr) return _user_repr ## Returns the UserRepresentation instance at a diven DISPLAY_GROUP_ID. # @param DISPLAY_GROUP_ID The id of the DisplayGroup to retrieve the UserRepresentation for. def get_user_representation_at(self, DISPLAY_GROUP_ID): return self.user_representations[DISPLAY_GROUP_ID] ## Switches the navigation for a display group. # @param DISPLAY_GROUP_ID Identification number of the display group to switch the navigation for. # @param NAVIGATION_ID Identification number of the navigation to be used within the display group. # @param WORKSPACE_USERS A list of all Users active in the workspace. def switch_navigation_at_display_group(self, DISPLAY_GROUP_ID, NAVIGATION_ID, WORKSPACE_USERS): if DISPLAY_GROUP_ID < len(self.user_representations): # switch navigation to desired one for DISPLAY_GROUP_ID _old_nav_id = self.user_representations[ DISPLAY_GROUP_ID].connected_navigation_id self.user_representations[ DISPLAY_GROUP_ID].connect_navigation_of_display_group( NAVIGATION_ID) _display_group_instance = self.user_representations[ DISPLAY_GROUP_ID].DISPLAY_GROUP # trigger correct tool visibilities at display group for _tool in self.WORKSPACE_INSTANCE.tools: _tool.handle_correct_visibility_groups_for( _display_group_instance) # trigger correct avatar and screen visibilities #for _user in WORKSPACE_USERS: # _user.handle_correct_visibility_groups_for(_display_group_instance) # trigger correct video visibilites at both navigations if self.WORKSPACE_INSTANCE.video_3D != None and ApplicationManager.current_avatar_mode == "VIDEO": _old_nav = self.WORKSPACE_INSTANCE.display_groups[ DISPLAY_GROUP_ID].navigations[_old_nav_id] _new_nav = self.WORKSPACE_INSTANCE.display_groups[ DISPLAY_GROUP_ID].navigations[NAVIGATION_ID] self.WORKSPACE_INSTANCE.video_3D.handle_correct_visibility_groups_for( _old_nav) self.WORKSPACE_INSTANCE.video_3D.handle_correct_visibility_groups_for( _new_nav) else: for _user in WORKSPACE_USERS: _user.handle_correct_visibility_groups_for( _display_group_instance) else: print_error("Error. Display Group ID does not exist.", False) ## Sets the user's active flag. # @param ACTIVE Boolean to which the active flag should be set. def toggle_user_activity(self, ACTIVE): if ACTIVE: self.is_active = True else: self.is_active = False ## Handles the correct GroupNames of all UserRepresentations at a display group. # @param DISPLAY_GROUP The DisplayGroup to be handled. def handle_correct_visibility_groups_for(self, DISPLAY_GROUP): # All UserRepresentation instances at DISPLAY_GROUP # normally, this list should just contain one user representation # in case of portals, however, a display group may have more than one user representation _user_representations_at_display_group = [] for _user_repr in self.user_representations: if _user_repr.DISPLAY_GROUP == DISPLAY_GROUP: _user_representations_at_display_group.append(_user_repr) # for all found user representations in the given display group for _user_repr_at_display_group in _user_representations_at_display_group: # display group instance belonging to DISPLAY_GROUP _handled_display_group_instance = _user_repr_at_display_group.DISPLAY_GROUP _all_user_reprs_at_display_group = [] for _user_repr in ApplicationManager.all_user_representations: if _user_repr.DISPLAY_GROUP == _handled_display_group_instance: _all_user_reprs_at_display_group.append(_user_repr) ## determine which group names have to be added to the user representations ## _user_visible_for = [] # when video avatars are enabled, do not make josephs visible if ApplicationManager.current_avatar_mode == "JOSEPH": # append all names of user representations which are not on same navigation for _user_repr in _all_user_reprs_at_display_group: if _user_repr.connected_navigation_id != _user_repr_at_display_group.connected_navigation_id: _user_visible_for.append( _user_repr.view_transform_node.Name.value) # check for all user representations outside the handled display group for _user_repr in ApplicationManager.all_user_representations: if _user_repr.DISPLAY_GROUP != _handled_display_group_instance: # consider visibility table _handled_display_group_tag = _handled_display_group_instance.visibility_tag _user_repr_display_group_tag = _user_repr.DISPLAY_GROUP.visibility_tag try: _visible = self.visibility_table[ _user_repr_display_group_tag][ _handled_display_group_tag] except: _visible = False if _visible: if _user_repr.view_transform_node.Name.value == "scene_matrix": _user_visible_for.append( _user_repr.view_transform_node.Parent. value.Name.value + "_" + _user_repr.head.Name.value) else: _user_visible_for.append( _user_repr.view_transform_node.Name.value) # apply the obtained group names to the user representation if len(_user_visible_for) == 0: # prevent wildcard from rendering the avatar _user_repr_at_display_group.set_avatar_group_names( ["do_not_display_group"]) else: for _string in _user_visible_for: _user_repr_at_display_group.set_avatar_group_names( _user_visible_for)
class GroundFollowing(avango.script.Script): # input field ## @var sf_abs_input_mat # The input matrix to be corrected by the ground following algorithm. sf_abs_input_mat = avango.gua.SFMatrix4() sf_abs_input_mat.value = avango.gua.make_identity_mat() # output field ## @var sf_abs_output_mat # The corrected matrix after the ground following algorithm was applied. sf_abs_output_mat = avango.gua.SFMatrix4() sf_abs_output_mat.value = avango.gua.make_identity_mat() # internal fields ## @var sf_gf_start_mat # The matrix representing the position where the sent ray to the ground starts. sf_gf_start_mat = avango.gua.SFMatrix4() sf_gf_start_mat.value = avango.gua.make_identity_mat() ## @var sf_station_mat # The matrix representing the position of the device belonging to the platform. sf_station_mat = avango.gua.SFMatrix4() sf_station_mat.value = avango.gua.make_identity_mat() ## @var mf_ground_pick_result # Intersections of the ground following ray with the objects in the scene. mf_ground_pick_result = avango.gua.MFPickResult() ## Default constructor. def __init__(self): self.super(GroundFollowing).__init__() ## Custom constructor. # @param SCENEGRAPH Reference to the scenegraph of the currently displayed scene. # @param SF_STATION_MAT The field containing the current position of the device belonging to the platform. # @param SETTINGS A list of a boolean and a floating number representing self.activated and self.ray_start_height def my_constructor(self, SCENEGRAPH, SF_STATION_MAT, SETTINGS): # 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 scale_factor # Scaling factor used for the modification of up and down vectors. self.scale_factor = 0.1 # 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 # Direction of the ground following ray (downwards). self.ground_pick_direction = avango.gua.Vec3(0.0, -1.0, 0.0) ## @var SCENEGRAPH # Reference to the scenegraph to intersect the ground following ray with. self.SCENEGRAPH = SCENEGRAPH ## @var ray_start_height # Starting height of the ground following ray. self.ray_start_height = SETTINGS[1] # initialize shoot and output matrices self.sf_abs_output_mat.value = self.sf_abs_input_mat.value # 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(SCENEGRAPH, self.sf_gf_start_mat, self.ground_pick_length, self.ground_pick_direction) self.mf_ground_pick_result.connect_from( self.ground_intersection.mf_pick_result) # activate or deactive ground following if SETTINGS[0] == True: self.activate() else: self.deactivate() ## Evaluated every frame. def evaluate(self): if self.activated: # prepare ground following matrix _platform_trans_vec = self.sf_abs_input_mat.value.get_translate() _device_trans_vec = self.sf_station_mat.value.get_translate() _gf_start_pos = self.sf_abs_input_mat.value * avango.gua.Vec3( self.sf_station_mat.value.get_element(0, 3), self.ray_start_height, self.sf_station_mat.value.get_element(2, 3)) self.sf_gf_start_mat.value = avango.gua.make_trans_mat( _gf_start_pos.x, _gf_start_pos.y, _gf_start_pos.z) if len(self.mf_ground_pick_result.value ) > 0: # an intersection with the ground was found _pick_result = self.mf_ground_pick_result.value[ 0] # get first intersection target _distance_to_ground = _pick_result.Distance.value * self.ground_pick_length _difference = _distance_to_ground - self.ray_start_height _difference = round(_difference, 3) if _difference < 0: # climb up if self.falling: self.falling = False self.fall_velocity = self.initial_fall_velocity _up_vec = avango.gua.Vec3( 0.0, _difference * -1.0 * self.scale_factor, 0.0) self.sf_abs_output_mat.value = avango.gua.make_trans_mat( _up_vec) * self.sf_abs_input_mat.value elif _difference > 0: if _difference > self.ray_start_height: # falling self.falling = True _fall_vec = avango.gua.Vec3(0.0, -self.fall_velocity, 0.0) self.sf_abs_output_mat.value = avango.gua.make_trans_mat( _fall_vec) * self.sf_abs_input_mat.value self.fall_velocity += 0.005 else: # climb down if self.falling: self.falling = False self.fall_velocity = self.initial_fall_velocity _down_vec = avango.gua.Vec3( 0.0, _difference * -1.0 * self.scale_factor, 0.0) self.sf_abs_output_mat.value = avango.gua.make_trans_mat( _down_vec) * self.sf_abs_input_mat.value else: self.sf_abs_output_mat.value = self.sf_abs_input_mat.value # player remains on ground else: self.sf_abs_output_mat.value = self.sf_abs_input_mat.value # no intersection with ground was found else: self.sf_abs_output_mat.value = self.sf_abs_input_mat.value # ground following is deactivated ## Activates the ground following algorithm. def activate(self): self.activated = True self.ground_intersection.activate() ## Deactivates the ground following algorithm. The input matrix is just passed through after calling this method. def deactivate(self): self.activated = False self.ground_intersection.deactivate()
class GroundFollowing(avango.script.Script): # input field ## @var sf_abs_input_mat # The input matrix to be corrected by the ground following algorithm. sf_abs_input_mat = avango.gua.SFMatrix4() sf_abs_input_mat.value = avango.gua.make_identity_mat() # output field ## @var sf_abs_output_mat # The corrected matrix after the ground following algorithm was applied. sf_abs_output_mat = avango.gua.SFMatrix4() sf_abs_output_mat.value = avango.gua.make_identity_mat() # internal fields ## @var sf_gf_start_mat # The matrix representing the position where the sent ray to the ground starts. sf_gf_start_mat = avango.gua.SFMatrix4() sf_gf_start_mat.value = avango.gua.make_identity_mat() ## @var sf_station_mat # The matrix representing the position of the device belonging to the platform. sf_station_mat = avango.gua.SFMatrix4() sf_station_mat.value = avango.gua.make_identity_mat() ## @var mf_ground_pick_result # Intersections of the ground following ray with the objects in the scene. mf_ground_pick_result = avango.gua.MFPickResult() ## Default constructor. def __init__(self): self.super(GroundFollowing).__init__() ## Custom constructor. # @param SCENEGRAPH Reference to the scenegraph of the currently displayed scene. # @param SF_STATION_MAT The field containing the current position of the device belonging to the platform. # @param SETTINGS A list of a boolean and a floating number representing self.activated and self.ray_start_height def my_constructor(self, SCENEGRAPH, SF_STATION_MAT, SETTINGS): # 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 scale_factor # Scaling factor used for the modification of up and down vectors. self.scale_factor = 0.1 # 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 # Direction of the ground following ray (downwards). self.ground_pick_direction = avango.gua.Vec3(0.0, -1.0, 0.0) ## @var SCENEGRAPH # Reference to the scenegraph to intersect the ground following ray with. self.SCENEGRAPH = SCENEGRAPH ## @var ray_start_height # Starting height of the ground following ray. self.ray_start_height = SETTINGS[1] # initialize shoot and output matrices self.sf_abs_output_mat.value = self.sf_abs_input_mat.value # 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(SCENEGRAPH, self.sf_gf_start_mat, self.ground_pick_length, self.ground_pick_direction) self.mf_ground_pick_result.connect_from(self.ground_intersection.mf_pick_result) # activate or deactive ground following if SETTINGS[0] == True: self.activate() else: self.deactivate() ## Evaluated every frame. def evaluate(self): if self.activated: # prepare ground following matrix _platform_trans_vec = self.sf_abs_input_mat.value.get_translate() _device_trans_vec = self.sf_station_mat.value.get_translate() _gf_start_pos = self.sf_abs_input_mat.value * avango.gua.Vec3(self.sf_station_mat.value.get_element(0,3), self.ray_start_height, self.sf_station_mat.value.get_element(2,3)) self.sf_gf_start_mat.value = avango.gua.make_trans_mat(_gf_start_pos.x, _gf_start_pos.y, _gf_start_pos.z) if len(self.mf_ground_pick_result.value) > 0: # an intersection with the ground was found _pick_result = self.mf_ground_pick_result.value[0] # get first intersection target _distance_to_ground = _pick_result.Distance.value * self.ground_pick_length _difference = _distance_to_ground - self.ray_start_height _difference = round(_difference, 3) if _difference < 0: # climb up if self.falling: self.falling = False self.fall_velocity = self.initial_fall_velocity _up_vec = avango.gua.Vec3(0.0, _difference * -1.0 * self.scale_factor, 0.0) self.sf_abs_output_mat.value = avango.gua.make_trans_mat(_up_vec) * self.sf_abs_input_mat.value elif _difference > 0: if _difference > self.ray_start_height: # falling self.falling = True _fall_vec = avango.gua.Vec3(0.0, -self.fall_velocity, 0.0) self.sf_abs_output_mat.value = avango.gua.make_trans_mat(_fall_vec) * self.sf_abs_input_mat.value self.fall_velocity += 0.005 else: # climb down if self.falling: self.falling = False self.fall_velocity = self.initial_fall_velocity _down_vec = avango.gua.Vec3(0.0, _difference * -1.0 * self.scale_factor, 0.0) self.sf_abs_output_mat.value = avango.gua.make_trans_mat(_down_vec) * self.sf_abs_input_mat.value else: self.sf_abs_output_mat.value = self.sf_abs_input_mat.value # player remains on ground else: self.sf_abs_output_mat.value = self.sf_abs_input_mat.value # no intersection with ground was found else: self.sf_abs_output_mat.value = self.sf_abs_input_mat.value # ground following is deactivated ## Activates the ground following algorithm. def activate(self): self.activated = True self.ground_intersection.activate() ## Deactivates the ground following algorithm. The input matrix is just passed through after calling this method. def deactivate(self): self.activated = False self.ground_intersection.deactivate()
class MultiTouchDevice(avango.script.Script): """ Base class for multi touch devices. rayOrientation: orientation matrix (start position + direction) of ray fingerCenterPos: the center of finger position in interval from -display-size to +display-size """ _rayOrientation = avango.gua.SFMatrix4() _fingerCenterPos = avango.gua.SFVec3() 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 my_constructor(self, graph, display, NET_TRANS_NODE, SCENE_MANAGER, APPLICATION_MANAGER): """ Initialize multi-touch device. @param graph: the scene graph on which to operate @param display: the physical display """ self._sceneGraph = graph self._display = display self._sceneManager = SCENE_MANAGER """ original matrix of the scene """ self._origMat = graph.Root.value.Transform.value """ """ self._applicationManager = APPLICATION_MANAGER self._intersection.my_constructor(self._sceneGraph, self._rayOrientation, self.ray_length, "") # parameters: SCENEGRAPH, SF_PICK_MATRIX, PICK_LENGTH, PICKMASK """ parent node of ray node """ _parent_node = self._sceneGraph["/net"] """ # init scenegraph node ## @var ray_transform # Transformation node of the pointer's ray. """ self.ray_transform = avango.gua.nodes.TransformNode(Name = "ray_transform") _parent_node.Children.value.append(self.ray_transform) _loader = avango.gua.nodes.TriMeshLoader() """ ## @var ray_geometry # Geometry node representing the ray graphically. """ self.ray_geometry = _loader.create_geometry_from_file("ray_geometry", "data/objects/cylinder.obj", "data/materials/White.gmd", avango.gua.LoaderFlags.DEFAULTS) self.ray_transform.Children.value.append(self.ray_geometry) self.ray_geometry.GroupNames.value = ["do_not_display_group"] self.ray_geometry.Transform.value = avango.gua.make_trans_mat(0,0,0) * \ avango.gua.make_rot_mat(0,0,0,0) * \ avango.gua.make_scale_mat(0,0,0) """ @var intersection_point_geometry Geometry node representing the intersection point of the ray with an object in the scene. """ self.intersection_point_geometry = _loader.create_geometry_from_file("intersection_point_geometry", "data/objects/sphere.obj", "data/materials/White.gmd", avango.gua.LoaderFlags.DEFAULTS) NET_TRANS_NODE.Children.value.append(self.intersection_point_geometry) self.intersection_point_geometry.GroupNames.value = ["do_not_display_group"] # set geometry invisible self.ray_transform.Transform.connect_from(self._rayOrientation) """ representation of fingercenterpos """ self.fingercenterpos_geometry = _loader.create_geometry_from_file("fingercenterpos", "data/objects/sphere.obj", "data/materials/Red.gmd", avango.gua.LoaderFlags.DEFAULTS) NET_TRANS_NODE.Children.value.append(self.fingercenterpos_geometry) self.fingercenterpos_geometry.GroupNames.value = ["do_not_display_group"] """ hand representation """ self.handPos_geometry = _loader.create_geometry_from_file("handpos", "data/objects/cube.obj", "data/materials/Red.gmd", avango.gua.LoaderFlags.DEFAULTS) NET_TRANS_NODE.Children.value.append(self.handPos_geometry) self.handPos_geometry.GroupNames.value = ["do_not_display_group"] """ define Input display size """ #111,5cm x 75,8 self._inputDisplaySize = avango.gua.Vec2(1.115,0.758) def getDisplay(self): return self._display def getSceneGraph(self): return self._sceneGraph def mapInputPosition(self, Pos): """ Map input position to display size """ point = Pos """ map points from interval [0, 1] to [-0.5, 0.5] """ mappedPosX = point[0] * 1 - 0.5 mappedPosY = point[1] * 1 - 0.5 """ map point to display intervall ([-1/2*display-size] -> [+1/2*display-size]) """ mappedPos = avango.gua.Vec3(mappedPosX * self._inputDisplaySize.x, 0.0, mappedPosY * self._inputDisplaySize.y) return mappedPos def setFingerCenterPos(self, fingerPos): self._fingerCenterPos.value = fingerPos """ update fingercenterpos representation """ self.fingercenterpos_geometry.GroupNames.value = [] self.fingercenterpos_geometry.Transform.value = avango.gua.make_trans_mat(self._fingerCenterPos.value) * \ avango.gua.make_scale_mat( 0.025, 0.025 , 0.025 ) def visualisizeHandPosition(self, handPos): """ update hand representation """ self.handPos_geometry.GroupNames.value = [] self.handPos_geometry.Transform.value = avango.gua.make_trans_mat(handPos) * \ avango.gua.make_scale_mat( 0.1, 0.005 , 0.1 ) def setObjectMode(self, active): """ Evaluate object mode. object mode activated only if an intersection was found @param active: toggle active state of object mode """ if active and self._intersectionFound: self._objectMode = True self._objectName = self._intersectionObject.Parent.value.Name.value return True else: self._objectMode = False self._objectName = None return False def addLocalTranslation(self, transMat): """ Add local translation. @param transMat: the (relative) translation matrix """ self._transMat *= transMat def addLocalRotation(self, rotMat): """ Add local rotation. @param rotMat: the (relative) rotation matrix """ self._rotMat *= rotMat def addLocalScaling(self, scaleMat): """ Add local scaling. @param scaleMat: the (relative) scaling matrix """ self._scaleMat *= scaleMat def intersectSceneWithFingerPos(self): """ Intersect Scene with ray from head to finger position. works only for first user. @param transMat: the (relative) translation matrix """ #TODO: decide between displays with tracking and not #for no tracking use this: #self._rayOrientation.value = avango.gua.make_trans_mat(self._fingerCenterPos.value.x , 0.5 , self._fingerCenterPos.value.z) * avango.gua.make_rot_mat(-90,1,0,0) #do this only once per gesture #do this only once per gesture if (1 < (self._frameCounter - self._lastIntersectionCounter)): """ ray orientation from fingerPos down """ self._rayOrientation.value = avango.gua.make_trans_mat(self._fingerCenterPos.value.x , 1 , self._fingerCenterPos.value.z) * avango.gua.make_rot_mat(-90,1,0,0) """intersection found""" if len(self._intersection.mf_pick_result.value) > 0: self._intersectionFound = True """first intersected object""" _pick_result = self._intersection.mf_pick_result.value[0] self._intersectionPoint = _pick_result.Position.value self._intersectionObject = _pick_result.Object.value """update intersectionObject until you insert object Mode""" if not self._objectMode: self._lastIntersectionObject = self._intersectionObject """ transform point into world coordinates """ self._intersectionPoint = self._intersectionObject.WorldTransform.value * self._intersectionPoint """make Vec3 from Vec4""" self._intersectionPoint = avango.gua.Vec3(self._intersectionPoint.x,self._intersectionPoint.y,self._intersectionPoint.z) if (self._objectMode and not self._objectName == self._intersectionObject.Parent.value.Name.value): #print "same object" self._intersectionPoint = avango.gua.Vec3(0,0,0) """ VISUALISATION """ """update intersection sphere""" self.intersection_point_geometry.Transform.value = avango.gua.make_trans_mat(self._intersectionPoint) * \ avango.gua.make_scale_mat(self.intersection_sphere_size, self.intersection_sphere_size, self.intersection_sphere_size) """set sphere and ray visible""" #self.intersection_point_geometry.GroupNames.value = [] #self.ray_geometry.GroupNames.value = [] """update ray""" _distance = (self._intersectionPoint - self.ray_transform.WorldTransform.value.get_translate()).length() self.ray_geometry.Transform.value = avango.gua.make_trans_mat(0.0, 0.0, _distance * -0.5) * \ avango.gua.make_rot_mat(-90.0,1,0,0) * \ avango.gua.make_scale_mat(self.ray_thickness, _distance, self.ray_thickness) else: """set geometry invisible""" self.intersection_point_geometry.GroupNames.value = ["do_not_display_group"] self.ray_geometry.GroupNames.value = ["do_not_display_group"] """set to default ray length""" self.ray_geometry.Transform.value = avango.gua.make_trans_mat(0.0,0.0,self.ray_length * -0.5) * \ avango.gua.make_rot_mat(-90.0,1,0,0) * \ avango.gua.make_scale_mat(self.ray_thickness, self.ray_length, self.ray_thickness) self._intersectionFound = False self._intersectionPoint = avango.gua.Vec3(0,0,0) self._lastIntersectionCounter = self._frameCounter def update_object_highlight(self): """highlight active object:""" if self._objectMode: _node = self._lastIntersectionObject if _node.has_field("InteractiveObject") == True: _object = _node.InteractiveObject.value if self.hierarchy_selection_level >= 0: _object = _object.get_higher_hierarchical_object(self.hierarchy_selection_level) if _object == None: """ evtl. disable highlight of prior object""" if self.highlighted_object != None: self.highlighted_object.enable_highlight(False) else: if _object != self.highlighted_object: # new object hit """evtl. disable highlight of prior object""" if self.highlighted_object != None: self.highlighted_object.enable_highlight(False) self.highlighted_object = _object """enable highlight of new object""" self.highlighted_object.enable_highlight(True) else: """evtl. disable highlight of prior object""" if self.highlighted_object != None: self.highlighted_object.enable_highlight(False) self.highlighted_object = None def applyTransformations(self): """ Apply calculated world matrix to scene graph. Requires the scene graph to have a transform node as root node. """ """ Reguires the scnene Name of actually scene to change dynamically """ sceneName = self._sceneManager.getActiveSceneName() """ to avoid errors until the scenen Name is set """ if (None != sceneName): sceneNode = "/net/" + sceneName self._globalMatrix = self._sceneGraph[sceneNode].Transform.value """ object Mode """ if self._objectMode: objectNode = "/net/" + sceneName + "/" + self._objectName scenePos = self._sceneGraph[objectNode].Transform.value.get_translate() TransformMatrix = self._sceneGraph[objectNode].Transform.value else: scenePos = self._sceneGraph[sceneNode].Transform.value.get_translate() TransformMatrix = self._sceneGraph[sceneNode].Transform.value """ distance between finger position and scene position (object position) """ translateDistance = self._fingerCenterPos.value - scenePos """transform world-space to object-space""" translateDistance = avango.gua.make_inverse_mat(avango.gua.make_rot_mat(TransformMatrix.get_rotate_scale_corrected())) * translateDistance translateDistance = avango.gua.Vec3(translateDistance.x, translateDistance.y, translateDistance.z) #print (self._transMat) """ TransfotmMatrix: 1. translate and rotate to origin, 2. calculate new position, 3. translate and rotate back """ """ object mode """ if self._objectMode: TransformMatrix = avango.gua.make_trans_mat(TransformMatrix.get_translate()) * \ avango.gua.make_rot_mat(TransformMatrix.get_rotate_scale_corrected()) * \ avango.gua.make_inverse_mat(avango.gua.make_rot_mat(self._globalMatrix.get_rotate_scale_corrected())) * \ avango.gua.make_inverse_mat(avango.gua.make_rot_mat(TransformMatrix.get_rotate_scale_corrected())) * \ self._rotMat * \ self._scaleMat * \ self._transMat * \ avango.gua.make_rot_mat(TransformMatrix.get_rotate_scale_corrected()) * \ avango.gua.make_rot_mat(self._globalMatrix.get_rotate_scale_corrected()) * \ avango.gua.make_scale_mat(TransformMatrix.get_scale()) else: TransformMatrix = avango.gua.make_trans_mat(TransformMatrix.get_translate()) * \ avango.gua.make_rot_mat(TransformMatrix.get_rotate_scale_corrected()) *\ avango.gua.make_trans_mat(translateDistance * 1.0) * \ avango.gua.make_trans_mat(avango.gua.Vec3(0, self._intersectionPoint.y * -1.0 , 0)) * \ avango.gua.make_inverse_mat(avango.gua.make_rot_mat(TransformMatrix.get_rotate_scale_corrected())) * \ self._rotMat * \ self._scaleMat * \ self._transMat * \ avango.gua.make_rot_mat(TransformMatrix.get_rotate_scale_corrected()) * \ avango.gua.make_trans_mat(avango.gua.Vec3(0, self._intersectionPoint.y * 1.0 , 0)) * \ avango.gua.make_trans_mat(translateDistance * -1.0) * \ avango.gua.make_scale_mat(TransformMatrix.get_scale()) """ object mode """ if self._objectMode: self._sceneGraph[objectNode].Transform.value = TransformMatrix else: self._sceneGraph[sceneNode].Transform.value = TransformMatrix """ reset all data """ self._transMat = avango.gua.make_identity_mat() self._rotMat = avango.gua.make_identity_mat() self._scaleMat = avango.gua.make_identity_mat() self._globalMatrix = avango.gua.make_identity_mat()
# 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 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)
class Ray(avango.script.Script): # internal fields ## @var sf_pointer_button0 # Boolean field representing the first button of the pointer. sf_pointer_button0 = avango.SFBool() ## @var sf_pointer_button1 # Boolean field representing the second button of the pointer. sf_pointer_button1 = avango.SFBool() ## @var sf_pointer_button2 # Boolean field representing the third button of the pointer. sf_pointer_button2 = avango.SFBool() ## @var mf_pointer_pick_result # Intersections of the picking ray with the objects in the scene. mf_pointer_pick_result = avango.gua.MFPickResult() sf_normals = avango.gua.SFVec3() ## Default constructor. def __init__(self): self.super(Ray).__init__() ## Custom constructor. # @param MANIPULATION_MANAGER Reference to the ManipulationManager instance to which this RayPointer is associated. # @param ID Identification number of the RayPointer, starting from 1. # @param SCENEGRAPH Reference to the scenegraph in which the manipulation is taking place. # @param NET_TRANS_NODE Reference to the nettrans node to which the scene is appended to. # @param PARENT_NODE Scenegraph node to which the ray is to be appended to. # @param TRACKING_TRANSMITTER_OFFSET Transmitter offset of the tracking system to be applied. # @param POINTER_TRACKING_STATION Tracking target name of the pointing device. # @param POINTER_DEVICE_STATION Input values name of the pointing device. #def my_constructor(self, MANIPULATION_MANAGER, ID, SCENEGRAPH, NET_TRANS_NODE, PARENT_NODE, TRACKING_TRANSMITTER_OFFSET, POINTER_TRACKING_STATION, POINTER_DEVICE_STATION): def my_constructor(self, MANIPULATION_MANAGER, ID, SCENEGRAPH, NET_TRANS_NODE, PARENT_NODE, MATRIX, POINTER_DEVICE_STATION): # references ## @var MANIPULATION_MANAGER # Reference to the ManipulationManager instance to which this RayPointer is associated. self.MANIPULATION_MANAGER = MANIPULATION_MANAGER self.net_trans_node = NET_TRANS_NODE self.parent_node = PARENT_NODE # parameters ## @var ray_length # Length of the pointer's ray in meters. self.ray_length = 10.0 ## @var ray_thickness # Thickness of the pointer's ray in meters. self.ray_thickness = 0.0075 ## @var intersection_sphere_size # Radius of the intersection sphere in meters. self.intersection_sphere_size = 0.025 ## @var hierarchy_selection_level # Hierarchy level which is selected by this pointer. self.hierarchy_selection_level = 0 # variables ## @var id # Identification number of the RayPointer, starting from 1. self.id = ID ## @var highlighted_object # Reference to the currently highlighted object. self.highlighted_object = None ## @var dragged_object # Reference to the currently dragged object. self.dragged_object = None ## @var dragging_offset # Offset to be applied during the dragging process. self.dragging_offset = None # init sensors ## @var pointer_tracking_sensor # Device sensor capturing the pointer's tracking position and rotation. #self.pointer_tracking_sensor = avango.daemon.nodes.DeviceSensor(DeviceService = avango.daemon.DeviceService()) #self.pointer_tracking_sensor.Station.value = POINTER_TRACKING_STATION #self.pointer_tracking_sensor.ReceiverOffset.value = avango.gua.make_identity_mat() #self.pointer_tracking_sensor.TransmitterOffset.value = TRACKING_TRANSMITTER_OFFSET ## @var pointer_device_sensor # Device sensor capturing the pointer's button input values. self.pointer_device_sensor = avango.daemon.nodes.DeviceSensor(DeviceService = avango.daemon.DeviceService()) self.pointer_device_sensor.Station.value = POINTER_DEVICE_STATION # init scenegraph node ## @var ray_transform # Transformation node of the pointer's ray. self.ray_transform = avango.gua.nodes.TransformNode(Name = "ray_transform") PARENT_NODE.Children.value.append(self.ray_transform) _loader = avango.gua.nodes.GeometryLoader() ## @var ray_geometry # Geometry node representing the ray graphically. self.ray_geometry = _loader.create_geometry_from_file("ray_geometry", "data/objects/cylinder.obj", "data/materials/White.gmd", avango.gua.LoaderFlags.DEFAULTS) self.ray_transform.Children.value.append(self.ray_geometry) self.ray_geometry.Transform.value = avango.gua.make_trans_mat(0.0,0.0,self.ray_length * -0.5) * \ avango.gua.make_rot_mat(-90.0,1,0,0) * \ avango.gua.make_scale_mat(0.005,self.ray_length,0.005) self.edge_geometry = _loader.create_geometry_from_file("edge_geometry", "data/objects/cylinder.obj", "data/materials/White.gmd", avango.gua.LoaderFlags.DEFAULTS) NET_TRANS_NODE.Children.value.append(self.edge_geometry) self.edge_geometry.GroupNames.value = ["do_not_display_group"] # set geometry invisible ## @var intersection_point_geometry # Geometry node representing the intersection point of the ray with an object in the scene. self.intersection_point_geometry = _loader.create_geometry_from_file("intersection_point_geometry", "data/objects/sphere.obj", "data/materials/White.gmd", avango.gua.LoaderFlags.DEFAULTS) NET_TRANS_NODE.Children.value.append(self.intersection_point_geometry) self.intersection_point_geometry.GroupNames.value = ["do_not_display_group"] # set geometry invisible ## @var dragging_trigger # Trigger function which is called when a dragging process is in progress. self.dragging_trigger = avango.script.nodes.Update(Callback = self.dragging_callback, Active = False) # init sub classes ## @var pointer_intersection # Instance of Intersection to determine hit points of the ray with the scene self.pointer_intersection = Intersection() # ray intersection for target identification self.pointer_intersection.my_constructor(SCENEGRAPH, self.ray_transform.WorldTransform, self.ray_length, "man_pick_group") # parameters: SCENEGRAPH, SF_PICK_MATRIX, PICK_LENGTH, PICKMASK self.line_crossing = LineCrossing() self.line_crossing.my_constructor(self.sf_normals) self.line_crossing_trigger = False # init field connections #self.ray_transform.Transform.connect_from(self.pointer_tracking_sensor.Matrix) self.ray_transform.Transform.connect_from(MATRIX) self.mf_pointer_pick_result.connect_from(self.pointer_intersection.mf_pick_result) self.sf_pointer_button0.connect_from(self.pointer_device_sensor.Button0) self.sf_pointer_button1.connect_from(self.pointer_device_sensor.Button1) self.sf_pointer_button2.connect_from(self.pointer_device_sensor.Button2) #if self.pointer_tracking_sensor.Station.value == "device-mouse": # self.mouse_mover = MouseMover() # self.mouse_mover.my_constructor(self.pointer_tracking_sensor) # self.ray_transform.Transform.connect_from(self.mouse_mover.sf_output_mat) self.set_hierarchy_selection_level(-1) self.output_mat = avango.gua.make_identity_mat() self.intersection_point = avango.gua.Vec3 # callbacks ## Called whenever mf_pointer_pick_result changes. @field_has_changed(mf_pointer_pick_result) def mf_pointer_pick_result_mat_changed(self): self.update_ray() self.update_object_highlight() ## Called whenever sf_pointer_button0 changes. @field_has_changed(sf_pointer_button0) def sf_pointer_button0_changed(self): if self.sf_pointer_button0.value == True and self.highlighted_object != None: # dragging started self.output_mat = self.ray_transform.WorldTransform.value self.dragged_object = self.highlighted_object if self.dragged_object.handler != None: self.dragged_object.handler.add_input(self) #self.dragging_offset = avango.gua.make_inverse_mat(self.ray_transform.WorldTransform.value) * self.dragged_object.get_world_transform() self.dragging_trigger.Active.value = True # activate dragging callback #get intersection point _pick_result = self.mf_pointer_pick_result.value[0] # get first intersection target _point = _pick_result.Position.value # intersection point in object coordinate system _node = _pick_result.Object.value _point = _node.WorldTransform.value * _point # transform point into world coordinates _point = avango.gua.Vec3(_point.x,_point.y,_point.z) # make Vec3 from Vec4 else: self.dragged_object = None elif self.sf_pointer_button0.value == False and self.dragged_object != None: # dragging stopped self.dragged_object.handler.remove_input(self) self.dragged_object = None self.dragging_trigger.Active.value = False # deactivate dragging callback ## Called whenever sf_pointer_button1 changes. @field_has_changed(sf_pointer_button1) def sf_pointer_button1_changed(self): if self.sf_pointer_button1.value == True and self.highlighted_object != None: self.line_crossing_trigger = True if self.sf_pointer_button1.value == False: self.line_crossing_trigger = False #if self.sf_pointer_button1.value == True: # self.set_hierarchy_selection_level(min(self.hierarchy_selection_level + 1, 3)) ## Called whenever sf_pointer_button2 changes. #@field_has_changed(sf_pointer_button2) #def sf_pointer_button2_changed(self): #if self.sf_pointer_button2.value == True: # self.set_hierarchy_selection_level(max(self.hierarchy_selection_level - 1, -1)) # functions ## Called when in dragging. Updates the position of the dragged object. def dragging_callback(self): #_mat = self.ray_transform.WorldTransform.value * self.dragging_offset self.output_mat = self.ray_transform.WorldTransform.value #self.dragged_object.set_world_transform(_mat) ## Change the hierarchy selection level to a given level. # @param HIERARCHY_LEVEL The new hierarchy selection level to be set. def set_hierarchy_selection_level(self, HIERARCHY_LEVEL): self.hierarchy_selection_level = HIERARCHY_LEVEL print "hierarchy selection level", self.hierarchy_selection_level if self.hierarchy_selection_level >= 0: _material = self.MANIPULATION_MANAGER.get_hierarchy_material(HIERARCHY_LEVEL) self.ray_geometry.Material.value = _material self.intersection_point_geometry.Material.value = _material else: self.ray_geometry.Material.value = "data/materials/White.gmd" self.intersection_point_geometry.Material.value = "data/materials/White.gmd" ## Updates the ray according to the intersections found. def update_ray(self): # self.parent_node.WorldTransform.value if len(self.mf_pointer_pick_result.value) > 0: # intersection found _pick_result = self.mf_pointer_pick_result.value[0] # get first intersection target #print _pick_result.Normal.value #print _pick_result.Object.value, _pick_result.Object.value.Name.value # update intersection point #_point = _pick_result.WorldPosition.value # intersection point in world coordinate system --> not working ??? _point = _pick_result.Position.value # intersection point in object coordinate system _node = _pick_result.Object.value _point = _node.WorldTransform.value * _point # transform point into world coordinates _point = avango.gua.Vec3(_point.x,_point.y,_point.z) # make Vec3 from Vec4 if self.line_crossing_trigger == True: self.sf_normals.value = _pick_result.Normal.value if self.line_crossing.edge != None: _axis = self.line_crossing.edge.cross(avango.gua.Vec3(0,1,0)) _pos = _pick_result.Position.value self.edge_geometry.Transform.value = avango.gua.make_trans_mat(_pos) *\ avango.gua.make_rot_mat(self.line_crossing._angle, _axis) *\ avango.gua.make_scale_mat(0.05,1,0.05) self.edge_geometry.GroupNames.value = [] # set geometry visible self.edge_geometry.Transform.value =_node.WorldTransform.value * self.edge_geometry.Transform.value self.line_crossing_trigger= False self.intersection_point = _point self.intersection_point_geometry.Transform.value = avango.gua.make_trans_mat(_point) * \ avango.gua.make_scale_mat(self.intersection_sphere_size, self.intersection_sphere_size, self.intersection_sphere_size) self.intersection_point_geometry.GroupNames.value = [] # set geometry visible # update ray length _distance = (_point - self.ray_transform.WorldTransform.value.get_translate()).length() self.ray_geometry.Transform.value = avango.gua.make_trans_mat(0.0,0.0,_distance * -0.5) * \ avango.gua.make_rot_mat(-90.0,1,0,0) * \ avango.gua.make_scale_mat(self.ray_thickness, _distance, self.ray_thickness) else: # no intersection found #print "None" self.intersection_point_geometry.GroupNames.value = ["do_not_display_group"] # set geometry invisible # set to default ray length self.ray_geometry.Transform.value = avango.gua.make_trans_mat(0.0,0.0,self.ray_length * -0.5) * \ avango.gua.make_rot_mat(-90.0,1,0,0) * \ avango.gua.make_scale_mat(self.ray_thickness, self.ray_length, self.ray_thickness) ## Updates the object to be highlighted according to the intersections found. def update_object_highlight(self): if len(self.mf_pointer_pick_result.value) > 0: # intersection found _pick_result = self.mf_pointer_pick_result.value[0] # get first intersection target _node = _pick_result.Object.value if _node.has_field("InteractiveObject") == True: _object = _node.InteractiveObject.value if self.hierarchy_selection_level >= 0: _object = _object.get_higher_hierarchical_object(self.hierarchy_selection_level) if _object == None: # evtl. disable highlight of prior object if self.highlighted_object != None: self.highlighted_object.enable_highlight(False) else: if _object != self.highlighted_object: # new object hit # evtl. disable highlight of prior object if self.highlighted_object != None: self.highlighted_object.enable_highlight(False) self.highlighted_object = _object # enable highlight of new object self.highlighted_object.enable_highlight(True) else: # no intersection found # evtl. disable highlight of prior object if self.highlighted_object != None: self.highlighted_object.enable_highlight(False) self.highlighted_object = None
def my_constructor(self, MANIPULATION_MANAGER, ID, SCENEGRAPH, NET_TRANS_NODE, PARENT_NODE, MATRIX, POINTER_DEVICE_STATION): # references ## @var MANIPULATION_MANAGER # Reference to the ManipulationManager instance to which this RayPointer is associated. self.MANIPULATION_MANAGER = MANIPULATION_MANAGER self.net_trans_node = NET_TRANS_NODE self.parent_node = PARENT_NODE # parameters ## @var ray_length # Length of the pointer's ray in meters. self.ray_length = 10.0 ## @var ray_thickness # Thickness of the pointer's ray in meters. self.ray_thickness = 0.0075 ## @var intersection_sphere_size # Radius of the intersection sphere in meters. self.intersection_sphere_size = 0.025 ## @var hierarchy_selection_level # Hierarchy level which is selected by this pointer. self.hierarchy_selection_level = 0 # variables ## @var id # Identification number of the RayPointer, starting from 1. self.id = ID ## @var highlighted_object # Reference to the currently highlighted object. self.highlighted_object = None ## @var dragged_object # Reference to the currently dragged object. self.dragged_object = None ## @var dragging_offset # Offset to be applied during the dragging process. self.dragging_offset = None # init sensors ## @var pointer_tracking_sensor # Device sensor capturing the pointer's tracking position and rotation. #self.pointer_tracking_sensor = avango.daemon.nodes.DeviceSensor(DeviceService = avango.daemon.DeviceService()) #self.pointer_tracking_sensor.Station.value = POINTER_TRACKING_STATION #self.pointer_tracking_sensor.ReceiverOffset.value = avango.gua.make_identity_mat() #self.pointer_tracking_sensor.TransmitterOffset.value = TRACKING_TRANSMITTER_OFFSET ## @var pointer_device_sensor # Device sensor capturing the pointer's button input values. self.pointer_device_sensor = avango.daemon.nodes.DeviceSensor(DeviceService = avango.daemon.DeviceService()) self.pointer_device_sensor.Station.value = POINTER_DEVICE_STATION # init scenegraph node ## @var ray_transform # Transformation node of the pointer's ray. self.ray_transform = avango.gua.nodes.TransformNode(Name = "ray_transform") PARENT_NODE.Children.value.append(self.ray_transform) _loader = avango.gua.nodes.GeometryLoader() ## @var ray_geometry # Geometry node representing the ray graphically. self.ray_geometry = _loader.create_geometry_from_file("ray_geometry", "data/objects/cylinder.obj", "data/materials/White.gmd", avango.gua.LoaderFlags.DEFAULTS) self.ray_transform.Children.value.append(self.ray_geometry) self.ray_geometry.Transform.value = avango.gua.make_trans_mat(0.0,0.0,self.ray_length * -0.5) * \ avango.gua.make_rot_mat(-90.0,1,0,0) * \ avango.gua.make_scale_mat(0.005,self.ray_length,0.005) self.edge_geometry = _loader.create_geometry_from_file("edge_geometry", "data/objects/cylinder.obj", "data/materials/White.gmd", avango.gua.LoaderFlags.DEFAULTS) NET_TRANS_NODE.Children.value.append(self.edge_geometry) self.edge_geometry.GroupNames.value = ["do_not_display_group"] # set geometry invisible ## @var intersection_point_geometry # Geometry node representing the intersection point of the ray with an object in the scene. self.intersection_point_geometry = _loader.create_geometry_from_file("intersection_point_geometry", "data/objects/sphere.obj", "data/materials/White.gmd", avango.gua.LoaderFlags.DEFAULTS) NET_TRANS_NODE.Children.value.append(self.intersection_point_geometry) self.intersection_point_geometry.GroupNames.value = ["do_not_display_group"] # set geometry invisible ## @var dragging_trigger # Trigger function which is called when a dragging process is in progress. self.dragging_trigger = avango.script.nodes.Update(Callback = self.dragging_callback, Active = False) # init sub classes ## @var pointer_intersection # Instance of Intersection to determine hit points of the ray with the scene self.pointer_intersection = Intersection() # ray intersection for target identification self.pointer_intersection.my_constructor(SCENEGRAPH, self.ray_transform.WorldTransform, self.ray_length, "man_pick_group") # parameters: SCENEGRAPH, SF_PICK_MATRIX, PICK_LENGTH, PICKMASK self.line_crossing = LineCrossing() self.line_crossing.my_constructor(self.sf_normals) self.line_crossing_trigger = False # init field connections #self.ray_transform.Transform.connect_from(self.pointer_tracking_sensor.Matrix) self.ray_transform.Transform.connect_from(MATRIX) self.mf_pointer_pick_result.connect_from(self.pointer_intersection.mf_pick_result) self.sf_pointer_button0.connect_from(self.pointer_device_sensor.Button0) self.sf_pointer_button1.connect_from(self.pointer_device_sensor.Button1) self.sf_pointer_button2.connect_from(self.pointer_device_sensor.Button2) #if self.pointer_tracking_sensor.Station.value == "device-mouse": # self.mouse_mover = MouseMover() # self.mouse_mover.my_constructor(self.pointer_tracking_sensor) # self.ray_transform.Transform.connect_from(self.mouse_mover.sf_output_mat) self.set_hierarchy_selection_level(-1) self.output_mat = avango.gua.make_identity_mat() self.intersection_point = avango.gua.Vec3
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)
class User(avango.script.Script): ## @var mf_screen_pick_result # Intersections of the viewing ray with the screens in the setup. mf_screen_pick_result = avango.gua.MFPickResult() ## Default constructor. def __init__(self): self.super(User).__init__() ## Custom constructor. # @param APPLICATION_MANAGER Reference to the ApplicationManager instance from which this user is created. # @param USER_ID Global user ID to be applied. # @param VIP Boolean indicating if the user to be created is a vip. # @param GLASSES_ID ID of the shutter glasses worn by the user. # @param HEADTRACKING_TARGET_NAME Name of the headtracking station as registered in daemon. # @param PLATFORM_ID Platform ID to which this user should be appended to. # @param AVATAR_MATERIAL The material string for the user avatar to be created. def my_constructor(self , APPLICATION_MANAGER , USER_ID , VIP , GLASSES_ID , HEADTRACKING_TARGET_NAME , PLATFORM_ID , AVATAR_MATERIAL): # 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 # variables ## @var APPLICATION_MANAGER # Reference to the ApplicationManager instance from which the user is created. self.APPLICATION_MANAGER = APPLICATION_MANAGER ## @var id # Identification number of the user, starting from 0. self.id = USER_ID ## @var platform_id # ID of the platform the user is belonging to. self.platform_id = PLATFORM_ID ## @var platform # Instance of the platform the user is belonging to. self.platform = self.APPLICATION_MANAGER.navigation_list[self.platform_id].platform ## @var current_display # Display instance on which the user physically is currently looking at. self.current_display = self.platform.displays[0] ## @var transmitter_offset # The transmitter offset to be applied. self.transmitter_offset = self.platform.transmitter_offset ## @var no_tracking_mat # The matrix to be applied when no tracking is available. self.no_tracking_mat = self.platform.no_tracking_mat ## @var avatar_material # Material of the user's avatar. self.avatar_material = AVATAR_MATERIAL ## @var headtracking_target_name # Name of the headtracking station as registered in daemon. self.headtracking_target_name = HEADTRACKING_TARGET_NAME ## @var glasses_id # ID of the shutter glasses worn by the user. Used for frequency updates. self.glasses_id = GLASSES_ID ## @var headtracking_reader # Instance of a child class of TrackingReader to supply translation input. if HEADTRACKING_TARGET_NAME == None: self.headtracking_reader = TrackingDefaultReader() self.headtracking_reader.set_no_tracking_matrix(self.no_tracking_mat) else: self.headtracking_reader = TrackingTargetReader() self.headtracking_reader.my_constructor(HEADTRACKING_TARGET_NAME) self.headtracking_reader.set_transmitter_offset(self.transmitter_offset) self.headtracking_reader.set_receiver_offset(avango.gua.make_identity_mat()) # create avatar representation if self.platform.avatar_type == "joseph" or self.platform.avatar_type == "None": self.create_avatar_representation(self.headtracking_reader.sf_avatar_head_mat, self.headtracking_reader.sf_avatar_body_mat) else: if self.platform.avatar_type == "joseph_table": print_warning("Avatar type jospeh_table is deprecated. The creation of table avatars are now handled by the " + \ "device automatically. Use avatar type jospeh instead.") print_error("Error: Unknown avatar type " + self.platform.avatar_type, True) # toggles avatar display and activity self.toggle_user_activity(self.is_active, False) # init intersection class for proxy geometry hit test ## @var pick_length # Length of the picking ray in meters to check for screen intersections. self.pick_length = 5.0 ## @var intersection_tester # Instance of Intersection to determine intersection points of user with screens. self.intersection_tester = Intersection() self.intersection_tester.my_constructor(self.APPLICATION_MANAGER.SCENEGRAPH , self.headtracking_reader.sf_global_mat , self.pick_length , "screen_proxy_group") self.mf_screen_pick_result.connect_from(self.intersection_tester.mf_pick_result) ## @var looking_outside_start # If the user is not facing a screen, the start time of this behaviour is saved to open glasses after a certain amount of time. self.looking_outside_start = None ## @var open_threshold # Time in seconds after which shutter glasses should open when no screen is hit by the viewing ray. self.open_threshold = 2.0 ## @var timer # Time sensor to handle time events. self.timer = avango.nodes.TimeSensor() # set evaluation policy self.always_evaluate(True) ## Evaluated every frame. def evaluate(self): if INTELLIGENT_SHUTTER_SWITCHING: if len(self.mf_screen_pick_result.value) > 0: _hit = self.mf_screen_pick_result.value[0].Object.value.Name.value _hit = _hit.replace("proxy_", "") _hit = _hit.split("_") _hit_platform = int(_hit[0]) _intended_platform = self.APPLICATION_MANAGER.navigation_list[_hit_platform].platform _hit_screen = int(_hit[1]) _intended_display = _intended_platform.displays[_hit_screen] if _intended_display != self.current_display: self.set_user_location(_hit_platform, _hit_screen, True) else: pass ''' if len(self.mf_screen_pick_result.value) > 0: _hit = self.mf_screen_pick_result.value[0] _hit_name = _hit.Object.value.Name.value.replace("proxy_", "") _hit_name = _hit_name.split("_") _hit_platform = int(_hit_name[0]) _hit_screen = int(_hit_name[1]) _intended_platform = self.APPLICATION_MANAGER.navigation_list[_hit_platform].platform _max_viewing_distance = _intended_platform.displays[_hit_screen].max_viewing_distance _distance_to_center = Tools.euclidean_distance(_hit.Object.value.Transform.value.get_translate() , self.headtracking_reader.sf_global_mat.value.get_translate()) _hit_distance = _hit.Distance.value * self.pick_length if _hit_platform != self.platform_id and \ _hit_distance < _max_viewing_distance and \ _distance_to_center < 1.0: if self.is_active == False: self.toggle_user_activity(True, True) # new intersection with other platform found in range self.set_user_location(_hit_platform, True) self.looking_outside_start = None elif _hit_distance > _max_viewing_distance: # intersection found but too far away if self.looking_outside_start == None: self.looking_outside_start = self.timer.Time.value if self.timer.Time.value - self.looking_outside_start > self.open_threshold: if self.is_active == True: self.toggle_user_activity(False, True) else: # no intersection found if self.looking_outside_start == None: self.looking_outside_start = self.timer.Time.value if self.timer.Time.value - self.looking_outside_start > self.open_threshold: if self.is_active == True: #print_message("Opening user") self.toggle_user_activity(False, True) ''' ## Sets the user's active flag. # @param ACTIVE Boolean to which the active flag should be set. # @param RESEND_CONFIG Boolean indicating if the shutter configuration should be directly resent. def toggle_user_activity(self, ACTIVE, RESEND_CONFIG): if ACTIVE: self.is_active = True self.head_avatar.GroupNames.value = ['avatar_group_' + str(self.platform_id)] self.body_avatar.GroupNames.value = ['avatar_group_' + str(self.platform_id)] else: self.is_active = False self.head_avatar.GroupNames.value.append("do_not_display_group") self.body_avatar.GroupNames.value.append("do_not_display_group") self.platform_id = -1 if RESEND_CONFIG: self.APPLICATION_MANAGER.slot_manager.update_slot_configuration() ## Changes the user's current platform. # @param PLATFORM_ID The new platform id to be set. # @param SCREEN_ID The new screen id to be set. # @param RESEND_CONFIG Boolean indicating if the shutter configuration should be directly resent. def set_user_location(self, PLATFORM_ID, SCREEN_ID, RESEND_CONFIG): _intended_platform = self.APPLICATION_MANAGER.navigation_list[PLATFORM_ID].platform _intended_display = _intended_platform.displays[SCREEN_ID] if self.APPLICATION_MANAGER.slot_manager.display_has_free_slot(_intended_display): self.remove_from_platform(self.head_avatar) self.remove_from_platform(self.body_avatar) self.platform_id = PLATFORM_ID self.platform = _intended_platform self.current_display = _intended_display self.transmitter_offset = self.platform.transmitter_offset self.no_tracking_mat = self.platform.no_tracking_mat self.headtracking_reader.set_transmitter_offset(self.transmitter_offset) self.avatar_material = self.APPLICATION_MANAGER.navigation_list[self.platform_id].trace_material self.head_avatar.GroupNames.value = ['avatar_group_' + str(self.platform_id)] self.head_avatar.Material.value = 'data/materials/' + self.avatar_material + '.gmd' self.body_avatar.GroupNames.value = ['avatar_group_' + str(self.platform_id)] self.body_avatar.Material.value = 'data/materials/' + self.avatar_material + '.gmd' if self.platform.avatar_type != "None": self.append_to_platform(self.head_avatar) self.append_to_platform(self.body_avatar) if RESEND_CONFIG: self.APPLICATION_MANAGER.slot_manager.update_slot_configuration() else: print_warning("Blocked") ## Appends a node to the children of a platform in the scenegraph. # @param NODE The node to be appended to the platform node. def append_to_platform(self, NODE): self.platform.platform_scale_transform_node.Children.value.append(NODE) ## Removes a node from the children of a platform in the scenegraph. # @param NODE The node to be removed from the platform node. def remove_from_platform(self, NODE): self.platform.platform_scale_transform_node.Children.value.remove(NODE) ## Creates a basic "joseph" avatar for this user. # @param SF_AVATAR_HEAD_MATRIX Field containing the transformation matrix for the avatar's head on the platform. # @param SF_AVATAR_BODY_MATRIX Field containing the transformation matrix for the avatar's body on the platform. def create_avatar_representation(self, SF_AVATAR_HEAD_MATRIX, SF_AVATAR_BODY_MATRIX): _loader = avango.gua.nodes.GeometryLoader() # create avatar head ## @var head_avatar # Scenegraph node representing the geometry and transformation of the basic avatar's head. self.head_avatar = _loader.create_geometry_from_file( 'head_avatar_' + str(self.id), 'data/objects/Joseph/JosephHead.obj', 'data/materials/' + self.avatar_material + '.gmd', avango.gua.LoaderFlags.LOAD_MATERIALS) self.head_avatar.Transform.value = avango.gua.make_rot_mat(-90, 0, 1, 0) * avango.gua.make_scale_mat(0.4, 0.4, 0.4) self.head_avatar.GroupNames.value = ['avatar_group_' + str(self.platform_id)] # create avatar body ## @var body_avatar # Scenegraph node representing the geometry and transformation of the basic avatar's body. self.body_avatar = _loader.create_geometry_from_file( 'body_avatar_' + str(self.id), 'data/objects/Joseph/JosephBody.obj', 'data/materials/' + self.avatar_material + '.gmd', avango.gua.LoaderFlags.LOAD_MATERIALS) self.body_avatar.GroupNames.value = ['avatar_group_' + str(self.platform_id)] self.append_to_platform(self.head_avatar) self.append_to_platform(self.body_avatar) self.head_avatar.Transform.connect_from(SF_AVATAR_HEAD_MATRIX) self.body_avatar.Transform.connect_from(SF_AVATAR_BODY_MATRIX)
Detection("dog.364.jpg", [66, 22, 428, 486]), Detection("dog.380.jpg", [46, 5, 357, 484]), Detection("dog.394.jpg", [111, 24, 428, 407]) ] for detection in examples: image = io.imread('image/' + detection.image_path) im, regions = selectivesearch.selective_search(image, scale=1, sigma=1) for r in regions: if r['rect'] in candidates: continue if r['size'] < 1000: continue candidates.add(r['rect']) for x, y, w, h in candidates: iou = union.get_union(detection.coordinate, [x, y, x + w, y + h]) if counter < 160: if iou > .7: PosImage = image[y:y + h, x:x + w] resized = cv2.resize(PosImage, (128, 128), interpolation=cv2.INTER_AREA) cv2.imwrite("IMAGE/positive%i.jpg" % p, resized) train_data.append(resized) train_label.append(1) counter += 1 p += 1 #for image saving else: fflag = 1 if falsecounter < 160: if iou < .3: NegImage = image[y:y + h, x:x + w]
return False if Intersection.closed_segment_intersect(self.collider_a, self.collider_b, start_point, end_point): self.collider_hits += 1 if __name__ == "__main__": from time import sleep updateintervall = 0.1 duration = 1 speed = 1 # 14 km/h # speed = 3.888888888888889 # 14 km/h dropcounter = 3 print() dropmaker = DropMakerNP(dropcounter, speed, xbound=1, ybound=1) c = (4000, 5000) d = (4000, 5000) Intersection.closed_segment_intersect(dropmaker.collider_a, dropmaker.collider_b, c, d) for time in range(duration): print(f'time:{time:3d}') # 1sec for _ in range(int(1 / updateintervall)): dropmaker.fall() dropmaker.showpos() sleep(updateintervall)