diff options
-rw-r--r-- | jni_mosaic/feature_mos/src/mosaic/AlignFeatures.cpp | 231 | ||||
-rw-r--r-- | jni_mosaic/feature_mos/src/mosaic/AlignFeatures.h | 93 | ||||
-rw-r--r-- | src/com/android/camera/PanoProgressBar.java | 188 | ||||
-rw-r--r-- | src/com/android/camera/PreviewGestures.java | 329 |
4 files changed, 841 insertions, 0 deletions
diff --git a/jni_mosaic/feature_mos/src/mosaic/AlignFeatures.cpp b/jni_mosaic/feature_mos/src/mosaic/AlignFeatures.cpp new file mode 100644 index 000000000..aeabf8f97 --- /dev/null +++ b/jni_mosaic/feature_mos/src/mosaic/AlignFeatures.cpp @@ -0,0 +1,231 @@ +/* + * Copyright (C) 2011 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. + */ + +/////////////////////////////////////////////////// +// AlignFeatures.cpp +// S.O. # : +// Author(s): zkira, mbansal, bsouthall, narodits +// $Id: AlignFeatures.cpp,v 1.20 2011/06/17 13:35:47 mbansal Exp $ + +#include <stdio.h> +#include <string.h> + +#include "trsMatrix.h" +#include "MatrixUtils.h" +#include "AlignFeatures.h" +#include "Log.h" + +#define LOG_TAG "AlignFeatures" + +Align::Align() +{ + width = height = 0; + frame_number = 0; + num_frames_captured = 0; + reference_frame_index = 0; + db_Identity3x3(Hcurr); + db_Identity3x3(Hprev); +} + +Align::~Align() +{ + // Free gray-scale image + if (imageGray != ImageUtils::IMAGE_TYPE_NOIMAGE) + ImageUtils::freeImage(imageGray); +} + +char* Align::getRegProfileString() +{ + return reg.profile_string; +} + +int Align::initialize(int width, int height, bool _quarter_res, float _thresh_still) +{ + int nr_corners = DEFAULT_NR_CORNERS; + double max_disparity = DEFAULT_MAX_DISPARITY; + int motion_model_type = DEFAULT_MOTION_MODEL; + int nrsamples = DB_DEFAULT_NR_SAMPLES; + double scale = DB_POINT_STANDARDDEV; + int chunk_size = DB_DEFAULT_CHUNK_SIZE; + int nrhorz = width/48; // Empirically determined number of horizontal + int nrvert = height/60; // and vertical buckets for harris corner detection. + bool linear_polish = false; + unsigned int reference_update_period = DEFAULT_REFERENCE_UPDATE_PERIOD; + + const bool DEFAULT_USE_SMALLER_MATCHING_WINDOW = false; + bool use_smaller_matching_window = DEFAULT_USE_SMALLER_MATCHING_WINDOW; + + quarter_res = _quarter_res; + thresh_still = _thresh_still; + + frame_number = 0; + num_frames_captured = 0; + reference_frame_index = 0; + db_Identity3x3(Hcurr); + db_Identity3x3(Hprev); + + if (!reg.Initialized()) + { + reg.Init(width, height, motion_model_type, 20, linear_polish, quarter_res, + scale, reference_update_period, false, 0, nrsamples, chunk_size, + nr_corners, max_disparity, use_smaller_matching_window, + nrhorz, nrvert); + } + this->width = width; + this->height = height; + + imageGray = ImageUtils::allocateImage(width, height, 1); + + if (reg.Initialized()) + return ALIGN_RET_OK; + else + return ALIGN_RET_ERROR; +} + +int Align::addFrameRGB(ImageType imageRGB) +{ + ImageUtils::rgb2gray(imageGray, imageRGB, width, height); + return addFrame(imageGray); +} + +int Align::addFrame(ImageType imageGray_) +{ + int ret_code = ALIGN_RET_OK; + + // Obtain a vector of pointers to rows in image and pass in to dbreg + ImageType *m_rows = ImageUtils::imageTypeToRowPointers(imageGray_, width, height); + + if (frame_number == 0) + { + reg.AddFrame(m_rows, Hcurr, true); // Force this to be a reference frame + int num_corner_ref = reg.GetNrRefCorners(); + + if (num_corner_ref < MIN_NR_REF_CORNERS) + { + return ALIGN_RET_LOW_TEXTURE; + } + } + else + { + reg.AddFrame(m_rows, Hcurr, false); + } + + // Average translation per frame = + // [Translation from Frame0 to Frame(n-1)] / [(n-1)] + average_tx_per_frame = (num_frames_captured < 2) ? 0.0 : + Hprev[2] / (num_frames_captured - 1); + + // Increment the captured frame counter if we already have a reference frame + num_frames_captured++; + + if (frame_number != 0) + { + int num_inliers = reg.GetNrInliers(); + + if(num_inliers < MIN_NR_INLIERS) + { + ret_code = ALIGN_RET_FEW_INLIERS; + + Hcurr[0] = 1.0; + Hcurr[1] = 0.0; + // Set this as the average per frame translation taking into acccount + // the separation of the current frame from the reference frame... + Hcurr[2] = -average_tx_per_frame * + (num_frames_captured - reference_frame_index); + Hcurr[3] = 0.0; + Hcurr[4] = 1.0; + Hcurr[5] = 0.0; + Hcurr[6] = 0.0; + Hcurr[7] = 0.0; + Hcurr[8] = 1.0; + } + + if(fabs(Hcurr[2])<thresh_still && fabs(Hcurr[5])<thresh_still) // Still camera + { + return ALIGN_RET_ERROR; + } + + // compute the homography: + double Hinv33[3][3]; + double Hprev33[3][3]; + double Hcurr33[3][3]; + + // Invert and multiple with previous transformation + Matrix33::convert9to33(Hcurr33, Hcurr); + Matrix33::convert9to33(Hprev33, Hprev); + normProjMat33d(Hcurr33); + + inv33d(Hcurr33, Hinv33); + + mult33d(Hcurr33, Hprev33, Hinv33); + normProjMat33d(Hcurr33); + Matrix9::convert33to9(Hprev, Hcurr33); + // Since we have already factored the current transformation + // into Hprev, we can reset the Hcurr to identity + db_Identity3x3(Hcurr); + + // Update the reference frame to be the current frame + reg.UpdateReference(m_rows,quarter_res,false); + + // Update the reference frame index + reference_frame_index = num_frames_captured; + } + + frame_number++; + + return ret_code; +} + +// Get current transformation +int Align::getLastTRS(double trs[3][3]) +{ + if (frame_number < 1) + { + trs[0][0] = 1.0; + trs[0][1] = 0.0; + trs[0][2] = 0.0; + trs[1][0] = 0.0; + trs[1][1] = 1.0; + trs[1][2] = 0.0; + trs[2][0] = 0.0; + trs[2][1] = 0.0; + trs[2][2] = 1.0; + return ALIGN_RET_ERROR; + } + + // Note that the logic here handles the case, where a frame is not used for + // mosaicing but is captured and used in the preview-rendering. + // For these frames, we don't set Hcurr to identity in AddFrame() and the + // logic here appends their transformation to Hprev to render them with the + // correct transformation. For the frames we do use for mosaicing, we already + // append their Hcurr to Hprev in AddFrame() and then set Hcurr to identity. + + double Hinv33[3][3]; + double Hprev33[3][3]; + double Hcurr33[3][3]; + + Matrix33::convert9to33(Hcurr33, Hcurr); + normProjMat33d(Hcurr33); + inv33d(Hcurr33, Hinv33); + + Matrix33::convert9to33(Hprev33, Hprev); + + mult33d(trs, Hprev33, Hinv33); + normProjMat33d(trs); + + return ALIGN_RET_OK; +} + diff --git a/jni_mosaic/feature_mos/src/mosaic/AlignFeatures.h b/jni_mosaic/feature_mos/src/mosaic/AlignFeatures.h new file mode 100644 index 000000000..19f39051d --- /dev/null +++ b/jni_mosaic/feature_mos/src/mosaic/AlignFeatures.h @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2011 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. + */ + +/////////////////////////////////////////////////// +// Align.h +// S.O. # : +// Author(s): zkira +// $Id: AlignFeatures.h,v 1.13 2011/06/17 13:35:47 mbansal Exp $ + +#ifndef ALIGN_H +#define ALIGN_H + +#include "dbreg/dbreg.h" +#include <db_utilities_camera.h> + +#include "ImageUtils.h" +#include "MatrixUtils.h" + +class Align { + +public: + // Types of alignment possible + static const int ALIGN_TYPE_PAN = 1; + + // Return codes + static const int ALIGN_RET_LOW_TEXTURE = -2; + static const int ALIGN_RET_ERROR = -1; + static const int ALIGN_RET_OK = 0; + static const int ALIGN_RET_FEW_INLIERS = 1; + + ///// Settings for feature-based alignment + // Number of features to use from corner detection + static const int DEFAULT_NR_CORNERS=750; + static const double DEFAULT_MAX_DISPARITY=0.1;//0.4; + // Type of homography to model + static const int DEFAULT_MOTION_MODEL=DB_HOMOGRAPHY_TYPE_R_T; +// static const int DEFAULT_MOTION_MODEL=DB_HOMOGRAPHY_TYPE_PROJECTIVE; +// static const int DEFAULT_MOTION_MODEL=DB_HOMOGRAPHY_TYPE_AFFINE; + static const unsigned int DEFAULT_REFERENCE_UPDATE_PERIOD=1500; // Manual reference frame update so set this to a large number + + static const int MIN_NR_REF_CORNERS = 25; + static const int MIN_NR_INLIERS = 10; + + Align(); + ~Align(); + + // Initialization of structures, etc. + int initialize(int width, int height, bool quarter_res, float thresh_still); + + // Add a frame. Note: The alignment computation is performed + // in this function + int addFrameRGB(ImageType image); + int addFrame(ImageType image); + + // Obtain the TRS matrix from the last two frames + int getLastTRS(double trs[3][3]); + char* getRegProfileString(); + +protected: + + db_FrameToReferenceRegistration reg; + + int frame_number; + + double Hcurr[9]; // Homography from the alignment reference to the frame-t + double Hprev[9]; // Homography from frame-0 to the frame-(t-1) + + int reference_frame_index; // Index of the reference frame from all captured frames + int num_frames_captured; // Total number of frames captured (different from frame_number) + double average_tx_per_frame; // Average pixel translation per captured frame + + int width,height; + + bool quarter_res; // Whether to process at quarter resolution + float thresh_still; // Translation threshold in pixels to detect still camera + ImageType imageGray; +}; + + +#endif diff --git a/src/com/android/camera/PanoProgressBar.java b/src/com/android/camera/PanoProgressBar.java new file mode 100644 index 000000000..8dfb3660b --- /dev/null +++ b/src/com/android/camera/PanoProgressBar.java @@ -0,0 +1,188 @@ +/* + * Copyright (C) 2011 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.content.Context; +import android.graphics.Canvas; +import android.graphics.Paint; +import android.graphics.RectF; +import android.util.AttributeSet; +import android.widget.ImageView; + +class PanoProgressBar extends ImageView { + @SuppressWarnings("unused") + private static final String TAG = "PanoProgressBar"; + public static final int DIRECTION_NONE = 0; + public static final int DIRECTION_LEFT = 1; + public static final int DIRECTION_RIGHT = 2; + private float mProgress = 0; + private float mMaxProgress = 0; + private float mLeftMostProgress = 0; + private float mRightMostProgress = 0; + private float mProgressOffset = 0; + private float mIndicatorWidth = 0; + private int mDirection = 0; + private final Paint mBackgroundPaint = new Paint(); + private final Paint mDoneAreaPaint = new Paint(); + private final Paint mIndicatorPaint = new Paint(); + private float mWidth; + private float mHeight; + private RectF mDrawBounds; + private OnDirectionChangeListener mListener = null; + + public interface OnDirectionChangeListener { + public void onDirectionChange(int direction); + } + + public PanoProgressBar(Context context, AttributeSet attrs) { + super(context, attrs); + mDoneAreaPaint.setStyle(Paint.Style.FILL); + mDoneAreaPaint.setAlpha(0xff); + + mBackgroundPaint.setStyle(Paint.Style.FILL); + mBackgroundPaint.setAlpha(0xff); + + mIndicatorPaint.setStyle(Paint.Style.FILL); + mIndicatorPaint.setAlpha(0xff); + + mDrawBounds = new RectF(); + } + + public void setOnDirectionChangeListener(OnDirectionChangeListener l) { + mListener = l; + } + + private void setDirection(int direction) { + if (mDirection != direction) { + mDirection = direction; + if (mListener != null) { + mListener.onDirectionChange(mDirection); + } + invalidate(); + } + } + + public int getDirection() { + return mDirection; + } + + @Override + public void setBackgroundColor(int color) { + mBackgroundPaint.setColor(color); + invalidate(); + } + + public void setDoneColor(int color) { + mDoneAreaPaint.setColor(color); + invalidate(); + } + + public void setIndicatorColor(int color) { + mIndicatorPaint.setColor(color); + invalidate(); + } + + @Override + protected void onSizeChanged(int w, int h, int oldw, int oldh) { + mWidth = w; + mHeight = h; + mDrawBounds.set(0, 0, mWidth, mHeight); + } + + public void setMaxProgress(int progress) { + mMaxProgress = progress; + } + + public void setIndicatorWidth(float w) { + mIndicatorWidth = w; + invalidate(); + } + + public void setRightIncreasing(boolean rightIncreasing) { + if (rightIncreasing) { + mLeftMostProgress = 0; + mRightMostProgress = 0; + mProgressOffset = 0; + setDirection(DIRECTION_RIGHT); + } else { + mLeftMostProgress = mWidth; + mRightMostProgress = mWidth; + mProgressOffset = mWidth; + setDirection(DIRECTION_LEFT); + } + invalidate(); + } + + public void setProgress(int progress) { + // The panning direction will be decided after user pan more than 10 degrees in one + // direction. + if (mDirection == DIRECTION_NONE) { + if (progress > 10) { + setRightIncreasing(true); + } else if (progress < -10) { + setRightIncreasing(false); + } + } + // mDirection might be modified by setRightIncreasing() above. Need to check again. + if (mDirection != DIRECTION_NONE) { + mProgress = progress * mWidth / mMaxProgress + mProgressOffset; + // value bounds. + mProgress = Math.min(mWidth, Math.max(0, mProgress)); + if (mDirection == DIRECTION_RIGHT) { + // The right most progress is adjusted. + mRightMostProgress = Math.max(mRightMostProgress, mProgress); + } + if (mDirection == DIRECTION_LEFT) { + // The left most progress is adjusted. + mLeftMostProgress = Math.min(mLeftMostProgress, mProgress); + } + invalidate(); + } + } + + public void reset() { + mProgress = 0; + mProgressOffset = 0; + setDirection(DIRECTION_NONE); + invalidate(); + } + + @Override + protected void onDraw(Canvas canvas) { + // the background + canvas.drawRect(mDrawBounds, mBackgroundPaint); + if (mDirection != DIRECTION_NONE) { + // the progress area + canvas.drawRect(mLeftMostProgress, mDrawBounds.top, mRightMostProgress, + mDrawBounds.bottom, mDoneAreaPaint); + // the indication bar + float l; + float r; + if (mDirection == DIRECTION_RIGHT) { + l = Math.max(mProgress - mIndicatorWidth, 0f); + r = mProgress; + } else { + l = mProgress; + r = Math.min(mProgress + mIndicatorWidth, mWidth); + } + canvas.drawRect(l, mDrawBounds.top, r, mDrawBounds.bottom, mIndicatorPaint); + } + + // draw the mask image on the top for shaping. + super.onDraw(canvas); + } +} diff --git a/src/com/android/camera/PreviewGestures.java b/src/com/android/camera/PreviewGestures.java new file mode 100644 index 000000000..2dccc3e45 --- /dev/null +++ b/src/com/android/camera/PreviewGestures.java @@ -0,0 +1,329 @@ +/* + * Copyright (C) 2012 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.os.Handler; +import android.os.Message; +import android.util.Log; +import android.view.MotionEvent; +import android.view.ScaleGestureDetector; +import android.view.View; +import android.view.ViewConfiguration; + +import com.android.camera.ui.PieRenderer; +import com.android.camera.ui.RenderOverlay; +import com.android.camera.ui.ZoomRenderer; + +import java.util.ArrayList; +import java.util.List; + +public class PreviewGestures + implements ScaleGestureDetector.OnScaleGestureListener { + + private static final String TAG = "CAM_gestures"; + + private static final long TIMEOUT_PIE = 200; + private static final int MSG_PIE = 1; + private static final int MODE_NONE = 0; + private static final int MODE_PIE = 1; + private static final int MODE_ZOOM = 2; + private static final int MODE_MODULE = 3; + private static final int MODE_ALL = 4; + + private CameraActivity mActivity; + private CameraModule mModule; + private RenderOverlay mOverlay; + private PieRenderer mPie; + private ZoomRenderer mZoom; + private MotionEvent mDown; + private MotionEvent mCurrent; + private ScaleGestureDetector mScale; + private List<View> mReceivers; + private int mMode; + private int mSlop; + private int mTapTimeout; + private boolean mEnabled; + private boolean mZoomOnly; + private int mOrientation; + private int[] mLocation; + + private Handler mHandler = new Handler() { + public void handleMessage(Message msg) { + if (msg.what == MSG_PIE) { + mMode = MODE_PIE; + openPie(); + cancelActivityTouchHandling(mDown); + } + } + }; + + public PreviewGestures(CameraActivity ctx, CameraModule module, + ZoomRenderer zoom, PieRenderer pie) { + mActivity = ctx; + mModule = module; + mPie = pie; + mZoom = zoom; + mMode = MODE_ALL; + mScale = new ScaleGestureDetector(ctx, this); + mSlop = (int) ctx.getResources().getDimension(R.dimen.pie_touch_slop); + mTapTimeout = ViewConfiguration.getTapTimeout(); + mEnabled = true; + mLocation = new int[2]; + } + + public void setRenderOverlay(RenderOverlay overlay) { + mOverlay = overlay; + } + + public void setOrientation(int orientation) { + mOrientation = orientation; + } + + public void setEnabled(boolean enabled) { + mEnabled = enabled; + if (!enabled) { + cancelPie(); + } + } + + public void setZoomOnly(boolean zoom) { + mZoomOnly = zoom; + } + + public void addTouchReceiver(View v) { + if (mReceivers == null) { + mReceivers = new ArrayList<View>(); + } + mReceivers.add(v); + } + + public void clearTouchReceivers() { + if (mReceivers != null) { + mReceivers.clear(); + } + } + + public boolean dispatchTouch(MotionEvent m) { + if (!mEnabled) { + return mActivity.superDispatchTouchEvent(m); + } + mCurrent = m; + if (MotionEvent.ACTION_DOWN == m.getActionMasked()) { + if (checkReceivers(m)) { + mMode = MODE_MODULE; + return mActivity.superDispatchTouchEvent(m); + } else { + mMode = MODE_ALL; + mDown = MotionEvent.obtain(m); + if (mPie != null && mPie.showsItems()) { + mMode = MODE_PIE; + return sendToPie(m); + } + if (mPie != null && !mZoomOnly) { + mHandler.sendEmptyMessageDelayed(MSG_PIE, TIMEOUT_PIE); + } + if (mZoom != null) { + mScale.onTouchEvent(m); + } + // make sure this is ok + return mActivity.superDispatchTouchEvent(m); + } + } else if (mMode == MODE_NONE) { + return false; + } else if (mMode == MODE_PIE) { + if (MotionEvent.ACTION_POINTER_DOWN == m.getActionMasked()) { + sendToPie(makeCancelEvent(m)); + if (mZoom != null) { + onScaleBegin(mScale); + } + } else { + return sendToPie(m); + } + return true; + } else if (mMode == MODE_ZOOM) { + mScale.onTouchEvent(m); + if (!mScale.isInProgress() && MotionEvent.ACTION_POINTER_UP == m.getActionMasked()) { + mMode = MODE_NONE; + onScaleEnd(mScale); + } + return true; + } else if (mMode == MODE_MODULE) { + return mActivity.superDispatchTouchEvent(m); + } else { + // didn't receive down event previously; + // assume module wasn't initialzed and ignore this event. + if (mDown == null) { + return true; + } + if (MotionEvent.ACTION_POINTER_DOWN == m.getActionMasked()) { + if (!mZoomOnly) { + cancelPie(); + sendToPie(makeCancelEvent(m)); + } + if (mZoom != null) { + mScale.onTouchEvent(m); + onScaleBegin(mScale); + } + } else if ((mMode == MODE_ZOOM) && !mScale.isInProgress() + && MotionEvent.ACTION_POINTER_UP == m.getActionMasked()) { + // user initiated and stopped zoom gesture without zooming + mScale.onTouchEvent(m); + onScaleEnd(mScale); + } + // not zoom or pie mode and no timeout yet + if (mZoom != null) { + boolean res = mScale.onTouchEvent(m); + if (mScale.isInProgress()) { + cancelPie(); + cancelActivityTouchHandling(m); + return res; + } + } + if (MotionEvent.ACTION_UP == m.getActionMasked()) { + cancelPie(); + cancelActivityTouchHandling(m); + // must have been tap + if (m.getEventTime() - mDown.getEventTime() < mTapTimeout) { + mModule.onSingleTapUp(null, + (int) mDown.getX() - mOverlay.getWindowPositionX(), + (int) mDown.getY() - mOverlay.getWindowPositionY()); + return true; + } else { + return mActivity.superDispatchTouchEvent(m); + } + } else if (MotionEvent.ACTION_MOVE == m.getActionMasked()) { + if ((Math.abs(m.getX() - mDown.getX()) > mSlop) + || Math.abs(m.getY() - mDown.getY()) > mSlop) { + // moved too far and no timeout yet, no focus or pie + cancelPie(); + if (isSwipe(m, true)) { + mMode = MODE_MODULE; + return mActivity.superDispatchTouchEvent(m); + } else { + cancelActivityTouchHandling(m); + if (isSwipe(m , false)) { + mMode = MODE_NONE; + } else if (!mZoomOnly) { + mMode = MODE_PIE; + openPie(); + sendToPie(m); + } + } + } + } + return false; + } + } + + private boolean checkReceivers(MotionEvent m) { + if (mReceivers != null) { + for (View receiver : mReceivers) { + if (isInside(m, receiver)) { + return true; + } + } + } + return false; + } + + // left tests for finger moving right to left + private boolean isSwipe(MotionEvent m, boolean left) { + float dx = 0; + float dy = 0; + switch (mOrientation) { + case 0: + dx = m.getX() - mDown.getX(); + dy = Math.abs(m.getY() - mDown.getY()); + break; + case 90: + dx = - (m.getY() - mDown.getY()); + dy = Math.abs(m.getX() - mDown.getX()); + break; + case 180: + dx = -(m.getX() - mDown.getX()); + dy = Math.abs(m.getY() - mDown.getY()); + break; + case 270: + dx = m.getY() - mDown.getY(); + dy = Math.abs(m.getX() - mDown.getX()); + break; + } + if (left) { + return (dx < 0 && dy / -dx < 0.6f); + } else { + return (dx > 0 && dy / dx < 0.6f); + } + } + + private boolean isInside(MotionEvent evt, View v) { + v.getLocationInWindow(mLocation); + return (v.getVisibility() == View.VISIBLE + && evt.getX() >= mLocation[0] && evt.getX() < mLocation[0] + v.getWidth() + && evt.getY() >= mLocation[1] && evt.getY() < mLocation[1] + v.getHeight()); + } + + public void cancelActivityTouchHandling(MotionEvent m) { + mActivity.superDispatchTouchEvent(makeCancelEvent(m)); + } + + private MotionEvent makeCancelEvent(MotionEvent m) { + MotionEvent c = MotionEvent.obtain(m); + c.setAction(MotionEvent.ACTION_CANCEL); + return c; + } + + private void openPie() { + mDown.offsetLocation(-mOverlay.getWindowPositionX(), + -mOverlay.getWindowPositionY()); + mOverlay.directDispatchTouch(mDown, mPie); + } + + private void cancelPie() { + mHandler.removeMessages(MSG_PIE); + } + + private boolean sendToPie(MotionEvent m) { + m.offsetLocation(-mOverlay.getWindowPositionX(), + -mOverlay.getWindowPositionY()); + return mOverlay.directDispatchTouch(m, mPie); + } + + @Override + public boolean onScale(ScaleGestureDetector detector) { + return mZoom.onScale(detector); + } + + @Override + public boolean onScaleBegin(ScaleGestureDetector detector) { + if (mMode != MODE_ZOOM) { + mMode = MODE_ZOOM; + cancelActivityTouchHandling(mCurrent); + } + if (mCurrent.getActionMasked() != MotionEvent.ACTION_MOVE) { + return mZoom.onScaleBegin(detector); + } else { + return true; + } + } + + @Override + public void onScaleEnd(ScaleGestureDetector detector) { + if (mCurrent.getActionMasked() != MotionEvent.ACTION_MOVE) { + mZoom.onScaleEnd(detector); + } + } +} |