def get_runs_by_parameters(self, parameters):
        conn = sqlite3.connect(self.database_filename)
        cur = conn.cursor()
        first = True
        sql = ''
        for parameter in parameters:
            if first:
                first = False
            else:
                sql += ''' INTERSECT '''
            sql += '''SELECT run_id FROM parameters
                     WHERE parameter_name=\'{}\' AND parameter_value LIKE \'{}\''''.format(
                parameter, parameters[parameter])

        cur.execute(sql)
        run_ids = cur.fetchone()
        if run_ids == None:
            """ raise Exception('No run found with these parameters') """

            # For testing
            self.intersection = Intersection(parameters=parameters,
                                             parameters_as_dict=True)
            self.run()
            cur.execute('''SELECT MAX(id) FROM runs''')
            run_id = cur.fetchone()[0]
            return self.read_database(run_id)
        # else:
        # print('Found run ids: {}'.format(run_ids))

        return self.read_database(run_ids[0])
Esempio n. 2
0
    def __init__(
            self,
            TOOL=None,
            RAY_LENGTH=1.0  # in meter
    ):

        ## init base class
        ResourceSelector.__init__(self, TOOL=TOOL)

        ### further resources ###

        ## init intersection
        self.default_intersection = Intersection(
            PICK_LENGTH=RAY_LENGTH
            #, BLACK_LIST = ["invisible", "unpickable", "man_unpickable"]
            ,
            BLACK_LIST=["invisible"])
Esempio n. 3
0
    def __init__( self
                , TOOL = None
                , RAY_LENGTH = 1.0 # in meter
                ):


        ## init base class
        ResourceSelector.__init__( self
                                 , TOOL = TOOL
                                 )
    

        ### further resources ###
    
        ## init intersection
        self.default_intersection = Intersection( PICK_LENGTH = RAY_LENGTH
                                                #, BLACK_LIST = ["invisible", "unpickable", "man_unpickable"]
                                                , BLACK_LIST = ["invisible"]                                                
                                                )
Esempio n. 4
0
class LightToolResourceSelector(ResourceSelector):

    ### constructor
    def __init__(
            self,
            TOOL=None,
            RAY_LENGTH=1.0  # in meter
    ):

        ## init base class
        ResourceSelector.__init__(self, TOOL=TOOL)

        ### further resources ###

        ## init intersection
        self.default_intersection = Intersection(
            PICK_LENGTH=RAY_LENGTH
            #, BLACK_LIST = ["invisible", "unpickable", "man_unpickable"]
            ,
            BLACK_LIST=["invisible"])

    ### further functions ###

    ## implement base-class function
    def update_candidate_resources(self):
        self.candidate_resource_list = []  # clear

        if self.TOOL.assigned_user is not None:  # guard
            _candidate_resource_list = []
            _candidate_resource_tupel_list = []

            ## check if ray representations intersect viewing frusta of their context
            for _resource in self.TOOL.get_resource_list():
                _world_mat = lib.Utilities.get_world_transform(
                    _resource.get_node())
                _pos = _world_mat.get_translate()
                #print(_resource, _resource.VIEW_CONTEXT, _pos)

                _frusta_list = _resource.VIEW_CONTEXT.get_valid_frusta_of_user(
                    self.TOOL.assigned_user)

                for _frustum in _frusta_list:
                    if _frustum.contains(
                            _pos
                    ) == True:  # tool resource is inside this frustum --> resource is candidate for interaction
                        _candidate_resource_list.append(_resource)

                        break  # break smallest enclosing loop

                    else:
                        self.default_intersection.set_pick_mat(_world_mat)
                        _ray = self.default_intersection.get_ray()

                        _mf_pick_result = _frustum.ray_test(_ray)

                        if len(
                                _mf_pick_result.value
                        ) > 0:  # tool resource intersects this frustum --> resource is candidate for interaction
                            _candidate_resource_list.append(_resource)

                            break  # break smallest enclosing loop

            #print("1", _candidate_resource_list)

            ## check if candidate ray representations intersect scene geometry
            for _resource in _candidate_resource_list:
                _pick_result = self.calc_intersection(_resource.get_node())

                if _pick_result is not None:
                    _pick_world_pos = _pick_result[3]

                    _frusta_list = _resource.VIEW_CONTEXT.get_valid_frusta_of_user(
                        self.TOOL.assigned_user)

                    for _frustum in _frusta_list:
                        if _frustum.contains(
                                _pick_world_pos
                        ) == True:  # pick position of this resource is inside frusta of the respective view-context --> pick position visible for assigned user
                            _candidate_resource_tupel_list.append(
                                (_resource, _pick_result))

                            break  # break smallest enclosing loop

            #print("2", _candidate_resource_tupel_list)

            ## select one ray representation as interaction candidate
            if len(_candidate_resource_tupel_list) == 1:
                _tupel = _candidate_resource_tupel_list[0]
                self.candidate_resource_list.append(
                    _tupel[0])  # get first (and only) active resource

            elif len(_candidate_resource_tupel_list) > 1:
                # if multiple intersecting resources exist, take the one with shortest pick distance
                _nearest_distance = sys.maxsize  # start with max distance

                for _tupel in _candidate_resource_tupel_list:
                    _resource = _tupel[0]
                    _pick_result = _tupel[1]
                    _pick_distance = _pick_result[5]

                    if len(self.candidate_resource_list) == 0:
                        self.candidate_resource_list.append(_resource)
                        _nearest_distance = _pick_distance

                    elif len(self.candidate_resource_list) > 0:
                        if _pick_distance < _nearest_distance:
                            self.candidate_resource_list[0] = _resource
                            _nearest_distance = _pick_distance

            # print("3", self.candidate_resource_list)

    def calc_intersection(self, NODE):
        _world_mat = lib.Utilities.get_world_transform(NODE)

        self.default_intersection.set_pick_mat(_world_mat)
        self.default_intersection.compute_intersection()

        return self.default_intersection.get_first_pick_result()
Esempio n. 5
0
    def __init__(
            self,
            INITIATOR=None,
            INPUT=None,
            RAY_LENGHT=10.0,
            TOOL_THICKNESS=0.01  # in meter
        ,
            LIGHT_COLOR=avango.gua.Color(1.0, 1.0, 1.0),
            LIGHT_BRIGHTNESS=10.0,
            LIGHT_DIMENSIONS=avango.gua.Vec3(1.0, 1.0, 1.0),
            SHADOW_FLAG=False,
            SHADOW_MAP_SIZE=512,
            VIEW_CONTEXT_LIST=[],
            VISIBILITY_DICTIONARY={}):

        ## init base class
        Tool.__init__(self,
                      INITIATOR=INITIATOR,
                      INPUT=INPUT,
                      VIEW_CONTEXT_LIST=VIEW_CONTEXT_LIST,
                      VISIBILITY_DICTIONARY=VISIBILITY_DICTIONARY,
                      RESOURCE_SELECTOR=LightToolResourceSelector(
                          TOOL=self, RAY_LENGTH=RAY_LENGHT))

        ### parameters ###
        self.tool_thickness = 0.01

        self.light_geometry_thickness = 0.02
        self.light_color = avango.gua.Color(1.0, 1.0, 1.0)
        self.light_brightness = 10.0
        self.light_dimensions = avango.gua.Vec3(1.0, 1.0, 1.0)
        self.shadow_flag = False
        self.shadow_map_size = 512

        ### variables ###
        self.active_resource = None
        self.action_flag = False

        ### resources ###

        ## init script
        self.script = LightToolScript()
        self.script.my_constructor(self)

        ## init intersection
        self.default_intersection = Intersection(PICK_LENGTH=RAY_LENGHT,
                                                 BLACK_LIST=["invisible"])

        ## init intersection node
        self.intersection_node = avango.gua.nodes.TransformNode(
            Name="light_intersection_node")
        builtins.APPLICATION.append_node_to_root(self.intersection_node)

        self.intersection_geometry = builtins.TRIMESH_LOADER.create_geometry_from_file(
            "intersection_geometry", "data/objects/sphere.obj",
            avango.gua.LoaderFlags.DEFAULTS)
        self.intersection_geometry.Material.value.set_uniform(
            "Emissivity", 0.5)
        self.intersection_geometry.ShadowMode.value = 0  # disable for shadowing
        self.intersection_geometry.Transform.value = avango.gua.make_scale_mat(
            0.03)
        self.intersection_node.Children.value.append(
            self.intersection_geometry)

        self.offset_node = avango.gua.nodes.TransformNode(Name="offset_node")
        self.offset_node.Transform.value = avango.gua.make_trans_mat(
            0.0, 0.0, 0.5)
        self.intersection_node.Children.value.append(self.offset_node)

        ## init flashlight geometries
        self.cube_geometry = builtins.TRIMESH_LOADER.create_geometry_from_file(
            "flashlight_resource_cube_geometry", "data/objects/cube.obj",
            avango.gua.LoaderFlags.DEFAULTS)
        self.cube_geometry.Material.value.set_uniform("Emissivity", 0.5)
        self.cube_geometry.ShadowMode.value = 0  # disable for shadowing
        self.cube_geometry.Transform.value = avango.gua.make_scale_mat(
            self.light_geometry_thickness)
        self.offset_node.Children.value.append(self.cube_geometry)

        self.cone_geometry = builtins.TRIMESH_LOADER.create_geometry_from_file(
            "flashlight_resource_cone_geometry", "data/objects/cone.obj",
            avango.gua.LoaderFlags.DEFAULTS)
        self.cone_geometry.Material.value.set_uniform("Emissivity",
                                                      1.0)  # pass through
        self.cone_geometry.ShadowMode.value = 0  # disable for shadowing
        self.cone_geometry.Transform.value = avango.gua.make_trans_mat(0.0, 0.0, -self.light_geometry_thickness) * \
                                             avango.gua.make_scale_mat(self.light_geometry_thickness * 2.0)
        self.offset_node.Children.value.append(self.cone_geometry)

        ## init light node
        self.light_node = avango.gua.nodes.LightNode(Name="light_node")
        self.light_node.Type.value = avango.gua.LightType.SPOT
        #self.light_node.ShadowNearClippingInSunDirection.value = 0.01
        #self.light_node.ShadowNearClippingInSunDirection.value = 0.1 * (1.0/LIGHT_DIMENSIONS.z)
        self.light_node.ShadowFarClippingInSunDirection.value = 1.1
        self.light_node.Falloff.value = 0.5
        self.offset_node.Children.value.append(self.light_node)

        ## trigger callbacks
        ## @var frame_trigger
        # Triggers framewise evaluation of respective callback method
        self.frame_trigger = avango.script.nodes.Update(
            Callback=self.frame_callback, Active=False)

        # Triggers framewise evaluation of respective callback method
        self.update_trigger = avango.script.nodes.Update(
            Callback=self.update_callback, Active=False)

        ### set initial states ###
        ## set tool properties
        self.set_thickness(TOOL_THICKNESS)

        ## set light properties
        self.set_light_color(LIGHT_COLOR)
        self.set_light_brightness(LIGHT_BRIGHTNESS)
        self.set_light_dimensions(LIGHT_DIMENSIONS)
        self.set_shadow_flag(SHADOW_FLAG)
        self.set_shadow_map_size(SHADOW_MAP_SIZE)

        print("LightTool initialized:", Tool.get_id(self))
Esempio n. 6
0
class LightTool(Tool):

    ### constructor
    def __init__(
            self,
            INITIATOR=None,
            INPUT=None,
            RAY_LENGHT=10.0,
            TOOL_THICKNESS=0.01  # in meter
        ,
            LIGHT_COLOR=avango.gua.Color(1.0, 1.0, 1.0),
            LIGHT_BRIGHTNESS=10.0,
            LIGHT_DIMENSIONS=avango.gua.Vec3(1.0, 1.0, 1.0),
            SHADOW_FLAG=False,
            SHADOW_MAP_SIZE=512,
            VIEW_CONTEXT_LIST=[],
            VISIBILITY_DICTIONARY={}):

        ## init base class
        Tool.__init__(self,
                      INITIATOR=INITIATOR,
                      INPUT=INPUT,
                      VIEW_CONTEXT_LIST=VIEW_CONTEXT_LIST,
                      VISIBILITY_DICTIONARY=VISIBILITY_DICTIONARY,
                      RESOURCE_SELECTOR=LightToolResourceSelector(
                          TOOL=self, RAY_LENGTH=RAY_LENGHT))

        ### parameters ###
        self.tool_thickness = 0.01

        self.light_geometry_thickness = 0.02
        self.light_color = avango.gua.Color(1.0, 1.0, 1.0)
        self.light_brightness = 10.0
        self.light_dimensions = avango.gua.Vec3(1.0, 1.0, 1.0)
        self.shadow_flag = False
        self.shadow_map_size = 512

        ### variables ###
        self.active_resource = None
        self.action_flag = False

        ### resources ###

        ## init script
        self.script = LightToolScript()
        self.script.my_constructor(self)

        ## init intersection
        self.default_intersection = Intersection(PICK_LENGTH=RAY_LENGHT,
                                                 BLACK_LIST=["invisible"])

        ## init intersection node
        self.intersection_node = avango.gua.nodes.TransformNode(
            Name="light_intersection_node")
        builtins.APPLICATION.append_node_to_root(self.intersection_node)

        self.intersection_geometry = builtins.TRIMESH_LOADER.create_geometry_from_file(
            "intersection_geometry", "data/objects/sphere.obj",
            avango.gua.LoaderFlags.DEFAULTS)
        self.intersection_geometry.Material.value.set_uniform(
            "Emissivity", 0.5)
        self.intersection_geometry.ShadowMode.value = 0  # disable for shadowing
        self.intersection_geometry.Transform.value = avango.gua.make_scale_mat(
            0.03)
        self.intersection_node.Children.value.append(
            self.intersection_geometry)

        self.offset_node = avango.gua.nodes.TransformNode(Name="offset_node")
        self.offset_node.Transform.value = avango.gua.make_trans_mat(
            0.0, 0.0, 0.5)
        self.intersection_node.Children.value.append(self.offset_node)

        ## init flashlight geometries
        self.cube_geometry = builtins.TRIMESH_LOADER.create_geometry_from_file(
            "flashlight_resource_cube_geometry", "data/objects/cube.obj",
            avango.gua.LoaderFlags.DEFAULTS)
        self.cube_geometry.Material.value.set_uniform("Emissivity", 0.5)
        self.cube_geometry.ShadowMode.value = 0  # disable for shadowing
        self.cube_geometry.Transform.value = avango.gua.make_scale_mat(
            self.light_geometry_thickness)
        self.offset_node.Children.value.append(self.cube_geometry)

        self.cone_geometry = builtins.TRIMESH_LOADER.create_geometry_from_file(
            "flashlight_resource_cone_geometry", "data/objects/cone.obj",
            avango.gua.LoaderFlags.DEFAULTS)
        self.cone_geometry.Material.value.set_uniform("Emissivity",
                                                      1.0)  # pass through
        self.cone_geometry.ShadowMode.value = 0  # disable for shadowing
        self.cone_geometry.Transform.value = avango.gua.make_trans_mat(0.0, 0.0, -self.light_geometry_thickness) * \
                                             avango.gua.make_scale_mat(self.light_geometry_thickness * 2.0)
        self.offset_node.Children.value.append(self.cone_geometry)

        ## init light node
        self.light_node = avango.gua.nodes.LightNode(Name="light_node")
        self.light_node.Type.value = avango.gua.LightType.SPOT
        #self.light_node.ShadowNearClippingInSunDirection.value = 0.01
        #self.light_node.ShadowNearClippingInSunDirection.value = 0.1 * (1.0/LIGHT_DIMENSIONS.z)
        self.light_node.ShadowFarClippingInSunDirection.value = 1.1
        self.light_node.Falloff.value = 0.5
        self.offset_node.Children.value.append(self.light_node)

        ## trigger callbacks
        ## @var frame_trigger
        # Triggers framewise evaluation of respective callback method
        self.frame_trigger = avango.script.nodes.Update(
            Callback=self.frame_callback, Active=False)

        # Triggers framewise evaluation of respective callback method
        self.update_trigger = avango.script.nodes.Update(
            Callback=self.update_callback, Active=False)

        ### set initial states ###
        ## set tool properties
        self.set_thickness(TOOL_THICKNESS)

        ## set light properties
        self.set_light_color(LIGHT_COLOR)
        self.set_light_brightness(LIGHT_BRIGHTNESS)
        self.set_light_dimensions(LIGHT_DIMENSIONS)
        self.set_shadow_flag(SHADOW_FLAG)
        self.set_shadow_map_size(SHADOW_MAP_SIZE)

        print("LightTool initialized:", Tool.get_id(self))

    ### functions ###

    ## extend respective base-class function
    def init(self):
        Tool.init(self)  # call base-class function

        self.enable(True)

        self.connect_input()

    ## implement respective base-class function
    def init_resource(self, PARENT_NODE, VIEW_CONTEXT):
        _resource = LightToolResource(TOOL=self,
                                      PARENT_NODE=PARENT_NODE,
                                      VIEW_CONTEXT=VIEW_CONTEXT,
                                      TOOL_THICKNESS=self.tool_thickness)

    ## extend respective base-class function
    def enable(self, BOOL):
        Tool.enable(self, BOOL)  # call base-class function

        self.frame_trigger.Active.value = self.enable_flag  # enable/disable frame callback

    ## INPUT CONNECTIONS
    def connect_input(self):
        if self.INPUT is not None:  # guard
            if self.INPUT.get_matrix_field() is not None:
                self.connect_matrix(self.INPUT.get_matrix_field())

            if self.INPUT.get_button0_field() is not None:
                self.script.sf_button0.disconnect()
                self.script.sf_button0.connect_from(
                    self.INPUT.get_button0_field())

    def connect_matrix(self, SF_MAT4):
        for _resource in Tool.get_resource_list(self):
            _resource.connect_matrix(SF_MAT4)

    def set_thickness(self, FLOAT):
        self.tool_thickness = FLOAT

        for _resource in Tool.get_resource_list(self):
            _resource.set_thickness(self.tool_thickness)

    def set_light_color(self, COLOR):
        self.light_color = COLOR

        self.light_node.Color.value = COLOR
        self.cone_geometry.Material.value.set_uniform(
            "Color", avango.gua.Vec4(COLOR.r, COLOR.g, COLOR.b, 1.0))

    def set_light_brightness(self, FLOAT):
        self.light_brightness = FLOAT

        self.light_node.Brightness.value = FLOAT

    def set_light_dimensions(self, VEC3):
        self.light_dimensions = VEC3

        self.light_node.Transform.value = avango.gua.make_scale_mat(VEC3)

        self.light_node.ShadowNearClippingInSunDirection.value = 0.1 * (
            1.0 / VEC3.z
        )  # shadow near cliiping at 10cm (independant of light dimensions)
        self.light_node.ShadowMaxDistance.value = VEC3.z + 5.0

    def set_shadow_flag(self, FLAG):
        self.shadow_flag = FLAG

        self.light_node.EnableShadows.value = FLAG

    def set_shadow_map_size(self, UINT):
        self.shadow_map_size = UINT

        self.light_node.ShadowMapSize.value = UINT

    def select_active_resource(self):
        _list = self.RESOURCE_SELECTOR.get_candidate_resources()

        if len(_list) == 0:
            self.active_resource = None
        elif len(_list) > 0:
            self.active_resource = _list[0]

    def process_button0(self, BOOL):
        if BOOL == True:
            if self.active_resource is not None:
                _world_mat = lib.Utilities.get_world_transform(
                    self.active_resource.get_node())

                self.default_intersection.set_pick_mat(_world_mat)
                self.default_intersection.compute_intersection()

                _pick_result = self.default_intersection.get_first_pick_result(
                )

                if _pick_result is not None:
                    self.action_flag = True

                    self.update_trigger.Active.value = True

                    _pick_world_pos = _pick_result[3]

                    _platform_node = self.active_resource.get_node(
                    ).Parent.value
                    _mat = _platform_node.Transform.value

                    self.intersection_node.Transform.value = avango.gua.make_trans_mat(_pick_world_pos) * \
                                                             avango.gua.make_rot_mat(_mat.get_rotate_scale_corrected())

                    self.intersection_node.Tags.value = []  # set visible

        else:
            if self.action_flag == True:
                self.action_flag = False

                self.update_trigger.Active.value = False

                self.intersection_node.Tags.value = ["invisible"
                                                     ]  # set invisible

    ### callback functions ###
    def frame_callback(self):
        #print("frame")

        if self.action_flag == False:
            Tool.update_assigned_user(self)

            self.RESOURCE_SELECTOR.update_candidate_resources()

            self.select_active_resource()

    def update_callback(self):
        _vec = self.INPUT.get_inputs()

        _platform_node = self.active_resource.get_node().Parent.value
        _mat = _platform_node.Transform.value

        _vec = avango.gua.make_rot_mat(
            _mat.get_rotate_scale_corrected()) * avango.gua.Vec3(
                _vec.x, _vec.y, 0.0)  # express in platform orientation

        self.intersection_node.Transform.value = avango.gua.make_trans_mat(self.intersection_node.Transform.value.get_translate()) * \
                                                 avango.gua.make_rot_mat(_vec.x * builtins.APPLICATION.get_application_fps_scale_factor() * 0.5,0,1,0) * \
                                                 avango.gua.make_rot_mat(_vec.y * builtins.APPLICATION.get_application_fps_scale_factor() * 0.5,1,0,0) * \
                                                 avango.gua.make_rot_mat(_vec.z * builtins.APPLICATION.get_application_fps_scale_factor() * 0.5,0,0,1) * \
                                                 avango.gua.make_rot_mat(self.intersection_node.Transform.value.get_rotate_scale_corrected())
Esempio n. 7
0
class LightToolResourceSelector(ResourceSelector):

    ### constructor
    def __init__( self
                , TOOL = None
                , RAY_LENGTH = 1.0 # in meter
                ):


        ## init base class
        ResourceSelector.__init__( self
                                 , TOOL = TOOL
                                 )
    

        ### further resources ###
    
        ## init intersection
        self.default_intersection = Intersection( PICK_LENGTH = RAY_LENGTH
                                                #, BLACK_LIST = ["invisible", "unpickable", "man_unpickable"]
                                                , BLACK_LIST = ["invisible"]                                                
                                                )


    ### further functions ###

    ## implement base-class function
    def update_candidate_resources(self):
        self.candidate_resource_list = [] # clear
            
        if self.TOOL.assigned_user is not None: # guard
            _candidate_resource_list = []
            _candidate_resource_tupel_list = []
                        
            ## check if ray representations intersect viewing frusta of their context
            for _resource in self.TOOL.get_resource_list():
                _world_mat = lib.Utilities.get_world_transform(_resource.get_node())
                _pos = _world_mat.get_translate()
                #print(_resource, _resource.VIEW_CONTEXT, _pos)
               
                _frusta_list = _resource.VIEW_CONTEXT.get_valid_frusta_of_user(self.TOOL.assigned_user)

                for _frustum in _frusta_list:           
                    if _frustum.contains(_pos) == True: # tool resource is inside this frustum --> resource is candidate for interaction
                        _candidate_resource_list.append(_resource)

                        break # break smallest enclosing loop

                    else:
                        self.default_intersection.set_pick_mat(_world_mat)           
                        _ray = self.default_intersection.get_ray()

                        _mf_pick_result = _frustum.ray_test(_ray)

                        if len(_mf_pick_result.value) > 0: # tool resource intersects this frustum --> resource is candidate for interaction
                            _candidate_resource_list.append(_resource)

                            break # break smallest enclosing loop

            #print("1", _candidate_resource_list)


            ## check if candidate ray representations intersect scene geometry
            for _resource in _candidate_resource_list:
                _pick_result = self.calc_intersection(_resource.get_node())

                if _pick_result is not None:
                    _pick_world_pos = _pick_result[3]
                    
                    _frusta_list = _resource.VIEW_CONTEXT.get_valid_frusta_of_user(self.TOOL.assigned_user)
                
                    for _frustum in _frusta_list:           
                        if _frustum.contains(_pick_world_pos) == True: # pick position of this resource is inside frusta of the respective view-context --> pick position visible for assigned user
                            _candidate_resource_tupel_list.append( (_resource, _pick_result) )

                            break # break smallest enclosing loop

            #print("2", _candidate_resource_tupel_list)
            
            ## select one ray representation as interaction candidate
            if len(_candidate_resource_tupel_list) == 1:
                _tupel = _candidate_resource_tupel_list[0]
                self.candidate_resource_list.append(_tupel[0]) # get first (and only) active resource
                
            elif len(_candidate_resource_tupel_list) > 1:                            
                # if multiple intersecting resources exist, take the one with shortest pick distance
                _nearest_distance = sys.maxsize # start with max distance
           
                for _tupel in _candidate_resource_tupel_list:
                    _resource = _tupel[0]
                    _pick_result = _tupel[1]
                    _pick_distance = _pick_result[5]
                
                    if len(self.candidate_resource_list) == 0:
                        self.candidate_resource_list.append(_resource)
                        _nearest_distance = _pick_distance
                        
                    elif len(self.candidate_resource_list) > 0:
                        if _pick_distance < _nearest_distance:
                            self.candidate_resource_list[0] = _resource
                            _nearest_distance = _pick_distance


            # print("3", self.candidate_resource_list)

    

    def calc_intersection(self, NODE):
        _world_mat = lib.Utilities.get_world_transform(NODE)
        
        self.default_intersection.set_pick_mat(_world_mat)
        self.default_intersection.compute_intersection()

        return self.default_intersection.get_first_pick_result()
Esempio n. 8
0
    def __init__( self
                , INITIATOR = None
                , INPUT = None
                , RAY_LENGHT = 10.0
                , TOOL_THICKNESS = 0.01 # in meter
                , LIGHT_COLOR = avango.gua.Color(1.0,1.0,1.0)
                , LIGHT_BRIGHTNESS = 10.0
                , LIGHT_DIMENSIONS = avango.gua.Vec3(1.0,1.0,1.0)
                , SHADOW_FLAG = False
                , SHADOW_MAP_SIZE = 512
                , VIEW_CONTEXT_LIST = []
                , VISIBILITY_DICTIONARY = {}
                ):


        ## init base class
        Tool.__init__( self
                     , INITIATOR = INITIATOR
                     , INPUT = INPUT
                     , VIEW_CONTEXT_LIST = VIEW_CONTEXT_LIST
                     , VISIBILITY_DICTIONARY = VISIBILITY_DICTIONARY
                     , RESOURCE_SELECTOR = LightToolResourceSelector(TOOL = self, RAY_LENGTH = RAY_LENGHT)
                     )


        ### parameters ###        
        self.tool_thickness = 0.01
        
        self.light_geometry_thickness = 0.02
        self.light_color = avango.gua.Color(1.0,1.0,1.0)
        self.light_brightness = 10.0
        self.light_dimensions = avango.gua.Vec3(1.0,1.0,1.0)
        self.shadow_flag = False
        self.shadow_map_size = 512


        ### variables ###
        self.active_resource = None
        self.action_flag = False
       
        ### resources ###

        ## init script
        self.script = LightToolScript()
        self.script.my_constructor(self)

        ## init intersection
        self.default_intersection = Intersection( PICK_LENGTH = RAY_LENGHT
                                                , BLACK_LIST = ["invisible"]
                                                )

                                                

        ## init intersection node
        self.intersection_node = avango.gua.nodes.TransformNode(Name = "light_intersection_node")
        builtins.APPLICATION.append_node_to_root(self.intersection_node)

        self.intersection_geometry = builtins.TRIMESH_LOADER.create_geometry_from_file("intersection_geometry", "data/objects/sphere.obj", avango.gua.LoaderFlags.DEFAULTS)
        self.intersection_geometry.Material.value.set_uniform("Emissivity", 0.5)
        self.intersection_geometry.ShadowMode.value = 0 # disable for shadowing
        self.intersection_geometry.Transform.value = avango.gua.make_scale_mat(0.03)
        self.intersection_node.Children.value.append(self.intersection_geometry)
        
        self.offset_node = avango.gua.nodes.TransformNode(Name = "offset_node")
        self.offset_node.Transform.value = avango.gua.make_trans_mat(0.0,0.0,0.5)
        self.intersection_node.Children.value.append(self.offset_node)


        ## init flashlight geometries
        self.cube_geometry = builtins.TRIMESH_LOADER.create_geometry_from_file("flashlight_resource_cube_geometry", "data/objects/cube.obj", avango.gua.LoaderFlags.DEFAULTS)
        self.cube_geometry.Material.value.set_uniform("Emissivity", 0.5)
        self.cube_geometry.ShadowMode.value = 0 # disable for shadowing
        self.cube_geometry.Transform.value = avango.gua.make_scale_mat(self.light_geometry_thickness)
        self.offset_node.Children.value.append(self.cube_geometry)

      
        self.cone_geometry = builtins.TRIMESH_LOADER.create_geometry_from_file("flashlight_resource_cone_geometry", "data/objects/cone.obj", avango.gua.LoaderFlags.DEFAULTS)        
        self.cone_geometry.Material.value.set_uniform("Emissivity", 1.0) # pass through
        self.cone_geometry.ShadowMode.value = 0 # disable for shadowing      
        self.cone_geometry.Transform.value = avango.gua.make_trans_mat(0.0, 0.0, -self.light_geometry_thickness) * \
                                             avango.gua.make_scale_mat(self.light_geometry_thickness * 2.0)
        self.offset_node.Children.value.append(self.cone_geometry)

        ## init light node
        self.light_node = avango.gua.nodes.LightNode(Name = "light_node")
        self.light_node.Type.value = avango.gua.LightType.SPOT
        #self.light_node.ShadowNearClippingInSunDirection.value = 0.01
        #self.light_node.ShadowNearClippingInSunDirection.value = 0.1 * (1.0/LIGHT_DIMENSIONS.z)
        self.light_node.ShadowFarClippingInSunDirection.value = 1.1
        self.light_node.Falloff.value = 0.5
        self.offset_node.Children.value.append(self.light_node)
             
        
        ## trigger callbacks
        ## @var frame_trigger
        # Triggers framewise evaluation of respective callback method
        self.frame_trigger = avango.script.nodes.Update(Callback = self.frame_callback, Active = False)

        # Triggers framewise evaluation of respective callback method
        self.update_trigger = avango.script.nodes.Update(Callback = self.update_callback, Active = False)


        ### set initial states ###
        ## set tool properties
        self.set_thickness(TOOL_THICKNESS)
        
        ## set light properties
        self.set_light_color(LIGHT_COLOR)
        self.set_light_brightness(LIGHT_BRIGHTNESS)
        self.set_light_dimensions(LIGHT_DIMENSIONS)
        self.set_shadow_flag(SHADOW_FLAG)
        self.set_shadow_map_size(SHADOW_MAP_SIZE)        
        

        print("LightTool initialized:", Tool.get_id(self))
Esempio n. 9
0
class LightTool(Tool):


    ### constructor
    def __init__( self
                , INITIATOR = None
                , INPUT = None
                , RAY_LENGHT = 10.0
                , TOOL_THICKNESS = 0.01 # in meter
                , LIGHT_COLOR = avango.gua.Color(1.0,1.0,1.0)
                , LIGHT_BRIGHTNESS = 10.0
                , LIGHT_DIMENSIONS = avango.gua.Vec3(1.0,1.0,1.0)
                , SHADOW_FLAG = False
                , SHADOW_MAP_SIZE = 512
                , VIEW_CONTEXT_LIST = []
                , VISIBILITY_DICTIONARY = {}
                ):


        ## init base class
        Tool.__init__( self
                     , INITIATOR = INITIATOR
                     , INPUT = INPUT
                     , VIEW_CONTEXT_LIST = VIEW_CONTEXT_LIST
                     , VISIBILITY_DICTIONARY = VISIBILITY_DICTIONARY
                     , RESOURCE_SELECTOR = LightToolResourceSelector(TOOL = self, RAY_LENGTH = RAY_LENGHT)
                     )


        ### parameters ###        
        self.tool_thickness = 0.01
        
        self.light_geometry_thickness = 0.02
        self.light_color = avango.gua.Color(1.0,1.0,1.0)
        self.light_brightness = 10.0
        self.light_dimensions = avango.gua.Vec3(1.0,1.0,1.0)
        self.shadow_flag = False
        self.shadow_map_size = 512


        ### variables ###
        self.active_resource = None
        self.action_flag = False
       
        ### resources ###

        ## init script
        self.script = LightToolScript()
        self.script.my_constructor(self)

        ## init intersection
        self.default_intersection = Intersection( PICK_LENGTH = RAY_LENGHT
                                                , BLACK_LIST = ["invisible"]
                                                )

                                                

        ## init intersection node
        self.intersection_node = avango.gua.nodes.TransformNode(Name = "light_intersection_node")
        builtins.APPLICATION.append_node_to_root(self.intersection_node)

        self.intersection_geometry = builtins.TRIMESH_LOADER.create_geometry_from_file("intersection_geometry", "data/objects/sphere.obj", avango.gua.LoaderFlags.DEFAULTS)
        self.intersection_geometry.Material.value.set_uniform("Emissivity", 0.5)
        self.intersection_geometry.ShadowMode.value = 0 # disable for shadowing
        self.intersection_geometry.Transform.value = avango.gua.make_scale_mat(0.03)
        self.intersection_node.Children.value.append(self.intersection_geometry)
        
        self.offset_node = avango.gua.nodes.TransformNode(Name = "offset_node")
        self.offset_node.Transform.value = avango.gua.make_trans_mat(0.0,0.0,0.5)
        self.intersection_node.Children.value.append(self.offset_node)


        ## init flashlight geometries
        self.cube_geometry = builtins.TRIMESH_LOADER.create_geometry_from_file("flashlight_resource_cube_geometry", "data/objects/cube.obj", avango.gua.LoaderFlags.DEFAULTS)
        self.cube_geometry.Material.value.set_uniform("Emissivity", 0.5)
        self.cube_geometry.ShadowMode.value = 0 # disable for shadowing
        self.cube_geometry.Transform.value = avango.gua.make_scale_mat(self.light_geometry_thickness)
        self.offset_node.Children.value.append(self.cube_geometry)

      
        self.cone_geometry = builtins.TRIMESH_LOADER.create_geometry_from_file("flashlight_resource_cone_geometry", "data/objects/cone.obj", avango.gua.LoaderFlags.DEFAULTS)        
        self.cone_geometry.Material.value.set_uniform("Emissivity", 1.0) # pass through
        self.cone_geometry.ShadowMode.value = 0 # disable for shadowing      
        self.cone_geometry.Transform.value = avango.gua.make_trans_mat(0.0, 0.0, -self.light_geometry_thickness) * \
                                             avango.gua.make_scale_mat(self.light_geometry_thickness * 2.0)
        self.offset_node.Children.value.append(self.cone_geometry)

        ## init light node
        self.light_node = avango.gua.nodes.LightNode(Name = "light_node")
        self.light_node.Type.value = avango.gua.LightType.SPOT
        #self.light_node.ShadowNearClippingInSunDirection.value = 0.01
        #self.light_node.ShadowNearClippingInSunDirection.value = 0.1 * (1.0/LIGHT_DIMENSIONS.z)
        self.light_node.ShadowFarClippingInSunDirection.value = 1.1
        self.light_node.Falloff.value = 0.5
        self.offset_node.Children.value.append(self.light_node)
             
        
        ## trigger callbacks
        ## @var frame_trigger
        # Triggers framewise evaluation of respective callback method
        self.frame_trigger = avango.script.nodes.Update(Callback = self.frame_callback, Active = False)

        # Triggers framewise evaluation of respective callback method
        self.update_trigger = avango.script.nodes.Update(Callback = self.update_callback, Active = False)


        ### set initial states ###
        ## set tool properties
        self.set_thickness(TOOL_THICKNESS)
        
        ## set light properties
        self.set_light_color(LIGHT_COLOR)
        self.set_light_brightness(LIGHT_BRIGHTNESS)
        self.set_light_dimensions(LIGHT_DIMENSIONS)
        self.set_shadow_flag(SHADOW_FLAG)
        self.set_shadow_map_size(SHADOW_MAP_SIZE)        
        

        print("LightTool initialized:", Tool.get_id(self))



    ### functions ###

    ## extend respective base-class function
    def init(self):
        Tool.init(self) # call base-class function
            
        self.enable(True)
        
        self.connect_input()


    ## implement respective base-class function
    def init_resource(self, PARENT_NODE, VIEW_CONTEXT):    
        _resource = LightToolResource( TOOL = self
                                     , PARENT_NODE = PARENT_NODE
                                     , VIEW_CONTEXT = VIEW_CONTEXT
                                     , TOOL_THICKNESS = self.tool_thickness
                                     )


    ## extend respective base-class function
    def enable(self, BOOL):
        Tool.enable(self, BOOL) # call base-class function
    
        self.frame_trigger.Active.value = self.enable_flag # enable/disable frame callback
   
   

    ## INPUT CONNECTIONS
    def connect_input(self):
        if self.INPUT is not None: # guard
            if self.INPUT.get_matrix_field() is not None:
                self.connect_matrix(self.INPUT.get_matrix_field())

            if self.INPUT.get_button0_field() is not None:
                self.script.sf_button0.disconnect()
                self.script.sf_button0.connect_from(self.INPUT.get_button0_field())
                 

    def connect_matrix(self, SF_MAT4):
        for _resource in Tool.get_resource_list(self):
            _resource.connect_matrix(SF_MAT4)
    

    def set_thickness(self, FLOAT):
        self.tool_thickness = FLOAT
        
        for _resource in Tool.get_resource_list(self):
            _resource.set_thickness(self.tool_thickness)


    def set_light_color(self, COLOR):
        self.light_color = COLOR

        self.light_node.Color.value = COLOR
        self.cone_geometry.Material.value.set_uniform("Color", avango.gua.Vec4(COLOR.r, COLOR.g, COLOR.b, 1.0))
            

    def set_light_brightness(self, FLOAT):
        self.light_brightness = FLOAT

        self.light_node.Brightness.value = FLOAT
        

    def set_light_dimensions(self, VEC3):
        self.light_dimensions = VEC3

        self.light_node.Transform.value = avango.gua.make_scale_mat(VEC3)

        self.light_node.ShadowNearClippingInSunDirection.value = 0.1 * (1.0/VEC3.z) # shadow near cliiping at 10cm (independant of light dimensions)
        self.light_node.ShadowMaxDistance.value = VEC3.z + 5.0


    def set_shadow_flag(self, FLAG):
        self.shadow_flag = FLAG

        self.light_node.EnableShadows.value = FLAG
        

    def set_shadow_map_size(self, UINT):
        self.shadow_map_size = UINT

        self.light_node.ShadowMapSize.value = UINT
        

    def select_active_resource(self):
        _list = self.RESOURCE_SELECTOR.get_candidate_resources()

        if len(_list) == 0:
            self.active_resource = None
        elif len(_list) > 0:
            self.active_resource = _list[0]


    def process_button0(self, BOOL):
        if BOOL == True:
            if self.active_resource is not None:
                _world_mat = lib.Utilities.get_world_transform(self.active_resource.get_node())
            
                self.default_intersection.set_pick_mat(_world_mat)
                self.default_intersection.compute_intersection()

                _pick_result = self.default_intersection.get_first_pick_result()
                
                if _pick_result is not None:
                    self.action_flag = True

                    self.update_trigger.Active.value = True
                
                    _pick_world_pos = _pick_result[3]
                    
                    _platform_node = self.active_resource.get_node().Parent.value
                    _mat = _platform_node.Transform.value
                    
                    self.intersection_node.Transform.value = avango.gua.make_trans_mat(_pick_world_pos) * \
                                                             avango.gua.make_rot_mat(_mat.get_rotate_scale_corrected())
                                        
                    self.intersection_node.Tags.value = [] # set visible
                
        else:
            if self.action_flag == True:
                self.action_flag = False
                
                self.update_trigger.Active.value = False
                
                self.intersection_node.Tags.value = ["invisible"] # set invisible
        


    ### callback functions ###
    def frame_callback(self):
        #print("frame")
        
        if self.action_flag == False:
            Tool.update_assigned_user(self)
            
            self.RESOURCE_SELECTOR.update_candidate_resources()

            self.select_active_resource()

            
    def update_callback(self):       
        _vec = self.INPUT.get_inputs()
        
        _platform_node = self.active_resource.get_node().Parent.value
        _mat = _platform_node.Transform.value

        _vec = avango.gua.make_rot_mat(_mat.get_rotate_scale_corrected()) * avango.gua.Vec3(_vec.x, _vec.y, 0.0) # express in platform orientation
        
        self.intersection_node.Transform.value = avango.gua.make_trans_mat(self.intersection_node.Transform.value.get_translate()) * \
                                                 avango.gua.make_rot_mat(_vec.x * builtins.APPLICATION.get_application_fps_scale_factor() * 0.5,0,1,0) * \
                                                 avango.gua.make_rot_mat(_vec.y * builtins.APPLICATION.get_application_fps_scale_factor() * 0.5,1,0,0) * \
                                                 avango.gua.make_rot_mat(_vec.z * builtins.APPLICATION.get_application_fps_scale_factor() * 0.5,0,0,1) * \
                                                 avango.gua.make_rot_mat(self.intersection_node.Transform.value.get_rotate_scale_corrected())
class DataWriter:
    def __init__(self, intersection=None, root_dir='data'):
        self.intersection = intersection
        self.root_dir = root_dir
        self.database_filename = 'data/sqlite_database.db'
        if not os.path.exists(self.database_filename):
            self.build_database()

    def get_parameters(self):
        parameters = self.intersection.parameters
        values = self.intersection.__dict__
        list_of_parameters = []
        for parameter in parameters:
            list_of_parameters.append((parameter, values[parameter]))
        return sorted(list_of_parameters, key=lambda x: x[0])

    def resolve_filename(self):
        list_of_parameters = self.get_parameters()
        return '{}.csv'.format('_'.join(
            [str(x[1]) for x in list_of_parameters]))

    def write(self, data, source="database"):
        if source == 'file':
            self.write_file(data)
        elif source == 'database':
            self.write_database(data)

    def build_database(self):
        print("Building database")
        create_runs_table = '''CREATE TABLE runs 
            (id INTEGER PRIMARY KEY, name, comments)'''
        create_parameters_table = '''CREATE TABLE parameters
            (id INTEGER PRIMARY KEY, run_id, parameter_name, parameter_value)'''
        create_results_table = '''CREATE TABLE results
            (id INTEGER PRIMARY KEY, run_id, average_speed, throughput, number_of_waiting_cars, mean_crossover_time)'''

        conn = sqlite3.connect(self.database_filename)
        conn.execute(create_runs_table)
        conn.execute(create_parameters_table)
        conn.execute(create_results_table)
        conn.commit()
        conn.close()

    def write_database(self, results):
        conn = sqlite3.connect(self.database_filename)
        # Run
        conn.execute('''INSERT INTO runs(name, comments) VALUES ('', '')''')
        conn.commit()

        cur = conn.cursor()
        cur.execute('''SELECT MAX(id) FROM runs''')
        run_id = cur.fetchone()[0]

        # Parameters
        parameters = self.get_parameters()
        conn.executemany(
            '''INSERT INTO parameters(run_id, parameter_name, parameter_value) VALUES ({}, ?, ?)'''
            .format(run_id), parameters)
        conn.commit()

        # Results
        conn.executemany(
            '''INSERT INTO results(run_id, average_speed, throughput, number_of_waiting_cars, mean_crossover_time) VALUES ({}, ?, ?, ?, ?)'''
            .format(run_id), results.values)
        conn.commit()
        print("Inserted run with id {}".format(run_id))

    def write_file(self, data):
        data.to_csv('{}/{}/{}'.format(self.root_dir,
                                      self.intersection.intersection_type,
                                      self.resolve_filename()).lower().replace(
                                          ' ', '_'))

    def read(self, run_id, source="database"):
        if source == 'file':
            # todo
            pass
        else:
            self.read_database(run_id)

    def read_database(self, run_id):
        run_id = (run_id, )
        data = dict()
        conn = sqlite3.connect(self.database_filename)

        cur = conn.cursor()
        cur.execute('''SELECT * FROM runs WHERE id = ?''', run_id)
        data['run'] = cur.fetchall()

        cur = conn.cursor()
        cur.execute('''SELECT * FROM results WHERE run_id = ?''', run_id)
        results = cur.fetchall()
        data['results'] = dict()
        data['results']['average_speed'] = [row[2] for row in results]
        data['results']['throughput'] = [row[3] for row in results]
        data['results']['number_of_waiting_cars'] = [row[4] for row in results]
        data['results']['mean_crossover_time'] = [row[5] for row in results]

        cur = conn.cursor()
        cur.execute('''SELECT * FROM parameters WHERE run_id = ?''', run_id)
        parameters = cur.fetchall()
        data['parameters'] = dict()
        for parameter in parameters:
            data['parameters'][parameter[2]] = parameter[3]
        conn.close()
        return data

    def get_runs_by_parameters(self, parameters):
        conn = sqlite3.connect(self.database_filename)
        cur = conn.cursor()
        first = True
        sql = ''
        for parameter in parameters:
            if first:
                first = False
            else:
                sql += ''' INTERSECT '''
            sql += '''SELECT run_id FROM parameters
                     WHERE parameter_name=\'{}\' AND parameter_value LIKE \'{}\''''.format(
                parameter, parameters[parameter])

        cur.execute(sql)
        run_ids = cur.fetchone()
        if run_ids == None:
            """ raise Exception('No run found with these parameters') """

            # For testing
            self.intersection = Intersection(parameters=parameters,
                                             parameters_as_dict=True)
            self.run()
            cur.execute('''SELECT MAX(id) FROM runs''')
            run_id = cur.fetchone()[0]
            return self.read_database(run_id)
        # else:
        # print('Found run ids: {}'.format(run_ids))

        return self.read_database(run_ids[0])

    def run(self, n=1000):
        self.intersection.run_model(n)
        self.intersection.average_speed.collect(self.intersection)
        df1 = self.intersection.average_speed.get_model_vars_dataframe()
        self.intersection.throughput.collect(self.intersection)
        df2 = self.intersection.throughput.get_model_vars_dataframe()
        self.intersection.waiting_cars.collect(self.intersection)
        df3 = self.intersection.waiting_cars.get_model_vars_dataframe()
        self.intersection.mean_crossover.collect(self.intersection)
        df4 = self.intersection.mean_crossover.get_model_vars_dataframe()
        df = pd.DataFrame(
            [df1.iloc[:, 0], df2.iloc[:, 0], df3.iloc[:, 0], df4.iloc[:, 0]])
        data = df.transpose()
        self.write(data)