private static void CopyImage(string file, ImageFileType type)
{
string newFileFullPath = Path.Combine(destFolder, Path.GetFileName(file));
if (type == ImageFileType.Jpeg)
newFileFullPath += ".jpg";
else if (type == ImageFileType.Png)
newFileFullPath += ".png";
if (File.Exists(newFileFullPath))
return;
if (ImageHelper.IsMobileSizeImage(file))
return;
try
{
if (!Directory.Exists(destFolder))
Directory.CreateDirectory(destFolder);
File.Copy(file, newFileFullPath);
}
catch (Exception)
{
}
}
public RasterImage(BitmapSource source, ImageFileType fileType)
{
this.source = source;
this.fileType = fileType;
this.frames = new List<IFrame>(1)
{
new RasterFrame(source)
};
}
internal ImageSearchData(SearchData result, Uri refUrl, Uri refClkUrl, long fileSize, ImageFileType fileFormat, int height, int width, Uri tmbUrl, int tmbHeight, int tmbWidth)
: base(result.Title, result.Description, result.Url, result.ClickUrl)
{
mRefererUrl = refUrl;
mRefererClickUrl = refClkUrl;
mFileSize = fileSize;
mFileFormat = fileFormat;
mHeight = height;
mWidth = width;
mThumbnail = new Thumbnail(tmbUrl, tmbHeight, tmbWidth);
}
public static void Capture( GraphicsDevice device, string filePath = null, ImageFileType format = ImageFileType.Png )
{
if( filePath == null )
{
if( !Directory.Exists( defaultFolder ) )
{
Directory.CreateDirectory( defaultFolder );
}
filePath = Path.Combine( defaultFolder, defaultName + "_" + ( FileCount( defaultFolder ) + 1 ).ToString() + "." + format.ToString().ToLower() );
}
device.BackBuffer.Save( filePath, format );
}
string GetFileType (ImageFileType type)
{
switch (type) {
case ImageFileType.Bmp:
return "bmp";
case ImageFileType.Jpeg:
return "jpeg";
case ImageFileType.Png:
return "png";
default:
throw new NotSupportedException ();
}
}
internal RtfImage(string fileName, ImageFileType type)
{
_imgFname = fileName;
_imgType = type;
_alignment = Align.None;
_margins = new Margins();
_keepAspectRatio = true;
_blockHead = @"{\pard";
_blockTail = @"\par}";
_startNewPage = false;
Image image = Image.FromFile(fileName);
_width = (image.Width / image.HorizontalResolution) * 72;
_height = (image.Height / image.VerticalResolution) * 72;
}
public OutputSet(SourceImage owner, string name)
{
this.owner = owner;
this.name = name;
this.description = string.Empty;
this.expanded = true;
this.transformType = ImageTransformType.None;
this.outputType = ImageHelpers.IsBitmapType(owner.Image.FileType)
? owner.Image.FileType
: ImageFileType.DefaultRasterize;
this.images = new ObservableCollection<OutputImage>();
this.UpdateSize();
owner.PropertyChanged += this.OnOwnerPropertyChanged;
}
/// <summary>
/// Create a new image.
/// </summary>
/// <param name="Url">URL from where the image data can be fetched through a web browser (about 512 pixels).</param>
/// <param name="Thumbnail">URL from where a thumbnail of the image can be fetched through a webbrowser (about 128 pixels).</param>
/// <param name="Category">Describes what the image is used for.</param>
/// <param name="Type">Image type like: gif, jpeg, png, svg.</param>
/// <param name="Width">Width of the full scale image.</param>
/// <param name="Height">Height of the full scale image.</param>
public Image(Uri Url,
Uri Thumbnail,
ImageCategoryType Category,
ImageFileType Type,
UInt32 Width,
UInt32 Height)
{
#region Initial checks
if (Url == null)
throw new ArgumentNullException("Url", "The given parameter must not be null!");
#endregion
this._Url = Url;
this._Thumbnail = Thumbnail;
this._Category = Category;
this._Type = Type;
this._Width = Width;
this._Height = Height;
}
/// <exception cref="ArgumentNullException">
/// Thrown when a null reference is passed to a method that does not accept it as a
/// valid argument.
/// </exception>
internal string SearchGalleryAdvancedRequest(string url,
string qAll = null, string qAny = null,
string qExactly = null, string qNot = null,
ImageFileType? fileType = null, ImageSize? imageSize = null)
{
if (string.IsNullOrWhiteSpace(url))
throw new ArgumentNullException(nameof(url));
if (string.IsNullOrWhiteSpace(qAll) &&
string.IsNullOrWhiteSpace(qAny) &&
string.IsNullOrWhiteSpace(qExactly) &&
string.IsNullOrWhiteSpace(qNot))
throw new ArgumentNullException(null,
"At least one search parameter must be provided (All | Any | Exactly | Not).");
var query = new StringBuilder();
if (!string.IsNullOrWhiteSpace(qAll))
query.Append($"&q_all={WebUtility.UrlEncode(qAll)}");
if (!string.IsNullOrWhiteSpace(qAny))
query.Append($"&q_any={WebUtility.UrlEncode(qAny)}");
if (!string.IsNullOrWhiteSpace(qExactly))
query.Append($"&q_exactly={WebUtility.UrlEncode(qExactly)}");
if (!string.IsNullOrWhiteSpace(qNot))
query.Append($"&q_not={WebUtility.UrlEncode(qNot)}");
if (fileType != null)
query.Append($"&q_type={WebUtility.UrlEncode(fileType.ToString().ToLower())}");
if (imageSize != null)
query.Append($"&q_size_px={WebUtility.UrlEncode(imageSize.ToString().ToLower())}");
return $"{url}?{query}".Replace("?&", "?");
}
public string GetScaledPath(double scale, string fileNameOverride = null, ImageFileType fileTypeOverride = ImageFileType.None)
{
string path;
int insertPos = -1;
if (string.IsNullOrEmpty(fileNameOverride))
{
path = this.pathScaleLength > 0
? this.path.Remove(this.pathScaleStart, this.pathScaleLength - 1)
: this.path;
insertPos = this.pathScaleStart;
}
else
{
path = Path.Combine(this.FullDir, fileNameOverride);
insertPos = path.Length - Path.GetExtension(path).Length;
}
if (insertPos != -1 && scale > 0)
{
path = path.Insert(insertPos, $".scale-{(int)(scale * 100.0)}");
}
if (fileTypeOverride != ImageFileType.None && fileTypeOverride != this.Image.FileType)
{
string oldExtension = Path.GetExtension(path);
string newExtension = oldExtension;
switch (fileTypeOverride)
{
case ImageFileType.Bmp:
newExtension = ".bmp";
break;
case ImageFileType.Jpeg:
newExtension = ".jpg";
break;
case ImageFileType.Png:
newExtension = ".png";
break;
default:
Debug.Fail("Can't save with file extension for: " + fileTypeOverride);
break;
}
if (oldExtension != newExtension)
{
path = path.Remove(path.Length - oldExtension.Length, oldExtension.Length) + newExtension;
}
}
return path;
}
public void TestLoadAndSave()
{
var dxsdkDir = Environment.GetEnvironmentVariable("DXSDK_DIR");
if (string.IsNullOrEmpty(dxsdkDir))
throw new NotSupportedException("Install DirectX SDK June 2010 to run this test (DXSDK_DIR env variable is missing).");
GC.Collect();
GC.WaitForFullGCComplete();
testMemoryBefore = GC.GetTotalMemory(true);
var files = new List<string>();
files.AddRange(Directory.EnumerateFiles(Path.Combine(dxsdkDir, @"Samples\Media"), "*.dds", SearchOption.AllDirectories));
files.AddRange(Directory.EnumerateFiles(Path.Combine(dxsdkDir, @"Samples\Media"), "*.jpg", SearchOption.AllDirectories));
files.AddRange(Directory.EnumerateFiles(Path.Combine(dxsdkDir, @"Samples\Media"), "*.bmp", SearchOption.AllDirectories));
const int Count = 1; // Change this to perform memory benchmarks
var types = new ImageFileType[] {
ImageFileType.Dds,
};
for (int i = 0; i < Count; i++)
{
for (int j = 0; j < types.Length; j++)
{
Console.Write("[{0}] ", i);
ProcessFiles(files, types[j]);
}
}
}
private static Guid GetContainerFormatFromFileType(ImageFileType fileType)
{
switch (fileType)
{
case ImageFileType.Bmp:
return ContainerFormatGuids.Bmp;
case ImageFileType.Jpg:
return ContainerFormatGuids.Jpeg;
case ImageFileType.Gif:
return ContainerFormatGuids.Gif;
case ImageFileType.Png:
return ContainerFormatGuids.Png;
case ImageFileType.Tiff:
return ContainerFormatGuids.Tiff;
case ImageFileType.Wmp:
return ContainerFormatGuids.Wmp;
default:
throw new NotSupportedException("Format not supported");
}
}
/// <summary>
/// Saves this instance to a stream.
/// </summary>
/// <param name="imageStream">The destination stream.</param>
/// <param name="fileType">Specify the output format.</param>
/// <remarks>This method support the following format: <c>dds, bmp, jpg, png, gif, tiff, wmp, tga</c>.</remarks>
public void Save(Stream imageStream, ImageFileType fileType)
{
Save(pixelBuffers, this.pixelBuffers.Length, Description, imageStream, fileType);
}
public abstract void SaveToStream(object backend, System.IO.Stream stream, ImageFileType fileType);
public override void SaveToStream (object backend, System.IO.Stream stream, ImageFileType fileType)
{
var pix = (GtkImage)backend;
var buffer = pix.Frames[0].Pixbuf.SaveToBuffer (GetFileType (fileType));
stream.Write (buffer, 0, buffer.Length);
}
/// <summary>
/// Saves this instance to a stream.
/// </summary>
/// <param name="imageStream">The destination stream.</param>
/// <param name="fileType">Specify the output format.</param>
/// <remarks>This method support the following format: <c>dds, bmp, jpg, png, gif, tiff, wmp, tga</c>.</remarks>
public void Save(Stream imageStream, ImageFileType fileType)
{
if (imageStream == null) throw new ArgumentNullException("imageStream");
Save(pixelBuffers, this.pixelBuffers.Length, Description, imageStream, fileType);
}
public LoadSaveDelegate(ImageFileType fileType, ImageLoadDelegate load, ImageSaveDelegate save)
{
FileType = fileType;
Load = load;
Save = save;
}
/// <summary>
/// Saves this instance to a stream.
/// </summary>
/// <param name="pixelBuffers">The buffers to save.</param>
/// <param name="count">The number of buffers to save.</param>
/// <param name="description">Global description of the buffer.</param>
/// <param name="imageStream">The destination stream.</param>
/// <param name="fileType">Specify the output format.</param>
/// <remarks>This method support the following format: <c>dds, bmp, jpg, png, gif, tiff, wmp, tga</c>.</remarks>
internal static void Save(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream, ImageFileType fileType)
{
foreach (var loadSaveDelegate in loadSaveDelegates)
{
if (loadSaveDelegate.FileType == fileType)
{
loadSaveDelegate.Save(pixelBuffers, count, description, imageStream);
return;
}
}
throw new NotSupportedException("This file format is not yet implemented.");
}
/// <summary>
/// Saves this instance to a stream.
/// </summary>
/// <param name="imageStream">The destination stream.</param>
/// <param name="fileType">Specify the output format.</param>
/// <remarks>This method support the following format: <c>dds, bmp, jpg, png, gif, tiff, wmp, tga</c>.</remarks>
public void Save(Stream imageStream, ImageFileType fileType)
{
Save(pixelBuffers, this.pixelBuffers.Length, Description, imageStream, fileType);
}
private static void SaveToWICMemory(PixelBuffer[] pixelBuffer, int count, WICFlags flags, ImageFileType fileType, Stream stream)
{
if (count > 1)
{
EncodeMultiframe(pixelBuffer, count, flags, GetContainerFormatFromFileType(fileType), stream);
}
else
{
EncodeSingleFrame(pixelBuffer[0], flags, GetContainerFormatFromFileType(fileType), stream);
}
}
private void ProcessFiles(Game game, ImageFileType sourceFormat, ImageFileType intermediateFormat)
{
var testMemoryBefore = GC.GetTotalMemory(true);
Log.Info("Testing {0}", intermediateFormat);
Console.Out.Flush();
var imageCount = 0;
var clock = Stopwatch.StartNew();
// Load an image from a file and dispose it.
var fileName = sourceFormat.ToFileExtension().Substring(1) + "Image";
var filePath = "ImageTypes/" + fileName;
Image image;
using (var inStream = game.Content.OpenAsStream(filePath, StreamFlags.None))
image = Image.Load(inStream);
image.Dispose();
// Load an image from a buffer
byte[] buffer;
using (var inStream = game.Content.OpenAsStream(filePath, StreamFlags.None))
{
var bufferSize = inStream.Length;
buffer = new byte[bufferSize];
inStream.Read(buffer, 0, (int)bufferSize);
}
using (image = Image.Load(buffer))
{
// Write this image to a memory stream using DDS format.
var tempStream = new MemoryStream();
image.Save(tempStream, intermediateFormat);
tempStream.Position = 0;
// Save to a file on disk
var extension = intermediateFormat.ToFileExtension();
using (var outStream = VirtualFileSystem.ApplicationCache.OpenStream(fileName + extension, VirtualFileMode.Create, VirtualFileAccess.Write))
image.Save(outStream, intermediateFormat);
if (intermediateFormat == ImageFileType.Xenko || intermediateFormat == ImageFileType.Dds || (sourceFormat == intermediateFormat &&
intermediateFormat != ImageFileType.Gif)) // TODO: remove this when Giff compression/decompression is fixed
{
int allowSmallDifferences;
switch (intermediateFormat)
{
case ImageFileType.Tiff: // TODO: remove this when tiff encryption implementation is stable
case ImageFileType.Png: // TODO: remove this when png encryption implementation is stable
allowSmallDifferences = 1;
break;
case ImageFileType.Jpg: // TODO: remove this when jepg encryption implementation is stable
allowSmallDifferences = 30;
break;
default:
allowSmallDifferences = 0;
break;
}
// Reload the image from the memory stream.
var image2 = Image.Load(tempStream);
CompareImage(image, image2, false, allowSmallDifferences, fileName);
image2.Dispose();
}
}
imageCount++;
var time = clock.ElapsedMilliseconds;
clock.Stop();
GC.Collect();
GC.WaitForPendingFinalizers();
var testMemoryAfter = GC.GetTotalMemory(true);
Log.Info("Loaded {0} and convert to (Dds, Jpg, Png, Gif, Bmp, Tiff) image from DirectXSDK test Memory: {1} bytes, in {2}ms", imageCount, testMemoryAfter - testMemoryBefore, time);
}
public override void SaveToStream(object backend, Stream stream, ImageFileType fileType)
{
var img = (DroidImage)backend;
img.SaveToStream(stream, fileType);
}
/// <summary>
/// Creates the thumbnail image.
/// </summary>
/// <param name="originalImageEntity">The original image entity.</param>
/// <param name="thumbnailWidth">Width of the thumbnail.</param>
/// <param name="thumbnailHeight">Height of the thumbnail.</param>
/// <param name="scaleEnumAlias">The scale enum alias.</param>
/// <returns></returns>
private Stream CreateThumbnailImage(ImageFileType originalImageEntity, int thumbnailWidth, int thumbnailHeight, string scaleEnumAlias)
{
// No thumbnail was found.
// Need to create one
var thumbnailImageMemoryStream = new MemoryStream( );
// Get the original image from the database
using (Stream imageDataStream = GetImageDataStream(originalImageEntity.Id))
{
using (Image originalImage = Image.FromStream(imageDataStream))
{
using (Image thumbnailImage = new Bitmap(thumbnailWidth, thumbnailHeight))
{
using (Graphics thumbnailGraphics = Graphics.FromImage(thumbnailImage))
{
switch (scaleEnumAlias)
{
case "core:scaleImageToFit":
thumbnailGraphics.CompositingQuality = CompositingQuality.HighQuality;
thumbnailGraphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
thumbnailGraphics.SmoothingMode = SmoothingMode.HighQuality;
thumbnailGraphics.DrawImage(originalImage, new Rectangle(0, 0, thumbnailWidth, thumbnailHeight));
break;
case "core:scaleImageProportionally":
// Get the smaller of the ratio between height and width
double aspectRatioWidth = thumbnailWidth / ( double )originalImage.Width;
double aspectRatioHeight = thumbnailHeight / ( double )originalImage.Height;
double aspectRatio = aspectRatioWidth < aspectRatioHeight ? aspectRatioWidth : aspectRatioHeight;
// Calculate the target rectangle
var targetRectangle = new Rectangle
{
X = ( int )((thumbnailWidth - (originalImage.Width * aspectRatio)) / 2),
Y = ( int )((thumbnailHeight - (originalImage.Height * aspectRatio)) / 2),
Width = ( int )(originalImage.Width * aspectRatio),
Height = ( int )(originalImage.Height * aspectRatio)
};
// Calculate the source rectangle
var sourceRectangle = new Rectangle
{
X = 0,
Y = 0,
Width = originalImage.Width,
Height = originalImage.Height
};
thumbnailGraphics.Clear(Color.Transparent);
thumbnailGraphics.CompositingQuality = CompositingQuality.HighQuality;
thumbnailGraphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
thumbnailGraphics.SmoothingMode = SmoothingMode.HighQuality;
thumbnailGraphics.DrawImage(originalImage, targetRectangle, sourceRectangle, GraphicsUnit.Pixel);
break;
case "core:cropImage":
thumbnailGraphics.DrawImageUnscaled(originalImage, new Rectangle(0, 0, thumbnailWidth, thumbnailHeight));
break;
}
}
// Save the thumbnail as the same format as the original
thumbnailImage.Save(thumbnailImageMemoryStream, originalImage.RawFormat);
}
}
}
return(thumbnailImageMemoryStream);
}
public void Save(Stream stream, ImageFileType fileType)
{
ToolkitEngine.ImageBackendHandler.SaveToStream (ToBitmap ().Backend, stream, fileType);
}
public LoadSaveDelegate(ImageFileType fileType, ImageLoadDelegate load, ImageSaveDelegate save)
{
FileType = fileType;
Load = load;
Save = save;
}
public void Save(string file, ImageFileType fileType)
{
using (var f = File.OpenWrite(file))
Save(f, fileType);
}
/// <summary>
/// Request a screenshot and save it to disc.
/// </summary>
/// <param name="game">The game.</param>
/// <param name="screenShotUrl">The screenshot URL.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="pixelFormat">The pixel format.</param>
/// <param name="depthBufferFormat">The depth buffer format.</param>
/// <param name="fileType">Type of the file.</param>
/// <returns>
/// True on success
/// </returns>
public static bool SaveScreenshot(GameBase game, string screenshotUrl, int width, int height, PixelFormat pixelFormat = PixelFormat.R8G8B8A8_UNorm, PixelFormat depthBufferFormat = PixelFormat.D24_UNorm_S8_UInt, ImageFileType fileType = ImageFileType.Png)
{
var status = true;
var graphicsContext = game.GraphicsContext;
var graphicsDevice = game.GraphicsDevice;
var commandList = graphicsContext.CommandList;
var gameSystems = game.GameSystems;
var drawTime = game.DrawTime;
var previousPresenter = graphicsDevice.Presenter;
try
{
// set the master output
var renderTarget = graphicsContext.Allocator.GetTemporaryTexture2D(width, height, pixelFormat, TextureFlags.ShaderResource | TextureFlags.RenderTarget);
var depthStencil = graphicsContext.Allocator.GetTemporaryTexture2D(width, height, depthBufferFormat, TextureFlags.DepthStencil);
var tempPresenter = new RenderTargetGraphicsPresenter(graphicsDevice, renderTarget, depthStencil.ViewFormat);
try
{
// temp presenter
graphicsDevice.Presenter = tempPresenter;
// Always clear the state of the GraphicsDevice to make sure a scene doesn't start with a wrong setup
commandList.ClearState();
// render the screenshot
graphicsContext.ResourceGroupAllocator.Reset(graphicsContext.CommandList);
gameSystems.Draw(drawTime);
// write the screenshot to the file
renderTarget.SaveTexture(commandList, screenshotUrl, fileType);
}
finally
{
// Cleanup
graphicsDevice.Presenter = previousPresenter;
tempPresenter.Dispose();
graphicsContext.Allocator.ReleaseReference(depthStencil);
graphicsContext.Allocator.ReleaseReference(renderTarget);
}
}
catch (Exception e)
{
status = false;
}
return(status);
}
public void Save(Stream stream, ImageFileType fileType)
{
ToolkitEngine.ImageBackendHandler.SaveToStream(ToBitmap().Backend, stream, fileType);
}
public bool ImageFileType(ImageFileType imageFileType)
{
return(imageFileType == Enums.ImageFileType.Jpg);
}
private ImageSearchData ToBossImageSearchResult(XParseElement node)
{
SearchData result = this.ToSearchResult(node);
if (result != null)
{
Uri refererUrl = null;
Uri refererClickUrl = null;
Uri tmbUrl = null;
ImageFileType fileFormat = default(ImageFileType);
long size = 0;
int height = 0;
int width = 0;
int tmbHeight = 0;
int tmbWidth = 0;
System.Globalization.CultureInfo convCult = new System.Globalization.CultureInfo("en-US");
foreach (XParseElement prpNode in node.Elements())
{
switch (prpNode.Name.LocalName)
{
case "refererurl":
refererUrl = new Uri(prpNode.Value);
break;
case "refererclickurl":
refererClickUrl = new Uri(prpNode.Value);
break;
case "size":
double srcSize = 0;
if (prpNode.Value.EndsWith("Bytes"))
{
double.TryParse(prpNode.Value.Replace("Bytes", ""), System.Globalization.NumberStyles.Any, convCult, out srcSize);
}
else if (prpNode.Value.EndsWith("KB"))
{
double.TryParse(prpNode.Value.Replace("KB", ""), System.Globalization.NumberStyles.Any, convCult, out srcSize);
srcSize *= 1024;
}
else if (prpNode.Value.EndsWith("MB"))
{
double.TryParse(prpNode.Value.Replace("MB", ""), System.Globalization.NumberStyles.Any, convCult, out srcSize);
srcSize *= Math.Pow(1024, 2);
}
size = Convert.ToInt64(srcSize);
break;
case "format":
switch (prpNode.Value.ToLower())
{
case "bmp":
fileFormat = ImageFileType.Bmp;
break;
case "gif":
fileFormat = ImageFileType.Gif;
break;
case "jpg":
fileFormat = ImageFileType.Jpeg;
break;
case "jpeg":
fileFormat = ImageFileType.Jpeg;
break;
case "png":
fileFormat = ImageFileType.Png;
break;
default:
fileFormat = ImageFileType.Any;
break;
}
break;
case "height":
int.TryParse(prpNode.Value, out height);
break;
case "width":
int.TryParse(prpNode.Value, out width);
break;
case "thumbnailurl":
if (prpNode.Value != string.Empty)
{
tmbUrl = new Uri(prpNode.Value);
}
break;
case "thumbnailwidth":
int.TryParse(prpNode.Value, out tmbWidth);
break;
case "thumbnailheight":
int.TryParse(prpNode.Value, out tmbHeight);
break;
}
}
return(new ImageSearchData(result, refererUrl, refererClickUrl, size, fileFormat, height, width, tmbUrl, tmbHeight, tmbWidth));
}
else
{
return(null);
}
}
/// <summary>
/// Saves this instance to a file.
/// </summary>
/// <param name="fileName">The destination file.</param>
/// <param name="fileType">Specify the output format.</param>
/// <remarks>This method support the following format: <c>dds, bmp, jpg, png, gif, tiff, wmp, tga</c>.</remarks>
public void Save(string fileName, ImageFileType fileType)
{
using (var imageStream = new NativeFileStream(fileName, NativeFileMode.Create, NativeFileAccess.Write))
{
Save(imageStream, fileType);
}
}
public async Task <string> Save(string filePath, string outputFolder, ImageFileType type)
{
throw new NotImplementedException();
}
private static void imageToPdf(Stream streamToConvert, Stream resultStream, ImageFileType imageFileType)
{
var pdfDocument = new Pdf();
var pdfDocumentSection = pdfDocument.Sections.Add();
var image = new Image(pdfDocumentSection)
{
ImageInfo =
{
ImageFileType = imageFileType,
ImageStream = streamToConvert
}
};
pdfDocumentSection.Paragraphs.Add(image);
pdfDocument.Save(resultStream);
streamToConvert.Close();
}
public void TestLoadAndSave()
{
GC.Collect();
GC.WaitForFullGCComplete();
testMemoryBefore = GC.GetTotalMemory(true);
var files = new List<string>();
files.AddRange(Directory.EnumerateFiles(Path.Combine(dxsdkDir, @"Samples\Media"), "*.dds", SearchOption.AllDirectories));
files.AddRange(Directory.EnumerateFiles(Path.Combine(dxsdkDir, @"Samples\Media"), "*.jpg", SearchOption.AllDirectories));
files.AddRange(Directory.EnumerateFiles(Path.Combine(dxsdkDir, @"Samples\Media"), "*.bmp", SearchOption.AllDirectories));
const int Count = 1; // Change this to perform memory benchmarks
var types = new ImageFileType[] {
ImageFileType.Dds,
ImageFileType.Jpg,
ImageFileType.Png,
////ImageFileType.Gif,
////ImageFileType.Bmp,
ImageFileType.Tiff,
ImageFileType.Tktx,
};
for (int i = 0; i < Count; i++)
{
for (int j = 0; j < types.Length; j++)
{
Console.Write("[{0}] ", i);
ProcessFiles(files, types[j]);
}
}
}
private static void SaveToWICMemory(PixelBuffer[] pixelBuffer, int count, WICFlags flags, ImageFileType fileType, Stream stream)
{
if (count > 1)
EncodeMultiframe(pixelBuffer, count, flags, GetContainerFormatFromFileType(fileType), stream);
else
EncodeSingleFrame(pixelBuffer[0], flags, GetContainerFormatFromFileType(fileType), stream);
}
public abstract void SaveToStream(object backend, System.IO.Stream stream, ImageFileType fileType);
private void ProcessFiles(IEnumerable<string> files, ImageFileType intermediateFormat)
{
Console.WriteLine("Testing {0}", intermediateFormat);
Console.Out.Flush();
int imageCount = 0;
var clock = Stopwatch.StartNew();
foreach (var file in files)
{
// Load an image from a file and dispose it.
Image image;
using (var inStream = File.OpenRead(file))
image = Image.Load(inStream);
image.Dispose();
// Load an image from a buffer
var buffer = File.ReadAllBytes(file);
using (image = Image.Load(buffer))
{
// Write this image to a memory stream using DDS format.
var tempStream = new MemoryStream();
image.Save(tempStream, intermediateFormat);
tempStream.Position = 0;
// Save to a file on disk
var name = Enum.GetName(typeof(ImageFileType), intermediateFormat).ToLower();
using (var outStream = File.OpenWrite(Path.ChangeExtension(Path.GetFileName(file), name)))
image.Save(outStream, intermediateFormat);
if (intermediateFormat == ImageFileType.Dds)
{
// Reload the image from the memory stream.
var image2 = Image.Load(tempStream);
CompareImage(image, image2, file);
image2.Dispose();
}
}
imageCount++;
}
var time = clock.ElapsedMilliseconds;
clock.Stop();
GC.Collect();
GC.WaitForPendingFinalizers();
var testMemoryAfter = GC.GetTotalMemory(true);
Console.WriteLine("Loaded {0} and convert to (Dds, Jpg, Png, Gif, Bmp, Tiff) image from DirectXSDK test Memory: {1} bytes, in {2}ms", imageCount, testMemoryAfter - testMemoryBefore, time);
}
public HttpResponseMessage GetImageThumbnail(string imageId, string sizeId, string scaleId)
{
using (Profiler.Measure("ImageController.GetImageThumbnail"))
{
EntityRef imageIdRef = WebApiHelpers.GetIdWithDashedAlias(imageId);
EntityRef sizeIdRef = WebApiHelpers.GetIdWithDashedAlias(sizeId);
EntityRef scaleIdRef = WebApiHelpers.GetIdWithDashedAlias(scaleId);
var imageInterface = new ImageInterface();
imageInterface.PreloadImageThumbnail(imageIdRef);
ImageFileType thumbnailImage = imageInterface.GetImageThumbnail(imageIdRef, sizeIdRef, scaleIdRef);
if (thumbnailImage == null)
{
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}
string dataHash = thumbnailImage.FileDataHash;
// Get the entity tag, which is the hash of the image data + dimensions + scaling
string etag = string.Format("\"{0}\"", imageInterface.GetImageThumbnailETag(dataHash, sizeIdRef, scaleIdRef));
// If the request contains the same e-tag then return a not modified
if (Request.Headers.IfNoneMatch != null &&
Request.Headers.IfNoneMatch.Any(et => et.Tag == etag))
{
var notModifiedResponse = new HttpResponseMessage(HttpStatusCode.NotModified);
notModifiedResponse.Headers.ETag = new EntityTagHeaderValue(etag, false);
notModifiedResponse.Headers.CacheControl = new CacheControlHeaderValue
{
MustRevalidate = true,
MaxAge = GetCacheMaxAge( )
};
return(notModifiedResponse);
}
Stream imageDataStream;
try
{
imageDataStream = imageInterface.GetImageDataStream(dataHash);
}
catch (FileNotFoundException)
{
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}
if (imageDataStream == null)
{
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}
// Return the image
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StreamContent(imageDataStream)
};
response.Headers.ETag = new EntityTagHeaderValue(etag, false);
response.Headers.CacheControl = new CacheControlHeaderValue
{
MustRevalidate = true,
MaxAge = GetCacheMaxAge( )
};
response.Content.Headers.ContentType = new MediaTypeHeaderValue(GetImageMediaType(thumbnailImage.FileExtension));
return(response);
}
}
public void Save(string file, ImageFileType fileType)
{
using (var f = File.OpenWrite (file))
Save (f, fileType);
}
/// <summary>
/// Add an image to this container.
/// </summary>
/// <param name="imgFname">Filename of the image.</param>
/// <param name="imgType">File type of the image.</param>
/// <returns>Image being added.</returns>
public RtfImage addImage(string imgFname, ImageFileType imgType)
{
if (!_allowImage) {
throw new Exception("Image is not allowed.");
}
RtfImage block = new RtfImage(imgFname, imgType);
addBlock(block);
return block;
}
/// <summary>
/// Gets an array of valid file extensions used by iView.NET, specified by
/// the image file type enumeration.
/// </summary>
/// <param name="nImageType">Specifies the type of file extensions to return.</param>
/// <returns></returns>
public static string[] GetFileExtensions(ImageFileType nImageType)
{
switch (nImageType)
{
case ImageFileType.All:
return new string[] { BMP, GIF, ICON, JPE, JPG, JPEG, PNG, TIF, TIFF };
case ImageFileType.Bmp:
return new string[] { BMP };
case ImageFileType.Gif:
return new string[] { GIF };
case ImageFileType.Icon:
return new string[] { ICON };
case ImageFileType.Jpeg:
return new string[] { JPE, JPG, JPEG };
case ImageFileType.Png:
return new string[] { PNG };
case ImageFileType.Tiff:
return new string[] { TIF, TIFF };
}
return null;
}
public override void SaveToStream(object backend, System.IO.Stream stream, ImageFileType fileType)
{
NSImage img = backend as NSImage;
if (img == null)
throw new NotSupportedException ();
var imageData = img.AsTiff ();
var imageRep = (NSBitmapImageRep) NSBitmapImageRep.ImageRepFromData (imageData);
var props = new NSDictionary ();
imageData = imageRep.RepresentationUsingTypeProperties (fileType.ToMacFileType (), props);
using (var s = imageData.AsStream ()) {
s.CopyTo (stream);
}
}
/// <summary>
/// Registers a loader/saver for a specified image file type.
/// </summary>
/// <param name="type">The file type (use integer and explicit casting to <see cref="ImageFileType"/> to register other fileformat.</param>
/// <param name="loader">The loader delegate (can be null).</param>
/// <param name="saver">The saver delegate (can be null).</param>
/// <exception cref="System.ArgumentException"></exception>
public static void Register(ImageFileType type, ImageLoadDelegate loader, ImageSaveDelegate saver)
{
// If reference equals, then it is null
if (ReferenceEquals(loader, saver))
throw new ArgumentNullException("Can set both loader and saver to null", "loader/saver");
var newDelegate = new LoadSaveDelegate(type, loader, saver);
for (int i = 0; i < loadSaveDelegates.Count; i++)
{
var loadSaveDelegate = loadSaveDelegates[i];
if (loadSaveDelegate.FileType == type)
{
loadSaveDelegates[i] = newDelegate;
return;
}
}
loadSaveDelegates.Add(newDelegate);
}
private void SaveAndCompareTexture(Image outputImage, string fileName, ImageFileType extension = ImageFileType.Png)
{
// save
Directory.CreateDirectory(ImageOutputPath);
outputImage.Save(new FileStream(ImageOutputPath + fileName + extension.ToFileExtension(), FileMode.Create), extension);
// Compare
using(var texTool = new TextureTool())
{
var referenceImage = LoadImage(texTool, new UFile(GoldImagePath + "/" + fileName + extension.ToFileExtension()));
Assert.IsTrue(CompareImages(outputImage, referenceImage), "The texture outputted differs from the gold image.");
}
}
/// <summary>
/// Saves this instance to a stream.
/// </summary>
/// <param name="pixelBuffers">The buffers to save.</param>
/// <param name="count">The number of buffers to save.</param>
/// <param name="description">Global description of the buffer.</param>
/// <param name="imageStream">The destination stream.</param>
/// <param name="fileType">Specify the output format.</param>
/// <remarks>This method support the following format: <c>dds, bmp, jpg, png, gif, tiff, wmp, tga</c>.</remarks>
internal static void Save(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream, ImageFileType fileType)
{
foreach (var loadSaveDelegate in loadSaveDelegates)
{
if (loadSaveDelegate.FileType == fileType)
{
loadSaveDelegate.Save(pixelBuffers, count, description, imageStream);
return;
}
}
throw new NotSupportedException("This file format is not yet implemented.");
}
private void OnEnable()
{
path = EditorPrefs.GetString(EditorCommon.GetProjectRelatedEditorPrefsKey(EDITOR_PREF_PATH_KEYS), "Assets/");
size = EditorPrefs.GetInt(EditorCommon.GetProjectRelatedEditorPrefsKey(EDITOR_PREF_SIZE_KEYS), 512);
fileType = (ImageFileType)EditorPrefs.GetInt(EditorCommon.GetProjectRelatedEditorPrefsKey(EDITOR_PREF_FILE_TYPE_KEYS), 0);
}
