Example #1
0
        static unsafe ComplexImage ToComplexImage(this SKImage image)
        {
            SKPixmap pixmap = image.PeekPixels();
            byte *   bmpPtr = (byte *)pixmap.GetPixels().ToPointer();
            int      width  = image.Width;
            int      height = image.Height;

            if ((!MathHelpers.IsPowerOf2(width)) || (!MathHelpers.IsPowerOf2(height)))
            {
                throw new ArgumentException("Image width and height must be a power of 2.");
            }

            ComplexImage complexImage = new ComplexImage(width, height);

            Complex[,] data = complexImage.Data;

            for (int row = 0; row < height; row++)
            {
                for (int col = 0; col < width; col++)
                {
                    byte red   = *bmpPtr++;
                    byte green = *bmpPtr++;
                    byte blue  = *bmpPtr++;
                    bmpPtr += 1; // Ignore alpha

                    // Assuming SKColorType.Rgba8888 - used by iOS and Android
                    // (UWP uses SKColorType.Bgra8888)
                    byte result = (byte)(0.2126 * red + 0.7152 * green + 0.0722 * blue);
                    data[row, col].Re = (float)result / 255;
                }
            }
            return(complexImage);
        }
        public static unsafe SKPixmap ToSKPixmap(this ComplexImage complexImage, SKImage image)
        {
            SKPixmap pixmap = image.PeekPixels();
            byte *   bmpPtr = (byte *)pixmap.GetPixels().ToPointer();
            int      width  = image.Width;
            int      height = image.Height;

            Complex[,] data = complexImage.Data;
            double scale = (complexImage.IsFourierTransformed) ? Math.Sqrt(width * height) : 1;

            bmpPtr = (byte *)pixmap.GetPixels().ToPointer();
            for (int row = 0; row < height; row++)
            {
                for (int col = 0; col < width; col++)
                {
                    // Assuming SKColorType.Rgba8888 - used by iOS and Android
                    // (UWP uses SKColorType.Bgra8888)
                    byte result   = (byte)Math.Max(0, Math.Min(255, data[row, col].Magnitude * scale * 255));
                    *    bmpPtr++ = result; // red
                    *    bmpPtr++ = result; // green
                    *    bmpPtr++ = result; // blue
                    bmpPtr += 1;            // Ignore alpha
                }
            }

            return(pixmap);
        }
Example #3
0
 public static Bitmap ToBitmap(this SKImage skiaImage)
 {
     using (var pixmap = skiaImage.PeekPixels())
     {
         return(pixmap.ToBitmap());
     }
 }
Example #4
0
        public static unsafe SKPixmap ToGreyscale(this SKImage image)
        {
            SKPixmap pixmap = image.PeekPixels();
            byte *   bmpPtr = (byte *)pixmap.GetPixels().ToPointer();
            int      width  = image.Width;
            int      height = image.Height;
            byte *   tempPtr;

            for (int row = 0; row < height; row++)
            {
                for (int col = 0; col < width; col++)
                {
                    tempPtr = bmpPtr;
                    byte red   = *bmpPtr++;
                    byte green = *bmpPtr++;
                    byte blue  = *bmpPtr++;
                    byte alpha = *bmpPtr++;

                    // Assuming SKColorType.Rgba8888 - used by iOS and Android
                    // (UWP uses SKColorType.Bgra8888)
                    byte result = (byte)(0.2126 * red + 0.7152 * green + 0.0722 * blue);

                    bmpPtr = tempPtr;
                    *bmpPtr++ = result; // red
                    *bmpPtr++ = result; // green
                    *bmpPtr++ = result; // blue
                    *bmpPtr++ = alpha;  // alpha
                }
            }
            return(pixmap);
        }
Example #5
0
        public static unsafe SKPixmap ToSepia(this SKImage image)
        {
            SKPixmap pixmap = image.PeekPixels();
            byte *   bmpPtr = (byte *)pixmap.GetPixels().ToPointer();
            int      width  = image.Width;
            int      height = image.Height;
            byte *   tempPtr;

            for (int row = 0; row < height; row++)
            {
                for (int col = 0; col < width; col++)
                {
                    tempPtr = bmpPtr;
                    byte red   = *bmpPtr++;
                    byte green = *bmpPtr++;
                    byte blue  = *bmpPtr++;
                    byte alpha = *bmpPtr++;

                    // Assuming SKColorType.Rgba8888 - used by iOS and Android
                    // (UWP uses SKColorType.Bgra8888)
                    byte intensity = (byte)(0.299 * red + 0.587 * green + 0.114 * blue);

                    bmpPtr = tempPtr;
                    *bmpPtr++ = (byte)((intensity > 206) ? 255 : intensity + 49); // red
                    *bmpPtr++ = (byte)((intensity < 14) ? 0 : intensity - 14);    // green
                    *bmpPtr++ = (byte)((intensity < 56) ? 0 : intensity - 56);    // blue
                    *bmpPtr++ = alpha;                                            // alpha
                }
            }
            return(pixmap);
        }
Example #6
0
        public static SKImage Resize(this SKImage input, int width, int height)
        {
            var     imageInfo = new SKImageInfo(width, height);
            SKImage image     = SKImage.Create(imageInfo);

            input.ScalePixels(image.PeekPixels(), SKFilterQuality.High);
            return(image);
        }
Example #7
0
 public static Bitmap ToBitmap(this SKImage skiaImage)
 {
     using (var pixmap = skiaImage.PeekPixels())
     {
         var bmp = pixmap.ToBitmap();
         GC.KeepAlive(skiaImage);
         return(bmp);
     }
 }
Example #8
0
        public static SKImage ToSKImage(this Bitmap bitmap)
        {
            SKImage sKImage = SKImage.Create(new SKImageInfo(bitmap.Width, bitmap.Height));

            using (SKPixmap pixmap = sKImage.PeekPixels())
            {
                bitmap.ToSKPixmap(pixmap);
                return(sKImage);
            }
        }
Example #9
0
        private void RenderImageToTexture2D(SKImage image, GraphicsDevice graphicsDevice)
        {
            var pixelMap = image.PeekPixels();
            var pointer  = pixelMap.GetPixels();

            Marshal.Copy(pointer, _rawCanvasPixels, 0, _rawCanvasPixels.Length);

            _graphTexture ??= new Texture2D(graphicsDevice, image.Width, image.Height);
            _graphTexture.SetData(_rawCanvasPixels);
        }
Example #10
0
        public static string Save(SKImage image)
        {
            var guid = Guid.NewGuid().ToString();

            using (var file = System.IO.File.Create(Path.Combine(rootPath, guid)))
            {
                using var pixmap = image.PeekPixels();
                pixmap.Encode(file, SKPngEncoderOptions.Default);
            }

            return(guid);
        }
Example #11
0
        public static Texture2D RenderImageToTexture2D(SKImage image, GraphicsDevice graphicsDevice)
        {
            var pixelMap = image.PeekPixels();
            var pointer  = pixelMap.GetPixels();
            var pixels   = new byte[image.Height * pixelMap.RowBytes];

            Marshal.Copy(pointer, pixels, 0, pixels.Length);
            var texture = new Texture2D(graphicsDevice, image.Width, image.Height);

            texture.SetData(pixels);

            return(texture);
        }
Example #12
0
        public ImmutableBitmap(ImmutableBitmap src, PixelSize destinationSize, BitmapInterpolationMode interpolationMode)
        {
            SKImageInfo info   = new SKImageInfo(destinationSize.Width, destinationSize.Height, SKColorType.Bgra8888);
            SKImage     output = SKImage.Create(info);

            src._image.ScalePixels(output.PeekPixels(), interpolationMode.ToSKFilterQuality());

            _image = output;

            PixelSize = new PixelSize(_image.Width, _image.Height);

            // TODO: Skia doesn't have an API for DPI.
            Dpi = new Vector(96, 96);
        }
        public static SKImage CaptureRegion(int x, int y, int width, int height)
        {
            IntPtr sourceDC = IntPtr.Zero;
            IntPtr targetDC = IntPtr.Zero;
            IntPtr compatibleBitmapHandle = IntPtr.Zero;

            // create the final SkiaSharp image
            SKImage  image  = SKImage.Create(new SKImageInfo(width, height));
            SKPixmap pixmap = image.PeekPixels();

            try
            {
                // gets the main desktop and all open windows
                sourceDC = User32.GetDC(User32.GetDesktopWindow());
                targetDC = Gdi32.CreateCompatibleDC(sourceDC);

                // create a bitmap compatible with our target DC
                compatibleBitmapHandle = Gdi32.CreateCompatibleBitmap(sourceDC, width, height);

                // gets the bitmap into the target device context
                Gdi32.SelectObject(targetDC, compatibleBitmapHandle);

                // copy from source to destination
                Gdi32.BitBlt(targetDC, 0, 0, width, height, sourceDC, x, y, Gdi32.TernaryRasterOperations.SRCCOPY);

                // create the info structure
                Gdi32.BITMAPINFOHEADER bmi = new Gdi32.BITMAPINFOHEADER();
                bmi.biPlanes      = 1;
                bmi.biBitCount    = 32;
                bmi.biWidth       = width;
                bmi.biHeight      = -height;
                bmi.biCompression = Gdi32.BitmapCompressionMode.BI_RGB;

                // read the raw pixels into the pixmap for the image
                Gdi32.GetDIBits(targetDC, compatibleBitmapHandle, 0, height, pixmap.GetPixels(), bmi, Gdi32.DIB_Color_Mode.DIB_RGB_COLORS);
            }
            finally
            {
                Gdi32.DeleteObject(compatibleBitmapHandle);

                User32.ReleaseDC(IntPtr.Zero, sourceDC);
                User32.ReleaseDC(IntPtr.Zero, targetDC);
            }

            return(image);
        }
        protected virtual SKImage ConvertProfile(SKImage data, float width, float height)
        {
            using SKImage srcImg = data;
            SKImageInfo info = new SKImageInfo((int)width, (int)height,
                                               SKImageInfo.PlatformColorType, SKAlphaType.Opaque, SKColorSpace.CreateSrgb());
            // this is the important part. set the destination ColorSpace as
            // `SKColorSpace.CreateSrgb()`. Skia will then be able to automatically convert
            // the original CMYK colorspace, to this new sRGB colorspace.

            SKImage newImg = SKImage.Create(info);

            srcImg.ScalePixels(newImg.PeekPixels(), SKFilterQuality.None);

            // Remove transparency
            var bitmap = RemoveTransparency(srcImg);

            newImg = SKImage.FromBitmap(bitmap);
            // now when doing this resize, Skia knows the original ColorSpace, and the
            // destination ColorSpace, and converts the colors from CMYK to sRGB.
            return(newImg);
        }
Example #15
0
        static unsafe void ToYCbCrAArrays(this SKImage image, float[,] y, float[,] cb, float[,] cr, float[,] a)
        {
            if (y == null)
            {
                throw new ArgumentException("y can't be null");
            }
            if (cb == null)
            {
                throw new ArgumentException("cb can't be null");
            }
            if (cr == null)
            {
                throw new ArgumentException("cr can't be null");
            }
            if (a == null)
            {
                throw new ArgumentException("a can't be null");
            }

            SKPixmap pixmap = image.PeekPixels();
            byte *   bmpPtr = (byte *)pixmap.GetPixels().ToPointer();
            int      width  = image.Width;
            int      height = image.Height;

            for (int row = 0; row < height; row++)
            {
                for (int col = 0; col < width; col++)
                {
                    byte red   = *bmpPtr++;
                    byte green = *bmpPtr++;
                    byte blue  = *bmpPtr++;
                    byte alpha = *bmpPtr++;

                    y[col, row]  = (0.2990f * red + 0.5870f * green + 0.1140f * blue + 0.5f);
                    cb[col, row] = (-0.1687f * red - 0.3313f * green + 0.5000f * blue + 127.5f + 0.5f);
                    cr[col, row] = (0.5000f * red - 0.4187f * green - 0.0813f * blue + 127.5f + 0.5f);
                    a[col, row]  = alpha;
                }
            }
        }
Example #16
0
        private static bool[,] GetDotArray(SKImage image, int rowCount, int colCount)
        {
            var path       = new bool[rowCount, colCount];
            var startPoint = new SKPoint();

            var pixels   = image.PeekPixels();
            var rectSize = new SKPoint(image.Width / (float)colCount, image.Height / (float)rowCount);

            for (var i = 0; i < rowCount; i++)
            {
                startPoint.X = 0;
                for (var j = 0; j < colCount; j++)
                {
                    var pixelColor = pixels.GetPixelColor((int)(startPoint.X + rectSize.X / 2), (int)(startPoint.Y + rectSize.Y / 2));
                    path[i, j]    = pixelColor.Alpha > 0;
                    startPoint.X += rectSize.X;
                }

                startPoint.Y += rectSize.Y;
            }
            pixels.Dispose();
            return(path);
        }
Example #17
0
        /// <summary>
        /// Load an image from the phone
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private async void LoadImage(object sender, EventArgs args)
        {
            IPhotoLibrary photoLibrary = DependencyService.Get <IPhotoLibrary>();

            using (Stream stream = await photoLibrary.PickPhotoAsync())
            {
                if (stream != null)
                {
                    SKBitmap loaded = SKBitmap.Decode(stream);
                    if (loaded != null)
                    {
                        if (animation)
                        {
                            StopAccelerometer();
                        }


                        //Set the image dimensions
                        width  = (int)imgGenerated.CanvasSize.ToFormsSize().Width;
                        height = (int)imgGenerated.CanvasSize.ToFormsSize().Height;

                        int oldSize = width;
                        if (width > height)
                        {
                            oldSize = height;
                        }

                        int size = oldSize;
                        for (int i = 1; i < oldSize; i <<= 1)
                        {
                            size = i;
                        }

                        width  = size;
                        height = size;

                        generator.SetDimensions(width, height);


                        // Resize the loaded image
                        //source: https://stackoverflow.com/questions/48422724/fastest-way-to-scale-an-skimage-skiasharp
                        SKImageInfo info = new SKImageInfo(width, height, SKColorType.Rgba8888);

                        SKImage output = SKImage.Create(info);

                        loaded.ScalePixels(output.PeekPixels(), SKFilterQuality.None);

                        imgBitmap = SKBitmap.FromImage(output);

                        skRect = new SKRect(0, 0, oldSize, oldSize);

                        generator.Load(imgBitmap);
                        imgGenerated.InvalidateSurface();

                        if (animation)
                        {
                            StartAccelerometer();
                        }
                    }
                }
            }
        }
Example #18
0
 async void OnSavePhotoClicked(object sender, EventArgs e)
 {
     await Navigation.PushModalAsync(new NavigationPage(new SavePhotoPage(image.PeekPixels())));
 }
Example #19
0
        public static unsafe SKPixmap OtsuThreshold(this SKImage image)
        {
            SKPixmap pixmap = image.PeekPixels();
            byte *   bmpPtr = (byte *)pixmap.GetPixels().ToPointer();
            int      width  = image.Width;
            int      height = image.Height;

            int[]    intHistogram = new int[256];
            double[] histogram    = new double[256];
            int      threshold    = 0;

            // Build a histogram
            for (int row = 0; row < height; row++)
            {
                for (int col = 0; col < width; col++)
                {
                    byte red   = *bmpPtr++;
                    byte green = *bmpPtr++;
                    byte blue  = *bmpPtr++;

                    // Assuming SKColorType.Rgba8888 - used by iOS and Android
                    // (UWP uses SKColorType.Bgra8888)
                    int result = (byte)(0.2126 * red + 0.7152 * green + 0.0722 * blue);
                    intHistogram[result]++;
                }
            }

            int    pixelCount = width * height;
            double imageMean  = 0;

            for (int i = 0; i < 256; i++)
            {
                histogram[i] = (double)intHistogram[i] / pixelCount;
                imageMean   += histogram[i] * i;
            }

            double max        = double.MinValue;
            double c1Prob     = 0;
            double c2Prob     = 1;
            double c1MeanInit = 0;

            for (int i = 0; i < 256 && c2Prob > 0; i++)
            {
                double c1Mean        = c1MeanInit;
                double c2Mean        = (imageMean - (c1Mean * c1Prob)) / c2Prob;
                double classVariance = c1Prob * (1.0 - c1Prob) * Math.Pow(c1Mean - c2Mean, 2);

                if (classVariance > max)
                {
                    max       = classVariance;
                    threshold = i;
                }

                c1MeanInit *= c1Prob;
                c1Prob     += histogram[i];
                c2Prob     -= histogram[i];
                c1MeanInit += (double)i * (double)histogram[i];

                if (Math.Abs(c1Prob) > 0)
                {
                    c1MeanInit /= c1Prob;
                }
            }

            bmpPtr = (byte *)pixmap.GetPixels().ToPointer();

            // Apply threshold
            for (int row = 0; row < height; row++)
            {
                for (int col = 0; col < width; col++)
                {
                    if (*bmpPtr <= threshold)
                    {
                        *bmpPtr++ = 0; // red
                        *bmpPtr++ = 0; // green
                        *bmpPtr++ = 0; // blue
                    }
                    else
                    {
                        *bmpPtr++ = 255; // red
                        *bmpPtr++ = 255; // green
                        *bmpPtr++ = 255; // blue
                    }
                    bmpPtr += 1;
                }
            }

            return(pixmap);
        }
Example #20
0
        static unsafe SKPixmap ToRGBAPixmap(this SKImage image, float[,] y, float[,] cb, float[,] cr, float[,] a)
        {
            if (y == null)
            {
                throw new ArgumentException("y can't be null");
            }
            if (cb == null)
            {
                throw new ArgumentException("cb can't be null");
            }
            if (cr == null)
            {
                throw new ArgumentException("cr can't be null");
            }
            if (a == null)
            {
                throw new ArgumentException("a can't be null");
            }

            SKPixmap pixmap = image.PeekPixels();
            byte *   bmpPtr = (byte *)pixmap.GetPixels().ToPointer();
            int      width  = image.Width;
            int      height = image.Height;

            for (int row = 0; row < height; row++)
            {
                for (int col = 0; col < width; col++)
                {
                    float yValue  = y[col, row];
                    float cbValue = cb[col, row] - 127.5f;
                    float crValue = cr[col, row] - 127.5f;
                    float aValue  = a[col, row];

                    int red   = (int)(yValue + 1.40200f * crValue + 0.5f);
                    int green = (int)(yValue - 0.34414f * cbValue - 0.71417f * crValue + 0.5f);
                    int blue  = (int)(yValue + 1.77200f * cbValue + 0.5f);
                    int alpha = (int)aValue;

                    if (red < 0)
                    {
                        red = 0;
                    }
                    else if (red > 255)
                    {
                        red = 255;
                    }

                    if (green < 0)
                    {
                        green = 0;
                    }
                    else if (green > 255)
                    {
                        green = 255;
                    }

                    if (blue < 0)
                    {
                        blue = 0;
                    }
                    else if (blue > 255)
                    {
                        blue = 255;
                    }

                    if (alpha < 0)
                    {
                        alpha = 0;
                    }
                    else if (alpha > 255)
                    {
                        alpha = 255;
                    }

                    *bmpPtr++ = (byte)red;
                    *bmpPtr++ = (byte)green;
                    *bmpPtr++ = (byte)blue;
                    *bmpPtr++ = (byte)alpha;
                }
            }
            return(pixmap);
        }