public string Process(Bitmap bitmap)
        {
            // When video device initializes it adapts to
            // background for some frames.
            if (_skipStartingFrames > 0)
            {
                _skipStartingFrames--;
                return(null);
            }

            using (var grayScaleImage = GrayScaleImageHelper.ToGrayScale(bitmap))
            {
                if (_previous == null)
                {
                    byte[,] imageTMinus1MeanWH;
                    byte[,] imageTMinus1VarianceWH;
                    GrayScaleImageHelper.CalculateMeanAndVarianceM9(
                        grayScaleImage,
                        out imageTMinus1MeanWH,
                        out imageTMinus1VarianceWH);

                    _previous = new RadiometricSimilarityImage(
                        grayScaleImage,
                        imageTMinus1MeanWH,
                        imageTMinus1VarianceWH
                        );

                    _grayScaleBackground = (Bitmap)grayScaleImage.Clone();
                    return(null);
                }

                var        bounds      = new Rectangle(0, 0, grayScaleImage.Width, grayScaleImage.Height);
                BitmapData bitmapData  = grayScaleImage.LockBits(bounds, ImageLockMode.ReadOnly, grayScaleImage.PixelFormat);
                var        grayScaleHW = new byte[grayScaleImage.Height * bitmapData.Stride];
                Marshal.Copy(bitmapData.Scan0, grayScaleHW, 0, grayScaleImage.Height * bitmapData.Stride);
                grayScaleImage.UnlockBits(bitmapData);

                byte[,] imageTMean;
                byte[,] imageTVariance;
                byte[,] motionWH;
                bool motionPresents;
                GrayScaleImageHelper.CalculateMeanAndVarianceM9(
                    grayScaleImage.Width,
                    grayScaleImage.Height,
                    bitmapData.Stride,
                    grayScaleHW,

                    out imageTMean,
                    out imageTVariance);
                var current = new RadiometricSimilarityImage(grayScaleImage.Width,
                                                             grayScaleImage.Height,
                                                             bitmapData.Stride,
                                                             grayScaleHW,
                                                             imageTMean, imageTVariance);

                byte[,] motionData, stationaryData;
                Bitmap motionImage, stationaryImage;
                GrayScaleImageHelper.GetRadiometricSimmilarity(
                    _previous,
                    current,
                    RadiometricDifferenceThrethhold,
                    out motionData,
                    out motionImage,

                    out stationaryData,
                    out stationaryImage);
                {
                    using (motionImage)
                    {
                        _interceptor.Intercept(RadiometricSimmilarityFrameTFrameTMinus1Motion, ImageHelper.ToBytes(motionImage));
                    }

                    using (stationaryImage)
                    {
                        _interceptor.Intercept(RadiometricSimmilarityFrameTFrameTMinus1Stationary, ImageHelper.ToBytes(stationaryImage));
                    }

                    UpdateBackgroundOrForeground(
                        motionData,
                        grayScaleImage.Width,
                        grayScaleImage.Height,
                        bitmapData.Stride,
                        grayScaleHW,
                        out motionPresents,
                        out motionWH);
                }

                _previous = current;

                using (var image = GrayScaleImageHelper.FromWH(motionWH))
                {
                    _interceptor.Intercept(DifferenceImage, ImageHelper.ToBytes(image));
                }

                if (motionPresents)
                {
                    return("Movement detected!");
                }
            }
            return(null);
        }
示例#2
0
        public string Process(Bitmap bitmap)
        {
            // When video device initializes it adapts to
            // background for some frames.
            if (_skipStartingFrames > 0)
            {
                _skipStartingFrames--;
                return(null);
            }

            using (var grayScaleImage = GrayScaleImageHelper.ToGrayScale(bitmap))
            {
                if (_grayScaleFrameTMinus1 == null ||
                    _grayScaleBackground == null)
                {
                    _grayScaleFrameTMinus1 = (Bitmap)grayScaleImage.Clone();
                    GrayScaleImageHelper.CalculateMeanAndVarianceM9(
                        _grayScaleFrameTMinus1,
                        out _imageTMinus1MeanWH,
                        out _imageTMinus1VarianceWH);
                    _grayScaleBackground = (Bitmap)grayScaleImage.Clone();
                    return(null);
                }

                var        bounds      = new Rectangle(0, 0, grayScaleImage.Width, grayScaleImage.Height);
                BitmapData bitmapData  = grayScaleImage.LockBits(bounds, ImageLockMode.ReadOnly, grayScaleImage.PixelFormat);
                var        grayScaleHW = new byte[grayScaleImage.Height * bitmapData.Stride];
                Marshal.Copy(bitmapData.Scan0, grayScaleHW, 0, grayScaleImage.Height * bitmapData.Stride);

                byte[,] imageTMean;
                byte[,] imageTVariance;
                byte[,] temporalImageAnalysisResultHW;
                byte[,] motionWH;
                bool motionPresents;
                using (var temporalImageAnalysisResult = GetRadiometricSimmilarity(
                           grayScaleImage.Width,
                           grayScaleImage.Height,
                           bitmapData.Stride,
                           grayScaleHW,
                           out temporalImageAnalysisResultHW,
                           out imageTMean,
                           out imageTVariance))
                {
                    _interceptor.Intercept(RadiometricSimmilarity, temporalImageAnalysisResult);

                    UpdateBackgroundOrForeground(
                        temporalImageAnalysisResultHW,
                        grayScaleImage.Width,
                        grayScaleImage.Height,
                        bitmapData.Stride,
                        grayScaleHW,
                        out motionPresents,
                        out motionWH);
                }

                _imageTMinus1MeanWH     = imageTMean;
                _imageTMinus1VarianceWH = imageTVariance;
                _grayScaleFrameTMinus1  = (Bitmap)grayScaleImage.Clone();
                grayScaleImage.UnlockBits(bitmapData);

                _interceptor.Intercept(DifferenceImage, GrayScaleImageHelper.FromWH(motionWH));

                if (motionPresents)
                {
                    return("Movement detected!");
                }
            }
            return(null);
        }