public static AMatrix ToAndroid(this Transform transform, float density = 1) { AMatrix aMatrix = new AMatrix(); if (transform == null) { return(aMatrix); } Matrix matrix = transform.Value; aMatrix.SetValues( new float[] { (float)matrix.M11, (float)matrix.M21, (float)matrix.OffsetX * density, (float)matrix.M12, (float)matrix.M22, (float)matrix.OffsetY * density, 0, 0, 1 }); return(aMatrix); }
public static Android.Graphics.Bitmap Rotate(Android.Graphics.Bitmap bitmap, int angle) { var mat = new Android.Graphics.Matrix(); mat.PostRotate(angle); return(Android.Graphics.Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, mat, true)); }
/// <summary> /// Rotate the picture taken /// https://forums.xamarin.com/discussion/5409/photo-being-saved-in-landscape-not-portrait /// </summary> /// <param name="path"></param> /// <param name="width"></param> /// <param name="height"></param> /// <returns></returns> void RotateBitmap(string path, byte[] data) { try { //using (Android.Graphics.Bitmap picture = Android.Graphics.BitmapFactory.DecodeFile(path)) using (Android.Graphics.Bitmap picture = data.ToBitmap()) using (Android.Graphics.Matrix mtx = new Android.Graphics.Matrix()) { ExifInterface exif = new ExifInterface(path); string orientation = exif.GetAttribute(ExifInterface.TagOrientation); var camOrientation = int.Parse(orientation); switch (_imageRotation) { case 0: // landscape break; case 90: // landscape upside down mtx.PreRotate(270); break; case 180: // portrait mtx.PreRotate(180); break; case 270: // portrait upside down mtx.PreRotate(90); break; } var maxSize = 1024; double w = picture.Width; double h = picture.Height; if (picture.Width > maxSize || picture.Height > maxSize) { // set scaled width and height to prevent out of memory exception double scaleFactor = (double)maxSize / (double)picture.Width; if (picture.Height > picture.Width) { scaleFactor = (double)maxSize / picture.Height; } w = picture.Width * scaleFactor; h = picture.Height * scaleFactor; } using (var scaledPiture = Android.Graphics.Bitmap.CreateScaledBitmap(picture, (int)w, (int)h, false)) using (var rotatedPiture = Android.Graphics.Bitmap.CreateBitmap(scaledPiture, 0, 0, (int)w, (int)h, mtx, false)) { SaveFile(path, rotatedPiture.ToBytes()); } } } catch (Java.Lang.OutOfMemoryError e) { e.PrintStackTrace(); throw; } }
public Android.Graphics.Bitmap rotateMyBitmap(Android.Graphics.Bitmap bmp) { //*****旋转一下 Android.Graphics.Matrix matrix = new Android.Graphics.Matrix(); matrix.PostRotate(270); Android.Graphics.Bitmap nbmp2 = Android.Graphics.Bitmap.CreateBitmap(bmp, 0, 0, bmp.Width, bmp.Height, matrix, true); bmp.Dispose(); return(nbmp2); }
public static Android.Graphics.Bitmap rotateBitmap(Android.Graphics.Bitmap bitmap, int orientation) { Android.Graphics.Matrix matrix = new Android.Graphics.Matrix(); switch (orientation) { case (int)Android.Media.Orientation.Normal: return(bitmap); case (int)Android.Media.Orientation.FlipHorizontal: matrix.SetScale(-1, 1); break; case (int)Android.Media.Orientation.Rotate180: matrix.SetRotate(180); break; case (int)Android.Media.Orientation.FlipVertical: matrix.SetRotate(180); matrix.PostScale(-1, 1); break; case (int)Android.Media.Orientation.Transpose: matrix.SetRotate(90); matrix.PostScale(-1, 1); break; case (int)Android.Media.Orientation.Rotate90: matrix.SetRotate(90); break; case (int)Android.Media.Orientation.Transverse: matrix.SetRotate(-90); matrix.PostScale(-1, 1); break; case (int)Android.Media.Orientation.Rotate270: matrix.SetRotate(-90); break; default: return(bitmap); } try { Android.Graphics.Bitmap bmRotated = Android.Graphics.Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, matrix, true); bitmap.Recycle(); return(bmRotated); } catch (Java.Lang.OutOfMemoryError e) { e.PrintStackTrace(); return(null); } }
private static Android.Graphics.Bitmap RotateImage(string filePath, int rotation) { var originalImage = Android.Graphics.BitmapFactory.DecodeFile(filePath); var matrix = new Android.Graphics.Matrix(); matrix.PostRotate(rotation); var rotatedImage = Android.Graphics.Bitmap.CreateBitmap(originalImage, 0, 0, originalImage.Width, originalImage.Height, matrix, true); originalImage.Recycle(); return(rotatedImage); }
public static Android.Graphics.Matrix ToNative(this Matrix3x2 matrix) { var nativeMatrix = new Android.Graphics.Matrix(); nativeMatrix.SetValues(new[] { matrix.M11, matrix.M21, matrix.M31, matrix.M12, matrix.M22, matrix.M32, 0, 0, 1 }); return(nativeMatrix); }
public void OnPictureTaken(byte[] data, Camera camera) { camera.StartPreview(); Task.Run(() => { try { var fileService = DependencyService.Get <IFileService>(); var fileName = "photo_" + DateTime.Now.ToString() + ".jpg"; fileName = fileName.Replace("/", "_"); fileName = System.IO.Path.Combine(fileService.AppWorkPath, fileName); // File.WriteAllBytes(fileName, data); var rotate = 90; if (rotate > 0) { var matrix = new Android.Graphics.Matrix(); matrix.PostRotate(rotate); var bitmap = Android.Graphics.BitmapFactory.DecodeByteArray(data, 0, data.Length); // MediaStore.Images.Media.GetBitmap(this.ContentResolver, Android.Net.Uri.Parse(uri)); var rotatedBitmap = Android.Graphics.Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, matrix, true); bitmap.Recycle(); bitmap = rotatedBitmap; using (var finalStream = new MemoryStream()) { bitmap.Compress(Android.Graphics.Bitmap.CompressFormat.Jpeg, 100, finalStream); data = finalStream.GetBuffer(); } File.WriteAllBytes(fileName, data); bitmap.Recycle(); GC.Collect(); } if (this.CameraPreviewCallback != null) { this.CameraPreviewCallback.AfterPictureTaken(fileName); } } catch { } }); }
/// <summary> /// Read the file into a Mat /// </summary> /// <param name="fileName">The file to read from</param> /// <param name="mat">The Mat to read the file into</param> /// <param name="loadType">The load type</param> /// <returns>True if successfully read file into Mat</returns> public bool ReadFile(String fileName, Mat mat, CvEnum.ImreadModes loadType) { try { int rotation = 0; Android.Media.ExifInterface exif = new Android.Media.ExifInterface(fileName); int orientation = exif.GetAttributeInt(Android.Media.ExifInterface.TagOrientation, int.MinValue); switch (orientation) { case (int)Android.Media.Orientation.Rotate270: rotation = 270; break; case (int)Android.Media.Orientation.Rotate180: rotation = 180; break; case (int)Android.Media.Orientation.Rotate90: rotation = 90; break; } using (Android.Graphics.Bitmap bmp = Android.Graphics.BitmapFactory.DecodeFile(fileName)) { if (rotation == 0) { bmp.ToMat(mat); } else { Android.Graphics.Matrix matrix = new Android.Graphics.Matrix(); matrix.PostRotate(rotation); using (Android.Graphics.Bitmap rotated = Android.Graphics.Bitmap.CreateBitmap(bmp, 0, 0, bmp.Width, bmp.Height, matrix, true)) { rotated.ToMat(mat); } } } return(true); } catch (Exception e) { Debug.WriteLine(e); //throw; return(false); } }
public async void OnPictureTaken(byte[] data, Camera camera) { img_container.bitma_pic = Android.Graphics.BitmapFactory.DecodeByteArray(data, 0, data.Length); string cur_time_milisec = System.DateTime.Now.Millisecond.ToString(); string cur_time_sec = System.DateTime.Now.Second.ToString(); img_container.temp_storage = new Java.IO.File(img_container.path_file, "image" + cur_time_milisec + cur_time_sec + ".jpg"); if (!img_container.temp_storage.Exists()) { img_container.temp_storage.CreateNewFile(); } img_container.absolut_path_pic = img_container.temp_storage.AbsolutePath; Android.Graphics.Matrix rotation_matrix = new Android.Graphics.Matrix(); //caz ii camera spate if (gcur_cam != gDef_front_cam) { rotation_matrix.PreRotate(90); } else //camera frontala { rotation_matrix.PreRotate(270); } img_container.bitma_pic = Android.Graphics.Bitmap.CreateBitmap(img_container.bitma_pic, 0, 0, img_container.bitma_pic.Width, img_container.bitma_pic.Height, rotation_matrix, true); MemoryStream stream = new MemoryStream(); Android.Graphics.Bitmap bmp = img_container.bitma_pic; bmp.Compress(Android.Graphics.Bitmap.CompressFormat.Jpeg, 100, stream); byte[] byte_array = stream.ToArray(); FileOutputStream outstream = new FileOutputStream(img_container.temp_storage); outstream.Write(byte_array); outstream.Flush(); outstream.Close(); }
internal Android.Graphics.Matrix ToNativeMatrix(Android.Graphics.Matrix targetMatrix = null, Point origin = new Point(), Size size = new Size()) { var matrix = ToMatrix(origin, size); if (targetMatrix == null) { targetMatrix = new Android.Graphics.Matrix(); } targetMatrix.SetValues(new[] { matrix.M11, matrix.M21, matrix.M31 * (float)size.Width, matrix.M12, matrix.M22, matrix.M32 * (float)size.Height, 0, 0, 1 }); return(targetMatrix); }
private void CorrectImageOrientation(string imagePath) { ExifInterface ei = new ExifInterface(imagePath); int orientation = ei.GetAttributeInt(ExifInterface.TagOrientation, (int)Orientation.Undefined); var matrix = new Android.Graphics.Matrix(); bool rotationIsNeeded = true; switch (orientation) { case (int)Orientation.Rotate90: matrix.PostRotate(90); break; case (int)Orientation.Rotate180: matrix.PostRotate(180); break; case (int)Orientation.Rotate270: matrix.PostRotate(270); break; default: rotationIsNeeded = false; break; } if (rotationIsNeeded) { var sourceBitmap = Android.Graphics.BitmapFactory.DecodeFile(imagePath); var rotatedBitmap = Android.Graphics.Bitmap.CreateBitmap(sourceBitmap, 0, 0, sourceBitmap.Width, sourceBitmap.Height, matrix, true); sourceBitmap.Dispose(); App.FileHelper.DeleteFile(imagePath); var outStream = App.FileHelper.CreateFile(imagePath); rotatedBitmap.Compress(Android.Graphics.Bitmap.CompressFormat.Jpeg, 100, outStream); rotatedBitmap.Dispose(); outStream.Close(); outStream.Dispose(); } }
public async void OnPictureTaken(byte[] data, Android.Hardware.Camera camera) { using (var bmp = await Android.Graphics.BitmapFactory.DecodeByteArrayAsync(data, 0, data.Length)) { using (var resized = bmp.DefaultResize()) { var mat = new Android.Graphics.Matrix(); var info = new Android.Hardware.Camera.CameraInfo(); Android.Hardware.Camera.GetCameraInfo(currentCamera, info); if (info.Facing == CameraFacing.Front) { mat.PostScale(-1, 1); } mat.PostRotate(90); var correctBmp = Android.Graphics.Bitmap.CreateBitmap(resized, 0, 0, resized.Width, resized.Height, mat, true); _captureComplete.SetResult(correctBmp); _captureComplete = null; } } }
protected override void Draw(Canvas canvas, Rect bounds) { int saveCount = canvas.Save(); RectF arcBounds = mTempBounds; arcBounds.Set(bounds); mPaint.Color = new Color(mColor); //calculate fish clip bounds //clip the width of the fish need to increase mPathDottedLineSize * 1.2f RectF fishRectF = new RectF(mFishHeadPos[0] - mFishWidth / 2.0f - mPathDottedLineSize * 1.2f, mFishHeadPos[1] - mFishHeight / 2.0f, mFishHeadPos[0] + mFishWidth / 2.0f + mPathDottedLineSize * 1.2f, mFishHeadPos[1] + mFishHeight / 2.0f); Matrix matrix = new Matrix(); matrix.PostRotate(mFishRotateDegrees, fishRectF.CenterX(), fishRectF.CenterY()); matrix.MapRect(fishRectF); //draw river int riverSaveCount = canvas.Save(); mPaint.SetStyle(Paint.Style.Stroke); canvas.ClipRect(fishRectF, Region.Op.Difference); canvas.DrawPath(CreateRiverPath(arcBounds), mPaint); canvas.RestoreToCount(riverSaveCount); //draw fish int fishSaveCount = canvas.Save(); mPaint.SetStyle(Paint.Style.Fill); canvas.Rotate(mFishRotateDegrees, mFishHeadPos[0], mFishHeadPos[1]); canvas.ClipPath(CreateFishEyePath(mFishHeadPos[0], mFishHeadPos[1] - mFishHeight * 0.06f), Region.Op.Difference); canvas.DrawPath(CreateFishPath(mFishHeadPos[0], mFishHeadPos[1]), mPaint); canvas.RestoreToCount(fishSaveCount); canvas.RestoreToCount(saveCount); }
public bool SetDisplayMatrix(Android.Graphics.Matrix finalMatrix) { return(mAttacher.SetDisplayMatrix(finalMatrix)); }
public void UpdateTransform(AMatrix transform) { UpdateShapeTransform(transform); }
/// <summary> /// Take a picture and perform previews /// </summary> /// <param name="data"></param> /// <param name="camera"></param> void Camera.IPictureCallback.OnPictureTaken(byte[] data, Android.Hardware.Camera camera) { if (data != null && _box != null) { if (!_processDialog.IsShowing) { _processDialog.SetMessage ("Waiting for image results..."); _processDialog.Show (); } Android.Graphics.BitmapFactory.Options options = new Android.Graphics.BitmapFactory.Options (); options.InJustDecodeBounds = true; options.InSampleSize = 2; options.InJustDecodeBounds = false; options.InTempStorage = new byte[16 * 1024]; Android.Graphics.Bitmap bmp = Android.Graphics.BitmapFactory.DecodeByteArray(data, 0, data.Length, options); data = null; GC.Collect (); Android.Graphics.Bitmap rotatedBitmap; if (bmp.Width > bmp.Height) { Android.Graphics.Matrix mtx = new Android.Graphics.Matrix(); mtx.SetRotate(90); rotatedBitmap = Android.Graphics.Bitmap.CreateBitmap(bmp, 0, 0, bmp.Width, bmp.Height, mtx, false); bmp.Recycle(); mtx.Dispose(); mtx = null; } else { rotatedBitmap = bmp.Copy(bmp.GetConfig(), true); bmp.Recycle(); } GC.Collect (); double ratioX = (double)rotatedBitmap.Width / (double)screenWidth; double ratioY = (double)rotatedBitmap.Height / (double)screenHeight; int startX = (int)(ratioX * (double)(_box.MidX - _box.Width / 2)); int startY = (int)(ratioY * (double)(_box.MidY - _box.Height / 2)); int width = (int)(ratioX * (double)_box.Width); int height = (int)(ratioY * (double)_box.Height); Android.Graphics.Bitmap croppedBitmap = Android.Graphics.Bitmap.CreateBitmap(rotatedBitmap, startX, startY, width, height); rotatedBitmap.Recycle(); GC.Collect (); bitmap = croppedBitmap.Copy(croppedBitmap.GetConfig(), true); PerformPreviews(croppedBitmap); } else { Toast.MakeText(this, "Data null error", ToastLength.Long).Show(); } }
public bool SetDisplayMatrix(Android.Graphics.Matrix finalMatrix) => _attacher.SetDisplayMatrix(finalMatrix);
public static Android.Graphics.Bitmap rotateImage(Android.Graphics.Bitmap source, float angle) { Android.Graphics.Matrix matrix = new Android.Graphics.Matrix(); matrix.PostRotate(angle); return(Android.Graphics.Bitmap.CreateBitmap(source, 0, 0, source.Width, source.Height, matrix, true)); }
public void ResetTransform() { Flush(); using(var m = new Android.Graphics.Matrix()) ACanvas.Matrix = m; }
public override void Draw(Android.Graphics.Canvas canvas) { if (Control == null) return; Control.CreateGraphicBuffers(); if (origMatrix == null) { origMatrix = new Android.Graphics.Matrix(); origMatrix.Set (canvas.Matrix); } if (hMatrix == null) { hMatrix = new Android.Graphics.Matrix(); hMatrix.Set(origMatrix); hMatrix.PostTranslate(-Control.offBmp.Width, 0); hMatrix.PostScale(-1, 1); } if (vMatrix == null) { vMatrix = new Android.Graphics.Matrix(); vMatrix.Set(origMatrix); vMatrix.PostTranslate(0, -Control.offBmp.Height); vMatrix.PostScale(1, -1); } var ctime = System.Environment.TickCount; var realupdate = false; Fleux.UIElements.Canvas.drawtime = 0; /**/ if (Control.offNeedExtraDraw && Control.offUpdated) lock(Control.offBmp){ Control.offNeedExtraDraw = false; Control.offUpdated = false; Control.offBmpDraw = true; Control.Draw(new PaintEventArgs(Control.offGr, new Rectangle(0,0, Control.offBmp.Width, Control.offBmp.Height))); Control.offBmpDraw = false; updcnt++; realupdate = true; } //*/ lock(Control.offBmp) { if (Fleux.Core.FleuxApplication.HorizontalMirror) { canvas.Matrix = hMatrix; }else if (Fleux.Core.FleuxApplication.VerticalMirror) { canvas.Matrix = vMatrix; }else canvas.Matrix = origMatrix; // Thats for FastGraphics.cs Control.offGr.Flush(); canvas.DrawBitmap(Control.offBmp.ABitmap, 0,0, paint); Control.offUpdated = false; updcntflush++; } if (PerfData) { ctime = System.Environment.TickCount - ctime; //if (realupdate) { totime += ctime; } var cavg = totime / (updcnt+1); var cpaint = new Android.Graphics.Paint(); cpaint.Color = new Android.Graphics.Color(0xA0, 0xFF, 0xFF, 0xFF); cpaint.SetStyle(Android.Graphics.Paint.Style.Fill); canvas.DrawRect(0,0, 250, 20, cpaint); canvas.DrawText(""+updcnt+":"+updcntflush+":"+updcntinval+" ctime: "+ctime+"cavg:"+cavg+" canv: "+Fleux.UIElements.Canvas.drawtime, 0,20, spaint); cpaint.Dispose(); if (updcnt > 100) { totime = 0; updcnt = 0; } } }
private static Android.Graphics.Bitmap RotateImage(string filePath, int rotation) { var originalImage = Android.Graphics.BitmapFactory.DecodeFile(filePath); var matrix = new Android.Graphics.Matrix(); matrix.PostRotate(rotation); var rotatedImage = Android.Graphics.Bitmap.CreateBitmap(originalImage, 0, 0, originalImage.Width, originalImage.Height, matrix, true); originalImage.Recycle(); return rotatedImage; }
private Android.Graphics.Bitmap LoadAndResizeBitmap(string fileName, Size newSize) { var exif = new ExifInterface(fileName); var width = exif.GetAttributeInt(ExifInterface.TagImageWidth, 100); var height = exif.GetAttributeInt(ExifInterface.TagImageLength, 80); var orientation = exif.GetAttribute(ExifInterface.TagOrientation); // We calculate the ratio that we need to resize the image by // in order to fit the requested dimensions. var inSampleSize = 1.0; if (newSize.Height < height || newSize.Width < width) { inSampleSize = newSize.Width > newSize.Height ? newSize.Height / height : newSize.Width / width; } var options = new Android.Graphics.BitmapFactory.Options { InJustDecodeBounds = false, InSampleSize = (int)inSampleSize }; // Now we will load the image and have BitmapFactory resize it for us. var resizedBitmap = Android.Graphics.BitmapFactory.DecodeFile(fileName, options); var rotate = false; switch (orientation) { case "1": // landscape case "3": // landscape if (width < height) rotate = true; break; case "8": case "4": case "6": // portrait if (width > height) rotate = true; break; case "0": //undefined default: break; } if (rotate) { var mtx = new Android.Graphics.Matrix(); mtx.PreRotate(90); resizedBitmap = Android.Graphics.Bitmap.CreateBitmap(resizedBitmap, 0, 0, resizedBitmap.Width, resizedBitmap.Height, mtx, false); mtx.Dispose(); mtx = null; } return resizedBitmap; }
private Android.Graphics.Bitmap LoadAndResizeBitmap(string fileName, Size newSize) { var exif = new ExifInterface(fileName); var width = exif.GetAttributeInt(ExifInterface.TagImageWidth, 100); var height = exif.GetAttributeInt(ExifInterface.TagImageLength, 80); var orientation = exif.GetAttribute(ExifInterface.TagOrientation); // We calculate the ratio that we need to resize the image by // in order to fit the requested dimensions. var inSampleSize = 1.0; if (newSize.Height < height || newSize.Width < width) { inSampleSize = newSize.Width > newSize.Height ? newSize.Height / height : newSize.Width / width; } var options = new Android.Graphics.BitmapFactory.Options { InJustDecodeBounds = false, InSampleSize = (int)inSampleSize }; // Now we will load the image and have BitmapFactory resize it for us. var resizedBitmap = Android.Graphics.BitmapFactory.DecodeFile(fileName, options); var rotate = false; switch (orientation) { case "1": // landscape case "3": // landscape if (width < height) { rotate = true; } break; case "8": case "4": case "6": // portrait if (width > height) { rotate = true; } break; case "0": //undefined default: break; } if (rotate) { var mtx = new Android.Graphics.Matrix(); mtx.PreRotate(90); resizedBitmap = Android.Graphics.Bitmap.CreateBitmap(resizedBitmap, 0, 0, resizedBitmap.Width, resizedBitmap.Height, mtx, false); mtx.Dispose(); mtx = null; } return(resizedBitmap); }
/// <summary> /// Write picture data to stream. The picture will be rotated if necessary. /// </summary> public async Task WriteDataToStream(byte[] data, Stream writeStream) { var rotate = _displayOrientation; if (rotate == 0) { using (var ms = new MemoryStream(data)) { await ms.CopyToAsync(writeStream); } } else { using (var sourceBm = await Android.Graphics.BitmapFactory.DecodeByteArrayAsync(data, 0, data.Length)) { using (var m = new Android.Graphics.Matrix()) { m.PostRotate(rotate); using (var bm = Android.Graphics.Bitmap.CreateBitmap(sourceBm, 0, 0, sourceBm.Width, sourceBm.Height, m, true)) { if (sourceBm != bm) { sourceBm.Recycle(); } await bm.CompressAsync(Android.Graphics.Bitmap.CompressFormat.Jpeg, 100, writeStream); bm.Recycle(); } } } } }
/// <summary> /// Rotate via EXIF information /// </summary> /// <param name="photoPath"></param> /// <returns></returns> public byte[] RotateImage(string photoPath) { Android.Graphics.BitmapFactory.Options options = new Android.Graphics.BitmapFactory.Options(); options.InPreferredConfig = Android.Graphics.Bitmap.Config.Argb8888; Android.Graphics.Bitmap bitmap = Android.Graphics.BitmapFactory.DecodeFile(photoPath, options); try { Android.Media.ExifInterface exifInterface = new Android.Media.ExifInterface(photoPath); int orientation = exifInterface.GetAttributeInt(Android.Media.ExifInterface.TagOrientation, (int)Android.Media.Orientation.Normal); int rotate = 0; switch (orientation) { case (int)Android.Media.Orientation.Normal: rotate = 0; break; case (int)Android.Media.Orientation.Rotate90: rotate = 90; break; case (int)Android.Media.Orientation.Rotate270: rotate = 270; break; case (int)Android.Media.Orientation.Rotate180: rotate = 180; break; default: rotate = 0; break; } using (var ms = new System.IO.MemoryStream()) { Android.Graphics.Bitmap croppedBitmap = null; Android.Graphics.Matrix mtx = new Android.Graphics.Matrix(); mtx.PreRotate(rotate); if (bitmap.Width >= bitmap.Height) { croppedBitmap = Android.Graphics.Bitmap.CreateBitmap( bitmap, bitmap.Width / 2 - bitmap.Height / 2, 0, bitmap.Height, bitmap.Height, mtx, false); } else { croppedBitmap = Android.Graphics.Bitmap.CreateBitmap( bitmap, 0, bitmap.Height / 2 - bitmap.Width / 2, bitmap.Width, bitmap.Width, mtx, false); } croppedBitmap.Compress(Android.Graphics.Bitmap.CompressFormat.Png, 100, ms); croppedBitmap.Recycle(); croppedBitmap.Dispose(); croppedBitmap = null; mtx.Dispose(); mtx = null; bitmap.Recycle(); bitmap.Dispose(); bitmap = null; return(ms.ToArray()); } } catch { // <!-- Fail out --> } return(null); }
public override void OnResourceReady(Java.Lang.Object p0, Com.Bumptech.Glide.Request.Transition.ITransition p1) { float density = currentContext.Resources.DisplayMetrics.Density; float MIN_WIDTH = 60 * density; float MAX_WIDTH = 200 * density; float MIN_HEIGHT = 60 * density; float MAX_HEIGHT = 200 * density; var resource = p0 as Android.Graphics.Bitmap; int imageWidth = resource.Width; int imageHeight = resource.Height; // 裁剪 bitmap float width, height; if (imageWidth > imageHeight) { if (imageWidth > MAX_WIDTH) { float temp = MAX_WIDTH / imageWidth * imageHeight; height = temp > MIN_HEIGHT ? temp : MIN_HEIGHT; width = MAX_WIDTH; } else if (imageWidth < MIN_WIDTH) { float temp = MIN_WIDTH / imageWidth * imageHeight; height = temp < MAX_HEIGHT ? temp : MAX_HEIGHT; width = MIN_WIDTH; } else { float ratio = imageWidth / imageHeight; if (ratio > 3) { ratio = 3; } height = imageHeight * ratio; width = imageWidth; } } else { if (imageHeight > MAX_HEIGHT) { float temp = MAX_HEIGHT / imageHeight * imageWidth; width = temp > MIN_WIDTH ? temp : MIN_WIDTH; height = MAX_HEIGHT; } else if (imageHeight < MIN_HEIGHT) { float temp = MIN_HEIGHT / imageHeight * imageWidth; width = temp < MAX_WIDTH ? temp : MAX_WIDTH; height = MIN_HEIGHT; } else { float ratio = imageHeight / imageWidth; if (ratio > 3) { ratio = 3; } width = imageWidth * ratio; height = imageHeight; } } var layoutParms = imageView.LayoutParameters; layoutParms.Width = (int)width; layoutParms.Height = (int)height; imageView.LayoutParameters = layoutParms; var matrix = new Android.Graphics.Matrix(); float scaleWidth = width / imageWidth; float scaleHeight = height / imageHeight; matrix.PostScale(scaleWidth, scaleHeight); imageView.SetImageBitmap(Android.Graphics.Bitmap.CreateBitmap(resource, 0, 0, imageWidth, imageHeight, matrix, true)); }
public void ResetTransform() { using (var m = new Android.Graphics.Matrix()) ACanvas.Matrix = m; }
internal virtual Android.Graphics.Matrix ToNative(Android.Graphics.Matrix targetMatrix = null, Size size = new Size(), bool isBrush = false) { throw new NotImplementedException(); }