public async Task <SoftwareBitmap> GetSampleBitmap()
{
FileOpenPicker fileOpenPicker = new FileOpenPicker();
fileOpenPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
fileOpenPicker.FileTypeFilter.Add(".jpg");
fileOpenPicker.ViewMode = PickerViewMode.Thumbnail;
var inputFile = await fileOpenPicker.PickSingleFileAsync();
if (inputFile == null)
{
// The user cancelled the picking operation
return(null);
}
using (IRandomAccessStream stream = await inputFile.OpenAsync(FileAccessMode.Read))
{
// Create the decoder from the stream
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
// Get the SoftwareBitmap representation of the file
return(await decoder.GetSoftwareBitmapAsync());
}
}
/// <summary>
/// Decode an image file into a VideoFrame
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
private async Task GetFrameFromFileAsync(StorageFile file)
{
// Decoding image file content into a SoftwareBitmap, and wrap into VideoFrame
SoftwareBitmap softwareBitmap = null;
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read))
{
// Create the decoder from the stream
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
// Get the SoftwareBitmap representation of the file in BGRA8 format
softwareBitmap = await decoder.GetSoftwareBitmapAsync();
// Convert to preferred format if specified and encapsulate the image in a VideoFrame instance
var convertedSoftwareBitmap = m_desiredImageDescriptor == null?SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore)
: SoftwareBitmap.Convert(softwareBitmap, m_desiredImageDescriptor.SupportedBitmapPixelFormat, m_desiredImageDescriptor.SupportedBitmapAlphaMode);
m_videoFrame = VideoFrame.CreateWithSoftwareBitmap(convertedSoftwareBitmap);
}
// Extract frame dimensions
FrameWidth = (uint)softwareBitmap.PixelWidth;
FrameHeight = (uint)softwareBitmap.PixelHeight;
}
private async Task <string> ReencodeAndSavePhotoAsync(IRandomAccessStream stream, PhotoOrientation photoOrientation)
{
using (var inputStream = stream)
{
var decoder = await BitmapDecoder.CreateAsync(inputStream);
var file = await ApplicationData.Current.LocalFolder.CreateFileAsync("photo.jpeg", CreationCollisionOption.GenerateUniqueName);
using (var outputStream = await file.OpenAsync(FileAccessMode.ReadWrite))
{
var encoder = await BitmapEncoder.CreateForTranscodingAsync(outputStream, decoder);
var properties = new BitmapPropertySet {
{ "System.Photo.Orientation", new BitmapTypedValue(photoOrientation, PropertyType.UInt16) }
};
await encoder.BitmapProperties.SetPropertiesAsync(properties);
await encoder.FlushAsync();
}
return(file.Path);
}
}
public async Task <ImageSource> InitializeAsync(IRandomAccessStream streamSource)
{
var bitmapDecoder = await BitmapDecoder.CreateAsync(BitmapDecoder.GifDecoderId, streamSource);
var imageProperties = await RetrieveImagePropertiesAsync(bitmapDecoder);
var frameProperties = new List <FrameProperties>();
for (var i = 0u; i < bitmapDecoder.FrameCount; i++)
{
var bitmapFrame = await bitmapDecoder.GetFrameAsync(i);
frameProperties.Add(await RetrieveFramePropertiesAsync(bitmapFrame));
}
_frameProperties = frameProperties;
_bitmapDecoder = bitmapDecoder;
_imageProperties = imageProperties;
CreateCanvasResources();
_isInitialized = true;
return(_canvasImageSource);
}
private async void SetImportPath(object sender, RoutedEventArgs e)
{
FileOpenPicker fileOpenPicker = new FileOpenPicker
{
ViewMode = PickerViewMode.Thumbnail,
SuggestedStartLocation = PickerLocationId.PicturesLibrary
};
fileOpenPicker.FileTypeFilter.Add(".bmp");
StorageFile image = await fileOpenPicker.PickSingleFileAsync();
if (image != null)
{
using (IRandomAccessStream stream = await image.OpenAsync(FileAccessMode.Read))
{
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
this.PixelData = await decoder.GetPixelDataAsync();
this.Bitmap = await decoder.GetSoftwareBitmapAsync();
if (this.Bitmap.BitmapPixelFormat != BitmapPixelFormat.Bgra8 || this.Bitmap.BitmapAlphaMode == BitmapAlphaMode.Straight)
{
this.Bitmap = SoftwareBitmap.Convert(this.Bitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
}
}
SoftwareBitmapSource source = new SoftwareBitmapSource();
await source.SetBitmapAsync(this.Bitmap);
this.ImagePreview.Source = source;
this.ImportName = image.Name;
this.ImportPath.Text = image.Path;
this.StartButton.IsEnabled = true;
}
}
/// <inheritdoc/>
public async Task <string> WriteBitmapAsync(Stream stream, string nameWithExt)
{
StorageFile storageFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(
nameWithExt,
CreationCollisionOption.ReplaceExisting);
// ref: https://codedocu.com/Details?d=1592&a=9&f=181&l=0&v=d
using (IRandomAccessStream s = stream.AsRandomAccessStream())
{
// Create the decoder from the stream
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(s);
// Get the SoftwareBitmap representation of the file
var softwareBitmap = await decoder.GetSoftwareBitmapAsync();
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, await storageFile.OpenAsync(FileAccessMode.ReadWrite));
encoder.SetSoftwareBitmap(softwareBitmap);
await encoder.FlushAsync();
return(storageFile.Path);
}
}
/// <summary>
/// Extracts the pixel data from file.
/// </summary>
/// <param name="file">The file.</param>
/// <returns>The byte array of pixel information from the file</returns>
public static async Task <byte[]> ExtractPixelDataFromFile(StorageFile file)
{
var copyBitmapImage = await FileBitmapConverter.ConvertFileToBitmap(file);
using (var fileStream = await file.OpenAsync(FileAccessMode.Read))
{
var decoder = await BitmapDecoder.CreateAsync(fileStream);
var transform = new BitmapTransform {
ScaledWidth = Convert.ToUInt32(copyBitmapImage.PixelWidth),
ScaledHeight = Convert.ToUInt32(copyBitmapImage.PixelHeight)
};
var pixelData = await decoder.GetPixelDataAsync(
BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Straight,
transform,
ExifOrientationMode.IgnoreExifOrientation,
ColorManagementMode.DoNotColorManage
);
return(pixelData.DetachPixelData());
}
}
private async Task<StorageFile> RescaleImage(StorageFile sourceFile, StorageFile resizedImageFile, uint width, uint height)
{
var writeableBitmap = new WriteableBitmap(1, 1);
using (var stream = await sourceFile.OpenReadAsync())
await writeableBitmap.SetSourceAsync(stream);
using (var imageStream = await sourceFile.OpenReadAsync())
{
var decoder = await BitmapDecoder.CreateAsync(imageStream);
using (var sourceStream = writeableBitmap.PixelBuffer.AsStream())
using (var resizedStream = await resizedImageFile.OpenAsync(FileAccessMode.ReadWrite))
{
var buffer = new byte[sourceStream.Length];
await sourceStream.ReadAsync(buffer, 0, buffer.Length);
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, resizedStream);
encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied, width, height, 96.0, 96.0, buffer);
encoder.BitmapTransform.InterpolationMode = BitmapInterpolationMode.NearestNeighbor;
encoder.BitmapTransform.ScaledWidth = width;
encoder.BitmapTransform.ScaledHeight = height;
await encoder.FlushAsync();
}
}
return resizedImageFile;
}
private async Task <Stream> ConvertToJpeg(IRandomAccessStream stream)
{
var decoder = await BitmapDecoder.CreateAsync(stream);
var pixels = await decoder.GetPixelDataAsync();
var outStream = new InMemoryRandomAccessStream();
// create encoder for saving the tile image
var propertySet = new BitmapPropertySet();
// create class representing target jpeg quality - a bit obscure, but it works
var qualityValue = new BitmapTypedValue(.7, PropertyType.Single);
propertySet.Add("ImageQuality", qualityValue);
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, outStream);
encoder.SetPixelData(decoder.BitmapPixelFormat, BitmapAlphaMode.Ignore,
decoder.OrientedPixelWidth, decoder.OrientedPixelHeight,
decoder.DpiX, decoder.DpiY,
pixels.DetachPixelData());
await encoder.FlushAsync();
return(outStream.AsStream());
}
private static async Task <string> OCRInternal(Bitmap bmp, string languageTag)
{
Language language = new Language(languageTag);
if (!OcrEngine.IsLanguageSupported(language))
{
throw new Exception($"{language.LanguageTag} is not supported in this system.");
}
OcrEngine engine = OcrEngine.TryCreateFromLanguage(language);
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
bmp.Save(stream.AsStream(), ImageFormat.Bmp);
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
using (SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync())
{
OcrResult ocrResult = await engine.RecognizeAsync(softwareBitmap);
return(string.Join("\r\n", ocrResult.Lines.Select(x => x.Text)));
}
}
}
private async void SaveEdit(object sender, RoutedEventArgs e)
{
if (grdImageEditor.DataContext != null && grdImageEditor.DataContext is ViewImageEditorMetadata)
{
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
// get bits from edited image
await imgCropper.SaveAsync(stream, BitmapFileFormat.Jpeg, true);
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
var editedBitmap = await decoder.GetSoftwareBitmapAsync();
// create bitmaps for persisting in models
var source = new SoftwareBitmapSource();
await source.SetBitmapAsync(FixBitmapForBGRA8(editedBitmap));
// store bitmap in models
var currentSelectedSnapshot = (ViewImageEditorMetadata)grdImageEditor.DataContext;
currentSelectedSnapshot.Bitmap = editedBitmap;
currentSelectedSnapshot.Source = source;
// force col to be updated
for (int i = 0; i < snapshots.Count(); i++)
{
if (snapshots[i].Number == currentSelectedSnapshot.Number)
{
snapshots[i] = currentSelectedSnapshot;
break;
}
}
SendSystemNotification("Snapshot updated!");
}
}
}
private async void AppBarButton_Click(object sender, RoutedEventArgs e)
{
FileOpenPicker openPicker = new FileOpenPicker();
openPicker.ViewMode = PickerViewMode.Thumbnail;
openPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
openPicker.FileTypeFilter.Add(".jpg");
openPicker.FileTypeFilter.Add(".jpeg");
openPicker.FileTypeFilter.Add(".png");
openPicker.FileTypeFilter.Add(".gif");
openPicker.FileTypeFilter.Add(".tiff");
openPicker.FileTypeFilter.Add(".bmp");
StorageFile file = await openPicker.PickSingleFileAsync();
CurrentPic = file;
if (file != null)
{
SoftwareBitmap softwareBitmap;
IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read);
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
softwareBitmap = await decoder.GetSoftwareBitmapAsync();
if (softwareBitmap.BitmapPixelFormat != BitmapPixelFormat.Bgra8 ||
softwareBitmap.BitmapAlphaMode == BitmapAlphaMode.Straight)
{
softwareBitmap = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
}
var source = new SoftwareBitmapSource();
await source.SetBitmapAsync(softwareBitmap);
personPic.ProfilePicture = source;
}
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
//File picker
var fileOpenPicker = new FileOpenPicker();
fileOpenPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
fileOpenPicker.FileTypeFilter.Add(".bmp");
fileOpenPicker.FileTypeFilter.Add(".jpg");
fileOpenPicker.FileTypeFilter.Add(".png");
fileOpenPicker.ViewMode = PickerViewMode.Thumbnail;
var selectedStorageFile = await fileOpenPicker.PickSingleFileAsync();
//Check file selected
if (selectedStorageFile == null)
{
return;
}
SoftwareBitmap softwareBitmap;
using (var stream = await selectedStorageFile.OpenAsync(FileAccessMode.Read))
{
// Create the decoder from the stream
var decoder = await BitmapDecoder.CreateAsync(stream);
// Get the SoftwareBitmap representation of the file in BGRA8 format
softwareBitmap = await decoder.GetSoftwareBitmapAsync();
softwareBitmap = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Premultiplied);
}
var inputImage = VideoFrame.CreateWithSoftwareBitmap(softwareBitmap);
EvaluateVideoFrameAsync(inputImage);
}
private async Task <SoftwareBitmap> CreateFromBitmap(SoftwareBitmap softwareBitmap, uint width, uint heigth, byte[] data)
{
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, stream);
encoder.SetSoftwareBitmap(softwareBitmap);
encoder.BitmapTransform.InterpolationMode = BitmapInterpolationMode.Linear;
var ancho = width * (0.2);
var alto = heigth * (0.2);
encoder.BitmapTransform.ScaledWidth = (uint)ancho;
encoder.BitmapTransform.ScaledHeight = (uint)alto;
await encoder.FlushAsync();
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
return(await decoder.GetSoftwareBitmapAsync(softwareBitmap.BitmapPixelFormat, softwareBitmap.BitmapAlphaMode));
}
}
// http://stackoverflow.com/questions/39618846/xamarin-forms-image-to-from-irandomaccessstreamreference/39632398#39632398
public static async Task <RandomAccessStreamReference> ScaleTo(this IRandomAccessStreamReference imageStream, uint width, uint height)
{
using (IRandomAccessStream fileStream = await imageStream.OpenReadAsync())
{
var decoder = await BitmapDecoder.CreateAsync(fileStream);
//create a RandomAccessStream as output stream
var memStream = new InMemoryRandomAccessStream();
//creates a new BitmapEncoder and initializes it using data from an existing BitmapDecoder
BitmapEncoder encoder = await BitmapEncoder.CreateForTranscodingAsync(memStream, decoder);
//resize the image
encoder.BitmapTransform.ScaledWidth = width;
encoder.BitmapTransform.ScaledHeight = height;
encoder.BitmapTransform.InterpolationMode = BitmapInterpolationMode.Cubic;
//commits and flushes all of the image data
await encoder.FlushAsync();
//return the output stream as RandomAccessStreamReference
return(RandomAccessStreamReference.CreateFromStream(memStream));
}
}
public static async Task <List <ColorThiefDotNet.QuantizedColor> > GeneratePalette(Uri path)
{
if (path == null)
{
throw new ArgumentNullException();
}
//get the file
if (path.IsFile)
{
var file = await StorageFile.GetFileFromPathAsync(path.LocalPath);
using (IRandomAccessStream stream = await file.OpenReadAsync())
{
var decoder = await BitmapDecoder.CreateAsync(stream);
return(await colorThief.GetPalette(decoder, 8, 1, false));
}
}
else
{
try
{
RandomAccessStreamReference random = RandomAccessStreamReference.CreateFromUri(path);
using (IRandomAccessStream stream = await random.OpenReadAsync())
{
var decoder = await BitmapDecoder.CreateAsync(stream);
return(await colorThief.GetPalette(decoder, 8, 1, false));
}
}
catch (Exception)
{
return(null);
}
}
}
/*
* Metodo responsavel por capturar uma imagem e enviar a MainPage
* Mais informações: https://docs.microsoft.com/pt-br/windows/uwp/audio-video-camera/capture-photos-and-video-with-cameracaptureui
*/
private async void take_photo(object sender, RoutedEventArgs e)
{
try
{
//Captura assincrona
photo = await this.captureUI.CaptureFileAsync(CameraCaptureUIMode.Photo);
// Se o Usuario cancelou a captura da foto
if (photo == null)
{
return;
}
else
{
//Carrego a foto
this.imageStream = await photo.OpenAsync(FileAccessMode.Read);
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(imageStream);
SoftwareBitmap softBitmap = await decoder.GetSoftwareBitmapAsync();
//Converto com as exigencias de exibição na pagina XAML
SoftwareBitmap softBitmapBGR8 = SoftwareBitmap.Convert(softBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
SoftwareBitmapSource bitmapSource = new SoftwareBitmapSource();
await bitmapSource.SetBitmapAsync(softBitmapBGR8);
//Anexo ao campo "image" a foto armazenada
image.Source = bitmapSource;
}
}
catch
{
//Envio a mensagem de erro pelo campo text que criei na tela
output.Text = "Erro: taking photo";
}
}
private static async Task <WriteableBitmap> read()
{
using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read))
{
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(BitmapDecoder.JpegDecoderId, stream);
uint width = decoder.PixelWidth;
uint height = decoder.PixelHeight;
if (angle % 180 != 0)
{
width = decoder.PixelHeight;
height = decoder.PixelWidth;
}
Dictionary <int, BitmapRotation> angles = new Dictionary <int, BitmapRotation>()
{
{ 0, BitmapRotation.None },
{ 90, BitmapRotation.Clockwise90Degrees },
{ 180, BitmapRotation.Clockwise180Degrees },
{ 270, BitmapRotation.Clockwise270Degrees },
{ 360, BitmapRotation.None }
};
BitmapTransform transform = new BitmapTransform();
transform.Rotation = angles[angle];
PixelDataProvider data = await decoder.GetPixelDataAsync(
BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, transform,
ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage);
bitmap = new WriteableBitmap((int)width, (int)height);
byte[] buffer = data.DetachPixelData();
using (Stream pixels = bitmap.PixelBuffer.AsStream())
{
pixels.Write(buffer, 0, (int)pixels.Length);
}
}
return(bitmap);
}
private async void DetectObjectPoseFromPicFile(StorageFile inputFile)
{
openedFile = inputFile;
var file = inputFile;
//var transform = new BitmapTransform() { ScaledWidth = 416, ScaledHeight = 416, InterpolationMode = BitmapInterpolationMode.Fant };
using (var stream = await file.OpenAsync(FileAccessMode.Read))
{
BitmapSource bitmapSource = new BitmapImage();
bitmapSource.SetSource(stream);
InputImage.Source = bitmapSource;
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
using (var imageTensor = await ConvertImageToTensorAsync(decoder).ConfigureAwait(true))
using (var input = new SingelObjectApeModelV8Input()
{
Image = imageTensor
})
using (var output = await model.EvaluateAsync(input).ConfigureAwait(true))
{
var shape = output.Grid.Shape;
var content = output.Grid.GetAsVectorView().ToArray();
List <float[]> rawOutput = new List <float[]>
{
content
};
using (OutputParser outputParser = new OutputParser(rawOutput, classCount, anchorCount, confThresh))
{
var boxes = outputParser.BoundingBoxes;
DrawBoxes(stream, boxes);
}
}
}
}
//public static async Task<byte[]> SaveToBytesAsync(ImageSource imageSource)
//{
// BitmapImage source = imageSource as BitmapImage;
// StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(source.UriSource);
// using (var inputStream = await file.OpenSequentialReadAsync())
// {
// var readStream = inputStream.AsStreamForRead();
// var byteArray = new byte[readStream.Length];
// await readStream.ReadAsync(byteArray, 0, byteArray.Length);
// return byteArray;
// }
//}
//public static byte[] SavetoBytes(ImageSource imageSource)
//{
// WriteableBitmap source = imageSource as WriteableBitmap;
// var byteArray = source.PixelBuffer;
// return byteArray.ToArray();
//}
//public static byte[] ImageSourceToBytes(BitmapEncoder encoder, ImageSource imageSource)
//{
// byte[] bytes = null;
// var bitmapSource = imageSource as BitmapSource;
// if (bitmapSource != null)
// {
// encoder.Frames.Add(BitmapFrame.Create(bitmapSource));
// using (var stream = new MemoryStream())
// {
// encoder.Save(stream);
// bytes = stream.ToArray();
// }
// }
// return bytes;
//}
//public static Byte[] ImageToByte(WriteableBitmap imageSource)
//{
// Stream stream = imageSource.PixelBuffer.AsStream();
// Byte[] buffer = null;
// if (stream != null && stream.Length > 0)
// {
// using (BinaryReader br = new BinaryReader(stream))
// {
// buffer = br.ReadBytes((Int32)stream.Length);
// }
// }
// return buffer;
//}
public static async Task <ImageSource> SaveToImageSource(byte[] imageBuffer)
{
ImageSource imageSource = null;
try
{
using (MemoryStream stream = new MemoryStream(imageBuffer))
{
var ras = stream.AsRandomAccessStream();
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(BitmapDecoder.JpegDecoderId, ras);
var provider = await decoder.GetPixelDataAsync();
byte[] buffer = provider.DetachPixelData();
WriteableBitmap bitmap = new WriteableBitmap((int)decoder.PixelWidth, (int)decoder.PixelHeight);
await bitmap.PixelBuffer.AsStream().WriteAsync(buffer, 0, buffer.Length);
imageSource = bitmap;
}
//using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
//{
// using (DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0)))
// {
// writer.WriteBytes(imageBuffer);
// await writer.StoreAsync();
// }
// BitmapImage image = new BitmapImage();
// await image.SetSourceAsync(stream);
// return image;
//}
}
catch (Exception ex)
{
}
return(imageSource);
}
/// <summary>
/// Loads the data from an image stream and returns a new WriteableBitmap.
/// </summary>
/// <param name="stream">The stream with the image data.</param>
/// <param name="pixelFormat">The pixel format of the stream data. If Unknown is provided as param, the default format of the BitmapDecoder is used.</param>
/// <returns>A new WriteableBitmap containing the pixel data.</returns>
public static async Task <WriteableBitmap> FromStream(IRandomAccessStream stream, BitmapPixelFormat pixelFormat = BitmapPixelFormat.Unknown)
{
var decoder = await BitmapDecoder.CreateAsync(stream);
var transform = new BitmapTransform();
if (pixelFormat == BitmapPixelFormat.Unknown)
{
pixelFormat = decoder.BitmapPixelFormat;
}
var pixelData = await decoder.GetPixelDataAsync(pixelFormat, decoder.BitmapAlphaMode, transform, ExifOrientationMode.RespectExifOrientation, ColorManagementMode.ColorManageToSRgb);
var pixels = pixelData.DetachPixelData();
// Copy to WriteableBitmap
var bmp = new WriteableBitmap((int)decoder.OrientedPixelWidth, (int)decoder.OrientedPixelHeight);
using (var bmpStream = bmp.PixelBuffer.AsStream())
{
bmpStream.Seek(0, SeekOrigin.Begin);
bmpStream.Write(pixels, 0, (int)bmpStream.Length);
return(bmp);
}
}
private async void cancelButton_Click(object sender, RoutedEventArgs e)
{
title.Text = "";
detail.Text = "";
WriteableBitmap defaultimage = null;
StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/background.jpg"));
if (file != null)
{
using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read))
{
BitmapDecoder bitmapDecoder = await BitmapDecoder.CreateAsync(fileStream);
BitmapTransform dummyTransform = new BitmapTransform();
PixelDataProvider pixelDataProvider =
await bitmapDecoder.GetPixelDataAsync(BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Premultiplied, dummyTransform,
ExifOrientationMode.RespectExifOrientation,
ColorManagementMode.ColorManageToSRgb);
byte[] pixelData = pixelDataProvider.DetachPixelData();
defaultimage = new WriteableBitmap(
(int)bitmapDecoder.OrientedPixelWidth,
(int)bitmapDecoder.OrientedPixelHeight);
using (Stream pixelStream = defaultimage.PixelBuffer.AsStream())
{
await pixelStream.WriteAsync(pixelData, 0, pixelData.Length);
}
}
}
image.Source = defaultimage;
date.Date = DateTime.Today;
ViewModel.SelectedItem = null;
CUButton.Content = "Create";
}
public static async Task <StorageFile> TranscodeAsync(IRandomAccessStream imageStream, StorageFile resizedImageFile, Guid encoderId)
{
var decoder = await BitmapDecoder.CreateAsync(imageStream);
//if (decoder.FrameCount > 1)
//{
// throw new InvalidCastException();
//}
var originalPixelWidth = decoder.PixelWidth;
var originalPixelHeight = decoder.PixelHeight;
using (var resizedStream = await resizedImageFile.OpenAsync(FileAccessMode.ReadWrite))
{
var pixelData = await decoder.GetSoftwareBitmapAsync(decoder.BitmapPixelFormat, decoder.BitmapAlphaMode, new BitmapTransform(), ExifOrientationMode.RespectExifOrientation, ColorManagementMode.DoNotColorManage);
var encoder = await BitmapEncoder.CreateAsync(encoderId, resizedStream);
encoder.SetSoftwareBitmap(pixelData);
await encoder.FlushAsync();
}
return(resizedImageFile);
}
private async void OnDeferredImageRequestedHandler(DataProviderRequest request)
{
// In this delegate we provide updated Bitmap data using delayed rendering.
if (_imageFile != null)
{
// If the delegate is calling any asynchronous operations it needs to acquire
// the deferral first. This lets the system know that you are performing some
// operations that might take a little longer and that the call to SetData
// could happen after the delegate returns. Once you acquired the deferral object
// you must call Complete on it after your final call to SetData.
DataProviderDeferral deferral = request.GetDeferral();
InMemoryRandomAccessStream inMemoryStream = new InMemoryRandomAccessStream();
// Make sure to always call Complete when finished with the deferral.
try
{
// Decode the image and re-encode it at 50% width and height.
IRandomAccessStream imageStream = await _imageFile.OpenAsync(FileAccessMode.Read);
BitmapDecoder imageDecoder = await BitmapDecoder.CreateAsync(imageStream);
BitmapEncoder imageEncoder = await BitmapEncoder.CreateForTranscodingAsync(inMemoryStream, imageDecoder);
imageEncoder.BitmapTransform.ScaledWidth = (uint)(imageDecoder.OrientedPixelWidth * 0.5);
imageEncoder.BitmapTransform.ScaledHeight = (uint)(imageDecoder.OrientedPixelHeight * 0.5);
await imageEncoder.FlushAsync();
request.SetData(RandomAccessStreamReference.CreateFromStream(inMemoryStream));
}
finally
{
deferral.Complete();
}
}
}
private async void TranscodeImage_Click(object sender, RoutedEventArgs e)
{
FileSystemStorageFile Item = PhotoCollection[Flip.SelectedIndex].PhotoFile;
TranscodeImageDialog Dialog = null;
using (IRandomAccessStream OriginStream = await Item.GetRandomAccessStreamFromFileAsync(FileAccessMode.Read).ConfigureAwait(true))
{
BitmapDecoder Decoder = await BitmapDecoder.CreateAsync(OriginStream);
Dialog = new TranscodeImageDialog(Decoder.PixelWidth, Decoder.PixelHeight);
}
if (await Dialog.ShowAsync().ConfigureAwait(true) == ContentDialogResult.Primary)
{
TranscodeLoadingControl.IsLoading = true;
await GeneralTransformer.TranscodeFromImageAsync(Item, Dialog.TargetFile, Dialog.IsEnableScale, Dialog.ScaleWidth, Dialog.ScaleHeight, Dialog.InterpolationMode).ConfigureAwait(true);
await Task.Delay(1000).ConfigureAwait(true);
TranscodeLoadingControl.IsLoading = false;
}
}
private async void Gif(IRandomAccessStream fileStream)
{
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream);
BitmapFrame frame = await decoder.GetFrameAsync(0);
var frameProperties = await frame.BitmapProperties.GetPropertiesAsync(new List <string>());
var imageDescriptionProperties = await(frameProperties["/imgdesc"].Value as BitmapPropertiesView).GetPropertiesAsync(new List <string>()
{
"/Top", "/Left", "/Width", "/Height"
});
int top = Int32.Parse(imageDescriptionProperties["/Top"].Value.ToString());
int left = Int32.Parse(imageDescriptionProperties["/Left"].Value.ToString());
int width = Int32.Parse(imageDescriptionProperties["/Width"].Value.ToString());
int height = Int32.Parse(imageDescriptionProperties["/Height"].Value.ToString());
var gifControlExtensionProperties = await(frameProperties["/grctlext"].Value as BitmapPropertiesView).GetPropertiesAsync(new List <string>()
{
"/Delay", "/UserInputFlag"
});
TimeSpan delay = TimeSpan.FromSeconds(Double.Parse(gifControlExtensionProperties["/Delay"].Value.ToString()) / 100); // delay is in 1/100s of a second
bool userInputFlag = bool.Parse(gifControlExtensionProperties["/UserInputFlag"].Value.ToString());
}
public static async Task <Mat> FromStorageFile(StorageFile file)
{
using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read))
{
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream);
Size s = new Size((int)decoder.PixelWidth, (int)decoder.PixelHeight);
BitmapTransform transform = new BitmapTransform();
PixelDataProvider pixelData = await decoder.GetPixelDataAsync(
BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.IgnoreExifOrientation,
ColorManagementMode.DoNotColorManage);
byte[] sourcePixels = pixelData.DetachPixelData();
GCHandle handle = GCHandle.Alloc(sourcePixels, GCHandleType.Pinned);
using (Image <Bgra, Byte> img = new Image <Bgra, byte>(s.Width, s.Height, s.Width * 4, handle.AddrOfPinnedObject()))
{
Mat m = new Mat();
CvInvoke.CvtColor(img, m, ColorConversion.Bgra2Bgr);
handle.Free();
return(m);
}
}
}
private async void zrobFoto()
{
CameraCaptureUI captureUI = new CameraCaptureUI();
captureUI.PhotoSettings.Format = CameraCaptureUIPhotoFormat.Jpeg;
captureUI.PhotoSettings.CroppedSizeInPixels = new Size(400, 400);
captureUI.PhotoSettings.AllowCropping = true;
// nasza apka czeka, na zrobienie zdjęcia prze aplikację CameraCaptureUI
photo = await captureUI.CaptureFileAsync(CameraCaptureUIMode.Photo);
if (photo == null)
{
// Gdy klikniemy cancel na aplikacji do robienia zdjęć
return;
}
// ciąg bitów ze zdjęcia
IRandomAccessStream stream = await photo.OpenAsync(FileAccessMode.Read);
// dekodujemy na bitmapę
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
// zmieniamy rodzaj bitmapy na software
SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync();
// konwertujemy bitmape na taką, która nam odpowiada do tego zadania
SoftwareBitmap softwareBitmapBGR8 = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
// ustawaimy obiekt typu źródło bitmap i wciskamy tam nasze wcześniej skonwertowane zdjęcie
SoftwareBitmapSource bitmapSource = new SoftwareBitmapSource();
await bitmapSource.SetBitmapAsync(softwareBitmapBGR8);
// na koniec przypisujemy zdjęcie do kontrolki aby wyświetlić
imageControl.Source = bitmapSource;
}
public static async Task <StorageFile> SaveCacheFile(this IRandomAccessStreamReference reference,
string name = null)
{
var file = await ApplicationData.Current.LocalCacheFolder.CreateFileAsync(name ?? $"{new Random().Next()}.jpg", CreationCollisionOption.GenerateUniqueName);
using (var fstream = await file.OpenStreamForWriteAsync())
{
using var stream = await reference.OpenReadAsync();
var decoder = await BitmapDecoder.CreateAsync(stream);
var pixels = await decoder.GetPixelDataAsync();
var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, fstream.AsRandomAccessStream());
encoder.SetPixelData(decoder.BitmapPixelFormat, BitmapAlphaMode.Ignore,
decoder.OrientedPixelWidth, decoder.OrientedPixelHeight,
decoder.DpiX, decoder.DpiY,
pixels.DetachPixelData());
await encoder.FlushAsync();
}
return(file);
}
private static async Task <TileImageCollection> CreateTileImages(Uri imageUri)
{
var file = await StorageFile.GetFileFromApplicationUriAsync(imageUri);
var decoder = await BitmapDecoder.CreateAsync(await file.OpenAsync(FileAccessMode.Read));
WriteableBitmap squareBitmap, wideBitmap;
(Point squarePoint, Size squareSize) = GetCropDetails(decoder, 1.0);
squareBitmap = await CropBitmap.GetCroppedBitmapAsync(file, squarePoint, squareSize, 1.0);
(Point widePoint, Size wideSize) = GetCropDetails(decoder, 310.0 / 150.0);
wideBitmap = await CropBitmap.GetCroppedBitmapAsync(file, widePoint, wideSize, 1.0);
var squareFile = await ImageSaveHelper.SaveWritableBitmapToTileImageCache(squareBitmap, "square");
var wideFile = await ImageSaveHelper.SaveWritableBitmapToTileImageCache(wideBitmap, "wide");
return(new TileImageCollection
{
SquareImage = squareFile,
WideImage = wideFile,
});
}
