Question

我有一个在Fling上旋转的Wheel的ImageView。旋转完成后，如何检测车轮的最终位置？基本上，类似于命运轮，结果取决于车轮停在哪里 enter image description here

有没有办法检测吊装/旋转何时完成，然后获得最终角度？我想将这个角度与圆圈中的4个象限中的一个相关联，并从中设置结果。谢谢，我的一些代码如下 //////////////////////////手势检测/////////////////

private class MyWheelOnTouchListener implements OnTouchListener {

 private double startAngle;

 @Override
 public boolean onTouch(View v, MotionEvent event) {

     switch (event.getAction()) {

         case MotionEvent.ACTION_DOWN:
             rotateAnim(); // test
            // reset the touched quadrants
             for (int i = 0; i < quadrantTouched.length; i++) {
                 quadrantTouched[i] = false;
             }

             allowRotating = false;

             startAngle = getAngle(event.getX(), event.getY());

             break;

         case MotionEvent.ACTION_MOVE:
             double currentAngle = getAngle(event.getX(), event.getY());
            rotateDialer((float) (startAngle - currentAngle));
             startAngle = currentAngle;
             break;

         case MotionEvent.ACTION_UP:
             allowRotating = true;
             break;
     }
     // set the touched quadrant to true
     quadrantTouched[getQuadrant(event.getX() - (wheelWidth / 2), wheelHeight - event.getY() - (wheelHeight / 2))] = true;

     wheeldetector.onTouchEvent(event);

     return true;
 }
}

/**
* Simple implementation of a {@link SimpleOnGestureListener} for detecting a fling event.
*/
private class MyWheelGestureDetector extends SimpleOnGestureListener {
    private double endAngle;
 @Override
 public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
     // get the quadrant of the start and the end of the fling
     int q1 = getQuadrant(e1.getX() - (wheelWidth / 2), wheelHeight - e1.getY() - (wheelHeight / 2));
     int q2 = getQuadrant(e2.getX() - (wheelWidth / 2), wheelHeight - e2.getY() - (wheelHeight / 2));

     // the inversed rotations
     if ((q1 == 2 && q2 == 2 && Math.abs(velocityX) < Math.abs(velocityY))
             || (q1 == 3 && q2 == 3)
             || (q1 == 1 && q2 == 3)
             || (q1 == 4 && q2 == 4 && Math.abs(velocityX) > Math.abs(velocityY))
             || ((q1 == 2 && q2 == 3) || (q1 == 3 && q2 == 2))
             || ((q1 == 3 && q2 == 4) || (q1 == 4 && q2 == 3))
             || (q1 == 2 && q2 == 4 && quadrantTouched[3])
             || (q1 == 4 && q2 == 2 && quadrantTouched[3])) {

         wheel.post(new FlingWheelRunnable(-1 * (velocityX + velocityY)));
     } else {
         // the normal rotation
         wheel.post(new FlingWheelRunnable(velocityX + velocityY));
     }
     endAngle = getAngle(e1.getX(), e2.getY());


     return true;
 }
}

/**
* A {@link Runnable} for animating the the dialer's fling.
*/
private class FlingWheelRunnable implements Runnable {

 private float velocity;

 public FlingWheelRunnable(float velocity) {
     this.velocity = velocity;
 }

 @Override
 public void run() {
     if (Math.abs(velocity) > 5) { // original = 5
         rotateDialer(velocity / 100); // original = 75
         velocity /= 1.0666F; // original = 1.0666F

        wheel.getRotation()); <-- maybe something like this, but not working??
         // post this instance again
         wheel.post(this);
     }

 }
}

/**
 * @return The angle of the unit circle with the image view's center
 */
private double getAngle(double xTouch, double yTouch) {
    double x = xTouch - (wheelWidth / 2d);
    double y = wheelHeight - yTouch - (wheelHeight / 2d);

    switch (getQuadrant(x, y)) {
        case 1:
            return Math.atan(y / x) * 180 / Math.PI;
        case 2:
            return 180 - Math.atan(y / x) * 180 / Math.PI;
        case 3:
            return 180 + (-1 * Math.atan(y / (x)) * 180 / Math.PI);
        case 4:
            return 360 + Math.atan(y / (x)) * 180 / Math.PI;
        default:
            return 0;
    }
}

/**
 * @return The selected quadrant.
 */
private static int getQuadrant(double x, double y) {
    if (x >= 0) {
        return y >= 0 ? 1 : 4;
    } else {
        return y >= 0 ? 2 : 3;
    }
}


/**
 * Rotate the wheel.
 *
 * @param degrees The degrees, the dialer should get rotated.
 */
private void rotateDialer(float degrees) {
    matrix.postRotate(degrees, wheelWidth / 2, wheelHeight / 2);
    wheel.setImageMatrix(matrix);




}

Answer 1

我不确定这会与您当前的实现兼容，但您是否尝试过检测最终轮的颜色？您需要做的就是使用BitmapFactory

加载它

Bitmap slice = BitmapFactory.decodeFile(); 
// just go through the documentation 
// to find the easiest, for you, way to load it

然后取出一个像素：

int slicePixel = slice.getPixel(0, 0);

最后检测颜色：

int red = Color.red(slicePixel);
int blue = Color.blue(slicePixel);
int green = Color.green(slicePixel);

希望这会有所帮助。

Answer 2

我最终以更简单的方式做到了这一点。我刚刚添加了一个随机角度（使用Math.random）函数，范围为0-360。然后添加了大约1800（动画5圈）。然后使用switch语句根据产生的随机角度确定结果。

Answer 3

我实际上将该函数放在我的rotateDialer函数中。我使用了以下代码：

    float[] vert = new float[9];
    matrix.getValues(vert) ;
    double bleh = Math.round(Math.atan2(vert[matrix.MSKEW_X], vert[matrix.MSCALE_X]) * (180 / Math.PI));

然后我不得不做其他算术，因为角度与我链接到数据的角度不匹配，但是如果你只是将它记录到控制台，你应该能够将它与你的匹配。

Sourced from here

如何确定旋转图像的最终位置或角度

3 个答案: