Ejemplo n.º 1
0
        private void Mytest(object sender, EventArgs e)
        {
            IGrabResult grabResult = m_camera.StreamGrabber.RetrieveResult(500, TimeoutHandling.ThrowException);

            using (grabResult)
            {
                // Image grabbed successfully?
                if (grabResult.GrabSucceeded)
                {
                    // Access the image data.
                    Console.WriteLine("SizeX: {0}", grabResult.Width);
                    Console.WriteLine("SizeY: {0}", grabResult.Height);
                    byte[] buffer = grabResult.PixelData as byte[];
                    IntPtr ptr    = Marshal.AllocHGlobal(buffer.Length);
                    Marshal.Copy(buffer, 0, ptr, buffer.Length);

                    int i = mChipDetection.myfind(ptr, (UInt32)grabResult.Width, (UInt32)grabResult.Height);
                    lblDebug.Text  = string.Empty;
                    lblDebug.Text += i.ToString() + "\r\n";


                    //mChipDetection.savebuffer(ptr, (UInt32)grabResult.Width, (UInt32)grabResult.Height);

                    // Display the grabbed image.
                    ImageWindow.DisplayImage(0, grabResult);
                }
                else
                {
                    Console.WriteLine("Error: {0} {1}", grabResult.ErrorCode, grabResult.ErrorDescription);
                }
            }
        }
Ejemplo n.º 2
0
        // Example of an image event handler.
        static void OnImageGrabbed(Object sender, ImageGrabbedEventArgs e)
        {
            // The grab result is automatically disposed when the event call back returns.
            // The grab result can be cloned using IGrabResult.Clone if you want to keep a copy of it (not shown in this sample).
            IGrabResult grabResult = e.GrabResult;

            // Image grabbed successfully?
            if (grabResult.GrabSucceeded)
            {
                // Access the image data.
                Console.WriteLine("SizeX: {0}", grabResult.Width);
                Console.WriteLine("SizeY: {0}", grabResult.Height);
                byte[] buffer = grabResult.PixelData as byte[];
                Console.WriteLine("Gray value of first pixel: {0}", buffer[0]);
                Console.WriteLine("");

                // Display the grabbed image.
                ImageWindow.DisplayImage(0, grabResult);
                ImagePersistence.Save(ImageFileFormat.Bmp, "test.bmp", grabResult);
            }
            else
            {
                Console.WriteLine("Error: {0} {1}", grabResult.ErrorCode, grabResult.ErrorDescription);
            }
        }
Ejemplo n.º 3
0
        public void GrabImage(string filename)
        {
            camera.StreamGrabber.Start();

            IGrabResult grabResult = camera.StreamGrabber.RetrieveResult(5000, TimeoutHandling.ThrowException);

            using (grabResult)
            {
                // Image grabbed successfully?
                if (grabResult.GrabSucceeded)
                {
                    // Access the image data.
                    Console.WriteLine("SizeX: {0}", grabResult.Width);
                    Console.WriteLine("SizeY: {0}", grabResult.Height);
                    byte[] buffer = grabResult.PixelData as byte[];
                    Console.WriteLine("Gray value of first pixel: {0}", buffer[0]);
                    Console.WriteLine("");

                    //####### Display Method 1 ##############
                    // Display the grabbed image.
                    ImageWindow.DisplayImage(0, grabResult);

                    //####### Display Method 2 : Convert to C# Image #########
                    Bitmap bmp = ConvertArrayToImage(buffer, grabResult.Width, grabResult.Height, grabResult);
                    bmp.RotateFlip(RotateFlipType.Rotate90FlipNone);
                    bmp.Save(filename);
                }
                else
                {
                    Console.WriteLine("Error: {0} {1}", grabResult.ErrorCode, grabResult.ErrorDescription);
                    MessageBox.Show("Error : " + grabResult.ErrorDescription);
                    MessageBox.Show("test");
                }
            }
            camera.StreamGrabber.Stop();
        }
Ejemplo n.º 4
0
        static void AutoGainOnce(Camera camera)
        {
            // Check whether the gain auto function is available.
            if (!camera.Parameters[PLCamera.GainAuto].IsWritable)
            {
                Console.WriteLine("The camera does not support Gain Auto.");
                return;
            }

            // Maximize the grabbed image area of interest (Image AOI).
            camera.Parameters[PLCamera.OffsetX].TrySetValue(camera.Parameters[PLCamera.OffsetX].GetMinimum());
            camera.Parameters[PLCamera.OffsetX].TrySetValue(camera.Parameters[PLCamera.OffsetY].GetMinimum());
            camera.Parameters[PLCamera.Width].SetValue(camera.Parameters[PLCamera.Width].GetMaximum());
            camera.Parameters[PLCamera.Height].SetValue(camera.Parameters[PLCamera.Height].GetMaximum());

            // Set the Auto Function ROI for luminance statistics.
            // We want to use ROI1 for gathering the statistics.
            if (camera.Parameters[autoFunctionAOIROIUseBrightness].IsWritable)
            {
                camera.Parameters[regionSelector].SetValue(regionSelectorValue1);
                camera.Parameters[autoFunctionAOIROIUseBrightness].SetValue(true);  // ROI 1 is used for brightness control
                camera.Parameters[regionSelector].SetValue(regionSelectorValue2);
                camera.Parameters[autoFunctionAOIROIUseBrightness].SetValue(false); // ROI 2 is not used for brightness control
            }
            camera.Parameters[regionSelector].SetValue(regionSelectorValue1);
            camera.Parameters[regionSelectorOffsetX].SetValue(camera.Parameters [PLCamera.OffsetX].GetMinimum());
            camera.Parameters[regionSelectorOffsetY].SetValue(camera.Parameters [PLCamera.OffsetY].GetMinimum());
            camera.Parameters[regionSelectorWidth].SetValue(camera.Parameters[PLCamera.Width].GetMaximum());
            camera.Parameters[regionSelectorHeight].SetValue(camera.Parameters[PLCamera.Height].GetMaximum());

            // We are going to try GainAuto = Once.
            Console.WriteLine("Trying 'GainAuto = Once'.");
            if (camera.GetSfncVersion() < sfnc2_0_0) // Handling for older cameras
            {
                // Set the target value for luminance control. The value is always expressed
                // as an 8 bit value regardless of the current pixel data output format,
                // i.e., 0 -> black, 255 -> white.
                camera.Parameters[PLCamera.AutoTargetValue].SetValue(80);

                Console.WriteLine("Initial Gain = {0}", camera.Parameters[PLCamera.GainRaw].GetValue());
                // Set the gain ranges for luminance control.
                camera.Parameters[PLCamera.AutoGainRawLowerLimit].SetValue(camera.Parameters[PLCamera.GainRaw].GetMinimum());
                camera.Parameters[PLCamera.AutoGainRawUpperLimit].SetValue(camera.Parameters[PLCamera.GainRaw].GetMaximum());
            }
            else // Handling for newer cameras (using SFNC 2.0, e.g. USB3 Vision cameras)
            {
                // Set the target value for luminance control.
                // A value of 0.3 means that the target brightness is 30 % of the maximum brightness of the raw pixel value read out from the sensor.
                // A value of 0.4 means 40 % and so forth.
                camera.Parameters[PLCamera.AutoTargetBrightness].SetValue(0.3);

                Console.WriteLine("Initial Gain = {0}", camera.Parameters[PLCamera.Gain].GetValue());
                // Set the gain ranges for luminance control.
                camera.Parameters[PLCamera.AutoGainLowerLimit].SetValue(camera.Parameters[PLCamera.Gain].GetMinimum());
                camera.Parameters[PLCamera.AutoGainUpperLimit].SetValue(camera.Parameters[PLCamera.Gain].GetMaximum());
            }
            camera.Parameters[PLCamera.GainAuto].SetValue(PLCamera.GainAuto.Once);

            // When the "once" mode of operation is selected,
            // the parameter values are automatically adjusted until the related image property
            // reaches the target value. After the automatic parameter value adjustment is complete, the auto
            // function will automatically be set to "off" and the new parameter value will be applied to the
            // subsequently grabbed images.
            int n = 0;

            while (camera.Parameters[PLCamera.GainAuto].GetValue() != PLCamera.GainAuto.Off)
            {
                IGrabResult result = camera.StreamGrabber.GrabOne(5000, TimeoutHandling.ThrowException);
                using (result)
                {
                    // Image grabbed successfully?
                    if (result.GrabSucceeded)
                    {
                        ImageWindow.DisplayImage(1, result);
                    }
                }
                n++;
                //For demonstration purposes only. Wait until the image is shown.
                System.Threading.Thread.Sleep(100);

                //Make sure the loop is exited.
                if (n > 100)
                {
                    throw new TimeoutException("The adjustment of auto gain did not finish.");
                }
            }

            Console.WriteLine("GainAuto went back to 'Off' after {0} frames", n);
            if (camera.GetSfncVersion() < sfnc2_0_0) // Handling for older cameras
            {
                Console.WriteLine("Final Gain = {0}", camera.Parameters[PLCamera.GainRaw].GetValue());
            }
            else // Handling for newer cameras (using SFNC 2.0, e.g. USB3 Vision cameras)
            {
                Console.WriteLine("Final Gain = {0}", camera.Parameters[PLCamera.Gain].GetValue());
            }
        }
Ejemplo n.º 5
0
        static void AutoWhiteBalance(Camera camera)
        {
            // Check whether the Balance White Auto feature is available.
            if (!camera.Parameters[PLCamera.BalanceWhiteAuto].IsWritable)
            {
                Console.WriteLine("The Camera does not support balance white auto.");
                return;
            }

            // Maximize the grabbed area of interest (Image AOI).
            camera.Parameters[PLCamera.OffsetX].TrySetValue(camera.Parameters[PLCamera.OffsetX].GetMinimum());
            camera.Parameters[PLCamera.OffsetY].TrySetValue(camera.Parameters[PLCamera.OffsetY].GetMinimum());
            camera.Parameters[PLCamera.Width].SetValue(camera.Parameters[PLCamera.Width].GetMaximum());
            camera.Parameters[PLCamera.Height].SetValue(camera.Parameters[PLCamera.Height].GetMaximum());

            // Set the Auto Function ROI for white balace statistics.
            // We want to use ROI2 for gathering the statistics.
            if (camera.Parameters [regionSelector].IsWritable)
            {
                camera.Parameters [regionSelector].SetValue(regionSelectorValue1);
                camera.Parameters [autoFunctionAOIROIUseWhiteBalance].SetValue(false); // ROI 1 is not used for white balance control
                camera.Parameters [regionSelector].SetValue(regionSelectorValue2);
                camera.Parameters [autoFunctionAOIROIUseWhiteBalance].SetValue(true);  // ROI 2 is used for white balance control
            }
            camera.Parameters[regionSelector].SetValue(regionSelectorValue2);
            camera.Parameters[regionSelectorOffsetX].SetValue(camera.Parameters [PLCamera.OffsetX].GetMinimum());
            camera.Parameters[regionSelectorOffsetY].SetValue(camera.Parameters [PLCamera.OffsetY].GetMinimum());
            camera.Parameters[regionSelectorWidth].SetValue(camera.Parameters[PLCamera.Width].GetMaximum());
            camera.Parameters[regionSelectorHeight].SetValue(camera.Parameters[PLCamera.Height].GetMaximum());

            Console.WriteLine("Trying 'BalanceWhiteAuto = Once'.");
            Console.WriteLine("Initial balance ratio:");
            camera.Parameters[PLCamera.BalanceRatioSelector].SetValue(PLCamera.BalanceRatioSelector.Red);
            Console.Write("R = {0}  ", camera.Parameters[balanceRatio].GetValue());
            camera.Parameters[PLCamera.BalanceRatioSelector].SetValue(PLCamera.BalanceRatioSelector.Green);
            Console.Write("G = {0}  ", camera.Parameters[balanceRatio].GetValue());
            camera.Parameters[PLCamera.BalanceRatioSelector].SetValue(PLCamera.BalanceRatioSelector.Blue);
            Console.Write("B = {0}  ", camera.Parameters[balanceRatio].GetValue());
            camera.Parameters[PLCamera.BalanceWhiteAuto].SetValue(PLCamera.BalanceWhiteAuto.Once);

            // When the "once" mode of operation is selected,
            // the parameter values are automatically adjusted until the related image property
            // reaches the target value. After the automatic parameter value adjustment is complete, the auto
            // function will automatically be set to "off" and the new parameter value will be applied to the
            // subsequently grabbed images.
            int n = 0;

            while (camera.Parameters[PLCamera.BalanceWhiteAuto].GetValue() != PLCamera.BalanceWhiteAuto.Off)
            {
                IGrabResult result = camera.StreamGrabber.GrabOne(5000, TimeoutHandling.ThrowException);
                using (result)
                {
                    // Image grabbed successfully?
                    if (result.GrabSucceeded)
                    {
                        ImageWindow.DisplayImage(1, result);
                    }
                }
                n++;

                //For demonstration purposes only. Wait until the image is shown.
                System.Threading.Thread.Sleep(100);

                //Make sure the loop is exited.
                if (n > 100)
                {
                    throw new TimeoutException("The adjustment of auto white balance did not finish.");
                }
            }
            Console.WriteLine("BalanceWhiteAuto went back to 'Off' after {0} Frames", n);
            Console.WriteLine("Final balance ratio: ");
            camera.Parameters[PLCamera.BalanceRatioSelector].SetValue(PLCamera.BalanceRatioSelector.Red);
            Console.Write("R = {0}  ", camera.Parameters[balanceRatio].GetValue());
            camera.Parameters[PLCamera.BalanceRatioSelector].SetValue(PLCamera.BalanceRatioSelector.Green);
            Console.Write("G = {0}  ", camera.Parameters[balanceRatio].GetValue());
            camera.Parameters[PLCamera.BalanceRatioSelector].SetValue(PLCamera.BalanceRatioSelector.Blue);
            Console.Write("B = {0}  ", camera.Parameters[balanceRatio].GetValue());
        }
Ejemplo n.º 6
0
        static void AutoExposureContinuous(Camera camera)
        {
            // Check whether the Exposure Auto feature is available.
            if (!camera.Parameters[PLCamera.ExposureAuto].IsWritable)
            {
                Console.WriteLine("The camera does not support Exposure Auto.");
                return;
            }

            // Maximize the grabbed image area of interest (Image AOI).
            camera.Parameters[PLCamera.OffsetX].TrySetValue(camera.Parameters[PLCamera.OffsetX].GetMinimum());
            camera.Parameters[PLCamera.OffsetY].TrySetValue(camera.Parameters[PLCamera.OffsetY].GetMinimum());
            camera.Parameters[PLCamera.Width].SetValue(camera.Parameters[PLCamera.Width].GetMaximum());
            camera.Parameters[PLCamera.Height].SetValue(camera.Parameters[PLCamera.Height].GetMaximum());

            // Set the Auto Function ROI for luminance statistics.
            // We want to use ROI1 for gathering the statistics.
            if (camera.Parameters[autoFunctionAOIROIUseBrightness].IsWritable)
            {
                camera.Parameters[regionSelector].SetValue(regionSelectorValue1);
                camera.Parameters[autoFunctionAOIROIUseBrightness].SetValue(true);  // ROI 1 is used for brightness control
                camera.Parameters[regionSelector].SetValue(regionSelectorValue2);
                camera.Parameters[autoFunctionAOIROIUseBrightness].SetValue(false); // ROI 2 is not used for brightness control
            }
            camera.Parameters[regionSelector].SetValue(regionSelectorValue1);
            camera.Parameters[regionSelectorOffsetX].SetValue(camera.Parameters [PLCamera.OffsetX].GetMinimum());
            camera.Parameters[regionSelectorOffsetY].SetValue(camera.Parameters [PLCamera.OffsetY].GetMinimum());
            camera.Parameters[regionSelectorWidth].SetValue(camera.Parameters[PLCamera.Width].GetMaximum());
            camera.Parameters[regionSelectorHeight].SetValue(camera.Parameters[PLCamera.Height].GetMaximum());

            if (camera.GetSfncVersion() < sfnc2_0_0) // Handling for older cameras
            {
                // Set the target value for luminance control. The value is always expressed
                // as an 8 bit value regardless of the current pixel data output format,
                // i.e., 0 -> black, 255 -> white.
                camera.Parameters[PLCamera.AutoTargetValue].SetValue(80);
            }
            else // Handling for newer cameras (using SFNC 2.0, e.g. USB3 Vision cameras)
            {
                // Set the target value for luminance control.
                // A value of 0.3 means that the target brightness is 30 % of the maximum brightness of the raw pixel value read out from the sensor.
                // A value of 0.4 means 40 % and so forth.
                camera.Parameters[PLCamera.AutoTargetBrightness].SetValue(0.3);
            }

            // Try ExposureAuto = Continuous.
            Console.WriteLine("Trying 'ExposureAuto = Continuous'.");
            Console.WriteLine("Initial Exposure time = {0} us", camera.Parameters[exposureTime].GetValue());
            camera.Parameters[PLCamera.ExposureAuto].SetValue(PLCamera.ExposureAuto.Continuous);

            // When "continuous" mode is selected, the parameter value is adjusted repeatedly while images are acquired.
            // Depending on the current frame rate, the automatic adjustments will usually be carried out for
            // every or every other image, unless the camera's microcontroller is kept busy by other tasks.
            // The repeated automatic adjustment will proceed until the "once" mode of operation is used or
            // until the auto function is set to "off", in which case the parameter value resulting from the latest
            // automatic adjustment will operate unless the value is manually adjusted.
            for (int n = 0; n < 20; n++)    // For demonstration purposes, we will use only 20 images.
            {
                IGrabResult result = camera.StreamGrabber.GrabOne(5000, TimeoutHandling.ThrowException);
                using (result)
                {
                    // Image grabbed successfully?
                    if (result.GrabSucceeded)
                    {
                        ImageWindow.DisplayImage(1, result);
                    }
                }

                //For demonstration purposes only. Wait until the image is shown.
                System.Threading.Thread.Sleep(100);
            }
            camera.Parameters[PLCamera.ExposureAuto].SetValue(PLCamera.ExposureAuto.Off); // Switch off Exposure Auto.

            Console.WriteLine("Final Exposure Time = {0} us", camera.Parameters[exposureTime].GetValue());
        }
Ejemplo n.º 7
0
        internal static void Main()
        {
            // The exit code of the sample application.
            int exitCode = 0;

            try
            {
                // Create a camera object selecting the first camera device found.
                // More constructors are available for selecting a specific camera device.
                using (Camera camera = new Camera())
                {
                    // Change default configuration to enable software triggering.
                    camera.CameraOpened += Configuration.SoftwareTrigger;

                    // Open the camera.
                    camera.Open();

                    // Register image grabbed event to print frame info
                    camera.StreamGrabber.ImageGrabbed += OnImageGrabbed;

                    // DeviceVendorName, DeviceModelName, and DeviceFirmwareVersion are string parameters.
                    Console.WriteLine("Camera Device Information");
                    Console.WriteLine("=========================");
                    Console.WriteLine("Vendor           : {0}", camera.Parameters[PLCamera.DeviceVendorName].GetValue());
                    Console.WriteLine("Model            : {0}", camera.Parameters[PLCamera.DeviceModelName].GetValue());
                    Console.WriteLine("Firmware version : {0}", camera.Parameters[PLCamera.DeviceFirmwareVersion].GetValue());
                    Console.WriteLine("");
                    Console.WriteLine("Camera Device Settings");
                    Console.WriteLine("======================");

                    // Can the camera device be queried whether it is ready to accept the next frame trigger?
                    if (camera.CanWaitForFrameTriggerReady)
                    {
                        // bool for testing if sequencer is available or not
                        bool sequencerAvailable = false;

                        if (camera.GetSfncVersion() < sfnc2_0_0) // Handling for older cameras
                        {
                            if (camera.Parameters[PLCamera.SequenceEnable].IsWritable)
                            {
                                sequencerAvailable = true; //Sequencer is available that is why it is true.

                                // Disable the sequencer before changing parameters.
                                // The parameters under control of the sequencer are locked
                                // when the sequencer is enabled. For a list of parameters
                                // controlled by the sequencer, see the camera User's Manual.
                                camera.Parameters[PLCamera.SequenceEnable].SetValue(false);

                                // Turn configuration mode on
                                if (camera.Parameters[PLCamera.SequenceConfigurationMode].IsWritable)
                                {
                                    camera.Parameters[PLCamera.SequenceConfigurationMode].SetValue(PLCamera.SequenceConfigurationMode.On);
                                }

                                // Maximize the image area of interest (Image AOI).
                                camera.Parameters[PLCamera.OffsetX].TrySetValue(camera.Parameters[PLCamera.OffsetX].GetMinimum());
                                camera.Parameters[PLCamera.OffsetY].TrySetValue(camera.Parameters[PLCamera.OffsetY].GetMinimum());
                                camera.Parameters[PLCamera.Width].SetValue(camera.Parameters[PLCamera.Width].GetMaximum());
                                camera.Parameters[PLCamera.Height].SetValue(camera.Parameters[PLCamera.Height].GetMaximum());

                                // Set the pixel data format.
                                camera.Parameters[PLCamera.PixelFormat].SetValue(PLCamera.PixelFormat.Mono8);

                                // Set up sequence sets.

                                // Configure how the sequence will advance.
                                // 'Auto' refers to the auto sequence advance mode.
                                // The advance from one sequence set to the next will occur automatically with each image acquired.
                                // After the end of the sequence set cycle was reached a new sequence set cycle will start.
                                camera.Parameters[PLCamera.SequenceAdvanceMode].SetValue(PLCamera.SequenceAdvanceMode.Auto);

                                // Our sequence sets relate to three steps (0..2).
                                // In each step we will increase the height of the Image AOI by one increment.
                                camera.Parameters[PLCamera.SequenceSetTotalNumber].SetValue(3);

                                long increments = (camera.Parameters[PLCamera.Height].GetMaximum() - camera.Parameters[PLCamera.Height].GetMinimum()) / camera.Parameters[PLCamera.Height].GetIncrement();

                                // Set the parameters for step 0; quarter height image.
                                camera.Parameters[PLCamera.SequenceSetIndex].SetValue(0);
                                camera.Parameters[PLCamera.Height].SetValue(camera.Parameters[PLCamera.Height].GetIncrement() * (increments / 4) + camera.Parameters[PLCamera.Height].GetMinimum());
                                camera.Parameters[PLCamera.SequenceSetStore].Execute();

                                // Set the parameters for step 1; half height image.
                                camera.Parameters[PLCamera.SequenceSetIndex].SetValue(1);
                                camera.Parameters[PLCamera.Height].SetValue(camera.Parameters[PLCamera.Height].GetIncrement() * (increments / 2) + camera.Parameters[PLCamera.Height].GetMinimum());
                                camera.Parameters[PLCamera.SequenceSetStore].Execute();

                                // Set the parameters for step 2; full height image.
                                camera.Parameters[PLCamera.SequenceSetIndex].SetValue(2);
                                camera.Parameters[PLCamera.Height].SetValue(camera.Parameters[PLCamera.Height].GetIncrement() * (increments) + camera.Parameters[PLCamera.Height].GetMinimum());
                                camera.Parameters[PLCamera.SequenceSetStore].Execute();

                                // Finish configuration
                                if (camera.Parameters[PLCamera.SequenceConfigurationMode].IsWritable)
                                {
                                    camera.Parameters[PLCamera.SequenceConfigurationMode].SetValue(PLCamera.SequenceConfigurationMode.Off);
                                }

                                // Enable the sequencer feature.
                                // From here on you cannot change the sequencer settings anymore.
                                camera.Parameters[PLCamera.SequenceEnable].SetValue(true);

                                // Start the grabbing of countOfImagesToGrab images.
                                camera.StreamGrabber.Start(countOfImagesToGrab);
                            }
                            else
                            {
                                sequencerAvailable = false; // Sequencer not available
                            }
                        }
                        else // Handling for newer cameras (using SFNC 2.0, e.g. USB3 Vision cameras)
                        {
                            if (camera.Parameters[PLCamera.SequencerMode].IsWritable)
                            {
                                sequencerAvailable = true;

                                // Disable the sequencer before changing parameters.
                                // The parameters under control of the sequencer are locked
                                // when the sequencer is enabled. For a list of parameters
                                // controlled by the sequencer, see the camera User's Manual.
                                camera.Parameters[PLCamera.SequencerMode].SetValue(PLCamera.SequencerMode.Off);

                                // Maximize the image area of interest (Image AOI).
                                camera.Parameters[PLCamera.OffsetX].TrySetValue(camera.Parameters[PLCamera.OffsetX].GetMinimum());
                                camera.Parameters[PLCamera.OffsetY].TrySetValue(camera.Parameters[PLCamera.OffsetY].GetMinimum());
                                camera.Parameters[PLCamera.Width].SetValue(camera.Parameters[PLCamera.Width].GetMaximum());
                                camera.Parameters[PLCamera.Height].SetValue(camera.Parameters[PLCamera.Height].GetMaximum());

                                // Set the pixel data format.
                                // This parameter may be locked when the sequencer is enabled.
                                camera.Parameters[PLCamera.PixelFormat].SetValue(PLCamera.PixelFormat.Mono8);

                                // Set up sequence sets and turn sequencer configuration mode on.
                                camera.Parameters[PLCamera.SequencerConfigurationMode].SetValue(PLCamera.SequencerConfigurationMode.On);

                                // Configure how the sequence will advance.

                                // The sequence sets relate to three steps (0..2).
                                // In each step, the height of the Image AOI is doubled.

                                long increments = (camera.Parameters[PLCamera.Height].GetMaximum() - camera.Parameters[PLCamera.Height].GetMinimum()) / camera.Parameters[PLCamera.Height].GetIncrement();

                                long initialSet = camera.Parameters[PLCamera.SequencerSetSelector].GetMinimum();
                                long incSet     = camera.Parameters[PLCamera.SequencerSetSelector].GetIncrement();
                                long curSet     = initialSet;

                                // Set the parameters for step 0; quarter height image.
                                camera.Parameters[PLCamera.SequencerSetSelector].SetValue(initialSet);
                                {
                                    // valid for all sets
                                    // reset on software signal 1;
                                    camera.Parameters[PLCamera.SequencerPathSelector].SetValue(0);
                                    camera.Parameters[PLCamera.SequencerSetNext].SetValue(initialSet);
                                    camera.Parameters[PLCamera.SequencerTriggerSource].SetValue(PLCamera.SequencerTriggerSource.SoftwareSignal1);
                                    // advance on Frame Start
                                    camera.Parameters[PLCamera.SequencerPathSelector].SetValue(1);
                                    camera.Parameters[PLCamera.SequencerTriggerSource].SetValue(PLCamera.SequencerTriggerSource.FrameStart);
                                }
                                camera.Parameters[PLCamera.SequencerSetNext].SetValue(curSet + incSet);

                                // Set the parameters for step 0; quarter height image.
                                camera.Parameters[PLCamera.Height].SetValue(camera.Parameters[PLCamera.Height].GetIncrement() * (increments / 4) + camera.Parameters[PLCamera.Height].GetMinimum());
                                camera.Parameters[PLCamera.SequencerSetSave].Execute();

                                // Set the parameters for step 1; half height image.
                                curSet += incSet;
                                camera.Parameters[PLCamera.SequencerSetSelector].SetValue(curSet);
                                // advance on Frame Start to next set
                                camera.Parameters[PLCamera.SequencerSetNext].SetValue(curSet + incSet);
                                camera.Parameters[PLCamera.Height].SetValue(camera.Parameters[PLCamera.Height].GetIncrement() * (increments / 2) + camera.Parameters[PLCamera.Height].GetMinimum());
                                camera.Parameters[PLCamera.SequencerSetSave].Execute();

                                // Set the parameters for step 2; full height image.
                                curSet += incSet;
                                camera.Parameters[PLCamera.SequencerSetSelector].SetValue(curSet);
                                // advance on Frame End to initial set,
                                camera.Parameters[PLCamera.SequencerSetNext].SetValue(initialSet); // terminates sequence definition
                                                                                                   // full height
                                camera.Parameters[PLCamera.Height].SetValue(camera.Parameters[PLCamera.Height].GetIncrement() * increments + camera.Parameters[PLCamera.Height].GetMinimum());
                                camera.Parameters[PLCamera.SequencerSetSave].Execute();

                                // Enable the sequencer feature.
                                // From here on you cannot change the sequencer settings anymore.
                                camera.Parameters[PLCamera.SequencerConfigurationMode].SetValue(PLCamera.SequencerConfigurationMode.Off);
                                camera.Parameters[PLCamera.SequencerMode].SetValue(PLCamera.SequencerMode.On);

                                // Start the grabbing of countOfImagesToGrab images.
                                camera.StreamGrabber.Start(countOfImagesToGrab);
                            }
                            else
                            {
                                sequencerAvailable = false; // Sequencer not available
                            }
                        }

                        if (sequencerAvailable)
                        {
                            IGrabResult result;
                            // Camera.StopGrabbing() is called automatically by the RetrieveResult() method
                            // when countOfImagesToGrab images have been retrieved.
                            while (camera.StreamGrabber.IsGrabbing)
                            {
                                // Execute the software trigger. Wait up to 1000 ms for the camera to be ready for trigger.
                                if (camera.WaitForFrameTriggerReady(1000, TimeoutHandling.ThrowException))
                                {
                                    camera.ExecuteSoftwareTrigger();

                                    // Wait for an image and then retrieve it. A timeout of 5000 ms is used.
                                    result = camera.StreamGrabber.RetrieveResult(5000, TimeoutHandling.ThrowException);

                                    using (result)
                                    {
                                        // Image grabbed successfully?
                                        if (result.GrabSucceeded)
                                        {
                                            // Display the grabbed image.
                                            ImageWindow.DisplayImage(1, result);
                                        }
                                        else
                                        {
                                            Console.WriteLine("Error code:{0} Error description:{1}", result.ErrorCode, result.ErrorDescription);
                                        }
                                    }
                                }

                                // Wait for user input.
                                Console.WriteLine("Press Enter to continue.");
                                while (camera.StreamGrabber.IsGrabbing && Console.ReadKey().Key != ConsoleKey.Enter)
                                {
                                    ;
                                }
                            }

                            // Disable the sequencer.
                            if (camera.GetSfncVersion() < sfnc2_0_0) // Handling for older cameras
                            {
                                camera.Parameters[PLCamera.SequenceEnable].SetValue(false);
                            }
                            else // Handling for newer cameras (using SFNC 2.0, e.g. USB3 Vision cameras)
                            {
                                camera.Parameters[PLCamera.SequencerMode].SetValue(PLCamera.SequencerMode.Off);
                            }
                        }
                        else
                        {
                            Console.WriteLine("The sequencer feature is not available for this camera.");
                        }
                    }
                    else
                    {
                        Console.WriteLine("This sample can only be used with cameras that can be queried whether they are ready to accept the next frame trigger.");
                    }

                    // Close the camera.
                    camera.Close();
                }
            }
            catch (Exception e)
            {
                // Error handling.
                Console.Error.WriteLine("Exception: {0}", e.Message);
                exitCode = 1;
            }

            // Comment the following two lines to disable waiting on exit.
            Console.Error.WriteLine("\nPress enter to exit.");
            Console.ReadLine();

            Environment.Exit(exitCode);
        }
Ejemplo n.º 8
0
        internal static void Main()
        {
            // The exit code of the sample application.
            int exitCode = 0;

            try
            {
                // Create a camera object that selects the first camera device found.
                // More constructors are available for selecting a specific camera device.
                // For multicast only look for GigE cameras here.
                using (Camera camera = new Camera(DeviceType.GigE, CameraSelectionStrategy.FirstFound))
                {
                    // Print the model name of the camera.
                    Console.WriteLine("Using camera {0}.", camera.CameraInfo[CameraInfoKey.ModelName]);
                    String deviceType = camera.CameraInfo[CameraInfoKey.DeviceType];

                    Console.WriteLine("==========");
                    Console.WriteLine("{0} Camera", deviceType);
                    Console.WriteLine("==========");
                    camera.StreamGrabber.ImageGrabbed += OnImageGrabbed;
                    camera.StreamGrabber.ImageGrabbed += OnImageSkipped;
                    // Get the Key from the user for selecting the mode

                    Console.Write("Start multicast sample in (c)ontrol or in (m)onitor mode? (c/m) ");
                    ConsoleKeyInfo keyPressed = Console.ReadKey();
                    switch (keyPressed.KeyChar)
                    {
                    // The default configuration must be removed when monitor mode is selected
                    // because the monitoring application is not allowed to modify any parameter settings.
                    case 'm':
                    case 'M':
                        // Monitor mode selected.
                        Console.WriteLine("\nIn Monitor mode");

                        // Set MonitorModeActive to true to act as monitor
                        camera.Parameters [PLCameraInstance.MonitorModeActive].SetValue(true);      // Set monitor mode

                        // Open the camera.
                        camera.Open();

                        // Select transmission type. If the camera is already controlled by another application
                        // and configured for multicast, the active camera configuration can be used
                        // (IP Address and Port will be set automatically).
                        camera.Parameters[PLGigEStream.TransmissionType].TrySetValue(PLGigEStream.TransmissionType.UseCameraConfig);

                        // Alternatively, the stream grabber could be explicitly set to "multicast"...
                        // In this case, the IP Address and the IP port must also be set.
                        //
                        //camera.Parameters[PLGigEStream.TransmissionType].SetValue(PLGigEStream.TransmissionType.Multicast);
                        //camera.Parameters[PLGigEStream.DestinationAddr].SetValue("239.0.0.1");
                        //camera.Parameters[PLGigEStream.DestinationPort].SetValue(49152);

                        if ((camera.Parameters[PLGigEStream.DestinationAddr].GetValue() != "0.0.0.0") &&
                            (camera.Parameters[PLGigEStream.DestinationPort].GetValue() != 0))
                        {
                            camera.StreamGrabber.Start(countOfImagesToGrab);
                        }
                        else
                        {
                            throw new Exception("Failed to open stream grabber (monitor mode): The acquisition is not yet started by the controlling application. Start the controlling application before starting the monitor application.");
                        }
                        break;

                    case 'c':
                    case 'C':
                        // Controlling mode selected.
                        Console.WriteLine("\nIn Control mode");

                        // Open the camera.
                        camera.Open();

                        // Set transmission type to "multicast"...
                        // In this case, the IP Address and the IP port must also be set.
                        camera.Parameters[PLGigEStream.TransmissionType].SetValue(PLGigEStream.TransmissionType.Multicast);
                        //camera.Parameters[PLGigEStream.DestinationAddr].SetValue("239.0.0.1");
                        //camera.Parameters[PLGigEStream.DestinationPort].SetValue(49152);

                        // Maximize the image area of interest (Image AOI).
                        camera.Parameters[PLGigECamera.OffsetX].TrySetValue(camera.Parameters[PLGigECamera.OffsetX].GetMinimum());
                        camera.Parameters[PLGigECamera.OffsetY].TrySetValue(camera.Parameters[PLGigECamera.OffsetY].GetMinimum());
                        camera.Parameters[PLGigECamera.Width].SetValue(camera.Parameters[PLGigECamera.Width].GetMaximum());
                        camera.Parameters[PLGigECamera.Height].SetValue(camera.Parameters[PLGigECamera.Height].GetMaximum());

                        // Set the pixel data format.
                        camera.Parameters[PLGigECamera.PixelFormat].SetValue(PLGigECamera.PixelFormat.Mono8);

                        camera.StreamGrabber.Start();
                        break;

                    default:
                        throw new NotSupportedException("Invalid mode selected.");
                    }

                    IGrabResult grabResult;

                    // Camera.StopGrabbing() is called automatically by the RetrieveResult() method
                    // when countOfImagesToGrab images have been retrieved in monitor mode
                    // or when a key is pressed and the camera object is destroyed.
                    Console.WriteLine("Press any key to quit FrameGrabber...");

                    while (!Console.KeyAvailable && camera.StreamGrabber.IsGrabbing)
                    {
                        grabResult = camera.StreamGrabber.RetrieveResult(5000, TimeoutHandling.ThrowException);
                        using (grabResult)
                        {
                            // Image grabbed successfully?
                            if (grabResult.GrabSucceeded)
                            {
                                // Display the image
                                ImageWindow.DisplayImage(1, grabResult);

                                // The grab result could now be processed here.
                            }
                            else
                            {
                                Console.WriteLine("Error: {0} {1}", grabResult.ErrorCode, grabResult.ErrorDescription);
                            }
                        }
                    }

                    camera.Close();
                }
            }
            catch (Exception e)
            {
                // Error handling
                Console.Error.WriteLine("\nException: {0}", e.Message);
                exitCode = 1;
            }
            finally
            {
                // Comment the following two lines to disable waiting on exit.
                Console.Error.WriteLine("\nPress enter to exit.");
                Console.ReadLine();
            }

            Environment.Exit(exitCode);
        }
Ejemplo n.º 9
0
        internal static void Main()
        {
            // The exit code of the sample application.
            int exitCode = 0;

            try
            {
                // Create a camera object that selects the first camera device found.
                // More constructors are available for selecting a specific camera device.
                using (Camera camera = new Camera())
                {
                    // Print the model name of the camera.
                    Console.WriteLine("Using camera {0}.", camera.CameraInfo[CameraInfoKey.ModelName]);

                    // Set the acquisition mode to free running continuous acquisition when the camera is opened.
                    camera.CameraOpened += Configuration.AcquireContinuous;

                    // Open the connection to the camera device.
                    camera.Open();

                    // Set buffer factory before starting the stream grabber because allocation
                    // happens there.
                    MyBufferFactory myFactory = new MyBufferFactory();
                    camera.StreamGrabber.BufferFactory = myFactory;

                    // Start grabbing.
                    camera.StreamGrabber.Start();

                    // Grab a number of images.
                    for (int i = 0; i < 10; ++i)
                    {
                        // Wait for an image and then retrieve it. A timeout of 5000 ms is used.
                        IGrabResult grabResult = camera.StreamGrabber.RetrieveResult(5000, TimeoutHandling.ThrowException);
                        using (grabResult)
                        {
                            // Image grabbed successfully?
                            if (grabResult.GrabSucceeded)
                            {
                                // Access the image data.
                                Console.WriteLine("SizeX: {0}", grabResult.Width);
                                Console.WriteLine("SizeY: {0}", grabResult.Height);

                                // Normally we would have a byte array in the pixel data.
                                // However we are using the buffer factory here which allocates
                                // ushort arrays.
                                ushort[] buffer = grabResult.PixelData as ushort[];
                                Console.WriteLine("First value of pixel data: {0}", buffer[0]);
                                Console.WriteLine("");

                                // Display the grabbed image.
                                ImageWindow.DisplayImage(0, grabResult);
                            }
                            else
                            {
                                Console.WriteLine("Error: {0} {1}", grabResult.ErrorCode, grabResult.ErrorDescription);
                            }
                        }
                    }

                    // Stop grabbing.
                    camera.StreamGrabber.Stop();

                    // Close the connection to the camera device.
                    camera.Close();
                }
            }
            catch (Exception e)
            {
                Console.Error.WriteLine("Exception: {0}", e.Message);
                exitCode = 1;
            }
            finally
            {
                // Comment the following two lines to disable waiting on exit.
                Console.Error.WriteLine("\nPress enter to exit.");
                Console.ReadLine();
            }

            Environment.Exit(exitCode);
        }
Ejemplo n.º 10
0
        internal static void Main()
        {
            // Time to wait for the user to disconnect the camera device.
            const int cTimeOutMs = 60000;

            // The exit code of the sample application.
            int exitCode = 0;

            try
            {
                // Create a camera object that selects the first camera device found.
                // More constructors are available for selecting a specific camera device.
                using (Camera camera = new Camera())
                {
                    // Print the model name of the camera.
                    Console.WriteLine("Using camera {0}.", camera.CameraInfo[CameraInfoKey.ModelName]);

                    // Set the acquisition mode to free running continuous acquisition when the camera is opened.
                    camera.CameraOpened += Configuration.AcquireContinuous;

                    // For demonstration purposes, only add an event handler for connection loss.
                    camera.ConnectionLost += OnConnectionLost;

                    // Open the connection to the camera device.
                    camera.Open();

                    ///////////////// Don't single step beyond this line when using GigE cameras (see comments above) ///////////////////////////////
                    // Before testing the callbacks, we manually set the heartbeat timeout to a short value when using GigE cameras.
                    // For debug versions, the heartbeat timeout has been set to 5 minutes, so it would take up to 5 minutes
                    // until device removal is detected.
                    camera.Parameters[PLTransportLayer.HeartbeatTimeout].TrySetValue(1000, IntegerValueCorrection.Nearest); // 1000 ms timeout

                    // Start the grabbing.
                    camera.StreamGrabber.Start();

                    // Start the timeout timer.
                    Console.WriteLine("Please disconnect the device. (Timeout {0}s)", cTimeOutMs / 1000.0);
                    Stopwatch stopWatch = new Stopwatch();
                    stopWatch.Start();

                    // Grab and display images until timeout.
                    while (camera.StreamGrabber.IsGrabbing && stopWatch.ElapsedMilliseconds < cTimeOutMs)
                    {
                        try
                        {
                            // Wait for an image and then retrieve it. A timeout of 5000 ms is used.
                            IGrabResult grabResult = camera.StreamGrabber.RetrieveResult(5000, TimeoutHandling.ThrowException);
                            using (grabResult)
                            {
                                // Image grabbed successfully?
                                if (grabResult.GrabSucceeded)
                                {
                                    // Display the grabbed image.
                                    ImageWindow.DisplayImage(0, grabResult);
                                }
                            }
                        }
                        catch (Exception)
                        {
                            // An exception occurred. Is it because the camera device has been physically removed?

                            // Known issue: Wait until the system safely detects a possible removal.
                            System.Threading.Thread.Sleep(1000);

                            if (!camera.IsConnected)
                            {
                                // Yes, the camera device has been physically removed.
                                Console.WriteLine("The camera device has been removed. Please reconnect. (Timeout {0}s)", cTimeOutMs / 1000.0);

                                // Close the camera object to close underlying resources used for the previous connection.
                                camera.Close();

                                // Try to re-establish a connection to the camera device until timeout.
                                // Reopening the camera triggers the above registered Configuration.AcquireContinous.
                                // Therefore, the camera is parameterized correctly again.
                                camera.Open(cTimeOutMs, TimeoutHandling.ThrowException);

                                // Due to unplugging the camera, settings have changed, e.g. the heartbeat timeout value for GigE cameras.
                                // After the camera has been reconnected, all settings must be restored. This can be done in the CameraOpened
                                // event as shown for the Configuration.AcquireContinous.
                                camera.Parameters[PLTransportLayer.HeartbeatTimeout].TrySetValue(1000, IntegerValueCorrection.Nearest);

                                // Restart grabbing.
                                camera.StreamGrabber.Start();

                                // Restart the timeout timer.
                                Console.WriteLine("Camera reconnected. You may disconnect the camera device again (Timeout {0}s)", cTimeOutMs / 1000.0);
                                stopWatch.Restart();
                            }
                            else
                            {
                                throw;
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.Error.WriteLine("Exception: {0}", e.Message);
                exitCode = 1;
            }
            finally
            {
                // Comment the following two lines to disable waiting on exit.
                Console.Error.WriteLine("\nPress enter to exit.");
                Console.ReadLine();
            }

            Environment.Exit(exitCode);
        }
Ejemplo n.º 11
0
        internal static void Main()
        {
            const int c_countOfImagesToGrab = 10;
            int       exitCode = 0;

            try
            {
                // Create a camera object and select the first camera device found.
                using (EventCamera eventCamera = new EventCamera())
                {
                    // Register the ExposureEnd event with the event handler member.
                    eventCamera.Configure();

                    // Register an event handler object with an anonymous method. The object is important if you want to unregister this event.
                    EventHandler <ParameterChangedEventArgs> handlerTimestamp = (s, e) =>
                    {
                        Console.WriteLine("Anonymous method: TimeStamp {0}", e.Parameter.ToString());
                    };

                    eventCamera.Parameters[eventCamera.ExposureEndTimestamp].ParameterChanged += handlerTimestamp;

                    eventCamera.StreamGrabber.Start(c_countOfImagesToGrab);
                    while (eventCamera.StreamGrabber.IsGrabbing)
                    {
                        if (eventCamera.WaitForFrameTriggerReady(1000, TimeoutHandling.ThrowException))
                        {
                            eventCamera.ExecuteSoftwareTrigger();
                        }
                        // Wait for an image and then retrieve it. A timeout of 5000 ms is used.
                        IGrabResult grabResult = eventCamera.StreamGrabber.RetrieveResult(5000, TimeoutHandling.ThrowException);
                        using (grabResult)
                        {
                            // Image grabbed successfully?
                            if (grabResult.GrabSucceeded)
                            {
                                ImageWindow.DisplayImage(0, grabResult);
                            }
                            else
                            {
                                Console.WriteLine("Error: {0} {1}", grabResult.ErrorCode, grabResult.ErrorDescription);
                            }
                        }
                    }
                    // If events are not required anymore, you should unregister the event handlers.
                    eventCamera.Parameters[eventCamera.ExposureEndDataName].ParameterChanged  -= eventCamera.OnEventExposureEndData;
                    eventCamera.Parameters[eventCamera.ExposureEndTimestamp].ParameterChanged -= handlerTimestamp;
                }
            }
            catch (Exception e)
            {
                Console.Error.WriteLine("Exception: {0}", e.Message);
                exitCode = 1;
            }
            finally
            {
                // Comment the following two lines to disable waiting on exit.
                Console.Error.WriteLine("\nPress enter to exit.");
                Console.ReadLine();
            }

            Environment.Exit(exitCode);
        }
Ejemplo n.º 12
0
        internal static void Main()
        {
            // The exit code of the sample application.
            int exitCode = 0;

            try
            {
                // Create a camera object that selects the first camera device found.
                // More constructors are available for selecting a specific camera device.
                using (Camera camera = new Camera())
                {
                    // Print the model name of the camera.
                    Console.WriteLine("Using camera {0}.", camera.CameraInfo[CameraInfoKey.ModelName]);

                    // Set the acquisition mode to free running continuous acquisition when the camera is opened.
                    //camera.CameraOpened += Configuration.AcquireContinuous;

                    // Open the connection to the camera device.
                    camera.Open();

                    Configure(camera);

                    // Set the pixel format to one from a list of ones compatible with this example
                    string[] pixelFormats = new string[]
                    {
                        PLCamera.PixelFormat.YUV422_YUYV_Packed,
                        PLCamera.PixelFormat.YCbCr422_8,
                        PLCamera.PixelFormat.BayerBG8,
                        PLCamera.PixelFormat.BayerRG8,
                        PLCamera.PixelFormat.BayerGR8,
                        PLCamera.PixelFormat.BayerGB8,
                        PLCamera.PixelFormat.Mono8
                    };
                    camera.Parameters[PLCamera.PixelFormat].SetValue(pixelFormats);

                    // Disable test image generator if available
                    camera.Parameters[PLCamera.TestImageSelector].TrySetValue(PLCamera.TestImageSelector.Off);
                    camera.Parameters[PLCamera.TestPattern].TrySetValue(PLCamera.TestPattern.Off);

                    // Set the Auto Function ROI for luminance and white balance statistics.
                    // We want to use ROI2 for gathering the statistics.
                    if (camera.Parameters[regionSelector].IsWritable)
                    {
                        camera.Parameters[regionSelector].SetValue(regionSelectorValue1);
                        camera.Parameters[autoFunctionAOIROIUseBrightness].SetValue(true);   // ROI 1 is used for brightness control
                        camera.Parameters[autoFunctionAOIROIUseWhiteBalance].SetValue(true); // ROI 1 is used for white balance control
                    }
                    camera.Parameters[regionSelector].SetValue(regionSelectorValue1);
                    camera.Parameters[regionSelectorOffsetX].SetValue(camera.Parameters[PLCamera.OffsetX].GetMinimum());
                    camera.Parameters[regionSelectorOffsetY].SetValue(camera.Parameters[PLCamera.OffsetY].GetMinimum());
                    camera.Parameters[regionSelectorWidth].SetValue(camera.Parameters[PLCamera.Width].GetMaximum());
                    camera.Parameters[regionSelectorHeight].SetValue(camera.Parameters[PLCamera.Height].GetMaximum());

                    if (camera.GetSfncVersion() < sfnc2_0_0) // Handling for older cameras
                    {
                        camera.Parameters[PLCamera.ProcessedRawEnable].TrySetValue(true);
                        camera.Parameters[PLCamera.GammaEnable].TrySetValue(true);
                        camera.Parameters[PLCamera.GammaSelector].TrySetValue(PLCamera.GammaSelector.sRGB);
                        camera.Parameters[PLCamera.AutoTargetValue].TrySetValue(80);
                        camera.Parameters[PLCamera.AutoFunctionProfile].TrySetValue(PLCamera.AutoFunctionProfile.GainMinimum);
                        camera.Parameters[PLCamera.AutoGainRawLowerLimit].TrySetToMinimum();
                        camera.Parameters[PLCamera.AutoGainRawUpperLimit].TrySetToMaximum();
                        camera.Parameters[PLCamera.AutoExposureTimeAbsLowerLimit].TrySetToMinimum();
                        camera.Parameters[PLCamera.AutoExposureTimeAbsUpperLimit].TrySetToMaximum();
                    }
                    else // Handling for newer cameras (using SFNC 2.0, e.g. USB3 Vision cameras)
                    {
                        camera.Parameters[PLCamera.AutoTargetBrightness].TrySetValue(0.3);
                        camera.Parameters[PLCamera.AutoFunctionProfile].TrySetValue(PLCamera.AutoFunctionProfile.MinimizeGain);
                        camera.Parameters[PLCamera.AutoGainLowerLimit].TrySetToMinimum();
                        camera.Parameters[PLCamera.AutoGainUpperLimit].TrySetToMaximum();
                        double maxExposure = camera.Parameters[PLCamera.AutoExposureTimeUpperLimit].GetMaximum();
                        // Reduce upper limit to one second for this example
                        if (maxExposure > 1000000)
                        {
                            maxExposure = 1000000;
                        }
                        camera.Parameters[PLCamera.AutoExposureTimeUpperLimit].TrySetValue(maxExposure);
                    }

                    // Set all auto functions to once in this example
                    camera.Parameters[PLCamera.GainSelector].TrySetValue(PLCamera.GainSelector.All);
                    camera.Parameters[PLCamera.GainAuto].TrySetValue(PLCamera.GainAuto.Once);
                    camera.Parameters[PLCamera.ExposureAuto].TrySetValue(PLCamera.ExposureAuto.Once);
                    camera.Parameters[PLCamera.BalanceWhiteAuto].TrySetValue(PLCamera.BalanceWhiteAuto.Once);
                    if (camera.GetSfncVersion() < sfnc2_0_0) // Handling for older cameras
                    {
                        camera.Parameters[PLCamera.LightSourceSelector].TrySetValue(PLCamera.LightSourceSelector.Daylight);
                    }
                    else // Handling for newer cameras (using SFNC 2.0, e.g. USB3 Vision cameras)
                    {
                        camera.Parameters[PLCamera.LightSourcePreset].TrySetValue(PLCamera.LightSourcePreset.Daylight5000K);
                    }

                    camera.StreamGrabber.Start();
                    for (int n = 0; n < 20; n++)            // For demonstration purposes, we will grab "only" 20 images.
                    {
                        IGrabResult result = camera.StreamGrabber.RetrieveResult(5000, TimeoutHandling.ThrowException);
                        using (result)
                        {
                            // Image grabbed successfully?
                            if (result.GrabSucceeded)
                            {
                                ImageWindow.DisplayImage(1, result);
                            }
                        }

                        //For demonstration purposes only. Wait until the image is shown.
                        System.Threading.Thread.Sleep(100);
                    }

                    // Close the camera.
                    camera.Close();
                }
            }
            catch (Exception e)
            {
                // Error handling.
                Console.Error.WriteLine("Exception: {0}", e.Message);
                exitCode = 1;
            }
            finally
            {
                // Comment the following two lines to disable waiting on exit.
                Console.Error.WriteLine("\nPress enter to exit.");
                Console.ReadLine();
            }

            Environment.Exit(exitCode);
        }
        internal static void Main()
        {
            // The exit code of the sample application.
            int exitCode = 0;

            try
            {
                // Create a camera object that selects the first camera device found.
                // More constructors are available for selecting a specific camera device.
                using (Camera camera = new Camera())
                {
                    // Print the model name of the camera.
                    Console.WriteLine("Using camera {0}.", camera.CameraInfo [CameraInfoKey.ModelName]);

                    // Set the acquisition mode to single frame acquisition when the camera is opened.
                    camera.CameraOpened += Configuration.AcquireSingleFrame;

                    // Open the connection to the camera device.
                    camera.Open();

                    // Remember the original compression mode.
                    string oldCompressionMode = camera.Parameters [PLCamera.ImageCompressionMode].GetValue();

                    // Set the compression mode to BaslerCompressionBeyond if available.
                    camera.Parameters [PLCamera.ImageCompressionMode].SetValue(PLCamera.ImageCompressionMode.BaslerCompressionBeyond);
                    // After enabling the compression, we can read the compression rate option.
                    string oldCompressionRateOption = camera.Parameters [PLCamera.ImageCompressionRateOption].GetValue();
                    // Configure lossless compression.
                    camera.Parameters [PLCamera.ImageCompressionRateOption].SetValue(PLCamera.ImageCompressionRateOption.Lossless);

                    // Create the decompressor and initialize it with the camera.
                    using (ImageDecompressor decompressor = new ImageDecompressor(camera))
                    {
                        // Wait max. 5000ms for a new image.
                        IGrabResult grabResult = camera.StreamGrabber.GrabOne(5000);
                        using (grabResult)
                        {
                            if (grabResult.GrabSucceeded)
                            {
                                // Fetch compression info and check whether the image was compressed by the camera.
                                CompressionInfo compressionInfo = new CompressionInfo();
                                if (ImageDecompressor.GetCompressionInfo(ref compressionInfo, grabResult))
                                {
                                    // Print content of CompressionInfo.
                                    PrintCompressionInfo(compressionInfo);

                                    // Check if we have a valid compressed image
                                    if (compressionInfo.CompressionStatus == CompressionStatus.Ok)
                                    {
                                        // Show compression ratio.
                                        Console.WriteLine("\nTransferred compressed payload: {0}", grabResult.PayloadSize);
                                        Console.WriteLine("Compression ratio: {0:N2}%", (Single)grabResult.PayloadSize / (Single)compressionInfo.DecompressedPayloadSize * 100.0);

                                        // Create buffer for storing the decompressed image.
                                        var myBuffer = new Byte [compressionInfo.DecompressedImageSize];

                                        // Decompress the image.
                                        decompressor.DecompressImage(myBuffer, grabResult);

                                        // Show the image.
                                        ImageWindow.DisplayImage(1, myBuffer, compressionInfo.PixelType, compressionInfo.Width, compressionInfo.Height, 0, ImageOrientation.TopDown);
                                    }
                                    else
                                    {
                                        Console.WriteLine("There was an error while the camera was compressing the image.");
                                    }
                                }
                            }
                            else
                            {
                                // Somehow image grabbing failed.
                                Console.WriteLine("Error: {0} {1}", grabResult.ErrorCode, grabResult.ErrorDescription);
                            }
                        }

                        Console.WriteLine("\n\n--- Switching to Fix Ratio compression ---");

                        // Take another picture with lossy compression (if available).
                        if (camera.Parameters [PLCamera.ImageCompressionRateOption].TrySetValue(PLCamera.ImageCompressionRateOption.FixRatio))
                        {
                            // After changing the compression parameters, the decompressor MUST be reconfigured.
                            decompressor.SetCompressionDescriptor(camera);

                            // Wait max. 5000ms for a new image.
                            grabResult = camera.StreamGrabber.GrabOne(5000);
                            using (grabResult)
                            {
                                if (grabResult.GrabSucceeded)
                                {
                                    // Fetch compression info and check whether the image was compressed by the camera.
                                    CompressionInfo compressionInfo = new CompressionInfo();
                                    if (ImageDecompressor.GetCompressionInfo(ref compressionInfo, grabResult))
                                    {
                                        // Print content of CompressionInfo.
                                        PrintCompressionInfo(compressionInfo);

                                        // Check if we have a valid compressed image
                                        if (compressionInfo.CompressionStatus == CompressionStatus.Ok)
                                        {
                                            // Show compression ratio.
                                            Console.WriteLine("\nTransferred compressed payload: {0}", grabResult.PayloadSize);
                                            Console.WriteLine("Compression ratio: {0:N2}%", (Single)grabResult.PayloadSize / (Single)compressionInfo.DecompressedPayloadSize * 100.0);

                                            // Create buffer for storing the decompressed image.
                                            var myBuffer = new Byte [compressionInfo.DecompressedImageSize];

                                            // Decompress the image.
                                            decompressor.DecompressImage(myBuffer, grabResult);

                                            // Show the image.
                                            ImageWindow.DisplayImage(2, myBuffer, compressionInfo.PixelType, compressionInfo.Width, compressionInfo.Height, 0, ImageOrientation.TopDown);
                                        }
                                        else
                                        {
                                            Console.WriteLine("There was an error while the camera was compressing the image.");
                                        }
                                    }
                                }
                                else
                                {
                                    // Somehow image grabbing failed.
                                    Console.WriteLine("Error: {0} {1}", grabResult.ErrorCode, grabResult.ErrorDescription);
                                }
                            }
                        }
                        else
                        {
                            Console.WriteLine("With this setting the camera does not support the \"FixRatio\" Image Compression Rate Option.");
                        }
                    }
                    // restore the old camera settings
                    camera.Parameters [PLCamera.ImageCompressionRateOption].SetValue(oldCompressionRateOption);
                    camera.Parameters [PLCamera.ImageCompressionMode].SetValue(oldCompressionMode);

                    camera.Close();
                }
            }
            catch (InvalidOperationException e)
            {
                Console.Error.WriteLine("Exception: Camera does not support Compression. {0}", e.Message);
                exitCode = 1;
            }
            catch (Exception e)
            {
                Console.Error.WriteLine("Exception: {0}", e.Message);
                exitCode = 1;
            }
            finally
            {
                // Comment the following two lines to disable waiting on exit.
                Console.Error.WriteLine("\nPress enter to exit.");
                Console.ReadLine();
            }

            Environment.Exit(exitCode);
        }
Ejemplo n.º 14
0
        internal static void Main()
        {
            // The exit code of the sample application.
            int exitCode = 0;

            try
            {
                // Create a camera object that selects the first camera device found.
                // More constructors are available for selecting a specific camera device.
                using (Camera camera = new Camera())
                {
                    // Print the model name of the camera.
                    Console.WriteLine("Using camera {0}.", camera.CameraInfo[CameraInfoKey.ModelName]);

                    // Set the acquisition mode to free running continuous acquisition when the camera is opened.
                    camera.CameraOpened += Configuration.AcquireContinuous;

                    // Open the connection to the camera device.
                    camera.Open();

                    // The parameter MaxNumBuffer can be used to control the amount of buffers
                    // allocated for grabbing. The default value of this parameter is 10.
                    camera.Parameters[PLCameraInstance.MaxNumBuffer].SetValue(5);

                    // Start grabbing.
                    camera.StreamGrabber.Start();

                    // Grab a number of images.
                    for (int i = 0; i < 10; ++i)
                    {
                        // Wait for an image and then retrieve it. A timeout of 5000 ms is used.
                        IGrabResult grabResult = camera.StreamGrabber.RetrieveResult(5000, TimeoutHandling.ThrowException);
                        using (grabResult)
                        {
                            // Image grabbed successfully?
                            if (grabResult.GrabSucceeded)
                            {
                                // Access the image data.
                                Console.WriteLine("SizeX: {0}", grabResult.Width);
                                Console.WriteLine("SizeY: {0}", grabResult.Height);
                                byte[] buffer = grabResult.PixelData as byte[];
                                Console.WriteLine("Gray value of first pixel: {0}", buffer[0]);
                                Console.WriteLine("");

                                // Display the grabbed image.
                                ImageWindow.DisplayImage(0, grabResult);
                            }
                            else
                            {
                                Console.WriteLine("Error: {0} {1}", grabResult.ErrorCode, grabResult.ErrorDescription);
                            }
                        }
                    }

                    // Stop grabbing.
                    camera.StreamGrabber.Stop();

                    // Close the connection to the camera device.
                    camera.Close();
                }
            }
            catch (Exception e)
            {
                Console.Error.WriteLine("Exception: {0}", e.Message);
                exitCode = 1;
            }
            finally
            {
                // Comment the following two lines to disable waiting on exit.
                Console.Error.WriteLine("\nPress enter to exit.");
                Console.ReadLine();
            }

            Environment.Exit(exitCode);
        }
Ejemplo n.º 15
0
        internal static void Main()
        {
            // The number of images to grab.
            const int c_countOfImagesToGrab = 10;

            // The exit code of the sample application.
            int exitCode = 0;

            try
            {
                // Create a camera object that selects the first camera device found.
                // More constructors are available for selecting a specific camera device.
                using (Camera camera = new Camera())
                {
                    // Print the model name of the camera.
                    Console.WriteLine("Using camera {0}.", camera.CameraInfo[CameraInfoKey.ModelName]);

                    // Set the acquisition mode to free running continuous acquisition when the camera is opened.
                    camera.CameraOpened += Configuration.AcquireContinuous;

                    // Open the connection to the camera device.
                    camera.Open();

                    // Enable the chunk mode.
                    if (!camera.Parameters[PLCamera.ChunkModeActive].TrySetValue(true))
                    {
                        throw new Exception("The camera doesn't support chunk features");
                    }

                    // Enable time stamp chunks.
                    camera.Parameters[PLCamera.ChunkSelector].SetValue(PLCamera.ChunkSelector.Timestamp);
                    camera.Parameters[PLCamera.ChunkEnable].SetValue(true);

                    // Enable frame counter chunk if possible.
                    if (camera.Parameters[PLCamera.ChunkSelector].TrySetValue(PLCamera.ChunkSelector.Framecounter))
                    {
                        camera.Parameters[PLCamera.ChunkEnable].SetValue(true);
                    }
                    // Enable generic counters if possible (USB camera devices).
                    else if (camera.Parameters[PLCamera.ChunkSelector].TrySetValue(PLCamera.ChunkSelector.CounterValue))
                    {
                        camera.Parameters[PLCamera.ChunkEnable].SetValue(true);
                        camera.Parameters[PLCamera.CounterSelector].SetValue(PLCamera.CounterSelector.Counter1);
                        camera.Parameters[PLCamera.CounterEventSource].SetValue(PLCamera.CounterEventSource.FrameStart);
                    }

                    // Enable CRC checksum chunks.
                    camera.Parameters[PLCamera.ChunkSelector].SetValue(PLCamera.ChunkSelector.PayloadCRC16);
                    camera.Parameters[PLCamera.ChunkEnable].SetValue(true);


                    // Start grabbing c_countOfImagesToGrab images.
                    camera.StreamGrabber.Start(c_countOfImagesToGrab);

                    // camera.StreamGrabber.Stop() is called automatically by the RetrieveResult() method
                    // when c_countOfImagesToGrab images have been retrieved.
                    while (camera.StreamGrabber.IsGrabbing)
                    {
                        // Wait for an image and then retrieve it. A timeout of 5000 ms is used.
                        IGrabResult grabResult = camera.StreamGrabber.RetrieveResult(5000, TimeoutHandling.ThrowException);
                        using (grabResult)
                        {
                            // Image grabbed successfully?
                            if (grabResult.GrabSucceeded)
                            {
                                // Display the grabbed image.
                                ImageWindow.DisplayImage(0, grabResult);

                                // Check to see if a buffer containing chunk data has been received.
                                if (PayloadType.ChunkData != grabResult.PayloadTypeValue)
                                {
                                    throw new Exception("Unexpected payload type received.");
                                }

                                // Because we have enabled the CRC Checksum feature, we can check
                                // the integrity of the buffer.
                                // Note: Enabling the CRC Checksum feature is not a prerequisite for using chunks.
                                // Chunks can also be handled when the CRC Checksum feature is disabled.
                                if (grabResult.HasCRC && grabResult.CheckCRC() == false)
                                {
                                    throw new Exception("Image was damaged!");
                                }

                                // Access the chunk data attached to the result.
                                // Before accessing the chunk data, you should check to see
                                // if the chunk is readable. If it is readable, the buffer
                                // contains the requested chunk data.
                                if (grabResult.ChunkData[PLChunkData.ChunkTimestamp].IsReadable)
                                {
                                    Console.WriteLine("ChunkData: TimeStamp = {0}", grabResult.ChunkData[PLChunkData.ChunkTimestamp]);
                                }
                                else
                                {
                                    Console.WriteLine("ChunkData: No TimeStamp");
                                }

                                // Print the frame counter value.
                                if (grabResult.ChunkData[PLChunkData.ChunkFramecounter].IsReadable)
                                {
                                    Console.WriteLine("ChunkData: FrameCounter = {0}", grabResult.ChunkData[PLChunkData.ChunkFramecounter]);
                                }
                                // Print the generic counter value (USB camera devices).
                                else if (grabResult.ChunkData[PLChunkData.ChunkCounterSelector].TrySetValue(PLChunkData.ChunkCounterSelector.Counter1) &&
                                         grabResult.ChunkData[PLChunkData.ChunkCounterValue].IsReadable
                                         )
                                {
                                    Console.WriteLine("ChunkData: FrameCounter = {0}", grabResult.ChunkData[PLChunkData.ChunkCounterValue]);
                                }

                                Console.WriteLine("");
                            }
                            else
                            {
                                Console.WriteLine("Error: {0} {1}", grabResult.ErrorCode, grabResult.ErrorDescription);
                            }
                        }
                    }
                    camera.Parameters[PLCamera.ChunkModeActive].SetValue(false);
                }
            }
            catch (Exception e)
            {
                Console.Error.WriteLine("Exception: {0}", e.Message);
                exitCode = 1;
            }
            finally
            {
                // Comment the following two lines to disable waiting on exit.
                Console.Error.WriteLine("\nPress enter to exit.");
                Console.ReadLine();
            }

            Environment.Exit(exitCode);
        }