C# Image.And方法代码示例

 public static Bitmap GetIntersection(Bitmap img1, Bitmap img2)
 {
     using (Image<Gray, byte> ip1 = new Image<Gray, byte>(img1))
     using (Image<Gray, byte> ip2 = new Image<Gray, byte>(img2))
     { return ip1.And(ip2).ToBitmap(); }
 }

        private void ThresholdColorizePupilFullImage()
        {
            // Threshold (whole image)
            Image<Gray, byte> pupilImage = gray.ThresholdBinaryInv(new Gray(Settings.Instance.Processing.PupilThreshold), new Gray(255));

            // Convert thresholded to color and add
            Image<Bgr, byte> pupilThresholdImage = new Image<Bgr, byte>(width, height, new Bgr(Settings.Instance.Visualization.PupilThresholdColor));
            pupilThresholdImage = pupilThresholdImage.And(pupilImage.Convert<Bgr, byte>());
            processed = processed.Add(pupilThresholdImage);

            pupilThresholdImage.Dispose();
            pupilImage.Dispose();
        }

        private void ThresholdColorizeGlintsFullImage()
        {
            // Threshold (whole image)
            Image<Gray, byte> glintImage = gray.ThresholdBinary(new Gray(Settings.Instance.Processing.GlintThreshold), new Gray(255));

            // Convert thresholded to color and add
            // Negate the selected color (unary minus) otherwise yellow becomes blue, green = red etc. 
            Color c = Settings.Instance.Visualization.GlintThresholdColor;
            Color glintNegated = Color.FromArgb(c.A, 255 - c.R, 255 - c.G, 255 - c.B);

            Image<Bgr, byte> glintThresholdImage = new Image<Bgr, byte>(width, height, new Bgr(glintNegated));
            glintThresholdImage = glintThresholdImage.And(glintImage.Convert<Bgr, byte>());
            processed = processed.Sub(glintThresholdImage);

            glintThresholdImage.Dispose();
            glintImage.Dispose();
        }

        /// <summary>
        /// the main function in this class 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void FrameGrabber(object sender, EventArgs e)
        {
            sw.Start();
            newImage = grabber.QueryFrame();

            count++;
            if (newImage != null)
            {
                current_image = newImage.Convert<Gray, byte>();
                detector.Process(newImage, tempImage);

                tempImage = tempImage.ThresholdBinary(thresholdValue, MaxValue);
                tempImage = tempImage.Dilate(2);
                tempImage = tempImage.SmoothMedian(3);

                newImageG = current_image.ThresholdBinaryInv(new Gray(threshold), new Gray(255d));
                newImageG = newImageG.And(tempImage);
                newImageG = newImageG.Dilate(1);

                if (numberOfHands > 0)
                {
                    int tt = numberOfHands;
                    for (int i = 0; i < tt; i++)
                    {
                        if (x[i] != null)
                        {
                            try
                            {
                                x[i].StartTracking(elapsed_time);
                            }

                     
                            catch(Exception ex)
                            {
                                Console.WriteLine("lost traking : number  of hands {0} & list x {1}", numberOfHands, x.Count);
                                int id = x[i].id;
                                hand_centers[id] = x[i].new_center_pt;
                                hand_centers.Remove(id);
                                x.RemoveAt(id);
                                --numberOfHands;

                            }
                        }

                    }

                }


                if (numberOfHands < hand_detected)
                {
                    detected_hand = HandDetection(newImageG);
                    if (detected_hand.Any())// any elements in the list
                    {
                        foreach (Contour<Point> h in detected_hand)
                        {
                            if (numberOfHands < hand_detected)
                            {

                                y = new HandTracking(current_image.Width, current_image.Height, hand_centers[numberOfHands]);

                                y.ExtractFeatures(h);
                                y.id = numberOfHands;
                                x.Add(y);

                                numberOfHands++;

                            }
                            else
                                Console.WriteLine("there is already 2 hands");
                        }
                        detected_hand.Clear();

                    }
                }

                sw.Stop();
                elapsed_time = sw.Elapsed.TotalMilliseconds;
           
                sw.Reset();
                imageBoxSkin.Image = newImage;
                imageBoxFrameGrabber.Image = newImageG;




            }
        }

 private Image<Gray, float> combineMotionAndGradient(Image<Gray,float> gradient, Image<Gray,float> motion)
 {
     return gradient.And(motion);
 }

        /// <summary>
        /// Simple helper function that will test to make sure that more than a certain percentage
        /// of the shred is non a transparent color.
        /// </summary>
        /// <param name="shred"></param>
        /// <returns></returns>
        public static bool TransparencyFilter(Bitmap shred)
        {
            Image<Bgr, Byte> image1 = new Image<Bgr, byte>(shred);

            Image<Bgr, byte> transparentImage = image1.And(new Bgr(Color.Transparent));
            long nonTransparent = transparentImage.CountNonzero().Sum();
            long totalPixels = transparentImage.Height * transparentImage.Width;
            double ratio = (double)nonTransparent / (double)totalPixels;
            return (ratio > MinTransparencyRatio);
        }

        private static Image<Bgr, Byte> ExtractContourImage(Image<Bgr, Byte> image, Contour<Point> contour, out Image<Gray, Byte> mask)
        {
            mask = image.Convert<Gray, Byte>();
            mask.SetZero();
            mask.Draw(contour, new Gray(255), new Gray(0), 2, -1);

            return image.And(new Bgr(255, 255, 255), mask);
        }

        private Image<Bgr, Byte> ExtractContourImage(Image<Bgr, Byte> source, Contour<Point> contour, out Image<Gray, Byte> mask)
        {
            mask = source.Convert<Gray, Byte>();
            mask.SetZero();
            //Contour<Point> shifted = ShiftContour(contour, -3,-3);
            mask.Draw(contour, new Gray(255), new Gray(0), 2, -1);

            return source.And(new Bgr(255, 255, 255), mask);
        }

        private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                _image = GetImage(@"d:\raw\classified\3_9_0.jpg");

                var tmpImage = GetImage(@"d:\raw\classified\3_9_1.jpg");

                _image.And(tmpImage,null);

                _inputArray = _image;

                pictureBox1.Image = _image.ToBitmap();
            }
            catch (Exception ex)
            {

                throw;
            }

            //var _ocr = new Tesseract(@"D:\", "eng", OcrEngineMode.TesseractCubeCombined);
            //_ocr.SetVariable("tessedit_char_whitelist", "1234567890");

            ////var tmp = FilterPlate(img);

            //_ocr.Recognize(_image);

            //var result = _ocr.GetCharacters();
        }

        /// <summary>
        /// Simple helper function that will test to make sure that more than a certain percentage
        /// of the shred is non a transparent color.
        /// </summary>
        /// <param name="shred"></param>
        /// <returns></returns>
        public static bool TransparencyFilter(Bitmap shred)
        {
            Image<Bgr,Byte> image1 = new Image<Bgr, byte>(shred);

            var MIN_TRANSPARENCY_RATIO = 0.6;
            var transparentImage = image1.And(new Bgr(Color.Transparent));
            var nonTransparent = transparentImage.CountNonzero().Sum();
            var totalPixels = transparentImage.Height*transparentImage.Width;
            var ratio = (double)(nonTransparent/totalPixels);
            return (ratio > MIN_TRANSPARENCY_RATIO);
        }