Beispiel #1
0
        // Callback called when a frame is done.
        static void FrameDoneCB(ref tFrame pFrame, ref tCamera Camera)
        {
            GCHandle pFrame1 = GCHandle.Alloc(Camera.Frame, GCHandleType.Pinned);

            tFrameCallback FrameCB = new tFrameCallback(FrameDummyCB);

            // If the frame was completed, re-enqueue it.
            if (pFrame.Status != tErr.eErrUnplugged && pFrame.Status != tErr.eErrCancelled)
            {
                Pv.CaptureQueueFrame(Camera.Handle, pFrame1.AddrOfPinnedObject(), FrameCB);
            }
        }
Beispiel #2
0
        // Start streaming frames.
        static bool DoStream(ref tCamera Camera)
        {
            tErr           Err;
            UInt32         FrameCount = 0;
            GCHandle       pFrame     = GCHandle.Alloc(Camera.Frame, GCHandleType.Pinned);
            tFrameCallback FrameCB    = new tFrameCallback(FrameDummyCBStream);
            uint           timeout    = 1000;

            // Adjust packet for optimal preformance.
            Pv.CaptureAdjustPacketSize(Camera.Handle, 8228);

            Console.WriteLine("Streaming has started...");

            // Set the camera in acquisition mode.
            if (((Err = Pv.CaptureStart(Camera.Handle)) == 0))
            {
                if ((Pv.CommandRun(Camera.Handle, "AcquisitionStart")) != 0)
                {
                    // If that fails, reset the camera to non capture mode.
                    Pv.CaptureEnd(Camera.Handle);
                    Console.WriteLine("PvCommandRun() failed!");
                    return(false);
                }
                else
                {
                    // Stream for a total of 30 frames.
                    while (FrameCount < 100)
                    {
                        if (Pv.CaptureQueueFrame(Camera.Handle, pFrame.AddrOfPinnedObject(), FrameCB) == 0)
                        {
                            Pv.CaptureWaitForFrameDone(Camera.Handle, pFrame.AddrOfPinnedObject(), timeout);
                            FrameCount++;
                        }
                    }
                    // After the 30 frames, stop streaming.
                    CameraStop(ref Camera);
                    Console.WriteLine("Streaming stopped.");
                    return(true);
                }
            }
            else
            {
                Console.WriteLine("PvCaptureStart() failed with error code {0}.", Err);
                return(false);
            }
        }
Beispiel #3
0
        // Snap a frame from the camera.
        static bool CameraSnap(ref tCamera Camera)
        {
            bool           result;
            GCHandle       pFrame  = GCHandle.Alloc(Camera.Frame, GCHandleType.Pinned);
            tFrameCallback FrameCB = new tFrameCallback(FrameDummyCB);

            // Queue the frame.
            if (Pv.CaptureQueueFrame(Camera.Handle, pFrame.AddrOfPinnedObject(), FrameCB) == 0)
            {
                Console.WriteLine("Triggering the camera ...");

                // Trigger the capture.
                if (Pv.CommandRun(Camera.Handle, "FrameStartTriggerSoftware") == 0)
                {
                    Console.WriteLine("Waiting for the frame to be done ...");

                    // Wait for the frame to be returned.
                    while (Pv.CaptureWaitForFrameDone(Camera.Handle, pFrame.AddrOfPinnedObject(), 10) == tErr.eErrTimeout)
                    {
                        Console.WriteLine("Still waiting ...");
                    }

                    // Copy the frame structure back in the frame we have.
                    Camera.Frame = (tFrame)Marshal.PtrToStructure(pFrame.AddrOfPinnedObject(), typeof(tFrame));

                    // Check the status flag.
                    if (!(result = (Camera.Frame.Status == tErr.eErrSuccess)))
                    {
                        Console.WriteLine("Frame captured un-succesfully {0}", Camera.Frame.Status);
                    }
                }
                else
                {
                    Pv.CaptureQueueClear(Camera.Handle);
                    result = false;
                }
            }
            else
            {
                result = false;
            }

            pFrame.Free();

            return(result);
        }
        internal bool QueueFrame(IntPtr framePointer, tFrameCallback callback)
        {
            if (!camera.HasValue)
            {
                throw new PvException(tErr.eErrUnavailable);
            }
            tErr error;

            lock (serial) {
                error = Pv.CaptureQueueFrame(camera.Value, framePointer, callback);
            }
            if (error != tErr.eErrSuccess)
            {
                return(false);
            }
            return(true);
        }
Beispiel #5
0
        // Snap a frame from the camera.
        static bool CameraSnap(ref tCamera Camera)
        {
            bool           result;
            GCHandle       pFrame  = GCHandle.Alloc(Camera.Frame, GCHandleType.Pinned);
            tFrameCallback FrameCB = new tFrameCallback(FrameDummyCB);

            // Adjust packet for optimal preformance.
            Pv.CaptureAdjustPacketSize(Camera.Handle, 8228);

            // Queue the frame.
            if (Pv.CaptureQueueFrame(Camera.Handle, pFrame.AddrOfPinnedObject(), FrameCB) == 0)
            {
                // Trigger the capture.
                if (Pv.CommandRun(Camera.Handle, "FrameStartTriggerSoftware") == 0)
                {
                    // Then wait for the frame to be returned.
                    if (Pv.CaptureWaitForFrameDone(Camera.Handle, pFrame.AddrOfPinnedObject(), 0) == 0)
                    {
                        // Check the status flag.
                        if (!(result = (Camera.Frame.Status == tErr.eErrSuccess)))
                        {
                            Console.WriteLine("Frame captured un-succesfully {0}.", Camera.Frame.Status);
                        }
                    }
                    else
                    {
                        Pv.CaptureQueueClear(Camera.Handle);
                        result = false;
                    }
                }
                else
                {
                    Pv.CaptureQueueClear(Camera.Handle);
                    result = false;
                }
            }
            else
            {
                result = false;
            }

            pFrame.Free();

            return(result);
        }
Beispiel #6
0
        // Snap a frame.
        static bool DoSnap(ref tCamera Camera)
        {
            GCHandle       pFrame  = GCHandle.Alloc(Camera.Frame, GCHandleType.Pinned);
            tFrameCallback FrameCB = new tFrameCallback(FrameDummyCBSnap);
            uint           timeout = 1000;

            // Set the camera is acquisition mode.
            if ((Pv.CaptureStart(Camera.Handle)) == 0)
            {
                // Set the acquisition mode to continuous.
                if ((Pv.CommandRun(Camera.Handle, "AcquisitionStart")) != 0)
                {
                    // If that fails,reset the camera to non capture mode.
                    Pv.CaptureEnd(Camera.Handle);
                    return(false);
                }
                else
                {
                    bool failed = false;

                    // Enqueue the single frame.
                    if (Pv.CaptureQueueFrame(Camera.Handle, pFrame.AddrOfPinnedObject(), FrameCB) == 0)
                    {
                        Console.WriteLine("Waiting for the frame...");
                        failed = Pv.CaptureWaitForFrameDone(Camera.Handle, pFrame.AddrOfPinnedObject(), timeout) != 0;
                        Console.WriteLine("Frame is done...");
                        Console.WriteLine("Snapping done.");
                    }
                    else
                    {
                        failed = true;
                    }

                    Pv.CommandRun(Camera.Handle, "AcquisitionStop");
                    Pv.CaptureEnd(Camera.Handle);
                    return(!failed);
                }
            }
            else
            {
                return(false);
            }
        }
Beispiel #7
0
        // Snap a frame from the camera.
        static bool CameraSnap()
        {
            bool           result;
            GCHandle       pFrame  = GCHandle.Alloc(GCamera.Frame, GCHandleType.Pinned);
            tFrameCallback FrameCB = new tFrameCallback(FrameDummyCB);

            // Queue the frame.
            if (Pv.CaptureQueueFrame(GCamera.Handle, pFrame.AddrOfPinnedObject(), FrameCB) == 0)
            {
                // Trigger the capture.

                Console.WriteLine("Waiting for a frame ...");

                // Wait for the frame to be returned.
                while (Pv.CaptureWaitForFrameDone(GCamera.Handle, pFrame.AddrOfPinnedObject(), 1500) == tErr.eErrTimeout)
                {
                    if (close == false)
                    {
                        Console.WriteLine("Still waiting ...");
                    }
                    else
                    {
                        break;
                    }
                }
                // Copy the frame structure back in the frame we have.
                GCamera.Frame = (tFrame)Marshal.PtrToStructure(pFrame.AddrOfPinnedObject(), typeof(tFrame));

                // Check the status flag.
                if (!(result = (GCamera.Frame.Status == tErr.eErrSuccess)))
                {
                    Console.WriteLine("Frame captured un-succesfully {0}", GCamera.Frame.Status);
                }
            }
            else
            {
                result = false;
            }

            pFrame.Free();

            return(result);
        }
Beispiel #8
0
 public Camera(tCameraInfo cameraInfo)
 {
     this.cameraInfo = cameraInfo;
     callback = OnFrameReady;
 }
Beispiel #9
0
 public static extern tErr CaptureQueueFrame(UInt32 Camera, [In, Out] IntPtr Frame, tFrameCallback Callback);
        // Setup the camera up for streaming.
        static bool CameraStart()
        {
            tFrameCallback       lFrameCB = new tFrameCallback(FrameDoneCB);
            tCameraEventCallback lEventCB = new tCameraEventCallback(EventDone);
            UInt32 FrameSize = 0;
            IntPtr Context   = IntPtr.Zero;


            if (Pv.AttrExists(GCamera.Handle, "EventsEnable1") == tErr.eErrNotFound)
            {
                Console.WriteLine("This camera does not support event notifications.");
                return(false);
            }

            // Adjust packet size for optimal performance.
            Pv.CaptureAdjustPacketSize(GCamera.Handle, 8228);

            // Determines how big the frame buffers should be.
            if (Pv.AttrUint32Get(GCamera.Handle, "TotalBytesPerFrame", ref FrameSize) == 0)
            {
                tFrame   Frame   = new tFrame();
                byte[]   Buffer  = new byte[FrameSize];
                GCHandle pBuffer = GCHandle.Alloc(Buffer, GCHandleType.Pinned);

                // Set the frame's fields.
                // Handle to the Camera.
                Frame.Context.Field0 = new IntPtr(GCamera.Handle);
                // Address of the pinned object.
                Frame.ImageBuffer = pBuffer.AddrOfPinnedObject();
                // Buffer size.
                Frame.ImageBufferSize = FrameSize;

                // Setup the event channel.
                Pv.AttrUint32Set(GCamera.Handle, "EventsEnable1", 0);
                Pv.AttrEnumSet(GCamera.Handle, "EventSelector", "AcquisitionStart");
                Pv.AttrEnumSet(GCamera.Handle, "EventNotification", "On");
                Pv.AttrEnumSet(GCamera.Handle, "EventSelector", "AcquisitionEnd");
                Pv.AttrEnumSet(GCamera.Handle, "EventNotification", "On");
                Pv.AttrEnumSet(GCamera.Handle, "EventSelector", "FrameTrigger");
                Pv.AttrEnumSet(GCamera.Handle, "EventNotification", "On");


                if (Pv.CameraEventCallbackRegister(GCamera.Handle, lEventCB, Context) != tErr.eErrSuccess)
                {
                    Console.WriteLine("There was an error accessing the driver.");
                    return(false);
                }

                // Start the capture mode.
                if (Pv.CaptureStart(GCamera.Handle) == 0)
                {
                    if (Pv.AttrFloat32Set(GCamera.Handle, "FrameRate", 5) == 0)
                    {
                        // Set the camera in continuous acquisition mode,and in "Freerun".
                        if (Pv.AttrEnumSet(GCamera.Handle, "FrameStartTriggerMode", "FixedRate") == 0)
                        {
                            // Set the acquisition mode into continuous.
                            if (Pv.CommandRun(GCamera.Handle, "AcquisitionStart") != 0)
                            {
                                // If that fails, reset the camera to non-capture mode.
                                Pv.CaptureEnd(GCamera.Handle);

                                Console.WriteLine("Failed to start.");
                                return(false);
                            }
                            else
                            {
                                // Pin down a copy of the frame structure.
                                GCHandle pFrame = GCHandle.Alloc(Frame, GCHandleType.Pinned);

                                // Enqueue the frame.
                                Pv.CaptureQueueFrame(GCamera.Handle, pFrame.AddrOfPinnedObject(), lFrameCB);

                                return(true);
                            }
                        }
                        else
                        {
                            return(false);
                        }
                    }
                    else
                    {
                        return(false);
                    }
                }
                else
                {
                    return(false);
                }
            }
            else
            {
                return(false);
            }
        }
 internal bool QueueFrame(IntPtr framePointer, tFrameCallback callback)
 {
     if (!camera.HasValue) {
         throw new PvException(tErr.eErrUnavailable);
     }
     tErr error;
     lock (serial) {
         error = Pv.CaptureQueueFrame(camera.Value, framePointer, callback);
     }
     if (error != tErr.eErrSuccess) {
         return false;
     }
     return true;
 }
Beispiel #12
0
 public Camera(tCameraInfo cameraInfo)
 {
     this.heartbeatTimer = new Timer(Heartbeat, null, 100, 100);
     this.cameraInfo = cameraInfo;
     this.callback = new tFrameCallback(OnFrameReady);
 }
Beispiel #13
0
 public Camera(tCameraInfo cameraInfo)
 {
     this.cameraInfo = cameraInfo;
     callback        = OnFrameReady;
 }