Ejemplo n.º 1
0
def get_device_from(factory=None, **kwargs):
    di = pylon.DeviceInfo()
    for key, value in kwargs.items():
        if key == "IpAddress":
            value = socket.gethostbyname(value)
        getattr(di, "Set" + key)(value)
    return get_device_from_info(di, factory)
Ejemplo n.º 2
0
 def __init__(self, serialNumber):
     """
     Initializes a Camera with the given serial number
     """
     self.cam = None
     self.serial = serialNumber
     device_info = py.DeviceInfo()
     device_info.SetSerialNumber(serialNumber)
     self.cam = py.InstantCamera(
         py.TlFactory.GetInstance().CreateDevice(device_info))
     self.lock = Lock()
Ejemplo n.º 3
0
    def test_grab_chunk_image(self):

        # Only look for usb cameras
        info = pylon.DeviceInfo()
        info.SetDeviceClass("BaslerUsb")

        # Create an instant camera object with the first found camera device that matches the specified device class.
        camera = pylon.InstantCamera(
            pylon.TlFactory.GetInstance().CreateFirstDevice(info))

        # Open the camera.
        camera.Open()

        camera.StaticChunkNodeMapPoolSize = camera.MaxNumBuffer.GetValue()

        if genicam.IsWritable(camera.ChunkModeActive):
            camera.ChunkModeActive = True
        else:
            self.fail()

        # Enable time stamp chunks.
        camera.ChunkSelector = "Timestamp"
        camera.ChunkEnable = True

        # Enable CRC checksum chunks.
        camera.ChunkSelector = "PayloadCRC16"
        camera.ChunkEnable = True

        camera.StartGrabbingMax(self.countOfImagesToGrab)

        while camera.IsGrabbing():

            # Wait for an image and then retrieve it. A timeout of 5000 ms is used.
            # RetrieveResult calls the image event handler's OnImageGrabbed method.
            grabResult = camera.RetrieveResult(
                5000, pylon.TimeoutHandling_ThrowException)

            # Check to see if a buffer containing chunk data has been received.
            if pylon.PayloadType_ChunkData != grabResult.PayloadType:
                self.fail()

            # Since we have activated the CRC Checksum feature, we can check
            # the integrity of the buffer first.
            # Note: Enabling the CRC Checksum feature is not a prerequisite for using
            # chunks. Chunks can also be handled when the CRC Checksum feature is deactivated.
            if grabResult.HasCRC() and grabResult.CheckCRC() == False:
                self.fail()

            if not genicam.IsReadable(grabResult.ChunkTimestamp):
                self.fail()

        camera.ChunkModeActive = False
Ejemplo n.º 4
0
    def __init__(self, ip_address='169.254.203.55'):
        info = pylon.DeviceInfo()
        info.SetPropertyValue('IpAddress', ip_address)
        self.camera = pylon.InstantCamera(
            pylon.TlFactory.GetInstance().CreateFirstDevice(info))
        #self.camera.ExposureTimeAbs = 500
        # Grabing Continusely (video) with minimal delay
        self.camera.StartGrabbing(pylon.GrabStrategy_LatestImageOnly)
        self.converter = pylon.ImageFormatConverter()

        #        self.camera.PixelFormat = 'BGR8Packed'

        print(self.camera.PixelFormat())
        # converting to opencv bgr format
        self.converter.OutputPixelFormat = pylon.PixelType_BGR8packed
        self.converter.OutputBitAlignment = pylon.OutputBitAlignment_MsbAligned
        print('Connected')
Ejemplo n.º 5
0
    async def _connect_internal(self):
        """Connect to a camera uid is serial number
        """
        info = pylon.DeviceInfo()
        info.SetSerialNumber(self.uid)
        cam = pylon.InstantCamera(
            pylon.TlFactory.GetInstance().CreateFirstDevice(info))
        cam.Open()
        # reverse Y so that image in ds9 displays correctly
        cam.ReverseY = True
        cam.PixelFormat = "Mono12"
        cam.Gain = cam.Gain.Min
        cam.Width = cam.Width.Max
        cam.Height = cam.Height.Max
        cam.BinningHorizontal = 1
        cam.BinningVertical = 1
        cam.BinningVerticalMode = "Sum"
        cam.BinningHorizontalMode = "Sum"

        self.device = cam
Ejemplo n.º 6
0
# Load Yolo
net = cv2.dnn.readNet("yolov3.weights", "yolov3.cfg")
classes = []
with open("coco.names", "r") as f:
    classes = [line.strip() for line in f.readlines()]

layer_names = net.getLayerNames()
output_layers = [layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers()]
colors = np.random.uniform(0, 255, size=(len(classes), 3))

# conecting to the first available camera
#camera = pylon.InstantCamera(pylon.TlFactory.GetInstance().CreateFirstDevice())

# connecting to the camera with specific IP
ip_address = '192.168.3.110'
info = pylon.DeviceInfo()
info.SetPropertyValue('IpAddress', ip_address)
camera = pylon.InstantCamera(
    pylon.TlFactory.GetInstance().CreateFirstDevice(info))

# Set Inter-Packet Delay in the Transport Layer to control bandwidth of camera. If not set it properly, It will fail to grab the image.
camera.Open()
camera.GevSCPD.SetValue(9000)  # Set Inter-Packet Delay (In tick)

# Grabing Continusely (video)
camera.StartGrabbing(pylon.GrabStrategy_LatestImageOnly)
converter = pylon.ImageFormatConverter()

# converting to opencv bgr format
converter.OutputPixelFormat = pylon.PixelType_BGR8packed
converter.OutputBitAlignment = pylon.OutputBitAlignment_MsbAligned
Ejemplo n.º 7
0
def get_class_and_filter():
    device_class = "BaslerCamEmu"
    di = pylon.DeviceInfo()
    di.SetDeviceClass(device_class)
    return device_class, [di]
    while True:
        if cameraArray.IsGrabbing():
            for camera in cameraArray:
                camera.ExecuteSoftwareTrigger()
        time.sleep(1 / float(triggerRate))


try:
    # number of images to grab from each camera
    numberOfImages = 10
    # framerate to trigger at
    frameRate = 10

    # for demo purposes, we will only look for certain types of cameras
    filters = list()
    filter1 = pylon.DeviceInfo()
    filter1.SetDeviceClass("BaslerUsb")
    filters.append(filter1)

    # detect and enumerate devices into a device info list
    tlFactory = pylon.TlFactory.GetInstance()
    devices = tlFactory.EnumerateDevices(filters)

    # We will use however many cameras are found
    numberOfCameras = len(devices)

    # The InstantCameraArray is generic (interface agnostic)
    # It encapsulates the physical camera and driver into one convinient object
    cameras = pylon.InstantCameraArray(numberOfCameras)

    # Attach each camera in the array to a physical device
    def test_grab_events(self):
        print("test_grab_event")
        self.assertTrue(True)
        # Create an example event handler. In the present case, we use one single camera handler for handling multiple camera events.
        # The handler prints a message for each received event.
        handler1 = SampleCameraEventHandler()

        # Create another more generic event handler printing out information about the node for which an event callback
        # is fired.
        handler2 = CameraEventPrinter()
        # Only look for cameras supported by Camera_t
        info = pylon.DeviceInfo()
        # info.SetDeviceClass( ## fetch deviceclass from environment ##);
        info.SetDeviceClass("BaslerUsb")

        # Create an instant camera object with the first found camera device matching the specified device class.
        camera = pylon.InstantCamera(
            pylon.TlFactory.GetInstance().CreateFirstDevice(info))

        # Register the standard configuration event handler for enabling software triggering.
        # The software trigger configuration handler replaces the default configuration
        # as all currently registered configuration handlers are removed by setting the registration mode to RegistrationMode_ReplaceAll.
        camera.RegisterConfiguration(pylon.SoftwareTriggerConfiguration(),
                                     pylon.RegistrationMode_ReplaceAll,
                                     pylon.Cleanup_Delete)

        # For demonstration purposes only, add sample configuration event handlers to print out information
        # about camera use and image grabbing.
        # camera.RegisterConfiguration(ConfigurationEventPrinter(), pylon.RegistrationMode_Append,
        #                            pylon.Cleanup_Delete)  # Camera use.

        # For demonstration purposes only, register another image event handler.
        camera.RegisterImageEventHandler(SampleImageEventHandler(),
                                         pylon.RegistrationMode_Append,
                                         pylon.Cleanup_Delete)

        # Camera event processing must be activated first, the default is off.
        camera.GrabCameraEvents = True

        # Register an event handler for the Exposure End event. For each event type, there is a "data" node
        # representing the event. The actual data that is carried by the event is held by child nodes of the
        # data node. In the case of the Exposure End event, the child nodes are EventExposureEndFrameID and EventExposureEndTimestamp.
        # The CSampleCameraEventHandler demonstrates how to access the child nodes within
        # a callback that is fired for the parent data node.
        # The user-provided ID eMyExposureEndEvent can be used to distinguish between multiple events (not shown).
        camera.RegisterCameraEventHandler(handler1, "EventExposureEndData",
                                          eMyExposureEndEvent,
                                          pylon.RegistrationMode_ReplaceAll,
                                          pylon.Cleanup_None)

        # The handler is registered for both, the EventExposureEndFrameID and the EventExposureEndTimestamp
        # node. These nodes represent the data carried by the Exposure End event.
        # For each Exposure End event received, the handler will be called twice, once for the frame ID, and
        # once for the time stamp.
        camera.RegisterCameraEventHandler(handler2, "EventExposureEndFrameID",
                                          eMyExposureEndEvent,
                                          pylon.RegistrationMode_Append,
                                          pylon.Cleanup_None)
        camera.RegisterCameraEventHandler(handler2,
                                          "EventExposureEndTimestamp",
                                          eMyExposureEndEvent,
                                          pylon.RegistrationMode_Append,
                                          pylon.Cleanup_None)

        # Open the camera for setting parameters.
        camera.Open()

        camera.ExposureTime.Value = camera.ExposureTime.Min

        # Check if the device supports events.
        if not genicam.IsAvailable(camera.EventSelector):
            raise genicam.RuntimeException(
                "The device doesn't support events.")

        # Enable sending of Exposure End events.
        # Select the event to receive.
        camera.EventSelector = "ExposureEnd"
        # Enable it.
        camera.EventNotification = "On"

        # Start the grabbing of c_countOfImagesToGrab images.
        camera.StartGrabbingMax(self.countOfImagesToGrab)

        # Camera.StopGrabbing() is called automatically by the RetrieveResult() method
        # when c_countOfImagesToGrab images have been retrieved.
        while camera.IsGrabbing():
            # Execute the software trigger. Wait up to 1000 ms for the camera to be ready for trigger.
            if camera.WaitForFrameTriggerReady(
                    100, pylon.TimeoutHandling_ThrowException):
                camera.ExecuteSoftwareTrigger()

            # Retrieve grab results and notify the camera event and image event handlers.
            grabResult = camera.RetrieveResult(100)
            # Nothing to do here with the grab result, the grab results are handled by the registered event handler.

        # Disable sending Exposure End events.
        camera.EventSelector = "ExposureEnd"
        camera.EventNotification = "Off"
        camera.Close()