def test_traversable_tutorial(self): # Create a Harvester object: self.harvester = Harvester() # The following block is just for administrative purpose; # you should not include it in your code: cti_file_path = get_cti_file_path() if 'TLSimu.cti' not in cti_file_path: return # Add a CTI file path: self.harvester.add_cti_file(cti_file_path) self.harvester.update_device_info_list() # Connect to the first camera in the list: self.ia = self.harvester.create_image_acquirer(0) # num_images_to_acquire = 0 # Then start image acquisition: self.ia.start_image_acquisition() while num_images_to_acquire < 100: # with self.ia.fetch_buffer() as buffer: # self.do_something(buffer) pass num_images_to_acquire += 1 # We don't need the ImageAcquirer object. Destroy it: self.ia.destroy()
def test_traversable_tutorial(self): # Create a Harvester object: self.harvester = Harvester() # Add a CTI file path: self.harvester.add_cti_file( get_cti_file_path() ) self.harvester.update_device_info_list() # Connect to the first camera in the list: self.ia = self.harvester.create_image_acquirer(0) # num_images_to_acquire = 0 # Then start image acquisition: self.ia.start_image_acquisition() while num_images_to_acquire < 100: # with self.ia.fetch_buffer() as buffer: # self.do_something(buffer) pass num_images_to_acquire += 1 # We don't need the ImageAcquirer object. Destroy it: self.ia.destroy()
def setUp(self): # super().setUp() # self._harvester = Harvester(logger=self._logger) self._harvester.add_file(self._cti_file_path) self._harvester.update()
def setUp(self): # super().setUp() # self._harvester = Harvester(logger=self._logger, do_clean_up=False) self._harvester.add_file(self._cti_file_path) self._harvester.update()
def setUp(self): # super().setUp() # self._harvester = Harvester(logger=self._logger) self._harvester.add_cti_file(self._cti_file) self._harvester.update_device_info_list()
def setUp(self) -> None: # The following block is just for administrative purpose; # you should not include it in your code: self.cti_file_path = get_cti_file_path() if 'TLSimu.cti' not in self.cti_file_path: self.skipTest('The target is not TLSimu.') # Create a Harvester object: self.harvester = Harvester()
def setUp(self): # super().setUp() # self._harvester = Harvester() self._harvester.add_cti_file(self._path + self._filename) self._harvester.update_device_info_list() self._iam = None self._thread = None
class HarvestersSource(Node, Observable): def __init__(self): Node.__init__(self, "Harvesters") Observable.__init__(self, self._on_subscribe) self.cfg = self.config[SECTION] self.harvester = Harvester() if self.cfg["disableInternalLogger"]: self.harvester._logger.setLevel(100) self.cti_file = self.cfg["ctiFile"] self.harvester.add_file(self.cti_file) self.logger.info(f"Loaded harvester cti file {self.cti_file}") self.harvester.update() self.logger.info( f"Found {len(self.harvester.device_info_list)} devices.") def _on_subscribe(self, observer: Observer, scheduler=None): self.acquirer = self.harvester.create_image_acquirer(list_index=0) self.reload_camera_driver() self.acquirer.add_callback( self.acquirer.Events.NEW_BUFFER_AVAILABLE, CallbackOnNewBuffer(self.acquirer, observer)) self.acquirer.start_image_acquisition(run_in_background=True) self.logger.info("Started acquisition in background") def dispose(): def _async_dispose(*args): # prevent join in the same thread. self.logger.info("Stopping image acquisition") self.acquirer.stop_image_acquisition() self.acquirer.destroy() self.logger.info("Stopped image acquisition") (scheduler or NewThreadScheduler()).schedule(_async_dispose) return Disposable(dispose) def reload_camera_driver(self): node = self.acquirer.device.node_map node.LineSelector.value = self.cfg["lineSelector"] node.LineMode.value = self.cfg["lineMode"] node.LineInverter.value = self.cfg["lineInverter"] node.LineSource.value = "ExposureActive" node.ExposureTime.value = self.cfg["exposureTime"] if node.has_node("acquisitionFrameRateMode"): # Allied Vision Camera node.AcquisitionFrameRateMode.value = "Basic" node.AcquisitionFrameRate.value = self.cfg["acquisitionFrameRate"] if self.cfg["extraNodes"]: extra_nodes: dict = self.cfg["extraNodes"] for k, v in extra_nodes.items(): node.get_node(k).value = v
class TestHarvesterNoCleanUp(TestHarvesterBase): def __init__(self, *args, **kwargs): # super().__init__(*args, **kwargs) def setUp(self): # super().setUp() # self._harvester = Harvester(logger=self._logger, do_clean_up=False) self._harvester.add_file(self._cti_file_path) self._harvester.update()
def main(): h = Harvester() h.add_cti_file('C:/Program Files/JAI/SDK/bin/JaiGevTL.cti') # JaiUSB3vTL JaiGevTL print(h.cti_files) h.update_device_info_list() print("file", h.device_info_list) print("dty", list(dict.fromkeys(h.device_info_list))) # x = unique(h.device_info_list) # print("pp",x) print("devices end") ia = h.create_image_acquirer(0) print("dsssx", ia.device) print("infor", ia.device.node_map.device_info) # ia.device.node_map.Test # ia.device.node_mapdsx key.PixelFormat.value = 'RGB12' # ia.device.node_map.RGB12Packed.value = 'RGB12' # ia.device.node_map.has_node() # ia.device.node_map.TestPattern = 'HorizontalColorBar' # ia.acquirer.remote_device.node_map print(ia.is_acquiring()) try: print("acqui") ia.start_image_acquisition() print("acquired", ia.is_acquiring()) print("acqui 2", ia.fetch_buffer()) i = 0 done = False while not done: with ia.fetch_buffer() as buffer: print("checkr 1") img = buffer.payload.components[0].data img = img.reshape(buffer.payload.components[0].height, buffer.payload.components[0].width) # img_copy = img.copy() img_copy = cv2.cvtColor(img, cv2.COLOR_BayerRG2RGB) cv2.namedWindow("window", cv2.WINDOW_KEEPRATIO | cv2.WINDOW_NORMAL) cv2.imshow("window", img_copy) fps = ia.statistics.fps print("FPS: ", fps) if cv2.waitKey(10) == ord('q'): done = True print('break') i = i + 1 except Exception as e: traceback.print_exc(file=sys.stdout) finally: ia.stop_image_acquisition() ia.destroy() cv2.destroyAllWindows() print('fin') h.reset()
def camera_stream(): global outputFrame, lock h = Harvester() h.add_cti_file('/opt/mvIMPACT_Acquire/lib/x86_64/mvGenTLProducer.cti') h.update_device_info_list() ia = h.create_image_acquirer(0) #ia.device.node_map.PixelFormat.value = 'BayerRG8' #ia.device.node_map.TestPattern = 'HorizontalColorBar' try: ia.start_image_acquisition() i = 0 done = False while not done: with ia.fetch_buffer() as buffer: img = buffer.payload.components[0].data img = img.reshape( buffer.payload.components[0].height, buffer.payload.components[0].width) img_copy = img.copy() img_copy = cv2.cvtColor(img, cv2.COLOR_BayerRG2RGB) if i == 0: first = img_copy.copy() change = np.allclose(first, img_copy, 3) #print(change) if not change: # cv2.namedWindow("window", cv2.WINDOW_KEEPRATIO | cv2.WINDOW_NORMAL) # cv2.imshow("window", img_copy) #cv2.imwrite(f'./images/image_{i}.png', img_copy) outputFrame = img_copy.copy() print(outputFrame) first = img_copy.copy() if cv2.waitKey(10) == ord('q'): fps = ia.statistics.fps print("FPS: ", fps) done = True print('break') i = i + 1 if i == 500: break except Exception as e: traceback.print_exc(file=sys.stdout) finally: ia.stop_image_acquisition() ia.destroy() cv2.destroyAllWindows() print('fin') h.reset()
def __init__(self): Node.__init__(self, "Harvesters") Observable.__init__(self, self._on_subscribe) self.cfg = self.config[SECTION] self.harvester = Harvester() if self.cfg["disableInternalLogger"]: self.harvester._logger.setLevel(100) self.cti_file = self.cfg["ctiFile"] self.harvester.add_file(self.cti_file) self.logger.info(f"Loaded harvester cti file {self.cti_file}") self.harvester.update() self.logger.info( f"Found {len(self.harvester.device_info_list)} devices.")
def __init__(self): from harvesters.core import Harvester super().__init__() self.config = config.SettingAccessor(self.config_prefix) self.logger = logging.getLogger("console") self._stop = subject.Subject() self.driver = Harvester() self.driver.add_cti_file(self.config["cti_path"]) self.acquirer = None self.simex_instance = None self.running = False self.scheduler = scheduler.NewThreadScheduler() self.scheduler.schedule( lambda sc, state: self.driver.update_device_info_list())
def __init__(self, producer_paths=None): super(Camera_harvester, self).__init__() self.name = "Harvester" ##Harvester object used to communicate with Harvester module self.h = Harvester() ##paths to GenTL producers self.paths = [] if (producer_paths): for path in producer_paths: self.add_gentl_producer(path) ##Image acquifier object used by Harvester self.ia = None
def __init__(self, device_handle): """ Implementation of the JAI camera device Parameters ---------- device_handle : object Unique camera device handle to identify the camera """ # Use the same Harvester core if it is already created if not Controller.harvester_instance: Controller.harvester_instance = Harvester() self._harverster = Controller.harvester_instance self.device_handle = device_handle super(Camera, self).__init__(device_handle) self.logger = logging.getLogger(__name__) if LOGGING_LEVEL is not None: self.logger.setLevel(LOGGING_LEVEL) self.openDevice() self.img_list = list() self._setTriggerSource(source_name='Line5') # Not needed, Just in case a previous Resolution was wrongly set. self.node_map.Width.value = self.node_map.WidthMax.value self.node_map.Height.value = self.node_map.HeightMax.value # Register JAI Camera specific functions. # Function to set maximum transfer rate depending has to be yet implemented self.registerFeature("gainselector", self._gain_selector)
def test_issue_85(self): # temp_dir = os.path.join( gettempdir(), 'harvester', self.test_issue_85.__name__ ) # if os.path.isdir(temp_dir): rmtree(temp_dir) os.makedirs(temp_dir) # os.environ[self.env_var] = temp_dir # self.assertFalse(os.listdir(temp_dir)) # with Harvester() as h: h.add_file(self._cti_file_path) h.update() with h.create_image_acquirer(0): # Check if XML files have been stored in the expected # directory: self.assertTrue(os.listdir(temp_dir))
def test_issue_85(self): # temp_dir = os.path.join( gettempdir(), 'harvester', self.test_issue_85.__name__ ) # if os.path.isdir(temp_dir): rmtree(temp_dir) os.makedirs(temp_dir) # env_var = 'HARVESTERS_XML_FILE_DIR' original = None if os.environ else os.environ[env_var] os.environ[env_var] = temp_dir # self.assertFalse(os.listdir(temp_dir)) # with Harvester() as h: h.add_cti_file(self._cti_file_path) h.update_device_info_list() with h.create_image_acquirer(0): pass # if original: os.environ[env_var] = original # self.assertTrue(os.listdir(temp_dir))
def run_camera(): # Create a Harvester object: h = Harvester() # Load a GenTL Producer; you can load many more if you want to: ##find producer h.add_file( 'C:\Program Files\Allied Vision\Vimba_4.2\VimbaGigETL\Bin\Win64\VimbaGigETL.cti' ) # Enumerate the available devices that GenTL Producers can handle: h.update() print(h.device_info_list) # Select a target device and create an ImageAcquire object that # controls the device: ia = h.create_image_acquirer(0) # Configure the target device; it looks very small but this is just # for demonstration: # ia.remote_device.node_map.Width.value = 1936 # ia.remote_device.node_map.Height.value = 1216 # ia.remote_device.node_map.PixelFormat.value = 'RGB8Packed' # Allow the ImageAcquire object to start image acquisition: ia.start_acquisition() # We are going to fetch a buffer filled up with an image: # Note that you'll have to queue the buffer back to the # ImageAcquire object once you consumed the buffer; the # with statement takes care of it on behalf of you: with ia.fetch_buffer() as buffer: # Let's create an alias of the 2D image component; it can be # lengthy which is not good for typing. In addition, note that # a 3D camera can give you 2 or more components: component = buffer.payload.components[0] # Reshape the NumPy array into a 2D array: image_rgb = component.data.reshape(component.height, component.width, 3) image_bgr = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2BGR) # img_inference runs both models processing_time, boxes, scores, labels = img_inference(image_bgr) # Stop the ImageAcquier object acquiring images: ia.stop_acquisition() # We're going to leave here shortly: ia.destroy() h.reset()
def run(self): h = Harvester() h.add_file(self._cti_file_path) h.update() try: ia = h.create_image_acquirer(0) except: # Transfer the exception anyway: self._message_queue.put(sys.exc_info()) else: ia.start_acquisition() ia.stop_acquisition() ia.destroy() h.reset()
def __init__(self, SetCameraLighting, Config_module=None, Warnings_module=None): # Misc from time import sleep import sys self.sleep = sleep self.warnings = Warnings_module self.sys = sys # Store custom module self.FileConfig = Config_module # Lights function self.SetCameraLighting = SetCameraLighting # GenICam helper from harvesters.core import Harvester, TimeoutException # Init harvester self.harvester = Harvester() self.TimeoutException = TimeoutException # Temperature self.criticalTemp = self.FileConfig.Get( "Cameras")["Generic"]["Temperature"]["Critical"] self.warningTemp = self.FileConfig.Get( "Cameras")["Generic"]["Temperature"]["Warning"] # Storage for camera modules self.n_camera = self.FileConfig.Get("QuickSettings")["ActiveCameras"] self.ImportCTI() # import cti file self.Scan() # check if producer is available self.Create() # define image Acquirer objects from discovered devices self.Config() # configure image acquirer objects self.ImportOpenCV() # Create opencv module
def open(self) -> None: """TBW.""" if self._simulate: return h = Harvester() locs = [ r"~/tools/mvImpact/lib/x86_64/mvGenTLProducer.cti", r"C:\Program Files\MATRIX VISION\mvIMPACT Acquire\bin\x64\mvGenTLProducer.cti" ] cti = "" for loc in locs: if Path(loc).expanduser().exists(): cti = loc if not cti: raise FileNotFoundError( "Could not locate cti file: mvGenTLProducer.cti") cti = str(Path(cti).expanduser()) h.add_file(cti) h.update() len(h.device_info_list) h.device_info_list[0] print("creating ia....") ia = h.create_image_acquirer(0) print("ia created") # ia = h.create_image_acquirer(serial_number='050200047485') # ia.remote_device.node_map.Width.value = 1024 # max: 1312 # ia.remote_device.node_map.Height.value = 1024 # max: 1082 # ia.remote_device.node_map.PixelFormat.value = 'Mono12' from harvesters.core import ImageAcquirer print(ImageAcquirer.Events.__members__) from harvesters.core import Callback class CallbackOnNewBuffer(Callback): def __init__(self, ia: ImageAcquirer): # super().__init__() # self._ia = ia def emit(self, context): # # You would implement this method by yourself. # with _ia.fetch_buffer() as buffer: # # Work with the fetched buffer. # print(buffer) print(datetime.utcnow(), "New image") on_new_buffer = CallbackOnNewBuffer(self) ia.add_callback(ia.Events.NEW_BUFFER_AVAILABLE, on_new_buffer) ia.start_acquisition(run_in_background=True) self._dev = h self._ia = ia self.on_new_buffer = on_new_buffer
class TestHarvesterCoreBase(unittest.TestCase): _cti_file_path = get_cti_file_path() sys.path.append(_cti_file_path) def __init__(self, *args, **kwargs): # super().__init__(*args, **kwargs) # self._harvester = None self._ia = None self._thread = None self._logger = get_logger(name='harvesters', level=DEBUG) self._buffers = [] def setUp(self): # super().setUp() # self._harvester = Harvester(logger=self._logger) self._harvester.add_cti_file(self._cti_file_path) self._harvester.update_device_info_list() def tearDown(self): # if self.ia: self.ia.destroy() # self._harvester.reset() # self._ia = None # super().tearDown() @property def harvester(self): return self._harvester @property def ia(self): return self._ia @ia.setter def ia(self, value): self._ia = value @property def general_purpose_thread(self): return self._thread @general_purpose_thread.setter def general_purpose_thread(self, value): self._thread = value def is_running_with_default_target(self): return True if 'TLSimu.cti' in self._cti_file_path else False
class TestHarvesterCoreBase(unittest.TestCase): _path = 'C:/Users/z1533tel/dev/genicam/bin/Win64_x64/' \ if is_running_on_windows() else \ '/Users/kznr/dev/genicam/bin/Maci64_x64/' _filename = 'TLSimu.cti' sys.path.append(_path) def __init__(self, *args, **kwargs): # super().__init__(*args, **kwargs) # self._harvester = None self._iam = None self._thread = None def setUp(self): # super().setUp() # self._harvester = Harvester() self._harvester.add_cti_file(self._path + self._filename) self._harvester.update_device_info_list() self._iam = None self._thread = None def tearDown(self): # if self.iam: self.iam.destroy() # self._harvester.reset() # super().tearDown() @property def harvester(self): return self._harvester @property def iam(self): return self._iam @iam.setter def iam(self, value): self._iam = value @property def general_purpose_thread(self): return self._thread @general_purpose_thread.setter def general_purpose_thread(self, value): self._thread = value
def __init__(self, *, vsync=True, logger=None): # self._logger = logger or get_logger(name='harvesters') # super().__init__() # self._mutex = QMutex() profile = True if 'HARVESTER_PROFILE' in os.environ else False self._harvester_core = HarvesterCore(profile=profile, logger=self._logger) self._ia = None # Image Acquirer # self._widget_canvas = Canvas2D(vsync=vsync) self._widget_canvas.create_native() self._widget_canvas.native.setParent(self) # self._action_stop_image_acquisition = None # self._observer_widgets = [] # self._widget_device_list = None self._widget_status_bar = None self._widget_main = None self._widget_about = None self._widget_attribute_controller = None # self._signal_update_statistics.connect(self.update_statistics) self._signal_stop_image_acquisition.connect( self._stop_image_acquisition) self._thread_statistics_measurement = _PyQtThread( parent=self, mutex=self._mutex, worker=self._worker_update_statistics, update_cycle_us=250000) # self._initialize_widgets() # for o in self._observer_widgets: o.update()
class Camera(QtCore.QObject): def __init__(self, parent=None): super().__init__(parent) self.harvester = Harvester() self.acquirer = None def load_cti_from_env(self): if arch.is_64bits: env_name = "GENICAM_GENTL64_PATH" else: env_name = "GENICAM_GENTL32_PATH" genicam_paths = os.environ[env_name].split(os.pathsep) cti_files = glob.glob(os.path.join(genicam_paths, "*.cti")) for cti in cti_files: self.harvester.add_cti_file(cti) def reload_device(self): self.harvester.update_device_info_list() def list_devices(self, reload=False) -> DeviceInfoList: if reload: self.reload_device() return self.harvester.device_info_list def use_device(self, cam_id, cfg_file): devices = self.list_devices() self.acquirer = self.harvester.create_image_acquirer(id_=cam_id) parser = configparser.ConfigParser() parser.read(cfg_file) config: dict = parser["DEVICE_CONFIG"] for k, v in config.items(): node_map: NodeMap = self.acquirer.device.node_map
def __init__(self, *, logger=None): # self._logger = logger or get_logger(name=__name__) # super().__init__() # self._mutex = QMutex() profile = True if 'HARVESTER_PROFILE' in os.environ else False self._harvester_core = HarvesterCore(profile=profile, logger=self._logger) self._iam = None # Image Acquisition Manager self._widget_canvas = Canvas() self._widget_canvas.set_shaders() # Pass custom shares if needed. self._widget_canvas.create_native() self._widget_canvas.native.setParent(self) # self._action_stop_image_acquisition = None # self._observer_widgets = [] # self._widget_device_list = None self._widget_status_bar = None self._widget_main = None self._widget_about = None self._widget_attribute_controller = None # self._signal_update_statistics.connect(self.update_statistics) self._signal_stop_image_acquisition.connect( self._stop_image_acquisition) # self._initialize_widgets() # for o in self._observer_widgets: o.update() self._is_going_to_terminate = False
def __init__(self): # super().__init__() # self._mutex = QMutex() self._harvester_core = HarvesterCore( frontend=self, profile=False, parent=self ) self._iam = None # Image Acquisition Manager self._widget_canvas = Canvas() self._widget_canvas.set_shaders() # Pass custom shares if needed. self._widget_canvas.create_native() self._widget_canvas.native.setParent(self) # self._action_stop_image_acquisition = None # self._observer_widgets = [] # self._widget_device_list = None self._widget_status_bar = None self._widget_main = None self._widget_about = None self._widget_attribute_controller = None # self._signal_update_statistics.connect(self.update_statistics) self._signal_stop_image_acquisition.connect(self._stop_image_acquisition) # self._initialize_widgets() # for o in self._observer_widgets: o.update() self._is_going_to_terminate = False
def __init__(self): """ Camera controller for JAI camera devices. This implementation uses Harvester as backend. """ if Controller.harvester_instance is None: Controller.harvester_instance = Harvester() self._harverster = Controller.harvester_instance super(Controller, self).__init__() self.logger = logging.getLogger(__name__) if LOGGING_LEVEL is not None: self.logger.setLevel(LOGGING_LEVEL) self.logger.debug('Starting JAI Camera Controller') try: self._harverster.add_cti_file(CTI_FILE) except LoadLibraryException: raise LoadLibraryException( "Installation path differs from default " "value. Change constant CTI_FILE to " "correct file path.")
def create(observer, sc=None): h = Harvester() h.add_cti_file( "C:\\Program Files\\MATRIX VISION\\mvIMPACT Acquire\\bin\\x64\\mvGenTLProducer.cti" ) h.update_device_info_list() acquirer = h.create_image_acquirer(0) print("create") def on_new_buffer_arrival(): buffer = acquirer.fetch_buffer() print("buffer") observer.on_next(buffer) buffer.queue() def dispose(): # scheduler.NewThreadScheduler().schedule(lambda *args: acquirer.stop_image_acquisition()) acquirer.stop_image_acquisition() acquirer.on_new_buffer_arrival = on_new_buffer_arrival acquirer.start_image_acquisition() return Disposable(dispose)
class TestHarvesterCoreBase(unittest.TestCase): name = 'HARVESTER_TEST_TARGET' if name in os.environ: _cti_file = os.getenv(name) else: if is_running_on_windows(): _cti_file = 'C:/Users/z1533tel/dev/genicam/bin/Win64_x64' else: if is_running_on_macos(): _cti_file = '/Users/kznr/dev/genicam/bin/Maci64_x64' else: _cti_file = '/home/vagrant/dev/genicam/bin/Linux64_x64' _cti_file += '/TLSimu.cti' sys.path.append(_cti_file) def __init__(self, *args, **kwargs): # super().__init__(*args, **kwargs) # self._harvester = None self._ia = None self._thread = None self._logger = get_logger(name='harvesters', level=DEBUG) def setUp(self): # super().setUp() # self._harvester = Harvester(logger=self._logger) self._harvester.add_cti_file(self._cti_file) self._harvester.update_device_info_list() def tearDown(self): # if self.ia: self.ia.destroy() # self._harvester.reset() # self._ia = None # super().tearDown() @property def harvester(self): return self._harvester @property def ia(self): return self._ia @ia.setter def ia(self, value): self._ia = value @property def general_purpose_thread(self): return self._thread @general_purpose_thread.setter def general_purpose_thread(self, value): self._thread = value def is_running_with_default_target(self): return True if 'TLSimu.cti' in self._cti_file else False