C# FastBitmap.Lock方法代码示例

        public static int CountColors(this Image image)
        {
            if (image == null)
            {
                throw new ArgumentNullException("image");
            }

            HashSet<int> colors = new HashSet<int>();

            FastBitmap fastBitmap = new FastBitmap(image);
            fastBitmap.Lock();

            // Loop through all the pixels of the image
            // and add the colors to the HashSet - duplicates
            // are automatically ignored by that collection type
            for (int x = 0; x < image.Width; x++)
            {
                for (int y = 0; y < image.Height; y++)
                {
                    // We use ToArgb because Colors are compared on more than their ARGB values - see Color class documentation on MSDN
                    colors.Add(fastBitmap.GetPixel(x, y).ToArgb());
                }
            }

            fastBitmap.Unlock();

            return colors.Count;
        }

        public void TestFastBitmapCreation()
        {
            Bitmap bitmap = new Bitmap(64, 64);
            FastBitmap fastBitmap = new FastBitmap(bitmap);
            fastBitmap.Lock();
            fastBitmap.Unlock();

            // Try creating a FastBitmap with different 32bpp depths
            try
            {
                // ReSharper disable once ObjectCreationAsStatement
                new FastBitmap(new Bitmap(1, 1, PixelFormat.Format32bppArgb));
                // ReSharper disable once ObjectCreationAsStatement
                new FastBitmap(new Bitmap(1, 1, PixelFormat.Format32bppPArgb));
                // ReSharper disable once ObjectCreationAsStatement
                new FastBitmap(new Bitmap(1, 1, PixelFormat.Format32bppRgb));
            }
            catch (ArgumentException)
            {
                Assert.Fail("The FastBitmap should accept any type of 32bpp pixel format bitmap");
            }

            // Try creating a FastBitmap with a bitmap of a bit depth different from 32bpp
            Bitmap invalidBitmap = new Bitmap(64, 64, PixelFormat.Format4bppIndexed);

            // ReSharper disable once ObjectCreationAsStatement
            new FastBitmap(invalidBitmap);
        }

        //tiles = 16 means 16 x 16 atlas
        public List<Bitmap> Atlas2dInto1d(Bitmap atlas2d, int tiles, int atlassizezlimit)
        {
            FastBitmap orig = new FastBitmap();
            orig.bmp = atlas2d;

            int tilesize = atlas2d.Width / tiles;

            int atlasescount = Math.Max(1, (tiles * tiles * tilesize) / atlassizezlimit);
            List<Bitmap> atlases = new List<Bitmap>();

            orig.Lock();

            //256 x 1
            FastBitmap atlas1d = null;

            for (int i = 0; i < tiles * tiles; i++)
            {
                int x = i % tiles;
                int y = i / tiles;
                int tilesinatlas = (tiles * tiles / atlasescount);
                if (i % tilesinatlas == 0)
                {
                    if (atlas1d != null)
                    {
                        atlas1d.Unlock();
                        atlases.Add(atlas1d.bmp);
                    }
                    atlas1d = new FastBitmap();
                    atlas1d.bmp = new Bitmap(tilesize, atlassizezlimit);
                    atlas1d.Lock();
                }
                for (int xx = 0; xx < tilesize; xx++)
                {
                    for (int yy = 0; yy < tilesize; yy++)
                    {
                        int c = orig.GetPixel(x * tilesize + xx, y * tilesize + yy);
                        atlas1d.SetPixel(xx, (i % tilesinatlas) * tilesize + yy, c);
                    }
                }
            }
            atlas1d.Unlock();
            atlases.Add(atlas1d.bmp);
            orig.Unlock();
            return atlases;
        }

        public void TestSequentialFastBitmapLocking()
        {
            Bitmap bitmap = new Bitmap(64, 64);
            FastBitmap fastBitmap = new FastBitmap(bitmap);

            Assert.IsFalse(fastBitmap.Locked, "Immediately after creation, the FastBitmap.Locked property must be false");

            fastBitmap.Lock();

            Assert.IsTrue(fastBitmap.Locked, "After a successful call to .Lock(), the .Locked property must be true");

            fastBitmap.Unlock();

            Assert.IsFalse(fastBitmap.Locked, "After a successful call to .Lock(), the .Locked property must be false");

            fastBitmap = new FastBitmap(bitmap);
            fastBitmap.Lock();
            fastBitmap.Unlock();
        }

        public static bool CompareColors(this Image image, Image other)
        {
            if (image == null || other == null)
            {
                throw new ArgumentNullException(image == null ? "image" : "other");
            }

            if (image.Size != other.Size)
            {
                return false;
            }

            FastBitmap fastImage = new FastBitmap(image);
            FastBitmap fastOther = new FastBitmap(other);

            try
            {
                fastImage.Lock();
                fastOther.Lock();

                for (int x = 0; x < image.Width; x++)
                {
                    for (int y = 0; y < image.Height; y++)
                    {
                        // We use ToArgb because Colors are compared on more than their ARGB values - see Color class documentation on MSDN
                        if (fastImage.GetPixel(x, y).ToArgb() != fastOther.GetPixel(x, y).ToArgb())
                        {
                            return false;
                        }
                    }
                }
            }
            finally
            {
                fastImage.Unlock();
                fastOther.Unlock();
            }

            return true;
        }

        public static Image ReplaceColor(this Image image, Color oldColor, Color newColor)
        {
            if (image == null)
            {
                throw new ArgumentNullException("image");
            }

            Image clone = image.Clone() as Image;

            // If they try to replace a color with itself (sneaky, sneaky!) then just return our cloned image immediately
            if (oldColor.ToArgb() == newColor.ToArgb())
            {
                return clone;
            }

            FastBitmap fastBitmap = new FastBitmap(clone);
            fastBitmap.Lock();

            for (int x = 0; x < image.Width; x++)
            {
                for (int y = 0; y < image.Height; y++)
                {
                    // We use ToArgb because Colors are compared on more than their ARGB values - see Color class documentation on MSDN
                    if (fastBitmap.GetPixel(x, y).ToArgb() == oldColor.ToArgb())
                    {
                        fastBitmap.SetPixel(x, y, newColor);
                    }
                }
            }

            fastBitmap.Unlock();

            return fastBitmap.Image;
        }

        public void TestFailedSequentialFastBitmapLocking()
        {
            Bitmap bitmap = new Bitmap(64, 64);
            FastBitmap fastBitmap = new FastBitmap(bitmap);
            fastBitmap.Lock();

            fastBitmap = new FastBitmap(bitmap);
            fastBitmap.Lock();
        }

 /// <summary>
 /// Generates a frame image with a given set of parameters.
 /// The seed is used to randomize the frame, and any call with the same width, height and seed will generate the same image
 /// </summary>
 /// <param name="width">The width of the image to generate</param>
 /// <param name="height">The height of the image to generate</param>
 /// <param name="seed">The seed for the image, used to seed the random number generator that will generate the image contents</param>
 /// <returns>An image with the passed parameters</returns>
 public static Bitmap GenerateRandomBitmap(int width, int height, int seed = -1)
 {
     if (seed == -1)
     {
         seed = _seedRandom.Next();
     }
     Bitmap bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
     FastBitmap fastBitmap = new FastBitmap(bitmap);
     fastBitmap.Lock();
     // Plot the image with random pixels now
     Random r = new Random(seed);
     for (int y = 0; y < height; y++)
     {
         for (int x = 0; x < width; x++)
         {
             uint pixelColor = (uint)(r.NextDouble() * 0xFFFFFFFF);
             fastBitmap.SetPixel(x, y, pixelColor);
         }
     }
     fastBitmap.Unlock();
     return bitmap;
 }

        public void TestFastBitmapSetPixelBoundsException()
        {
            Bitmap bitmap = new Bitmap(64, 64);
            FastBitmap fastBitmap = new FastBitmap(bitmap);

            fastBitmap.Lock();

            try
            {
                fastBitmap.SetPixel(-1, -1, 0);
                Assert.Fail("When trying to access a coordinate that is out of bounds via GetPixel, an exception must be thrown");
            }
            catch (ArgumentOutOfRangeException) { }

            try
            {
                fastBitmap.SetPixel(fastBitmap.Width, 0, 0);
                Assert.Fail("When trying to access a coordinate that is out of bounds via GetPixel, an exception must be thrown");
            }
            catch (ArgumentOutOfRangeException) { }

            try
            {
                fastBitmap.SetPixel(0, fastBitmap.Height, 0);
                Assert.Fail("When trying to access a coordinate that is out of bounds via GetPixel, an exception must be thrown");
            }
            catch (ArgumentOutOfRangeException) { }

            fastBitmap.SetPixel(fastBitmap.Width - 1, fastBitmap.Height - 1, 0);
        }

        public void TestFastBitmapLockingException()
        {
            Bitmap bitmap = new Bitmap(64, 64);
            FastBitmap fastBitmap = new FastBitmap(bitmap);

            fastBitmap.Lock();
            fastBitmap.Lock();
        }

        public void TestFastBitmapLocker()
        {
            Bitmap bitmap = new Bitmap(64, 64);
            FastBitmap fastBitmap = new FastBitmap(bitmap);

            // Immediate lock and dispose
            fastBitmap.Lock().Dispose();
            Assert.IsFalse(fastBitmap.Locked, "After disposing of the FastBitmapLocker object, the underlying fast bitmap must be unlocked");

            using (var locker = fastBitmap.Lock())
            {
                fastBitmap.SetPixel(0, 0, 0);

                Assert.AreEqual(fastBitmap, locker.FastBitmap, "The fast bitmap referenced in the fast bitmap locker must be the one that had the original Lock() call");
            }

            Assert.IsFalse(fastBitmap.Locked, "After disposing of the FastBitmapLocker object, the underlying fast bitmap must be unlocked");

            // Test the conditional unlocking of the fast bitmap locker by unlocking the fast bitmap before exiting the 'using' block
            using (fastBitmap.Lock())
            {
                fastBitmap.SetPixel(0, 0, 0);
                fastBitmap.Unlock();
            }
        }

        public void TestSetPixelInt()
        {
            Bitmap bitmap1 = new Bitmap(64, 64);
            Bitmap bitmap2 = new Bitmap(64, 64);

            FastBitmap fastBitmap1 = new FastBitmap(bitmap1);
            fastBitmap1.Lock();

            Random r = new Random();

            for (int y = 0; y < bitmap1.Height; y++)
            {
                for (int x = 0; x < bitmap1.Width; x++)
                {
                    int intColor = r.Next(0xFFFFFF);
                    Color color = Color.FromArgb(intColor);

                    fastBitmap1.SetPixel(x, y, intColor);
                    bitmap2.SetPixel(x, y, color);
                }
            }

            fastBitmap1.Unlock();

            AssertBitmapEquals(bitmap1, bitmap2,
                "Calls to FastBitmap.SetPixel() with an integer overload must be equivalent to calls to Bitmap.SetPixel() with a Color with the same ARGB value as the interger");
        }

        public void TestGetPixel()
        {
            Bitmap original = GenerateRandomBitmap(64, 64);
            Bitmap copy = original.Clone(new Rectangle(0, 0, 64, 64), original.PixelFormat);

            FastBitmap fastOriginal = new FastBitmap(original);
            fastOriginal.Lock();

            for (int y = 0; y < original.Height; y++)
            {
                for (int x = 0; x < original.Width; x++)
                {
                    Assert.AreEqual(fastOriginal.GetPixel(x, y).ToArgb(), copy.GetPixel(x, y).ToArgb(),
                        "Calls to FastBitmap.GetPixel() must return the same value as returned by Bitmap.GetPixel()");
                }
            }

            fastOriginal.Unlock();
        }

        protected override Image CreateImage()
        {
            // set design-mode properties
            foreach (Layer layer in this.Layers)
                if (layer is ImageLayer)
                {
                    ImageLayer imageLayer = (ImageLayer) layer;
                    imageLayer._site = this.Site;
                    imageLayer._designMode = this.DesignMode;
                }

            // process layers
            foreach (Layer layer in this.Layers)
                layer.Process();

            // for SizeMode = Auto, we need to calculate the output dimensions
            // based on the combination of all layers' dimensions
            int outputWidth, outputHeight;
            if (this.AutoSize)
            {
                Rectangle outputDimensions = Rectangle.Empty;
                foreach (Layer layer in this.Layers)
                {
                    Rectangle? bounds = layer.Bounds;
                    if (bounds != null)
                        outputDimensions = Rectangle.Union(outputDimensions, bounds.Value);
                }
                outputWidth = outputDimensions.Width;
                outputHeight = outputDimensions.Height;
            }
            else
            {
                outputWidth = this.Width.Value;
                outputHeight = this.Height.Value;
            }

            if (outputWidth == 0 && outputHeight == 0)
                return null;

            // create output bitmap and lock data
            FastBitmap output = new FastBitmap(outputWidth, outputHeight, PixelFormat.Format24bppRgb);

            // lock layer bitmaps and output bitmap
            output.Lock();
            foreach (Layer layer in this.Layers)
                layer.Bitmap.Lock();

            // calculate colors of flattened image
            // 1. take offsetx, offsety into consideration
            // 2. calculate alpha of color (alpha, opacity, mask)
            // 3. mix colors of current layer and layer below
            for (int y = 0; y < outputHeight; ++y)
            {
                for (int x = 0; x < outputWidth; ++x)
                {
                    Color c0 = Color.Transparent;
                    foreach (Layer layer in this.Layers)
                    {
                        Color c1 = Color.Transparent;

                        if (x >= layer.X &&
                            x <= layer.X + layer.Bitmap.Width - 1 &&
                            y >= layer.Y &&
                            y <= layer.Y + layer.Bitmap.Height - 1)
                        {
                            c1 = layer.Bitmap[x - layer.X, y - layer.Y];
                        }

                        if (c1.A == 255)
                        {
                            c0 = c1;
                        }
                        else
                        {
                            double a = c1.A / 255.0;
                            double tr = c1.R * a + c0.R * (1.0 - a);
                            double tg = c1.G * a + c0.G * (1.0 - a);
                            double tb = c1.B * a + c0.B * (1.0 - a);
                            tr = Math.Round(tr);
                            tg = Math.Round(tg);
                            tb = Math.Round(tb);
                            tr = Math.Min(tr, 255);
                            tg = Math.Min(tg, 255);
                            tb = Math.Min(tb, 255);
                            c0 = Color.FromArgb((byte) tr, (byte) tg, (byte) tb);
                        }
                    }
                    output[x, y] = c0;
                }
            }

            // unlock layer bitmaps and output bitmap
            foreach (Layer layer in this.Layers)
                layer.Bitmap.Unlock();
            output.Unlock();

            return output.InnerBitmap;
        }