public MemoryStream GenerateImage(Visual vsual, int widhth, int height, ImageFormat format)
{
BitmapEncoder encoder = null;
switch (format)
{
case ImageFormat.JPG :
encoder = new JpegBitmapEncoder();
break;
case ImageFormat.PNG:
encoder = new PngBitmapEncoder();
break;
case ImageFormat.BMP:
encoder = new BmpBitmapEncoder();
break;
case ImageFormat.GIF:
encoder = new GifBitmapEncoder();
break;
case ImageFormat.TIF:
encoder = new TiffBitmapEncoder();
break;
}
if (encoder == null) return null;
RenderTargetBitmap rtb = this.RenderVisaulToBitmap(vsual, widhth, height);
MemoryStream file = new MemoryStream();
encoder.Frames.Add(BitmapFrame.Create(rtb));
encoder.Save(file);
return file;
}
public void Save(BitmapSource bmSource)
{
BitmapEncoder encoder;
switch (Path.GetExtension(_path).ToLower())
{
case ".jpg":
case ".jpeg":
encoder = new JpegBitmapEncoder();
break;
case ".gif":
encoder = new GifBitmapEncoder();
break;
case ".bmp":
encoder = new BmpBitmapEncoder();
break;
case ".tif":
case ".tiff":
encoder = new TiffBitmapEncoder();
break;
case ".png":
encoder = new PngBitmapEncoder();
break;
default:
throw new ArgumentException("Wrong path");
}
encoder.Frames.Add(BitmapFrame.Create(bmSource));
Stream stm = File.Create(_path);
encoder.Save(stm);
stm.Dispose();
}
/// custom
private static void createGif(IEnumerable <Bitmap> bitmaps, string path)
{
var gifEnc = new Media.Imaging.GifBitmapEncoder();
foreach (var bmp in bitmaps)
{
var src = Interop.Imaging.CreateBitmapSourceFromHBitmap(
bmp.GetHbitmap(),
IntPtr.Zero,
Int32Rect.Empty,
Media.Imaging.BitmapSizeOptions.FromEmptyOptions()
);
var emptyBmp = new Bitmap(bmp.Width, bmp.Height);
/*
* Graphics g = Graphics.FromImage(emptyBmp);
* g.FillRectangle(new SolidBrush(Color.White), 0, 0, bmp.Width, bmp.Height);
* g.Dispose();
*
* var emptyFrame = Interop.Imaging.CreateBitmapSourceFromHBitmap(
* emptyBmp.GetHbitmap(),
* IntPtr.Zero,
* Int32Rect.Empty,
* Media.Imaging.BitmapSizeOptions.FromEmptyOptions()
* );
* gifEnc.Frames.Add(Media.Imaging.BitmapFrame.Create(src));
*/
}
using (var fs = new FileStream(path, FileMode.Create))
{
gifEnc.Save(fs);
}
}
public void Write(BitmapSource i, Stream s)
{
BitmapEncoder encoder = null;
if (MimeType.Equals("image/jpeg"))
{
encoder = new JpegBitmapEncoder();
((JpegBitmapEncoder)encoder).QualityLevel = localSettings.Quality;
}
else if (MimeType.Equals("image/png"))
{
encoder = new PngBitmapEncoder();
}
else if (MimeType.Equals("image/gif"))
{
encoder = new GifBitmapEncoder();
encoder.Palette = new BitmapPalette(i, 256);
}
encoder.Frames.Add(BitmapFrame.Create(i));
using (MemoryStream outputStream = new MemoryStream())
{
encoder.Save(outputStream);
outputStream.WriteTo(s);
}
}
//custom
public Image CreateAnimation(Control ctl, List <Image> frames, int delay)
{
var gifEnc = new Media.Imaging.GifBitmapEncoder();
var ms = new System.IO.MemoryStream();
var codec = ImageCodecInfo.GetImageEncoders().First(i => i.MimeType == "image/tiff");
EncoderParameters encoderParameters = new EncoderParameters(2);
encoderParameters.Param[0] = new EncoderParameter(Encoder.SaveFlag, (long)EncoderValue.MultiFrame);
encoderParameters.Param[1] = new EncoderParameter(Encoder.Quality, (long)EncoderValue.CompressionLZW);
frames[0].Save(ms, codec, encoderParameters);
encoderParameters = new EncoderParameters(1);
encoderParameters.Param[0] = new EncoderParameter(Encoder.SaveFlag, (long)EncoderValue.FrameDimensionPage);
for (int i = 1; i < frames.Count; i++)
{
frames[0].SaveAdd(frames[i], encoderParameters);
}
encoderParameters.Param[0] = new EncoderParameter(Encoder.SaveFlag, (long)EncoderValue.Flush);
frames[0].SaveAdd(encoderParameters);
ms.Position = 0;
var img = Image.FromStream(ms);
Animate(ctl, img, delay, frames.Count);
return(img);
}
public void A()
{
int width = 128;
int height = width;
int stride = width / 8;
byte[] pixels = new byte[height * stride];
BitmapPalette myPalette = BitmapPalettes.WebPalette;
BitmapSource image = BitmapSource.Create(
width,
height,
96,
96,
PixelFormats.Indexed1,
myPalette,
pixels,
stride);
BitmapSource A = BitmapConverter.GetBitmapSource(Properties.Resources._1);
BitmapSource B = BitmapConverter.GetBitmapSource(Properties.Resources._2);
FileStream stream = new FileStream("new.gif", FileMode.Create);
GifBitmapEncoder encoder = new GifBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(A));
encoder.Frames.Add(BitmapFrame.Create(B));
encoder.Save(stream);
}
private static void SaveBitmap(BitmapSource bitmap, string destination)
{
BitmapEncoder encoder;
switch (Path.GetExtension(destination).ToUpperInvariant())
{
case ".BMP":
encoder = new BmpBitmapEncoder();
break;
case ".GIF":
encoder = new GifBitmapEncoder();
break;
case ".JPG":
encoder = new JpegBitmapEncoder() { QualityLevel = 100 };
break;
case ".PNG":
encoder = new PngBitmapEncoder();
break;
case ".TIF":
encoder = new TiffBitmapEncoder() { Compression = TiffCompressOption.Zip };
break;
default:
throw new NotSupportedException("Not supported output extension.");
}
encoder.Frames.Add(BitmapFrame.Create(bitmap));
encoder.Save(new FileStream(destination, FileMode.Create));
}
public static Tuple<BitmapSource, byte[]> Convert(this IEnumerable<PointFrame> cloud, int width, int height)
{
var bytes = new byte[cloud.Count() * (PixelFormats.Bgr32.BitsPerPixel / 8)];
byte[] result;
var index = 0;
foreach (var point in cloud)
{
bytes[index++] = (byte)point.B; // Blue
bytes[index++] = (byte)point.G; // Green
bytes[index++] = (byte)point.R; // Red
}
var source = BitmapSource.Create(width, height, 96, 96, PixelFormats.Rgb24, BitmapPalettes.Gray16, bytes, width * PixelFormats.Rgb24.BitsPerPixel / 8);
var encoder = new GifBitmapEncoder();
using (var stream = new MemoryStream())
{
encoder.Frames.Add(BitmapFrame.Create(source));
encoder.Save(stream);
result = stream.ToArray().Select(s => (byte)(sbyte)s).ToArray();
stream.Close();
}
return Tuple.Create(source, result);
}
public void Save(Stream stream, ImageFormat format)
{
ApplicationHandler.InvokeIfNecessary(() =>
{
swm.Imaging.BitmapEncoder encoder;
switch (format)
{
case ImageFormat.Png:
encoder = new swm.Imaging.PngBitmapEncoder();
break;
case ImageFormat.Gif:
encoder = new swm.Imaging.GifBitmapEncoder();
break;
case ImageFormat.Bitmap:
encoder = new swm.Imaging.BmpBitmapEncoder();
break;
case ImageFormat.Jpeg:
encoder = new swm.Imaging.JpegBitmapEncoder();
break;
case ImageFormat.Tiff:
encoder = new swm.Imaging.TiffBitmapEncoder();
break;
default:
throw new NotSupportedException();
}
encoder.Frames.Add(swmi.BitmapFrame.Create(Control));
encoder.Save(stream);
});
}
/// <summary>
/// Saves the full chart to a file, including technical analysis.
/// </summary>
/// <param name="filename">The file to write to.</param>
public void SaveAsImage(string filename)
{
if (string.IsNullOrEmpty(filename))
throw new ArgumentNullException();
var extension = Path.GetExtension(filename);
if (string.IsNullOrEmpty(extension))
throw new ArgumentNullException();
BitmapEncoder bitmapEncoder;
extension = extension.ToLower();
if (extension == ".png")
bitmapEncoder = new PngBitmapEncoder();
else if (extension == ".jpg" || extension == ".jpeg")
bitmapEncoder = new JpegBitmapEncoder();
else if (extension == ".gif")
bitmapEncoder = new GifBitmapEncoder();
else if (extension == ".bmp")
bitmapEncoder = new BmpBitmapEncoder();
else throw new ArgumentException("Cannot find a BitmapEncoder for this file type.");
var renderTargetBitmap = new RenderTargetBitmap((int)this.ActualWidth, (int)this.ActualHeight, 96, 96, PixelFormats.Pbgra32);
foreach (var child in LogicalTreeHelper.GetChildren(this))
{
if (child is ChartPanel)
renderTargetBitmap.Render((ChartPanel)child);
}
bitmapEncoder.Frames.Add(BitmapFrame.Create(renderTargetBitmap));
using (Stream stream = File.Create(filename))
{
bitmapEncoder.Save(stream);
}
}
static void Main()
{
#region License
RuntimeManager.Bind(ProductCode.EngineOrDesktop);
var ao = new AoInitialize();
var code = new[] { 60, 50, 40, 10 }.Cast<esriLicenseProductCode>().First(c => ao.IsProductCodeAvailable(c) == esriLicenseStatus.esriLicenseAvailable);
ao.Initialize(code);
#endregion
var grid = new Grid("ascii.txt", true);
var fileName = "GospersGliderGun.gif";
var iteration = 100;
var encoder = new GifBitmapEncoder();
for (var i = 0; i < iteration; i++)
{
Console.WriteLine($"Processing {i + 1} of {iteration}...");
var tempFileName = $@"{Path.GetTempPath()}\{Guid.NewGuid()}.png";
Resample(200 * grid, 0.1).Save(tempFileName);
encoder.Frames.Add(BitmapFrame.Create(new Uri(tempFileName)));
grid = Tick(grid);
}
using (var s = new System.IO.FileStream(fileName, FileMode.Create))
encoder.Save(s);
Process.Start(fileName);
}
public static void ToImageFile(this Visual theVisual, string fileName)
{
BitmapEncoder encoder;
switch (Path.GetExtension(fileName).ToLower())
{
case ".jpg":
case ".jpeg":
encoder = new JpegBitmapEncoder();
break;
case ".png":
encoder = new PngBitmapEncoder();
break;
case ".bmp":
encoder = new BmpBitmapEncoder();
break;
case ".gif":
encoder = new GifBitmapEncoder();
break;
case ".tiff":
encoder = new TiffBitmapEncoder();
break;
default:
throw new EncoderFallbackException("The Specified Filename is not a known image type. Supported image formats are jpeg, png, bmp, gif, and tiff.");
}
encoder.Frames.Add(BitmapFrame.Create(theVisual.ToBitmapSource()));
using (var stream = new FileStream(fileName, FileMode.Create)) encoder.Save(stream);
}
private static BitmapEncoder GetBitmapEncoder(ImageContentType imageContentType)
{
BitmapEncoder bitmapEncoder;
switch (imageContentType)
{
case ImageContentType.ImageBmpContentType:
bitmapEncoder = new BmpBitmapEncoder();
break;
case ImageContentType.ImageGifContentType:
bitmapEncoder = new GifBitmapEncoder();
break;
case ImageContentType.ImageJpegContentType:
bitmapEncoder = new JpegBitmapEncoder();
break;
case ImageContentType.ImageTiffContentType:
bitmapEncoder = new TiffBitmapEncoder();
break;
case ImageContentType.ImagePngContentType:
bitmapEncoder = new PngBitmapEncoder();
break;
default:
bitmapEncoder = new PngBitmapEncoder();
break;
}
return bitmapEncoder;
}
//This method takes in a list of imagedata found in the database, creates a new gifbitmapencoder and puts the images into the newly formed gif.
public GifBitmapEncoder Create(IEnumerable<ImageData> listOFImages, int frameRate = 2)
{
JpegBitmapDecoder decoder;
BitmapSource convertToBmp;
GifBitmapEncoder newGif = new GifBitmapEncoder();
//Run through the list of ImageData from the database
foreach (BlueMarble.Data.ImageData indImage in listOFImages)
{
//Get the image based off of the url found on the data of the image
var request = WebRequest.Create(indImage.Lowresurl);
using (var response = request.GetResponse())
using (var webstream = response.GetResponseStream())
{
decoder = new JpegBitmapDecoder(webstream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
convertToBmp = decoder.Frames[0];
//The amount of times you store the image in the in the gif, the slower it appears to transition, default for this speed is 2
for (int x = 0; x < frameRate; x++)
{
newGif.Frames.Add(BitmapFrame.Create(convertToBmp));
}
}
}
return newGif;
}
private void Button_Click(object sender, RoutedEventArgs e)
{
RenderTargetBitmap bmp = new RenderTargetBitmap((int)100, (int)100, 96, 96, PixelFormats.Pbgra32);
bmp.Render(this);
string file = @"c:\temp\test.jpg";
string Extension = System.IO.Path.GetExtension(file).ToLower();
BitmapEncoder encoder;
if (Extension == ".gif")
encoder = new GifBitmapEncoder();
else if (Extension == ".png")
encoder = new PngBitmapEncoder();
else if (Extension == ".jpg")
encoder = new JpegBitmapEncoder();
else
return;
encoder.Frames.Add(BitmapFrame.Create(bmp));
using (Stream stm = File.Create(file))
{
encoder.Save(stm);
}
}
public void Save(Stream stream, ImageFormat format)
{
swmi.BitmapEncoder encoder;
switch (format)
{
case ImageFormat.Png:
encoder = new swmi.PngBitmapEncoder();
break;
case ImageFormat.Gif:
encoder = new swmi.GifBitmapEncoder();
break;
case ImageFormat.Bitmap:
encoder = new swmi.BmpBitmapEncoder();
break;
case ImageFormat.Jpeg:
encoder = new swmi.JpegBitmapEncoder();
break;
case ImageFormat.Tiff:
encoder = new swmi.TiffBitmapEncoder();
break;
default:
throw new NotSupportedException();
}
encoder.Frames.Add(swmi.BitmapFrame.Create(FrozenControl));
encoder.Save(stream);
}
public void Animate(FinalRender renderer)
{
FileStream stream = new FileStream(@"TMP.GIF", FileMode.Create);
var encoder = new System.Windows.Media.Imaging.GifBitmapEncoder();
foreach (var f in frames)
{
encoder.Frames.Add(BitmapFrame.Create(toBitmapConvert(f)));
}
encoder.Save(stream);
stream.Close();
var test = new Jillzhang.GifUtility.GifDecoder();
test.Decode(@"TMP.GIF");
foreach (var frame in test.Frames)
{
frame.Delay = (short)((double)100 / Animatronic.FRAMES_PER_SECOND);
}
var test2 = new Jillzhang.GifUtility.GifEncoder(@"TMP.GIF");
test2.Encode(test);
//var w = new Jillzhang.GifUtility.GifHelper();
//w.WaterMark(@"TMP2.GIF", "Distributed RT - ITCS 422", Color.White, new Font(new FontFamily("Arial"), 8), 0, 0, @"TMP2.GIF");
renderer.Picture.LoadAsync(@"TMP.GIF");
}
public byte[] getGIFFromImageControl(BitmapImage imageC)
{
MemoryStream memStream = new MemoryStream();
GifBitmapEncoder encoder = new GifBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(imageC));
encoder.Save(memStream);
return memStream.GetBuffer();
}
public static bool ConvertToGif(this List<BitmapSource> bmps, string filepath)
{
FileStream stream = new FileStream(filepath, FileMode.OpenOrCreate);
GifBitmapEncoder encoder = new GifBitmapEncoder();
bmps.ForEach(i =>
{
encoder.Frames.Add(BitmapFrame.Create(i));
});
encoder.Save(stream);
return true;
}
static void bi_DownloadCompleted(object sender, EventArgs e)
{
string fullPath = System.Reflection.Assembly.GetAssembly(typeof(Microsoft.Samples.SqlServer.WordAddIn.WorkflowRibbon)).Location;
string gifPath = String.Format(@"{0}$word.odata.gif", Path.GetDirectoryName(fullPath));
using (FileStream stream = new FileStream(gifPath, FileMode.Create))
{
var encoder = new GifBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create((BitmapImage)sender));
encoder.Save(stream);
}
Globals.ThisAddIn.Application.Selection.InlineShapes.AddPicture(gifPath, false);
}
/// <summary>
/// Method exports the GraphArea to an png image.
/// </summary>
/// <param name="surface">GraphArea control</param>
/// <param name="path">Image destination path</param>
/// <param name="imgdpi">Optional image DPI parameter</param>
/// <param name="imgQuality">Optional image quality parameter (for some formats like JPEG)</param>
public static void ExportToImage(GraphAreaBase surface, Uri path, ImageType itype, bool useZoomControlSurface = false, double imgdpi = DefaultDPI, int imgQuality = 100)
{
//Create a render bitmap and push the surface to it
Visual vis = surface;
if (useZoomControlSurface)
{
if (surface.Parent != null && surface.Parent is IZoomControl)
vis = (surface.Parent as IZoomControl).PresenterVisual;
else if(surface.Parent!=null && surface.Parent is FrameworkElement && (surface.Parent as FrameworkElement).Parent is IZoomControl)
vis = ((surface.Parent as FrameworkElement).Parent as IZoomControl).PresenterVisual;
}
var renderBitmap =
new RenderTargetBitmap(
//(int)surface.ActualWidth,
//(int)surface.ActualHeight,
(int)(vis as UIElement).DesiredSize.Width + 100,
(int)(vis as UIElement).DesiredSize.Height + 100,
imgdpi,
imgdpi,
pixelFormat);
//Render the graphlayout onto the bitmap.
renderBitmap.Render(vis);
//Create a file stream for saving image
using (FileStream outStream = new FileStream(path.LocalPath, FileMode.Create))
{
//Use png encoder for our data
BitmapEncoder encoder;
switch (itype)
{
case ImageType.PNG: encoder = new PngBitmapEncoder();
break;
case ImageType.JPEG: encoder = new JpegBitmapEncoder() { QualityLevel = imgQuality };
break;
case ImageType.BMP: encoder = new BmpBitmapEncoder();
break;
case ImageType.GIF: encoder = new GifBitmapEncoder();
break;
case ImageType.TIFF: encoder = new TiffBitmapEncoder();
break;
default: throw new GX_InvalidDataException("ExportToImage() -> Unknown output image format specified!");
}
//Push the rendered bitmap to it
encoder.Frames.Add(BitmapFrame.Create(renderBitmap));
//Save the data to the stream
encoder.Save(outStream);
}
}
//BlueMarble.Data.MarbleDataBase dataBase;
public void InitiateVideo(int rollNum, int frameRate)
{
FileStream stream = new FileStream("new.gif", FileMode.Create);
Stream imageStream = new FileStream("images.jpg", FileMode.Open, FileAccess.Read, FileShare.Read);
JpegBitmapDecoder decoder = new JpegBitmapDecoder(imageStream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
BitmapSource image = decoder.Frames[0];
GifBitmapEncoder newGif = new GifBitmapEncoder();
for (int x = 0; x < 10; x++)
{
newGif.Frames.Add(BitmapFrame.Create(image));
}
bool duration = newGif.Frames[0].HasAnimatedProperties;
imageStream = new FileStream("images2.jpg", FileMode.Open, FileAccess.Read, FileShare.Read);
decoder = new JpegBitmapDecoder(imageStream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
image = decoder.Frames[0];
for (int x = 0; x < 10; x++)
{
newGif.Frames.Add(BitmapFrame.Create(image));
}
imageStream = new FileStream("images3.jpg", FileMode.Open, FileAccess.Read, FileShare.Read);
decoder = new JpegBitmapDecoder(imageStream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
image = decoder.Frames[0];
for (int x = 0; x < 10; x++)
{
newGif.Frames.Add(BitmapFrame.Create(image));
}
var request = WebRequest.Create("http://www.gravatar.com/avatar/6810d91caff032b202c50701dd3af745?d=identicon&r=PG");
using (var response = request.GetResponse())
using (var webstream = response.GetResponseStream())
{
decoder = new JpegBitmapDecoder(webstream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
//imageStream = Bitmap.FromStream(webstream);
}
//decoder = new JpegBitmapDecoder(imageStream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
image = decoder.Frames[0];
for (int x = 0; x < 10; x++)
{
newGif.Frames.Add(BitmapFrame.Create(image));
}
newGif.Save(stream);
}
/// <summary>
/// Save a solved map to an image file.
/// </summary>
/// <param name="path"></param>
/// <param name="map"></param>
/// <param name="outputPath"></param>
public static void OutputBitmap(
MapPath path,
Map map,
string outputPath)
{
// Get pixels from original map data.
byte[] pixels = path.TraceOverMap(map);
// Output the bitmap.
string extension = Path.GetExtension(outputPath);
BitmapEncoder encoder;
switch (extension)
{
default:
encoder = new BmpBitmapEncoder();
break;
case ".png":
encoder = new PngBitmapEncoder();
break;
case ".gif":
encoder = new GifBitmapEncoder();
break;
case ".tif": case "tiff":
encoder = new TiffBitmapEncoder();
break;
case ".jpg": case "jpeg":
encoder = new JpegBitmapEncoder();
break;
case ".wmp":
encoder = new WmpBitmapEncoder();
break;
}
Console.WriteLine(extension);
// TODO: Figure out why files have no compression.
int stride = map.Width * Map.BytesPerPixel;
BitmapSource bitmapSource = BitmapSource.Create(
map.Width, map.Height,
96, 96,
PixelFormats.Bgra32, null, pixels, stride);
encoder.Frames.Add(BitmapFrame.Create(bitmapSource));
using (FileStream filestream = new FileStream(outputPath, FileMode.Create))
{
encoder.Save(filestream);
}
}
private void CreateImageFile(FileStream file,BitmapFrame frame,ImageType type)
{
if(file==null)return;
BitmapEncoder encoder=null;
switch(type)
{
case ImageType.Bmp:encoder=new BmpBitmapEncoder();break;
case ImageType.Jpg:encoder=new JpegBitmapEncoder(){QualityLevel=100};break;
case ImageType.Png:encoder=new PngBitmapEncoder();break;
case ImageType.Gif:encoder=new GifBitmapEncoder();break;
case ImageType.Tiff:encoder=new TiffBitmapEncoder(){Compression=TiffCompressOption.Default};break;
}
encoder.Frames.Add(frame);
encoder.Save(file);
}
public static void GenerateImage(BitmapSource bitmap, string lowerExtension, Stream destStream)
{
/*
* 参考资料：
* [在WPF程序中将控件所呈现的内容保存成图像]
* (http://www.cnblogs.com/TianFang/archive/2012/10/07/2714140.html)
* [Rendering a WPF Container to Bitmap]
* (http://weblog.west-wind.com/posts/2007/Sep/10/Rendering-a-WPF-Container-to-Bitmap)
*/
BitmapEncoder encoder = null;
switch (lowerExtension)
{
case ".jpg": { encoder = new JpegBitmapEncoder(); break; }
case ".png": { encoder = new PngBitmapEncoder(); break; }
case ".bmp": { encoder = new BmpBitmapEncoder(); break; }
case ".gif": { encoder = new GifBitmapEncoder(); break; }
case ".tif": { encoder = new TiffBitmapEncoder(); break; }
default: { encoder = new BmpBitmapEncoder(); break; }
}
encoder.Frames.Add(BitmapFrame.Create(bitmap));
encoder.Save(destStream);
}
private bool SaveImage(BitmapSource image, string filename)
{
string ext = Path.GetExtension(filename).ToLower();
BitmapEncoder encoder;
if (ext == ".gif")
{
encoder = new GifBitmapEncoder();
}
else if (ext == ".png")
{
encoder = new PngBitmapEncoder();
}
else if (ext == ".jpg")
{
encoder = new JpegBitmapEncoder();
}
else
{
filename = Path.ChangeExtension(filename, ".png");
encoder = new PngBitmapEncoder();
}
try
{
encoder.Frames.Add(BitmapFrame.Create(image));
using (Stream stm = File.Create(filename))
{
encoder.Save(stm);
}
}
catch (SystemException)
{
return false;
}
return true;
}
public static void writeImage(String outputPath, BitmapSource image, Dictionary<String, Object> options = null, ImageMetadata metaData = null, CancellableOperationProgressBase progress = null)
{
int width = image.PixelWidth;
int height = image.PixelHeight;
float scale = ImageUtils.resizeRectangle(width, height, Constants.MAX_THUMBNAIL_WIDTH, Constants.MAX_THUMBNAIL_HEIGHT);
TransformedBitmap thumbnail = new TransformedBitmap(image, new System.Windows.Media.ScaleTransform(scale, scale));
if (options != null)
{
if (options.ContainsKey("Width"))
{
width = (int)options["Width"];
if (!options.ContainsKey("Height"))
{
height = (int)(((float)width / image.PixelWidth) * image.PixelHeight);
}
}
if (options.ContainsKey("Height")) {
height = (int)options["Height"];
if (!options.ContainsKey("Width"))
{
width = (int)(((float)height / image.PixelHeight) * image.PixelWidth);
}
}
}
BitmapSource outImage = image;
if (width != image.PixelWidth || height != image.PixelHeight)
{
outImage = new TransformedBitmap(image, new System.Windows.Media.ScaleTransform((double)width / image.PixelWidth, (double)height / image.PixelHeight));
}
ImageFormat format = MediaFormatConvert.fileNameToImageFormat(outputPath);
BitmapEncoder encoder = null;
if (format == ImageFormat.Jpeg)
{
encoder = configureJpeg(options, ref thumbnail);
}
else if (format == ImageFormat.Png)
{
encoder = configurePng(options);
}
else if (format == ImageFormat.Gif)
{
encoder = new GifBitmapEncoder();
}
else if (format == ImageFormat.Bmp)
{
encoder = new BmpBitmapEncoder();
}
else if (format == ImageFormat.Tiff)
{
encoder = configureTiff(options);
}
encoder.Frames.Add(BitmapFrame.Create(outImage, thumbnail, null, null));
FileStream outputFile = new FileStream(outputPath, FileMode.Create);
encoder.Save(outputFile);
outputFile.Close();
if (metaData != null)
{
metaData.Location = outputPath;
ImageFileMetadataWriter metadataWriter = new ImageFileMetadataWriter();
metadataWriter.writeMetadata(metaData, progress);
}
}
public static void CreateIcon(FrameworkElement element, int width, int height, string path)
{
try
{
RenderTargetBitmap bmp = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Pbgra32);
bmp.Render(element);
string file = path;
string Extension = Path.GetExtension(file).ToLower();
BitmapEncoder encoder;
if (Extension == ".gif")
encoder = new GifBitmapEncoder();
else if (Extension == ".png")
encoder = new PngBitmapEncoder();
else if (Extension == ".jpg")
encoder = new JpegBitmapEncoder();
else
return;
encoder.Frames.Add(BitmapFrame.Create(bmp));
using (Stream stm = File.Create(file))
{
encoder.Save(stm);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
internal byte[] GetEncodedImageData(ImageSource image, string preferredFormat)
{
try
{
byte[] result = null;
BitmapEncoder encoder = null;
switch (preferredFormat.ToLower())
{
case ".jpg":
case ".jpeg":
encoder = new JpegBitmapEncoder();
break;
case ".bmp":
encoder = new BmpBitmapEncoder();
break;
case ".png":
encoder = new PngBitmapEncoder();
break;
case ".tif":
case ".tiff":
encoder = new TiffBitmapEncoder();
break;
case ".gif":
encoder = new GifBitmapEncoder();
break;
case ".wmp":
encoder = new WmpBitmapEncoder();
break;
}
if (image is BitmapSource)
{
MemoryStream stream = new MemoryStream();
encoder.Frames.Add(BitmapFrame.Create(image as BitmapSource));
encoder.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
result = new byte[stream.Length];
BinaryReader br = new BinaryReader(stream);
br.Read(result, 0, (int)stream.Length);
br.Close();
stream.Close();
}
return result;
}
catch (System.Exception ex1)
{
TaskDialog.Show("Error!", "exception: " + ex1);
}
return null;
}
private void FileSave_Click(object sender, RoutedEventArgs e)
{
if (curArr == -1)
return;
Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog();
dlg.InitialDirectory = Properties.Settings.Default.lastSavePath;
Console.WriteLine(dlg.InitialDirectory);
dlg.FileName = arrangements[curArr].Name;
dlg.DefaultExt = ".png";
dlg.AddExtension = true;
dlg.Filter = "Portable Network Graphics|*.png|GIF Image|*.gif";
Nullable<bool> result = dlg.ShowDialog();
if (result == true) {
string filename = dlg.FileName;
Properties.Settings.Default.lastSavePath = dlg.FileName.Substring(0, dlg.FileName.LastIndexOf('\\'));
Properties.Settings.Default.Save();
RenderTargetBitmap bitmap = new RenderTargetBitmap(Convert.ToInt32(ArrangementCanvas.ActualWidth), Convert.ToInt32(ArrangementCanvas.ActualHeight), 72, 72, PixelFormats.Pbgra32);
bitmap.Render(ArrangementCanvas2);
bitmap.Render(ArrangementCanvas);
BitmapFrame frame = BitmapFrame.Create((BitmapSource)bitmap);
BitmapEncoder encoder = null;
if (filename.Substring(filename.Length - 3, 3) == "png") {
encoder = new PngBitmapEncoder();
encoder.Frames.Add(frame);
}
if (filename.Substring(filename.Length - 3, 3) == "gif") {
encoder = new GifBitmapEncoder();
encoder.Frames.Add(frame);
}
FileStream saveFile = new FileStream(filename, FileMode.Create);
if (encoder != null)
encoder.Save(saveFile);
saveFile.Close();
}
}
/// <summary>
/// Image export method
/// Encodes a RenderTargetBitmap as a graphic-file (bmp, gif, jpeg, png or tiff) and saves it with the given filename.
/// </summary>
/// <param name="filename">Filename</param>
/// <returns>bool if the export was successfully</returns>
/// <author>Thomas Meents, Bernhard Bruns, Andrej Albrecht</author>
public bool export(String filename)
{
try
{
processModelCanvas.Background = Brushes.White;
RenderTargetBitmap render = new RenderTargetBitmap((int)processModelCanvas.Width, (int)processModelCanvas.Height, 96d, 96d, PixelFormats.Pbgra32);
render.Clone();
processModelCanvas.Measure(new Size((int)processModelCanvas.Width, (int)processModelCanvas.Height));
processModelCanvas.Arrange(new Rect(new Size((int)processModelCanvas.Width, (int)processModelCanvas.Height)));
render.Render(processModelCanvas);
switch (this.filetype)
{
case ".bmp":
BmpBitmapEncoder bmpEncoder = new BmpBitmapEncoder();
bmpEncoder.Frames.Add(BitmapFrame.Create(render));
using (FileStream bmpFile = File.Create(filename))
{
bmpEncoder.Save(bmpFile);
}
break;
case ".gif":
GifBitmapEncoder gifEncoder = new GifBitmapEncoder();
gifEncoder.Frames.Add(BitmapFrame.Create(render));
using (FileStream gifFile = File.Create(filename))
{
gifEncoder.Save(gifFile);
}
break;
case ".jpeg":
JpegBitmapEncoder jpegEncoder = new JpegBitmapEncoder();
jpegEncoder.Frames.Add(BitmapFrame.Create(render));
using (FileStream jpegFile = File.Create(filename))
{
jpegEncoder.Save(jpegFile);
}
break;
case ".png":
PngBitmapEncoder pngEncoder = new PngBitmapEncoder();
pngEncoder.Frames.Add(BitmapFrame.Create(render));
using (FileStream pngFile = File.Create(filename))
{
pngEncoder.Save(pngFile);
}
break;
case ".tiff":
TiffBitmapEncoder tiffEncoder = new TiffBitmapEncoder();
tiffEncoder.Frames.Add(BitmapFrame.Create(render));
using (FileStream tiffFile = File.Create(filename))
{
tiffEncoder.Save(tiffFile);
}
break;
}
return true;
}
catch (Exception)
{
return false;
}
}
public static byte[] SaveToBytes(this BitmapSource image, ImageType saveType = ImageType.Png)
{
BitmapEncoder encoder;
switch (saveType)
{
case ImageType.Gif:
encoder = new GifBitmapEncoder();
break;
case ImageType.Jpg:
encoder = new JpegBitmapEncoder();
break;
case ImageType.Tiff:
encoder = new TiffBitmapEncoder();
break;
default:
// default: use PNG format
encoder = new PngBitmapEncoder();
break;
}
encoder.Frames.Add(BitmapFrame.Create(image));
using (var ms = new MemoryStream())
{
encoder.Save(ms);
return ms.ToArray();
}
}
private void btnSaveImageGraph_Click(object sender, RoutedEventArgs e)
{
var fileDialog = new SaveFileDialog()
{
Filter = "PNG (*.png)|*.png|JPEG (*.jpg)|*.jpg|GIF (*.gif)|*.gif|BMP (*.bmp)|*.bmp|TIFF (.tiff)|*.tiff"
};
fileDialog.ShowDialog();
if (String.IsNullOrEmpty(fileDialog.FileName))
return;
// render it
var renderBitmap = new RenderTargetBitmap((int)graphLayout.ActualWidth,
(int)graphLayout.ActualHeight,
96d,
96d,
PixelFormats.Default);
renderBitmap.Render(graphLayout);
using (var outStream = new FileStream(fileDialog.FileName, FileMode.Create))
{
BitmapEncoder encoder;
switch (fileDialog.FilterIndex)
{
case 1:
encoder = new PngBitmapEncoder();
break;
case 2:
encoder = new JpegBitmapEncoder();
break;
case 3:
encoder = new GifBitmapEncoder();
break;
case 4:
encoder = new BmpBitmapEncoder();
break;
case 5:
encoder = new TiffBitmapEncoder();
break;
default:
encoder = new PngBitmapEncoder();
break;
}
encoder.Frames.Add(BitmapFrame.Create(renderBitmap));
encoder.Save(outStream);
}
}
private static BitmapEncoder GetBitmapEncoder(ImageExtension type)
{
BitmapEncoder encoder = null;
switch (type)
{
case ImageExtension.PNG:
encoder = new PngBitmapEncoder();
break;
case ImageExtension.GIF:
encoder = new GifBitmapEncoder();
break;
case ImageExtension.JPG:
encoder = new JpegBitmapEncoder();
break;
default:
break;
}
return encoder;
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
Hp.Drawing drawing = new Hp.Drawing();
if (!DA.GetData <Hp.Drawing>(0, ref drawing))
{
return;
}
int dpi = 96;
string path = "C:\\Users\\Public\\Documents\\";
string name = DateTime.UtcNow.ToString("yyyy-dd-M_HH-mm-ss");;
int extension = 0;
string format = ".png";
bool save = false;
if (!DA.GetData(1, ref dpi))
{
return;
}
bool hasPath = DA.GetData(2, ref path);
bool hasName = DA.GetData(3, ref name);
if (!DA.GetData(4, ref extension))
{
return;
}
if (!DA.GetData(5, ref save))
{
return;
}
Si.BitmapEncoder encoding = new Si.PngBitmapEncoder();
switch (extension)
{
case 1:
encoding = new Si.JpegBitmapEncoder();
format = ".jpeg";
break;
case 2:
encoding = new Si.BmpBitmapEncoder();
format = ".bmp";
break;
case 3:
encoding = new Si.TiffBitmapEncoder();
format = ".tiff";
break;
case 4:
encoding = new Si.GifBitmapEncoder();
format = ".gif";
break;
}
if (!hasPath)
{
if (this.OnPingDocument().FilePath != null)
{
path = Path.GetDirectoryName(this.OnPingDocument().FilePath) + "\\";
}
}
else
{
path += "//";
}
string filepath = path + name + format;
Sm.DrawingVisual dwg = drawing.ToGeometryVisual();
Bitmap bitmap = dwg.ToBitmap(drawing.Width, drawing.Height, dpi, encoding);
if (save)
{
bitmap.Save(filepath);
bitmap.Dispose();
}
DA.SetData(0, filepath);
}
/// <summary> Saves the rendered scoreboard to an image when clicked. </summary>
private void SaveImage()
{
if (MainWindowViewModel.DisplayWindow.IsVisible == false)
{
MessageBox.Show(
"Scoreboard must be showing on-screen in order to save to an image.",
"Error: Scoreboard Hidden",
MessageBoxButton.OK,
MessageBoxImage.Error);
return;
}
const string Filter = "PNG Image (*.png)|*.png|" +
"TIFF Image (*.tiff)|*.tiff|" +
"All Files (*.*)|*.*";
var sfd = new Microsoft.Win32.SaveFileDialog { Filter = Filter };
if (sfd.ShowDialog() == true)
{
var filename = sfd.FileName;
if (string.IsNullOrEmpty(filename))
{
return;
}
var viewBox = MainWindowViewModel.DisplayWindow.rootGrid;
var bmp = new RenderTargetBitmap(
(int)viewBox.RenderSize.Width, (int)viewBox.RenderSize.Height, 96, 96, PixelFormats.Pbgra32);
bmp.Render(viewBox);
BitmapEncoder encoder;
var extUpper = Path.GetExtension(filename);
if (extUpper == null)
{
// Could happen if they choose all files and didn't type an extension.
MessageBox.Show(
"Unrecognized Image Format",
"Error: Format Unrecognized",
MessageBoxButton.OK,
MessageBoxImage.Error);
return;
}
string ext = extUpper.ToLower();
if (ext.Equals(".png"))
{
encoder = new PngBitmapEncoder();
}
else if (ext.Equals(".jpg"))
{
encoder = new JpegBitmapEncoder { QualityLevel = 95 };
}
else if (ext.Equals(".tiff"))
{
encoder = new TiffBitmapEncoder();
}
else if (ext.Equals(".gif"))
{
encoder = new GifBitmapEncoder();
}
else if (ext.Equals(".bmp"))
{
encoder = new BmpBitmapEncoder();
}
else
{
MessageBox.Show(
"Unrecognized Image Format",
"Error: Format Unrecognized",
MessageBoxButton.OK,
MessageBoxImage.Error);
return;
}
using (var stream = new FileStream(filename, FileMode.Create))
{
encoder.Frames.Add(BitmapFrame.Create(bmp));
encoder.Save(stream);
}
}
}
