def __init__(self, **kwargs): parameterInitCheck(LiveManagedFilterchain.parameter_defs, kwargs, self) # checks that parameters ok, attaches them as attributes to self # remove parameters not used by the mother class kwargs.pop("livethread") if ("recv_buffer_size" in kwargs): kwargs.pop("recv_buffer_size") if ("reordering_mstime" in kwargs): kwargs.pop("reordering_mstime") super().__init__(**kwargs)
def __init__(self, **kwargs): # auxiliary string for debugging output self.pre = self.__class__.__name__ + " : " # check for input parameters, attach them to this instance as # attributes parameterInitCheck(MultiForkFilterchain.parameter_defs, kwargs, self) generateGetters(self.parameter_defs, self) # check some types for openglthread in self.openglthreads: assert (issubclass(openglthread.__class__, OpenGLThread)) #if self.valkkafsmanager is not None: # assert(isinstance(self.valkkafsmanager, ValkkaFSManager)) #if record_type != RecordType.never: # assert(self.id_rec > -1) self.idst = str(id(self)) self.initVars() # must be called before any clients are requested self.make_main_branch() self.make_filesystem_branch() # calls by default self.fs_gate.unSet() self.make_decode_branch() self.make_analysis_branch() self.createContext( ) # creates & registers contexes to LiveThread & USBDeviceThread self.start() # starts threads corresponding to this filterchain
def __init__(self, **kwargs): # auxiliary string for debugging output self.pre = self.__class__.__name__ + " : " # check for input parameters, attach them to this instance as # attributes parameterInitCheck(self.parameter_defs, kwargs, self) self.init()
def __init__(self, **kwargs): super().__init__(**kwargs) parameterInitCheck( MovementDetector.parameter_defs, kwargs, self ) # checks that kwargs is consistent with parameter_defs. Attaches parameters as attributes to self self.pre = self.__class__.__name__ + " : " self.reset()
def __init__(self, **kwargs): # auxiliary string for debugging output self.pre = self.__class__.__name__ + " : " # check for input parameters, attach them to this instance as # attributes parameterInitCheck(MVisionContainer.parameter_defs, kwargs, self) assert (issubclass(self.mvision_class, multiprocess.QValkkaShmemProcess2)) super().__init__(parent_container=self.parent_container, filterchain_group=self.filterchain_group, n_xscreen=self.n_xscreen) tag = self.mvision_class.tag # identifies a list of multiprocesses in self.process_map try: queue = self.process_map[tag] except KeyError: self.mvision_process = None return try: self.mvision_process = queue.pop() except IndexError: self.mvision_process = None return
def __init__(self, **kwargs): parameterInitCheck(PlayVideoContainerNxM.parameter_defs, kwargs, self) kwargs.pop("n_dim") kwargs.pop("m_dim") kwargs.pop("valkkafsmanager") kwargs.pop("playback_controller") super().__init__(**kwargs)
def __init__(self, **kwargs): parameterInitCheck( USBManagedFilterchain.parameter_defs, kwargs, self ) # checks that parameters ok, attaches them as attributes to self # remove parameters not used by the mother class kwargs.pop("usbthread") super().__init__(**kwargs)
def __init__(self, **kwargs): # auxiliary string for debugging output self.pre = self.__class__.__name__ + " : " # check for input parameters, attach them to this instance as # attributes print(self.pre, kwargs) parameterInitCheck(VideoContainer.parameter_defs, kwargs, self) self.signals = self.Signals() # reset callback functions self.set_cb_focus() self.set_cb_unfocus() # container state variables self.double_click_focus = False # has this container been double-click focused # right-click menu self.right_click_menu = self.RightClickMenu() self.right_click_menu.maximize.triggered.connect( lambda x: self.handle_left_double_click(None) ) # use lambda as we must connect to a function self.right_click_menu.remove_camera.triggered.connect(self.clearDevice) # no stream yet self.device = None self.onvif_thread = None # TODO: ONVIF self.filterchain = None self.viewport = ViewPort( ) # viewport instance is used by ManagedFilterChain(s)
def __init__(self, **kwargs): parameterInitCheck(PlaybackFilterChainGroup.parameter_defs, kwargs, self) self.pre = self.__class__.__name__ + " : " self.chains = [] self.context_type = None self.closed = False
def __init__(self, **kwargs): # auxiliary string for debugging output self.pre = self.__class__.__name__ + " : " # check kwargs agains parameter_defs, attach ok'd parameters to this # object as attributes parameterInitCheck(self.parameter_defs, kwargs, self) self.makeWidget() self.reset()
def __init__(self, **kwargs): self.pre = self.__class__.__name__ + " : " # auxiliary string for debugging output parameterInitCheck( self.parameter_defs, kwargs, self ) # check for input parameters, attach them to this instance as attributes typeCheck(self.shmem_image_dimensions[0], int) typeCheck(self.shmem_image_dimensions[1], int) self.init()
def __init__(self, **kwargs): # auxiliary string for debugging output self.pre = self.__class__.__name__ + " : " # check for input parameters, attach them to this instance as # attributes parameterInitCheck(ManagedFilterchain3.parameter_defs, kwargs, self) generateGetters(self.parameter_defs, self) for openglthread in self.openglthreads: assert(issubclass(openglthread.__class__, OpenGLThread)) self.init()
def __init__(self, **kwargs): # auxiliary string for debugging output self.pre = self.__class__.__name__ + " : " # check for input parameters, attach them to this instance as attributes parameterInitCheck(self.parameter_defs, kwargs, self) typeCheck(self.shmem_image_dimensions[0], int) typeCheck(self.shmem_image_dimensions[1], int) # check type of frag_shmem_cellsize to review !!! # typeCheck(self.frag_shmem_cellsize[0], int) # typeCheck(self.frag_shmem_cellsize[1], int) # typeCheck(self.frag_shmem_cellsize[2], int) self.init() setValkkaLogLevel(loglevel_silent)
def __init__(self, **kwargs): # auxiliary string for debugging output self.pre = self.__class__.__name__ + " : " # check for input parameters, attach them to this instance as # attributes print("MVisionContainer: __init__: kwargs:", pformat(kwargs)) super().__init__(**filter_keys(super().parameter_defs.keys(), kwargs)) parameterInitCheck( MVisionContainer.parameter_defs, filter_keys(MVisionContainer.parameter_defs.keys(), kwargs), self) if isinstance(self.mvision_class, str): self.mvision_class = nameToClass(self.mvision_class) assert (issubclass(self.mvision_class, multiprocess.QShmemProcess)) tag = self.mvision_class.tag # identifies a list of multiprocesses in singleton.process_map self.verbose = True self.mvision_process = self.getProcess(tag) if self.mvision_process is None: return self.analyzer_widget_connected = False if hasattr(self.mvision_process, "analyzer_video_widget_class"): # the machine vision class may declare what video widget it wants to use to define the machine vision parameters (line crossing, zone intrusion, etc.) self.analyzer_widget = AnalyzerWidget( analyzer_video_widget_class=self.mvision_process. analyzer_video_widget_class) # if hasattr(self.mvision_process, "connectAnalyzerWidget"): # self.mvision_process.connectAnalyzerWidget(self.analyzer_widget) # self.analyzer_widget_connected = True # TODO: init analyzer parameters by sending a signal & serialize analyzer parameters else: self.analyzer_widget = AnalyzerWidget() self.mvision_process.connectAnalyzerWidget(self.analyzer_widget) self.analyzer_widget_connected = True # self.mvision_process.connectShmem(self.analyzer_widget) # do in connectAnalyzerWidget self.analyzer_widget.setVisible(False) self.signals.right_double_click.connect(self.right_double_click_slot) if self.mvision_parameters: self.mvision_process.updateAnalyzerParameters( self.mvision_parameters) self.analyzer_widget.mvisionToParameters(self.mvision_parameters)
def __init__(self, **kwargs): # auxiliary string for debugging output self.pre = self.__class__.__name__ + " : " # check for input parameters, attach them to this instance as # attributes # print("MVisionContainer: __init__: kwargs:", pformat(kwargs)) # remove key-values of this child class & pass the rest to the superclass super().__init__( **remove_keys(MVisionContainer.parameter_defs.keys(), kwargs)) # init internal variables for this child class parameterInitCheck( MVisionContainer.parameter_defs, filter_keys(MVisionContainer.parameter_defs.keys(), kwargs), self) # print(">>>", self.filterchain_group) self.init()
def __init__(self, **kwargs): # auxiliary string for debugging output self.pre = self.__class__.__name__ + " : " # check for input parameters, attach them to this instance as # attributes parameterInitCheck(RootVideoContainer.parameter_defs, kwargs, self) self.signals = self.Signals() self.closed = False self.children = [] self.openglthread = self.gpu_handler.openglthreads[self.n_xscreen] # TODO: check number of xscreens and correct self.n_xscreen if necessary self.signals.close.connect(self.close_slot) # this creates the container objects .. their widgets are created in # makeWidget self.createChildren() # create widget into a certain xscreen self.makeWidget(self.gpu_handler.true_screens[self.n_xscreen])
def __init__(self, **kwargs): # auxiliary string for debugging output self.pre = self.__class__.__name__ + " : " # check for input parameters, attach them to this instance as # attributes parameterInitCheck(PlaybackFilterchain.parameter_defs, kwargs, self) generateGetters(self.parameter_defs, self) # check some types for openglthread in self.openglthreads: assert (issubclass(openglthread.__class__, OpenGLThread)) self.idst = str(id(self)) self.initVars() # must be called before any clients are requested self.make_main_branch() self.make_decode_branch() self.start() # starts threads corresponding to this filterchain
def __init__(self, **kwargs): self.pre = self.__class__.__name__ + " : " # auxiliary string for debugging output parameterInitCheck( GPUHandler.parameter_defs, kwargs, self ) # check kwargs agains parameter_defs, attach ok'd parameters to this object as attributes self.kwargs = kwargs self.true_screens = [] # list of QtCore.QScreen self.openglthreads = [] # list of OpenGLThread instances self.findXScreens() # self.true_screens=[self.true_screens[0]] for n_gpu, screen in enumerate(self.true_screens): x_connection = ":0." + str(n_gpu) # x_connection=":0.1" # x_connection=":1.0" # nopes print(pre, "GPUHandler: starting OpenGLThread with", x_connection) affinity = -1 if self.cpu_scheme: affinity = self.cpu_scheme.getOpenGL() openglthread = OpenGLThread( name="gpu_" + str(n_gpu), # reserve stacks of YUV video frames for various resolutions n_720p=self.n_720p, n_1080p=self.n_1080p, n_1440p=self.n_1440p, n_4K=self.n_4K, verbose=False, msbuftime=self.msbuftime, affinity=affinity, x_connection=x_connection) print(pre, "GPUHandler: OpenGLThread started") self.openglthreads.append(openglthread)
def __init__(self, **kwargs): parameterInitCheck(VideoContainerNxM.parameter_defs, kwargs, self) kwargs.pop("n_dim") kwargs.pop("m_dim") super().__init__(**kwargs)
def __init__(self, **kwargs): parameterInitCheck(ManagedFilterchain2.parameter_defs, kwargs, self) kwargs.pop("shmem_image_dimensions") kwargs.pop("shmem_n_buffer") kwargs.pop("shmem_image_interval") super().__init__(**kwargs)
def __init__(self, **kwargs): parameterInitCheck( Analyzer.parameter_defs, kwargs, self, undefined_ok=True ) # checks that kwargs is consistent with parameter_defs. Attaches parameters as attributes to self. This is a mother class: there might be more parameters not defined here from child classes self.pre = self.__class__.__name__ + " : "