Image.cs

Siirry tämän tiedoston dokumentaatioon.

using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework;
using System;
using System.IO;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;

using XnaRectangle = Microsoft.Xna.Framework.Rectangle;
using XnaV2 = Microsoft.Xna.Framework.Vector2;
using XnaColor = Microsoft.Xna.Framework.Color;
using JyColor = Jypeli.Color;

#if !XBOX
using System.Net;
using System.Threading;
#endif

namespace Jypeli
{
    public class Image
    {
        private Image parentImage;
        private XnaRectangle parentRectangle;

        private string assetName;
        private Texture2D xnaTexture;

        private event Action InitDimensions;
        private event Action InitTexture;

        int _width = -1;
        int _height = -1;

        internal Texture2D XNATexture
        {
            get { DoInitTexture(); return xnaTexture; }
        }

        public Color this[int row, int col]
        {
            get
            {
                DoInitTexture();

                Color[] buffer = new Color[1];
                XnaRectangle rect = new XnaRectangle( col, row, 1, 1 );
                xnaTexture.GetData<Color>( 0, rect, buffer, 0, 1 );
                return buffer[0];
            }
            set
            {
                DoInitTexture();
                InvalidateAsset();

                if ( row < 0 || row >= xnaTexture.Height ) throw new IndexOutOfRangeException( "row" );
                if ( col < 0 || col >= XNATexture.Width ) throw new IndexOutOfRangeException( "col" );

                Color[] buffer = new Color[1] { value };
                XnaRectangle rect = new XnaRectangle( col, row, 1, 1 );

                xnaTexture.SetData<Color>( 0, rect, buffer, 0, 1 );
                UpdateTexture();
            }
        }


        public Color[,] GetData( int ox = 0, int oy = 0, int w = int.MaxValue, int h = int.MaxValue )
        {
            int ny = Height;
            if ( h < ny ) ny = h;
            if ( Height < ny + oy ) ny = Height - oy;
            int nx = Width;
            if ( w < nx ) nx = w;
            if ( Width < nx + ox ) nx = Width - ox;
            if ( nx <= 0 || ny <= 0 ) return new Color[0, 0];

            DoInitTexture();
            Color[,] bmp = new Color[ny, nx];

            XnaRectangle rect = new XnaRectangle( ox, oy, nx, ny );
            Color[] buffer = new Color[ny * nx];
            xnaTexture.GetData<Color>( 0, rect, buffer, 0, buffer.Length );
            int i = 0;
            for ( int iy = 0; iy < ny; iy++ )
                for ( int ix = 0; ix < nx; ix++ )
                    bmp[iy, ix] = buffer[i++];
            return bmp;
        }


        public void SetData( Color[,] bmp, int ox = 0, int oy = 0, int w = int.MaxValue, int h = int.MaxValue )
        {
            DoInitTexture();
            InvalidateAsset();
            int ny = bmp.GetLength( 0 );
            int nx = bmp.GetLength( 1 );
            if ( ny > Height ) ny = Height;
            if ( nx > Width ) nx = Height;
            if ( ny > h ) ny = h;
            if ( nx > w ) nx = w;
            if ( Height < ny + oy ) ny = Height - oy;
            if ( Width < nx + ox ) nx = Width - ox;
            if ( nx <= 0 || ny <= 0 ) return;

            XnaRectangle rect = new XnaRectangle( ox, oy, nx, ny );
            Color[] buffer = new Color[ny * nx];
            int i = 0;
            for ( int iy = 0; iy < ny; iy++ )
                for ( int ix = 0; ix < nx; ix++ )
                    buffer[i++] = bmp[iy, ix];

            xnaTexture.SetData<Color>( 0, rect, buffer, 0, buffer.Length );
            UpdateTexture();
        }


        public uint[,] GetDataUInt( int ox = 0, int oy = 0, int w = int.MaxValue, int h = int.MaxValue )
        {
            int ny = Height;
            if ( h < ny ) ny = h;
            if ( Height < ny + oy ) ny = Height - oy;
            int nx = Width;
            if ( w < nx ) nx = w;
            if ( Width < nx + ox ) nx = Width - ox;
            if ( nx <= 0 || ny <= 0 ) return new uint[0, 0];

            DoInitTexture();
            uint[,] bmp = new uint[ny, nx];

            XnaRectangle rect = new XnaRectangle( ox, oy, nx, ny );
            Color[] buffer = new Color[ny * nx];
            xnaTexture.GetData<Color>( 0, rect, buffer, 0, buffer.Length );
            int i = 0;
            for ( int iy = 0; iy < ny; iy++ )
                for ( int ix = 0; ix < nx; ix++ )
                    bmp[iy, ix] = buffer[i++].ToUInt();
            return bmp;
        }


        public uint[][] GetDataUIntAA( int ox = 0, int oy = 0, int w = int.MaxValue, int h = int.MaxValue )
        {
            int ny = Height;
            if ( h < ny ) ny = h;
            if ( Height < ny + oy ) ny = Height - oy;
            int nx = Width;
            if ( w < nx ) nx = w;
            if ( Width < nx + ox ) nx = Width - ox;
            if ( nx <= 0 || ny <= 0 ) return new uint[0][];

            DoInitTexture();
            uint[][] bmp = new uint[ny][];

            XnaRectangle rect = new XnaRectangle( ox, oy, nx, ny );
            Color[] buffer = new Color[ny * nx];
            xnaTexture.GetData<Color>( 0, rect, buffer, 0, buffer.Length );
            int i = 0;
            for ( int iy = 0; iy < ny; iy++ )
            {
                uint[] row = new uint[nx];
                bmp[iy] = row;
                for ( int ix = 0; ix < nx; ix++ )
                    row[ix] = buffer[i++].ToUInt();
            }
            return bmp;
        }


        public void SetData( uint[,] bmp, int ox = 0, int oy = 0, int w = int.MaxValue, int h = int.MaxValue )
        {
            DoInitTexture();
            InvalidateAsset();
            int ny = bmp.GetLength( 0 );
            int nx = bmp.GetLength( 1 );
            if ( ny > Height ) ny = Height;
            if ( nx > Width ) nx = Width;
            if ( ny > h ) ny = h;
            if ( nx > w ) nx = w;
            if ( Height < ny + oy ) ny = Height - oy;
            if ( Width < nx + ox ) nx = Width - ox;

            if ( nx <= 0 || ny <= 0 ) return;

            XnaRectangle rect = new XnaRectangle( ox, oy, nx, ny );
            Color[] buffer = new Color[ny * nx];
            int i = 0;
            for ( int iy = 0; iy < ny; iy++ )
                for ( int ix = 0; ix < nx; ix++ )
                    buffer[i++] = Jypeli.Color.UIntToColor( bmp[iy, ix] );
            // foreach (int c in bmp) buffer[i++] = Jypeli.Color.IntToColor(c);

            xnaTexture.SetData<Color>( 0, rect, buffer, 0, buffer.Length );
            UpdateTexture();
        }


        public void SetData( uint[][] bmp, int ox = 0, int oy = 0, int w = int.MaxValue, int h = int.MaxValue )
        {
            DoInitTexture();
            InvalidateAsset();
            int ny = bmp.Length;
            int nx = bmp[0].Length;
            if ( ny > Height ) ny = Height;
            if ( nx > Width ) nx = Width;
            if ( ny > h ) ny = h;
            if ( nx > w ) nx = w;
            if ( nx <= 0 || ny <= 0 ) return;

            XnaRectangle rect = new XnaRectangle( ox, oy, nx, ny );
            Color[] buffer = new Color[ny * nx];
            int i = 0;
            for ( int iy = 0; iy < ny; iy++ )
                for ( int ix = 0; ix < nx; ix++ )
                    buffer[i++] = Jypeli.Color.UIntToColor( bmp[iy][ix] );
            // foreach (int c in bmp) buffer[i++] = Jypeli.Color.IntToColor(c);

            xnaTexture.SetData<Color>( 0, rect, buffer, 0, buffer.Length );
            UpdateTexture();
        }

        public override int GetHashCode()
        {
            if ( assetName != null )
                return assetName.GetHashCode();

            if ( xnaTexture != null )
                return xnaTexture.GetHashCode();

            return base.GetHashCode();
        }


        public int Width
        {
            get { DoInitDimensions(); return _width; }
        }

        public int Height
        {
            get { DoInitDimensions(); return _height; }
        }

        public string Name
        {
            get { DoInitTexture(); return xnaTexture.Name; }
        }

        internal Image( int width, int height )
        {
            this._width = width;
            this._height = height;
            this.InitTexture += CreateNewTexture;
        }

        internal Image( string assetName )
        {
            this.assetName = assetName;
            this.InitDimensions += LoadContentTexture;
        }

        [EditorBrowsable( EditorBrowsableState.Never )]
        public Image( Microsoft.Xna.Framework.Graphics.Texture2D texture )
        {
            this.xnaTexture = texture;
            this._width = texture.Width;
            this._height = texture.Height;
        }

        public Image( int width, int height, Color backColor )
        {
            assetName = null;
            this._width = width;
            this._height = height;
            this.InitTexture += CreateNewTexture;
            this.InitTexture += delegate { this.Fill( backColor ); };
        }

        public Image( double width, double height, Color backColor )
            : this( (int)Math.Round( width ), (int)Math.Round( height ), backColor )
        {
        }

        private void DoInitDimensions()
        {
            if ( _width >= 0 && _height >= 0 )
                return;

            if ( InitDimensions != null )
                InitDimensions();
            else
                throw new InvalidOperationException( "Cannot initialize dimensions for image!" );
        }

        private void DoInitTexture()
        {
            DoInitDimensions();

            if ( xnaTexture != null )
                return;

            if ( InitTexture != null )
                InitTexture();
            else
                throw new InvalidOperationException( "Cannot initialize texture for image!" );
        }

        private void LoadContentTexture()
        {
            // Some duct tape around the fact that in XNA,
            // content can not be loaded before LoadContent().
            Debug.Assert( assetName != null );
            xnaTexture = Game.Instance.Content.Load<Texture2D>( assetName );
            _width = xnaTexture.Width;
            _height = xnaTexture.Height;
        }

        private void CreateNewTexture()
        {
            this.xnaTexture = new Texture2D( Game.GraphicsDevice, Width, Height );
        }

        public Image Clone()
        {
            Image copy;

            if ( assetName != null )
            {
                copy = new Image( assetName );
            }
            else
            {
                copy = new Image( this.Width, this.Height );
                copy.InitTexture += delegate { CopyData( copy, this ); };
            }

            return copy;
        }

        private static void CopyData( Image dest, Image src )
        {
            src.DoInitTexture();

            int w = src.Width;
            int h = src.Height;
            XnaRectangle rect = new XnaRectangle( 0, 0, w, 1 );
            Color[] scanline = new Color[w];

            for ( rect.Y = 0; rect.Y < h; rect.Y++ )
            {
                src.xnaTexture.GetData<Color>( 0, rect, scanline, 0, w );
                dest.xnaTexture.SetData<Color>( 0, rect, scanline, 0, w );
            }
        }

        private static void CopyData( Texture2D dest, Texture2D src )
        {
            int w = src.Width;
            int h = src.Height;
            XnaRectangle rect = new XnaRectangle( 0, 0, w, 1 );
            Color[] scanline = new Color[w];

            for ( rect.Y = 0; rect.Y < h; rect.Y++ )
            {
                src.GetData<Color>( 0, rect, scanline, 0, w );
                dest.SetData<Color>( 0, rect, scanline, 0, w );
            }
        }

        private static void CopyData( Image dest, Image src, XnaRectangle destRect, XnaRectangle srcRect )
        {
            src.DoInitTexture();

            int w = srcRect.Width;
            int h = srcRect.Height;
            Color[] buffer = new Color[w * h];
            //XnaRectangle srcScan = new XnaRectangle( 0, 0, w, 1 );
            //Color[] scanline = new Color[w];

            //for ( rect.Y = 0; rect.Y < h; rect.Y++ )
            //{
            //    src.xnaTexture.GetData<Color>( 0, rect, scanline, 0, w );
            //    dest.xnaTexture.SetData<Color>( 0, rect, scanline, 0, w );
            //}

            src.xnaTexture.GetData<Color>( 0, srcRect, buffer, 0, w * h );
            dest.xnaTexture.SetData<Color>( 0, destRect, buffer, 0, w * h );
        }

        public void ApplyPixelOperation( Converter<Color, Color> operation )
        {
            Converter<XnaColor, XnaColor> newOp = delegate( XnaColor c )
            {
                return operation( new Color( c ) ).AsXnaColor();
            };

            ApplyPixelOperation( newOp );
        }

        internal void ApplyPixelOperation( Converter<XnaColor, XnaColor> operation )
        {
            DoInitTexture();
            InvalidateAsset();

            XnaRectangle scanRect = new XnaRectangle( 0, 0, xnaTexture.Width, 1 );
            XnaColor[] scanline = new XnaColor[xnaTexture.Width];

            for ( scanRect.Y = 0; scanRect.Y < xnaTexture.Height; scanRect.Y++ )
            {
                xnaTexture.GetData<XnaColor>( 0, scanRect, scanline, 0, xnaTexture.Width );

                for ( int j = 0; j < xnaTexture.Width; j++ )
                {
                    scanline[j] = operation( scanline[j] );
                }

                xnaTexture.SetData<XnaColor>( 0, scanRect, scanline, 0, xnaTexture.Width );
            }

            UpdateTexture();
        }

        private void InvalidateAsset()
        {
            if ( assetName == null )
                return;

            Texture2D oldTex = xnaTexture;
            CreateNewTexture();
            CopyData( xnaTexture, oldTex );
            assetName = null;
        }

        private void UpdateTexture()
        {
            Game.DoNextUpdate( DoUpdateTexture );
        }

        private void DoUpdateTexture()
        {
            if ( parentImage != null )
            {
                XnaRectangle srcRect = new XnaRectangle( 0, 0, Width, Height );
                CopyData( parentImage, this, parentRectangle, srcRect );
                parentImage.UpdateTexture();
            }
        }

        #region static methods

#if !XBOX
        public static Image FromFile( string path )
        {
            StreamReader sr = new StreamReader( path );
            Image img = new Image( Texture2D.FromStream( Game.GraphicsDevice, sr.BaseStream ) );
            return img;
        }

#endif

        public static Image FromFile( StorageFile file )
        {
            return FromStream( file.Stream );
        }

        public static Image FromStream( Stream stream )
        {
            return new Image( Texture2D.FromStream( Game.GraphicsDevice, stream ) );
        }

#if WINDOWS
        public static Image FromURL( string url )
        {
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create( url );
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            Stream resStream = response.GetResponseStream();

            MemoryStream memStream = new MemoryStream();
            resStream.CopyTo( memStream );

            Image img = new Image( Texture2D.FromStream( Game.GraphicsDevice, memStream ) );
            return img;
        }
#endif

        public static Image CreateStarSky( int width, int height, int stars, bool transparent = false)
        {
            XnaColor[] textureColors = new XnaColor[width * height];

            // Background, black or transparent
            int i = 0;
            for ( int ver = 0; ver < height; ver++ )
            {
                for ( int hor = 0; hor < width; hor++ )
                {
                    if (transparent) textureColors[i++] = XnaColor.Transparent;
                    else textureColors[i++] = XnaColor.Black;
                }
            }

            // Random stars
            for ( int j = 0; j < stars; j++ )
            {
                int star = RandomGen.NextInt( 0, width * height );
                int size = RandomGen.NextInt( 1, 5 );

                for ( int k = 0; k < size / 2; k++ )
                {
                    XnaColor starcolor = RandomGen.NextColor( Jypeli.Color.White, new Color( 192, 192, 192, 255 ) ).AsXnaColor();

                    if ( star + k < textureColors.Length )
                        textureColors[star + k] = starcolor;

                    if ( size % 2 != 0 || size == 2 )
                        continue;

                    int nextStar = star + k + width;

                    if ( nextStar < ( width * height ) )
                    {
                        textureColors[nextStar] = starcolor;
                    }
                }
            }

            //Texture2D newTexture = new Texture2D( Game.GraphicsDevice, width, height, 1, TextureUsage.None, SurfaceFormat.Color );
            Texture2D newTexture = new Texture2D( Game.GraphicsDevice, width, height, false, SurfaceFormat.Color );
            newTexture.SetData<XnaColor>( textureColors );

            return new Image( newTexture );
        }

        public static Image FromText( string text, Font font, Color textColor, Color backgroundColor )
        {
            if ( text == null )
                text = "";

            var spriteBatch = new SpriteBatch( Game.GraphicsDevice );
            var device = spriteBatch.GraphicsDevice;

            XnaV2 textDims = font.XnaFont.MeasureString( text );
            int textw = ( textDims.X > 1 ) ? Convert.ToInt32( textDims.X ) : 1;
            int texth = ( textDims.Y > 1 ) ? Convert.ToInt32( textDims.Y ) : 1;

            //RenderTarget2D rt = new RenderTarget2D( device, textw, texth, 1, device.DisplayMode.Format );
            RenderTarget2D rt = new RenderTarget2D( device, textw, texth, false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8 );

            //device.SetRenderTarget( 0, rt );
            device.SetRenderTarget( rt );
            device.Clear( ClearOptions.Target | ClearOptions.DepthBuffer, backgroundColor.AsXnaColor(), 1.0f, 0 );

            spriteBatch.Begin();
            spriteBatch.DrawString( font.XnaFont, text, XnaV2.Zero, textColor.AsXnaColor() );
            spriteBatch.End();

            //device.SetRenderTarget( 0, null );
            device.SetRenderTarget( null );

            //return new Image( rt.GetTexture() );
            return new Image( rt );
        }

        public static Image DrawTextOnImage( Image img, string text, Vector position, Font font, Color textColor, Color backgroundColor )
        {
            if ( text == null )
                text = "";

            var spriteBatch = new SpriteBatch( Game.GraphicsDevice );
            var device = spriteBatch.GraphicsDevice;

            XnaV2 textDims = font.XnaFont.MeasureString( text );
            int textw = ( textDims.X > 1 ) ? Convert.ToInt32( textDims.X ) : 1;
            int texth = ( textDims.Y > 1 ) ? Convert.ToInt32( textDims.Y ) : 1;

            //RenderTarget2D rt = new RenderTarget2D( device, textw, texth, 1, device.DisplayMode.Format );
            RenderTarget2D rt = new RenderTarget2D( device, img.Width, img.Height, false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8 );

            //device.SetRenderTarget( 0, rt );
            device.SetRenderTarget( rt );
            device.Clear( ClearOptions.Target | ClearOptions.DepthBuffer, backgroundColor.AsXnaColor(), 1.0f, 0 );

            float xpos = 0.5f * ( img.Width - textw ) + (float)position.X;
            float ypos = 0.5f * ( img.Height - texth ) - (float)position.Y;

            spriteBatch.Begin();
            spriteBatch.Draw( img.XNATexture, rt.Bounds, XnaColor.White );
            spriteBatch.DrawString( font.XnaFont, text, new XnaV2( xpos, ypos ), textColor.AsXnaColor() );
            spriteBatch.End();

            //device.SetRenderTarget( 0, null );
            device.SetRenderTarget( null );


            //return new Image( rt.GetTexture() );
            return new Image( rt );
        }

        public static Image DrawTextOnImage( Image img, string text, Font font, Color textColor )
        {
            return DrawTextOnImage( img, text, Vector.Zero, font, textColor, Jypeli.Color.Transparent );
        }

        public static Image FromGradient( int imageWidth, int imageHeight, Color lowerColor, Color upperColor )
        {
            XnaColor lower = lowerColor.AsXnaColor();
            XnaColor upper = upperColor.AsXnaColor();
            XnaColor[] textureColors = new XnaColor[imageWidth * imageHeight];
            int i = 0;

            for ( int ver = 0; ver < imageHeight; ver++ )
            {
                for ( int hor = 0; hor < imageWidth; hor++ )
                {
                    textureColors[i++] = XnaColor.Lerp( upper, lower, ( (float)ver / (float)imageHeight ) );
                }
            }

            Texture2D newTexture = new Texture2D( Game.GraphicsDevice, imageWidth, imageHeight, false, SurfaceFormat.Color );
            newTexture.SetData<XnaColor>( textureColors );
            return new Image( newTexture );
        }

        public static Image FromColor( int imageWidth, int imageHeight, Color color )
        {
            return Image.FromGradient( imageWidth, imageHeight, color, color );
        }

        private static XnaColor[] MirrorLine( XnaColor[] scanline, int width )
        {
            XnaColor[] res = new XnaColor[width];
            int l = 0;
            int r = width - 1;

            while ( l < r )
            {
                res[l] = scanline[r];
                res[r] = scanline[l];
                l++; r--;
            }

            if ( l == r )
            {
                // Center pixel
                res[l] = scanline[l];
            }

            return res;
        }

        public static Image Mirror( Image image )
        {
            Texture2D newTex = new Texture2D( image.XNATexture.GraphicsDevice, image.Width, image.Height, false, image.XNATexture.Format );
            XnaColor[] scanline = new XnaColor[image.Width];
            var scanRect = new XnaRectangle( 0, 0, image.Width, 1 );

            for ( scanRect.Y = 0; scanRect.Y < image.Height; scanRect.Y++ )
            {
                image.XNATexture.GetData<XnaColor>( 0, scanRect, scanline, 0, image.Width );
                scanline = MirrorLine( scanline, image.Width );
                newTex.SetData<XnaColor>( 0, scanRect, scanline, 0, image.Width );
            }

            return new Image( newTex );
        }

        public static Image[] Mirror( Image[] images )
        {
            Image[] result = new Image[images.Length];
            for ( int i = 0; i < images.Length; i++ )
                result[i] = Mirror( images[i] );
            return result;
        }

        public static Image Flip( Image image )
        {
            Texture2D newTex = new Texture2D( image.XNATexture.GraphicsDevice, image.Width, image.Height, false, image.XNATexture.Format );
            XnaColor[] scanlineUpper = new XnaColor[image.Width];
            XnaColor[] scanlineLower = new XnaColor[image.Width];
            var scanRectUpper = new XnaRectangle( 0, 0, image.Width, 1 );
            var scanRectLower = new XnaRectangle( 0, 0, image.Width, 1 );

            for ( int i = 0; i < image.Height / 2; i++ )
            {
                scanRectUpper.Y = i;
                scanRectLower.Y = image.Height - 1 - i;

                image.XNATexture.GetData<XnaColor>( 0, scanRectUpper, scanlineUpper, 0, image.Width );
                image.XNATexture.GetData<XnaColor>( 0, scanRectLower, scanlineLower, 0, image.Width );

                newTex.SetData<XnaColor>( 0, scanRectUpper, scanlineLower, 0, image.Width );
                newTex.SetData<XnaColor>( 0, scanRectLower, scanlineUpper, 0, image.Width );
            }

            if ( image.Height % 2 == 1 )
            {
                // Center line
                scanRectUpper.Y = image.Height / 2;
                image.XNATexture.GetData<XnaColor>( 0, scanRectUpper, scanlineUpper, 0, image.Width );
                newTex.SetData<XnaColor>( 0, scanRectUpper, scanlineUpper, 0, image.Width );
            }

            return new Image( newTex );
        }

        public static Image[] Flip( Image[] images )
        {
            Image[] result = new Image[images.Length];
            for ( int i = 0; i < images.Length; i++ )
                result[i] = Flip( images[i] );
            return result;
        }

        public static Image Color( Image image, Color color )
        {
            Texture2D newTex = new Texture2D( image.XNATexture.GraphicsDevice, image.Width, image.Height, false, image.XNATexture.Format );
            XnaColor[] scanline = new XnaColor[image.Width];
            var scanRect = new XnaRectangle( 0, 0, image.Width, 1 );
            XnaColor xnaColor = color.AsXnaColor();

            for ( scanRect.Y = 0; scanRect.Y < image.Height; scanRect.Y++ )
            {
                image.XNATexture.GetData<XnaColor>( 0, scanRect, scanline, 0, image.Width );

                for ( int i = 0; i < image.Width; i++ )
                {
                    if ( scanline[i].A < 255 )
                    {
                        scanline[i].R = (byte)( ( 255 - scanline[i].A ) * xnaColor.R + scanline[i].A * scanline[i].R );
                        scanline[i].G = (byte)( ( 255 - scanline[i].A ) * xnaColor.G + scanline[i].A * scanline[i].G );
                        scanline[i].B = (byte)( ( 255 - scanline[i].A ) * xnaColor.B + scanline[i].A * scanline[i].B );

                        if ( scanline[i].A > 10 )
                        {
                            scanline[i].A = color.AlphaComponent;
                        }
                    }
                }

                newTex.SetData<XnaColor>( 0, scanRect, scanline, 0, image.Width );
            }

            return new Image( newTex );
        }

        public static Image[] Color( Image[] images, Color color )
        {
            Image[] result = new Image[images.Length];
            for ( int i = 0; i < images.Length; i++ )
                result[i] = Color( images[i], color );
            return result;
        }

        public static Image Color( Image image, byte alpha )
        {
            Texture2D newTex = new Texture2D( image.XNATexture.GraphicsDevice, image.Width, image.Height, false, image.XNATexture.Format );
            XnaColor[] scanline = new XnaColor[image.Width];
            var scanRect = new XnaRectangle( 0, 0, image.Width, 1 );

            for ( scanRect.Y = 0; scanRect.Y < image.Height; scanRect.Y++ )
            {
                image.XNATexture.GetData<XnaColor>( 0, scanRect, scanline, 0, image.Width );
                for ( int i = 0; i < image.Width; i++ )
                {
                    scanline[i].A = alpha;
                }
                newTex.SetData<XnaColor>( 0, scanRect, scanline, 0, image.Width );
            }
            return new Image( newTex );
        }

        public static Image TileHorizontal( Image left, Image right )
        {
            if ( left.Height != right.Height ) throw new InvalidOperationException( "Cannot tile two images with different height" );

            left.DoInitTexture();
            right.DoInitTexture();

            XnaRectangle leftRect = new XnaRectangle( 0, 0, left.Width, left.Height );
            XnaRectangle rightSrc = new XnaRectangle( 0, 0, right.Width, right.Height );
            XnaRectangle rightDest = new XnaRectangle( left.Width, 0, right.Width, right.Height );

            Image tiled = new Image( left.Width + right.Width, left.Height );
            tiled.InitTexture += delegate { CopyData( tiled, left, leftRect, leftRect ); };
            tiled.InitTexture += delegate { CopyData( tiled, right, rightDest, rightSrc ); };

            return tiled;
        }

        public static Image TileVertical( Image top, Image bottom )
        {
            if ( top.Width != bottom.Width ) throw new InvalidOperationException( "Cannot tile two images with different width" );

            top.DoInitTexture();
            bottom.DoInitTexture();

            XnaRectangle topRect = new XnaRectangle( 0, 0, top.Width, top.Height );
            XnaRectangle botSrc = new XnaRectangle( 0, 0, bottom.Width, bottom.Height );
            XnaRectangle botDest = new XnaRectangle( 0, top.Height, bottom.Width, bottom.Height );

            Image tiled = new Image( top.Width, top.Height + bottom.Height );
            tiled.InitTexture += delegate { CopyData( tiled, top, topRect, topRect ); };
            tiled.InitTexture += delegate { CopyData( tiled, bottom, botDest, botSrc ); };

            return tiled;
        }

        #endregion

        public Image Area( int left, int top, int right, int bottom )
        {
            int width = right - left;
            int height = bottom - top;

            if ( width <= 0 ) throw new ArgumentException( "Left coordinate must be less than right coordinate" );
            if ( height <= 0 ) throw new ArgumentException( "Top coordinate must be less than bottom coordinate" );

            XnaRectangle srcRect = new XnaRectangle( left, top, width, height );
            XnaRectangle destRect = new XnaRectangle( 0, 0, width, height );

            Image areaImage = new Image( width, height );
            areaImage.parentImage = this;
            areaImage.parentRectangle = srcRect;
            areaImage.InitTexture += delegate { CopyData( areaImage, this, destRect, srcRect ); };
            return areaImage;
        }

        public void Fill( Color backColor )
        {
            DoInitTexture();
            InvalidateAsset();

            XnaRectangle rect = new XnaRectangle( 0, 0, xnaTexture.Width, 1 );
            Color[] scanline = new Color[xnaTexture.Width];

            for ( int i = 0; i < xnaTexture.Width; i++ )
                scanline[i] = backColor;

            for ( rect.Y = 0; rect.Y < xnaTexture.Height; rect.Y++ )
                xnaTexture.SetData<Color>( 0, rect, scanline, 0, xnaTexture.Width );

            UpdateTexture();
        }

        public void ReplaceColor( Color src, Color dest, double tolerance, bool blend, bool exactAlpha = false )
        {
            XnaColor srcColor = src.AsXnaColor();
            XnaColor destColor = dest.AsXnaColor();
            Converter<XnaColor, XnaColor> op = delegate( XnaColor c )
            {
                if ( exactAlpha && c.A != srcColor.A )
                    return c;

                if ( JyColor.Distance( c, srcColor ) <= tolerance )
                {
                    if ( !blend ) return destColor;
                    Vector3 srcDist = new Vector3( c.R - srcColor.R, c.G - srcColor.G, c.B - srcColor.B );
                    return new XnaColor( destColor.ToVector3() + srcDist );
                }

                return c;
            };

            ApplyPixelOperation( op );
        }

        public void ReplaceColor( Color src, Color dest )
        {
            XnaColor srcColor = src.AsXnaColor();
            XnaColor destColor = dest.AsXnaColor();
            Converter<XnaColor, XnaColor> op = delegate( XnaColor c )
            {
                return c == srcColor ? destColor : c;
            };

            ApplyPixelOperation( op );
        }

        public Stream AsJpeg()
        {
            DoInitTexture();
            MemoryStream jpegStream = new MemoryStream();
            XNATexture.SaveAsJpeg( jpegStream, Width, Height );
            jpegStream.Seek( 0, SeekOrigin.Begin );
            return jpegStream;
        }

        public Stream AsPng()
        {
            DoInitTexture();
            MemoryStream pngStream = new MemoryStream();
            XNATexture.SaveAsPng( pngStream, Width, Height );
            pngStream.Seek( 0, SeekOrigin.Begin );
            return pngStream;
        }
    }
}