Example #1
0
        private void Snapshot_Click(object sender, EventArgs e)
        {
            try
            {
                //1.Open Device
                // Before using any GxIAPINET methods, the GxIAPINET must be initialized.
                m_objIGXFactory = IGXFactory.GetInstance();
                m_objIGXFactory.Init();

                //open device
                List <IGXDeviceInfo> listGXDeviceInfo = new List <IGXDeviceInfo>();

                // Close stream
                __CloseStream();

                // If the device is opened then close it to ensure the camera could open again.
                __CloseDevice();

                // Enumerate all camera devices
                m_objIGXFactory.UpdateDeviceList(200, listGXDeviceInfo);

                // Check if found any device
                if (listGXDeviceInfo.Count <= 0)
                {
                    MessageBox.Show("No devices found!");
                    return;
                }

                //Open the first found device
                m_objIGXDevice         = m_objIGXFactory.OpenDeviceBySN(listGXDeviceInfo[0].GetSN(), GX_ACCESS_MODE.GX_ACCESS_EXCLUSIVE);
                m_objIGXFeatureControl = m_objIGXDevice.GetRemoteFeatureControl();


                // Open stream
                if (null != m_objIGXDevice)
                {
                    m_objIGXStream = m_objIGXDevice.OpenStream(0);
                }

                // It is recommended that the user set the camera's stream channel packet length value
                // according to the current network environment after turning on
                // the network camera to improve the collection performance of the network camera.
                // For the setting method, refer to the following code.
                GX_DEVICE_CLASS_LIST objDeviceClass = m_objIGXDevice.GetDeviceInfo().GetDeviceClass();
                if (GX_DEVICE_CLASS_LIST.GX_DEVICE_CLASS_GEV == objDeviceClass)
                {
                    // Determine whether the device supports the stream channel packet function.
                    if (true == m_objIGXFeatureControl.IsImplemented("GevSCPSPacketSize"))
                    {
                        // Get the optimal packet length value of the current network environment
                        uint nPacketSize = m_objIGXStream.GetOptimalPacketSize();
                        // Set the optimal packet length value to the stream channel packet length of the current device.
                        m_objIGXFeatureControl.GetIntFeature("GevSCPSPacketSize").SetValue(nPacketSize);
                    }
                }

                __InitDevice();

                m_objGxBitmap = new GxBitmap(m_objIGXDevice, m_pic_ShowImage);



                //2.Start acquisition
                // Start stream channel acquisition
                if (null != m_objIGXStream)
                {
                    m_objIGXStream.StartGrab();
                }

                // Send AcquisitionStart command
                if (null != m_objIGXFeatureControl)
                {
                    m_objIGXFeatureControl.GetCommandFeature("AcquisitionStart").Execute();
                }



                //3.Snapshot
                IImageData objIImageData = null;
                double     dElapsedtime  = 0;
                uint       nTimeout      = 500;


                //Flush image queues to clear out-of-date images
                if (null != m_objIGXStream)
                {
                    m_objIGXStream.FlushQueue();
                }

                //Send TriggerSoftware commands
                if (null != m_objIGXFeatureControl)
                {
                    m_objIGXFeatureControl.GetCommandFeature("TriggerSoftware").Execute();
                }

                //Get image
                if (null != m_objIGXStream)
                {
                    //Start stopwatch
                    m_objStopTime.Start();

                    objIImageData = m_objIGXStream.GetImage(nTimeout);

                    //Stop stopwatch and get the ElapsedTime
                    dElapsedtime = m_objStopTime.Stop();
                }

                m_objGxBitmap.Show(objIImageData);
                string strFileName = @"D:\TestImages\SWS.bmp";
                m_objGxBitmap.SaveBmp(objIImageData, strFileName);


                if (null != objIImageData)
                {
                    // Release resource
                    objIImageData.Destroy();
                }

                //4.Stop acquisition
                // Send AcquisitionStop command
                if (null != m_objIGXFeatureControl)
                {
                    m_objIGXFeatureControl.GetCommandFeature("AcquisitionStop").Execute();
                }

                // Stop stream channel acquisition
                if (null != m_objIGXStream)
                {
                    m_objIGXStream.StopGrab();
                }

                //5.Close device
                // Reset statistical time count
                m_objStatistic.Reset();

                // close stream and device
                __CloseAll();
            }

            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
Example #2
0
        private async void Generater_Click(object sender, EventArgs e)
        {
            string dir = ".\\" + textBox1.Text + " 회 데이터";

            DirectoryInfo di = new DirectoryInfo(dir);

            if (di.Exists == false)
            {
                di.Create();
            }
            RandomDataGen Making = new RandomDataGen();

            RandomDataGen.strFilePath = dir + $"\\{ DateTime.Now.ToString("yyyy - MM - dd - HH - mm - ss")} -";

            CStopWatch speedWatch    = new CStopWatch();
            CStopWatch weavingWatch  = new CStopWatch();
            CStopWatch intervalWatch = new CStopWatch();

            long SpeedElapsedTime;
            long WeavingElapsedTime;
            long IntervalElapsedTime;

            Task <int> speedfile        = null;
            Task <int> intervaltestfile = null;
            Task <int> Weavingtestfile  = null;

            if (SpeedCheck.CheckState == CheckState.Checked)
            {
                speedWatch.Start();
                speedfile = Making.speedfile(Convert.ToInt32(textBox1.Text));
            }
            if (DistanceCheck.CheckState == CheckState.Checked)
            {
                weavingWatch.Start();
                Weavingtestfile = Making.Weavingtestfile(Convert.ToInt32(textBox1.Text));
            }
            if (IntervalCheck.CheckState == CheckState.Checked)
            {
                intervalWatch.Start();
                intervaltestfile = Making.intervaltestfile(Convert.ToInt32(textBox1.Text));
            }


            if (speedfile != null)
            {
                await speedfile;
                SpeedElapsedTime = speedWatch.GetElapsedTime(CStopWatch.TIME_UNIT.MICROSECOND, true); //타임끝
                label1.Text      = SpeedElapsedTime.ToString() + " μs";
            }
            if (Weavingtestfile != null)
            {
                await Weavingtestfile;
                WeavingElapsedTime = weavingWatch.GetElapsedTime(CStopWatch.TIME_UNIT.MICROSECOND, true); //타임끝
                label2.Text        = WeavingElapsedTime.ToString() + " μs";
            }
            if (intervaltestfile != null)
            {
                await intervaltestfile;
                IntervalElapsedTime = intervalWatch.GetElapsedTime(CStopWatch.TIME_UNIT.MICROSECOND, true); //타임끝
                label3.Text         = IntervalElapsedTime.ToString() + " μs";
            }
            GC.Collect();
            GC.WaitForPendingFinalizers();
            MessageBox.Show("완료");
        }