class ConeTree(avango.script.Script): COLORMODE = "NODETYPE" FocusCTNode = avango.gua.SFNode() FocusSceneNode = avango.gua.SFNode() def __init__(self): self.super(ConeTree).__init__() # Constructor, start_node is the input node from wich one the ConeTree Representation starts def myConstructor(self, start_node): self.Start_node = start_node self.RootNode_ = avango.gua.nodes.TransformNode( Name = "ConeTreeRoot", ) self.ScaleNode_ = avango.gua.nodes.TransformNode( Name = "ConeTreeScale", ) self.TransformNode_ = avango.gua.nodes.TransformNode( Name = "ConeTreeTransform", ) self.RootCone_ = Cone(self.Start_node, None) self.FocusCone_ = self.RootCone_ avango.gua.load_materials_from("data/materials") self.FocusEdge_ = -1 self.layout() def update_focus_nodes(self): if self.FocusEdge_ == -1: self.FocusCTNode.value = self.FocusCone_.outNode_.geometry_ self.FocusSceneNode.value = self.FocusCone_.Input_node_ else: self.FocusCTNode.value = self.FocusCone_.ChildrenCones_[self.FocusEdge_].outNode_.geometry_ self.FocusSceneNode.value = self.FocusCone_.ChildrenCones_[self.FocusEdge_].Input_node_ def get_scene_node(self, CT_node): cones = [] cones.append(self.RootCone_) # search for the node while (not len(cones) == 0): current = cones.pop() # when found set collapsed if current.outNode_.geometry_ == CT_node: return current.Input_node_ for child in current.ChildrenCones_: cones.append(child) def get_CT_node(self, scene_node): cones = [] cones.append(self.RootCone_) # search for the node while (not len(cones) == 0): current = cones.pop() # when found set collapsed if current.Input_node_ == scene_node: return current.outNode_.geometry_ for child in current.ChildrenCones_: cones.append(child) def create_scenegraph_structure(self): node = self.RootCone_.get_scenegraph() self.RootNode_.Children.value = [self.ScaleNode_] self.ScaleNode_.Children.value = [self.TransformNode_] self.TransformNode_.Children.value = [node] return self.RootNode_ def get_root(self): return self.RootNode_ def print_ConeTree(self): self.RootCone_.print_cone(0) def layout(self): self.RootCone_.layout() self.RootCone_.apply_layout(root = True) self.FocusCone_.highlight(True) def set_colormode(self, colormode = "NODETYPE", flip = False): if flip: if ConeTree.COLORMODE == "NODETYPE": ConeTree.COLORMODE = "DEPTH" else: ConeTree.COLORMODE = "NODETYPE" else: ConeTree.COLORMODE = colormode def reapply_materials(self): self.RootCone_.reapply_material() self.FocusCone_.highlight(True) def scale(self): if self.FocusCone_.is_leaf(): used_Cone = self.FocusCone_.Parent_ else: used_Cone = self.FocusCone_ bb = used_Cone.outNode_.geometry_.BoundingBox.value bb_sides = (bb.Max.value.x - bb.Min.value.x ,bb.Max.value.y - bb.Min.value.y ,bb.Max.value.z - bb.Min.value.z) # scale = 0.5 / max(bb_sides) scale = 1.0 / max(bb_sides) # scale = 1.5 / max(bb_sides) self.ScaleNode_.Transform.value *= avango.gua.make_scale_mat(scale) def reposition(self): if self.FocusCone_.is_leaf(): used_Cone = self.FocusCone_.Parent_ else: used_Cone = self.FocusCone_ if not used_Cone.Parent_ == None: current = used_Cone parent = current.Parent_ matrix = current.outNode_.geometry_.Transform.value while not parent == self.RootCone_: current = parent parent = current.Parent_ matrix *= current.outNode_.geometry_.Transform.value self.TransformNode_.Transform.value = avango.gua.make_inverse_mat(matrix) else: self.TransformNode_.Transform.value = avango.gua.make_identity_mat() def set_camera_on_Focus(self): return # if not self.FocusCone_.is_leaf(): # bb = self.FocusCone_.outNode_.geometry_.BoundingBox.value # nodePosition = self.FocusCone_.outNode_.geometry_.WorldTransform.value.get_translate() # diff_x_left = nodePosition.x - bb.Min.value.x # diff_x_right = bb.Max.value.x - nodePosition.x # diff_y_left = nodePosition.y - bb.Min.value.y # diff_y_right = bb.Max.value.y - nodePosition.y # size_x = max(diff_x_left,diff_x_right) * 2 # size_y = bb.Max.value.y - bb.Min.value.y # size_z = bb.Max.value.z - bb.Min.value.z # eye_from_screen = self.EyeTransform.value.get_translate().length() # distance_x = ((eye_from_screen*size_x)/self.Screen.Width.value) - eye_from_screen # distance_y = ((eye_from_screen*size_y)/self.Screen.Height.value) - eye_from_screen # distance = max(distance_x,distance_y) + 0.5 * size_z # depth = - size_y / 2 # self.OutMatrix.value = avango.gua.make_trans_mat( nodePosition + avango.gua.Vec3(0,depth,distance) ) # rotate def rotate_by_id(self, id, angle): cones = [] cones.append(self.RootCone_) # search for the id while (not len(cones) == 0): current = cones.pop() # when found set highlighted if current.id_ == id : current.rotate(angle) print "Rotate: " + str(current.id_) + " : " + str(angle) self.layout() return True for child in current.ChildrenCones_: cones.append(child) return False # highlighting def highlight(self, selector, highlight = True, path = False): cones = [] cones.append(self.RootCone_) # search for the selector while (not len(cones) == 0): current = cones.pop() # when found set highlighted if current.id_ == selector or current.Input_node_ == selector or current.outNode_.geometry_ == selector: if path: current.highlight_path(highlight) print "Highlight path: " + str(current.id_) + " : " + str(highlight) else: current.highlight(highlight) print "Highlight: " + str(current.id_) + " : " + str(highlight) for child in current.ChildrenCones_: cones.append(child) def highlight_by_level(self, level, highlight): cones = [] cones.append(self.RootCone_) # search for the id while (not len(cones) == 0): current = cones.pop() # when found set highlighted if current.Level_ == level : current.highlight(highlight) print "Highlight: " + str(current.id_) + " : " + str(highlight) #self.layout() for child in current.ChildrenCones_: cones.append(child) # collapsing def flip_collapse_at_focus(self): if self.FocusCone_.collapsed_: self.FocusCone_.collapse(False) else: self.FocusCone_.collapse(True) self.layout() def collapse_by_level(self, level, collapse): cones = [] cones.append(self.RootCone_) # search for the level while (not len(cones) == 0): current = cones.pop() # when found set highlighted if current.Level_ == level : current.collapse(collapse) self.layout() for child in current.ChildrenCones_: cones.append(child) def collapse(self, selector, collapse = True): cones = [] cones.append(self.RootCone_) # search for the selector while (not len(cones) == 0): current = cones.pop() # when found set highlighted if current.id_ == selector or current.Input_node_ == selector or current.outNode_.geometry_ == selector: current.collapse(collapse) print "Collapsed: " + str(current.id_) + " : " + str(collapse) for child in current.ChildrenCones_: cones.append(child) # deal with focus def focus(self, selector): cones = [] cones.append(self.RootCone_) # search for the selector in whole COneTree while (not len(cones) == 0): current = cones.pop() # when found set highlighted if current.id_ == selector or current.Input_node_ == selector or current.outNode_.geometry_ == selector: # set new focus self.FocusCone_.highlight_path(0) self.FocusCone_ = current self.FocusCone_.highlight_path(1) self.FocusEdge_ = -1 self.update_focus_nodes() return True for child in current.ChildrenCones_: cones.append(child) return False def rotate_by_ray(self, ray, ray_scale): ray_start = ray.WorldTransform.value.get_translate() matrix = ray.WorldTransform.value * avango.gua.make_scale_mat(1.0/ray_scale.x , 1.0/ray_scale.y , 1.0/ray_scale.z) ray_direction = avango.gua.make_rot_mat(matrix.get_rotate()) * avango.gua.Vec3(0,0,-1) ray_direction = avango.gua.Vec3(ray_direction.x, ray_direction.y, ray_direction.z) ray_direction.normalize() if abs(ray_direction.x) > 0.5: if ray_direction.x > 0: self.FocusCone_.rotate((ray_direction.x - 0.5) / 10) else: self.FocusCone_.rotate((ray_direction.x + 0.5) / 10) # self.RootCone_.apply_layout(root = True) self.layout() def highlight_closest_edge(self, ray, ray_scale): ray_start = ray.WorldTransform.value.get_translate() matrix = ray.WorldTransform.value * avango.gua.make_scale_mat(1.0/ray_scale.x , 1.0/ray_scale.y , 1.0/ray_scale.z) ray_direction = avango.gua.make_rot_mat(matrix.get_rotate()) * avango.gua.Vec3(0,0,-1) ray_direction = avango.gua.Vec3(ray_direction.x, ray_direction.y, ray_direction.z) ray_direction_length = ray_direction.length() # calculate distance to Focus Node point = self.FocusCone_.outNode_.geometry_.WorldTransform.value.get_translate() tmp = ray_direction.cross((point - ray_start)) closest_distance = tmp.length() / ray_direction_length result = -1 # and calculate distance to all Children for i in range(len(self.FocusCone_.ChildrenCones_)): point = self.FocusCone_.ChildrenCones_[i].outNode_.geometry_.WorldTransform.value.get_translate() tmp = ray_direction.cross((point - ray_start)) tmp_distance = tmp.length() / ray_direction_length # closer ? if tmp_distance < closest_distance: closest_distance = tmp_distance result = i # the closest one ist highlighted if not result == -1: self.FocusCone_.weak_highlight_edge(self.FocusEdge_,0) self.FocusEdge_ = result self.FocusCone_.weak_highlight_edge(self.FocusEdge_,1) self.update_focus_nodes() def focus_in_focuscone(self, selector): # look for the selector in the edges of the Focus Cone for i in range(len(self.FocusCone_.Edges_)): if self.FocusCone_.Edges_[i].geometry_ == selector: self.FocusCone_.highlight_edge(self.FocusEdge_,0) self.FocusEdge_ = i self.FocusCone_.highlight_edge(self.FocusEdge_,1) return True cones = [] if self.FocusCone_.Parent_ == None: cones.append(self.FocusCone_) else: cones.append(self.FocusCone_.Parent_) for child in self.FocusCone_.ChildrenCones_: cones.append(child) # search for the selector in whole FocusCone while (not len(cones) == 0): current = cones.pop() # when found set highlighted if current.id_ == selector or current.Input_node_ == selector or current.outNode_.geometry_ == selector: # set new focus # self.FocusCone_.highlight_edge(self.FocusEdge_,0) self.FocusCone_.highlight_path(0) self.FocusCone_ = current self.FocusCone_.highlight_path(1) self.FocusEdge_ = -1 self.update_focus_nodes() return True return False def focus_next_edge(self): if not self.FocusCone_.is_leaf(): if not self.FocusEdge_ == -1: self.FocusCone_.highlight_edge(self.FocusEdge_,0) self.FocusEdge_ += 1 if self.FocusEdge_ == len(self.FocusCone_.Edges_): self.FocusEdge_ = 0 self.FocusCone_.highlight_edge(self.FocusEdge_,1) self.update_focus_nodes() # self.update_label() def focus_prev_edge(self): if not self.FocusCone_.is_leaf(): if self.FocusEdge_ == -1: self.FocusEdge_ = len(self.FocusCone_.Edges_) - 1 else: self.FocusCone_.highlight_edge(self.FocusEdge_,0) self.FocusEdge_ -= 1 if self.FocusEdge_ == -1: self.FocusEdge_ = len(self.FocusCone_.Edges_) - 1 self.FocusCone_.highlight_edge(self.FocusEdge_,1) self.update_focus_nodes() # self.update_label() def go_deep_at_focus(self): if not (self.FocusCone_.is_leaf() or self.FocusEdge_ == -1): # reset focusi self.FocusCone_.highlight_path(0) self.FocusCone_.highlight_edge(self.FocusEdge_,0) # set new focus self.FocusCone_ = self.FocusCone_.ChildrenCones_[self.FocusEdge_] self.FocusCone_.highlight_path(1) self.FocusEdge_ = -1 self.update_focus_nodes() # self.update_label() def level_up(self): if not self.FocusCone_.Parent_ == None: self.FocusCone_.highlight_path(0) if not self.FocusEdge_ == -1: self.FocusCone_.highlight_edge(self.FocusEdge_,0) self.FocusEdge_ = -1 self.FocusCone_ = self.FocusCone_.Parent_ self.FocusCone_.highlight_path(1) self.update_focus_nodes()