| /* |
| * Copyright (C) 2007 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.camera; |
| |
| import android.app.Activity; |
| import android.app.ProgressDialog; |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.graphics.Bitmap; |
| import android.graphics.Canvas; |
| import android.graphics.Matrix; |
| import android.graphics.Paint; |
| import android.graphics.PointF; |
| import android.graphics.PorterDuff; |
| import android.graphics.PorterDuffXfermode; |
| import android.graphics.Rect; |
| import android.graphics.RectF; |
| import android.graphics.Region; |
| import android.media.FaceDetector; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.provider.MediaStore; |
| import android.util.AttributeSet; |
| import android.util.Config; |
| import android.util.Log; |
| import android.view.Menu; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.Window; |
| import android.widget.Toast; |
| |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.io.FileOutputStream; |
| import java.util.ArrayList; |
| |
| public class CropImage extends Activity { |
| private static final String TAG = "CropImage"; |
| private ProgressDialog mFaceDetectionDialog = null; |
| private ProgressDialog mSavingProgressDialog = null; |
| private ImageManager.IImageList mAllImages; |
| private Bitmap.CompressFormat mSaveFormat = Bitmap.CompressFormat.JPEG; // only used with mSaveUri |
| private Uri mSaveUri = null; |
| private int mAspectX, mAspectY; |
| private int mOutputX, mOutputY; |
| private boolean mDoFaceDetection = true; |
| private boolean mCircleCrop = false; |
| private boolean mWaitingToPick; |
| private boolean mScale; |
| private boolean mSaving; |
| private boolean mScaleUp = true; |
| |
| CropImageView mImageView; |
| ContentResolver mContentResolver; |
| |
| Bitmap mBitmap; |
| Bitmap mCroppedImage; |
| HighlightView mCrop; |
| |
| ImageManager.IImage mImage; |
| |
| public CropImage() { |
| } |
| |
| @Override |
| public boolean onCreateOptionsMenu(Menu menu) { |
| return super.onCreateOptionsMenu(menu); |
| } |
| |
| static public class CropImageView extends ImageViewTouchBase { |
| ArrayList<HighlightView> mHighlightViews = new ArrayList<HighlightView>(); |
| HighlightView mMotionHighlightView = null; |
| float mLastX, mLastY; |
| int mMotionEdge; |
| |
| public CropImageView(Context context) { |
| super(context); |
| } |
| |
| @Override |
| protected boolean doesScrolling() { |
| return false; |
| } |
| |
| @Override |
| protected void onLayout(boolean changed, int left, int top, int right, int bottom) { |
| super.onLayout(changed, left, top, right, bottom); |
| if (mBitmapDisplayed != null) { |
| for (HighlightView hv : mHighlightViews) { |
| hv.mMatrix.set(getImageMatrix()); |
| hv.invalidate(); |
| if (hv.mIsFocused) { |
| centerBasedOnHighlightView(hv); |
| } |
| } |
| } |
| } |
| |
| public CropImageView(Context context, AttributeSet attrs) { |
| super(context, attrs); |
| } |
| |
| protected void zoomTo(float scale, float centerX, float centerY) { |
| super.zoomTo(scale, centerX, centerY); |
| for (HighlightView hv : mHighlightViews) { |
| hv.mMatrix.set(getImageMatrix()); |
| hv.invalidate(); |
| } |
| } |
| |
| protected void zoomIn() { |
| super.zoomIn(); |
| for (HighlightView hv : mHighlightViews) { |
| hv.mMatrix.set(getImageMatrix()); |
| hv.invalidate(); |
| } |
| } |
| |
| protected void zoomOut() { |
| super.zoomOut(); |
| for (HighlightView hv : mHighlightViews) { |
| hv.mMatrix.set(getImageMatrix()); |
| hv.invalidate(); |
| } |
| } |
| |
| |
| @Override |
| protected boolean usePerfectFitBitmap() { |
| return false; |
| } |
| |
| @Override |
| protected void postTranslate(float deltaX, float deltaY) { |
| super.postTranslate(deltaX, deltaY); |
| for (int i = 0; i < mHighlightViews.size(); i++) { |
| HighlightView hv = mHighlightViews.get(i); |
| hv.mMatrix.postTranslate(deltaX, deltaY); |
| hv.invalidate(); |
| } |
| } |
| |
| private void recomputeFocus(MotionEvent event) { |
| for (int i = 0; i < mHighlightViews.size(); i++) { |
| HighlightView hv = mHighlightViews.get(i); |
| hv.setFocus(false); |
| hv.invalidate(); |
| } |
| |
| for (int i = 0; i < mHighlightViews.size(); i++) { |
| HighlightView hv = mHighlightViews.get(i); |
| int edge = hv.getHit(event.getX(), event.getY()); |
| if (edge != HighlightView.GROW_NONE) { |
| if (!hv.hasFocus()) { |
| hv.setFocus(true); |
| hv.invalidate(); |
| } |
| break; |
| } |
| } |
| invalidate(); |
| } |
| |
| @Override |
| public boolean onTouchEvent(MotionEvent event) { |
| CropImage cropImage = (CropImage)mContext; |
| if (cropImage.mSaving) |
| return false; |
| |
| switch (event.getAction()) { |
| case MotionEvent.ACTION_DOWN: |
| if (cropImage.mWaitingToPick) { |
| recomputeFocus(event); |
| } else { |
| for (int i = 0; i < mHighlightViews.size(); i++) { |
| HighlightView hv = mHighlightViews.get(i); |
| int edge = hv.getHit(event.getX(), event.getY()); |
| if (edge != HighlightView.GROW_NONE) { |
| mMotionEdge = edge; |
| mMotionHighlightView = hv; |
| mLastX = event.getX(); |
| mLastY = event.getY(); |
| mMotionHighlightView.setMode(edge == HighlightView.MOVE |
| ? HighlightView.ModifyMode.Move |
| : HighlightView.ModifyMode.Grow); |
| break; |
| } |
| } |
| } |
| break; |
| case MotionEvent.ACTION_UP: |
| if (cropImage.mWaitingToPick) { |
| for (int i = 0; i < mHighlightViews.size(); i++) { |
| HighlightView hv = mHighlightViews.get(i); |
| if (hv.hasFocus()) { |
| cropImage.mCrop = hv; |
| for (int j = 0; j < mHighlightViews.size(); j++) { |
| if (j == i) |
| continue; |
| mHighlightViews.get(j).setHidden(true); |
| } |
| centerBasedOnHighlightView(hv); |
| ((CropImage)mContext).mWaitingToPick = false; |
| return true; |
| } |
| } |
| } else if (mMotionHighlightView != null) { |
| centerBasedOnHighlightView(mMotionHighlightView); |
| mMotionHighlightView.setMode(HighlightView.ModifyMode.None); |
| } |
| mMotionHighlightView = null; |
| break; |
| case MotionEvent.ACTION_MOVE: |
| if (cropImage.mWaitingToPick) { |
| recomputeFocus(event); |
| } else if (mMotionHighlightView != null) { |
| mMotionHighlightView.handleMotion(mMotionEdge, event.getX()-mLastX, event.getY()-mLastY); |
| mLastX = event.getX(); |
| mLastY = event.getY(); |
| |
| if (true) { |
| // This section of code is optional. It has some user |
| // benefit in that moving the crop rectangle against |
| // the edge of the screen causes scrolling but it means |
| // that the crop rectangle is no longer fixed under |
| // the user's finger. |
| ensureVisible(mMotionHighlightView); |
| } |
| } |
| break; |
| } |
| |
| switch (event.getAction()) { |
| case MotionEvent.ACTION_UP: |
| center(true, true, true); |
| break; |
| case MotionEvent.ACTION_MOVE: |
| // if we're not zoomed then there's no point in even allowing |
| // the user to move the image around. This call to center |
| // puts it back to the normalized location (with false meaning |
| // don't animate). |
| if (getScale() == 1F) |
| center(true, true, false); |
| break; |
| } |
| |
| return true; |
| } |
| |
| private void ensureVisible(HighlightView hv) { |
| Rect r = hv.mDrawRect; |
| |
| int panDeltaX1 = Math.max(0, mLeft - r.left); |
| int panDeltaX2 = Math.min(0, mRight - r.right); |
| |
| int panDeltaY1 = Math.max(0, mTop - r.top); |
| int panDeltaY2 = Math.min(0, mBottom - r.bottom); |
| |
| int panDeltaX = panDeltaX1 != 0 ? panDeltaX1 : panDeltaX2; |
| int panDeltaY = panDeltaY1 != 0 ? panDeltaY1 : panDeltaY2; |
| |
| if (panDeltaX != 0 || panDeltaY != 0) |
| panBy(panDeltaX, panDeltaY); |
| } |
| |
| private void centerBasedOnHighlightView(HighlightView hv) { |
| Rect drawRect = hv.mDrawRect; |
| |
| float width = drawRect.width(); |
| float height = drawRect.height(); |
| |
| float thisWidth = getWidth(); |
| float thisHeight = getHeight(); |
| |
| float z1 = thisWidth / width * .6F; |
| float z2 = thisHeight / height * .6F; |
| |
| float zoom = Math.min(z1, z2); |
| zoom = zoom * this.getScale(); |
| zoom = Math.max(1F, zoom); |
| |
| if ((Math.abs(zoom - getScale()) / zoom) > .1) { |
| float [] coordinates = new float[] { hv.mCropRect.centerX(), hv.mCropRect.centerY() }; |
| getImageMatrix().mapPoints(coordinates); |
| zoomTo(zoom, coordinates[0], coordinates[1], 300F); |
| } |
| |
| ensureVisible(hv); |
| } |
| |
| @Override |
| protected void onDraw(Canvas canvas) { |
| super.onDraw(canvas); |
| for (int i = 0; i < mHighlightViews.size(); i++) { |
| mHighlightViews.get(i).draw(canvas); |
| } |
| } |
| |
| public HighlightView get(int i) { |
| return mHighlightViews.get(i); |
| } |
| |
| public int size() { |
| return mHighlightViews.size(); |
| } |
| |
| public void add(HighlightView hv) { |
| mHighlightViews.add(hv); |
| invalidate(); |
| } |
| } |
| |
| private void fillCanvas(int width, int height, Canvas c) { |
| Paint paint = new Paint(); |
| paint.setColor(0x00000000); // pure alpha |
| paint.setStyle(android.graphics.Paint.Style.FILL); |
| paint.setAntiAlias(true); |
| paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR)); |
| c.drawRect(0F, 0F, width, height, paint); |
| } |
| |
| @Override |
| public void onCreate(Bundle icicle) { |
| super.onCreate(icicle); |
| mContentResolver = getContentResolver(); |
| |
| requestWindowFeature(Window.FEATURE_NO_TITLE); |
| setContentView(R.layout.cropimage); |
| |
| mImageView = (CropImageView) findViewById(R.id.image); |
| |
| MenuHelper.showStorageToast(this); |
| |
| try { |
| android.content.Intent intent = getIntent(); |
| Bundle extras = intent.getExtras(); |
| if (Config.LOGV) |
| Log.v(TAG, "extras are " + extras); |
| if (extras != null) { |
| for (String s: extras.keySet()) { |
| if (Config.LOGV) |
| Log.v(TAG, "" + s + " >>> " + extras.get(s)); |
| } |
| if (extras.getString("circleCrop") != null) { |
| mCircleCrop = true; |
| mAspectX = 1; |
| mAspectY = 1; |
| } |
| mSaveUri = (Uri) extras.getParcelable(MediaStore.EXTRA_OUTPUT); |
| if (mSaveUri != null) { |
| String compressFormatString = extras.getString("outputFormat"); |
| if (compressFormatString != null) |
| mSaveFormat = Bitmap.CompressFormat.valueOf(compressFormatString); |
| } |
| mBitmap = (Bitmap) extras.getParcelable("data"); |
| mAspectX = extras.getInt("aspectX"); |
| mAspectY = extras.getInt("aspectY"); |
| mOutputX = extras.getInt("outputX"); |
| mOutputY = extras.getInt("outputY"); |
| mScale = extras.getBoolean("scale", true); |
| mScaleUp = extras.getBoolean("scaleUpIfNeeded", true); |
| mDoFaceDetection = extras.containsKey("noFaceDetection") ? !extras.getBoolean("noFaceDetection") : true; |
| } |
| |
| if (mBitmap == null) { |
| Uri target = intent.getData(); |
| mAllImages = ImageManager.makeImageList(target, CropImage.this, ImageManager.SORT_ASCENDING); |
| mImage = mAllImages.getImageForUri(target); |
| if(mImage != null) { |
| // don't read in really large bitmaps. max out at 1000. |
| // TODO when saving the resulting bitmap use the decode/crop/encode |
| // api so we don't lose any resolution |
| mBitmap = mImage.thumbBitmap(); |
| if (Config.LOGV) |
| Log.v(TAG, "thumbBitmap returned " + mBitmap); |
| } |
| } |
| |
| if (mBitmap == null) { |
| finish(); |
| return; |
| } |
| |
| mHandler.postDelayed(new Runnable() { |
| public void run() { |
| mFaceDetectionDialog = ProgressDialog.show(CropImage.this, |
| null, |
| getResources().getString(R.string.runningFaceDetection), |
| true, false); |
| mImageView.setImageBitmapResetBase(mBitmap, true, true); |
| if (mImageView.getScale() == 1F) |
| mImageView.center(true, true, false); |
| |
| new Thread(new Runnable() { |
| public void run() { |
| final Bitmap b = mImage != null ? mImage.fullSizeBitmap(500) : mBitmap; |
| if (Config.LOGV) |
| Log.v(TAG, "back from mImage.fullSizeBitmap(500) with bitmap of size " + b.getWidth() + " / " + b.getHeight()); |
| mHandler.post(new Runnable() { |
| public void run() { |
| if (b != mBitmap && b != null) { |
| mBitmap = b; |
| mImageView.setImageBitmapResetBase(b, true, false); |
| } |
| if (mImageView.getScale() == 1F) |
| mImageView.center(true, true, false); |
| |
| new Thread(mRunFaceDetection).start(); |
| } |
| }); |
| } |
| }).start(); |
| }}, 100); |
| } catch (Exception e) { |
| Log.e(TAG, "Failed to load bitmap", e); |
| finish(); |
| } |
| |
| findViewById(R.id.discard).setOnClickListener(new android.view.View.OnClickListener() { |
| public void onClick(View v) { |
| setResult(RESULT_CANCELED); |
| finish(); |
| } |
| }); |
| |
| findViewById(R.id.save).setOnClickListener(new android.view.View.OnClickListener() { |
| public void onClick(View v) { |
| // TODO this code needs to change to use the decode/crop/encode single |
| // step api so that we don't require that the whole (possibly large) bitmap |
| // doesn't have to be read into memory |
| mSaving = true; |
| if (mCroppedImage == null) { |
| if (mCrop == null) { |
| if (Config.LOGV) |
| Log.v(TAG, "no cropped image..."); |
| return; |
| } |
| |
| Rect r = mCrop.getCropRect(); |
| |
| int width = r.width(); |
| int height = r.height(); |
| |
| // if we're circle cropping we'll want alpha which is the third param here |
| mCroppedImage = Bitmap.createBitmap(width, height, |
| mCircleCrop ? |
| Bitmap.Config.ARGB_8888 : |
| Bitmap.Config.RGB_565); |
| Canvas c1 = new Canvas(mCroppedImage); |
| c1.drawBitmap(mBitmap, r, new Rect(0, 0, width, height), null); |
| |
| if (mCircleCrop) { |
| // OK, so what's all this about? |
| // Bitmaps are inherently rectangular but we want to return something |
| // that's basically a circle. So we fill in the area around the circle |
| // with alpha. Note the all important PortDuff.Mode.CLEAR. |
| Canvas c = new Canvas (mCroppedImage); |
| android.graphics.Path p = new android.graphics.Path(); |
| p.addCircle(width/2F, height/2F, width/2F, android.graphics.Path.Direction.CW); |
| c.clipPath(p, Region.Op.DIFFERENCE); |
| |
| fillCanvas(width, height, c); |
| } |
| } |
| |
| /* If the output is required to a specific size then scale or fill */ |
| if (mOutputX != 0 && mOutputY != 0) { |
| |
| if (mScale) { |
| |
| /* Scale the image to the required dimensions */ |
| mCroppedImage = ImageLoader.transform(new Matrix(), |
| mCroppedImage, mOutputX, mOutputY, mScaleUp); |
| } else { |
| |
| /* Don't scale the image crop it to the size requested. |
| * Create an new image with the cropped image in the center and |
| * the extra space filled. |
| */ |
| |
| /* Don't scale the image but instead fill it so it's the required dimension */ |
| Bitmap b = Bitmap.createBitmap(mOutputX, mOutputY, Bitmap.Config.RGB_565); |
| Canvas c1 = new Canvas(b); |
| |
| /* Draw the cropped bitmap in the center */ |
| Rect r = mCrop.getCropRect(); |
| int left = (mOutputX / 2) - (r.width() / 2); |
| int top = (mOutputY / 2) - (r.width() / 2); |
| c1.drawBitmap(mBitmap, r, new Rect(left, top, left |
| + r.width(), top + r.height()), null); |
| |
| /* Set the cropped bitmap as the new bitmap */ |
| mCroppedImage = b; |
| } |
| } |
| |
| Bundle myExtras = getIntent().getExtras(); |
| if (myExtras != null && (myExtras.getParcelable("data") != null || myExtras.getBoolean("return-data"))) { |
| Bundle extras = new Bundle(); |
| extras.putParcelable("data", mCroppedImage); |
| setResult(RESULT_OK, |
| (new Intent()).setAction("inline-data").putExtras(extras)); |
| finish(); |
| } else { |
| if (!isFinishing()) { |
| mSavingProgressDialog = ProgressDialog.show(CropImage.this, |
| null, |
| getResources().getString(R.string.savingImage), |
| true, true); |
| } |
| Runnable r = new Runnable() { |
| public void run() { |
| if (mSaveUri != null) { |
| OutputStream outputStream = null; |
| try { |
| String scheme = mSaveUri.getScheme(); |
| if (scheme.equals("file")) { |
| outputStream = new FileOutputStream(mSaveUri.toString().substring(scheme.length()+":/".length())); |
| } else { |
| outputStream = mContentResolver.openOutputStream(mSaveUri); |
| } |
| if (outputStream != null) |
| mCroppedImage.compress(mSaveFormat, 75, outputStream); |
| |
| } catch (IOException ex) { |
| if (Config.LOGV) |
| Log.v(TAG, "got IOException " + ex); |
| } finally { |
| if (outputStream != null) { |
| try { |
| outputStream.close(); |
| } catch (IOException ex) { |
| |
| } |
| } |
| } |
| Bundle extras = new Bundle(); |
| setResult(RESULT_OK, |
| (new Intent()) |
| .setAction(mSaveUri.toString()) |
| .putExtras(extras)); |
| } else { |
| Bundle extras = new Bundle(); |
| extras.putString("rect", mCrop.getCropRect().toString()); |
| |
| // here we decide whether to create a new image or |
| // modify the existing image |
| if (false) { |
| /* |
| // this is the "modify" case |
| ImageManager.IGetBoolean_cancelable cancelable = |
| mImage.saveImageContents(mCroppedImage, null, null, null, mImage.getDateTaken(), 0, false); |
| boolean didSave = cancelable.get(); |
| extras.putString("thumb1uri", mImage.thumbUri().toString()); |
| setResult(RESULT_OK, |
| (new Intent()).setAction(mImage.fullSizeImageUri().toString()) |
| .putExtras(extras)); |
| */ |
| } else { |
| // this is the "new image" case |
| java.io.File oldPath = new java.io.File(mImage.getDataPath()); |
| java.io.File directory = new java.io.File(oldPath.getParent()); |
| |
| int x = 0; |
| String fileName = oldPath.getName(); |
| fileName = fileName.substring(0, fileName.lastIndexOf(".")); |
| |
| while (true) { |
| x += 1; |
| String candidate = directory.toString() + "/" + fileName + "-" + x + ".jpg"; |
| if (Config.LOGV) |
| Log.v(TAG, "candidate is " + candidate); |
| boolean exists = (new java.io.File(candidate)).exists(); |
| if (!exists) |
| break; |
| } |
| |
| try { |
| Uri newUri = ImageManager.instance().addImage( |
| CropImage.this, |
| getContentResolver(), |
| mImage.getTitle(), |
| mImage.getDescription(), |
| mImage.getDateTaken(), |
| null, // TODO this null is going to cause us to lose the location (gps) |
| 0, // TODO this is going to cause the orientation to reset |
| directory.toString(), |
| fileName + "-" + x + ".jpg"); |
| |
| ImageManager.IAddImage_cancelable cancelable = ImageManager.instance().storeImage( |
| newUri, |
| CropImage.this, |
| getContentResolver(), |
| 0, // TODO fix this orientation |
| mCroppedImage, |
| null); |
| |
| cancelable.get(); |
| setResult(RESULT_OK, |
| (new Intent()).setAction(newUri.toString()) |
| .putExtras(extras)); |
| } catch (Exception ex) { |
| // basically ignore this or put up |
| // some ui saying we failed |
| } |
| } |
| } |
| finish(); |
| } |
| }; |
| Thread t = new Thread(r); |
| t.start(); |
| } |
| } |
| }); |
| } |
| |
| @Override |
| public void onResume() { |
| super.onResume(); |
| } |
| |
| Handler mHandler = new Handler(); |
| |
| Runnable mRunFaceDetection = new Runnable() { |
| float mScale = 1F; |
| RectF mUnion = null; |
| Matrix mImageMatrix; |
| FaceDetector.Face[] mFaces = new FaceDetector.Face[3]; |
| int mNumFaces; |
| |
| private void handleFace(FaceDetector.Face f) { |
| PointF midPoint = new PointF(); |
| |
| int r = ((int)(f.eyesDistance() * mScale)) * 2 ; |
| f.getMidPoint(midPoint); |
| midPoint.x *= mScale; |
| midPoint.y *= mScale; |
| |
| int midX = (int) midPoint.x; |
| int midY = (int) midPoint.y; |
| |
| HighlightView hv = makeHighlightView(); |
| |
| int width = mBitmap.getWidth(); |
| int height = mBitmap.getHeight(); |
| |
| Rect imageRect = new Rect(0, 0, width, height); |
| |
| RectF faceRect = new RectF(midX, midY, midX, midY); |
| faceRect.inset(-r, -r); |
| if (faceRect.left < 0) |
| faceRect.inset(-faceRect.left, -faceRect.left); |
| |
| if (faceRect.top < 0) |
| faceRect.inset(-faceRect.top, -faceRect.top); |
| |
| if (faceRect.right > imageRect.right) |
| faceRect.inset(faceRect.right - imageRect.right, faceRect.right - imageRect.right); |
| |
| if (faceRect.bottom > imageRect.bottom) |
| faceRect.inset(faceRect.bottom - imageRect.bottom, faceRect.bottom - imageRect.bottom); |
| |
| hv.setup(mImageMatrix, imageRect, faceRect, mCircleCrop, mAspectX != 0 && mAspectY != 0); |
| |
| if (mUnion == null) { |
| mUnion = new RectF(faceRect); |
| } else { |
| mUnion.union(faceRect); |
| } |
| |
| mImageView.add(hv); |
| } |
| |
| private HighlightView makeHighlightView() { |
| return new HighlightView(mImageView); |
| } |
| |
| private void makeDefault() { |
| HighlightView hv = makeHighlightView(); |
| |
| int width = mBitmap.getWidth(); |
| int height = mBitmap.getHeight(); |
| |
| Rect imageRect = new Rect(0, 0, width, height); |
| |
| // make the default size about 4/5 of the width or height |
| int cropWidth = Math.min(width, height) * 4 / 5; |
| int cropHeight = cropWidth; |
| |
| if (mAspectX != 0 && mAspectY != 0) { |
| if (mAspectX > mAspectY) { |
| cropHeight = cropWidth * mAspectY / mAspectX; |
| // Log.v(TAG, "adjusted cropHeight to " + cropHeight); |
| } else { |
| cropWidth = cropHeight * mAspectX / mAspectY; |
| // Log.v(TAG, "adjusted cropWidth to " + cropWidth); |
| } |
| } |
| |
| int x = (width - cropWidth) / 2; |
| int y = (height - cropHeight) / 2; |
| |
| RectF cropRect = new RectF(x, y, x + cropWidth, y + cropHeight); |
| hv.setup(mImageMatrix, imageRect, cropRect, mCircleCrop, mAspectX != 0 && mAspectY != 0); |
| mImageView.add(hv); |
| } |
| |
| private Bitmap prepareBitmap() { |
| if (mBitmap == null) |
| return null; |
| |
| // scale the image down for faster face detection |
| // 256 pixels wide is enough. |
| if (mBitmap.getWidth() > 256) { |
| mScale = 256.0F / (float) mBitmap.getWidth(); |
| } |
| Matrix matrix = new Matrix(); |
| matrix.setScale(mScale, mScale); |
| Bitmap faceBitmap = Bitmap.createBitmap(mBitmap, 0, 0, mBitmap |
| .getWidth(), mBitmap.getHeight(), matrix, true); |
| return faceBitmap; |
| } |
| |
| public void run() { |
| mImageMatrix = mImageView.getImageMatrix(); |
| Bitmap faceBitmap = prepareBitmap(); |
| |
| mScale = 1.0F / mScale; |
| if (faceBitmap != null && mDoFaceDetection) { |
| FaceDetector detector = new FaceDetector(faceBitmap.getWidth(), |
| faceBitmap.getHeight(), mFaces.length); |
| mNumFaces = detector.findFaces(faceBitmap, mFaces); |
| if (Config.LOGV) |
| Log.v(TAG, "numFaces is " + mNumFaces); |
| } |
| mHandler.post(new Runnable() { |
| public void run() { |
| mWaitingToPick = mNumFaces > 1; |
| if (mNumFaces > 0) { |
| for (int i = 0; i < mNumFaces; i++) { |
| handleFace(mFaces[i]); |
| } |
| } else { |
| makeDefault(); |
| } |
| mImageView.invalidate(); |
| if (mImageView.mHighlightViews.size() == 1) { |
| mCrop = mImageView.mHighlightViews.get(0); |
| mCrop.setFocus(true); |
| } |
| |
| closeProgressDialog(); |
| |
| if (mNumFaces > 1) { |
| Toast t = Toast.makeText(CropImage.this, R.string.multiface_crop_help, Toast.LENGTH_SHORT); |
| t.show(); |
| } |
| } |
| }); |
| |
| } |
| }; |
| |
| @Override |
| public void onStop() { |
| closeProgressDialog(); |
| super.onStop(); |
| if (mAllImages != null) |
| mAllImages.deactivate(); |
| } |
| |
| private synchronized void closeProgressDialog() { |
| if (mFaceDetectionDialog != null) { |
| mFaceDetectionDialog.dismiss(); |
| mFaceDetectionDialog = null; |
| } |
| if (mSavingProgressDialog != null) { |
| mSavingProgressDialog.dismiss(); |
| mSavingProgressDialog = null; |
| } |
| } |
| } |