MARKUS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Diagnostics;

using System.Windows.Media;

using System.Windows;

using System.Security.Permissions;

using System.IO;

using System.Xml.Linq;

using System.Globalization;

namespace ImageFields

{

    public class SparseImageCreator : ImageFieldsBase

    {

        // Fields

        private Color backgroundColor = defaultOpaqueBackgroundColor;

        private bool copyMetadata;

        private static Color defaultAlphaBackgroundColor = Colors.Transparent;

        private static Color defaultOpaqueBackgroundColor = Colors.White;

        private const double Epsilon = 1E-10;

        private bool userSelectedBkColor = false;

        // Methods

        public SparseImageCreator()

        {

            this.ServerFormatXML = ServerFormats.Default;

            this.NoCaching = false;

        }

        private Int32Rect ComputeTileRect(ref Rect levelTargetRect)

        {

            int x = (int)Math.Floor((double)(levelTargetRect.Left / ((double)this.TileSize)));

            if (x < 0)

            {

                x = 0;

            }

            int num2 = (int)Math.Ceiling((double)(levelTargetRect.Right / ((double)this.TileSize)));

            int y = (int)Math.Floor((double)(levelTargetRect.Top / ((double)this.TileSize)));

            if (y < 0)

            {

                y = 0;

            }

            int num4 = (int)Math.Ceiling((double)(levelTargetRect.Bottom / ((double)this.TileSize)));

            return new Int32Rect(x, y, num2 - x, num4 - y);

        }

        [FileIOPermission(SecurityAction.LinkDemand)]

        public void Create(ICollection<Image> images, string destination)

        {

            double num15;

            Rect rect;

            double num16;

            int num17;

            int num18;

            int num22;

            int num23;

            int num24;

            int num25;

            Rect rect3;

            int num26;

            int num27;

            EventHandler<StreamEventArgs> handler = null;

            EventHandler<StreamEventArgs> handler2 = null;

            EventHandler<StreamEventArgs> handler3 = null;

            EventHandler<StreamEventArgs> handler4 = null;

            BitmapTransformer transformer = new BitmapTransformer

            {

                StripingEnabled = base.UseOptimizations

            };

            bool useOptimizations = base.UseOptimizations;

            if (this.NoCaching)

            {

                transformer.LargeFile = 0;

            }

            ImageFormat tileFormat = base.TileFormat;

            int finishedTiles = 0;

            int totalTiles = 0;

            foreach (Image image in images)

            {

                Uri uri = new Uri(image.Path, UriKind.RelativeOrAbsolute);

                if (!uri.IsAbsoluteUri)

                {

                    image.Path = Path.GetFullPath(image.Path);

                }

            }

            if (base.HasInputNeededHandler())

            {

                if (handler == null)

                {

                    handler = (o, e) => base.OnInputNeeded(e);

                }

                transformer.InputNeeded += handler;

            }

            if (base.HasInputCompletedHandler())

            {

                if (handler2 == null)

                {

                    handler2 = (o, e) => base.OnInputCompleted(e);

                }

                transformer.InputCompleted += handler2;

            }

            if (base.HasOutputNeededHandler())

            {

                if (handler3 == null)

                {

                    handler3 = (o, e) => base.OnOutputNeeded(e);

                }

                transformer.OutputNeeded += handler3;

            }

            if (base.HasOutputCompletedHandler())

            {

                if (handler4 == null)

                {

                    handler4 = delegate(object o, StreamEventArgs e)

                    {

                        finishedTiles++;

                        e.Progress = ((double)finishedTiles) / ((double)totalTiles);

                        this.OnOutputCompleted(e);

                    };

                }

                transformer.OutputCompleted += handler4;

            }

            transformer.CopyMetadata = this.CopyMetadata;

            if (string.IsNullOrEmpty(Path.GetExtension(destination)))

            {

                destination = Path.ChangeExtension(destination, "xml");

            }

            double num = 1.0;

            double num2 = 0.0;

            double num3 = 0.0;

            bool flag2 = false;

            foreach (Image image in images)

            {

                if (image.ViewportWidth == 0.0)

                {

                    throw new ArgumentException("ViewportWidth cannot be 0:" + image.Path, "images");

                }

                transformer.AddInput(image.Path);

                if (image.Size.X == 0.0)

                {

                    image.Size = transformer.GetPixelSize(image.Path);

                }

                if (image.Dpi.X == 0.0)

                {

                    Point dpi = transformer.GetDpi(image.Path);

                    if ((dpi.X == 0.0) && (dpi.Y == 0.0))

                    {

                        image.Dpi = new Point(1.0, 1.0);

                    }

                    else

                    {

                        image.Dpi = dpi;

                    }

                }

                if (base.HasInputImageInfoHandler())

                {

                    PixelFormat pixelFormat = transformer.GetPixelFormat(image.Path);

                    ImageInfoEventArgs args = new ImageInfoEventArgs(image.Path, image.Size, image.Dpi, pixelFormat);

                    base.OnInputImageInfo(args);

                }

                if (!(image.Dpi.X == image.Dpi.Y))

                {

                    throw new ArgumentException("Image has different vertical DPI than horizontal DPI:" + image.Path, "images");

                }

                if (!((flag2 || !(Path.GetExtension(image.Path) != ".jpg")) || transformer.IsOpaque(image.Path)))

                {

                    flag2 = true;

                }

                if (!this.userSelectedBkColor)

                {

                    if (flag2)

                    {

                        this.backgroundColor = defaultAlphaBackgroundColor;

                    }

                    else

                    {

                        this.backgroundColor = defaultOpaqueBackgroundColor;

                    }

                }

                if (this.backgroundColor.A < 0xff)

                {

                    flag2 = true;

                }

                num3 += image.Size.X * image.Size.Y;

                double num4 = (1.0 / image.ViewportWidth) / image.Size.X;

                double num5 = (num4 * image.Dpi.X) / image.Dpi.Y;

                double num6 = num5 * image.Size.Y;

                double num7 = (-image.ViewportOrigin.Y / image.ViewportWidth) + num6;

                double num8 = Math.Max(Math.Min(num4, num5), 1.0 / image.MaxViewportWidth);

                num = Math.Min(num, num8);

                num2 = Math.Max(num2, num7);

                if ((((-image.ViewportOrigin.X + 1.0) / image.ViewportWidth) - 1.0) > 1E-10)

                {

                    throw new ArgumentException("Image out of bounds " + image.Path, "images");

                }

                if ((image.ViewportOrigin.X > 0.0) || (image.ViewportOrigin.Y > 0.0))

                {

                    throw new ArgumentException("Image out of bounds " + image.Path, "images");

                }

            }

            if (tileFormat == ImageFormat.AutoSelect)

            {

                if (images.Count == 1)

                {

                    IEnumerator<Image> enumerator = images.GetEnumerator();

                    enumerator.MoveNext();

                    try

                    {

                        tileFormat = (ImageFormat)Enum.Parse(typeof(ImageFormat), Path.GetExtension(enumerator.Current.Path).Substring(1), true);

                    }

                    catch (Exception)

                    {

                    }

                }

                if (tileFormat == ImageFormat.AutoSelect)

                {

                    if (flag2)

                    {

                        tileFormat = ImageFormat.Png;

                    }

                    else

                    {

                        tileFormat = ImageFormat.Jpg;

                    }

                }

            }

            double num9 = Math.Round((double)(1.0 / num));

            double num10 = Math.Round((double)(num2 / num));

            int num11 = 0;

            int num12 = 0;

            if ((num9 > 2147483647.0) || (num10 > 2147483647.0))

            {

                Console.WriteLine(string.Concat(new object[] { "Warning: Maximum image size exceeded; Image would be ", num9, " by ", num10 }));

                Debug.WriteLine(string.Concat(new object[] { "Warning: Maximum image size exceeded; Image would be ", num9, " by ", num10 }));

                if (num9 > num10)

                {

                    num11 = (int)Math.Pow(2.0, (double)base.MaxLevel);

                    num12 = (int)Math.Round((double)((num11 * num10) / num9));

                }

                else

                {

                    num12 = (int)Math.Pow(2.0, 30.0);

                    num11 = (int)Math.Round((double)((num12 * num9) / num10));

                }

                Console.WriteLine(string.Concat(new object[] { "Image will be scaled to ", num11, " by ", num12 }));

                Debug.WriteLine(string.Concat(new object[] { "Image will be scaled to ", num11, " by ", num12 }));

            }

            else

            {

                num11 = (int)num9;

                num12 = (int)num10;

            }

            int maxLevel = (int)Math.Ceiling(Math.Log((double)Math.Max(num11, num12), 2.0));

            if (maxLevel > base.MaxLevel)

            {

                num15 = Math.Pow(2.0, (double)(maxLevel - base.MaxLevel));

                num11 = (int)Math.Ceiling((double)(((double)num11) / num15));

                num12 = (int)Math.Ceiling((double)(((double)num12) / num15));

                maxLevel = base.MaxLevel;

            }

            bool flag3 = false;

            foreach (Image image in images)

            {

                rect = ImageToRect(num11, num12, image);

                num16 = Math.Max(image.Dpi.X, image.Dpi.Y);

                num17 = maxLevel - ((int)Math.Floor(Math.Log(((rect.Width / image.Size.X) * image.Dpi.X) / num16, 2.0)));

                num18 = maxLevel + ((int)Math.Floor(Math.Log(image.MaxViewportWidth / ((double)num11), 2.0)));

                Debug.WriteLine(string.Concat(new object[] { image.Path, ",", num18, ",", num17 }));

                if (num18 > 500)

                {

                    num18 = num17;

                }

                else if (num18 == num17)

                {

                    num18 = num17 + 1;

                }

                else if (num18 > num17)

                {

                    throw new ArgumentException("MaxViewportWidth exteds beyond the supported value. image:" + image.Path);

                }

                if ((num18 > maxLevel) && (num18 <= base.MaxLevel))

                {

                    flag3 = true;

                }

            }

            if (flag3)

            {

                num15 = Math.Pow(2.0, (double)(maxLevel - base.MaxLevel));

                num9 = Math.Ceiling((double)(num11 * 2.0));

                num10 = Math.Ceiling((double)(num12 * 2.0));

                if ((num9 > 2147483647.0) || (num10 > 2147483647.0))

                {

                    throw new ArgumentException("MaxViewportWidth forces a unsupported images size");

                }

                num11 = (int)num9;

                num12 = (int)num10;

                maxLevel = (int)Math.Ceiling(Math.Log((double)Math.Max(num11, num12), 2.0));

                if (maxLevel > base.MaxLevel)

                {

                    throw new ArgumentException("MaxViewportWidth forces a unsupported images size");

                }

            }

            Debug.WriteLine(string.Concat(new object[] { "Image size:", num11, " ", num12, " ", maxLevel }));

            Debug.WriteLine(images.Count + " inputs, total pixels: " + num3);

            string str = base.CreateDirectories(destination, maxLevel);

            List<RectCollection> list = new List<RectCollection>(maxLevel);

            List<RectCollection> list2 = new List<RectCollection>(maxLevel);

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

            {

                list.Add(new RectCollection());

                list2.Add(new RectCollection());

            }

            int num20 = this.FindSingleTileLevel(num11, num12, maxLevel) + 1;

            int num21 = num20;

            if (maxLevel < num21)

            {

                useOptimizations = false;

            }

            num20 = Math.Min(num20, maxLevel);

            foreach (Image image in images)

            {

                rect = ImageToRect(num11, num12, image);

                num16 = Math.Max(image.Dpi.X, image.Dpi.Y);

                num17 = maxLevel - ((int)Math.Floor(Math.Log(((rect.Width / image.Size.X) * image.Dpi.X) / num16, 2.0)));

                num18 = maxLevel + ((int)Math.Floor(Math.Log(image.MaxViewportWidth / ((double)num11), 2.0)));

                if ((num18 < maxLevel) && (num18 < num20))

                {

                    useOptimizations = false;

                }

                else

                {

                    num22 = maxLevel + ((int)Math.Ceiling(Math.Log(image.MinViewportWidth / ((double)num11), 2.0)));

                    if (num22 > 0)

                    {

                        useOptimizations = false;

                    }

                }

                Debug.WriteLine(string.Concat(new object[] { image.Path, ",", num18, ",", num17 }));

                if (num18 > 500)

                {

                    num18 = num17;

                }

                else if (num18 <= num17)

                {

                    num18++;

                }

                else if (num18 > num17)

                {

                    throw new ArgumentException("MaxViewportWidth exteds beyond the supported value. image:" + image.Path);

                }

                num18 = Math.Min(maxLevel, num18);

                Int32Rect toAdd = BitmapTransformer.RectToInt32Rect(rect);

                for (num23 = num20; num23 <= num18; num23++)

                {

                    list2[num23].Add(ref toAdd);

                    num15 = Math.Pow(2.0, (double)(maxLevel - num23));

                    num24 = (int)Math.Ceiling((double)(((double)num11) / num15));

                    num25 = (int)Math.Ceiling((double)(((double)num12) / num15));

                    rect3 = rect;

                    rect3.Scale(((double)num24) / ((double)num11), ((double)num25) / ((double)num12));

                    if ((rect3.Bottom > num25) && (rect3.Bottom < (num25 + 0.5)))

                    {

                        rect3.Height = num25 - rect3.Top;

                    }

                    if ((rect3.Right > num24) && (rect3.Right < (num24 + 0.5)))

                    {

                        rect3.Width = num24 - rect3.Left;

                    }

                    Int32Rect rect4 = this.ComputeTileRect(ref rect3);

                    list[num23].Add(ref rect4);

                }

            }

            if (useOptimizations)

            {

                num15 = Math.Pow(2.0, (double)(maxLevel - num21));

                num26 = (int)Math.Ceiling((double)(((double)num11) / num15));

                num27 = (int)Math.Ceiling((double)(((double)num12) / num15));

                int num28 = (int)Math.Ceiling((double)(((double)num26) / ((double)this.TileSize)));

                int height = (int)Math.Ceiling((double)(((double)num27) / ((double)this.TileSize)));

                Int32Rect rect5 = new Int32Rect(0, 0, num28, height);

                if (!((list[num21].Rects.Count != 0) && list[num21].Rects[0].Equals(rect5)))

                {

                    useOptimizations = false;

                }

            }

            if (!useOptimizations)

            {

                Int32Rect rect6 = new Int32Rect(0, 0, 1, 1);

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

                {

                    list[i].Add(ref rect6);

                }

            }

            num23 = 0;

            while (num23 <= maxLevel)

            {

                foreach (Int32Rect rect4 in list[num23].Rects)

                {

                    totalTiles += rect4.Width * rect4.Height;

                }

                num23++;

            }

            if (useOptimizations)

            {

                totalTiles += num20;

            }

            if (base.HasOutputInfoHandler())

            {

                OutputInfoEventArgs args2 = new OutputInfoEventArgs(destination, new Point((double)num11, (double)num12), new Point(96.0, 96.0), transformer.ChoosePixelFormat(tileFormat), tileFormat, maxLevel, totalTiles);

                base.OnOutputInfo(args2);

            }

            if (this.CopyMetadata)

            {

                XElement element = new XElement((XName)(DZTCommon.DeepZoomNamespace + "Size"), new object[] { new XAttribute("Width", num11), new XAttribute("Height", num12) });

                XElement element2 = new XElement((XName)(DZTCommon.DeepZoomNamespace + "Image"), new object[] { new XAttribute("TileSize", this.TileSize), new XAttribute("Overlap", base.TileOverlap), new XAttribute("Format", tileFormat.ToString().ToLowerInvariant()), new XAttribute("ServerFormat", this.ServerFormatXML.ToString()), element });

                if (images.Count > 1)

                {

                    Int32Rect rect7 = new Int32Rect(0, 0, num11, num12);

                    while ((num20 < maxLevel) && (list2[num20 + 1].Rects[0] == rect7))

                    {

                        num20++;

                    }

                    if ((num20 + 1) < maxLevel)

                    {

                        List<XElement> content = new List<XElement> {

                    CreateDisplayRect(0, num20, 0, 0, num11, num12)

                };

                        for (int i = num20 + 1; i <= maxLevel; i++)

                        {

                            foreach (Int32Rect rect2 in list2[i].Rects)

                            {

                                content.Add(CreateDisplayRect(i, i, rect2.X, rect2.Y, rect2.Width, rect2.Height));

                            }

                        }

                        element2.Add(new XElement((XName)(DZTCommon.DeepZoomNamespace + "DisplayRects"), content));

                    }

                }

                StreamEventArgs args3 = new StreamEventArgs(destination)

                {

                    MimeType = "application/xml",

                    Compress = true

                };

                if (base.HasOutputNeededHandler())

                {

                    base.OnOutputNeeded(args3);

                    using (StreamWriter writer = new StreamWriter(args3.Stream))

                    {

                        element2.Save(writer, SaveOptions.DisableFormatting);

                        writer.Flush();

                    }

                }

                else

                {

                    element2.Save(destination, SaveOptions.DisableFormatting);

                }

                if (base.HasOutputCompletedHandler())

                {

                    base.OnOutputCompleted(args3);

                }

                element = null;

                element2 = null;

                list2 = null;

            }

            transformer.OutputAlpha = flag2;

            string str2 = "." + tileFormat.ToString().ToLowerInvariant();

            int width = this.TileSize + (2 * base.TileOverlap);

            int num31 = num21;

            if (!useOptimizations)

            {

                num31 = 0;

            }

            for (num23 = maxLevel; num23 >= num31; num23--)

            {

                bool flag4;

                if (useOptimizations && (num23 == num21))

                {

                    flag4 = true;

                }

                else

                {

                    flag4 = false;

                }

                num15 = Math.Pow(2.0, (double)(maxLevel - num23));

                num24 = (int)Math.Ceiling((double)(((double)num11) / num15));

                num25 = (int)Math.Ceiling((double)(((double)num12) / num15));

                Int32Rect b = new Int32Rect(0, 0, num24, num25);

                string str3 = Path.Combine(str, num23.ToString(CultureInfo.InvariantCulture)) + Path.DirectorySeparatorChar;

                foreach (Int32Rect rect4 in list[num23].Rects)

                {

                    int x;

                    Int32Rect rect9;

                    Rect rect10;

                    string str4;

                    int y = rect4.Y;

                    while (y < (rect4.Y + rect4.Height))

                    {

                        x = rect4.X;

                        while (x < (rect4.X + rect4.Width))

                        {

                            rect9 = new Int32Rect((x * this.TileSize) - base.TileOverlap, (y * this.TileSize) - base.TileOverlap, width, width);

                            rect9 = Int32RectIntersect(rect9, b);

                            rect10 = BitmapTransformer.Int32RectToRect(rect9);

                            str4 = str3 + x.ToString(CultureInfo.InvariantCulture) + "_" + y.ToString(CultureInfo.InvariantCulture) + str2;

                            transformer.AddOutput(str4, rect9.Width, rect9.Height, base.ImageQuality, tileFormat, this.BackgroundColor, flag4);

                            x++;

                        }

                        y++;

                    }

                    foreach (Image image in images)

                    {

                        num22 = maxLevel + ((int)Math.Ceiling(Math.Log(image.MinViewportWidth / ((double)num11), 2.0)));

                        num18 = maxLevel + ((int)Math.Floor(Math.Log(image.MaxViewportWidth / ((double)num11), 2.0)));

                        if ((num23 >= num22) && (num23 <= num18))

                        {

                            rect = ImageToRect(num11, num12, image);

                            num16 = Math.Max(image.Dpi.X, image.Dpi.Y);

                            Point point2 = new Point((image.Size.X / image.Dpi.X) * num16, (image.Size.Y / image.Dpi.Y) * num16);

                            rect3 = rect;

                            rect3.Scale(((double)num24) / ((double)num11), ((double)num25) / ((double)num12));

                            if (DoesInt32RectIntersect(this.ComputeTileRect(ref rect3), rect4))

                            {

                                for (y = rect4.Y; y < (rect4.Y + rect4.Height); y++)

                                {

                                    for (x = rect4.X; x < (rect4.X + rect4.Width); x++)

                                    {

                                        rect9 = new Int32Rect((x * this.TileSize) - base.TileOverlap, (y * this.TileSize) - base.TileOverlap, width, width);

                                        rect9 = Int32RectIntersect(rect9, b);

                                        Rect rect12 = BitmapTransformer.Int32RectToRect(rect9);

                                        rect10 = Rect.Intersect(rect12, rect3);

                                        if (!rect10.IsEmpty)

                                        {

                                            str4 = str3 + x.ToString(CultureInfo.InvariantCulture) + "_" + y.ToString(CultureInfo.InvariantCulture) + str2;

                                            rect10.Offset((double)-rect9.X, (double)-rect9.Y);

                                            rect12.Scale(((double)num11) / ((double)num24), ((double)num12) / ((double)num25));

                                            rect12.Intersect(rect);

                                            rect12.Offset(-rect.X, -rect.Y);

                                            rect12.Scale(point2.X / rect.Width, point2.Y / rect.Height);

                                            transformer.AddTransformation(image.Path, str4, rect12, rect10);

                                        }

                                    }

                                }

                            }

                        }

                    }

                    transformer.Execute();

                }

                foreach (Image image in images)

                {

                    num18 = maxLevel + ((int)Math.Ceiling(Math.Log(image.MaxViewportWidth / ((double)num11), 2.0)));

                    if (num23 == num18)

                    {

                        transformer.CloseInput(image.Path);

                    }

                }

                GC.Collect(2);

                GC.Collect(2);

            }

            transformer.CloseAllInputs();

            GC.Collect(2);

            GC.Collect(2);

            if (useOptimizations)

            {

                string str8;

                Rect rect15;

                int num34 = num21;

                int num35 = num34 - 1;

                string str5 = Path.Combine(str, num35.ToString(CultureInfo.InvariantCulture)) + Path.DirectorySeparatorChar;

                string str6 = Path.Combine(str, num34.ToString(CultureInfo.InvariantCulture)) + Path.DirectorySeparatorChar;

                string fileName = str5 + "0_0" + str2;

                num15 = Math.Pow(2.0, (double)(maxLevel - num34));

                num26 = (int)Math.Ceiling((double)(((double)num11) / num15));

                num27 = (int)Math.Ceiling((double)(((double)num12) / num15));

                num15 = Math.Pow(2.0, (double)(maxLevel - num35));

                int num36 = (int)Math.Ceiling((double)(((double)num11) / num15));

                int num37 = (int)Math.Ceiling((double)(((double)num12) / num15));

                Int32Rect rect13 = new Int32Rect(0, 0, num26, num27);

                transformer.AddOutput(fileName, num36, num37, base.ImageQuality, tileFormat, this.BackgroundColor, true);

                int tileOverlap = 0;

                for (int i = 0; i < num27; i += this.TileSize)

                {

                    int tileSize = this.TileSize;

                    if ((i + tileSize) > num27)

                    {

                        tileSize = num27 % this.TileSize;

                    }

                    int num41 = 0;

                    for (int j = 0; j < num26; j += this.TileSize)

                    {

                        string[] strArray = new string[5];

                        strArray[0] = str6;

                        int num44 = j / this.TileSize;

                        strArray[1] = num44.ToString();

                        strArray[2] = "_";

                        strArray[3] = (i / this.TileSize).ToString();

                        strArray[4] = str2;

                        str8 = string.Concat(strArray);

                        transformer.AddOutputAsInput(str8);

                        int num43 = this.TileSize;

                        if ((j + num43) > num26)

                        {

                            num43 = num26 % this.TileSize;

                        }

                        Rect rect14 = new Rect((double)num41, (double)tileOverlap, (double)num43, (double)tileSize);

                        num41 = base.TileOverlap;

                        rect15 = new Rect(Math.Ceiling((double)(((double)j) / 2.0)), Math.Ceiling((double)(((double)i) / 2.0)), Math.Ceiling((double)(((double)num43) / 2.0)), Math.Ceiling((double)(((double)tileSize) / 2.0)));

                        if ((rect15.Width + rect15.X) > num36)

                        {

                            rect15.Width = num36 - rect15.X;

                        }

                        if ((rect15.Height + rect15.Y) > num37)

                        {

                            rect15.Height = num37 - rect15.Y;

                        }

                        transformer.AddTransformation(str8, fileName, rect14, rect15);

                    }

                    tileOverlap = base.TileOverlap;

                }

                transformer.Execute();

                Rect inputRect = new Rect(0.0, 0.0, (double)num36, (double)num37);

                str8 = fileName;

                transformer.AddOutputAsInput(str8);

                num35--;

                // 7레벨 이하 저장

                if(!this.LowLevelPass)

                    while (num35 >= 0)

                    {

                        fileName = (Path.Combine(str, num35.ToString(CultureInfo.InvariantCulture)) + Path.DirectorySeparatorChar) + "0_0" + str2;

                        num15 = Math.Pow(2.0, (double)(maxLevel - num35));

                        num36 = (int)Math.Ceiling((double)(((double)num11) / num15));

                        num37 = (int)Math.Ceiling((double)(((double)num12) / num15));

                        rect15 = new Rect(0.0, 0.0, (double)num36, (double)num37);

                        transformer.AddOutput(fileName, num36, num37, base.ImageQuality, tileFormat, this.BackgroundColor, false);

                        transformer.AddTransformation(str8, fileName, inputRect, rect15);

                        transformer.Execute();

                        num35--;

                    }

            }

            transformer.CleanUp();

            GC.Collect(2);

            GC.Collect(2);

        }

        private static XElement CreateDisplayRect(int minLevel, int maxLevel, int x, int y, int width, int height)

        {

            XElement element = new XElement((XName)(DZTCommon.DeepZoomNamespace + "Rect"), new object[] { new XAttribute("X", x), new XAttribute("Y", y), new XAttribute("Width", width), new XAttribute("Height", height) });

            return new XElement((XName)(DZTCommon.DeepZoomNamespace + "DisplayRect"), new object[] { new XAttribute("MinLevel", minLevel), new XAttribute("MaxLevel", maxLevel), element });

        }

        private static bool DoesInt32RectIntersect(Int32Rect a, Int32Rect b)

        {

            return (((((b.X + b.Width) >= a.X) && (b.X <= (a.X + a.Width))) && ((b.Y + b.Height) >= a.Y)) && (b.Y <= (a.Y + a.Height)));

        }

        private int FindSingleTileLevel(int width, int height, int level)

        {

            double num = Math.Max(width, height);

            while (((int)Math.Ceiling((double)(num / ((double)this.TileSize)))) > 1)

            {

                num /= 2.0;

                level--;

            }

            return level;

        }

        private static Rect ImageToRect(int fullWidth, int fullHeight, Image image)

        {

            double num = -image.ViewportOrigin.X / image.ViewportWidth;

            double num2 = -image.ViewportOrigin.Y / image.ViewportWidth;

            double num3 = 1.0 / image.ViewportWidth;

            double num4 = Math.Max(image.Dpi.X, image.Dpi.Y);

            Point point = new Point(((image.Size.X / image.Dpi.X) / 96.0) * num4, ((image.Size.Y / image.Dpi.Y) / 96.0) * num4);

            double num5 = (num3 * point.Y) / point.X;

            Rect rect = new Rect(num * fullWidth, num2 * fullWidth, num3 * fullWidth, num5 * fullWidth);

            if (rect.Bottom > fullHeight)

            {

                rect.Height = fullHeight - rect.Top;

            }

            return rect;

        }

        private static Int32Rect Int32RectIntersect(Int32Rect a, Int32Rect b)

        {

            if (DoesInt32RectIntersect(a, b))

            {

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

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

                int num3 = Math.Min((int)(a.X + a.Width), (int)(b.X + b.Width));

                int num4 = Math.Min((int)(a.Y + a.Height), (int)(b.Y + b.Height));

                return new Int32Rect(x, y, num3 - x, num4 - y);

            }

            return new Int32Rect(0, 0, 0, 0);

        }

        // Properties

        public Color BackgroundColor

        {

            get

            {

                return this.backgroundColor;

            }

            set

            {

                this.backgroundColor = value;

                this.userSelectedBkColor = true;

            }

        }

        public bool CopyMetadata

        {

            get

            {

                return this.copyMetadata;

            }

            set

            {

                this.copyMetadata = value;

            }

        }

        public bool NoCaching { get; set; }

        public ServerFormats ServerFormat

        {

            get

            {

                return base.ServerFormat;

            }

            set

            {

                if (value == ServerFormats.SmoothStreaming)

                {

                    throw new NotSupportedException("Smooth Streaming is not supported for Sparse Images");

                }

            }

        }

        internal ServerFormats ServerFormatXML { get; set; }

    }

}