public static void Animate(Image image, EventHandler onFrameChangedHandler)
 {
     if (image != null)
     {
         ImageInfo item = null;
         lock (image)
         {
             item = new ImageInfo(image);
         }
         StopAnimate(image, onFrameChangedHandler);
         bool isReaderLockHeld = rwImgListLock.IsReaderLockHeld;
         LockCookie lockCookie = new LockCookie();
         threadWriterLockWaitCount++;
         try
         {
             if (isReaderLockHeld)
             {
                 lockCookie = rwImgListLock.UpgradeToWriterLock(-1);
             }
             else
             {
                 rwImgListLock.AcquireWriterLock(-1);
             }
         }
         finally
         {
             threadWriterLockWaitCount--;
         }
         try
         {
             if (item.Animated)
             {
                 if (imageInfoList == null)
                 {
                     imageInfoList = new List<ImageInfo>();
                 }
                 item.FrameChangedHandler = onFrameChangedHandler;
                 imageInfoList.Add(item);
                 if (animationThread == null)
                 {
                     animationThread = new Thread(new ThreadStart(ImageAnimator.AnimateImages50ms));
                     animationThread.Name = typeof(ImageAnimator).Name;
                     animationThread.IsBackground = true;
                     animationThread.Start();
                 }
             }
         }
         finally
         {
             if (isReaderLockHeld)
             {
                 rwImgListLock.DowngradeFromWriterLock(ref lockCookie);
             }
             else
             {
                 rwImgListLock.ReleaseWriterLock();
             }
         }
     }
 }

        public async Task<ImageInfo[]> GetImages(Match match)
        {
            var id = match.Groups[1].Value;
            var key = "cloudapp-" + id;

            var result = await this._memoryCache.GetOrSet(
                "cloudapp-" + id,
                () => this.Fetch(match.Value)
            ).ConfigureAwait(false);

            ImageInfo i;
            switch (result.item_type)
            {
                case "image":
                    i = new ImageInfo(result.content_url, result.content_url, result.thumbnail_url ?? result.content_url);
                    break;
                case "video":
                    // ThumbnailUrl is probably null.
                    i = new ImageInfo(result.thumbnail_url, result.thumbnail_url, result.thumbnail_url, result.content_url, result.content_url, result.content_url);
                    break;
                default:
                    throw new NotPictureException();
            }

            return new[] { i };
        }

 public Product(string name, decimal unitPrice, Category category, ImageInfo image)
 {
     this.Name = name;
     this.UnitPrice = unitPrice;
     this.Category = category;
     this.Image = image;
 }

 public AttachedImage(PlatformClient client, AttachedImageData data)
     : base(client)
 {
     _data = data;
     Image = new ImageInfo(client, data.Image);
     Album = new AlbumInfo(client, data.Album);
 }

        public static ImageInfo toImgur(Bitmap bmp)
        {
            ImageConverter convert = new ImageConverter();
            byte[] toSend = (byte[])convert.ConvertTo(bmp, typeof(byte[]));
            using (WebClient wc = new WebClient())
            {
                NameValueCollection nvc = new NameValueCollection
                {
                    { "image", Convert.ToBase64String(toSend) }
                };
                wc.Headers.Add("Authorization", Imgur.getAuth());
                ImageInfo info = new ImageInfo();
                try  
                {
                    byte[] response = wc.UploadValues("https://api.imgur.com/3/upload.xml", nvc);
                    string res = System.Text.Encoding.Default.GetString(response);

                    var xmlDoc = new System.Xml.XmlDocument();
                    xmlDoc.LoadXml(res);
                    info.link = new Uri(xmlDoc.SelectSingleNode("data/link").InnerText);
                    info.deletehash = xmlDoc.SelectSingleNode("data/deletehash").InnerText;
                    info.id = xmlDoc.SelectSingleNode("data/id").InnerText;
                    info.success = true;
                }
                catch (Exception e)
                {
                    info.success = false;
                    info.ex = e;
                }
                return info;
            }
        }

        public async Task<ImageInfo[]> GetImages(Match match)
        {
            var username = match.Groups[1].Value;
            var id = match.Groups[2].Value;
            var info = await this._memoryCache.GetOrSet(
                "hatenafotolife-" + username + "/" + id,
                () => this.Fetch(username, id)
            ).ConfigureAwait(false);

            var result = new ImageInfo();
            var baseUri = "http://cdn-ak.f.st-hatena.com/images/fotolife/" + username.Substring(0, 1) + "/" + username + "/" + id.Substring(0, 8) + "/" + id;

            if (info.Extension == "flv")
            {
                result.VideoFull = result.VideoLarge = result.VideoMobile = baseUri + ".flv";
                result.Full = result.Large = baseUri + ".jpg";
            }
            else
            {
                result.Large = baseUri + "." + info.Extension;
                result.Full = info.IsOriginalAvailable
                    ? baseUri + "_original." + info.Extension
                    : result.Large;
            }

            result.Thumb = baseUri + "_120.jpg";

            return new[] { result };
        }

 void _timer_Tick(object sender, object e)
 {
     _timer.Stop();
     ImageInfo image = new ImageInfo();
     image.ViewBounds = this.ViewBounds;
     StartDownloadImage(image);
 }

        public void DoIt()
        {
            // Get the tool GUID;
            Type t = typeof(SimpleTool);
            GuidAttribute guidAttr = (GuidAttribute)t.GetCustomAttributes(typeof(GuidAttribute), false)[0];
            Guid guid = new Guid(guidAttr.Value);

            // don't redefine the stock tool if it's already in the catalog
            ToolPaletteManager mgr = ToolPaletteManager.Manager;
            if (mgr.StockToolCatalogs.Find(guid) != null)
                return;

            SimpleTool tool = new SimpleTool();
            tool.New();

            Catalog catalog = tool.CreateStockTool("SimpleCatalog");
            Palette palette = tool.CreatePalette(catalog, "SimplePalette");
            Package package = tool.CreateShapeCatalog("*AutoCADShapes");
            tool.CreateFlyoutTool(palette, package, null);
            ImageInfo imageInfo = new ImageInfo();
            imageInfo.ResourceFile = "TOOL1.bmp";
            imageInfo.Size=new System.Drawing.Size(65,65);

            tool.CreateCommandTool(palette, "Line", imageInfo, tool.CmdName);
            tool.CreateTool(palette, "Custom Line",imageInfo);
            mgr.LoadCatalogs();
        }

        /// <summary>
        ///     Resizes the image presented by the <paramref name="imageData"/> to a <paramref name="newSize"/>.
        /// </summary>
        /// <param name="imageData">
        ///     The binary data of the image to resize.
        /// </param>
        /// <param name="newSize">
        ///     The size to which to resize the image.
        /// </param>
        /// <param name="keepAspectRatio">
        ///     A flag indicating whether to save original aspect ratio.
        /// </param>
        /// <returns>
        ///     The structure which contains binary data of resized image and the actial size of resized image depending on <paramref name="keepAspectRatio"/> value.
        /// </returns>
        /// <exception cref="InvalidOperationException">
        ///     An error occurred during resizing the image.
        /// </exception>
        public static Task<ImageInfo> ResizeAsync(this byte[] imageData, Size newSize, bool keepAspectRatio)
        {
            var result = new ImageInfo();
            var image = imageData.ToBitmap();
            var percentWidth = (double) newSize.Width/(double) image.PixelWidth;
            var percentHeight = (double) newSize.Height/(double) image.PixelHeight;

            ScaleTransform transform;
            if (keepAspectRatio)
            {
                transform = percentWidth < percentHeight
                                ? new ScaleTransform {ScaleX = percentWidth, ScaleY = percentWidth}
                                : new ScaleTransform {ScaleX = percentHeight, ScaleY = percentHeight};
            }
            else
            {
                transform = new ScaleTransform {ScaleX = percentWidth, ScaleY = percentHeight};
            }

            var resizedImage = new TransformedBitmap(image, transform);

            using (var memoryStream = new MemoryStream())
            {
                var jpegEncoder = new JpegBitmapEncoder();
                jpegEncoder.Frames.Add(BitmapFrame.Create(resizedImage));
                jpegEncoder.Save(memoryStream);

                result.Data = memoryStream.ToArray();
                result.Size = new Size(resizedImage.PixelWidth, resizedImage.PixelHeight);
            }

            return Task.FromResult(result);
        }

        public void ProductImageReturnTheType()
        {
            ImageInfo imageInfo = new ImageInfo("Bike01.jpg");

            string type = imageInfo.ImageType;

            Assert.AreEqual("jpg", type);
        }

 public ResizeImageAction(ImageInfo imageInfo, int oldWidth, int oldHeight, int newWidth, int newHeight)
 {
     this.imageInfo = imageInfo;
     this.oldWidth = oldWidth;
     this.oldHeight = oldHeight;
     this.newWidth = newWidth;
     this.newHeight = newHeight;
 }

 public static OpenCLErrorCode GetImageInfo(IMemoryObject image,
                                      ImageInfo paramName,
                                      IntPtr paramValueSize,
                                      InfoBuffer paramValue,
                                      out IntPtr paramValueSizeRet)
 {
     return clGetImageInfo((image as IHandleData).Handle, paramName, paramValueSize, paramValue.Address, out paramValueSizeRet);
 }

 protected override void AfterSetUp()
 {
     _product = new ProductBuilder().Build();
     _image1 = new ImageInfo("1.png", ImageType.Png);
     _image2 = new ImageInfo("2.jpg", ImageType.Jpeg);
     _product.Images.Add(_image1);
     _product.Images.Add(_image2);
     Session.Save(_product);
 }

 void StartDownloadImage(ImageInfo image)
 {
     CancelRequest();
     _cts = new CancellationTokenSource();
     Task.Run(async () =>
     {
         await DownloadImage(image, _cts.Token);
     });
 }

        private static void GenerateCrop(Preset preset, string imgUrl, Config config, StringBuilder sbRaw)
        {
            if (string.IsNullOrEmpty(preset.Name))
                return;

            var imgInfo = new ImageInfo(imgUrl);

            var data = new SaveData(sbRaw.ToString());
            imgInfo.GenerateThumbnails(data, config);
        }

		void Log( ImageInfo imageInfo, bool imageLoaded )
		{
			string msg = String.Format( 
				"{0} - {1} BitmapImage: {2}", 
				++this.logCounter, 
				imageLoaded ? "Loaded" : "Unloaded",
				System.IO.Path.GetFileName( imageInfo.FileName ) );
			this.listBoxLog.Items.Add( msg );
			this.listBoxLog.ScrollIntoView( msg );
			this.listBoxLog.SelectedItem = msg;
		}

        public string Xml(Config config, ImageInfo imageInfo)
        {
            var doc = CreateBaseXmlDocument();
            var root = doc.DocumentElement;

            if (root == null) return null;

            var dateStampNode = doc.CreateNode(XmlNodeType.Attribute, "date", null);
            dateStampNode.Value = imageInfo.DateStamp.ToString("s");
            root.Attributes.SetNamedItem(dateStampNode);

            for (var i = 0; i < Data.Count; i++)
            {
                var crop = (Crop)Data[i];
                var preset = config.Presets[i];

                var newNode = doc.CreateElement("crop");

                var nameNode = doc.CreateNode(XmlNodeType.Attribute, "name", null);
                nameNode.Value = preset.Name;
                newNode.Attributes.SetNamedItem(nameNode);

                var xNode = doc.CreateNode(XmlNodeType.Attribute, "x", null);
                xNode.Value = crop.X.ToString(CultureInfo.InvariantCulture);
                newNode.Attributes.SetNamedItem(xNode);

                var yNode = doc.CreateNode(XmlNodeType.Attribute, "y", null);
                yNode.Value = crop.Y.ToString(CultureInfo.InvariantCulture);
                newNode.Attributes.SetNamedItem(yNode);

                var x2Node = doc.CreateNode(XmlNodeType.Attribute, "x2", null);
                x2Node.Value = crop.X2.ToString(CultureInfo.InvariantCulture);
                newNode.Attributes.SetNamedItem(x2Node);

                var y2Node = doc.CreateNode(XmlNodeType.Attribute, "y2", null);
                y2Node.Value = crop.Y2.ToString(CultureInfo.InvariantCulture);
                newNode.Attributes.SetNamedItem(y2Node);

                if (config.GenerateImages)
                {
                    var urlNode = doc.CreateNode(XmlNodeType.Attribute, "url", null);
                    urlNode.Value = String.Format("{0}/{1}_{2}.jpg",
                                                  imageInfo.RelativePath.Substring(0, imageInfo.RelativePath.LastIndexOf('/')),
                                                  imageInfo.Name,
                                                  preset.Name);
                    newNode.Attributes.SetNamedItem(urlNode);
                }

                root.AppendChild(newNode);
            }

            return doc.InnerXml;
        }

    /// <summary>
    /// Returns the next ImageInfo with random width and height
    /// </summary>
    /// <returns></returns>
    public ImageInfo Next()
    {
        int width = _r.Next(_minWidth, _maxWidth);
        int height =
            _r.Next(
                (int)Math.Round(((100 - _maxAspectRatioDeviationPercentage) * width) / (double)100),
                (int)Math.Round(((100 + _maxAspectRatioDeviationPercentage) * width) / (double)100));

        ImageInfo s = new ImageInfo(width, height);

        return s;
    }

 /// <summary>
 /// Function returns an img tag for a given Photo view model
 /// </summary>
 /// <param name="html">html helper</param>
 /// <param name="model">photo we wish to create the img tag for</param>
 /// <returns>returns an img tag</returns>
 public static MvcHtmlString Photo(this HtmlHelper html, ImageInfo model)
 {
     StringBuilder sb = new StringBuilder();
         if (model != null)
         {
             sb.Append("<img src='" + model.Src);
             sb.Append("' width='" + model.Width);
             sb.Append("' height='" + model.Height);
             sb.Append("' alt='" + model.Alt + "' />");
         }
         return MvcHtmlString.Create(sb.ToString());
 }

 private void InitGenerator()
 {
     //Try to initialize the singleton instance with HD resolution
     try
     {
         GeneratorSingleton.Instance.Initialize(PlatformType.WINDOWS, m_imageInfo);
     }
     catch (GenericEngineErrorException)
     {//If it doesn't succeed, initialize with 640X480
         m_imageInfo = new ImageInfo(ImageResolution.Resolution640x480, Xtr3D.Net.ImageInfo.ImageFormat.RGB888);
         GeneratorSingleton.Instance.Initialize(PlatformType.WINDOWS, m_imageInfo);
     }
 }