Inheritance: IBitmapDecoder, IBitmapFrame
		/// <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;
		}
Exemple #2
0
        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);
        }
Exemple #3
0
        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;
        }
Exemple #5
0
        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);
        }
Exemple #6
0
        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);
        }
Exemple #7
0
        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());
        }
Exemple #8
0
        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());
        }
Exemple #9
0
        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);
        }
Exemple #10
0
        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;
            }
        }
Exemple #11
0
        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);
        }
Exemple #12
0
    /// <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);
    }
Exemple #13
0
        /// <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();
 }
Exemple #22
0
 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);
            }
Exemple #24
0
		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;
			}
		}
Exemple #25
0
        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();
            }
        }
Exemple #26
0
        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;
        }
Exemple #30
0
 /// <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); ;
        }
Exemple #32
-1
        /// <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);
        }