public static void ShowExportDialog(this BitmapContainer image)
{
if (image == null) return;
SaveFileDialog saveImg = new SaveFileDialog();
saveImg.Filter = "Jpeg Image|*.jpg|Png Image|*.png|Bitmap Image|*.bmp|Tiff Image|*.tiff|Windows Media Bitmap|*.wmb";
saveImg.Title = "Export Single Image";
saveImg.FileName = image.Name;
saveImg.AddExtension = true;
saveImg.DefaultExt = "*.png";
saveImg.CheckPathExists = true;
BitmapEncoder encoder = null;
if (saveImg.ShowDialog() == true)
{
string ext = Path.GetExtension(saveImg.FileName);
switch (ext.ToLower())
{
case ".png":
encoder = new PngBitmapEncoder();
break;
case ".bmp":
encoder = new BmpBitmapEncoder();
break;
case ".jpeg":
case ".jpg":
encoder = new JpegBitmapEncoder();
break;
case ".tiff":
encoder = new TiffBitmapEncoder();
break;
case ".wmb":
encoder = new WmpBitmapEncoder();
break;
default:
encoder = new BmpBitmapEncoder();
saveImg.FileName += ".bmp";
break;
}
encoder.Frames.Add(BitmapFrame.Create(image.Bitmap));
using (FileStream fs = new FileStream(saveImg.FileName, FileMode.OpenOrCreate))
{
encoder.Save(fs);
fs.Close();
}
}
}
/// <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);
}
}
bool SaveImageToDisk(string filename, out string errorMessage)
{
string extension = filename.LastIndexOf(".") > -1 ? filename.Substring(filename.LastIndexOf(".")) : ".jpg";
BitmapEncoder encoder = null;
switch (extension.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;
default:
errorMessage = "extension is wrong!";
return false;
}
try
{
FileStream stream = new FileStream(filename, FileMode.Create);
encoder.Frames.Add(BitmapFrame.Create(imageToSave));
encoder.Save(stream);
errorMessage = "";
stream.Close();
return true;
}
catch (Exception e)
{
errorMessage = e.ToString();
}
return false;
}
/* Paste the page to various types supported by the windows encoder class */
private void PastePage(object sender, RoutedEventArgs e)
{
var menu = (System.Windows.Controls.MenuItem)sender;
String tag = (String)menu.Tag;
if (!m_clipboardset || !System.Windows.Clipboard.ContainsImage() ||
!m_init_done)
return;
var bitmap = System.Windows.Clipboard.GetImage();
BitmapEncoder encoder;
System.Windows.Forms.SaveFileDialog dlg = new System.Windows.Forms.SaveFileDialog();
dlg.FilterIndex = 1;
switch (tag)
{
case "PNG":
dlg.Filter = "PNG Files(*.png)|*.png";
encoder = new PngBitmapEncoder();
break;
case "JPG":
dlg.Filter = "JPEG Files(*.jpg)|*.jpg";
encoder = new JpegBitmapEncoder();
break;
case "WDP":
dlg.Filter = "HDP Files(*.wdp)|*.wdp";
encoder = new WmpBitmapEncoder();
break;
case "TIF":
dlg.Filter = "TIFF Files(*.tif)|*.tif";
encoder = new TiffBitmapEncoder();
break;
case "BMP":
dlg.Filter = "BMP Files(*.bmp)|*.bmp";
encoder = new BmpBitmapEncoder();
break;
case "GIF":
dlg.Filter = "GIF Files(*.gif)|*.gif";
encoder = new GifBitmapEncoder();
break;
default:
return;
}
encoder.Frames.Add(BitmapFrame.Create(bitmap));
if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
using (var stream = dlg.OpenFile())
encoder.Save(stream);
}
}
private BitmapEncoder GetBitmapEncoder(string fileExtension)
{
BitmapEncoder bitmapEncoder = null;
if (_bitmapEncoder != null && _bitmapEncoder.CodecInfo != null)
{
string mimeType = String.Empty;
BitmapCodecInfo codecInfo = _bitmapEncoder.CodecInfo;
string mimeTypes = codecInfo.MimeTypes;
string fileExtensions = codecInfo.FileExtensions;
switch (_encoderType)
{
case ImageEncoderType.BmpBitmap:
mimeType = "image/bmp";
break;
case ImageEncoderType.GifBitmap:
mimeType = "image/gif";
break;
case ImageEncoderType.JpegBitmap:
mimeType = "image/jpeg,image/jpe,image/jpg";
break;
case ImageEncoderType.PngBitmap:
mimeType = "image/png";
break;
case ImageEncoderType.TiffBitmap:
mimeType = "image/tiff,image/tif";
break;
case ImageEncoderType.WmpBitmap:
mimeType = "image/vnd.ms-photo";
break;
}
if (!String.IsNullOrEmpty(fileExtensions) &&
fileExtensions.IndexOf(fileExtension,
StringComparison.OrdinalIgnoreCase) >= 0)
{
bitmapEncoder = _bitmapEncoder;
}
else if (!String.IsNullOrEmpty(mimeTypes) &&
!String.IsNullOrEmpty(mimeType))
{
string[] arrayMimeTypes = mimeType.Split(',');
for (int i = 0; i < arrayMimeTypes.Length; i++)
{
if (mimeTypes.IndexOf(arrayMimeTypes[i],
StringComparison.OrdinalIgnoreCase) >= 0)
{
bitmapEncoder = _bitmapEncoder;
break;
}
}
}
}
if (bitmapEncoder == null)
{
switch (_encoderType)
{
case ImageEncoderType.BmpBitmap:
bitmapEncoder = new BmpBitmapEncoder();
break;
case ImageEncoderType.GifBitmap:
bitmapEncoder = new GifBitmapEncoder();
break;
case ImageEncoderType.JpegBitmap:
JpegBitmapEncoder jpgEncoder = new JpegBitmapEncoder();
// Set the default/user options...
bitmapEncoder = jpgEncoder;
break;
case ImageEncoderType.PngBitmap:
PngBitmapEncoder pngEncoder = new PngBitmapEncoder();
// Set the default/user options...
bitmapEncoder = pngEncoder;
break;
case ImageEncoderType.TiffBitmap:
bitmapEncoder = new TiffBitmapEncoder();
break;
case ImageEncoderType.WmpBitmap:
WmpBitmapEncoder wmpEncoder = new WmpBitmapEncoder();
// Set the default/user options...
bitmapEncoder = wmpEncoder;
break;
}
}
if (bitmapEncoder == null)
{
bitmapEncoder = new PngBitmapEncoder();
}
return bitmapEncoder;
}
/// <summary>Creates a converted copy of the image (wmp formatted).</summary>
public static byte[] ConvertTo_WmpByteArray(this BitmapSource input)
{
var encoder = new WmpBitmapEncoder();
//TODO include Options
return input.ConvertTo_UsingEncoder(encoder);
}
public static byte[] ImageSourceToBytes(ImageSource image, string preferredFormat)
{
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;
}
private void SaveCurrentAs()
{
System.Windows.Forms.SaveFileDialog saveFileDialog = new System.Windows.Forms.SaveFileDialog();
saveFileDialog.Title = Comisor.Resource.SaveImage;
saveFileDialog.OverwritePrompt = true;
saveFileDialog.Filter = Comisor.Resource.SaveFilter;
saveFileDialog.AddExtension = true;
saveFileDialog.ValidateNames = true;
saveFileDialog.InitialDirectory = ys.DataProcessor.GetAvailableParentDir(imgInfo.FullName);
saveFileDialog.FileName = imgInfo.Name.Remove(imgInfo.Name.LastIndexOf('.'));
if (saveFileDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
BitmapEncoder encoder;
BitmapSource bmp = imgContainer.Source as BitmapSource;
string name = saveFileDialog.FileName.ToLower();
switch (name.Remove(0, name.LastIndexOf('.')))
{
case ".png":
PngBitmapEncoder pngEncoder = new PngBitmapEncoder();
if (saveFileDialog.FilterIndex == 2)
pngEncoder.Interlace = PngInterlaceOption.On;
encoder = pngEncoder;
break;
case ".jpg":
JpegBitmapEncoder jpgEncoder = new JpegBitmapEncoder();
switch (saveFileDialog.FilterIndex)
{
case 3:
jpgEncoder.QualityLevel = 50;
break;
case 4:
jpgEncoder.QualityLevel = 85;
break;
case 5:
jpgEncoder.QualityLevel = 100;
break;
}
encoder = jpgEncoder;
bmp = ys.ImageProcessor.LayWhiteBg(imgContainer.Source as BitmapSource);
break;
case ".gif":
GifBitmapEncoder gifEncoder = new GifBitmapEncoder();
encoder = gifEncoder;
bmp = ys.ImageProcessor.LayWhiteBg(imgContainer.Source as BitmapSource);
break;
case ".bmp":
BmpBitmapEncoder bmpEncoder = new BmpBitmapEncoder();
encoder = bmpEncoder;
bmp = ys.ImageProcessor.LayWhiteBg(imgContainer.Source as BitmapSource);
break;
case ".tif":
TiffBitmapEncoder tifEncoder = new TiffBitmapEncoder();
encoder = tifEncoder;
if (saveFileDialog.FilterIndex == 8)
{
encoder.Frames = bmpDecoder.Frames;
FileStream multilayerFS = new FileStream(saveFileDialog.FileName, FileMode.Create);
encoder.Save(multilayerFS);
multilayerFS.Dispose();
return;
}
break;
case ".wdp":
WmpBitmapEncoder wdpEncoder = new WmpBitmapEncoder();
encoder = wdpEncoder;
break;
default:
return;
}
encoder.Frames.Add(BitmapFrame.Create(bmp));
FileStream fs = new FileStream(saveFileDialog.FileName, FileMode.Create);
encoder.Save(fs);
fs.Dispose();
}
}
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 static BitmapEncoder GetBitmapEncoder(string fileExtension,
ImageEncoderType encoderType)
{
BitmapEncoder bitampEncoder = null;
switch (encoderType)
{
case ImageEncoderType.BmpBitmap:
bitampEncoder = new BmpBitmapEncoder();
break;
case ImageEncoderType.GifBitmap:
bitampEncoder = new GifBitmapEncoder();
break;
case ImageEncoderType.JpegBitmap:
JpegBitmapEncoder jpgEncoder = new JpegBitmapEncoder();
// Set the default/user options...
bitampEncoder = jpgEncoder;
break;
case ImageEncoderType.PngBitmap:
PngBitmapEncoder pngEncoder = new PngBitmapEncoder();
// Set the default/user options...
bitampEncoder = pngEncoder;
break;
case ImageEncoderType.TiffBitmap:
bitampEncoder = new TiffBitmapEncoder();
break;
case ImageEncoderType.WmpBitmap:
WmpBitmapEncoder wmpEncoder = new WmpBitmapEncoder();
// Set the default/user options...
bitampEncoder = wmpEncoder;
break;
}
if (bitampEncoder == null)
{
bitampEncoder = new PngBitmapEncoder();
}
return bitampEncoder;
}
private byte[] EncodeImageData(ImageSource image, ImageEncoding encoding)
{
byte[] buffer = null;
BitmapEncoder encoder = null;
switch (encoding)
{
case ImageEncoding.Jpg100:
encoder = new JpegBitmapEncoder { QualityLevel = 100 };
break;
case ImageEncoding.Jpg95:
encoder = new JpegBitmapEncoder { QualityLevel = 95 };
break;
case ImageEncoding.Jpg90:
encoder = new JpegBitmapEncoder { QualityLevel = 90 };
break;
case ImageEncoding.Jpg:
encoder = new JpegBitmapEncoder();
break;
case ImageEncoding.Bmp:
encoder = new BmpBitmapEncoder();
break;
case ImageEncoding.Png:
encoder = new PngBitmapEncoder();
break;
case ImageEncoding.Tiff:
encoder = new TiffBitmapEncoder();
break;
case ImageEncoding.Gif:
encoder = new GifBitmapEncoder();
break;
case ImageEncoding.Wmp:
encoder = new WmpBitmapEncoder();
break;
}
if (image is BitmapSource)
{
var stream = new MemoryStream();
if (encoder != null)
{
var bitmapFrame = BitmapFrame.Create(image as BitmapSource);
encoder.Frames.Add(bitmapFrame);
encoder.Save(stream);
}
stream.Seek(0L, SeekOrigin.Begin);
buffer = new byte[stream.Length];
var reader = new BinaryReader(stream);
reader.Read(buffer, 0, (int)stream.Length);
reader.Close();
stream.Close();
}
return buffer;
}
public static void ShowExportMultipleDialog(this IEnumerable<BitmapContainer> images)
{
SaveFileDialog saveImg = new SaveFileDialog();
saveImg.Filter = "Png Image|*.png|Jpeg Image|*.jpg|Bitmap Image|*.bmp|Tiff Image|*.tiff|Windows Media Bitmap|*.wmb";
saveImg.Title = "Export All Image";
saveImg.FileName = "[Multiple Files - Choose File Type]";
saveImg.AddExtension = false;
saveImg.FilterIndex = 0;
saveImg.CheckPathExists = true;
if (saveImg.ShowDialog() == true)
{
string ext = saveImg.Filter.Split('|')[saveImg.FilterIndex / 2 + 1].TrimStart('*');
string path = Path.GetDirectoryName(saveImg.FileName);
foreach (var bmp in images)
{
BitmapEncoder encoder = null;
switch (ext.ToLower())
{
case ".png":
encoder = new PngBitmapEncoder();
break;
case ".bmp":
encoder = new BmpBitmapEncoder();
break;
case ".jpeg":
case ".jpg":
encoder = new JpegBitmapEncoder();
break;
case ".tiff":
encoder = new TiffBitmapEncoder();
break;
case ".wmb":
encoder = new WmpBitmapEncoder();
break;
default:
encoder = new BmpBitmapEncoder();
saveImg.FileName += ".bmp";
break;
}
encoder.Frames.Add(BitmapFrame.Create(bmp.Bitmap));
using (FileStream fs = new FileStream(Path.Combine(path, bmp.Name + ext), FileMode.OpenOrCreate))
{
encoder.Save(fs);
fs.Close();
}
}
}
}
/// <summary>
/// Export the Sparrow Chart as Image
/// </summary>
/// <param name="fileName">Output File Name to Export the Chart as Image</param>
public void ExportAsImage(string fileName)
{
string fileExtension = new FileInfo(fileName).Extension.ToLower(CultureInfo.InvariantCulture);
BitmapEncoder imageEncoder = null;
switch (fileExtension)
{
case ".bmp":
imageEncoder = new BmpBitmapEncoder();
break;
case ".jpg":
case ".jpeg":
imageEncoder = new JpegBitmapEncoder();
break;
case ".png":
imageEncoder = new PngBitmapEncoder();
break;
case ".gif":
imageEncoder = new GifBitmapEncoder();
break;
case ".tif":
case ".tiff":
imageEncoder = new TiffBitmapEncoder();
break;
case ".wdp":
imageEncoder = new WmpBitmapEncoder();
break;
default:
imageEncoder = new BmpBitmapEncoder();
break;
}
RenderTargetBitmap bmpSource =new RenderTargetBitmap((int)this.ActualWidth,(int)this.ActualHeight, 96, 96,PixelFormats.Pbgra32);
bmpSource.Render(this);
imageEncoder.Frames.Add(BitmapFrame.Create(bmpSource));
using (Stream stream = File.Create(fileName))
{
imageEncoder.Save(stream);
stream.Close();
}
}
private void OnSaveImpl(
Document input,
Stream output,
SaveConfigToken token,
Surface scratchSurface,
ProgressEventHandler callback)
{
HDPhotoSaveConfigToken hdToken = token as HDPhotoSaveConfigToken;
WmpBitmapEncoder wbe = new WmpBitmapEncoder();
using (RenderArgs ra = new RenderArgs(scratchSurface))
{
input.Render(ra, true);
}
MemoryBlock block = scratchSurface.Scan0;
IntPtr scan0 = block.Pointer;
double dpiX;
double dpiY;
switch (input.DpuUnit)
{
case MeasurementUnit.Centimeter:
dpiX = Document.DotsPerCmToDotsPerInch(input.DpuX);
dpiY = Document.DotsPerCmToDotsPerInch(input.DpuY);
break;
case MeasurementUnit.Inch:
dpiX = input.DpuX;
dpiY = input.DpuY;
break;
case MeasurementUnit.Pixel:
dpiX = Document.GetDefaultDpu(MeasurementUnit.Inch);
dpiY = Document.GetDefaultDpu(MeasurementUnit.Inch);
break;
default:
throw new InvalidEnumArgumentException();
}
BitmapSource bitmapSource = BitmapFrame.Create(
scratchSurface.Width,
scratchSurface.Height,
dpiX,
dpiY,
System.Windows.Media.PixelFormats.Bgra32,
null,
scan0,
(int)block.Length, // TODO: does not support >2GB images
scratchSurface.Stride);
FormatConvertedBitmap fcBitmap = new FormatConvertedBitmap(
bitmapSource,
hdToken.BitDepth == 24 ? PixelFormats.Bgr24 : PixelFormats.Bgra32,
null,
0);
BitmapFrame outputFrame0 = BitmapFrame.Create(fcBitmap);
wbe.Frames.Add(outputFrame0);
wbe.ImageQualityLevel = (float)hdToken.Quality / 100.0f;
string tempFileName = FileSystem.GetTempFileName();
FileStream tempFileOut = new FileStream(tempFileName, FileMode.Create, FileAccess.Write, FileShare.Read);
wbe.Save(tempFileOut);
tempFileOut.Close();
tempFileOut = null;
FileStream tempFileIn = new FileStream(tempFileName, FileMode.Open, FileAccess.ReadWrite, FileShare.Read);
WmpBitmapDecoder wbd = new WmpBitmapDecoder(tempFileIn, BitmapCreateOptions.None, BitmapCacheOption.None);
BitmapFrame ioFrame0 = wbd.Frames[0];
InPlaceBitmapMetadataWriter metadata2 = ioFrame0.CreateInPlaceBitmapMetadataWriter();
CopyMetadataTo(metadata2, input.Metadata);
tempFileIn.Close();
tempFileIn = null;
FileStream tempFileIn2 = new FileStream(tempFileName, FileMode.Open, FileAccess.ReadWrite, FileShare.Read);
Utility.CopyStream(tempFileIn2, output);
tempFileIn2.Close();
tempFileIn2 = null;
try
{
File.Delete(tempFileName);
}
catch (Exception)
{
}
// WPF doesn't give us an IDisposable implementation on its types
Utility.GCFullCollect();
}
//---------------------------------------------------------
private void btnSave_Click(object sender, RoutedEventArgs e)
{
if ( MyCanvas == null) return;
Image saveData = Croper.Crop(MyCanvas, 0, 0, MyCanvas.Width, MyCanvas.Height);
SaveFileDialog saveFileDialogue = new SaveFileDialog()
{
FileName = "Untitled",
Filter = "Bitmap Image (.bmp)|*.bmp|Gif Image (.gif)|*.gif|JPEG Image (.jpeg)|*.jpeg|Png Image (.png)|*.png|Tiff Image (.tiff)|*.tiff|Wmf Image (.wmf)|*.wmf"
};
if (saveFileDialogue.ShowDialog() == true)
{
//Image saveData = paintLogic.Save();
BitmapEncoder encoder;
#region Encoding
string extension = System.IO.Path.GetExtension(saveFileDialogue.FileName);
switch (extension.ToLower())
{
case ".jpeg":
encoder = new JpegBitmapEncoder();
break;
case ".png":
encoder = new PngBitmapEncoder();
break;
case ".gif":
encoder = new GifBitmapEncoder();
break;
case ".tiff":
encoder = new TiffBitmapEncoder();
break;
case ".wmf":
encoder = new WmpBitmapEncoder();
break;
case ".bmp":
encoder = new BmpBitmapEncoder();
break;
default:
return;
}
#endregion
encoder.Frames.Add(saveData.Source as BitmapFrame);
using (FileStream file = File.Create(saveFileDialogue.FileName))
{
encoder.Save(file);
}
}
}
public override void Set(string key, object value, CacheItemPolicy policy, string regionName = null)
{
var bitmap = value as BitmapFrame;
if (bitmap == null)
{
throw new ArgumentException("The parameter value must contain a System.Windows.Media.Imaging.BitmapFrame.");
}
var metadata = (BitmapMetadata)bitmap.Metadata;
var format = metadata != null ? metadata.Format : "bmp";
BitmapEncoder encoder = null;
switch (format)
{
case "bmp":
encoder = new BmpBitmapEncoder();
break;
case "gif":
encoder = new GifBitmapEncoder();
break;
case "jpg":
encoder = new JpegBitmapEncoder();
break;
case "png":
encoder = new PngBitmapEncoder();
break;
case "tiff":
encoder = new TiffBitmapEncoder();
break;
case "wmphoto":
encoder = new WmpBitmapEncoder();
break;
default:
break;
}
if (encoder == null)
{
throw new NotSupportedException(string.Format("The bitmap format {0} is not supported.", format));
}
memoryCache.Set(key, bitmap, policy, regionName);
var path = string.Format("{0}.{1}", GetPath(key), format);
try
{
Directory.CreateDirectory(Path.GetDirectoryName(path));
using (var fileStream = new FileStream(path, FileMode.Create, FileAccess.Write))
{
encoder.Frames.Add(bitmap);
encoder.Save(fileStream);
}
var fileSecurity = File.GetAccessControl(path);
fileSecurity.AddAccessRule(fullControlRule);
File.SetAccessControl(path, fileSecurity);
}
catch (Exception ex)
{
Debug.WriteLine("ImageFileCache: Writing file {0} failed: {1}", path, ex.Message);
}
}
private void TakeScreenCapture(Control control, string imageFileName)
{
UIElement element = control;
if (element.Dispatcher.Thread.IsAlive && !element.Dispatcher.HasShutdownStarted)
{
WriteObject(
element.Dispatcher.Invoke((Func<object>)(() =>
{
try
{
Window w = element as Window;
if (w != null && w.Content is UIElement)
{
element = ((Window)element).Content as UIElement;
}
var rtb = new RenderTargetBitmap((int)element.RenderSize.Width, (int)element.RenderSize.Height, _resolution.Width, _resolution.Height, _pixelFormat);
rtb.Render(element);
if (string.IsNullOrEmpty(imageFileName))
{
Clipboard.SetImage(rtb);
WriteWarning("No file path provided for image, screen capture placed on clipboard");
return null;
}
else
{
BitmapEncoder encoder = null;
switch (Path.GetExtension(imageFileName).ToUpperInvariant())
{
case ".BMP": { encoder = new BmpBitmapEncoder(); break; }
case ".GIF": { encoder = new GifBitmapEncoder(); break; }
case ".JPG": { encoder = new JpegBitmapEncoder(); break; }
case ".JPEG": { encoder = new JpegBitmapEncoder(); break; }
case ".PNG": { encoder = new PngBitmapEncoder(); break; }
case ".TIF": { encoder = new TiffBitmapEncoder(); break; }
case ".TIFF": { encoder = new TiffBitmapEncoder(); break; }
case ".WDP": { encoder = new WmpBitmapEncoder(); break; }
default:
{
encoder = new PngBitmapEncoder();
imageFileName = Path.Combine(Path.GetDirectoryName(imageFileName), Path.GetFileNameWithoutExtension(imageFileName) + ".png");
break;
}
}
encoder.Frames.Add(BitmapFrame.Create(rtb));
// Make sure .Net is thinking the same thing as PowerShell
var now = Environment.CurrentDirectory;
Environment.CurrentDirectory = base.CurrentProviderLocation("FileSystem").ProviderPath;
int i = 0;
var fileName = imageFileName;
while (File.Exists(fileName))
{
fileName = Path.GetFileNameWithoutExtension(imageFileName) + String.Format(CultureInfo.InvariantCulture, "{0:000}", i++) + Path.GetExtension(imageFileName);
}
using(var stream = File.Create(Path.Combine(Path.GetDirectoryName(imageFileName), fileName)))
{
encoder.Save(stream);
}
Environment.CurrentDirectory = now;
return new FileInfo(fileName);
}
}
catch (Exception ex)
{
return new ErrorRecord(ex, "ScreenCaptureError", ErrorCategory.InvalidOperation, element);
}
})));
}
else
{
WriteError(new ErrorRecord(new System.Threading.ThreadStateException("Can't take screenshot of a window that's not running"), "WindowStopped", ErrorCategory.ResourceUnavailable, element));
}
}
private void CreateAndShowMainWindow()
{
// Create the application's main window
_mainWindow = new Window {Title = "WDP Imaging Sample"};
var mySv = new ScrollViewer();
var width = 128;
var height = width;
var stride = width/8;
var pixels = new byte[height*stride];
// Define the image palette
var myPalette = BitmapPalettes.WebPalette;
// Creates a new empty image with the pre-defined palette
var image = BitmapSource.Create(
width,
height,
96,
96,
PixelFormats.Indexed1,
myPalette,
pixels,
stride);
var stream = new FileStream("new.wdp", FileMode.Create);
var encoder = new WmpBitmapEncoder();
var myTextBlock = new TextBlock {Text = "Codec Author is: " + encoder.CodecInfo.Author};
encoder.Frames.Add(BitmapFrame.Create(image));
encoder.Save(stream);
// Open a Stream and decode a WDP image
Stream imageStreamSource = new FileStream("tulipfarm.wdp", FileMode.Open, FileAccess.Read, FileShare.Read);
var decoder = new WmpBitmapDecoder(imageStreamSource, BitmapCreateOptions.PreservePixelFormat,
BitmapCacheOption.Default);
BitmapSource bitmapSource = decoder.Frames[0];
// Draw the Image
var myImage = new Image
{
Source = bitmapSource,
Stretch = Stretch.None,
Margin = new Thickness(20)
};
// Open a Uri and decode a WDP image
var myUri = new Uri("tulipfarm.wdp", UriKind.RelativeOrAbsolute);
var decoder3 = new WmpBitmapDecoder(myUri, BitmapCreateOptions.PreservePixelFormat,
BitmapCacheOption.Default);
BitmapSource bitmapSource3 = decoder3.Frames[0];
// Draw the Image
var myImage2 = new Image
{
Source = bitmapSource3,
Stretch = Stretch.None,
Margin = new Thickness(20)
};
var stream2 = new FileStream("tulipfarm.jpg", FileMode.Open);
var decoder2 = new JpegBitmapDecoder(stream2, BitmapCreateOptions.PreservePixelFormat,
BitmapCacheOption.Default);
BitmapSource bitmapSource2 = decoder2.Frames[0];
var stream3 = new FileStream("new2.wdp", FileMode.Create);
var encoder2 = new WmpBitmapEncoder();
encoder2.Frames.Add(BitmapFrame.Create(bitmapSource2));
encoder2.Save(stream3);
// Define a StackPanel to host the decoded WDP images
var myStackPanel = new StackPanel
{
Orientation = Orientation.Vertical,
VerticalAlignment = VerticalAlignment.Stretch,
HorizontalAlignment = HorizontalAlignment.Stretch
};
// Add the Image and TextBlock to the parent Grid
myStackPanel.Children.Add(myImage);
myStackPanel.Children.Add(myImage2);
myStackPanel.Children.Add(myTextBlock);
// Add the StackPanel as the Content of the Parent Window Object
mySv.Content = myStackPanel;
_mainWindow.Content = mySv;
_mainWindow.Show();
}
public void SaveImageToFile(string path)
{
string extension = Path.GetExtension(path).ToLower();
DrawingVisual dv = new DrawingVisual();
using (DrawingContext dc = dv.RenderOpen())
{
if (extension == ".bmp" || extension == "jpg")
{
dc.DrawRectangle(Brushes.White, null, new Rect(0, 0, Math.Ceiling(Width + Location.X * 2), Math.Ceiling(Width + Location.Y * 2)));
}
ActiveChild.DrawEquation(dc);
}
RenderTargetBitmap bitmap = new RenderTargetBitmap((int)(Math.Ceiling(Width + Location.X * 2)), (int)(Math.Ceiling(Height + Location.Y * 2)), 96, 96, PixelFormats.Default);
bitmap.Render(dv);
BitmapEncoder encoder = null;
switch (extension)
{
case ".jpg":
encoder = new JpegBitmapEncoder();
break;
case ".gif":
encoder = new GifBitmapEncoder();
break;
case ".bmp":
encoder = new BmpBitmapEncoder();
break;
case ".png":
encoder = new PngBitmapEncoder();
break;
case ".wdp":
encoder = new WmpBitmapEncoder();
break;
case ".tif":
encoder = new TiffBitmapEncoder();
break;
}
try
{
encoder.Frames.Add(BitmapFrame.Create(bitmap));
using (Stream s = File.Create(path))
{
encoder.Save(s);
}
}
catch
{
MessageBox.Show("File could not be saved. Please make sure the path you entered is correct", "Error");
}
}
public static void Save(this BitmapSource source, Stream stream, BitmapEncoding enc, BitmapMetadata data)
{
BitmapEncoder encorder = null;
switch (enc)
{
case BitmapEncoding.Bmp:
encorder = new BmpBitmapEncoder();
break;
case BitmapEncoding.Png:
encorder = new PngBitmapEncoder();
break;
case BitmapEncoding.Jpg:
encorder = new JpegBitmapEncoder();
break;
case BitmapEncoding.Tiff:
encorder = new TiffBitmapEncoder();
break;
case BitmapEncoding.Gif:
encorder = new GifBitmapEncoder();
break;
case BitmapEncoding.Wmp:
encorder = new WmpBitmapEncoder();
break;
case BitmapEncoding.Icon:
throw new NotSupportedException("The icon format can only load!");
default:
throw new NotImplementedException();
}
encorder.Frames.Add(BitmapFrame.Create(source));
if (data != null)
encorder.Metadata = data;
encorder.Save(stream);
}
/// <summary>
/// Gets the encoded image data.
/// </summary>
/// <param name="image">The image.</param>
/// <param name="preferredFormat">The preferred Image format.</param>
/// <param name="qualityLevel">JpegBitmapEncoder QualityLevel</param>
/// <returns></returns>
public static byte[] ToEncodedBuffer(this BitmapSource image, ImageFormat preferredFormat, int qualityLevel)
{
byte[] result = default(byte[]);
BitmapEncoder encoder = default(BitmapEncoder);
if (image == null) return null;
switch (preferredFormat)
{
case ImageFormat.JPEG:
case ImageFormat.JPG:
encoder = new JpegBitmapEncoder
{
QualityLevel = qualityLevel
};
break;
case ImageFormat.BMP:
encoder = new BmpBitmapEncoder();
break;
case ImageFormat.PNG:
encoder = new PngBitmapEncoder();
break;
case ImageFormat.TIFF:
case ImageFormat.TIF:
encoder = new TiffBitmapEncoder();
break;
case ImageFormat.GIF:
encoder = new GifBitmapEncoder();
break;
case ImageFormat.WMP:
encoder = new WmpBitmapEncoder();
break;
}
using (var stream = new MemoryStream())
{
if (encoder != null)
{
encoder.Frames.Add(BitmapFrame.Create(image));
encoder.Save(stream);
}
stream.Seek(0, SeekOrigin.Begin);
result = new byte[stream.Length];
using (var br = new BinaryReader(stream))
{
br.Read(result, 0, (int) stream.Length);
br.Close();
}
stream.Close();
return result;
}
}
