System.Drawing.Image.FromStream(System.IO.Stream)

Here are the examples of the csharp api System.Drawing.Image.FromStream(System.IO.Stream) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

356 Examples 7

19 Source : ImageHelper.cs
with MIT License
from 499116344

public static Image BytesToImage(byte[] buffer)
        {
            return Image.FromStream(new MemoryStream(buffer));
        }

19 Source : ACBrConsultaCPF.cs
with MIT License
from ACBrNet

public Image GetCaptcha()
		{
			var request = GetClient(urlBaseReceitaFederal + paginaPrincipal);
			var response = request.GetResponse();

			string htmlResult;
			using (var reader = new StreamReader(response.GetResponseStream()))
			{
				htmlResult = reader.ReadToEnd();
			}

			if (htmlResult.Length < 1) return null;

			var imgBase64 = htmlResult.GetStrBetween("data:image/png;base64,", "\">");

			Guard.Against<ACBrCaptchaException>(imgBase64.IsEmpty(), "Erro ao carregar captcha");

			using (var ms = new MemoryStream(Convert.FromBase64String(imgBase64)))
			{
				return Image.FromStream(ms);
			}
		}

19 Source : AeroEpubSchemeHandlerFactory.cs
with MIT License
from Aeroblast

public IResourceHandler Create(IBrowser browser, IFrame frame, string schemeName, IRequest request)
        {
            var uri = new Uri(request.Url);
            Log.log(request.Url);
            var route = uri.AbsolutePath.Split('/')[1];
            switch (route)
            {
                case "book":
                    {
                        if (uri.Query.Contains("footnote"))
                        {
                            return ResourceHandler.FromString("");
                        }
                        var epubItemPath = uri.AbsolutePath.Substring("/book/".Length);
                        if (epubItemPath[0] == '/') epubItemPath = epubItemPath.Substring(1);
                        Item i = Program.epub.Gereplacedem(epubItemPath);
                        if (i != null)
                        {
                            if (i.mediaType == "application/xhtml+xml")
                            {
                                string content = (i.GetFile() as TextEpubFileEntry).text;
                                content = HtmlHack.Hack(content);
                                return ResourceHandler.FromString(content);
                            }
                            if (i.mediaType == "text/css")
                            {
                                //html里的其实也应该处理……
                                string content = (i.GetFile() as TextEpubFileEntry).text;
                                content = CssHack.Hack(content);
                                return ResourceHandler.FromString(content, null, true, i.mediaType);
                            }
                            if (i.mediaType.StartsWith("image"))
                            {
                                //Image warm color process
                                if (uri.Query.Contains("warm"))
                                {
                                    switch (i.mediaType)
                                    {
                                        case "image/heic":
                                        case "image/webp":
                                            byte[] imageData = i.GetFile().GetBytes();
                                            var decoded = ImageHack.TryDecode(imageData);
                                            if (decoded != null)
                                            {
                                                return ResourceHandler.FromByteArray(ImageHack.Warmer(decoded), "image/bmp");
                                            }
                                            else//local decoder not found 
                                            {
                                                return ResourceHandler.FromByteArray(imageData, i.mediaType);
                                            }
                                        default:
                                            return ResourceHandler.FromByteArray(ImageHack.Warmer(i.GetFile().GetBytes()), "image/bmp");
                                    }
                                }
                                //do not return image but  a html page 
                                if (uri.Query.Contains("page"))
                                {
                                    if (imagePageSizeAttribute == null)
                                    {
                                        if (Program.epub.spine.pageProgressionDirection == "rtl")
                                        { imagePageSizeAttribute = "height=\"100%\""; }
                                        else
                                        { imagePageSizeAttribute = "width=\"100%\""; }
                                    }
                                    return ResourceHandler.FromString($"<html><head><link href=\"aeroepub://viewer/viewer-inject.css\" rel=\"stylesheet\" type=\"text/css\"/></head><body><img {imagePageSizeAttribute} src={("aeroepub://book" + uri.AbsolutePath)}><script src=\"aeroepub://viewer/viewer-inject.js\"></script></body></html>");
                                }
                                //normally return image data. Decode use system decoder for some format
                                switch (i.mediaType)
                                {
                                    case "image/heic":
                                        byte[] imageData = i.GetFile().GetBytes();
                                        var decoded = ImageHack.TryDecode(imageData);
                                        if (decoded != null)
                                        {
                                            return ResourceHandler.FromByteArray(decoded, "image/bmp");
                                        }
                                        else//local decoder not found 
                                        {
                                            return ResourceHandler.FromByteArray(imageData, i.mediaType);
                                        }
                                    default:
                                        return ResourceHandler.FromByteArray(i.GetFile().GetBytes(), i.mediaType);

                                }

                            }
                            return ResourceHandler.FromByteArray(i.GetFile().GetBytes(), i.mediaType);

                        }
                        else
                        {
                            Log.log("[Error]Cannot get " + uri);
                        }

                    }
                    break;
                case "viewer":
                    {
                        var filename = uri.AbsolutePath.Substring("/viewer/".Length).Replace("/", ".");
                        Stream fs = replacedembly.GetManifestResourceStream("AeroEpubViewer.Res." + filename);
                        string mime = Util.GetMimeType(filename);
                        if (mime != null)
                            return ResourceHandler.FromStream(fs, mime);
                        return ResourceHandler.FromStream(fs);
                    } //break;
                case "app":
                    {
                        string[] args = uri.AbsolutePath.Substring("/app/".Length).Split('/');
                        switch (args[0])
                        {
                            case "pos":
                                ResizeManage.SetPara(args);
                                return ResourceHandler.FromString("OK");
                            case "bookfontsize":
                                UserSettings.bookFontSize = int.Parse(args[1]);
                                EpubViewer.chromium.LoadingStateChanged += EpubViewer.SendDataWhenLoad;
                                EpubViewer.chromium.Reload(true);
                                return ResourceHandler.FromString("OK");
                            case "screentest":
                                CssHack.SetScreenTest(args);
                                return ResourceHandler.FromString("OK");
                            case "inspector":
                                EpubViewer.chromium.ShowDevTools();
                                return ResourceHandler.FromString("OK");
                            case "theme":
                                UserSettings.theme = args[1];
                                return ResourceHandler.FromString("OK");
                            case "ImageQuickView":
                                return ResourceHandler.FromString(SpecialPageService.ImageQuickView());
                            case "BookInfo":
                                return ResourceHandler.FromString(SpecialPageService.BookInfo());
                            case "StartSearch":
                                {
                                    var t = uri.AbsolutePath.Substring("/app/".Length);
                                    int i = t.IndexOf('/');
                                    var word = Uri.UnescapeDataString(t.Substring(i + 1));
                                    SearchService.Start(word);
                                    Log.log(word);
                                    return ResourceHandler.FromString("OK");
                                }
                            case "CheckSearchResult":
                                return ResourceHandler.FromString(SearchService.GetResult(int.Parse(args[1])));
                            case "CopyImage":
                                {
                                    string path = uri.AbsolutePath.Substring("/app/CopyImage/".Length);
                                    var f = Program.epub.GetFile(path);
                                    using (var stm = new MemoryStream(f.GetBytes()))
                                    using (var img = System.Drawing.Image.FromStream(stm))
                                        System.Windows.Forms.Clipboard.SetImage(img);
                                }
                                return ResourceHandler.FromString("OK");
                            case "UserBookCss":
                                return ResourceHandler.FromString(UserSettings.userBookCssContent, null, true, "text/css");
                            case "UserBookCssRtl":
                                return ResourceHandler.FromString(UserSettings.userBookCssContent_rtl, null, true, "text/css");
                            case "UserBookCssLtr":
                                return ResourceHandler.FromString(UserSettings.userBookCssContent_ltr, null, true, "text/css");
                            case "External":
                                System.Diagnostics.Process.Start("explorer.exe", Uri.UnescapeDataString(args[1]));
                                return ResourceHandler.FromString("OK");
                        }


                    }
                    break;


            }
            return null;
        }

19 Source : utils.cs
with GNU General Public License v3.0
from Aeroblast

public static (int, int) GetImageSize(byte[] data)
        {
            using (var img = Image.FromStream(new MemoryStream(data)))
            {
                return (img.Width, img.Height);
            }
        }

19 Source : LayoutDescriptionEx.cs
with GNU General Public License v3.0
from aglab2

public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            string text = (string)reader.Value;
            if (string.IsNullOrWhiteSpace(text))
            {
                return Resource.gold_star;
            }
            return Image.FromStream(new MemoryStream(Convert.FromBase64String(text)));
        }

19 Source : ImageCompressEngine.cs
with GNU General Public License v3.0
from aiportal

public static byte[] GrayScaleImage(byte[] bsImage, ImageFormat format)
		{
			Image newImage;
			using (MemoryStream msImage = new MemoryStream(bsImage))
			{
				var srcImage = Image.FromStream(msImage);
				newImage = GrayScaleImage(srcImage);
				//newImage = new ImageColorsConverter().SaveImageWithNewColorTable(srcImage);
				srcImage.Dispose();
			}
			byte[] bsData;
			using (MemoryStream msData = new MemoryStream())
			{
				newImage.Save(msData, format);
				bsData = msData.ToArray();
				newImage.Dispose();
			}
			return bsData;
		}

19 Source : ImageCompressEngine.cs
with GNU General Public License v3.0
from aiportal

public static byte[] ShortColorImage(byte[] bsImage, ImageFormat format)
		{
			Image newImage;
			using (MemoryStream msImage = new MemoryStream(bsImage))
			{
				var srcImage = Image.FromStream(msImage);
				newImage = ShortColorImage(srcImage);
				srcImage.Dispose();
			}
			byte[] bsData;
			using (MemoryStream msData = new MemoryStream())
			{
				newImage.Save(msData, format);
				bsData = msData.ToArray();
				newImage.Dispose();
			}
			return bsData;
		}

19 Source : ImageCompressor.cs
with GNU General Public License v3.0
from aiportal

private Image Deserialize(byte[] bsImage)
		{
			using (MemoryStream ms = new MemoryStream(bsImage))
			{
				return Image.FromStream(ms);
			}
		}

19 Source : CompressStorage.cs
with GNU General Public License v3.0
from aiportal

private void CompressImageData(Snapshot sshot)
		{
			Debug.replacedert(sshot.ImageData != null && sshot.ImageData.Length > 0);
			Debug.replacedert(sshot.BackgroundId == null);
			try
			{
				Image img = null;
				using (MemoryStream ms = new MemoryStream(sshot.ImageData))
					img = Image.FromStream(ms);
				Debug.replacedert(img.PixelFormat != PixelFormat.Format8bppIndexed);

				if (_backgroundImage == null)
				{
					_backgroundId = sshot.SnapshotId;
					_backgroundImage = img;
				}
				else
				{
					Debug.replacedert(_backgroundImage != null && _backgroundImage != img);
					Debug.replacedert(_backgroundImage.PixelFormat == img.PixelFormat);

					Rectangle rc = CompareImageDifference(_backgroundImage, img);
					if (rc.Width * rc.Height * 100 / img.Width * img.Height > 80)
					{
						// change background.
						_backgroundId = sshot.SnapshotId;
						_backgroundImage = img;
					}
					else
					{
						// clip
						Bitmap bmp = new Bitmap(rc.Width, rc.Height);
						using (Graphics g = Graphics.FromImage(bmp))
						{
							g.DrawImage(img, 0, 0, rc, GraphicsUnit.Pixel);
						}
						sshot.BackgroundId = _backgroundId;
						sshot.WindowRect = rc;
						using (MemoryStream ms = new MemoryStream())
						{
							bmp.Save(ms, ImageFormat.Png);
							sshot.ImageData = ms.ToArray();
						}
					}
				}
			}
			catch (Exception ex) { TraceLogger.Instance.WriteException(ex); throw; }
		}

19 Source : ImageCompressor.cs
with GNU General Public License v3.0
from aiportal

public void CompressSnapshot(bfbd.UltraRecord.Core.Snapshot sshot, bool isGrayScale)
		{
			Debug.replacedert(sshot.ImageData != null && sshot.ImageData.Length > 0);

			using (MemoryStream ms = new MemoryStream(sshot.ImageData))
			{
				var img = Image.FromStream(ms);
				var bmp = isGrayScale ? ImageCompressEngine.GrayScaleBitmap(img) : ImageCompressEngine.ColorValueBitmap(img);
				img.Dispose();

				bool isBackground;
				byte[] bsData = CompressImageData(sshot.SnapshotId, bmp, out isBackground);

				Debug.replacedert(sshot.ScreenWidth == bmp.Width && sshot.ScreenHeight == bmp.Height);
				sshot.ScreenWidth = bmp.Width;
				sshot.ScreenHeight = bmp.Height;
				sshot.IsGrayScale = isGrayScale;
				sshot.ImageData = bsData;
				if (!isBackground)
					sshot.BackgroundId = _background.SnapshotId;

				bmp.Dispose();
			}
		}

19 Source : _CompressEngine.cs
with GNU General Public License v3.0
from aiportal

private Image LoadImage(SnapImage sshot)
		{
			byte[] bsImage = null;
			string path = Path.Combine(DataPath, sshot.SessionId + ".rdt");
			if (File.Exists(path))
			{
				using (FileStream fs = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
				using (BinaryReader br = new BinaryReader(fs))
				{
					br.BaseStream.Seek(sshot.ImagePos, SeekOrigin.Begin);
					bsImage = br.ReadBytes(sshot.ImageLength);
				}
			}

			Image img = null;
			if (bsImage != null && bsImage.Length > 0)
			{
				using (MemoryStream ms = new MemoryStream(bsImage))
					img = Image.FromStream(ms);
			}
			return img;
		}

19 Source : TestDownloader.cs
with MIT License
from AkiniKites

private byte[] ApplyText(byte[] img, string modelName)
        {
            using (var ms = new MemoryStream(img))
            {
                var bmp = Image.FromStream(ms);
                var g = Graphics.FromImage(bmp);

                g.SmoothingMode = SmoothingMode.AntiAlias;
                g.InterpolationMode = InterpolationMode.HighQualityBicubic;
                g.PixelOffsetMode = PixelOffsetMode.HighQuality;

                var fSize = bmp.Height / 30;
                var f = GetAdjustedFont(g, modelName, new Font("Arial", fSize), fSize);
                var textPosition = new Point(bmp.Height / 30, (bmp.Height / 30) * 29);
                var size = g.MeasureString(modelName, f);
                var rect = new RectangleF(textPosition.X, textPosition.Y, size.Width, size.Height);
                g.FillRectangle(Brushes.Black, rect);
                g.DrawString(modelName, f, Brushes.LightGray, textPosition);

                g.Flush();

                using (var msOut = new MemoryStream())
                {
                    bmp.Save(msOut, System.Drawing.Imaging.ImageFormat.Jpeg);
                    return msOut.ToArray();
                }
            }
        }

19 Source : HttpServer.cs
with MIT License
from AlexGyver

private void ServeResourceImage(HttpListenerResponse response, string name) {
      name = "OpenHardwareMonitor.Resources." + name;

      string[] names =
        replacedembly.GetExecutingreplacedembly().GetManifestResourceNames();
      for (int i = 0; i < names.Length; i++) {
        if (names[i].Replace('\\', '.') == name) {
          using (Stream stream = replacedembly.GetExecutingreplacedembly().
            GetManifestResourceStream(names[i])) {

            Image image = Image.FromStream(stream);
            response.ContentType = "image/png";
            try {
              Stream output = response.OutputStream;
              using (MemoryStream ms = new MemoryStream()) {
                image.Save(ms, ImageFormat.Png);
                ms.WriteTo(output);
              }
              output.Close();
            } catch (HttpListenerException) {              
            }
            image.Dispose();
            response.Close();
            return;
          }
        }
      }

      response.StatusCode = 404;
      response.Close();
    }

19 Source : EmbeddedResources.cs
with MIT License
from AlexGyver

public static Image GetImage(string name) {
      name = "OpenHardwareMonitor.Resources." + name;

      string[] names = 
        replacedembly.GetExecutingreplacedembly().GetManifestResourceNames();
      for (int i = 0; i < names.Length; i++) {
        if (names[i].Replace('\\', '.') == name) {
          using (Stream stream = replacedembly.GetExecutingreplacedembly().
            GetManifestResourceStream(names[i])) {

            // "You must keep the stream open for the lifetime of the Image."
            Image image = Image.FromStream(stream);

            // so we just create a copy of the image 
            Bitmap bitmap = new Bitmap(image);

            // and dispose it right here
            image.Dispose();

            return bitmap;
          }
        }
      } 

      return new Bitmap(1, 1);    
    }

19 Source : GraphicsRenderContext.cs
with MIT License
from AlexGyver

private Image GetImage(OxyImage source)
        {
            if (source == null)
            {
                return null;
            }

            if (!this.imagesInUse.Contains(source))
            {
                this.imagesInUse.Add(source);
            }

            Image src;
            if (this.imageCache.TryGetValue(source, out src))
            {
                return src;
            }

            if (source != null)
            {
                Image btm;
                using (var ms = new MemoryStream(source.GetData()))
                {
                    btm = Image.FromStream(ms);
                }

                this.imageCache.Add(source, btm);
                return btm;
            }

            return null;
        }

19 Source : Export.cs
with MIT License
from alfarok

public static void ToPng(UserControl control)
        {
            RenderTargetBitmap rtb = new RenderTargetBitmap((int)control.ActualWidth, (int)control.ActualHeight, 96, 96, PixelFormats.Pbgra32);
            rtb.Render(control);

            PngBitmapEncoder png = new PngBitmapEncoder();
            png.Frames.Add(BitmapFrame.Create(rtb));
            MemoryStream stream = new MemoryStream();
            png.Save(stream);
            var image = System.Drawing.Image.FromStream(stream);

            SaveFileDialog dialog = new SaveFileDialog();
            dialog.FileName = "NodeModelChart"; // Default file name
            dialog.DefaultExt = ".png"; // Default file extension
            dialog.Filter = "Image files (*.png) | *.png"; // Filter files by extension

            // Show save file dialog box
            Nullable<bool> result = dialog.ShowDialog();

            // Process save file dialog box results
            if (result == true)
            {
                // Save doreplacedent
                string filename = dialog.FileName;
                image.Save(filename, ImageFormat.Png);
            }
        }

19 Source : ImageResizer.cs
with MIT License
from AlturosDestinations

private Image Byte2Image(byte[] imageData)
        {
            using (var memoryStream = new MemoryStream(imageData))
            {
                return Image.FromStream(memoryStream);
            }
        }

19 Source : FileIconMapper.cs
with Apache License 2.0
from AmpScm

void EnsureSpecialImages()
        {
            if ((_lvUp != 0))
                return;

            Image img = Bitmap.FromStream(typeof(FileIconMapper).replacedembly.GetManifestResourceStream(
                typeof(FileIconMapper).Namespace + ".UpDnListView.png"));

            int count = img.Width / 16;
            _imageList.Images.AddStrip(img);

            _lvUp = _imageList.Images.Count - count + 1;
        }

19 Source : CSharpClassesTab.cs
with MIT License
from AndresTraks

private void LoadIcon(string imageName)
        {
            Stream iconStream = replacedembly.GetExecutingreplacedembly().GetManifestResourceStream($"DotNetWrapperGen.Images.{imageName}.png");
            Image icon = Image.FromStream(iconStream);
            imageList.Images.Add(imageName, icon);
        }

19 Source : Database.cs
with GNU General Public License v3.0
from andysal

private System.Drawing.Image byteArrayToImage(byte[] byteArrayIn, bool stripOleHeader)
        {
            int strippedImageLength = byteArrayIn.Length - (stripOleHeader ? 78 : 0);
            byte[] strippedImageData = new byte[strippedImageLength];
            Array.Copy(byteArrayIn, (stripOleHeader ? 78 : 0), strippedImageData, 0, strippedImageLength);
            var ms = new MemoryStream(strippedImageData);
            return System.Drawing.Image.FromStream(ms);
        }

19 Source : CategoryRepository.cs
with GNU General Public License v3.0
from andysal

private System.Drawing.Image byteArrayToImage(byte[] byteArrayIn, bool stripOleHeader)
        {
            int strippedImageLength = byteArrayIn.Length - (stripOleHeader ? 78 : 0);
            byte[] strippedImageData = new byte[strippedImageLength];
            Array.Copy(byteArrayIn, (stripOleHeader ? 78 : 0), strippedImageData, 0, strippedImageLength);
            MemoryStream ms = new MemoryStream(strippedImageData);
            return System.Drawing.Image.FromStream(ms);
        }

19 Source : ResourceImage.cs
with GNU General Public License v3.0
from anotak

protected override void LocalLoadImage()
		{
			Stream bitmapdata;

			lock(this)
			{
				// No failure checking here. I anything fails here, it is not the user's fault,
				// because the resources this loads are in the replacedembly.
				
				// Get resource from memory
				bitmapdata = replacedembly.GetManifestResourceStream(resourcename);
				if(bitmap != null) bitmap.Dispose();
				bitmap = (Bitmap)Image.FromStream(bitmapdata);
				bitmapdata.Dispose();
				
				// Preplaced on to base
				base.LocalLoadImage();
			}
		}

19 Source : UserAvatar.cs
with MIT License
from araditc

public void Publish(Stream stream) {
			stream.ThrowIfNull("stream");
			using (Image image = Image.FromStream(stream)) {
				string mimeType = GetMimeType(image);
				int width = image.Width;
				int height = image.Height;
				long size = 0;
				string hash = String.Empty, base64Data = String.Empty;
				using (var ms = new MemoryStream()) {
					image.Save(ms, image.RawFormat);
					size = ms.Length;
					// Calculate the SHA-1 hash of the image data.
					byte[] data = ms.ToArray();
					hash = Hash(data);
					// Convert the binary data into a BASE64-string.
					base64Data = Convert.ToBase64String(data);
				}
				// Publish the image- and meta data.
				pep.Publish("urn:xmpp:avatar:data", hash,
					Xml.Element("data", "urn:xmpp:avatar:data").Text(base64Data));
				pep.Publish("urn:xmpp:avatar:metadata", hash,
					Xml.Element("metadata", "urn:xmpp:avatar:metadata").Child(
					Xml.Element("info")
						.Attr("bytes", size.ToString())
						.Attr("height", height.ToString())
						.Attr("width", width.ToString())
						.Attr("id", hash)
						.Attr("type", mimeType))
				);
			}
		}

19 Source : UserAvatar.cs
with MIT License
from araditc

Image RequestImage(Jid jid, string hash) {
			jid.ThrowIfNull("jid");
			hash.ThrowIfNull("hash");
			XmlElement item = pep.RetrieveItem(jid, "urn:xmpp:avatar:data", hash);
			if (item["data"] == null || item["data"].NamespaceURI != "urn:xmpp:avatar:data")
				throw new XmppException("Erroneous avatar data: " + item);
			string b64 = item["data"].InnerText;
			// Try to decode the base64-string and create an Image instance from the
			// decoded binary data.
			try {
				byte[] data = Convert.FromBase64String(b64);
				using (var ms = new MemoryStream(data)) {
					return Image.FromStream(ms);
				}
			} catch (Exception e) {
				throw new XmppException("Invalid image data.", e);
			}
		}

19 Source : ResourceReader.cs
with GNU General Public License v3.0
from armandoalonso

public string GetResourceAsBase64(string name)
        {
            if (_resourceCache.ContainsKey(name))
            {
                return _resourceCache[name];
            }

            using (var stream = _currentreplacedmbley.GetManifestResourceStream(name))
            {
                var img = Image.FromStream(stream ?? throw new InvalidOperationException());
                var base64 = ImageHelper.Insatnce.ImageToBase64(img);

                _resourceCache.Add(name, base64);
                return base64;
            }

            throw new InvalidOperationException("Failed to read base 64 icon");
        }

19 Source : ImageHelper.cs
with GNU General Public License v3.0
from armandoalonso

public Image Base64ToImage(string base64)
        {
            var img = Image.FromStream(new MemoryStream(Convert.FromBase64String(base64)));
            return img;
        }

19 Source : Utilities.cs
with MIT License
from arsium

public static Image BytesToImage(byte[] bytes)
        {
            using (MemoryStream mStream = new MemoryStream(bytes))
            {
                return Image.FromStream(mStream);
            }
        }

19 Source : HttpHandler.cs
with MIT License
from Ashesh3

public Image GetCaptchaImageraw()
        {
            Logger.Trace("Starting loading captcha image...");

            if (!GetRecaptcha(3, out var _siteKey, out _captchaGid, out var isRecaptcha))
            {
                Logger.Warn("Cannot get captcha GID...");
                return null;
            }

            //download and return captcha image
            _client.BaseUrl = new Uri($"{Defaults.Web.STEAM_RENDER_CAPTCHA_ADDRESS}?gid={_captchaGid}");
            var captchaResponse = _client.DownloadData(_request);
            using (var ms = new MemoryStream(captchaResponse))
            {
                return Image.FromStream(ms);
            }
        }

19 Source : HttpHandler.cs
with MIT License
from Ashesh3

public string GetBase64FromImage(byte[] captcha)
        {
            using (var ms = new MemoryStream(captcha))
            {
                using (var image = Image.FromStream(ms))
                {
                    using (var m = new MemoryStream())
                    {
                        image.Save(m, image.RawFormat);
                        var imageBytes = m.ToArray();

                        return Convert.ToBase64String(imageBytes);
                    }
                }
            }
        }

19 Source : GraphicsFactory.cs
with GNU General Public License v3.0
from AtomCrafty

public override YukaGraphics FromBinary(Stream s) {
			byte[] colorData = null, alphaData = null, metaData = null;
			long offset = s.Position;

			BinaryReader br = new BinaryReader(s, Encoding.ASCII, true /* don't close the stream! */);
			s.Seek(0x28, SeekOrigin.Current);
			int coloroffset = br.ReadInt32();
			int colorlength = br.ReadInt32();
			int alphaoffset = br.ReadInt32();
			int alphalength = br.ReadInt32();
			int metaoffset = br.ReadInt32();
			int metalength = br.ReadInt32();

			if(coloroffset != 0) {
				s.Seek(offset + coloroffset, SeekOrigin.Begin);
				colorData = br.ReadBytes(colorlength);
				// PNG header hack
				colorData[1] = (byte)'P';
				colorData[3] = (byte)'G';
			}
			else {
				if(FlagCollection.current.Has('v')) {
					Console.WriteLine("Warning: missing color layer");
				}
				// throw new Exception("No color layer found");
			}
			if(alphaoffset != 0) {
				s.Seek(offset + alphaoffset, SeekOrigin.Begin);
				alphaData = br.ReadBytes(alphalength);
				// PNG header hack
				alphaData[1] = (byte)'P';
				alphaData[3] = (byte)'G';
			}
			if(metaoffset != 0) {
				s.Seek(offset + metaoffset, SeekOrigin.Begin);
				metaData = br.ReadBytes(metalength);
			}

			br.Close();

			Bitmap colorLayer = colorData != null ? (Image.FromStream(new MemoryStream(colorData)) as Bitmap) : null;

			if(alphaData != null) {
				Bitmap alphaLayer = Image.FromStream(new MemoryStream(alphaData)) as Bitmap;

				Rectangle rect = new Rectangle(0, 0, alphaLayer.Width, alphaLayer.Height);

				colorLayer = colorLayer != null ? colorLayer.Clone(rect, PixelFormat.Format32bppArgb) : new Bitmap(alphaLayer.Width, alphaLayer.Height, PixelFormat.Format32bppArgb);

				BitmapData colorBits = colorLayer.LockBits(rect, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
				BitmapData alphaBits = alphaLayer.LockBits(rect, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);

				int colorBytes = Math.Abs(colorBits.Stride) * colorLayer.Height;
				int alphaBytes = Math.Abs(alphaBits.Stride) * alphaLayer.Height;

				byte[] colorValues = new byte[colorBytes];
				byte[] alphaValues = new byte[alphaBytes];

				Marshal.Copy(colorBits.Scan0, colorValues, 0, colorBytes);
				Marshal.Copy(alphaBits.Scan0, alphaValues, 0, alphaBytes);

				for(int counter = 0; counter < colorValues.Length; counter += 4) {
					// set the alpha channel of colorValue to the inverted red channel of alphaValues
					colorValues[counter + 3] = (byte)(255 - alphaValues[counter]);
				}

				Marshal.Copy(colorValues, 0, colorBits.Scan0, colorBytes);
				Marshal.Copy(alphaValues, 0, alphaBits.Scan0, alphaBytes);

				colorLayer.UnlockBits(colorBits);
				alphaLayer.UnlockBits(alphaBits);
			}

			return new YukaGraphics(colorLayer, metaData);
		}

19 Source : FormBackground.cs
with MIT License
from AutoItConsulting

private bool RefreshBackgroundImage(bool forceUpdate = false)
        {
            // Get the current user's wallpaper
            string wallpaperPath = GetCurrentUserWallpaperPath();

            // If wallpaper is blank or doesn't exist then quit as we can't do anything useful
            if (string.IsNullOrEmpty(wallpaperPath) || !File.Exists(wallpaperPath))
            {
                return false;
            }

            // Get Current filename and filetime and check if we need to update the image
            DateTime modifiedTime = File.GetLastWriteTime(wallpaperPath);
            if (!forceUpdate && _wallpaperPath == wallpaperPath && _wallpaperLastModified.CompareTo(modifiedTime) == 0)
            {
                return false;
            }

            // Save new values
            _wallpaperPath = wallpaperPath;
            _wallpaperLastModified = modifiedTime;

            // Set the form bitmap and force display to primary monitor
            StartPosition = FormStartPosition.Manual;
            Location = Screen.PrimaryScreen.Bounds.Location;

            WindowState = FormWindowState.Maximized;

            // Don't use Maximized as it goes over the task bar which can be ugly
            //Size = new Size(Screen.GetWorkingArea(this).Width, Screen.GetWorkingArea(this).Height);

            try
            {
                using (var fileStream = new FileStream(wallpaperPath, FileMode.Open, FileAccess.Read))
                {
                    pictureBoxBackground.BackgroundImage = Image.FromStream(fileStream);
                    pictureBoxBackground.Invalidate();
                }
            }
            catch (Exception)
            {
                return false;
            }

            return true;
        }

19 Source : MapRender.cs
with MIT License
from AyrA

public static void Init(int MaxWidth = DEFAULT_WIDTH, int MaxHeight = DEFAULT_HEIGHT)
        {
            if (BaseImage == null)
            {
                Log.Write("Map: Initializing base image W={0},H={1}", MaxWidth, MaxHeight);
                //Load base image and provide initially scaled version
                using (var MS = new MemoryStream(Tools.GetMap()))
                {
                    BaseImage = Image.FromStream(MS);
                }
                SetBaseSize(MaxWidth, MaxHeight);
            }
        }

19 Source : frmManager.cs
with MIT License
from AyrA

private void RenderCloudEntry(MapView MapEntry)
        {
            var T = new Thread(delegate ()
            {
                byte[] ImageData;
                try
                {
                    ImageData = SMRAPI.API.Preview(MapEntry.Map.hidden_id);
                    if (ImageData == null || ImageData.Length == 0)
                    {
                        throw new InvalidDataException("API returned an empty image");
                    }
                }
                catch (Exception ex)
                {
                    Tools.E("Error getting preview image.\r\n" + ex.Message, "Cloud Save Preview", this);
                    return;
                }
                Invoke((MethodInvoker)delegate
                {
                    using (var MS = new MemoryStream(ImageData, false))
                    {
                        try
                        {
                            using (var IMG = Image.FromStream(MS))
                            {
                                PreviewImage(IMG, MapEntry.Map.name);
                            }
                        }
                        catch (Exception ex)
                        {
                            Tools.E("Error getting preview image.\r\n" + ex.Message, "Cloud Save Preview", this);
                            return;
                        }
                    }
                });
            });
            T.IsBackground = true;
            T.Start();
        }

19 Source : NetGraphics.cs
with MIT License
from azist

public IPALImage CreateImage(Stream stream)
    {
      var nimg = System.Drawing.Image.FromStream(stream);
      return new NetImage(nimg);
    }

19 Source : NetGraphics.cs
with MIT License
from azist

public IPALImage CreateImage(byte[] data)
    {
      using(var ms = new MemoryStream(data))
      {
       var nimg = System.Drawing.Image.FromStream(ms);
       return new NetImage(nimg);
      }
    }

19 Source : ImagesForm.cs
with MIT License
from azist

private Bitmap loadImage(string path, IDataObject data)
    {
      Bitmap tempBmp = null;
      MemoryStream stream = null;
      if (!string.IsNullOrWhiteSpace(path))
      {
        tempBmp = new Bitmap(path);
      }
      else if (data.GetDataPresent(DataFormats.FileDrop))
      {
        var files = (string[])data.GetData(DataFormats.FileDrop);
        if (files.Any())
          tempBmp = new Bitmap(files[0]);
      }
      else
      {
        var html = (string)data.GetData(DataFormats.Html);
        var anchor = "src=\"";
        int idx1 = html.IndexOf(anchor) + anchor.Length;
        int idx2 = html.IndexOf("\"", idx1);
        var url = html.Substring(idx1, idx2 - idx1);

        if (url.StartsWith("http"))
        {
          using (var client = new WebClient())
          {
            var bytes = client.DownloadData(url);
            stream = new MemoryStream(bytes);
            tempBmp = new Bitmap(stream);
          }
        }
        else if (url.StartsWith("data:image"))
        {
          anchor = "base64,";
          idx1 = url.IndexOf(anchor) + anchor.Length;
          var base64Data = url.Substring(idx1);
          var bytes = Convert.FromBase64String(base64Data);
          stream = new MemoryStream(bytes);
          tempBmp = new Bitmap(stream);
        }
      }

      if (tempBmp == null)
      {
        throw new Exception("Cannot load image");
      }

      var ms = new MemoryStream();
      tempBmp.Save(ms, ImageFormat.Png);
      tempBmp.Dispose();
      if (stream != null) stream.Dispose();
      var result = new Bitmap(ms); // OMG
      m_ImgInitial.Image = Image.FromStream(ms);

      return result;
    }

19 Source : ImageTests.cs
with MIT License
from azist

[Run]
    public void Image_SaveToStream()
    {
      using (var ms = new MemoryStream())
      using (var imgSrc = Image.FromFile(TEST_PNG_FILENAME))
      {
        imgSrc.Save(ms, new PngImageFormat(16));

        using (var imgTrg = Image.FromStream(ms))
        {
          averTestImage(imgTrg);
        }
      }
    }

19 Source : ImageTests.cs
with MIT License
from azist

[Run]
    public void Image_FromStream()
    {
      using (var file = File.OpenRead(TEST_PNG_FILENAME))
      using (var img = Image.FromStream(file))
      {
        averTestImage(img);
      }
    }

19 Source : mcbbs.cs
with MIT License
from baibao132

public ImageBrush get_image(string url)
        {
            var image = new ImageBrush();
            try
            {
                System.Net.WebRequest webreq = System.Net.WebRequest.Create(url);
                System.Net.WebResponse webres = webreq.GetResponse();
                System.IO.Stream stream = webres.GetResponseStream();
                System.Drawing.Image img1 = System.Drawing.Image.FromStream(stream);
                System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(img1);
                IntPtr hBitmap = bmp.GetHbitmap();
                System.Windows.Media.ImageSource WpfBitmap = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(hBitmap, IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
                image.ImageSource = WpfBitmap;
                image.Stretch = Stretch.Uniform;
                stream.Dispose();
            }
            catch (Exception e)
            {
                return null;
            }
            return image;
        }

19 Source : 图印Tabpage.cs
with Apache License 2.0
from becomequantum

private Bitmap 加载图片文件(string 图片文件名) { //这样加载图片后,原来的图片文件不会被占用锁定
            try {
                FileStream 文件流 = new FileStream(图片文件名, FileMode.Open, FileAccess.Read);
                Bitmap tmpImg = (Bitmap)Image.FromStream(文件流);
                文件流.Close();
                文件流.Dispose();
                return tmpImg;
            }
            catch (Exception exp) {
                MessageBox.Show(exp.Message);
                return null;
            }
        }

19 Source : Form1.cs
with Apache License 2.0
from becomequantum

private void ReceiveUdpData()
        {
            int 收包计数 = 54; //数据是收到用来存储图片的buffer中,从第54开始,前面已经存了文件头.
            bool 图片发送请求已发送 = false;
            byte[] tempbuff = new byte[1024]; //临时buffer,用来收空UDP Buffer中的数据
            while (接收数据) //不限帧率连续接受图像.收完一帧就立即请求发下一帧
            {     
                
                if(图片发送请求已发送 == false)
                {

                    while (UDP_socket1.Available > 0)    //先把UDP Buffer中可能残留的数据读空
                    {
                        UDP_socket1.ReceiveFrom(tempbuff, ref remoteEP);
                    }
                    NoteFPGA();                          //向FPGA发送7字节发送图片请求
                    图片发送请求已发送 = true;           //限制每帧只发一次
                }

                if (UDP_socket1.Available > 1) //接收数据
                {
                    收包计数 += UDP_socket1.ReceiveFrom(PicRxbuff, 收包计数, UDP_socket1.Available, SocketFlags.None, ref remoteEP);
                }
                if(收包计数 >= PicRxbuffLength ) //收满了一帧图像的字节数,这里用>=是因为FPGA在最后还多发了两个字节,所以在前面也要先读空.
                {
                    try
                    {
                        Image img = Image.FromStream(new MemoryStream(PicRxbuff));//把字节数组转成内存流显示.
                        ShowBMP(pictureBox1, img);
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(ex.Message);
                    }
                    收包计数 = 54;                //一帧收完显示完后复位计数
                    图片发送请求已发送 = false;   //开启发送请求.
                   
                }
                  
            }

        }

19 Source : Form1.cs
with Apache License 2.0
from becomequantum

private void AsyncReceive(IAsyncResult ar) //异步法貌似略慢
        {
            var UDPsocket = ar.AsyncState as Socket;
            异步接收字节计数 += UDPsocket.EndReceive(ar);
            if (异步接收字节计数 < PicRxbuffLength)
            {
                 UDPsocket.BeginReceive(PicRxbuff, 异步接收字节计数, 分包大小, SocketFlags.None, new AsyncCallback(AsyncReceive), UDPsocket);                          
            }
            else
            {
                MemoryStream ms = new MemoryStream(PicRxbuff);//把字节数组转成内存流显示.
                try
                {
                    Image img = Image.FromStream(ms);
                    ShowBMP(pictureBox1, img);
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }
                收完一帧 = true;
            }     
           
            
        }

19 Source : PlatformUtils.cs
with MIT License
from BleuBleu

public static Bitmap LoadBitmapFromResource(string name)
        {
            return System.Drawing.Image.FromStream(replacedembly.GetExecutingreplacedembly().GetManifestResourceStream(name)) as System.Drawing.Bitmap;
        }

19 Source : PropertyDialog.cs
with MIT License
from BleuBleu

private void Init()
        {
            InitializeComponent();

            string suffix = DpiScaling.Dialog >= 2.0f ? "@2x" : "";

            buttonYes.Image      = Image.FromStream(replacedembly.GetExecutingreplacedembly().GetManifestResourceStream($"FamiStudio.Resources.Yes{suffix}.png"));
            buttonNo.Image       = Image.FromStream(replacedembly.GetExecutingreplacedembly().GetManifestResourceStream($"FamiStudio.Resources.No{suffix}.png"));
            buttonAdvanced.Image = Image.FromStream(replacedembly.GetExecutingreplacedembly().GetManifestResourceStream($"FamiStudio.Resources.PlusSmall{suffix}.png"));

            toolTip.SetToolTip(buttonYes, "Accept");
            toolTip.SetToolTip(buttonNo, "Cancel");
            toolTip.SetToolTip(buttonAdvanced, "Toggle Advanced Options");
        }

19 Source : TutorialDialog.cs
with MIT License
from BleuBleu

private void Init()
        {
            InitializeComponent();

            string suffix = DpiScaling.Dialog >= 2.0f ? "@2x" : "";
            buttonLeft.Image   = Image.FromStream(replacedembly.GetExecutingreplacedembly().GetManifestResourceStream($"FamiStudio.Resources.ArrowLeft{suffix}.png"));

            Width         = DpiScaling.ScaleForDialog(Width);
            Height        = DpiScaling.ScaleForDialog(Height);
            label1.Height = DpiScaling.ScaleForDialog(label1.Height);

            pictureBox1.Top    = (label1.Top + label1.Height) + 8;
            pictureBox1.Height = (int)(pictureBox1.Width / 1.7777777f); // 16:9
            pictureBox1.Width  = DpiScaling.ScaleForDialog(pictureBox1.Width);
            pictureBox1.Height = DpiScaling.ScaleForDialog(pictureBox1.Height);

            label1.ForeColor           = Theme.LightGreyFillColor2;
            checkBoxDontShow.ForeColor = Theme.LightGreyFillColor2;

            buttonLeft.Width   = DpiScaling.ScaleForDialog(buttonLeft.Width);
            buttonLeft.Height  = DpiScaling.ScaleForDialog(buttonLeft.Height);
            buttonRight.Width  = DpiScaling.ScaleForDialog(buttonRight.Width);
            buttonRight.Height = DpiScaling.ScaleForDialog(buttonRight.Height);

            buttonRight.Left  = ClientSize.Width  - buttonRight.Width  - 10;
            buttonRight.Top   = ClientSize.Height - buttonRight.Height - 10;
            buttonLeft.Left   = buttonRight.Left - buttonLeft.Width - 10;
            buttonLeft.Top    = buttonRight.Top;

            toolTip.SetToolTip(buttonRight, "Next");
            toolTip.SetToolTip(buttonLeft, "Previous");

            try
            {
                label1.Font = new Font(PlatformUtils.PrivateFontCollection.Families[0], 10.0f, FontStyle.Regular);
                checkBoxDontShow.Font = label1.Font;
            }
            catch {}

            SetPage(0);
        }

19 Source : TutorialDialog.cs
with MIT License
from BleuBleu

private void SetPage(int idx)
        {
            pageIndex = Utils.Clamp(idx, 0, TutorialMessages.Length - 1);
            pictureBox1.Image = Image.FromStream(replacedembly.GetExecutingreplacedembly().GetManifestResourceStream($"FamiStudio.Resources.{TutorialImages[pageIndex]}"));
            label1.Text = TutorialMessages[pageIndex];
            buttonLeft.Visible = pageIndex != 0;

            string suffix = DpiScaling.Dialog >= 2.0f ? "@2x" : "";
            buttonRight.Image = pageIndex == TutorialMessages.Length - 1 ?
                Image.FromStream(replacedembly.GetExecutingreplacedembly().GetManifestResourceStream($"FamiStudio.Resources.Yes{suffix}.png")) :
                Image.FromStream(replacedembly.GetExecutingreplacedembly().GetManifestResourceStream($"FamiStudio.Resources.ArrowRight{suffix}.png"));
        }

19 Source : MultiPropertyDialog.cs
with MIT License
from BleuBleu

public PropertyPage AddPropertyPage(string text, string image)
        {
            var suffix = DpiScaling.Dialog > 1.0f ? "@2x" : "";
            var stream = replacedembly.GetExecutingreplacedembly().GetManifestResourceStream($"FamiStudio.Resources.{image}{suffix}.png");
            
            if (stream == null)
                Debug.WriteLine($"Error loading bitmap {image }.");

            var bmp = stream != null ? Image.FromStream(stream) as Bitmap : null;

            if ((DpiScaling.Dialog % 1.0f) != 0.0f && bmp != null)
            {
                var newWidth  = (int)(bmp.Width  * (DpiScaling.Dialog / 2.0f));
                var newHeight = (int)(bmp.Height * (DpiScaling.Dialog / 2.0f));

                bmp = new Bitmap(bmp, newWidth, newHeight);
            }

            var page = new PropertyPage();
            page.Dock = DockStyle.Fill;
            panelProps.Controls.Add(page);

            var tab = new PropertyPageTab();
            tab.button = AddButton(text, bmp);
            tab.properties = page;

            tabs.Add(tab);

            return page;
        }

19 Source : PropertyDialog.cs
with MIT License
from BleuBleu

private void buttonAdvanced_Click(object sender, EventArgs e)
        {
            Debug.replacedert(propertyPage.HasAdvancedProperties);

            advancedPropertiesVisible = !advancedPropertiesVisible;
            propertyPage.Build(advancedPropertiesVisible);
            UpdateLayout(false);

            var iconName = advancedPropertiesVisible ? "Minus" : "Plus";
            var suffix = DpiScaling.Dialog >= 2.0f ? "@2x" : "";
            buttonAdvanced.Image = Image.FromStream(replacedembly.GetExecutingreplacedembly().GetManifestResourceStream($"FamiStudio.Resources.{iconName}Small{suffix}.png"));
        }

19 Source : RemoteForm.cs
with GNU General Public License v3.0
from boonkerz

private void Events_OnScreenshotReceived(object sender, Messages.EventArgs.Network.ScreenshotReceivedEventArgs e)
        {
            if (e.Fullscreen)
            {
                Bounds = e.Bounds;
            }

            Ratio = (float)this.drawingArea1.Width / (float)Bounds.Width;

            if (this.drawingArea1.InvokeRequired)
            {
                SetDrawingAreaHeightCallback d = new SetDrawingAreaHeightCallback(setDrawingAreaHeight);
                this.Invoke(d, new object[] { (int)((float)Bounds.Height * Ratio) });
            }
            else
            {
                setDrawingAreaHeight((int)((float)Bounds.Height * Ratio));
            }

            if (e.Nothing)
            {
                return;
            }

            if (e.SystemId == this.SystemId)
            {
                using (var stream = new MemoryStream(e.Image))
                {
                    Image image = Image.FromStream(stream);

                    if (this.drawingArea1.InvokeRequired)
                    {
                        DrawImageCallback d = new DrawImageCallback(drawImage);
                        this.Invoke(d, new object[] { image, e.Bounds });
                    }
                    else
                    {
                        drawImage(image, e.Bounds);
                    }
                    
                }
            }
        }

19 Source : Util.cs
with GNU General Public License v3.0
from bp2008

[Obsolete]
		/// <summary>
		/// This method is DANGEROUS.  The Image is not valid if the MemoryStream is closed.
		/// </summary>
		/// <param name="imageData"></param>
		/// <returns></returns>
		public static Image ImageFromBytes(byte[] imageData)
		{
			try
			{
				using (MemoryStream ms = new MemoryStream(imageData))
				{
					return Image.FromStream(ms);
				}
			}
			catch (Exception) { }
			return null;
		}

See More Examples