예제 #1
0
        /// <summary>
        /// build template List from a Gray image
        /// </summary>
        /// <param name="image">input image</param>
        /// <param name="buildXMLTemplateFile">true to build a xml file with current templates</param>
        /// <param name="angles">the number of angles, default to 360</param>
        /// <param name="sizes">number of sizes, default to 1</param>
        /// <param name="minRatio">The ratio of smallest size to original, default to 0.6</param>
        /// <param name="maxFeaturesPerLevel">the array of maximum features per pyrimid level, default to 200 in DEFAULT_MAX_FEATURES_PER_LEVEL from ImageTemplatePyramid.cs:56,
        ///                                     increase to increase the precision in expense of detection time-delay</param>
        /// <param name="userFunc">Input User Function for customization and diversity</param>
        /// <returns>List of templates.</returns>
        public static List <TemplatePyramid> buildTemplate(Gray <byte>[,] image, int Width, int Height, bool buildXMLTemplateFile = false, int angles = 360, int sizes = 1, float minRatio = 0.6f, int[] maxFeaturesPerLevel = null, Func <TemplatePyramid, Gray <byte> [, ], TemplatePyramid> userFunc = null)
        {
            List <TemplatePyramid> retList = new List <TemplatePyramid>();
            float Ratio = 1;

            Gray <byte>[,] tempIMG;
            rotateLoad(retList, image, angles, Width, Height, false, userFunc: validateFeatures);
            for (int i = 0; i < sizes - 1; i++)
            {
                Ratio -= (float)(1 - minRatio) / sizes;
                int width  = (int)(image.Width() * Ratio);
                int height = (int)(image.Height() * Ratio);

                DotImaging.Primitives2D.Size Nsize = new DotImaging.Primitives2D.Size(width, height);
                tempIMG = ResizeExtensions_Gray.Resize(image, Nsize, Accord.Extensions.Imaging.InterpolationMode.NearestNeighbor);

                rotateLoad(retList, tempIMG, angles, Width, Height, false, maxFeaturesPerLevel, image.ToString(), userFunc: userFunc);
            }
            if (buildXMLTemplateFile)
            {
                XMLTemplateSerializer <ImageTemplatePyramid <ImageTemplate>, ImageTemplate> .ToFile(retList,
                                                                                                    Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).FullName, "Resources", "template" + ".xml"));
            }

            return(retList);
        }
예제 #2
0
 /// <summary>
 /// Creates a Rectangle from Point and Size values.
 /// </summary>
 /// <param name="location">Location.</param>
 /// <param name="size">Size.</param>
 public Rectangle(Point location, Size size)
 {
     x = location.X;
     y = location.Y;
     width = size.Width;
     height = size.Height;
 }
예제 #3
0
 /// <summary>
 /// Clamps point coordinate according to the specified size (0,0, size.Width, size.Height).
 /// </summary>
 /// <param name="point">The point to clamp.</param>
 /// <param name="size">The valid region.</param>
 /// <returns>Clamped point.</returns>
 public static Point Clamp(this Point point, Size size)
 {
     return new Point
     {
         X = System.Math.Min(System.Math.Max(0, point.X), size.Width),
         Y = System.Math.Min(System.Math.Max(0, point.Y), size.Height)
     };
 }
예제 #4
0
        /// <summary>
        /// Creates new video writer.
        /// </summary>
        /// <param name="fileName">Video file name.</param>
        /// <param name="frameSize">Video frame size.</param>
        /// <param name="fps">Specifies the number of frames per second.</param>
        /// <param name="isColor">Specifies whether the image is color image (3 channels) or grayscale image (one channel).</param>
        /// <param name="videoCodec">Specifies used codec for video encoding.</param>
        public VideoWriter(string fileName, Size frameSize, float fps, bool isColor, VideoCodec videoCodec)
        {
            this.CanSeek = false;
             this.IsLiveStream = true;

             this.OutputFileName = fileName;
             this.ColorFrames = isColor;
             this.Codec = videoCodec;
             this.FrameSize = frameSize;
             this.FrameRate = fps;

             this.Open(); //to enable property change
        }
        /// <summary>
        /// Inflates the rectangle by specified width and height (can be negative) and automatically clamps rectangle coordinates.
        /// </summary>
        /// <param name="rect">Rectangle to inflate.</param>
        /// <param name="widthScale">Horizontal scale.</param>
        /// <param name="heightScale">Vertical scale.</param>
        /// <param name="constrainedArea">If specified rectangle region will be clamped.</param>
        /// <returns>Inflated rectangle.</returns>
        public static Rectangle Inflate(this Rectangle rect, double widthScale, double heightScale, Size constrainedArea = default(Size))
        {
            Rectangle newRect = new Rectangle
            {
                X = (int)(rect.X - rect.Width * widthScale / 2),
                Y = (int)(rect.Y - rect.Height * heightScale / 2),
                Width = (int)(rect.Width + rect.Width * widthScale),
                Height = (int)(rect.Height + rect.Height * heightScale)
            };

            if (constrainedArea.IsEmpty == false)
                newRect.Intersect(new Rectangle(new Point(), constrainedArea));

            return newRect;
        }
        /// <summary>
        /// Inflates the rectangle by specified width and height (can be negative) and automatically clamps rectangle coordinates.
        /// </summary>
        /// <param name="rect">Rectangle to inflate.</param>
        /// <param name="width">Horizontal amount.</param>
        /// <param name="height">Vertical amount.</param>
        /// <param name="constrainedArea">If specified rectangle region will be clamped.</param>
        /// <returns>Inflated rectangle.</returns>
        public static Rectangle Inflate(this Rectangle rect, int width, int height, Size constrainedArea = default(Size))
        {
            Rectangle newRect = new Rectangle
            {
                X = rect.X - width,
                Y = rect.Y - height,
                Width = rect.Width + 2 * width,
                Height = rect.Height + 2 * height
            };

            if (constrainedArea.IsEmpty == false)
                newRect.Intersect(new Rectangle(new Point(), constrainedArea));

            return newRect;
        }
예제 #7
0
 /// <summary>
 /// Translates a PointF by the negative of a specified size.
 /// </summary>
 /// <param name="pt">Point.</param>
 /// <param name="sz">Offset.</param>
 /// <returns>PointF structure.</returns>
 public static PointF Subtract(PointF pt, Size sz)
 {
     return new PointF(pt.X - sz.Width, pt.Y - sz.Height);
 }
예제 #8
0
 /// <summary>
 /// Translates a PointF by the positive of a specified size.
 /// </summary>
 /// <param name="pt">Point.</param>
 /// <param name="sz">Offset.</param>
 /// <returns>PointF structure.</returns>
 public static PointF Add(PointF pt, Size sz)
 {
     return new PointF(pt.X + sz.Width, pt.Y + sz.Height);
 }
예제 #9
0
        public static bool SetImageSize(IntPtr capturePtr, Size newSize)
        {
            bool success;
            success = CvHighGuiInvoke.cvSetCaptureProperty(capturePtr, CaptureProperty.FrameWidth, newSize.Width);
            success &= CvHighGuiInvoke.cvSetCaptureProperty(capturePtr, CaptureProperty.FrameHeight, newSize.Height);

            return success;
        }
예제 #10
0
 public static extern IntPtr cvCreateVideoWriter([MarshalAs(UnmanagedType.LPStr)] String filename, int fourcc, double fps, Size frameSize, [MarshalAs(UnmanagedType.Bool)] bool isColor);
예제 #11
0
 /// <summary>
 /// Creates a Point from a Size value.
 /// </summary>
 /// <param name="sz">Size.</param>
 public Point(Size sz)
 {
     x = sz.Width;
     y = sz.Height;
 }
예제 #12
0
        /// <summary>
        /// build template List from a XML file
        /// </summary>
        /// <param name="filename">input XML file name, the file has to be in the current directory </param>
        /// <param name="buildXMLTemplateFile">true to build a xml file with current templates</param>
        /// <param name="angles">the number of angles, default to 360</param>
        /// <param name="sizes">number of sizes, default to 1</param>
        /// <param name="CropToSqr">decides whether to crop the image to sqrside to prevent edges issues</param>
        /// <param name="maxFeaturesPerLevel">the array of maximum features per pyrimid level, default (null) would evaluate to 200 in DEFAULT_MAX_FEATURES_PER_LEVEL from ImageTemplatePyramid.cs:56,
        ///                                     increase to increase the precision in expense of detection time-delay</param>
        /// <param name="userFunc">Input User Function for customization and diversity</param>
        /// <returns>List of templates.</returns>
        public static List <TemplatePyramid> fromFiles(String[] files, bool buildXMLTemplateFile = false, int angles = 360, int sizes = 1, bool CropToSqr = false, int[] maxFeaturesPerLevel = null, Func <TemplatePyramid, Gray <byte> [, ], TemplatePyramid> userFunc = null)
        {
            Console.WriteLine("Building templates from files...");
            Gray <byte>[,] ResizedtemplatePic;
            var list = new List <TemplatePyramid>();

            string resourceDir = Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).FullName, "Resources");

            //string[] files = Directory.GetFiles(resourceDir, fileName);
            if (files.Length == 0)
            {
                throw new Exception("NO FILE FOUND");
            }
            object syncObj = new object();


            foreach (var file in files)
            {
                int   shortSide, SqrSide, inputWidth, inputHeight;
                float FileRatio = 1;
                Gray <byte>[,] preparedBWImage;
                for (int j = 0; j < sizes; j++)
                {
                    Console.WriteLine("Size # " + j);
                    try
                    {
                        preparedBWImage = ImageIO.LoadGray(file).Clone();
                    }
                    catch
                    {
                        Console.WriteLine("Error occurs when loading " + file);
                        continue;
                    }

                    FileRatio -= (float)0.01;
                    int width  = (int)(preparedBWImage.Width() * FileRatio);
                    int height = (int)(preparedBWImage.Height() * FileRatio);
                    if (FileRatio < 0)
                    {
                        Console.WriteLine("Too many sizes to build, Max 100");
                        FileRatio = 1;
                        break;
                    }
                    DotImaging.Primitives2D.Size Nsize = new DotImaging.Primitives2D.Size(width, height);
                    ResizedtemplatePic = ResizeExtensions_Gray.Resize(preparedBWImage, Nsize, Accord.Extensions.Imaging.InterpolationMode.NearestNeighbor);

                    try
                    {
                        //var tp = TemplatePyramid.CreatePyramidFromPreparedBWImage(preparedBWImage, new FileInfo(file + "  " + i * 10).Name, ImageAngle, maxNumberOfFeaturesPerLevel: maxFeaturesPerLevel);
                        shortSide   = (preparedBWImage.Width() < preparedBWImage.Height()) ? preparedBWImage.Width() : preparedBWImage.Height();
                        SqrSide     = (int)(shortSide / Math.Sqrt(2));
                        inputWidth  = CropToSqr ? SqrSide : preparedBWImage.Width();
                        inputHeight = CropToSqr ? SqrSide : preparedBWImage.Height();

                        rotateLoad(list, preparedBWImage, angles, inputWidth, inputHeight, false, maxFeaturesPerLevel, file, userFunc);
                    }
                    catch (Exception)
                    { }
                }
                //}
            }
            if (buildXMLTemplateFile)
            {
                XMLTemplateSerializer <ImageTemplatePyramid <ImageTemplate>, ImageTemplate> .ToFile(list, Path.Combine(resourceDir, files[0].Substring(0, files[0].IndexOf(".")) + ".xml"));
            }
            return(list);
        }
예제 #13
0
 /// <summary>
 /// Creates new video writer (with default codec).
 /// </summary>
 /// <param name="fileName">Video file name.</param>
 /// <param name="frameSize">Video frame size.</param>
 /// <param name="fps">Specifies the number of frames per second.</param>
 /// <param name="isColor">Specifies whether the image is color image (3 channels) or grayscale image (one channel).</param>
 public VideoWriter(string fileName, Size frameSize, float fps = 30, bool isColor = true)
     : this(fileName, frameSize, fps, isColor, VideoCodec.MotionJpeg)
 {
 }
예제 #14
0
 /// <summary>
 /// Enlarges this rectangle by the specified amount.
 /// </summary>
 /// <param name="size">The amount to inflate this rectangle.</param>
 public void Inflate(Size size)
 {
     x -= size.Width;
     y -= size.Height;
     Width += size.Width * 2;
     Height += size.Height * 2;
 }
예제 #15
0
 /// <summary>
 /// Calculates the binding rectangle for the given text string when the font is used
 /// </summary>
 /// <param name="text">Input string</param>
 /// <param name="baseline">y-coordinate of the baseline relatively to the bottom-most text point</param>
 /// <returns>size of the text string. Height of the text does not include the height of character parts that are below the baseline</returns>
 public Size GetTextSize(string text, int baseline)
 {
     var size = new Size();
     CvCoreInvoke.cvGetTextSize(text, ref this, ref size, ref baseline);
     return size;
 }
예제 #16
0
파일: Size.cs 프로젝트: bestwpw/dot-imaging
 /// <summary>
 /// Adds two Size structures.
 /// </summary>
 /// <param name="sz1">First structure.</param>
 /// <param name="sz2">Second structure.</param>
 /// <returns>Size structure.</returns>
 public static Size Add(Size sz1, Size sz2)
 {
     return new Size(sz1.Width + sz2.Width,
                     sz1.Height + sz2.Height);
 }
        /// <summary>
        /// Changes rectangle's location in order to fit the specified area.
        /// </summary>
        /// <param name="rect">Rectangle.</param>
        /// <param name="area">Valid bounding box.</param>
        /// <param name="translatedRectangle">Translated rectangle.</param>
        /// <returns>True if the translation exist, false otherwise.</returns>
        public static bool MoveToFit(this Rectangle rect, Size area, out Rectangle translatedRectangle)
        {
            var leftOffset = (rect.X < 0) ? -rect.X : 0;
            var topOffset = (rect.Y < 0) ? -rect.Y : 0;

            rect.X += leftOffset;
            rect.Y += topOffset;

            var rightOffset = (rect.Right > area.Width) ? (area.Width - rect.Right) : 0;
            var bottomOffset = (rect.Bottom > area.Height) ? (area.Height - rect.Bottom) : 0;

            rect.X += rightOffset;
            rect.Y += bottomOffset;

            translatedRectangle = rect;
            if (rect.X < 0 || rect.Y < 0 || rect.Right > area.Width || rect.Bottom > area.Height)
                return false;

            return true;
        }
 /// <summary>
 /// Calculates intersected rectangle from specified area (transformed into rectangle with location (0,0)) 
 /// which can be useful for image area intersections.
 /// </summary>
 /// <param name="rect">Rectangle to intersect.</param>
 /// <param name="area">Maximum bounding box represented as size.</param>
 /// <param name="preserveScale">
 /// If true the size components will be cropped by equal amount.
 /// If false the size ratio will not be checked.
 /// </param>
 /// <returns>Intersected rectangle.</returns>
 public static Rectangle Intersect(this Rectangle rect, Size area, bool preserveScale = false)
 {
     Rectangle newRect = rect.Intersect(new Rectangle(0, 0, area.Width, area.Height), preserveScale);
     return newRect;
 }
예제 #19
0
 public static unsafe extern void cvEllipse(IplImage* img, Point center, Size axes, double angle, double startAngle, double endAngle,
     CvScalar color, int thickness,
     LineTypes lineType, int shift);
예제 #20
0
 public static extern void cvGetTextSize([MarshalAs(UnmanagedType.LPStr)] String textString, ref Font font, ref Size textSize, ref int baseline);
예제 #21
0
파일: Size.cs 프로젝트: bestwpw/dot-imaging
 /// <summary>
 /// Subtracts two Size structures.
 /// </summary>
 /// <param name="sz1">First structure.</param>
 /// <param name="sz2">Second structure.</param>
 /// <returns>Size structure.</returns>
 public static Size Subtract(Size sz1, Size sz2)
 {
     return new Size(sz1.Width - sz2.Width,
                     sz1.Height - sz2.Height);
 }
예제 #22
0
        /// <summary>
        /// Build template with the cemara
        ///
        /// State Machine---->
        /// int -> build template -> resize to find the best -> draw the template then comfirm by user ->
        /// rotate for angles ->done and return
        ///
        /// make sure the object is in green circle
        /// </summary>
        /// <param name="name">template name, default to "Template" if the name is null</param>
        /// <param name="templPyrs">the template list that to be used</param
        /// <param name="videoCapture">the video stream</param>
        /// <param name="pictureBox">the picture box of window form</param>
        /// <param name="minRatio">The ratio of smallest size to original, default to 0.4</param>
        /// /// <returns>nothing.</returns>
        public void TemplateCapture(ref List <TemplatePyramid> templPyrs, ImageStreamReader videoCapture, PictureBox pictureBox, string name = null, float minCalibrationRatio = 0.4f)
        {
            if (name == null)
            {
                name = "Template";
            }

#if runXML
            try
            {
                Console.WriteLine("Reading from existing Template Data");
                templPyrs = fromXML(name);
                Cap       = State.Done;
            }
            catch (Exception)
            {
                Console.WriteLine("\nTemplate NOT found! \n initiating camera...");
            }
#endif
            switch (Cap)
            {
            case State.Init:
                videoCapture.ReadTo(ref frame);
                if (frame == null)
                {
                    return;
                }



                drawFrameWork(frame);

                pictureBox.Image = frame.ToBitmap();     //it will be just casted (data is shared) 24bpp color
                GC.Collect();
                break;

            case State.BuildingTemplate:
                Console.WriteLine("building template");
                videoCapture.ReadTo(ref frame);

                if (frame == null)
                {
                    return;
                }

                templatePic = frame.ToGray();

                //var list = new List<TemplatePyramid>();
                try
                {
                    if (templPyrs == null)
                    {
                        templPyrs = new List <TemplatePyramid>();
                    }
                    rotateLoad(templPyrs, templatePic, 1, frame.Width(), frame.Height(), userFunc: validateFeatures);
                }
                catch (Exception)
                {
                    Console.WriteLine("ERROR IN CREATING TEMPLATE!");

                    return;
                }

                Cap = State.Calibrate;
                break;

            case State.Calibrate:
                Console.WriteLine("calibrating template   " + CabRatio + "    " + templatePic.Width() * CabRatio);
                var bestRepresentatives = findObjects(frame, templPyrs);
                if (bestRepresentatives.Count == 0)
                {
                    if (templPyrs.Count != 0)
                    {
                        templPyrs.RemoveAt(templPyrs.Count - 1);
                    }
                    CabRatio -= (float)0.01;
                    int width  = (int)(templatePic.Width() * CabRatio);
                    int height = (int)(templatePic.Height() * CabRatio);
                    if (CabRatio < minCalibrationRatio)
                    {
                        Console.WriteLine("Calibration failed");
                        CabRatio = 1;
                        Cap      = State.Init;
                    }
                    DotImaging.Primitives2D.Size Nsize = new DotImaging.Primitives2D.Size(width, height);
                    ResiizedtemplatePic = ResizeExtensions_Gray.Resize(templatePic, Nsize, Accord.Extensions.Imaging.InterpolationMode.NearestNeighbor);

                    try
                    {
                        templPyrs.Add(TemplatePyramid.CreatePyramidFromPreparedBWImage(
                                          ResiizedtemplatePic, new FileInfo(name + " #" + TPindex++).Name, 0));
                    }
                    catch (Exception)
                    {
                        Console.WriteLine("ERROR IN CALIBRATING TEMPLATE!");
                    }
                }
                else
                {
                    ResiizedtemplatePic = (ResiizedtemplatePic == null ? templatePic : ResiizedtemplatePic);

                    CaptureFrame(templPyrs, videoCapture, pictureBox);
                    drawFrameWork(frame);
                    pictureBox.Image = frame.ToBitmap();     //it will be just casted (data is shared) 24bpp color

                    Cap = State.Confirm;
                }
                break;

            case State.Confirm:
                Console.WriteLine("comfirm Template, press Y to continue, press R to retry, and other keys to abort");
                string a = Console.ReadLine();

                switch (a)
                {
                case "y":
                    Cap = State.Rotate;
                    break;

                case "r":
                    templPyrs.RemoveAt(templPyrs.Count - 1);

                    Cap = State.Init;
                    break;

                default:
                    Cap = State.Done;
                    break;
                }
                //if (a == "y") Cap = State.Rotate;
                //else
                //{
                //    Cap = State.Init;
                //}
                break;

            case State.Rotate:
                int SqrSide = (int)(frame.Height() / Math.Sqrt(2));
                templPyrs.AddRange(buildTemplate(ResiizedtemplatePic, SqrSide, SqrSide, false, totalAngles, totalSizes, 0.5f, null, validateFeatures));
                //ResiizedtemplatePic, totalAngles, SqrSide, SqrSide, true, userFunc: validateFeatures));


                Cap = State.ConfirmDone;
                break;

            case State.ConfirmDone:
                Console.WriteLine("Do you want to build a new template? press y to build another template, other keys to abort");
                string OtherTemplate = Console.ReadLine();
                if (OtherTemplate == "y" || OtherTemplate == "Y")
                {
                    Cap = State.Init;
                }
                else
                {
                    string resourceDir = Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).FullName, "Resources");
                    XMLTemplateSerializer <ImageTemplatePyramid <ImageTemplate>, ImageTemplate> .ToFile(templPyrs, Path.Combine(resourceDir, name + ".xml"));

                    Cap = State.Done;
                }
                break;

            //break;
            case State.Done:
                CaptureFrame(templPyrs, videoCapture, pictureBox);
                GC.Collect();
                break;
                //break;
            }
            pictureBox.Image = frame.ToBitmap(); //it will be just casted (data is shared) 24bpp color
        }