BrawlLib.BrawlManagerLib.BitmapUtilities Class Reference

Static Public Member Functions
static Bitmap	AlphaSwap (Bitmap source)
	Swaps the alpha and value channels of a monochrome image. Transparent areas become black, and black areas become transparent. More...
static Bitmap	ApplyMask (Bitmap source, Bitmap mask)
static Bitmap	Combine (Bitmap bg, Image fg)
	Combines two images. The size of the second (foreground) image will be used for the final image. More...
static Bitmap	Invert (Bitmap source)
	Inverts the colors in a bitmap. More...
static Bitmap	Resize (Bitmap orig, Size resizeTo)
	Makes a scaled version of an image using BrawlLib's texture converter. More...
static Bitmap	Border (Bitmap orig, Color color, int penwidth=1)
static bool	IsSolidColor (Bitmap bmp, out Color c)
	Checks if the given bitmap is a single color. If the result is true, its color will be stored in the second parameter. More...
static bool	HasAlpha (Bitmap bmp)
	Checks if an image has any transparency. More...
static bool	HasNonAlpha (Bitmap bmp)
	Checks if an image has varying RGB values among pixels that are partially or fully opaque. More...
static int	CountColors (Bitmap bmp, int max)
	Counts the number of colors in a bitmap, up through the given maximum. If the maximum is reached, the method will return early. More...
static Bitmap	Blur (Bitmap orig, Color blurColor)
	Creates a new image, 2 pixels wider and taller than the original. Each pixel's alpha value is the largest alpha value among adjacent pixels on the original image. The color of each pixel will be the color given in the second argument. More...
static Bitmap	BlurCombine (Bitmap fg, Color blurColor)
	Creates a new bitmap with the original bitmap centered on top of the result of the Blur function. More...
static bool	HasSolidCorners (Bitmap newBitmap)

Member Function Documentation

AlphaSwap()

static Bitmap BrawlLib.BrawlManagerLib.BitmapUtilities.AlphaSwap ( Bitmap  source )

inlinestatic

Swaps the alpha and value channels of a monochrome image. Transparent areas become black, and black areas become transparent.

        {
            Color c;
            if (IsSolidColor(source, out c) && c.A == 0)
            {
                // fully transparent image
                return source;
            }
 
            Bitmap ret = new Bitmap(source.Width, source.Height);
            for (int x = 0; x < ret.Width; x++)
            {
                for (int y = 0; y < ret.Height; y++)
                {
                    Color fromColor = source.GetPixel(x, y);
                    int toColor = fromColor.A == 0 ? -0x01000000 : fromColor.A * 0x10101 + fromColor.R * 0x1000000;
                    ret.SetPixel(x, y, Color.FromArgb(toColor));
                }
            }
 
            return ret;
        }

ApplyMask()

static Bitmap BrawlLib.BrawlManagerLib.BitmapUtilities.ApplyMask ( Bitmap  source, Bitmap  mask  )

inlinestatic

        {
            source = Resize(source, mask.Size);
            Bitmap ret = new Bitmap(source.Width, source.Height);
            for (int x = 0; x < ret.Width; x++)
            {
                for (int y = 0; y < ret.Height; y++)
                {
                    Color c = source.GetPixel(x, y);
                    ret.SetPixel(x, y, Color.FromArgb(
                        mask.GetPixel(x, y).R,
                        c.R, c.G, c.B));
                }
            }
 
            return ret;
        }

Blur()

static Bitmap BrawlLib.BrawlManagerLib.BitmapUtilities.Blur ( Bitmap  orig, Color  blurColor  )

inlinestatic

Creates a new image, 2 pixels wider and taller than the original. Each pixel's alpha value is the largest alpha value among adjacent pixels on the original image. The color of each pixel will be the color given in the second argument.

        {
            Bitmap b = new Bitmap(orig.Width + 2, orig.Height + 2);
            for (int y = -1; y < orig.Height + 1; y++)
            {
                for (int x = -1; x < orig.Width + 1; x++)
                {
                    byte[] vals =
                    {
                        TryGetAlpha(orig, x - 1, y - 1) ?? 0,
                        TryGetAlpha(orig, x - 1, y) ?? 0,
                        TryGetAlpha(orig, x - 1, y + 1) ?? 0,
                        TryGetAlpha(orig, x, y - 1) ?? 0,
                        TryGetAlpha(orig, x, y) ?? 0,
                        TryGetAlpha(orig, x, y + 1) ?? 0,
                        TryGetAlpha(orig, x + 1, y - 1) ?? 0,
                        TryGetAlpha(orig, x + 1, y) ?? 0,
                        TryGetAlpha(orig, x + 1, y + 1) ?? 0
                    };
                    byte alpha = vals.Max();
                    b.SetPixel(x + 1, y + 1, Color.FromArgb(alpha, blurColor));
                }
            }
 
            return b;
        }

BlurCombine()

static Bitmap BrawlLib.BrawlManagerLib.BitmapUtilities.BlurCombine ( Bitmap  fg, Color  blurColor  )

inlinestatic

Creates a new bitmap with the original bitmap centered on top of the result of the Blur function.

        {
            Bitmap both = Blur(fg, blurColor);
            Graphics g = Graphics.FromImage(both);
            g.DrawImage(fg, 1, 1);
            return both;
        }

Border()

static Bitmap BrawlLib.BrawlManagerLib.BitmapUtilities.Border ( Bitmap  orig, Color  color, int  penwidth = 1  )

inlinestatic

        {
            Bitmap b = new Bitmap(orig.Width, orig.Height);
            Graphics g = Graphics.FromImage(b);
            g.DrawImage(orig, 0, 0);
            g.DrawRectangle(new Pen(color, penwidth),
                penwidth - 1, penwidth - 1,
                orig.Width - penwidth, orig.Height - penwidth);
            return b;
        }

Combine()

static Bitmap BrawlLib.BrawlManagerLib.BitmapUtilities.Combine ( Bitmap  bg, Image  fg  )

inlinestatic

Combines two images. The size of the second (foreground) image will be used for the final image.

        {
            int w = fg.Width, h = fg.Height;
            Bitmap both = new Bitmap(w, h);
            Graphics g = Graphics.FromImage(both);
            g.DrawImage(Resize(bg, both.Size), 0, 0);
            g.DrawImage(fg, 0, 0);
            return both;
        }

CountColors()

static int BrawlLib.BrawlManagerLib.BitmapUtilities.CountColors ( Bitmap  bmp, int  max  )

inlinestatic

Counts the number of colors in a bitmap, up through the given maximum. If the maximum is reached, the method will return early.

        {
            int count = 0;
            HashSet<Color> colors = new HashSet<Color>();
            for (int y = 0; y < bmp.Height && count < max; y++)
            {
                for (int x = 0; x < bmp.Width && count < max; x++)
                {
                    Color color = bmp.GetPixel(x, y);
                    if (!colors.Contains(color))
                    {
                        colors.Add(color);
                        count++;
                    }
                }
            }
 
            return count;
        }

HasAlpha()

static bool BrawlLib.BrawlManagerLib.BitmapUtilities.HasAlpha ( Bitmap  bmp )

inlinestatic

Checks if an image has any transparency.

        {
            for (int y = 0; y < bmp.Height; y++)
            {
                for (int x = 0; x < bmp.Width; x++)
                {
                    if (bmp.GetPixel(x, y).A < 255)
                    {
                        return true;
                    }
                }
            }
 
            return false;
        }

HasNonAlpha()

static bool BrawlLib.BrawlManagerLib.BitmapUtilities.HasNonAlpha ( Bitmap  bmp )

inlinestatic

Checks if an image has varying RGB values among pixels that are partially or fully opaque.

        {
            int? found = null;
            for (int y = 0; y < bmp.Height; y++)
            {
                for (int x = 0; x < bmp.Width; x++)
                {
                    Color color = bmp.GetPixel(x, y);
                    if (color.A == 0)
                    {
                        continue;
                    }
 
                    int rgb = color.ToArgb() & 0xFFFFFF;
                    if (found == null)
                    {
                        found = rgb;
                    }
                    else if (rgb != found)
                    {
                        return true;
                    }
                }
            }
 
            return false;
        }

HasSolidCorners()

static bool BrawlLib.BrawlManagerLib.BitmapUtilities.HasSolidCorners ( Bitmap  newBitmap )

inlinestatic

        {
            int w = newBitmap.Width;
            int h = newBitmap.Height;
            return newBitmap.GetPixel(0, 0).A == 255
                   && newBitmap.GetPixel(w - 1, 0).A == 255
                   && newBitmap.GetPixel(0, h - 1).A == 255
                   && newBitmap.GetPixel(w - 1, h - 1).A == 255;
        }

Invert()

static Bitmap BrawlLib.BrawlManagerLib.BitmapUtilities.Invert ( Bitmap  source )

inlinestatic

Inverts the colors in a bitmap.

        {
            Bitmap ret = new Bitmap(source.Width, source.Height);
            for (int x = 0; x < ret.Width; x++)
            {
                for (int y = 0; y < ret.Height; y++)
                {
                    Color c = source.GetPixel(x, y);
                    ret.SetPixel(x, y, Color.FromArgb(c.A, 255 - c.R, 255 - c.G, 255 - c.B));
                }
            }
 
            return ret;
        }

IsSolidColor()

static bool BrawlLib.BrawlManagerLib.BitmapUtilities.IsSolidColor ( Bitmap  bmp, out Color  c  )

inlinestatic

Checks if the given bitmap is a single color. If the result is true, its color will be stored in the second parameter.

        {
            c = bmp.GetPixel(0, 0);
            for (int y = 0; y < bmp.Height; y++)
            {
                for (int x = 0; x < bmp.Width; x++)
                {
                    if (bmp.GetPixel(x, y) != c)
                    {
                        return false;
                    }
                }
            }
 
            return true;
        }

Resize()

static Bitmap BrawlLib.BrawlManagerLib.BitmapUtilities.Resize ( Bitmap  orig, Size  resizeTo  )

inlinestatic

Makes a scaled version of an image using BrawlLib's texture converter.

        {
            return orig.Resize(resizeTo.Width, resizeTo.Height);
        }

---

The documentation for this class was generated from the following file:

• BrawlLib/BrawlManagerLib/BitmapUtilities.cs