public ExifData(string filename)
{
var exif = new ExifInterface(filename);
_rawData = new Dictionary <string, object>
{
{ ExifInterface.TagAperture, exif.GetAttributeDouble(ExifInterface.TagAperture, 1) },
{ ExifInterface.TagDatetime, exif.GetAttribute(ExifInterface.TagDatetime) },
{ ExifInterface.TagExposureTime, exif.GetAttribute(ExifInterface.TagExposureTime) },
{ ExifInterface.TagFlash, exif.GetAttribute(ExifInterface.TagFlash) },
{ ExifInterface.TagFocalLength, exif.GetAttributeDouble(ExifInterface.TagFocalLength, 0) },
{ ExifInterface.TagGpsAltitude, exif.GetAttribute(ExifInterface.TagGpsAltitude) },
{ ExifInterface.TagGpsAltitudeRef, exif.GetAttribute(ExifInterface.TagGpsAltitudeRef) },
{ ExifInterface.TagGpsDatestamp, exif.GetAttribute(ExifInterface.TagGpsDatestamp) },
{ ExifInterface.TagGpsLatitude, exif.GetAttribute(ExifInterface.TagGpsLatitude) },
{ ExifInterface.TagGpsLatitudeRef, exif.GetAttribute(ExifInterface.TagGpsLatitudeRef) },
{ ExifInterface.TagGpsLongitude, exif.GetAttribute(ExifInterface.TagGpsLongitude) },
{ ExifInterface.TagGpsLongitudeRef, exif.GetAttribute(ExifInterface.TagGpsLongitudeRef) },
{ ExifInterface.TagGpsProcessingMethod, exif.GetAttribute(ExifInterface.TagGpsProcessingMethod) },
{ ExifInterface.TagGpsTimestamp, exif.GetAttribute(ExifInterface.TagGpsTimestamp) },
{ ExifInterface.TagImageLength, exif.GetAttribute(ExifInterface.TagImageLength) },
{ ExifInterface.TagImageWidth, exif.GetAttribute(ExifInterface.TagImageWidth) },
{ ExifInterface.TagIso, exif.GetAttribute(ExifInterface.TagIso) },
{ ExifInterface.TagMake, exif.GetAttribute(ExifInterface.TagMake) },
{ ExifInterface.TagModel, exif.GetAttribute(ExifInterface.TagModel) },
{ ExifInterface.TagOrientation, exif.GetAttributeInt(ExifInterface.TagOrientation, -1) },
{ ExifInterface.TagWhiteBalance, exif.GetAttributeInt(ExifInterface.TagWhiteBalance, 0) },
};
}
static int GetRotation(ExifInterface exif)
{
try
{
var orientation = exif.GetAttributeInt(ExifInterface.TagOrientation, ExifInterface.OrientationNormal);
switch (orientation)
{
case ExifInterface.OrientationRotate90:
return(90);
case ExifInterface.OrientationRotate180:
return(180);
case ExifInterface.OrientationRotate270:
return(270);
default:
return(0);
}
}
catch (Exception ex)
{
#if DEBUG
throw ex;
#else
return(0);
#endif
}
}
private Matrix GetMatrix(string imageAbsoluePath)
{
ExifInterface ei = new ExifInterface(imageAbsoluePath);
int orientation = ei.GetAttributeInt(ExifInterface.TagOrientation, (int)Android.Media.Orientation.Normal);
int rotate = 0;
switch (orientation)
{
case (int)Android.Media.Orientation.Rotate270:
rotate = 270;
break;
case (int)Android.Media.Orientation.Rotate180:
rotate = 180;
break;
case (int)Android.Media.Orientation.Rotate90:
rotate = 90;
break;
}
Matrix matrix = new Matrix();
matrix.PreRotate(rotate);
GC.Collect();
return(matrix);
}
private int GetRotation(string fileName)
{
var rotate = 0;
if (!String.IsNullOrEmpty(fileName))
{
ExifInterface exif = new ExifInterface(fileName);
//int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
var orientation = exif.GetAttributeInt(ExifInterface.TagOrientation, (int)Android.Media.Orientation.Normal);
switch (orientation)
{
case (int)Android.Media.Orientation.Rotate270:
rotate = 270;
break;
case (int)Android.Media.Orientation.Rotate180:
rotate = 180;
break;
case (int)Android.Media.Orientation.Rotate90:
rotate = 90;
break;
}
}
return(rotate);
}
/// <summary>
/// Получение Bitmap по пути до файла
/// </summary>
/// <param name="path">путь к файлу</param>
/// <returns></returns>
private Bitmap GetBitmap(string path)
{
byte[] imageArray = System.IO.File.ReadAllBytes(path);
ExifInterface exif = new ExifInterface(path);
int orientation = exif.GetAttributeInt(ExifInterface.TagOrientation, 1);
Matrix matrix = new Matrix();
switch (orientation)
{
case 3:
matrix.PostRotate(180);
break;
case 6:
matrix.PostRotate(90);
break;
case 8:
matrix.PostRotate(270);
break;
}
Bitmap bitmap = BitmapFactory.DecodeByteArray(imageArray, 0, imageArray.Length);
return(Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, matrix, true));
}
public static int CameraPhotoOrientation(Context context, Android.Net.Uri imageUri, String imagePath)
{
int rotate = 0;
try
{
context.ContentResolver.NotifyChange(imageUri, null);
Java.IO.File imageFile = new Java.IO.File(imagePath);
ExifInterface exif = new ExifInterface(imageFile.AbsolutePath);
//int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
var orientation = exif.GetAttributeInt(ExifInterface.TagOrientation, (int)Android.Media.Orientation.Normal);
switch (orientation)
{
case (int)Android.Media.Orientation.Rotate270:
rotate = 270;
break;
case (int)Android.Media.Orientation.Rotate180:
rotate = 180;
break;
case (int)Android.Media.Orientation.Rotate90:
rotate = 90;
break;
}
System.Diagnostics.Debug.WriteLine("Orientation for file " + imagePath + " is " + rotate);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("Exception during Camera orientations" + e.StackTrace + e.ToString());
}
return(rotate);
}
int NeededRotation(Java.IO.File ff)
{
try
{
// extract the header info
ExifInterface exif = new ExifInterface(ff.AbsolutePath);
// determine how we should rotate the image
int orientation = exif.GetAttributeInt(ExifInterface.TagOrientation, 0);
switch (orientation)
{
case 3: return(180);
case 6: return(90);
case 8: return(270);
}
return(0);
}
catch (Exception)
{
}
return(0);
}
public static int GetExifRotationDegrees(this string filePath)
{
int rotation = 0;
var exifInt = new ExifInterface(filePath);
int exifRotation = exifInt.GetAttributeInt(ExifInterface.TagOrientation, (int)Orientation.Normal);
switch (exifRotation)
{
case (int)Orientation.Rotate270:
rotation = 270;
break;
case (int)Orientation.Rotate180:
rotation = 180;
break;
case (int)Orientation.Rotate90:
rotation = 90;
break;
default:
return(0);
}
return(rotation);
}
public static int GetExifRotationDegrees(this Stream stream)
{
int rotation = 0;
var exifInt = new ExifInterface(stream);
int exifRotation = exifInt.GetAttributeInt(ExifInterface.TagOrientation, ExifInterface.OrientationNormal);
switch (exifRotation)
{
case ExifInterface.OrientationRotate270:
rotation = 270;
break;
case ExifInterface.OrientationRotate180:
rotation = 180;
break;
case ExifInterface.OrientationRotate90:
rotation = 90;
break;
default:
return(0);
}
return(rotation);
}
static int GetRotation(ExifInterface exif)
{
if (exif == null)
{
return(0);
}
try
{
var orientation = (Orientation)exif.GetAttributeInt(ExifInterface.TagOrientation, (int)Orientation.Normal);
switch (orientation)
{
case Orientation.Rotate90:
return(90);
case Orientation.Rotate180:
return(180);
case Orientation.Rotate270:
return(270);
default:
return(0);
}
}
catch (Exception ex)
{
#if DEBUG
throw ex;
#else
return(0);
#endif
}
}
public int GetRotation(ExifInterface exif)
{
try
{
var orientation = (Android.Media.Orientation)exif.GetAttributeInt(ExifInterface.TagOrientation, (int)Android.Media.Orientation.Normal);
switch (orientation)
{
case Android.Media.Orientation.Rotate90:
return(90);
case Android.Media.Orientation.Rotate180:
return(180);
case Android.Media.Orientation.Rotate270:
return(270);
default:
return(0);
}
}
catch (Exception ex)
{
//Console.WriteLine(ex);
return(0);
}
}
public static int?GetRotation(string filePath)
{
try
{
ExifInterface ei = new ExifInterface(filePath);
int orientation = Convert.ToInt16(ei.GetAttributeInt(ExifInterface.TagOrientation, (int)0));
switch (orientation)
{
case 6:
return(90);
case 3:
return(180);
case 8:
return(270);
default:
return(null);
}
}
catch (Exception ex)
{
// ex.report();
return(null);
}
}
private static Bitmap FixOrientation(Bitmap bitmap, string fileName)
{
ExifInterface exif = new ExifInterface(fileName);
int orientation = exif.GetAttributeInt(ExifInterface.TagOrientation, 1);
int rotationDegrees = 0;
switch (orientation)
{
case 6:
rotationDegrees = 90;
break;
case 3:
rotationDegrees = 180;
break;
case 8:
rotationDegrees = 270;
break;
}
Matrix matrix = new Matrix();
matrix.PostRotate(rotationDegrees);
return(Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, matrix, true));
}
/// <summary>
/// Load the image from the device, and resize it to the specified dimensions.
/// </summary>
/// <returns>The and resize bitmap.</returns>
/// <param name="fileName">File name.</param>
/// <param name="width">Width.</param>
/// <param name="height">Height.</param>
public static Bitmap LoadAndResizeBitmap(this string fileName, int width, int height)
{
// First we get the the dimensions of the file on disk
BitmapFactory.Options options = new BitmapFactory.Options
{
// InBitmap = true,
InJustDecodeBounds = true
};
BitmapFactory.DecodeFile(fileName, options);
ExifInterface exif = new ExifInterface(fileName);
var orientation = exif.GetAttributeInt(ExifInterface.TagOrientation, 1);
// Next we calculate the ratio that we need to resize the image by
// in order to fit the requested dimensions.
var outHeight = options.OutHeight;
var outWidth = options.OutWidth;
var inSampleSize = 1;
if (outHeight > height || outWidth > width)
{
inSampleSize = outWidth > outHeight
? outHeight / height
: outWidth / width;
}
// Now we will load the image and have BitmapFactory resize it for us.
// options.InSampleSize = inSampleSize;
options.InJustDecodeBounds = false;
var resizedBitmap = BitmapFactory.DecodeFile(fileName, options);
return(ExifRotateBitmap(fileName, resizedBitmap));
// return resizedBitmap;
}
static int GetRotation(string filePath)
{
try
{
using (var ei = new ExifInterface(filePath))
{
var orientation = (Orientation)ei.GetAttributeInt(ExifInterface.TagOrientation, (int)Orientation.Normal);
switch (orientation)
{
case Orientation.Rotate90:
return(90);
case Orientation.Rotate180:
return(180);
case Orientation.Rotate270:
return(270);
default:
return(0);
}
}
}
catch (Exception ex)
{
#if DEBUG
throw ex;
#else
return(0);
#endif
}
}
private int GetRotation(ExifInterface exif)
{
if (exif == null)
{
return(0);
}
try
{
var orientation = (Orientation)exif.GetAttributeInt(
ExifInterface.TagOrientation,
(int)Orientation.Normal);
switch (orientation)
{
case Orientation.Rotate90:
return(90);
case Orientation.Rotate180:
return(180);
case Orientation.Rotate270:
return(270);
default:
return(0);
}
}
catch (Exception ex)
{
loggingService.Error(ex);
return(0);
}
}
private static int GetRotation(string filePath)
{
using (var ei = new ExifInterface(filePath))
{
var orientation = (Android.Media.Orientation)ei.GetAttributeInt(ExifInterface.TagOrientation, (int)Android.Media.Orientation.Normal);
switch (orientation)
{
case Android.Media.Orientation.Rotate90:
return(90);
case Android.Media.Orientation.Rotate180:
return(180);
case Android.Media.Orientation.Rotate270:
return(270);
default:
return(0);
}
}
}
/// <summary>
/// Changes the orientation.
/// </summary>
/// <returns>The orientation.</returns>
/// <param name="mediafile">Mediafile.</param>
/// <param name="bitmap">Bitmap.</param>
public static Bitmap changeOrientation(ExifInterface exifInterface, Bitmap bitmap)
{
int orientation = exifInterface.GetAttributeInt(ExifInterface.TagOrientation, 1);
var matrix = new Matrix();
switch (orientation)
{
case 2:
matrix.SetScale(-1, 1);
break;
case 3:
matrix.SetRotate(180);
break;
case 4:
matrix.SetRotate(180);
matrix.PostScale(-1, 1);
break;
case 5:
matrix.SetRotate(90);
matrix.PostScale(-1, 1);
break;
case 6:
matrix.SetRotate(90);
break;
case 7:
matrix.SetRotate(-90);
matrix.PostScale(-1, 1);
break;
case 8:
matrix.SetRotate(-90);
break;
default:
return(bitmap);
}
try
{
Bitmap oriented = Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, matrix, true);
bitmap.Recycle();
return(oriented);
}
catch (OutOfMemoryError e)
{
e.PrintStackTrace();
return(bitmap);
}
catch (System.Exception e)
{
System.Diagnostics.Debug.WriteLine(e.Message);
return(bitmap);
}
}
private static Bitmap ResizeImage(System.IO.Stream image, Bitmap bitmap, int width, int height)
{
var originalPixelWidth = bitmap.Width;
var originalPixelHeight = bitmap.Height;
var widthRatio = (double)height / originalPixelWidth;
var heightRatio = (double)width / originalPixelHeight;
var aspectWidth = width;
var aspectHeight = height;
if (originalPixelWidth > originalPixelHeight)
{
aspectWidth = (int)(heightRatio * originalPixelWidth);
}
else
{
aspectHeight = (int)(widthRatio * originalPixelHeight);
}
var scaledBitmap = Bitmap.CreateBitmap(aspectWidth, aspectHeight, Bitmap.Config.Argb8888);
var ratioX = aspectWidth / (float)bitmap.Width;
var ratioY = aspectHeight / (float)bitmap.Height;
var middleX = aspectWidth / 2.0f;
var middleY = aspectHeight / 2.0f;
var scaleMatrix = new Matrix();
scaleMatrix.SetScale(ratioX, ratioY, middleX, middleY);
using var canvas = new Canvas(scaledBitmap)
{
Matrix = scaleMatrix
};
canvas.DrawBitmap(bitmap, middleX - bitmap.Width / 2, middleY - bitmap.Height / 2, new Paint(PaintFlags.FilterBitmap));
// check the rotation of the image and display it properly
using var exif = new ExifInterface(image);
var orientation = exif.GetAttributeInt(ExifInterface.TagOrientation, 0);
var matrix = new Matrix();
if (orientation == 6)
{
matrix.PostRotate(90);
}
else if (orientation == 3)
{
matrix.PostRotate(180);
}
else if (orientation == 8)
{
matrix.PostRotate(270);
}
scaledBitmap = Bitmap.CreateBitmap(scaledBitmap, 0, 0,
scaledBitmap.Width, scaledBitmap.Height, matrix,
true);
return(scaledBitmap);
}
public Photo(string filename)
{
Filename = filename;
// Get and set picture orienation
ExifInterface exif = new ExifInterface(Filename);
mOrientation = exif.GetAttributeInt(ExifInterface.TagOrientation, (int)PhotoOrienation.Normal);
}
/**
* Sets a Bitmap and initializes the image rotation according to the EXIT data.
* <p>
* The EXIF can be retrieved by doing the following:
* <code>ExifInterface exif = new ExifInterface(path);</code>
*
* @param bitmap the original bitmap to set; if null, this
* @param exif the EXIF information about this bitmap; may be null
*/
public void SetImageBitmap(Bitmap bitmap, ExifInterface exif)
{
try
{
if (bitmap == null)
{
return;
}
if (exif == null)
{
SetImageBitmap(bitmap);
return;
}
var matrix = new Matrix();
int orientation = exif.GetAttributeInt(ExifInterface.TagOrientation, 1);
int rotate = -1;
//TODO CHECK THIS FIX
switch (orientation)
{
case (int)Orientation.Rotate270:
rotate = 270;
break;
case (int)Orientation.Rotate180:
rotate = 180;
break;
case (int)Orientation.Rotate90:
rotate = 90;
break;
}
if (rotate == -1)
{
SetImageBitmap(bitmap);
}
else
{
matrix.PostRotate(rotate);
Bitmap rotatedBitmap = Bitmap.CreateBitmap(bitmap,
0,
0,
bitmap.Width,
bitmap.Height,
matrix,
true);
SetImageBitmap(rotatedBitmap);
bitmap.Recycle();
}
}
catch (Exception ex)
{
ex.ToString();
}
}
public Tuple <string, byte[]> ProcessCapturedPhoto(string filePath, bool needXMirroring = false)
{
ExifInterface exif = new ExifInterface(filePath);
var orientation = (Orientation)exif.GetAttributeInt(ExifInterface.TagOrientation, (int)Orientation.Undefined);
Bitmap bitmap = BitmapFactory.DecodeFile(filePath);
Matrix mtx = new Matrix();
switch (orientation)
{
case Orientation.Rotate180:
mtx.PreRotate(180);
break;
case Orientation.Rotate90: // portrait
mtx.PreRotate(90);
break;
case Orientation.Rotate270: // might need to flip horizontally too...
mtx.PreRotate(270);
break;
default:
mtx.PreRotate(90);
break;
case Orientation.Undefined: // Nexus 7 landscape...
case Orientation.Normal: // landscape
case Orientation.FlipHorizontal:
case Orientation.FlipVertical:
case Orientation.Transpose:
case Orientation.Transverse:
break;
}
if (needXMirroring)
{
mtx.PreScale(1, -1);
}
bitmap = Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, mtx, false);
mtx.Dispose();
mtx = null;
System.IO.MemoryStream stream = new System.IO.MemoryStream();
var compressionResult = bitmap.Compress(Bitmap.CompressFormat.Jpeg, 80, stream);
var id = Guid.NewGuid().ToString("n");
var filename = $"capture-{id}";
var imageByteArray = stream.GetBuffer();
var newFilePath = SavePictureAndThumbnail(imageByteArray, filename);
return(new Tuple <string, byte[]>(newFilePath, imageByteArray));
}
public static Bitmap LoadAndResizeBitmap(this string fileName, int width, int height, Context context)
{
// First we get the the dimensions of the file on disk
BitmapFactory.Options options = new BitmapFactory.Options {
InJustDecodeBounds = true
};
BitmapFactory.DecodeFile(fileName, options);
// Next we calculate the ratio that we need to resize the image by
// in order to fit the requested dimensions.
int outHeight = options.OutHeight;
int outWidth = options.OutWidth;
int inSampleSize = 1;
if (outHeight > height || outWidth > width)
{
inSampleSize = outWidth > outHeight
? outHeight / height
: outWidth / width;
}
// Now we will load the image and have BitmapFactory resize it for us.
options.InSampleSize = inSampleSize;
options.InJustDecodeBounds = false;
Bitmap resizedBitmap = BitmapFactory.DecodeFile(fileName, options);
//int orientation = ((BaseActivity)context).tempRotation;
ExifInterface exif = new ExifInterface(fileName);
int orientation = exif.GetAttributeInt(ExifInterface.TagOrientation, 1);
float angle = 0f;
switch (orientation)
{
case 6:
angle = 90f;
break;
case 3:
angle = 180f;
break;
case 8:
angle = 270f;
break;
}
Matrix matrix = new Matrix();
matrix.PostRotate(angle);
resizedBitmap = Bitmap.CreateBitmap(resizedBitmap, 0, 0, resizedBitmap.Width, resizedBitmap.Height, matrix, true);
GC.Collect();
return(resizedBitmap);
}
internal static Bitmap GetPictureWithRotation(Bitmap inBitmap, ExifInterface exif)
{
var orientation = (Orientation)exif.GetAttributeInt(ExifInterface.TagOrientation, (int)Orientation.Undefined);
Bitmap resultBitmap = inBitmap;
Matrix mtx = new Matrix();
switch (orientation)
{
case Orientation.Undefined: // Nexus 7 landscape...
break;
case Orientation.Normal: // landscape
break;
case Orientation.FlipHorizontal:
break;
case Orientation.Rotate180:
mtx.PreRotate(180);
resultBitmap = Bitmap.CreateBitmap(resultBitmap, 0, 0, resultBitmap.Width, resultBitmap.Height, mtx, false);
mtx.Dispose();
mtx = null;
break;
case Orientation.FlipVertical:
break;
case Orientation.Transpose:
break;
case Orientation.Rotate90: // portrait
mtx.PreRotate(90);
resultBitmap = Bitmap.CreateBitmap(resultBitmap, 0, 0, resultBitmap.Width, resultBitmap.Height, mtx, false);
mtx.Dispose();
mtx = null;
break;
case Orientation.Transverse:
break;
case Orientation.Rotate270: // might need to flip horizontally too...
mtx.PreRotate(270);
resultBitmap = Bitmap.CreateBitmap(resultBitmap, 0, 0, resultBitmap.Width, resultBitmap.Height, mtx, false);
mtx.Dispose();
mtx = null;
break;
default:
break;
}
return(resultBitmap);
}
private static Bitmap ResizeImageFile(string filePath, int maxSize)
{
Bitmap bp = BitmapFactory.DecodeFile(filePath);
int originalWidth = bp.Width;
int originalHeight = bp.Height;
ExifInterface exif = new ExifInterface(filePath);
int orientation = exif.GetAttributeInt(ExifInterface.TagOrientation, (int)Android.Media.Orientation.Normal);
int angle = 0;
switch (orientation)
{
case (int)Android.Media.Orientation.Normal:
break;
case (int)Android.Media.Orientation.Rotate90:
angle = 90;
break;
case (int)Android.Media.Orientation.Rotate180:
angle = 180;
break;
case (int)Android.Media.Orientation.Rotate270:
angle = 270;
break;
}
float resizeScale = 1;
if (originalWidth > maxSize || originalHeight > maxSize)
{
double ratio = (double)originalWidth / (double)originalHeight;
if (ratio > 1)
{
resizeScale = (float)maxSize / (float)originalWidth;
}
else
{
resizeScale = (float)maxSize / (float)originalHeight;
}
}
Matrix mat = new Matrix();
mat.PostScale(resizeScale, resizeScale);
mat.PostRotate((float)angle);
Bitmap capBitmap = Bitmap.CreateBitmap(bp, 0, 0, originalWidth, originalHeight, mat, true);
return(capBitmap);
}
static public Bitmap LoadFrom(string realPath)
{
if (!File.Exists(realPath))
{
Insight.Track("ChadderImage: Invalid real path");
return(null);
}
ExifInterface exif = new ExifInterface(realPath);
var a = exif.GetAttributeInt(ExifInterface.TagOrientation, -1);
return(SampledLoad(realPath, a));
}
public static Bitmap GetAndRotateBitmap(string fileName)
{
Bitmap bitmap = BitmapFactory.DecodeFile(fileName);
// Images are being saved in landscape, so rotate them back to portrait if they were taken in portrait
// See https://forums.xamarin.com/discussion/5409/photo-being-saved-in-landscape-not-portrait
// See http://developer.android.com/reference/android/media/ExifInterface.html
using (Matrix mtx = new Matrix())
{
if (Android.OS.Build.Product.Contains("Emulator"))
{
mtx.PreRotate(90);
}
else
{
ExifInterface exif = new ExifInterface(fileName);
var orientation = (Orientation)exif.GetAttributeInt(ExifInterface.TagOrientation, (int)Orientation.Normal);
//TODO : handle FlipHorizontal, FlipVertical, Transpose and Transverse
switch (orientation)
{
case Orientation.Rotate90:
mtx.PreRotate(90);
break;
case Orientation.Rotate180:
mtx.PreRotate(180);
break;
case Orientation.Rotate270:
mtx.PreRotate(270);
break;
case Orientation.Normal:
// Normal, do nothing
break;
default:
break;
}
}
if (mtx != null)
{
bitmap = Bitmap.CreateBitmap(bitmap, 0, 0, bitmap.Width, bitmap.Height, mtx, false);
}
}
return(bitmap);
}
public Task <byte[]> NormalizeAsync(byte[] imageData, float quality)
{
return(Task <byte[]> .Factory.StartNew(delegate {
int orient;
using (MemoryStream ms = new MemoryStream(imageData)) {
ExifInterface exif = new ExifInterface(ms);
orient = exif.GetAttributeInt(ExifInterface.TagOrientation, (int)Orientation.Undefined);
}
using (Bitmap bmp = BitmapFactory.DecodeByteArray(imageData, 0, imageData.Length)) {
Matrix m = new Matrix();
switch (orient)
{
case (int)Orientation.Rotate90:
m.PostRotate(90);
break;
case (int)Orientation.Rotate180:
m.PostRotate(180);
break;
case (int)Orientation.Rotate270:
m.PostRotate(270);
break;
default:
m = null;
break;
}
byte[] retVal = null;
if (m != null)
{
using (Bitmap normBmp = Bitmap.CreateBitmap(bmp, 0, 0, bmp.Width, bmp.Height, m, true)) {
using (MemoryStream ms = new MemoryStream()) {
normBmp.Compress(Bitmap.CompressFormat.Jpeg, (int)(quality * 100), ms);
retVal = ms.ToArray();
}
}
}
else
{
using (MemoryStream ms = new MemoryStream()) {
bmp.Compress(Bitmap.CompressFormat.Jpeg, (int)(quality * 100), ms);
retVal = ms.ToArray();
}
}
return (retVal);
}
}));
}
private static bool TryGetOrientation(string url, out Orientation rez)
{
try
{
var ei = new ExifInterface(url);
rez = (Orientation)ei.GetAttributeInt(ExifInterface.TagOrientation, (int)Orientation.Normal);
return(true);
}
catch
{
//nothing to do
}
rez = Orientation.Normal;
return(false);
}
