public static Bitmap ToRotatedBitmap(this Bitmap sourceBitmap, ExifOrientation orientation)
        {
            if (orientation == ExifOrientation.ORIENTATION_UNDEFINED || orientation == ExifOrientation.ORIENTATION_NORMAL)
            {
                return(sourceBitmap);
            }

            var width  = sourceBitmap.Width;
            var height = sourceBitmap.Height;

            try
            {
                using (var matrix = new Matrix())
                {
                    switch (orientation)
                    {
                    case ExifOrientation.ORIENTATION_FLIP_HORIZONTAL:
                        matrix.PostScale(-1, 1);
                        break;

                    case ExifOrientation.ORIENTATION_ROTATE_180:
                        matrix.PostRotate(180);
                        break;

                    case ExifOrientation.ORIENTATION_FLIP_VERTICAL:
                        matrix.PostRotate(180);
                        matrix.PostScale(-1, 1);
                        break;

                    case ExifOrientation.ORIENTATION_TRANSPOSE:
                        matrix.PostRotate(90);
                        matrix.PostScale(-1, 1);
                        break;

                    case ExifOrientation.ORIENTATION_ROTATE_90:
                        matrix.PostRotate(90);
                        break;

                    case ExifOrientation.ORIENTATION_TRANSVERSE:
                        matrix.PostRotate(270);
                        matrix.PostScale(-1, 1);
                        break;

                    case ExifOrientation.ORIENTATION_ROTATE_270:
                        matrix.PostRotate(270);
                        break;
                    }

                    return(Bitmap.CreateBitmap(sourceBitmap, 0, 0, width, height, matrix, false));
                }
            }
            finally
            {
                if (sourceBitmap != null && sourceBitmap.Handle != IntPtr.Zero && !sourceBitmap.IsRecycled)
                {
                    sourceBitmap.Recycle();
                    sourceBitmap.TryDispose();
                }
            }
        }
Exemple #2
0
        public static Bitmap RotateToCorrentOrientation(this Bitmap bitmap, ExifOrientation currentOrientation)
        {
            //Calculate rotation
            float degrees = 0;

            switch (currentOrientation)
            {
            case ExifOrientation.TopRight:
                degrees = 90;
                break;

            case ExifOrientation.BottomLeft:
                degrees = -90;
                break;

            case ExifOrientation.BottomRight:
                degrees = 180;
                break;
            }

            //Rotate if needed
            if (degrees != 0)
            {
                using (var mtx = new Matrix())
                {
                    mtx.PreRotate(degrees);
                    bitmap = Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, mtx, false);
                }
            }
            return(bitmap);
        }
Exemple #3
0
        public static RotateFlipType GetRotateFlipType(this ExifOrientation orientation)
        {
            switch (orientation)
            {
            case ExifOrientation.HorizontalFlip:
                return(RotateFlipType.RotateNoneFlipX);

            case ExifOrientation.Rotate180:
                return(RotateFlipType.Rotate180FlipNone);

            case ExifOrientation.VerticalFlip:
                return(RotateFlipType.Rotate180FlipX);

            case ExifOrientation.Transpose:
                return(RotateFlipType.Rotate90FlipX);

            case ExifOrientation.Rotate270:
                return(RotateFlipType.Rotate90FlipNone);

            case ExifOrientation.Transverse:
                return(RotateFlipType.Rotate270FlipX);

            case ExifOrientation.Rotate90:
                return(RotateFlipType.Rotate270FlipNone);

            default:
                return(RotateFlipType.RotateNoneFlipNone);
            }
        }
Exemple #4
0
        /// <summary>
        /// Returning an int so I dont need to link exif into the native apps.
        /// </summary>
        /// <param name="imgBits"></param>
        /// <returns></returns>
        public static int readExifOrientation(byte[] imgBits)
        {
            ExifOrientation result = ExifOrientation.Undefined;

            if (imgBits != null)
            {
                using (var resource = new MemoryStream(imgBits)) {
                    try {
                        JpegInfo jpegInfo = ExifReader.ReadJpeg(resource);
                        // What exif lib associates each orientation with num in spec:
                        // ExifLib.ExifOrientation.TopRight == 6;   // i need to rotate clockwise 90
                        // ExifLib.ExifOrientation.BottomLeft == 8;  // i need to rotate ccw 90
                        // ExifLib.ExifOrientation.BottomRight == 3; // i need to rotate 180
                        // ExifLib.ExifOrientation.TopLeft ==1;  // do nada.

                        // What each image I set the exif on resulted in:
                        // (note: what I set should be correct as it displays right in programs that adjust for exif)
                        // Unchd: 1
                        // ImgRotLeft: 6
                        // ImgRotRight: 8
                        // ImgRot180: 3
                        // Cool. These all tie out with images in Dave Perret article.
                        result = jpegInfo.Orientation;
                        //int imgExifWidth = jpegInfo.Width;
                        //int imgExifHeight = jpegInfo.Height;
                        Debug.WriteLine("DHB:GlobalSingletonHelpers:readExifOrientation orientation:" + result);
                    } catch (Exception e) {
                        Debug.WriteLine("DHB:GlobalSingletonHelpers:readExifOrientation  bad exif read");
                        Debug.WriteLine(e.ToString());
                    }
                }
            }
            return((int)result);
        }
Exemple #5
0
		public static Bitmap RotateToCorrentOrientation(this Bitmap bitmap, ExifOrientation currentOrientation)
		{
			//Calculate rotation
			float degrees = 0;
			switch (currentOrientation)
			{
				case ExifOrientation.TopRight:
					degrees = 90;
					break;
				case ExifOrientation.BottomLeft:
					degrees = -90;
					break;
				case ExifOrientation.BottomRight:
					degrees = 180;
					break;
			}

			//Rotate if needed
			if (degrees != 0)
			{
				using (Matrix mtx = new Matrix())
				{
					mtx.PreRotate(degrees);
					bitmap = Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, mtx, false);
				}
			}
			return bitmap;
		}
Exemple #6
0
        public static Image buildFixedRotationImageFromBytes(byte[] inImg, ExifOrientation imgExifO = ExifOrientation.Undefined, int width = -1, int height = -1)
        {
            if (inImg == null)
            {
                return(null);
            }
            Debug.WriteLine("DHB:GlobalSingletonHelpers:buildFixedRotationImageFromBytes");
            DateTime step0      = DateTime.Now;
            Image    result     = new Image();
            DateTime step1      = DateTime.Now;
            SKBitmap rotatedBmp = buildFixedRotationSKBitmapFromBytes(inImg, imgExifO);

            Debug.WriteLine("DHB:GlobalSingletonHelpers:buildFixedRotationImageFromBytes rotBmp done");
            if ((width > -1) && (height > 1) && (rotatedBmp != null))
            {
                SKImageInfo sizing = new SKImageInfo(width, height);
                rotatedBmp = rotatedBmp.Resize(sizing, SKBitmapResizeMethod.Hamming);
            }
            Debug.WriteLine("DHB:GlobalSingletonHelpers:buildFixedRotationImageFromBytes resize done");
            DateTime step2 = DateTime.Now;

            if (rotatedBmp != null)
            {
                result = SKImageToXamarinImage(SKImage.FromBitmap((SKBitmap)rotatedBmp));
            }
            Debug.WriteLine("DHB:GlobalSingletonHelpers:buildFixedRotationImageFromBytes resize done");
            DateTime step3 = DateTime.Now;

            //Debug.WriteLine("DHB:GlobalSingletonHelpers:buildFixedRotationImageFromBytes step1:" + (step1 - step0));
            //Debug.WriteLine("DHB:GlobalSingletonHelpers:buildFixedRotationImageFromBytes step2:" + (step2 - step1));
            //Debug.WriteLine("DHB:GlobalSingletonHelpers:buildFixedRotationImageFromBytes step3:" + (step3 - step2));
            return(result);
        }
Exemple #7
0
        /// <summary>
        /// Examines the exif metadata in am image and determines if the picture was rotated
        /// when it was taken. If the orientation is rotated, the image will be rotated to make it
        /// straight.
        /// </summary>
        /// <param name="image"></param>
        private static void FixImageOrientation(Bitmap image)
        {
            try
            {
                ExifOrientation orientation = ExifOrientation.Normal;
                try
                {
                    orientation = ExifMetadata.FromImage(image).Orientation;
                    if (orientation == ExifOrientation.Unknown)
                    {
                        orientation = ExifOrientation.Normal;
                    }
                }
                catch (Exception e) { Debug.Fail("Unexpected error getting image orientation", e.ToString()); }

                if (orientation == ExifOrientation.Rotate270CW)
                {
                    image.RotateFlip(RotateFlipType.Rotate90FlipXY);
                }
                else if (orientation == ExifOrientation.Rotate90CW)
                {
                    image.RotateFlip(RotateFlipType.Rotate270FlipXY);
                }
            }
            catch (Exception)
            {
                //image.PropertyItems will throw an exception if the image does not contain any exif data
            }
        }
Exemple #8
0
        public static SKBitmap HandleOrientation(SKBitmap bitmap, ExifOrientation exifOrientation)
        {
            SKBitmap rotated;

            switch (exifOrientation)
            {
            case ExifOrientation.Rotate180:

                using (var surface = new SKCanvas(bitmap))
                {
                    surface.RotateDegrees(180, bitmap.Width / 2, bitmap.Height / 2);
                    surface.DrawBitmap(bitmap.Copy(), 0, 0);
                }

                return(bitmap);

            case ExifOrientation.MirrorHorizontal:
                rotated = new SKBitmap(bitmap.Height, bitmap.Width);

                using (var surface = new SKCanvas(rotated))
                {
                    surface.Translate(rotated.Width, 0);
                    surface.RotateDegrees(90);
                    surface.DrawBitmap(bitmap, 0, 0);
                }

                return(rotated);

            case ExifOrientation.MirrorVertical:
                rotated = new SKBitmap(bitmap.Height, bitmap.Width);

                using (var surface = new SKCanvas(rotated))
                {
                    surface.Translate(0, rotated.Height);
                    surface.RotateDegrees(270);
                    surface.DrawBitmap(bitmap, 0, 0);
                }

                return(rotated);

            case ExifOrientation.Rotate90:

                rotated = new SKBitmap(bitmap.Height, bitmap.Width);

                using (var surface = new SKCanvas(rotated))
                {
                    surface.Translate(rotated.Width, 0);
                    surface.RotateDegrees(90);
                    surface.DrawBitmap(bitmap, 0, 0);
                }

                return(rotated);

            default:
                return(bitmap);
            }
        }
Exemple #9
0
        public static Size GetOrientatedSize(Size size, ExifOrientation orientation)
        {
            switch (orientation)
            {
            case Transpose:
            case Rotate90:
            case Transverse:
            case Rotate270: return(new Size(size.Height, size.Width));

            default: return(new Size(size.Width, size.Height));
            }
        }
Exemple #10
0
        private void GetPhotoLocation(MediaFile file)
        {
            using (Stream photo = file.GetStream())
            {
                var                 picture     = ExifReader.ReadJpeg(photo);
                ExifOrientation     orientation = picture.Orientation;
                ExifGpsLatitudeRef  latRef      = picture.GpsLatitudeRef;
                ExifGpsLongitudeRef longRef     = picture.GpsLongitudeRef;

                latitude.Text  = GetLatitude(latRef, picture.GpsLatitude).ToString();
                longitude.Text = GetLongitude(picture.GpsLongitude).ToString();
            }
        }
Exemple #11
0
        private void GetPhotoTaskCompleted(object sender, PhotoResult e)
        {
            if (getPhotoCallback != null)
            {
                if (e.TaskResult == TaskResult.OK)
                {
                    JpegInfo info = ExifReader.ReadJpeg(e.ChosenPhoto, e.OriginalFileName);
                    e.ChosenPhoto.Seek(0, SeekOrigin.Begin);
                    ExifOrientation _orientation = info.Orientation;
                    int             _angle       = 0;
                    switch (info.Orientation)
                    {
                    case ExifOrientation.TopLeft:
                    case ExifOrientation.Undefined:
                        _angle = 0;
                        break;

                    case ExifOrientation.TopRight:
                        _angle = 90;
                        break;

                    case ExifOrientation.BottomRight:
                        _angle = 180;
                        break;

                    case ExifOrientation.BottomLeft:
                        _angle = 270;
                        break;
                    }

                    Stream capturedImage;
                    if (_angle > 0d)
                    {
                        capturedImage = RotateStream(e.ChosenPhoto, _angle);
                    }
                    else
                    {
                        capturedImage = e.ChosenPhoto;
                    }
                    IMobeelizerFile file = Mobeelizer.CreateFile("photo", capturedImage);
                    this.getPhotoCallback(file);
                    this.getPhotoCallback = null;
                }
                else
                {
                    this.GetPhoto(getPhotoCallback);
                }
            }
        }
Exemple #12
0
        private void PreviewPhoto(MediaFile mediaFile)
        {
            using (Stream photo = mediaFile.GetStream())
            {
                var picture = ExifReader.ReadJpeg(photo);

                FilePath = mediaFile.Path;

                ExifOrientation     orientation = picture.Orientation;
                ExifGpsLatitudeRef  latRef      = picture.GpsLatitudeRef;
                ExifGpsLongitudeRef longRef     = picture.GpsLongitudeRef;

                Latitude  = GpsHelper.GetLatitude(latRef, picture.GpsLatitude);
                Longitude = GpsHelper.GetLongitude(picture.GpsLongitude);
            }
        }
Exemple #13
0
        public static Bitmap GetScaledAndRotatedBitmap(this Bitmap bitmap, ExifOrientation currentOrientation,
                                                       float maxPixelDimension)
        {
            var newBitmapSize = getScaledSize(bitmap.Width, bitmap.Height, maxPixelDimension);

            if (newBitmapSize != SizeF.Empty)
            {
                var scaled  = bitmap.ScaleBitmap(newBitmapSize);
                var rotated = scaled.RotateToCorrentOrientation(currentOrientation);
                if (rotated != scaled)
                {
                    scaled.Dispose();
                }
                return(rotated);
            }
            return(bitmap.RotateToCorrentOrientation(currentOrientation));
        }
Exemple #14
0
        /// <summary>
        /// Given an exif orientation, rotates the passed in image accordingly
        /// </summary>
        /// <param name="orientation"></param>
        /// <param name="image"></param>
        public static bool RotateFromExifOrientation(ExifOrientation orientation, Image image)
        {
            switch (orientation)
            {
            case ExifOrientation.Rotate90CW:
                image.RotateFlip(RotateFlipType.Rotate90FlipNone);
                return(true);

            case ExifOrientation.Rotate270CW:
                image.RotateFlip(RotateFlipType.Rotate270FlipNone);
                return(true);

            case ExifOrientation.Normal:
            case ExifOrientation.Unknown:
                return(false);
            }

            return(false);
        }
Exemple #15
0
        public static IProcessor[] GetTransforms(this ExifOrientation orientation)
        {
            switch (orientation)
            {
            case FlipHorizontal: return(new IProcessor[] { FlipTransform.Horizontally });

            case Rotate180: return(new IProcessor[] { new RotateTransform(180) });

            case FlipVertical: return(new IProcessor[] { FlipTransform.Vertically });

            case Transpose: return(new IProcessor[] { FlipTransform.Horizontally, new RotateTransform(270) });

            case Rotate90: return(new IProcessor[] { new RotateTransform(90) });

            case Transverse: return(new IProcessor[] { FlipTransform.Horizontally, new RotateTransform(90) });

            case Rotate270: return(new IProcessor[] { new RotateTransform(270) });

            default: return(Array.Empty <IProcessor>());
            }
        }
Exemple #16
0
		public static Bitmap GetScaledAndRotatedBitmap(this Bitmap bitmap, ExifOrientation currentOrientation, float maxPixelDimension)
		{
			var newBitmapSize = getScaledSize(bitmap.Width, bitmap.Height, maxPixelDimension);
			if (newBitmapSize != SizeF.Empty)
			{
				var scaled = bitmap.ScaleBitmap(newBitmapSize);
				var rotated = scaled.RotateToCorrentOrientation(currentOrientation);
				if (rotated != scaled)
					scaled.Dispose();
				return rotated;
			}
			else
			{
				return bitmap.RotateToCorrentOrientation(currentOrientation);
			}
		}
Exemple #17
0
        public static IList <Image> buildTwoFixedRotationImageFromBytes(byte[] inImg, ExifOrientation imgExifO = ExifOrientation.Undefined)
        {
            IList <Image> res   = new List <Image>(2);
            DateTime      step0 = DateTime.Now;

            //Image result = new Image();
            res.Add(new Image());
            res.Add(new Image());
            DateTime step1      = DateTime.Now;
            SKBitmap rotatedBmp = buildFixedRotationSKBitmapFromBytes(inImg, imgExifO);
            DateTime step2      = DateTime.Now;

            if (rotatedBmp != null)
            {
                //result = SKImageToXamarinImage(SKImage.FromBitmap((SKBitmap)rotatedBmp));
                SKImage img = SKImage.FromBitmap((SKBitmap)rotatedBmp);
                res[0] = SKImageToXamarinImage(img);
                res[1] = SKImageToXamarinImage(img);
            }
            DateTime step3 = DateTime.Now;

            //Debug.WriteLine("DHB:GlobalSingletonHelpers:buildFixedRotationImageFromBytes step1:" + (step1 - step0));
            //Debug.WriteLine("DHB:GlobalSingletonHelpers:buildFixedRotationImageFromBytes step2:" + (step2 - step1));
            //Debug.WriteLine("DHB:GlobalSingletonHelpers:buildFixedRotationImageFromBytes step3:" + (step3 - step2));
            //return result;
            return(res);
        }
Exemple #18
0
        private bool OrientImage(string sourceFileName, string destinationFileName)
        {
            Image image          = null;
            bool  isProperlyDone = false;

            try
            {
                image = Image.FromFile(sourceFileName);
                ExifOrientation orientation = ImageOrientation(image);

                switch (orientation)
                {
                case ExifOrientation.TopLeft:
                    break;

                case ExifOrientation.TopRight:
                    image.RotateFlip(RotateFlipType.RotateNoneFlipX);
                    break;

                case ExifOrientation.BottomRight:
                    image.RotateFlip(RotateFlipType.Rotate180FlipNone);
                    break;

                case ExifOrientation.BottomLeft:
                    image.RotateFlip(RotateFlipType.RotateNoneFlipY);
                    break;

                case ExifOrientation.LeftTop:
                    image.RotateFlip(RotateFlipType.Rotate90FlipX);
                    break;

                case ExifOrientation.RightTop:
                    image.RotateFlip(RotateFlipType.Rotate90FlipNone);
                    break;

                case ExifOrientation.RightBottom:
                    image.RotateFlip(RotateFlipType.Rotate90FlipY);
                    break;

                case ExifOrientation.LeftBottom:
                    image.RotateFlip(RotateFlipType.Rotate270FlipNone);
                    break;
                }

                // setting image orientation to top left
                //propOrient.Value[0] = 1;
                //image.SetPropertyItem(propOrient);

                image.Save(destinationFileName);
                isProperlyDone = true;
            }
            catch (Exception ex)
            {
                richTextFailed.AppendText(string.Format("{0} - {1}\r\n",
                                                        sourceFileName,
                                                        ex.Message));
            }
            finally
            {
                if (image != null)
                {
                    image.Dispose();
                }
            }

            return(isProperlyDone);
        }
        /// <summary>
        /// Given an exif orientation, rotates the passed in image accordingly
        /// </summary>
        /// <param name="orientation"></param>
        /// <param name="image"></param>
        public static bool RotateFromExifOrientation(ExifOrientation orientation, Image image)
        {
            switch (orientation)
            {
                case ExifOrientation.Rotate90CW:
                    image.RotateFlip(RotateFlipType.Rotate90FlipNone);
                    return true;
                case ExifOrientation.Rotate270CW:
                    image.RotateFlip(RotateFlipType.Rotate270FlipNone);
                    return true;
                case ExifOrientation.Normal:
                case ExifOrientation.Unknown:
                    return false;
            }

            return false;
        }
Exemple #20
0
 private static string GetDisplayString(ExifOrientation tag)
 {
     return(ExifOrientationStrings.ContainsKey(tag) ? ExifOrientationStrings[tag] : tag.ToString());
 }
Exemple #21
0
 public PageInfo(int width, int height, ExifOrientation orientation = ExifOrientation.None)
 {
     Width       = width;
     Height      = height;
     Orientation = orientation;
 }
Exemple #22
0
        public static SKBitmap buildFixedRotationSKBitmapFromBytes(byte[] imgBits, ExifOrientation imgExifO = ExifOrientation.Undefined)
        {
            SKBitmap rotatedBmp = null;

            if (imgBits != null)
            {
                DateTime step0 = DateTime.Now;
                using (var resource = new MemoryStream(imgBits)) {
                    //using (var stream = new SKManagedStream(resource)) {
                    //using (var stream = new MemoryStream((resource)) {
                    DateTime step1 = DateTime.Now;
                    if (imgExifO == ExifOrientation.Undefined)
                    {
                        imgExifO = ExifLib.ExifOrientation.TopLeft;
                        try {
                            JpegInfo jpegInfo = ExifReader.ReadJpeg(resource);
                            // What exif lib associates each orientation with num in spec:
                            // ExifLib.ExifOrientation.TopRight == 6;   // i need to rotate clockwise 90
                            // ExifLib.ExifOrientation.BottomLeft == 8;  // i need to rotate ccw 90
                            // ExifLib.ExifOrientation.BottomRight == 3; // i need to rotate 180
                            // ExifLib.ExifOrientation.TopLeft ==1;  // do nada.

                            // What each image I set the exif on resulted in:
                            // (note: what I set should be correct as it displays right in programs that adjust for exif)
                            // Unchd: 1
                            // ImgRotLeft: 6
                            // ImgRotRight: 8
                            // ImgRot180: 3
                            // Cool. These all tie out with images in Dave Perret article.
                            imgExifO = jpegInfo.Orientation;
                            //int imgExifWidth = jpegInfo.Width;
                            //int imgExifHeight = jpegInfo.Height;

                            //string res = "Orient:" + imgExifO.ToString() + "  W:" + imgExifWidth + ", H:" + imgExifHeight;
                            //string res2 = res + "dummy";
                        } catch (Exception e) {
                            Debug.WriteLine("DHB:GlobalSingletonHelpers:buildFixedRotationSKBitmapFromBytes bad exif read");
                            Debug.WriteLine(e.ToString());
                        }
                    }
                    DateTime step2 = DateTime.Now;
                    try {
                        SKBitmap baseBmp = SKBitmapFromBytes(imgBits);
                        //SKBitmap rotatedBmp = null;
                        if (imgExifO == ExifLib.ExifOrientation.TopRight)
                        {
                            rotatedBmp = new SKBitmap(baseBmp.Height, baseBmp.Width);
                            using (var canvas = new SKCanvas(rotatedBmp)) {
                                canvas.Translate(rotatedBmp.Width, 0);
                                canvas.RotateDegrees(90);
                                canvas.DrawBitmap(baseBmp, 0, 0);
                            }
                        }
                        else if (imgExifO == ExifLib.ExifOrientation.BottomLeft)
                        {
                            rotatedBmp = new SKBitmap(baseBmp.Height, baseBmp.Width);
                            using (var canvas = new SKCanvas(rotatedBmp)) {
                                // currently upside down. with w, 90.
                                // failures:   -W, 270    w,-90    -W,90     0,90  0,270
                                //   h, 270  -> soln is to think about the corner I'm told is important...
                                //canvas.Translate(-rotatedBmp.Width, 0);
                                canvas.Translate(0, rotatedBmp.Height);
                                canvas.RotateDegrees(270);
                                canvas.DrawBitmap(baseBmp, 0, 0);
                            }
                        }
                        else if (imgExifO == ExifLib.ExifOrientation.BottomRight)
                        {
                            rotatedBmp = new SKBitmap(baseBmp.Width, baseBmp.Height);
                            using (var canvas = new SKCanvas(rotatedBmp)) {
                                canvas.Translate(rotatedBmp.Width, rotatedBmp.Height);
                                canvas.RotateDegrees(180);
                                canvas.DrawBitmap(baseBmp, 0, 0);
                            }
                        }
                        else
                        {
                            rotatedBmp = baseBmp;
                        }
                        Debug.WriteLine("DHB:GlobalSingletonHelpers:buildFixedRotationSKBitmapFromBytes success");
                    } catch (Exception e) {
                        string msg = e.ToString();
                    }
                    DateTime step3 = DateTime.Now;
                    //Debug.WriteLine("DHB:GlobalSingletonHelpers:buildFixedRotationSKBitmapFromBytes step1:" + (step1 - step0));
                    //Debug.WriteLine("DHB:GlobalSingletonHelpers:buildFixedRotationSKBitmapFromBytes step2:" + (step2 - step1));
                    //Debug.WriteLine("DHB:GlobalSingletonHelpers:buildFixedRotationSKBitmapFromBytes step3:" + (step3 - step2));
                }
            }
            return(rotatedBmp);
        }
Exemple #23
0
 public OrientTransform(ExifOrientation orientation)
 {
     Orientation = orientation;
 }