/// <summary>
/// Use BitmapTransform to define the region to crop, and then get the pixel data in the region.
/// If you want to get the pixel data of a scaled image, set the scaledWidth and scaledHeight
/// of the scaled image.
/// </summary>
/// <returns></returns>
async static private Task<byte[]> GetPixelData(BitmapDecoder decoder, uint startPointX, uint startPointY,
uint width, uint height, uint scaledWidth, uint scaledHeight)
{
BitmapTransform transform = new BitmapTransform();
BitmapBounds bounds = new BitmapBounds();
bounds.X = startPointX;
bounds.Y = startPointY;
bounds.Height = height;
bounds.Width = width;
transform.Bounds = bounds;
transform.ScaledWidth = scaledWidth;
transform.ScaledHeight = scaledHeight;
// Get the cropped pixels within the bounds of transform.
PixelDataProvider pix = await decoder.GetPixelDataAsync(
BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Straight,
transform,
ExifOrientationMode.IgnoreExifOrientation,
ColorManagementMode.ColorManageToSRgb);
byte[] pixels = pix.DetachPixelData();
return pixels;
}
public static async Task <string> GetFullText2(string pathToImg)
{
Bitmap bmp = new Bitmap(pathToImg);
int width = bmp.Width;
int height = bmp.Height;
using (Graphics g = Graphics.FromImage(bmp))
{
// copy rectangle from screen (doesn't include cursor)
using (var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
{
//These steps to get to a SoftwareBitmap are aweful!
bmp.Save(stream.AsStream(), System.Drawing.Imaging.ImageFormat.Bmp);//choose the specific image format by your own bitmap source
Windows.Graphics.Imaging.BitmapDecoder decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(stream);
SoftwareBitmap bitmap = await decoder.GetSoftwareBitmapAsync();
OcrResult ocrResult = await _ocrEngine.RecognizeAsync(bitmap);
for (int i = 0; i < ocrResult.Lines.Count; i++)
{
OcrLine line = ocrResult.Lines[i];
}
}
}
return(string.Empty);
}
private async void OnRecognize(object sender, RoutedEventArgs e)
{
OpenFileDialog dialog = new OpenFileDialog();
if (dialog.ShowDialog() == true)
{
string fileName = dialog.FileName;
var selectedStorageFile = await StorageFile.GetFileFromPathAsync(dialog.FileName);
SoftwareBitmap softwareBitmap;
using (IRandomAccessStream stream = await selectedStorageFile.OpenAsync(FileAccessMode.Read))
{
// Create the decoder from the stream
Windows.Graphics.Imaging.BitmapDecoder decoder = await Windows.Graphics.Imaging.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);
}
// Display the image
//SoftwareBitmapSource imageSource = new SoftwareBitmapSource();
//await imageSource.SetBitmapAsync(softwareBitmap);
//PreviewImage.Source = imageSource;
PreviewImage.Source = new System.Windows.Media.Imaging.BitmapImage(new Uri(fileName));
// Encapsulate the image in the WinML image type (VideoFrame) to be bound and evaluated
VideoFrame inputImage = VideoFrame.CreateWithSoftwareBitmap(softwareBitmap);
await EvaluateVideoFrameAsync(inputImage);
}
}
private async void OnCaptureButton_Click(Object sender, RoutedEventArgs e)
{
Visibility = Visibility.Hidden;
try
{
CaptureWindow captureWindow = new CaptureWindow();
Boolean result = captureWindow.ShowDialog().Value;
if (result)
{ // The region is captured. Run OCR and Translate
MemoryStream ms;
var bitmapSource = CopyScreen(captureWindow.Rect, out ms);
captureImage.Source = bitmapSource;
Visibility = Visibility.Visible;
initialized = true;
InMemoryRandomAccessStream inMemoryStream = new InMemoryRandomAccessStream();
ms.Position = 0;
Byte[] byteArray = ms.GetBuffer();
inMemoryStream.AsStream().Write(byteArray, 0, byteArray.Length);
inMemoryStream.AsStream().Flush();
Windows.Graphics.Imaging.BitmapDecoder bitmapDecoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(inMemoryStream);
SoftwareBitmap softwareBitmap = await bitmapDecoder.GetSoftwareBitmapAsync().AsTask().ConfigureAwait(true);
captureImage.Tag = softwareBitmap; // for later use
await RunOcrAndTranslate();
}
}
catch { }
Visibility = Visibility.Visible;
}
public static async Task <OcrResult?> GetOcrResultFromRegion(Rectangle region)
{
Language?selectedLanguage = GetOCRLanguage();
if (selectedLanguage == null)
{
return(null);
}
Bitmap bmp = new(region.Width, region.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
Graphics g = Graphics.FromImage(bmp);
g.CopyFromScreen(region.Left, region.Top, 0, 0, bmp.Size, CopyPixelOperation.SourceCopy);
OcrResult?ocrResult;
await using (MemoryStream memory = new())
{
bmp.Save(memory, ImageFormat.Bmp);
memory.Position = 0;
BitmapDecoder bmpDecoder = await BitmapDecoder.CreateAsync(memory.AsRandomAccessStream());
SoftwareBitmap softwareBmp = await bmpDecoder.GetSoftwareBitmapAsync();
OcrEngine ocrEngine = OcrEngine.TryCreateFromLanguage(selectedLanguage);
ocrResult = await ocrEngine.RecognizeAsync(softwareBmp);
}
return(ocrResult);
}
public static async Task <string> GetFullTextFromImage(Image img)
{
try
{
StringBuilder b = new StringBuilder();
using (var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream())
{
img.Save(stream.AsStream(), System.Drawing.Imaging.ImageFormat.Bmp);
//These steps to get to a SoftwareBitmap are aweful!
Windows.Graphics.Imaging.BitmapDecoder decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(stream);
SoftwareBitmap bitmap = await decoder.GetSoftwareBitmapAsync();
OcrResult ocrResult = await _ocrEngine.RecognizeAsync(bitmap);
for (int i = 0; i < ocrResult.Lines.Count; i++)
{
b.Append(ocrResult.Lines[i].Text);
b.Append(" ");
}
}
return(b.ToString());
}catch (Exception ex)
{
Logger.Error(ex.ToString());
}
return(string.Empty);
}
public async Task <SoftwareBitmap> CreateSoftwareBitmap(Windows.Storage.StorageFile file, BitmapImage bitmap)
{
Windows.Storage.Streams.IRandomAccessStream random = await Windows.Storage.Streams.RandomAccessStreamReference.CreateFromFile(file).OpenReadAsync();
Windows.Graphics.Imaging.BitmapDecoder decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(random);
var swBitmap = new SoftwareBitmap(BitmapPixelFormat.Rgba8, bitmap.PixelWidth, bitmap.PixelHeight);
return(swBitmap = await decoder.GetSoftwareBitmapAsync());
}
public static async Task <byte[]> ImageToByteArray(Uri uri)
{
Windows.Storage.Streams.IRandomAccessStream random = await Windows.Storage.Streams.RandomAccessStreamReference.CreateFromUri(uri).OpenReadAsync();
Windows.Graphics.Imaging.BitmapDecoder decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(random);
Windows.Graphics.Imaging.PixelDataProvider pixelData = await decoder.GetPixelDataAsync();
return(pixelData.DetachPixelData());
}
public async Task <IList <DetectedFace> > DetectFaces(Stream fileStream)
{
var stream = fileStream.AsRandomAccessStream();
var bitmapDecoder = await BitmapDecoder.CreateAsync(stream);
using SoftwareBitmap bitmap = await bitmapDecoder.GetSoftwareBitmapAsync();
var bmp = FaceDetector.IsBitmapPixelFormatSupported(bitmap.BitmapPixelFormat)
? bitmap : SoftwareBitmap.Convert(bitmap, BitmapPixelFormat.Gray8);
var faceDetector = await FaceDetector.CreateAsync();
var detectedFaces = await faceDetector.DetectFacesAsync(bmp);
return(detectedFaces);
}
private async Task SetImageSourceAsync(BitmapDecoder decoder, byte[] bitmapData)
{
using (IRandomAccessStream outputStream = new InMemoryRandomAccessStream())
{
BitmapEncoder encoder = await BitmapEncoder.CreateForTranscodingAsync(outputStream, decoder);
encoder.SetPixelData(decoder.BitmapPixelFormat, decoder.BitmapAlphaMode, decoder.PixelWidth,
decoder.PixelHeight, decoder.DpiX, decoder.DpiY, bitmapData);
await encoder.FlushAsync();
BitmapImage bitmapImage = new BitmapImage();
await bitmapImage.SetSourceAsync(outputStream);
_image.Source = bitmapImage;
}
}
public async Task <SoftwareBitmap> GetSoftwareSnapShot(int pattern)
{
var target = this.GetTargetWindow();
var bitmapSource = target?.GetClientBitmap();
var bitmap = new System.Drawing.Bitmap(
bitmapSource.PixelWidth,
bitmapSource.PixelHeight,
System.Drawing.Imaging.PixelFormat.Format32bppPArgb
);
var bitmapData = bitmap.LockBits(
new System.Drawing.Rectangle(System.Drawing.Point.Empty, bitmap.Size),
System.Drawing.Imaging.ImageLockMode.WriteOnly,
System.Drawing.Imaging.PixelFormat.Format32bppPArgb
);
bitmapSource.CopyPixels(
System.Windows.Int32Rect.Empty,
bitmapData.Scan0,
bitmapData.Height * bitmapData.Stride,
bitmapData.Stride
);
bitmap.UnlockBits(bitmapData);
bitmap = trimmingBitmap(bitmap, pattern);
var folder = Directory.GetCurrentDirectory();
var imageName = "ScreenCapture.bmp";
StorageFolder appFolder = await StorageFolder.GetFolderFromPathAsync(@folder);
bitmap.Save(folder + "\\" + imageName, ImageFormat.Bmp);
SoftwareBitmap softwareBitmap;
var bmpFile = await appFolder.GetFileAsync(imageName);
using (IRandomAccessStream stream = await bmpFile.OpenAsync(FileAccessMode.Read))
{
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
softwareBitmap = await decoder.GetSoftwareBitmapAsync();
}
File.Delete(folder + "\\" + imageName);
return(softwareBitmap);
}
/// <summary>
/// 指定範囲のキャプチャ画像をSoftwareBitmap型として得る
/// </summary>
/// <param name="left">キャプチャ範囲の左端端x座標</param>
/// <param name="top">キャプチャ範囲の左端端y座標</param>
/// <param name="height">キャプチャ範囲の高さ</param>
/// <param name="width">キャプチャ範囲の幅</param>
/// <returns>指定された範囲のキャプチャ画像</returns>
public static async Task <SoftwareBitmap> CaptureAsSoftwareBitmap(int left, int top, int height, int width)
{
//ビットマップの保持領域を確保
Bitmap partialCapture = new Bitmap(width, height);
//描画インターフェイスの設定
Graphics draw = Graphics.FromImage(partialCapture);
//画面全体をコピーする
draw.CopyFromScreen(
left,
top,
0, 0,
partialCapture.Size
);
//解放
draw.Dispose();
MemoryStream memStream = new MemoryStream();
partialCapture.Save(memStream, ImageFormat.Bmp);
SoftwareBitmap softwareBitmap;
using (var randomAccessStream = new UwpInMemoryRandomAccessStream())
{
using (var outputStream = randomAccessStream.GetOutputStreamAt(0))
using (var writer = new UwpDataWriter(outputStream))
{
writer.WriteBytes(memStream.ToArray());
await writer.StoreAsync();
await outputStream.FlushAsync();
}
// IRandomAccessStreamをSoftwareBitmapに変換
// （ここはUWP APIのデコーダーを使う）
var decoder = await UwpBitmapDecoder.CreateAsync(randomAccessStream);
softwareBitmap = await decoder.GetSoftwareBitmapAsync(UwpBitmapPixelFormat.Bgra8, UwpBitmapAlphaMode.Premultiplied);
}
return(softwareBitmap);
}
/// <summary>
/// Convert BitmapImage to SoftwareBitmap.
/// </summary>
/// <param name="bitmap">BitmapImage to be convereted.</param>
/// <returns>Converted SoftwareBitmap instance.</returns>
public static async Task <SoftwareBitmap> ToSoftwareBitmap(this BitmapImage bitmap)
{
try
{
using (var stream = await ToRandomAccessStream((MemoryStream)bitmap.StreamSource))
{
// Create the decoder from the stream
var decoder = await BitmapDecoder.CreateAsync(stream);
// Get the SoftwareBitmap representation of the file
return(await decoder.GetSoftwareBitmapAsync());
}
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
return(null);
}
async public static Task<WriteableBitmap> GetCroppedBitmapAsync(BitmapDecoder decoder,
Point startPoint, Size corpSize, double scale)
{
if (double.IsNaN(scale) || double.IsInfinity(scale))
{
scale = 1;
}
// Convert start point and size to integer.
uint startPointX = (uint)Math.Floor(startPoint.X * scale);
uint startPointY = (uint)Math.Floor(startPoint.Y * scale);
uint height = (uint)Math.Floor(corpSize.Height * scale);
uint width = (uint)Math.Floor(corpSize.Width * scale);
// The scaledSize of original image.
uint scaledWidth = (uint)Math.Floor(decoder.PixelWidth * scale);
uint scaledHeight = (uint)Math.Floor(decoder.PixelHeight * scale);
// Refine the start point and the size.
if (startPointX + width > scaledWidth)
{
startPointX = scaledWidth - width;
}
if (startPointY + height > scaledHeight)
{
startPointY = scaledHeight - height;
}
// Get the cropped pixels.
byte[] pixels = await GetPixelData(decoder, startPointX, startPointY, width, height,
scaledWidth, scaledHeight);
// Stream the bytes into a WriteableBitmap
WriteableBitmap cropBmp = new WriteableBitmap((int)width, (int)height);
Stream pixStream = cropBmp.PixelBuffer.AsStream();
pixStream.Write(pixels, 0, (int)(width * height * 4));
return cropBmp;
}
private void Dispose(bool disposing)
{
if (disposing)
{
this.Stop();
_isInitialized = false;
_hasCanvasResources = false;
_bitmapDecoder = null;
if (_frameProperties != null)
{
foreach (var item in _frameProperties)
{
item.ReleasePixels();
}
_frameProperties.Clear();
_frameProperties = null;
}
_canvasImageSource = null;
_accumulationRenderTarget = null;
_animationTimer = null;
}
}
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;
}
public async Task<ImageSource> InitializeAsync(IRandomAccessStream streamSource)
{
var bitmapDecoder = await BitmapDecoder.CreateAsync(BitmapDecoder.GifDecoderId, streamSource);
var imageProperties = await RetrieveImagePropertiesAsync(bitmapDecoder);
_frameProperties = new FrameProperties?[bitmapDecoder.FrameCount];
_bitmapDecoder = bitmapDecoder;
_imageProperties = imageProperties;
CreateCanvasResources();
_isInitialized = true;
return _canvasImageSource;
}
private void Dispose(bool disposing)
{
if (disposing)
{
this.Stop();
_isInitialized = false;
_hasCanvasResources = false;
_bitmapDecoder = null;
_frameProperties?.Clear();
_frameProperties = null;
_canvasImageSource = null;
_accumulationRenderTarget = null;
_animationTimer = null;
}
}
/// <summary>
/// Computes a BitmapTransform to downscale the source image if it's too large.
/// </summary>
/// <remarks>
/// Performance of the FaceDetector degrades significantly with large images, and in most cases it's best to downscale
/// the source bitmaps if they're too large before passing them into FaceDetector. Remember through, your application's performance needs will vary.
/// </remarks>
/// <param name="sourceDecoder">Source image decoder</param>
/// <returns>A BitmapTransform object holding scaling values if source image is too large</returns>
private BitmapTransform ComputeScalingTransformForSourceImage(BitmapDecoder sourceDecoder)
{
BitmapTransform transform = new BitmapTransform();
if (sourceDecoder.PixelHeight > this.sourceImageHeightLimit)
{
float scalingFactor = (float)this.sourceImageHeightLimit / (float)sourceDecoder.PixelHeight;
transform.ScaledWidth = (uint)Math.Floor(sourceDecoder.PixelWidth * scalingFactor);
transform.ScaledHeight = (uint)Math.Floor(sourceDecoder.PixelHeight * scalingFactor);
}
return transform;
}
public async Task<byte[]> DecodeAsync(BitmapDecoder bitmapDecoder)
{
if (_isDecode)
{
return this.Pixels;
}
var frame = await bitmapDecoder.GetFrameAsync(FrameIndex).AsTask().ConfigureAwait(false);
var pixelData = await frame.GetPixelDataAsync(
BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Premultiplied,
new BitmapTransform(),
ExifOrientationMode.IgnoreExifOrientation,
ColorManagementMode.DoNotColorManage
).AsTask().ConfigureAwait(false);
this.Pixels = pixelData.DetachPixelData();
_isDecode = true;
return Pixels;
}
protected async Task<byte[]> getPixelData(BitmapDecoder decoder)
{
PixelDataProvider pixelProvider = await decoder.GetPixelDataAsync(
BitmapPixelFormat.Rgba8,
BitmapAlphaMode.Straight,
new BitmapTransform(),
ExifOrientationMode.RespectExifOrientation,
ColorManagementMode.ColorManageToSRgb
);
return pixelProvider.DetachPixelData();
}
private static bool IsGifImage(BitmapDecoder decoder)
{
foreach (var mimeType in decoder.DecoderInformation.MimeTypes)
{
if (mimeType.Equals("image/gif", StringComparison.OrdinalIgnoreCase))
{
return true;
}
}
return false;
}
private static async Task<ImageProperties> RetrieveImagePropertiesAsync(BitmapDecoder bitmapDecoder)
{
// Properties not currently supported: background color, pixel aspect ratio.
const string widthProperty = "/logscrdesc/Width";
const string heightProperty = "/logscrdesc/Height";
const string applicationProperty = "/appext/application";
const string dataProperty = "/appext/data";
var propertiesView = bitmapDecoder.BitmapContainerProperties;
var requiredProperties = new[] { widthProperty, heightProperty };
var properties = await propertiesView.GetPropertiesAsync(requiredProperties);
var pixelWidth = (ushort)properties[widthProperty].Value;
var pixelHeight = (ushort)properties[heightProperty].Value;
var loopCount = 0; // Repeat forever by default
var isAnimated = true;
try
{
var extensionProperties = new[] { applicationProperty, dataProperty };
properties = await propertiesView.GetPropertiesAsync(extensionProperties);
if (properties.ContainsKey(applicationProperty) &&
properties[applicationProperty].Type == PropertyType.UInt8Array)
{
var bytes = (byte[])properties[applicationProperty].Value;
var applicationName = Encoding.UTF8.GetString(bytes, 0, bytes.Length);
if (applicationName == "NETSCAPE2.0" || applicationName == "ANIMEXTS1.0")
{
if (properties.ContainsKey(dataProperty) && properties[dataProperty].Type == PropertyType.UInt8Array)
{
// The data is in the following format:
// byte 0: extsize (must be > 1)
// byte 1: loopType (1 == animated gif)
// byte 2: loop count (least significant byte)
// byte 3: loop count (most significant byte)
// byte 4: set to zero
var data = (byte[])properties[dataProperty].Value;
loopCount = data[2] | data[3] << 8;
isAnimated = data[1] == 1;
}
}
}
}
catch
{
// These properties are not required, so it's okay to ignore failure.
}
return new ImageProperties(pixelWidth, pixelHeight, isAnimated, loopCount);
}
private async static Task<byte[]> ImageToScaledPixels(BitmapDecoder decoder, uint newWidth)
{
using (var encoderStream = new InMemoryRandomAccessStream())
{
var encoder = await BitmapEncoder.CreateForTranscodingAsync(encoderStream, decoder);
var scaleFactor = decoder.PixelWidth / (double)newWidth;
uint newHeight = (uint)(decoder.PixelHeight / scaleFactor);
encoder.BitmapTransform.ScaledWidth = newWidth;
encoder.BitmapTransform.ScaledHeight = newHeight;
await encoder.FlushAsync();
byte[] pixels = new byte[encoderStream.Size];
await encoderStream.ReadAsync(pixels.AsBuffer(), (uint)pixels.Length, InputStreamOptions.None);
return pixels;
}
}
private static async Task ResizeImageAsync(BitmapDecoder decoder, StorageFile targetFile, Size finalSize)
{
await _semaphore.WaitAsync();
try
{
using (var fileStream = await targetFile.OpenAsync(FileAccessMode.ReadWrite))
{
var encoder = await BitmapEncoder.CreateForTranscodingAsync(fileStream, decoder);
encoder.BitmapTransform.ScaledWidth = (uint)finalSize.Width;
encoder.BitmapTransform.ScaledHeight = (uint)finalSize.Height;
encoder.BitmapTransform.InterpolationMode = BitmapInterpolationMode.Fant;
await encoder.FlushAsync();
}
}
catch
{
throw;
}
finally
{
_semaphore.Release();
}
}
public static async Task <string> ExtractText(Bitmap bmp, System.Windows.Point?singlePoint = null)
{
Language?selectedLanguage = GetOCRLanguage();
if (selectedLanguage == null)
{
return("");
}
XmlLanguage lang = XmlLanguage.GetLanguage(selectedLanguage.LanguageTag);
CultureInfo culture = lang.GetEquivalentCulture();
bool scaleBMP = true;
if (singlePoint != null ||
bmp.Width * 1.5 > OcrEngine.MaxImageDimension)
{
scaleBMP = false;
}
Bitmap scaledBitmap;
if (scaleBMP)
{
scaledBitmap = ScaleBitmapUniform(bmp, 1.5);
}
else
{
scaledBitmap = ScaleBitmapUniform(bmp, 1.0);
}
StringBuilder text = new();
await using (MemoryStream memory = new())
{
scaledBitmap.Save(memory, ImageFormat.Bmp);
memory.Position = 0;
BitmapDecoder bmpDecoder = await BitmapDecoder.CreateAsync(memory.AsRandomAccessStream());
SoftwareBitmap softwareBmp = await bmpDecoder.GetSoftwareBitmapAsync();
OcrEngine ocrEngine = OcrEngine.TryCreateFromLanguage(selectedLanguage);
OcrResult ocrResult = await ocrEngine.RecognizeAsync(softwareBmp);
if (singlePoint == null)
{
foreach (OcrLine line in ocrResult.Lines)
{
text.AppendLine(line.Text);
}
}
else
{
Windows.Foundation.Point fPoint = new Windows.Foundation.Point(singlePoint.Value.X, singlePoint.Value.Y);
foreach (OcrLine ocrLine in ocrResult.Lines)
{
foreach (OcrWord ocrWord in ocrLine.Words)
{
if (ocrWord.BoundingRect.Contains(fPoint))
{
_ = text.Append(ocrWord.Text);
}
}
}
}
}
if (culture.TextInfo.IsRightToLeft)
{
string[] textListLines = text.ToString().Split(new char[] { '\n', '\r' });
_ = text.Clear();
foreach (string textLine in textListLines)
{
List <string> wordArray = textLine.Split().ToList();
wordArray.Reverse();
_ = text.Append(string.Join(' ', wordArray));
if (textLine.Length > 0)
{
_ = text.Append('\n');
}
}
return(text.ToString());
}
else
{
return(text.ToString());
}
}
public async Task LoadImageAsync(IRandomAccessStreamWithContentType stream)
{
var decoder = await BitmapDecoder.CreateAsync(BitmapDecoder.GifDecoderId, stream);
var imageProperties = await _gifPropertiesHelper.RetrieveImagePropertiesAsync(decoder);
var frameProperties = new List<FrameProperties>();
for (var i = 0; i < decoder.FrameCount; i++)
{
var bitmapFrame = await decoder.GetFrameAsync((uint)i);
frameProperties.Add(await _gifPropertiesHelper.RetrieveFramePropertiesAsync(bitmapFrame, i));
}
_decoder = decoder;
_imageProperties = imageProperties;
_frameProperties = frameProperties;
CreateImageBuffer();
}
private async void loadnew()
{
Assembly assembly = typeof(Clr_Pckr).GetTypeInfo().Assembly;
//Stream imgStream = assembly.GetManifestResourceStream("Color_Picker.Assets.c.png");
InMemoryRandomAccessStream res = new InMemoryRandomAccessStream();
using (var imgstream = assembly.GetManifestResourceStream("Dev.MartijnHoogendoorn.Inking.Behavior.Assets.c.png"))
{
await imgstream.CopyToAsync(res.AsStreamForWrite());
}
BitmapImage bmp = new BitmapImage();
using (IRandomAccessStream fileStream =res)// await( await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/c.png"))).OpenAsync(FileAccessMode.Read))
{
BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream);
fileStream.Seek(0);
bmp.SetSource(fileStream);
ColorImg.Source = bmp;
BitmapTransform bt = new BitmapTransform();
bt.ScaledHeight = 100;
bt.ScaledWidth = 100;
PixelDataProvider pixelData = await decoder.GetPixelDataAsync(
BitmapPixelFormat.Bgra8,
BitmapAlphaMode.Straight,
bt,
ExifOrientationMode.IgnoreExifOrientation,
ColorManagementMode.DoNotColorManage);
bd = decoder;
//byte[] sourcePixels = pixelData.DetachPixelData();
tempBuffer = pixelData.DetachPixelData();
}
}
public async Task<ImageSource> InitializeAsync(CoreDispatcher dispatcher,
IRandomAccessStream streamSource, CancellationTokenSource cancellationTokenSource)
{
var inMemoryStream = new InMemoryRandomAccessStream();
var copyAction = RandomAccessStream.CopyAndCloseAsync(
streamSource.GetInputStreamAt(0L),
inMemoryStream.GetOutputStreamAt(0L));
await copyAction.AsTask(cancellationTokenSource.Token);
var bitmapDecoder = await BitmapDecoder.
CreateAsync(BitmapDecoder.GifDecoderId, inMemoryStream).AsTask(cancellationTokenSource.Token).ConfigureAwait(false);
var imageProperties = await RetrieveImagePropertiesAsync(bitmapDecoder);
var frameProperties = new List<FrameProperties>();
for (var i = 0u; i < bitmapDecoder.FrameCount; i++)
{
var bitmapFrame = await bitmapDecoder.GetFrameAsync(i).AsTask(cancellationTokenSource.Token).ConfigureAwait(false); ;
frameProperties.Add(await RetrieveFramePropertiesAsync(i, bitmapFrame));
}
_frameProperties = frameProperties;
_bitmapDecoder = bitmapDecoder;
_imageProperties = imageProperties;
_dispatcher = dispatcher;
await _dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
CreateCanvasResources();
});
_isInitialized = true;
return _canvasImageSource;
}
/// <summary>
/// Use BitmapTransform to define the region to crop, and then get the pixel data in the region
/// </summary>
/// <returns></returns>
async static private Task<byte[]> GetPixelData(BitmapDecoder decoder, uint startPointX, uint startPointY,
uint width, uint height)
{
return await GetPixelData(decoder,startPointX, startPointY, width, height,
decoder.PixelWidth,decoder.PixelHeight);
}
public async Task<ImagePackage> InitializeAsync(CoreDispatcher dispatcher, Image image, Uri uriSource,
IRandomAccessStream streamSource, CancellationTokenSource cancellationTokenSource)
{
var bitmapDecoder = ImagingCache.Get<BitmapDecoder>(uriSource);
if (bitmapDecoder == null)
{
var inMemoryStream = new InMemoryRandomAccessStream();
var copyAction = RandomAccessStream.CopyAndCloseAsync(
streamSource.GetInputStreamAt(0L),
inMemoryStream.GetOutputStreamAt(0L));
await copyAction.AsTask(cancellationTokenSource.Token);
bitmapDecoder = await BitmapDecoder.CreateAsync(BitmapDecoder.GifDecoderId, inMemoryStream);
ImagingCache.Add(uriSource, bitmapDecoder);
}
var imageProperties = await RetrieveImagePropertiesAsync(bitmapDecoder);
var frameProperties = new List<FrameProperties>();
for (var i = 0u; i < bitmapDecoder.FrameCount; i++)
{
var bitmapFrame = await bitmapDecoder.GetFrameAsync(i).AsTask(cancellationTokenSource.Token).ConfigureAwait(false); ;
frameProperties.Add(await RetrieveFramePropertiesAsync(i, bitmapFrame));
}
_frameProperties = frameProperties;
_bitmapDecoder = bitmapDecoder;
_imageProperties = imageProperties;
_dispatcher = dispatcher;
await _dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
CreateCanvasResources();
var uri = image.Tag as Uri;
if (uri == uriSource)
{
image.Source = _canvasImageSource;
}
});
_isInitialized = true;
return new ImagePackage(this, _canvasImageSource, _imageProperties.PixelWidth, _imageProperties.PixelHeight); ;
}
/// <summary>
/// Convert Bitmap to SoftwareBitmap.
/// Beneficial for use in UWP framework and API.
/// </summary>
/// <param name="bitmap">Bitmap to be converted.</param>
/// <returns>Converted SoftwareBitmap instance.</returns>
public static async Task <SoftwareBitmap> ToSoftwareBitmap(this Bitmap bitmap)
{
try
{
// Create new MemoryStream for original bitmap data.
using (var memoryStream = new MemoryStream())
{
// Save data to memory stream.
bitmap.Save(memoryStream, ImageFormat.Bmp);
// Reset position.
//memoryStream.Position = 0;
// Convert MemoryStream to RandomAccessStream.
using (var randomAccessStream = await memoryStream.ToRandomAccessStream())
{
// Create the decoder from the stream.
var decoder = await BitmapDecoder.CreateAsync(randomAccessStream);
// Get the SoftwareBitmap representation of the file.
return(await decoder.GetSoftwareBitmapAsync());
}
}
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
return(null);
}
