/// <summary> /// Displays the specified image in a window and waits the user to create a rectangle by drawing. /// <para>Press and hold shift + mouse (track-pad) to translate and zoom an image.</para> /// </summary> /// <param name="image">Image to display.</param> /// <param name="windowTitle">Window title (ID).</param> /// <param name="scaleForm">True to adjust form to the image size, false otherwise.</param> /// <returns>Drawn rectangle.</returns> public static RectangleF GetRectangle(this Bgr <byte>[,] image, string windowTitle = "Draw rectangle (close when finished)", bool scaleForm = false) { var rect = FormCollection.CreateAndShowDialog(() => { var f = new DrawingRectangleForm(windowTitle); f.ScaleForm = scaleForm; f.SetImage(image); return(f); }, f => f.Rectangle); return(rect); }
/// <summary> /// Displays the specified image in a window and waits the user to create a mask by drawing. /// <para>Press and hold shift + mouse (track-pad) to translate and zoom an image.</para> /// </summary> /// <param name="image">Image to display.</param> /// <param name="windowTitle">Window title (ID).</param> /// <param name="scaleForm">True to adjust form to the image size, false otherwise.</param> /// <returns>Drawn mask.</returns> public static Gray <byte>[,] GetMask(this Bgr <byte>[,] image, string windowTitle = "Draw image mask (close when finished)", bool scaleForm = false) { var mask = FormCollection.CreateAndShowDialog(() => { var f = new DrawingPenForm(windowTitle); f.ScaleForm = scaleForm; f.SetImage(image); return(f); }, f => f.Mask); return(mask); }
/// <summary> /// Draws contour. /// </summary> /// <param name="image">Input image.</param> /// <param name="contour">Contour points.</param> /// <param name="color">Contour color.</param> /// <param name="thickness">Contours thickness.</param> /// <param name="opacity">Sets alpha channel where 0 is transparent and 255 is full opaque.</param> public unsafe static void Draw(this Bgr <byte>[,] image, Point[] contour, Bgr <byte> color, int thickness, byte opacity = Byte.MaxValue) { var contourHandle = GCHandle.Alloc(contour, GCHandleType.Pinned); using (var img = image.Lock()) { var iplImage = img.AsCvIplImage(); //TODO - noncritical: implement with cvContour CvCoreInvoke.cvPolyLine(&iplImage, new IntPtr[] { contourHandle.AddrOfPinnedObject() }, new int[] { contour.Length }, 1, true, color.ToCvScalar(), thickness, LineTypes.EightConnected, 0); } contourHandle.Free(); }
/// <summary> /// Draws circles. /// </summary> /// <param name="image">Input image.</param> /// <param name="circles">Circles</param> /// <param name="color">Circle color.</param> /// <param name="thickness">Contours thickness.</param> public unsafe static void Draw(this Bgr <byte>[,] image, IEnumerable <Circle> circles, Bgr <byte> color, int thickness) { using (var img = image.Lock()) { var iplImage = img.AsCvIplImage(); foreach (var circle in circles) { var center = new Point(circle.X, circle.Y); CvCoreInvoke.cvCircle(&iplImage, center, circle.Radius, color.ToCvScalar(), thickness, LineTypes.EightConnected, 0); } } }
public static void Convert(Hsv <byte> hsv, ref Bgr <byte> bgr) { if (hsv.S == 0) { bgr.R = hsv.V; bgr.G = hsv.V; bgr.B = hsv.V; return; } int hue = hsv.H * 2; //move to [0-360 range] (only needed for byte!) int hQuadrant = hue / 60; // Hue quadrant 0 - 5 (60deg) int hOffset = hue % 60; // Hue position in quadrant int vs = hsv.V * hsv.S; byte p = (byte)(hsv.V - (vs / 255)); byte q = (byte)(hsv.V - (vs / 255 * hOffset) / 60); byte t = (byte)(hsv.V - (vs / 255 * (60 - hOffset)) / 60); switch (hQuadrant) { case 0: bgr.R = hsv.V; bgr.G = t; bgr.B = p; break; case 1: bgr.R = q; bgr.G = hsv.V; bgr.B = p; break; case 2: bgr.R = p; bgr.G = hsv.V; bgr.B = t; break; case 3: bgr.R = p; bgr.G = q; bgr.B = hsv.V; break; case 4: bgr.R = t; bgr.G = p; bgr.B = hsv.V; break; default: bgr.R = hsv.V; bgr.G = p; bgr.B = q; break; } }
/// <summary> /// Displays the image and enables the user selects an area. /// <para>Press and hold any key to temporary block the calling thread (useful when used with video sequence stream).</para> /// </summary> /// <param name="image">Image to display.</param> /// <param name="windowTitle">Window title (ID).</param> /// <param name="onDrawn">Action executed when a rectangle is drawn (when mouse is released).</param> /// <param name="scaleForm">True to adjust form to the image size, false otherwise.</param> /// <param name="startBlocked"> /// Used only when a form is first initialized. True to start as a dialog, false to show the form in non-blocking way. /// <para>When form is the blocking state (dialog) user is required to press and release a key to enable non-blocking mode.</para> /// </param> public static void GetRectangle(this Bgr <byte>[,] image, string windowTitle = "Draw rectangle", Action <RectangleF> onDrawn = null, bool scaleForm = false, bool startBlocked = false) { ManualResetEvent resetEvent = null; FormCollection.CreateOrUpdate( () => new DrawingRectangleForm(windowTitle, !startBlocked), form => { form.ScaleForm = scaleForm; form.SetImage(image); resetEvent = form.ResetEvent; form.OnDrawn = onDrawn; }, windowTitle); resetEvent.WaitOne(); }
public static void Convert(Bgr <byte> bgr, ref Hsv <byte> hsv) { byte rgbMin, rgbMax; rgbMin = bgr.R < bgr.G ? (bgr.R < bgr.B ? bgr.R : bgr.B) : (bgr.G < bgr.B ? bgr.G : bgr.B); rgbMax = bgr.R > bgr.G ? (bgr.R > bgr.B ? bgr.R : bgr.B) : (bgr.G > bgr.B ? bgr.G : bgr.B); hsv.V = rgbMax; if (hsv.V == 0) { hsv.H = 0; hsv.S = 0; return; } hsv.S = (byte)(255 * (rgbMax - rgbMin) / rgbMax); if (hsv.S == 0) { hsv.H = 0; return; } int hue = 0; if (rgbMax == bgr.R) { hue = 0 + 60 * (bgr.G - bgr.B) / (rgbMax - rgbMin); if (hue < 0) { hue += 360; } } else if (rgbMax == bgr.G) { hue = 120 + 60 * (bgr.B - bgr.R) / (rgbMax - rgbMin); } else //rgbMax == bgr.B { hue = 240 + 60 * (bgr.R - bgr.G) / (rgbMax - rgbMin); } hsv.H = (byte)(hue / 2); //scale [0-360] . [0-180] (only needed for byte!) //Debug.Assert(hue >= 0 && hue <= 360); }
/// <summary> /// Sets the specified image. /// </summary> /// <param name="image">Image to display.</param> public void SetImage(Bgr <byte>[,] image) { if (bmp == null || bmp.Width != image.Width() || bmp.Height != image.Height()) { bmp = new Bitmap(image.Width(), image.Height(), PixelFormat.Format24bppRgb); } using (BitmapData bmpData = bmp.Lock()) using (var uIm = image.Lock()) { Copy.UnsafeCopy2D(uIm.ImageData, bmpData.Data, uIm.Stride, bmpData.ScanWidth, uIm.Height); } PictureBox.Image = bmp; if (ScaleForm) { ClientSize = new Size(image.Width(), image.Height()); } }
/// <summary> /// Displays an color picker dialog. /// <para>REQUIREMENT: calling thread must be STAThread.</para> /// </summary> /// <param name="defaultColor">Default color.</param> /// <returns>Picked or default color in case the selection is cancelled.</returns> public static Bgr <byte> PickColor(Bgr <byte> defaultColor = default(Bgr <byte>)) { Bgr <byte> color = defaultColor; using (ColorDialog dialog = new ColorDialog()) { dialog.Color = new Eto.Drawing.Color { Bb = defaultColor.B, Gb = defaultColor.G, Rb = defaultColor.R }; var result = dialog.ShowDialog(null); if (result == DialogResult.Ok) { color = new Bgr <byte> { B = (byte)dialog.Color.Bb, G = (byte)dialog.Color.Gb, R = (byte)dialog.Color.Rb } } ; } return(color); }
/// <summary> /// Draws Box2D. /// </summary> /// <param name="image">Input image.</param> /// <param name="box">Box 2D.</param> /// <param name="color">Object's color.</param> /// <param name="thickness">Border thickness (-1 to fill the object).</param> /// <param name="opacity">Sets alpha channel where 0 is transparent and 255 is full opaque.</param> public unsafe static void Draw(this Bgr <byte>[,] image, Box2D box, Bgr <byte> color, int thickness, byte opacity = Byte.MaxValue) { if (thickness < 1) { throw new NotSupportedException("Only positive values are valid!"); } var vertices = box.GetVertices(); draw(image, opacity, cvImg => { for (int i = 0; i < vertices.Length; i++) { int idx2 = (i + 1) % vertices.Length; CvCoreInvoke.cvLine(&cvImg, vertices[i].Round(), vertices[idx2].Round(), color.ToCvScalar(), thickness, LineTypes.EightConnected, 0); } }); }
public static void Convert(Rgb <byte> rgb, ref Bgr <byte> bgr) { rgb.R = bgr.R; rgb.G = bgr.G; rgb.B = bgr.B; }
/// <summary> /// Encodes the specified image into the specified image type byte array. /// </summary> /// <param name="image">Image to encode.</param> /// <param name="extension">Image type extension (.bmp, .png, .jpg)</param> /// <returns>Image type byte array.</returns> public static byte[] Encode(this Bgr <ushort>[,] image, string extension) { return(encode(image, extension, null)); }
/// <summary> /// Encodes the specified image into the PNG byte array. /// </summary> /// <param name="image">Image to encode.</param> /// <param name="pngCompression">PNG compression level [0..9] where 9 is the highest compression.</param> /// <returns>PNG byte array.</returns> public static byte[] EncodeAsPng(this Bgr <ushort>[,] image, int pngCompression = 3) { return(encodeAsPng(image, pngCompression)); }
/// <summary> /// Converts the source color to the destination color. /// </summary> /// <param name="image">Source image.</param> /// <param name="area">Working area.</param> /// <returns>image with converted color.</returns> public static Gray <byte>[,] ToGray(this Bgr <byte>[,] image, Rectangle area) { return(image.Convert <Bgr <byte>, Gray <byte> >(Bgr <byte> .Convert, area)); }
/// <summary> /// Converts 8-bit Bgra to 8-bit Bgr color. /// </summary> /// <param name="bgra">Source color.</param> /// <param name="bgr">Destination color.</param> public static void Convert(Bgra <byte> bgra, ref Bgr <byte> bgr) { bgr.B = bgra.B; bgr.G = bgra.G; bgr.R = bgra.R; }
/// <summary> /// Gets System.Drawing.Color from Bgr8 color. /// </summary> /// <param name="color">Color.</param> /// <param name="opacity">Opacity. If color has 4 channels opacity is discarded.</param> /// <returns>System.Drawing.Color</returns> public static System.Drawing.Color ToColor(this Bgr <byte> color, byte opacity = Byte.MaxValue) { return(Color.FromArgb(opacity, color.R, color.G, color.B)); }
/// <summary> /// Draws circles. /// </summary> /// <param name="image">Input image.</param> /// <param name="circles">Circles</param> /// <param name="color">Circle color.</param> /// <param name="thickness">Contours thickness.</param> /// <param name="opacity">Sets alpha channel where 0 is transparent and 255 is full opaque.</param> public unsafe static void Draw(this Bgr <byte>[,] image, IEnumerable <Circle> circles, Bgr <byte> color, int thickness, byte opacity = Byte.MaxValue) { draw(image, opacity, cvImg => { foreach (var circle in circles) { var center = new Point(circle.X, circle.Y); CvCoreInvoke.cvCircle(&cvImg, center, circle.Radius, color.ToCvScalar(), thickness, LineTypes.EightConnected, 0); } }); }
/// <summary> /// Draws text on the provided image. /// </summary> /// <param name="image">Input image.</param> /// <param name="text">User text.</param> /// <param name="font">Font.</param> /// <param name="botomLeftPoint">Bottom-left point.</param> /// <param name="color">Text color.</param> /// <param name="opacity">Sets alpha channel where 0 is transparent and 255 is full opaque.</param> public unsafe static void Draw(this Bgr <byte>[,] image, string text, Font font, Point botomLeftPoint, Bgr <byte> color, byte opacity = Byte.MaxValue) { draw(image, opacity, cvImg => { CvCoreInvoke.cvPutText(&cvImg, text, botomLeftPoint, ref font, color.ToCvScalar()); }); }
/// <summary> /// Converts the source color to the destination color. /// </summary> /// <param name="image">Source image.</param> /// <param name="area">Working area.</param> /// <returns>image with converted color.</returns> public static Hsv <byte>[,] ToHsv(this Bgr <byte>[,] image, Rectangle area) { return(image.Convert <Bgr <byte>, Hsv <byte> >(Bgr <byte> .Convert, area)); }
/// <summary> /// Converts the source color to the destination color. /// </summary> /// <param name="image">Source image.</param> /// <returns>image with converted color.</returns> public static Hsv <byte>[,] ToHsv(this Bgr <byte>[,] image) { return(image.Convert <Bgr <byte>, Hsv <byte> >(Bgr <byte> .Convert)); }
public static CvScalar ToCvScalar(this Bgr <byte> color, byte opacity = Byte.MaxValue) { return(new CvScalar { V0 = color.B, V1 = color.G, V2 = color.R, V3 = opacity }); }
/// <summary> /// Converts the source channel depth to the destination channel depth. /// </summary> /// <typeparam name="TDepth">Destination channel depth.</typeparam> /// <param name="image">Image.</param> /// <returns>Image with converted element depth.</returns> public static Bgr <TDepth>[,] Cast <TDepth>(this Bgr <double>[,] image) where TDepth : struct { return(image.ConvertChannelDepth <Bgr <double>, Bgr <TDepth> >()); }
/// <summary> /// Draws text on the provided image. /// </summary> /// <param name="image">Input image.</param> /// <param name="text">User text.</param> /// <param name="font">Font.</param> /// <param name="botomLeftPoint">Bottom-left point.</param> /// <param name="color">Text color.</param> /// <param name="opacity">Sets alpha channel where 0 is transparent and 255 is full opaque.</param> public unsafe static void Draw(this Bgr <byte>[,] image, string text, Font font, Point botomLeftPoint, Bgr <byte> color, byte opacity = Byte.MaxValue) { using (var img = image.Lock()) { var iplImage = img.AsCvIplImage(); CvCoreInvoke.cvPutText(&iplImage, text, botomLeftPoint, ref font, color.ToCvScalar()); } }
/// <summary> /// Saves the specified image. /// </summary> /// <param name="image">Image to save.</param> /// <param name="fileName">Image filename.</param> public static void Save(this Bgr <double>[,] image, string fileName) { image.Save <Bgr <double> >(fileName); }
/// <summary> /// Converts 8-bit gray intensity to the 8-bit Bgr color. /// </summary> /// <param name="gray">Source color.</param> /// <param name="bgr">Destination color.</param> public static void Convert(Gray <T> gray, ref Bgr <T> bgr) { bgr.B = gray.Intensity; bgr.G = gray.Intensity; bgr.R = gray.Intensity; }
/// <summary> /// Encodes the specified image into the Jpeg byte array. /// </summary> /// <param name="image">Image to encode.</param> /// <param name="jpegQuality">Jpeg quality [0..100] where 100 is the highest quality.</param> /// <returns>Jpeg byte array.</returns> public static byte[] EncodeAsJpeg(this Bgr <ushort>[,] image, int jpegQuality = 95) { return(encodeAsJpeg(image, jpegQuality)); }
public static CvScalar ToCvScalar(this Bgr <byte> color) { return(new CvScalar { V0 = color.B, V1 = color.G, V2 = color.R, V3 = Byte.MaxValue }); }
/// <summary> /// Converts the source color to the destination color. /// </summary> /// <param name="image">Source image.</param> /// <returns>image with converted color.</returns> public static Gray <byte>[,] ToGray(this Bgr <byte>[,] image) { return(image.Convert <Bgr <byte>, Gray <byte> >(Bgr <byte> .Convert)); }
/// <summary> /// Saves the specified image. /// </summary> /// <param name="image">Image to save.</param> /// <param name="fileName">Image filename.</param> public static void Save(this Bgr <ushort>[,] image, string fileName) { image.Save <Bgr <ushort> >(fileName); }
/// <summary> /// Converts the source color to the destination color. /// </summary> /// <param name="image">Source image.</param> /// <param name="area">Working area.</param> /// <returns>image with converted color.</returns> public static Bgra <byte>[,] ToBgra(this Bgr <byte>[,] image, Rectangle area) { return(image.Convert <Bgr <byte>, Bgra <byte> >(Bgr <byte> .Convert, area)); }