Exemple #1
0
        private void PopulateStreamFormat()
        {
            bool readable = Pylon.DeviceFeatureIsReadable(deviceHandle, "PixelFormat");

            if (!readable)
            {
                cmbFormat.Enabled = false;
                return;
            }

            string currentValue = Pylon.DeviceFeatureToString(deviceHandle, "PixelFormat");

            List <StreamFormat> streamFormats = PylonHelper.GetSupportedStreamFormats(deviceHandle);

            if (streamFormats == null)
            {
                cmbFormat.Enabled = false;
                return;
            }

            foreach (StreamFormat streamFormat in streamFormats)
            {
                cmbFormat.Items.Add(streamFormat);
                if (currentValue == streamFormat.Symbol)
                {
                    selectedStreamFormat    = streamFormat;
                    cmbFormat.SelectedIndex = cmbFormat.Items.Count - 1;
                }
            }
        }
Exemple #2
0
        private void cmbFormat_SelectedIndexChanged(object sender, EventArgs e)
        {
            StreamFormat selected = cmbFormat.SelectedItem as StreamFormat;

            if (selected == null || selectedStreamFormat.Symbol == selected.Symbol)
            {
                return;
            }

            selectedStreamFormat = selected;
            specificChanged      = true;
        }
Exemple #3
0
        public static StreamFormat GetCurrentStreamFormat(PYLON_DEVICE_HANDLE deviceHandle)
        {
            StreamFormat sf = null;

            string enumerationName = "PixelFormat";

            NODEMAP_HANDLE nodeMapHandle = Pylon.DeviceGetNodeMap(deviceHandle);
            NODE_HANDLE    nodeHandle    = GenApi.NodeMapGetNode(nodeMapHandle, enumerationName);

            if (!nodeHandle.IsValid)
            {
                return(null);
            }

            string selected = GenApi.NodeToString(nodeHandle);

            uint itemCount = GenApi.EnumerationGetNumEntries(nodeHandle);

            for (uint i = 0; i < itemCount; i++)
            {
                NODE_HANDLE entryHandle = GenApi.EnumerationGetEntryByIndex(nodeHandle, i);
                string      symbol      = GenApi.EnumerationEntryGetSymbolic(entryHandle);
                if (selected != symbol)
                {
                    continue;
                }

                if (!GenApi.NodeIsAvailable(entryHandle))
                {
                    continue;
                }

                string displayName = GenApi.NodeGetDisplayName(entryHandle);
                sf = new StreamFormat(symbol, displayName);
                break;
            }

            return(sf);
        }
Exemple #4
0
        private void Open()
        {
            // Unlike in the DirectShow module, we do not backup and restore camera configuration.
            // If the user configured the camera outside of Kinovea we respect the new settings.
            // Two reasons:
            // 1. In DirectShow we must do the backup/restore to work around drivers that inadvertently reset the camera properties.
            // 2. Industrial cameras have many properties that won't be configurable in Kinovea
            // so the user is more likely to configure the camera from the outside.

            if (grabbing)
            {
                Stop();
            }

            try
            {
                deviceHandle = Pylon.CreateDeviceByIndex(deviceIndex);
                imageProvider.Open(deviceHandle);
            }
            catch (Exception e)
            {
                log.Error("Could not open Basler device.");
                LogError(e, imageProvider.GetLastErrorMessage());
                return;
            }

            if (deviceHandle.IsValid)
            {
                SpecificInfo specific = summary.Specific as SpecificInfo;
                if (specific == null)
                {
                    return;
                }

                specific.Handle = deviceHandle;
                StreamFormat currentStreamFormat = PylonHelper.GetCurrentStreamFormat(deviceHandle);

                // Some properties can only be changed when the camera is opened but not streaming.
                // We store them in the summary when coming back from FormConfiguration, and we write them to the camera here.
                // Only do this if it's not the first time we open the camera, to respect any change that could have been done outside Kinovea.
                if (!firstOpen)
                {
                    if (specific.StreamFormat != currentStreamFormat.Symbol)
                    {
                        PylonHelper.WriteStreamFormat(deviceHandle, specific.StreamFormat);
                    }

                    if (specific.CameraProperties != null && specific.CameraProperties.ContainsKey("framerate"))
                    {
                        if (specific.CameraProperties.ContainsKey("enableFramerate"))
                        {
                            bool enabled = bool.Parse(specific.CameraProperties["enableFramerate"].CurrentValue);
                            if (!enabled && !specific.CameraProperties["enableFramerate"].ReadOnly)
                            {
                                specific.CameraProperties["enableFramerate"].CurrentValue = "true";
                                CameraPropertyManager.Write(deviceHandle, specific.CameraProperties["enableFramerate"]);
                            }
                        }

                        CameraPropertyManager.Write(deviceHandle, specific.CameraProperties["framerate"]);
                    }

                    if (specific.CameraProperties != null && specific.CameraProperties.ContainsKey("width") && specific.CameraProperties.ContainsKey("height"))
                    {
                        CameraPropertyManager.Write(deviceHandle, specific.CameraProperties["width"]);
                        CameraPropertyManager.Write(deviceHandle, specific.CameraProperties["height"]);
                    }
                }
                else
                {
                    specific.StreamFormat = currentStreamFormat.Symbol;
                }
            }
        }