/src/Core/Utility.cs

Large files files are truncated, but you can click here to view the full file

/////////////////////////////////////////////////////////////////////////////////

// Paint.NET                                                                   //

// Copyright (C) dotPDN LLC, Rick Brewster, Tom Jackson, and contributors.     //

// Portions Copyright (C) Microsoft Corporation. All Rights Reserved.          //

// See src/Resources/Files/License.txt for full licensing and attribution      //

// details.                                                                    //

// .                                                                           //

/////////////////////////////////////////////////////////////////////////////////



using System.Linq;

using PaintDotNet.Base;

using PaintDotNet.SystemLayer;

using System;

using System.Collections;

using System.Collections.Generic;

using System.ComponentModel;

using System.Drawing;

using System.Drawing.Drawing2D;

using System.Drawing.Imaging;

using System.IO;

using System.Net;

using System.Reflection;

using System.Runtime.InteropServices;

using System.Runtime.Serialization.Formatters.Binary;

using System.Text;

using System.Windows.Forms;



namespace PaintDotNet

{

    /// <summary>

    /// Defines miscellaneous constants and static functions.

    /// </summary>

    /// // TODO: refactor into mini static classes

    public static class Utility

    {

        internal static bool IsNumber(float x)

        {

            return x >= float.MinValue && x <= float.MaxValue;

        }



        internal static bool IsNumber(double x)

        {

            return x >= double.MinValue && x <= double.MaxValue;

        }



        internal static int Min(int val0, params int[] vals)

        {

            int min = val0;



            foreach (int t in vals)

            {

                if (t < min)

                {

                    min = t;

                }

            }



            return min;

        }



        internal static int Max(int val0, params int[] vals)

        {

            int max = val0;



            foreach (int t in vals)

            {

                if (t > max)

                {

                    max = t;

                }

            }



            return max;

        }



        public static PointF[] GetRgssOffsets(int quality)

        {

            unsafe

            {

                int sampleCount = quality * quality;

                var samplesArray = new PointF[sampleCount];



                fixed (PointF* pSamplesArray = samplesArray)

                {

                    GetRgssOffsets(pSamplesArray, sampleCount, quality);

                }



                return samplesArray;

            }

        }



        public static unsafe void GetRgssOffsets(PointF* samplesArray, int sampleCount, int quality)

        {

            if (sampleCount < 1)

            {

                throw new ArgumentOutOfRangeException("sampleCount", "sampleCount must be [0, int.MaxValue]");

            }



            if (sampleCount != quality * quality)

            {

                throw new ArgumentOutOfRangeException("sampleCount != (quality * quality)");

            }



            if (sampleCount == 1)

            {

                samplesArray[0] = new PointF(0.0f, 0.0f);

            }

            else

            {

                for (int i = 0; i < sampleCount; ++i)

                {

                    double y = (i + 1d) / (sampleCount + 1d);

                    double x = y * quality;



                    x -= (int)x;



                    samplesArray[i] = new PointF((float)(x - 0.5d), (float)(y - 0.5d));

                }

            }

        }



        public static bool IsObsolete(Type type, bool inherit)

        {

            object[] attrs = type.GetCustomAttributes(typeof(ObsoleteAttribute), inherit);

            return (attrs.Length != 0);

        }



        public static void DrawDropShadow1Px(Graphics g, Rectangle rect)

        {

            Brush b0 = new SolidBrush(Color.FromArgb(15, Color.Black));

            Brush b1 = new SolidBrush(Color.FromArgb(47, Color.Black));

            var p2 = new Pen(Color.FromArgb(63, Color.Black));



            g.FillRectangle(b0, rect.Left, rect.Top, 1, 1);

            g.FillRectangle(b1, rect.Left + 1, rect.Top, 1, 1);

            g.FillRectangle(b1, rect.Left, rect.Top + 1, 1, 1);



            g.FillRectangle(b0, rect.Right - 1, rect.Top, 1, 1);

            g.FillRectangle(b1, rect.Right - 2, rect.Top, 1, 1);

            g.FillRectangle(b1, rect.Right - 1, rect.Top + 1, 1, 1);



            g.FillRectangle(b0, rect.Left, rect.Bottom - 1, 1, 1);

            g.FillRectangle(b1, rect.Left + 1, rect.Bottom - 1, 1, 1);

            g.FillRectangle(b1, rect.Left, rect.Bottom - 2, 1, 1);



            g.FillRectangle(b0, rect.Right - 1, rect.Bottom - 1, 1, 1);

            g.FillRectangle(b1, rect.Right - 2, rect.Bottom - 1, 1, 1);

            g.FillRectangle(b1, rect.Right - 1, rect.Bottom - 2, 1, 1);



            g.DrawLine(p2, rect.Left + 2, rect.Top, rect.Right - 3, rect.Top);

            g.DrawLine(p2, rect.Left, rect.Top + 2, rect.Left, rect.Bottom - 3);

            g.DrawLine(p2, rect.Left + 2, rect.Bottom - 1, rect.Right - 3, rect.Bottom - 1);

            g.DrawLine(p2, rect.Right - 1, rect.Top + 2, rect.Right - 1, rect.Bottom - 3);



            b0.Dispose();

            b0 = null;

            b1.Dispose();

            b1 = null;

            p2.Dispose();

            p2 = null;

        }



        public static Keys LetterOrDigitCharToKeys(char c)

        {

            if (c >= 'a' && c <= 'z')

            {

                return (Keys)(c - 'a' + (int)Keys.A);

            }

            if (c >= 'A' && c <= 'Z')

            {

                return (Keys)(c - 'A' + (int)Keys.A);

            }

            if (c >= '0' && c <= '9')

            {

                return (Keys)(c - '0' + (int)Keys.D0);

            }

            return Keys.None;

        }



        public static Control FindFocus()

        {

            return (from Form form in Application.OpenForms select FindFocus(form)).FirstOrDefault(focused => focused != null);

        }



        private static Control FindFocus(Control c)

        {

            return c.Focused ? c : (from Control child in c.Controls select FindFocus(child)).FirstOrDefault(f => f != null);

        }



        public static void DrawColorRectangle(Graphics g, Rectangle rect, Color color, bool drawBorder)

        {

            int inflateAmt = drawBorder ? -2 : 0;

            Rectangle colorRectangle = Rectangle.Inflate(rect, inflateAmt, inflateAmt);

            Brush colorBrush = new LinearGradientBrush(colorRectangle, Color.FromArgb(255, color), color, 90.0f, false);

            var backgroundBrush = new HatchBrush(HatchStyle.LargeCheckerBoard, Color.FromArgb(191, 191, 191), Color.FromArgb(255, 255, 255));



            if (drawBorder)

            {

                g.DrawRectangle(Pens.Black, rect.Left, rect.Top, rect.Width - 1, rect.Height - 1);

                g.DrawRectangle(Pens.White, rect.Left + 1, rect.Top + 1, rect.Width - 3, rect.Height - 3);

            }



            PixelOffsetMode oldPOM = g.PixelOffsetMode;

            g.PixelOffsetMode = PixelOffsetMode.Half;

            g.FillRectangle(backgroundBrush, colorRectangle);

            g.FillRectangle(colorBrush, colorRectangle);

            g.PixelOffsetMode = oldPOM;



            backgroundBrush.Dispose();

            colorBrush.Dispose();

        }



        public static Size ComputeThumbnailSize(Size originalSize, int maxEdgeLength)

        {

            Size thumbSize;



            if (originalSize.Width > originalSize.Height)

            {

                int longSide = Math.Min(originalSize.Width, maxEdgeLength);

                thumbSize = new Size(longSide, Math.Max(1, (originalSize.Height * longSide) / originalSize.Width));

            }

            else if (originalSize.Height > originalSize.Width)

            {

                int longSide = Math.Min(originalSize.Height, maxEdgeLength);

                thumbSize = new Size(Math.Max(1, (originalSize.Width * longSide) / originalSize.Height), longSide);

            }

            else // if (docSize.Width == docSize.Height)

            {

                int longSide = Math.Min(originalSize.Width, maxEdgeLength);

                thumbSize = new Size(longSide, longSide);

            }



            return thumbSize;

        }



        public static bool IsClipboardImageAvailable()

        {

            try

            {

                return System.Windows.Forms.Clipboard.ContainsImage() || 

                    System.Windows.Forms.Clipboard.ContainsData(DataFormats.EnhancedMetafile);

            }



            catch (ExternalException)

            {

                return false;

            }

        }



        public static Font CreateFont(string name, float size, FontStyle style)

        {

            Font returnFont;



            try

            {

                returnFont = new Font(name, size, style);

            }



            catch (Exception)

            {

                returnFont = new Font(FontFamily.GenericSansSerif, size);

            }



            return returnFont;

        }



        public static Font CreateFont(string name, float size, string backupName, float backupSize, FontStyle style)

        {

            Font returnFont;



            try

            {

                returnFont = new Font(name, size, style);

            }



            catch (Exception)

            {

                returnFont = CreateFont(backupName, backupSize, style);

            }



            return returnFont;

        }

        

        public static readonly Color TransparentKey = Color.FromArgb(192, 192, 192);



        public static string WebExceptionToErrorMessage(WebException wex)

        {

            string errorMessage;



            switch (wex.Status)

            {

                case WebExceptionStatus.ProtocolError:

                    string format = PdnResources.GetString("WebExceptionStatus.ProtocolError.Format");

                    HttpStatusCode statusCode = ((HttpWebResponse)wex.Response).StatusCode;

                    errorMessage = string.Format(format, statusCode, (int)statusCode);

                    break;



                default:

                    string stringName = "WebExceptionStatus." + wex.Status;

                    errorMessage = PdnResources.GetString(stringName);

                    break;

            }



            return errorMessage;

        }



        private static bool _allowGcFullCollect = true;

        public static bool AllowGCFullCollect

        {

            get

            {

                return _allowGcFullCollect;

            }



            set

            {

                _allowGcFullCollect = value;

            }

        }



        public static void GCFullCollect()

        {

            if (!AllowGCFullCollect) return;

            GC.Collect();

            GC.WaitForPendingFinalizers();

            GC.Collect();

            GC.WaitForPendingFinalizers();

        }



        private static int _defaultSimplificationFactor = 50;

        public static int DefaultSimplificationFactor

        {

            get

            {

                return _defaultSimplificationFactor;

            }



            set

            {

                _defaultSimplificationFactor = value;

            }

        }



        public static bool IsArrowKey(Keys keyData)

        {

            Keys key = keyData & Keys.KeyCode;



            return key == Keys.Up || key == Keys.Down || key == Keys.Left || key == Keys.Right;

        }



        public static bool DoesControlHaveMouseCaptured(Control control)

        {

            bool result = false;



            result |= control.Capture;



            return control.Controls.Cast<Control>().Aggregate(result, (current, c) => current | DoesControlHaveMouseCaptured(c));

        }



        public static void SplitRectangle(Rectangle rect, Rectangle[] rects)

        {

            int height = rect.Height;



            for (int i = 0; i < rects.Length; ++i)

            {

                Rectangle newRect = Rectangle.FromLTRB(rect.Left,

                                                       rect.Top + ((height * i) / rects.Length),

                                                       rect.Right,

                                                       rect.Top + ((height * (i + 1)) / rects.Length));



                rects[i] = newRect;

            }

        }



        public static long TicksToMs(long ticks)

        {

            return ticks / 10000;

        }



        public static string GetStaticName(Type type)

        {

            PropertyInfo pi = type.GetProperty("StaticName", BindingFlags.Static | BindingFlags.Public | BindingFlags.GetProperty);

            return (string)pi.GetValue(null, null);

        }



        public static readonly float[][] Identity5X5F = new[]

                                                            {

                                                                          new float[] { 1, 0, 0, 0, 0 },

                                                                          new float[] { 0, 1, 0, 0, 0 },

                                                                          new float[] { 0, 0, 1, 0, 0 },

                                                                          new float[] { 0, 0, 0, 1, 0 },

                                                                          new float[] { 0, 0, 0, 0, 1 } 

                                                                      };



        public static readonly ColorMatrix IdentityColorMatrix = new ColorMatrix(Identity5X5F);



        [ThreadStatic]

        private static Matrix _identityMatrix;

        public static Matrix IdentityMatrix

        {

            get

            {

                if (_identityMatrix == null)

                {

                    _identityMatrix = new Matrix();

                    _identityMatrix.Reset();

                }



                return _identityMatrix;

            }

        }



        /// <summary>

        /// Rounds an integer to the smallest power of 2 that is greater

        /// than or equal to it.

        /// </summary>

        public static int Log2RoundUp(int x)

        {

            if (x == 0)

            {

                return 1;

            }



            if (x == 1)

            {

                return 1;

            }



            return 1 << (1 + HighestBit(x - 1));

        }



        private static int HighestBit(int x)

        {

            if (x == 0)

            {

                return 0;

            }



            int b = 0;

            int hi = 0;



            while (b <= 30)

            {

                if ((x & (1 << b)) != 0)

                {

                    hi = b;

                }



                ++b;

            }



            return hi;

        }



/*

        private int CountBits(int x)

        {

            var y = (uint)x;

            int count = 0;



            for (int bit = 0; bit < 32; ++bit)

            {

                if ((y & ((uint)1 << bit)) != 0)

                {

                    ++count;

                }

            }



            return count;       //POSSIBLE UNUSED METHOD

        }

*/



        public static string RemoveSpaces(string s)

        {

            var sb = new StringBuilder();



            foreach (char c in s.Where(c => !char.IsWhiteSpace(c)))

            {

                sb.Append(c);

            }



            return sb.ToString();

        }

        

        public static int Max(int[,] array)

        {

            int max = int.MinValue;



            for (int i = array.GetLowerBound(0); i <= array.GetUpperBound(0); ++i)

            {

                for (int j = array.GetLowerBound(1); j <= array.GetUpperBound(1); ++j)

                {

                    if (array[i,j] > max)

                    {

                        max = array[i,j];

                    }

                }

            }



            return max;

        }



        public static int Sum(int[][] array)

        {

            int sum = 0;



            foreach (int[] row in array)

            {

                sum = row.Sum();

            }



            return sum;

        }



        // TODO: obsolete these NUD funcitons, move them into PdnNumericUpDown

        public static void ClipNumericUpDown(NumericUpDown upDown)

        {

            if (upDown.Value < upDown.Minimum)

            {

                upDown.Value = upDown.Minimum;

            }

            else if (upDown.Value > upDown.Maximum)

            {

                upDown.Value = upDown.Maximum;

            }

        }



        public static bool GetUpDownValueFromText(NumericUpDown nud, out double val)

        {

            if (nud.Text == string.Empty)

            {

                val = 0;

                return false;

            }

            try

            {

                val = nud.DecimalPlaces == 0 ? int.Parse(nud.Text) : double.Parse(nud.Text);

            }



            catch

            {

                val = 0;

                return false;

            }



            return true;

        }



        public static bool CheckNumericUpDown(NumericUpDown upDown)

        {

            int a;

            bool result = int.TryParse(upDown.Text, out a);



            return result && (a <= (int)upDown.Maximum) && (a >= (int)upDown.Minimum);

        }



        public static void SetNumericUpDownValue(NumericUpDown upDown, decimal newValue)

        {

            if (upDown.Value != newValue)

            {

                upDown.Value = newValue;

            }

        }



        public static void SetNumericUpDownValue(NumericUpDown upDown, int newValue)

        {

            SetNumericUpDownValue(upDown, (decimal)newValue);

        }



        public static string SizeStringFromBytes(long bytes)

        {

            var bytesDouble = (double)bytes;

            string toStringFormat;

            string formatString;



            if (bytesDouble > (1024 * 1024 * 1024))

            {

                // Gigs

                bytesDouble /= 1024 * 1024 * 1024;

                toStringFormat = "F1";

                formatString = PdnResources.GetString("Utility.SizeStringFromBytes.GBFormat");

            }

            else if (bytesDouble > (1024 * 1024))

            {

                // Megs

                bytesDouble /= 1024 * 1024;

                toStringFormat = "F1";

                formatString = PdnResources.GetString("Utility.SizeStringFromBytes.MBFormat");

            }

            else if (bytesDouble > (1024))

            {

                // K

                bytesDouble /= 1024;

                toStringFormat = "F1";

                formatString = PdnResources.GetString("Utility.SizeStringFromBytes.KBFormat");

            }

            else

            {

                // Bytes

                toStringFormat = "F0";

                formatString = PdnResources.GetString("Utility.SizeStringFromBytes.BytesFormat");

            }



            string bytesString = bytesDouble.ToString(toStringFormat);

            string sizeString = string.Format(formatString, bytesString);



            return sizeString;

        }



        public static void ShowWiaError(IWin32Window owner)

        {

            // WIA requires Windows XP SP1 or later, or Windows Server 2003

            // So if we know they're on WS2k3, we tell them to enable WIA.

            // If they're on XP or later, tell them that WIA isn't available.

            // Otherwise we tell them they need XP SP1 (for the Win2K folks).

            ErrorBox(owner,

                             OS.Type == OSType.Server

                                 ? PdnResources.GetString("WIA.Error.EnableMe")

                                 : PdnResources.GetString("WIA.Error.UnableToLoad"));

        }



        public static void ShowNonAdminErrorBox(IWin32Window parent)

        {

            ErrorBox(parent, PdnResources.GetString("NonAdminErrorBox.Message"));

        }



        public static void ErrorBox(IWin32Window parent, string message)

        {

            MessageBox.Show(parent, message, PdnInfo.GetBareProductName(), MessageBoxButtons.OK, MessageBoxIcon.Error);

        }



        public static DialogResult ErrorBoxOkCancel(IWin32Window parent, string message)

        {

            return MessageBox.Show(parent, message, PdnInfo.GetBareProductName(), MessageBoxButtons.OKCancel, MessageBoxIcon.Error);

        }



        public static void InfoBox(IWin32Window parent, string message)

        {

            MessageBox.Show(parent, message, PdnInfo.GetBareProductName(), MessageBoxButtons.OK, MessageBoxIcon.Information);

        }



        public static DialogResult InfoBoxOkCancel(IWin32Window parent, string message)

        {

            return MessageBox.Show(parent, message, PdnInfo.GetBareProductName(), MessageBoxButtons.OKCancel, MessageBoxIcon.Information);

        }



        public static DialogResult AskOkCancel(IWin32Window parent, string question)

        {

            return MessageBox.Show(parent, question, PdnInfo.GetBareProductName(), MessageBoxButtons.OKCancel, MessageBoxIcon.Question);

        }



        public static DialogResult AskYesNo(IWin32Window parent, string question)

        {

            return MessageBox.Show(parent, question, PdnInfo.GetBareProductName(), MessageBoxButtons.YesNo, MessageBoxIcon.Question);

        }



        public static DialogResult AskYesNoCancel(IWin32Window parent, string question)

        {

            return MessageBox.Show(parent, question, PdnInfo.GetBareProductName(), MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

        }



        public static Icon ImageToIcon(Image image)

        {

            return ImageToIcon(image, TransparentKey);

        }



        public static Icon ImageToIcon(Image image, bool disposeImage)

        {

            return ImageToIcon(image, TransparentKey, disposeImage);

        }



        public static Icon ImageToIcon(Image image, Color seeThru)

        {

            return ImageToIcon(image, seeThru, false);

        }



        /// <summary>

        /// Converts an Image to an Icon.

        /// </summary>

        /// <param name="image">The Image to convert to an icon. Must be an appropriate icon size (32x32, 16x16, etc).</param>

        /// <param name="seeThru">The color that will be treated as transparent in the icon.</param>

        /// <param name="disposeImage">Whether or not to dispose the passed-in Image.</param>

        /// <returns>An Icon representation of the Image.</returns>

        public static Icon ImageToIcon(Image image, Color seeThru, bool disposeImage)

        {

            var bitmap = new Bitmap(image);



            for (int y = 0; y < bitmap.Height; ++y)

            {

                for (int x = 0; x < bitmap.Width; ++x)

                {

                    if (bitmap.GetPixel(x, y) == seeThru)

                    {

                        bitmap.SetPixel(x, y, Color.FromArgb(0));

                    }

                }

            }



            Icon icon = Icon.FromHandle(bitmap.GetHicon());

            bitmap.Dispose();



            if (disposeImage)

            {

                image.Dispose();

            }



            return icon;

        }



        public static Icon BitmapToIcon(Bitmap bitmap, bool disposeBitmap)

        {

            Icon icon = Icon.FromHandle(bitmap.GetHicon());



            if (disposeBitmap)

            {

                bitmap.Dispose();

            }



            return icon;

        }



        public static Icon SurfaceToIcon(Surface surface, bool disposeSurface)

        {

            Bitmap bitmap = surface.CreateAliasedBitmap();

            Icon icon = Icon.FromHandle(bitmap.GetHicon());



            bitmap.Dispose();



            if (disposeSurface)

            {

                surface.Dispose();

            }



            return icon;

        }



        public static Point GetRectangleCenter(Rectangle rect)

        {

            return new Point((rect.Left + rect.Right) / 2, (rect.Top + rect.Bottom) / 2);

        }



        public static PointF GetRectangleCenter(RectangleF rect)

        {

            return new PointF((rect.Left + rect.Right) / 2, (rect.Top + rect.Bottom) / 2);

        }



        public static Scanline[] GetRectangleScans(Rectangle rect)

        {

            var scans = new Scanline[rect.Height];



            for (int y = 0; y < rect.Height; ++y)

            {

                scans[y] = new Scanline(rect.X, rect.Y + y, rect.Width);

            }



            return scans;

        }



        public static Scanline[] GetRegionScans(Rectangle[] region)

        {

            int scanCount = region.Sum(t => t.Height);



            var scans = new Scanline[scanCount];

            int scanIndex = 0;



            foreach (Rectangle rect in region)

            {

                for (int y = 0; y < rect.Height; ++y)

                {

                    scans[scanIndex] = new Scanline(rect.X, rect.Y + y, rect.Width);

                    ++scanIndex;

                }

            }



            return scans;

        }



        public static Rectangle[] ScanlinesToRectangles(Scanline[] scans)

        {

            return ScanlinesToRectangles(scans, 0, scans.Length);

        }



        public static Rectangle[] ScanlinesToRectangles(Scanline[] scans, int startIndex, int length)

        {

            var rects = new Rectangle[length];



            for (int i = 0; i < length; ++i)

            {

                Scanline scan = scans[i + startIndex];

                rects[i] = new Rectangle(scan.X, scan.Y, scan.Length, 1);

            }



            return rects;

        }



        /// <summary>

        /// Found on Google Groups when searching for "Region.Union" while looking

        /// for bugs:

        /// ---

        /// Hello,

        /// 

        /// I did not run your code, but I know Region.Union is flawed in both 1.0 and

        /// 1.1, so I assume it is in the gdi+ unmanged code dll.  The best workaround,

        /// in terms of speed, is to use a PdnGraphicsPath, but it must be a path with

        /// FillMode = FillMode.Winding. You add the rectangles to the path, then you do

        /// union onto an empty region with the path. The important point is to do only

        /// one union call on a given empty region. We created a "super region" object

        /// to hide all these bugs and optimize clipping operations. In fact, it is much

        /// faster to use the path than to call Region.Union for each rectangle.

        /// 

        /// Too bad about Region.Union. A lot of people will hit this bug, as it is

        /// essential in high-performance animation.

        /// 

        /// Regards,

        /// Frank Hileman

        /// Prodige Software Corporation

        /// ---

        /// </summary>

        /// <param name="rectsF"></param>

        /// <param name="startIndex"></param>

        /// <param name="length"></param>

        /// <returns></returns>

        public static PdnRegion RectanglesToRegion(RectangleF[] rectsF, int startIndex, int length)

        {

            PdnRegion region;



            if (rectsF == null || rectsF.Length == 0 || length == 0)

            {

                region = PdnRegion.CreateEmpty();

            }

            else

            {

                using (var path = new PdnGraphicsPath())

                {

                    path.FillMode = FillMode.Winding;



                    if (startIndex == 0 && length == rectsF.Length)

                    {

                        path.AddRectangles(rectsF);

                    }

                    else

                    {

                        for (int i = startIndex; i < startIndex + length; ++i)

                        {

                            path.AddRectangle(rectsF[i]);

                        }

                    }



                    region = new PdnRegion(path);

                }

            }



            return region;

        }



        public static PdnRegion RectanglesToRegion(RectangleF[] rectsF)

        {

            return RectanglesToRegion(rectsF, 0, rectsF != null ? rectsF.Length : 0);

        }



        public static PdnRegion RectanglesToRegion(RectangleF[] rectsF1, RectangleF[] rectsF2, params RectangleF[][] rectsFA)

        {

            using (var path = new PdnGraphicsPath())

            {

                path.FillMode = FillMode.Winding;



                if (rectsF1 != null && rectsF1.Length > 0)

                {

                    path.AddRectangles(rectsF1);

                }



                if (rectsF2 != null && rectsF2.Length > 0)

                {

                    path.AddRectangles(rectsF2);

                }

               

                foreach (RectangleF[] rectsF in rectsFA.Where(rectsF => rectsF != null && rectsF.Length > 0))

                {

                    path.AddRectangles(rectsF);

                }



                return new PdnRegion(path);

            }

        }



        public static PdnRegion RectanglesToRegion(Rectangle[] rects, int startIndex, int length)

        {

            PdnRegion region;



            if (length == 0)

            {

                region = PdnRegion.CreateEmpty();

            }

            else

            {

                using (var path = new PdnGraphicsPath())

                {

                    path.FillMode = FillMode.Winding;

                    if (startIndex == 0 && length == rects.Length)

                    {

                        path.AddRectangles(rects);

                    }

                    else

                    {

                        for (int i = startIndex; i < startIndex + length; ++i)

                        {

                            path.AddRectangle(rects[i]);

                        }

                    }



                    region = new PdnRegion(path);

                    path.Dispose();

                }

            }



            return region;

        }



        public static PdnRegion RectanglesToRegion(Rectangle[] rects)

        {

            return RectanglesToRegion(rects, 0, rects.Length);

        }



        public static int GetRegionArea(RectangleF[] rectsF)

        {

            return rectsF.Select(rectF => Rectangle.Truncate(rectF)).Select(rect => rect.Width*rect.Height).Sum();

        }



        public static RectangleF RectangleFromCenter(PointF center, float halfSize) 

        {

            var ret = new RectangleF(center.X, center.Y, 0, 0);

            ret.Inflate(halfSize, halfSize);

            return ret;

        }



        public static List<PointF> PointListToPointFList(List<Point> ptList)

        {

            var ret = new List<PointF>(ptList.Count);

            ret.AddRange(ptList.Select(t => (PointF) t));



            return ret;

        }



        public static PointF[] PointArrayToPointFArray(Point[] ptArray)

        {

            var ret = new PointF[ptArray.Length];



            for (int i = 0; i < ret.Length; ++i)

            {

                ret[i] = ptArray[i];

            }



            return ret;

        }



        public static Rectangle[] InflateRectangles(Rectangle[] rects, int amount)

        {

            var inflated = new Rectangle[rects.Length];



            for (int i = 0; i < rects.Length; ++i)

            {

                inflated[i] = Rectangle.Inflate(rects[i], amount, amount);

            }



            return inflated;

        }



        public static void InflateRectanglesInPlace(Rectangle[] rects, int amount)

        {

            for (int i = 0; i < rects.Length; ++i)

            {

                rects[i].Inflate(amount, amount);

            }

        }



        public static RectangleF[] InflateRectangles(RectangleF[] rectsF, int amount)

        {

            var inflated = new RectangleF[rectsF.Length];



            for (int i = 0; i < rectsF.Length; ++i)

            {

                inflated[i] = RectangleF.Inflate(rectsF[i], amount, amount);

            }



            return inflated;

        }



        public static void InflateRectanglesInPlace(RectangleF[] rectsF, float amount)

        {

            for (int i = 0; i < rectsF.Length; ++i)

            {

                rectsF[i].Inflate(amount, amount);

            }

        }



        public static Rectangle PointsToConstrainedRectangle(Point a, Point b)

        {

            Rectangle rect = PointsToRectangle(a, b);

            int minWH = Math.Min(rect.Width, rect.Height);



            rect.Width = minWH;

            rect.Height = minWH;



            if (rect.Y != a.Y)

            {

                rect.Location = new Point(rect.X, a.Y - minWH);

            }



            if (rect.X != a.X)

            {

                rect.Location = new Point(a.X - minWH, rect.Y);

            }



            return rect;

        }



        public static RectangleF PointsToConstrainedRectangle(PointF a, PointF b)

        {

            RectangleF rect = PointsToRectangle(a, b);

            float minWH = Math.Min(rect.Width, rect.Height);



            rect.Width = minWH;

            rect.Height = minWH;



            if (rect.Y != a.Y)

            {

                rect.Location = new PointF(rect.X, a.Y - minWH);

            }



            if (rect.X != a.X)

            {

                rect.Location = new PointF(a.X - minWH, rect.Y);

            }



            return rect;

        }



        /// <summary>

        /// Takes two points and creates a bounding rectangle from them.

        /// </summary>

        /// <param name="a">One corner of the rectangle.</param>

        /// <param name="b">The other corner of the rectangle.</param>

        /// <returns>A Rectangle instance that bounds the two points.</returns>

        public static Rectangle PointsToRectangle(Point a, Point b)

        {

            int x = Math.Min(a.X, b.X);

            int y = Math.Min(a.Y, b.Y);

            int width = Math.Abs(a.X - b.X) + 1;

            int height = Math.Abs(a.Y - b.Y) + 1;

 

            return new Rectangle(x, y, width, height);

        }



        public static RectangleF PointsToRectangle(PointF a, PointF b)

        {

            float x = Math.Min(a.X, b.X);

            float y = Math.Min(a.Y, b.Y);

            float width = Math.Abs(a.X - b.X) + 1;

            float height = Math.Abs(a.Y - b.Y) + 1;

 

            return new RectangleF(x, y, width, height);

        }



        public static Rectangle PointsToRectangleExclusive(Point a, Point b)

        {

            int x = Math.Min(a.X, b.X);

            int y = Math.Min(a.Y, b.Y);

            int width = Math.Abs(a.X - b.X);

            int height = Math.Abs(a.Y - b.Y);

 

            return new Rectangle(x, y, width, height);

        }



        public static RectangleF PointsToRectangleExclusive(PointF a, PointF b)

        {

            float x = Math.Min(a.X, b.X);

            float y = Math.Min(a.Y, b.Y);

            float width = Math.Abs(a.X - b.X);

            float height = Math.Abs(a.Y - b.Y);

 

            return new RectangleF(x, y, width, height);

        }



        public static RectangleF[] PointsToRectangles(PointF[] pointsF)

        {

            if (pointsF.Length == 0)

            {

                return new RectangleF[] { };

            }



            if (pointsF.Length == 1)

            {

                return new[] { new RectangleF(pointsF[0].X, pointsF[0].Y, 1, 1) };

            }



            var rectsF = new RectangleF[pointsF.Length - 1];



            for (int i = 0; i < pointsF.Length - 1; ++i)

            {

                rectsF[i] = PointsToRectangle(pointsF[i], pointsF[i + 1]);

            }



            return rectsF;

        }



        public static Rectangle[] PointsToRectangles(Point[] points)

        {

            if (points.Length == 0)

            {

                return new Rectangle[] { };

            }



            if (points.Length == 1)

            {

                return new[] { new Rectangle(points[0].X, points[0].Y, 1, 1) };

            }



            var rects = new Rectangle[points.Length - 1];



            for (int i = 0; i < points.Length - 1; ++i)

            {

                rects[i] = PointsToRectangle(points[i], points[i + 1]);

            }



            return rects;

        }



        /// <summary>

        /// Converts a RectangleF to RectangleF by rounding down the Location and rounding

        /// up the Size.

        /// </summary>

        public static Rectangle RoundRectangle(RectangleF rectF)

        {

            var left = (float)Math.Floor(rectF.Left);

            var top = (float)Math.Floor(rectF.Top);

            var right = (float)Math.Ceiling(rectF.Right);

            var bottom = (float)Math.Ceiling(rectF.Bottom);

            

            return Rectangle.Truncate(RectangleF.FromLTRB(left, top, right, bottom));

        }



        public static Stack Reverse(Stack reverseMe)

        {

            var reversed = new Stack();



            foreach (object o in reverseMe)

            {

                reversed.Push(o);

            }



            return reversed;

        }



        public static void SerializeObjectToStream(object graph, Stream stream) 

        {

            new BinaryFormatter().Serialize(stream, graph);

        }



        public static object DeserializeObjectFromStream(Stream stream)

        {

            return new BinaryFormatter().Deserialize(stream);

        }



        [Obsolete("Use rect.Contains() instead", true)]

        public static bool IsPointInRectangle(Point pt, Rectangle rect)

        {

            return rect.Contains(pt);

        }

        

        [Obsolete("Use rect.Contains() instead", true)]

        public static bool IsPointInRectangle(int x, int y, Rectangle rect)

        {

            return rect.Contains(x, y);

        }



        public static Bitmap FullCloneBitmap(Bitmap cloneMe)

        {

            var bitmap = new Bitmap(cloneMe.Width, cloneMe.Height, cloneMe.PixelFormat);



            using (Graphics g = Graphics.FromImage(bitmap))

            {

                g.DrawImage(cloneMe, 0, 0, cloneMe.Width, cloneMe.Height);

            }            



            return bitmap;

        }



        /// <summary>

        /// Allows you to find the bounding box for a Region object without requiring

        /// the presence of a Graphics object.

        /// (Region.GetBounds takes a Graphics instance as its only parameter.)

        /// </summary>

        /// <param name="region">The region you want to find a bounding box for.</param>

        /// <returns>A RectangleF structure that surrounds the Region.</returns>

        public static Rectangle GetRegionBounds(PdnRegion region)

        {

            Rectangle[] rects = region.GetRegionScansReadOnlyInt();

            return GetRegionBounds(rects, 0, rects.Length);

        }



        /// <summary>

        /// Allows you to find the bounding box for a "region" that is described as an

        /// array of bounding boxes.

        /// </summary>

        /// <param name="rectsF">The "region" you want to find a bounding box for.</param>

        /// <param name="startIndex"></param>

        /// <param name="length"></param>

        /// <returns>A RectangleF structure that surrounds the Region.</returns>

        public static RectangleF GetRegionBounds(RectangleF[] rectsF, int startIndex, int length)

        {

            if (rectsF.Length == 0)

            {

                return RectangleF.Empty;

            }



            float left = rectsF[startIndex].Left;

            float top = rectsF[startIndex].Top;

            float right = rectsF[startIndex].Right;

            float bottom = rectsF[startIndex].Bottom;



            for (int i = startIndex + 1; i < startIndex + length; ++i)

            {

                RectangleF rectF = rectsF[i];



                if (rectF.Left < left)

                {

                    left = rectF.Left;

                }



                if (rectF.Top < top)

                {

                    top = rectF.Top;

                }



                if (rectF.Right > right)

                {

                    right = rectF.Right;

                }



                if (rectF.Bottom > bottom)

                {

                    bottom = rectF.Bottom;

                }

            }



            return RectangleF.FromLTRB(left, top, right, bottom);

        }



        public static RectangleF GetTraceBounds(PointF[] pointsF, int startIndex, int length)

        {

            if (pointsF.Length == 0)

            {

                return RectangleF.Empty;

            }



            float left = pointsF[startIndex].X;

            float top = pointsF[startIndex].Y;

            float right = 1 + pointsF[startIndex].X;

            float bottom = 1 + pointsF[startIndex].Y;



            for (int i = startIndex + 1; i < startIndex + length; ++i)

            {

                PointF pointF = pointsF[i];



                if (pointF.X < left)

                {

                    left = pointF.X;

                }



                if (pointF.Y < top)

                {

                    top = pointF.Y;

                }



                if (pointF.X > right)

                {

                    right = pointF.X;

                }



                if (pointF.Y > bottom)

                {

                    bottom = pointF.Y;

                }

            }



            return RectangleF.FromLTRB(left, top, right, bottom);

        }



        public static Rectangle GetTraceBounds(Point[] points, int startIndex, int length)

        {

            if (points.Length == 0)

            {

                return Rectangle.Empty;

            }



            int left = points[startIndex].X;

            int top = points[startIndex].Y;

            int right = 1 + points[startIndex].X;

            int bottom = 1 + points[startIndex].Y;



            for (int i = startIndex + 1; i < startIndex + length; ++i)

            {

                Point point = points[i];



                if (point.X < left)

                {

                    left = point.X;

                }



                if (point.Y < top)

                {

                    top = point.Y;

                }



                if (point.X > right)

                {

                    right = point.X;

                }



                if (point.Y > bottom)

                {

                    bottom = point.Y;

                }

            }



            return Rectangle.FromLTRB(left, top, right, bottom);

        }



        /// <summary>

        /// Allows you to find the bounding box for a "region" that is described as an

        /// array of bounding boxes.

        /// </summary>

        /// <param name="rectsF">The "region" you want to find a bounding box for.</param>

        /// <param name="rects"></param>

        /// <param name="startIndex"></param>

        /// <param name="length"></param>

        /// <returns>A RectangleF structure that surrounds the Region.</returns>

        public static Rectangle GetRegionBounds(Rectangle[] rects, int startIndex, int length)

        {

            if (rects.Length == 0)

            {

                return Rectangle.Empty;

            }



            int left = rects[startIndex].Left;

            int top = rects[startIndex].Top;

            int right = rects[startIndex].Right;

            int bottom = rects[startIndex].Bottom;



            for (int i = startIndex + 1; i < startIndex + length; ++i)

            {

                Rectangle rect = rects[i];



                if (rect.Left < left)

                {

                    left = rect.Left;

                }



                if (rect.Top < top)

                {

                    top = rect.Top;

                }



                if (rect.Right > right)

                {

                    right = rect.Right;

                }



                if (rect.Bottom > bottom)

                {

                    bottom = rect.Bottom;

                }

            }



            return Rectangle.FromLTRB(left, top, right, bottom);

        }



        public static RectangleF GetRegionBounds(RectangleF[] rectsF)

        {

            return GetRegionBounds(rectsF, 0, rectsF.Length);

        }



        public static Rectangle GetRegionBounds(Rectangle[] rects)

        {

            return GetRegionBounds(rects, 0, rects.Length);

        }



/*

        private static float DistanceSquared(IList<RectangleF> rectsF, int indexA, int indexB)

        {

            var centerA = new PointF(rectsF[indexA].Left + (rectsF[indexA].Width / 2), rectsF[indexA].Top + (rectsF[indexA].Height / 2));

            var centerB = new PointF(rectsF[indexB].Left + (rectsF[indexB].Width / 2), rectsF[indexB].Top + (rectsF[indexB].Height / 2));

            

            return ((centerA.X - centerB.X) * (centerA.X - centerB.X)) + 

                ((centerA.Y - centerB.Y) * (centerA.Y - centerB.Y));    UNUSED METHOD

        }

*/

       

        /// <summary>

        /// Simplifies a Region into N number of bounding boxes.

        /// </summary>

        /// <param name="region">The Region to simplify.</param>

        /// <param name="complexity">The maximum number of bounding boxes to return, or 0 for however many are necessary (equivalent to using Region.GetRegionScans).</param>

        /// <returns></returns>

        public static Rectangle[] SimplifyRegion(PdnRegion region, int complexity)

        {

            Rectangle[] rects = region.GetRegionScansReadOnlyInt();

            return SimplifyRegion(rects, complexity);

        }



        public static Rectangle[] SimplifyRegion(Rectangle[] rects, int complexity)

        {

            if (complexity == 0 || rects.Length < complexity)

            {

                return (Rectangle[])rects.Clone();

            }



            var boxes = new Rectangle[complexity];



            for (int i = 0; i < complexity; ++i)

            {

                int startIndex = (i * rects.Length) / complexity;

                int length = Math.Min(rects.Length, ((i + 1) * rects.Length) / complexity) - startIndex;

                boxes[i] = GetRegionBounds(rects, startIndex, length);

            }



            return boxes;

        }





        public static RectangleF[] SimplifyTrace(PointF[] pointsF, int complexity)

        {

            if (complexity == 0 || 

                (pointsF.Length - 1) < complexity)

            {

                return PointsToRectangles(pointsF);

            }



            var boxes = new RectangleF[complexity];

            int parLength = pointsF.Length - 1; // "(points as Rectangles).Length"

            

            for (int i = 0; i < complexity; ++i)

            {

                int startIndex = (i * parLength) / complexity;

                int length = Math.Min(parLength, ((i + 1) * parLength) / complexity) - startIndex;

                boxes[i] = GetTraceBounds(pointsF, startIndex, length + 1);

            }



            return boxes;

        }



        public static Rectangle[] SimplifyTrace(PdnGraphicsPath trace, int complexity)

        {

            return SimplifyRegion(TraceToRectangles(trace), complexity);

        }



        public static Rectangle[] SimplifyTrace(PdnGraphicsPath trace)

        {

            return SimplifyTrace(trace, DefaultSimplificationFactor);

        }



        public static Rectangle[] TraceToRectangles(PdnGraphicsPath trace, int complexity)

        {

            int pointCount = trace.PointCount;



            if (pointCount == 0)

            {

                return new Rectangle[0];

            }



            PointF[] pathPoints = trace.PathPoints;

            byte[] pathTypes = trace.PathTypes;

            int figureStart = 0;



            // first get count of rectangles we'll need

            var rects = new Rectangle[pointCount];



            for (int i = 0; i < pointCount; ++i)

            {

                byte type = pathTypes[i];



                Point a = Point.Truncate(pathPoints[i]);

                Point b;

            

                if ((type & (byte)PathPointType.CloseSubpath) != 0)

                {

                    b = Point.Truncate(pathPoints[figureStart]);

                    figureStart = i + 1;

                }

                else

                {

                    b = Point.Truncate(pathPoints[i + 1]);

                }



                rects[i] = PointsToRectangle(a, b);

            }



            return rects;

        }



        public static Rectangle[] TraceToRectangles(PdnGraphicsPath trace)

        {

            return TraceToRectangles(trace, DefaultSimplificationFactor);

        }



  …