コード例 #1
0
        public CameraPropertySettings GetVideoPropertySettings(VideoProcAmpProperty property)
        {
            int         filterHandle;
            IBaseFilter captureFilter = null;

            filterHandle = filterGraph.FindFilterByName("Video input", out captureFilter);
            if (captureFilter != null)
            {
                int min          = 0;
                int max          = 0;
                int stepDelta    = 1;
                int defaultValue = 0;
                VideoProcAmpFlags videoFlags;
                IAMCameraControl  iC = captureFilter as IAMCameraControl;
                ((IAMVideoProcAmp)iC).GetRange(property, out min, out max, out stepDelta, out defaultValue, out videoFlags);
                CameraPropertySettings videoPropertySettings = new CameraPropertySettings();
                videoPropertySettings.Minimum      = min;
                videoPropertySettings.Maximum      = max;
                videoPropertySettings.Step         = stepDelta;
                videoPropertySettings.DefaultValue = defaultValue;
                return(videoPropertySettings);
            }
            else
            {
                return(null);
            }
        }
コード例 #2
0
        private void GetZoomRange()
        {
            CameraPropertySettings zoomSettings = camera.CaptureDevice.GetCameraControlPropertySettings(CameraControlProperty.Zoom);

            zoomTrackBar.Minimum     = zoomSettings.Minimum;
            zoomTrackBar.Maximum     = zoomSettings.Maximum;
            zoomTrackBar.SmallChange = zoomSettings.Step;
            zoomTrackBar.LargeChange = RELATIVE_LARGE_TRACKBAR_STEP * zoomSettings.Step;
            int currentValue = camera.CaptureDevice.GetCameraControlProperty(CameraControlProperty.Zoom);

            if (currentValue < zoomTrackBar.Minimum)
            {
                currentValue = zoomTrackBar.Minimum;
            }
            zoomTrackBar.Value = currentValue;
            zoomTextBox.Text   = currentValue.ToString();
            if (zoomSettings.Minimum == zoomSettings.Maximum)
            {
                zoomTrackBar.Enabled = false;
                zoomTextBox.Enabled  = false;
            }
            else
            {
                zoomTrackBar.ValueChanged += new EventHandler(ZoomValueChanged);
            }
        }
コード例 #3
0
        private void GetContrastRange()
        {
            CameraPropertySettings contrastSettings = camera.CaptureDevice.GetVideoPropertySettings(VideoProcAmpProperty.Contrast);

            contrastTrackBar.Minimum     = contrastSettings.Minimum;
            contrastTrackBar.Maximum     = contrastSettings.Maximum;
            contrastTrackBar.SmallChange = contrastSettings.Step;
            contrastTrackBar.LargeChange = RELATIVE_LARGE_TRACKBAR_STEP * contrastSettings.Step;
            int currentValue = camera.CaptureDevice.GetVideoProperty(VideoProcAmpProperty.Contrast);

            contrastTrackBar.Value         = currentValue;
            contrastTextBox.Text           = currentValue.ToString();
            contrastTrackBar.ValueChanged += new EventHandler(ContrastValueChanged);
        }
コード例 #4
0
        private void GetBrightnessRange()
        {
            CameraPropertySettings brightnessSettings = camera.CaptureDevice.GetVideoPropertySettings(VideoProcAmpProperty.Brightness);

            brightnessTrackBar.Minimum     = brightnessSettings.Minimum;
            brightnessTrackBar.Maximum     = brightnessSettings.Maximum;
            brightnessTrackBar.SmallChange = brightnessSettings.Step;
            brightnessTrackBar.LargeChange = RELATIVE_LARGE_TRACKBAR_STEP * brightnessSettings.Step;
            int currentValue = camera.CaptureDevice.GetVideoProperty(VideoProcAmpProperty.Brightness);

            brightnessTrackBar.Value         = currentValue;
            brightnessTextBox.Text           = currentValue.ToString();
            brightnessTrackBar.ValueChanged += new EventHandler(BrightnessValueChanged);
        }
コード例 #5
0
        private void GetBacklightCompensationRange()
        {
            CameraPropertySettings backlightCompensationSettings = camera.CaptureDevice.GetVideoPropertySettings(VideoProcAmpProperty.BacklightCompensation);

            backlightCompensationComboBox.SelectedIndex = backlightCompensationSettings.DefaultValue;
            if (backlightCompensationSettings.Minimum == backlightCompensationSettings.Maximum)
            {
                backlightCompensationComboBox.Enabled = false;
            }
            else
            {
                backlightCompensationComboBox.SelectedIndexChanged += new EventHandler(BacklightCompensationChanged);
            }
        }
コード例 #6
0
        private void GetHueRange()
        {
            CameraPropertySettings hueSettings = camera.CaptureDevice.GetVideoPropertySettings(VideoProcAmpProperty.Hue);

            hueTrackBar.Minimum     = hueSettings.Minimum;
            hueTrackBar.Maximum     = hueSettings.Maximum;
            hueTrackBar.SmallChange = hueSettings.Step;
            hueTrackBar.LargeChange = RELATIVE_LARGE_TRACKBAR_STEP * hueSettings.Step;
            int currentValue = camera.CaptureDevice.GetVideoProperty(VideoProcAmpProperty.Hue);

            hueTrackBar.Value         = currentValue;
            hueTextBox.Text           = currentValue.ToString();
            hueTrackBar.ValueChanged += new EventHandler(HueValueChanged);
        }
コード例 #7
0
        private void GetSaturationRange()
        {
            CameraPropertySettings saturationSettings = camera.CaptureDevice.GetVideoPropertySettings(VideoProcAmpProperty.Saturation);

            saturationTrackBar.Minimum     = saturationSettings.Minimum;
            saturationTrackBar.Maximum     = saturationSettings.Maximum;
            saturationTrackBar.SmallChange = saturationSettings.Step;
            saturationTrackBar.LargeChange = RELATIVE_LARGE_TRACKBAR_STEP * saturationSettings.Step;
            int currentValue = camera.CaptureDevice.GetVideoProperty(VideoProcAmpProperty.Saturation);

            saturationTrackBar.Value         = currentValue;
            saturationTextBox.Text           = currentValue.ToString();
            saturationTrackBar.ValueChanged += new EventHandler(SaturationValueChanged);
        }
コード例 #8
0
        private void GetIrisRange()
        {
            CameraPropertySettings irisSettings = camera.CaptureDevice.GetCameraControlPropertySettings(CameraControlProperty.Iris);

            irisTrackBar.Minimum     = irisSettings.Minimum;
            irisTrackBar.Maximum     = irisSettings.Maximum;
            irisTrackBar.SmallChange = irisSettings.Step;
            irisTrackBar.LargeChange = RELATIVE_LARGE_TRACKBAR_STEP * irisSettings.Step;
            int currentValue = camera.CaptureDevice.GetCameraControlProperty(CameraControlProperty.Iris);

            irisTrackBar.Value = currentValue;
            irisTextBox.Text   = currentValue.ToString();
            if (irisSettings.Minimum == irisSettings.Maximum)
            {
                irisTrackBar.Enabled = false;
                irisTextBox.Enabled  = false;
            }
            else
            {
                irisTrackBar.ValueChanged += new EventHandler(IrisValueChanged);
            }
        }
コード例 #9
0
        private void GetFocusRange()
        {
            CameraPropertySettings focusSettings = camera.CaptureDevice.GetCameraControlPropertySettings(CameraControlProperty.Focus);

            focusTrackBar.Minimum     = focusSettings.Minimum;
            focusTrackBar.Maximum     = focusSettings.Maximum;
            focusTrackBar.SmallChange = focusSettings.Step;
            focusTrackBar.LargeChange = RELATIVE_LARGE_TRACKBAR_STEP * focusSettings.Step;
            int currentValue = camera.CaptureDevice.GetCameraControlProperty(CameraControlProperty.Focus);

            focusTrackBar.Value = currentValue;
            focusTextBox.Text   = currentValue.ToString();
            if (focusSettings.Minimum == focusSettings.Maximum)
            {
                focusTrackBar.Enabled = false;
                focusTextBox.Enabled  = false;
            }
            else
            {
                focusTrackBar.ValueChanged += new EventHandler(FocusValueChanged);
            }
        }
コード例 #10
0
        private void GetExposureRange()
        {
            CameraPropertySettings exposureSettings = camera.CaptureDevice.GetCameraControlPropertySettings(CameraControlProperty.Exposure);

            exposureTrackBar.Minimum     = exposureSettings.Minimum;
            exposureTrackBar.Maximum     = exposureSettings.Maximum;
            exposureTrackBar.SmallChange = exposureSettings.Step;
            exposureTrackBar.LargeChange = RELATIVE_LARGE_TRACKBAR_STEP * exposureSettings.Step;
            int currentValue = camera.CaptureDevice.GetCameraControlProperty(CameraControlProperty.Exposure);

            exposureTrackBar.Value = currentValue;
            exposureTextBox.Text   = currentValue.ToString();
            if (exposureSettings.Minimum == exposureSettings.Maximum)
            {
                exposureTrackBar.Enabled = false;
                exposureTextBox.Enabled  = false;
            }
            else
            {
                exposureTrackBar.ValueChanged += new EventHandler(ExposureValueChanged);
            }
        }
コード例 #11
0
        private void GetWhiteBalance()
        {
            CameraPropertySettings whiteBalanceSettings = camera.CaptureDevice.GetVideoPropertySettings(VideoProcAmpProperty.WhiteBalance);

            whiteBalanceTrackBar.Minimum     = whiteBalanceSettings.Minimum;
            whiteBalanceTrackBar.Maximum     = whiteBalanceSettings.Maximum;
            whiteBalanceTrackBar.SmallChange = whiteBalanceSettings.Step;
            whiteBalanceTrackBar.LargeChange = RELATIVE_LARGE_TRACKBAR_STEP * whiteBalanceSettings.Step;
            int currentValue = camera.CaptureDevice.GetVideoProperty(VideoProcAmpProperty.WhiteBalance);

            whiteBalanceTrackBar.Value = currentValue;
            whiteBalanceTextBox.Text   = currentValue.ToString();
            if (whiteBalanceSettings.Minimum == whiteBalanceSettings.Maximum)
            {
                whiteBalanceTrackBar.Enabled = false;
                whiteBalanceTextBox.Enabled  = false;
            }
            else
            {
                whiteBalanceTrackBar.ValueChanged += new EventHandler(WhiteBalanceChanged);
            }
        }
コード例 #12
0
        private void GetGammaRange()
        {
            CameraPropertySettings gammaSettings = camera.CaptureDevice.GetVideoPropertySettings(VideoProcAmpProperty.Gamma);

            gammaTrackBar.Minimum     = gammaSettings.Minimum;
            gammaTrackBar.Maximum     = gammaSettings.Maximum;
            gammaTrackBar.SmallChange = gammaSettings.Step;
            gammaTrackBar.LargeChange = RELATIVE_LARGE_TRACKBAR_STEP * gammaSettings.Step;
            int currentValue = camera.CaptureDevice.GetVideoProperty(VideoProcAmpProperty.Gamma);

            gammaTrackBar.Value = currentValue;
            gammaTextBox.Text   = currentValue.ToString();
            if (gammaSettings.Minimum == gammaSettings.Maximum)
            {
                gammaTrackBar.Enabled = false;
                gammaTextBox.Enabled  = false;
            }
            else
            {
                gammaTrackBar.ValueChanged += new EventHandler(GammaValueChanged);
            }
        }