ARCore OpenGL ES Moving Object using onScroll

Question

I'm attempting to add in the moving of objects around with single finger scrolling. (See Google AR Stickers for example) I'm using native ARCore/OpenGL based originally off the ARCore examples. When you slide 1 finger, I want to move the object in 3D space along the X and Z axes.

I can easily create the movement using Translation, however, it performs the movement based on the original camera orientation. If you physically move the phone/camera a few lateral steps, the finger movements no longer match what a user would expect.

So I changed up my code and mapped the finger distanceX and distanceY that is swiped to affect X and Z coordinates depending on the angle of change from the original camera starting point to the current camera point.

The issue that I'm running into is determining the angle at which the camera has been moved. I've been looking at the value from the Camera View matrix:

camera.getViewMatrix(viewmtx, 0);

But the X, Y, and Z coordinates always say 0. I'm assuming this is because it's always making the camera the origin? Does anyone know of a way to calculate the angle of rotation of a camera from a 3D object using the ARCore/OpenGL ES libraries? The red angle in the illustration below (from top-down perspective) is what I'm trying to get. Sorry for the crude drawing:

Here's my code for your reference:

// Handle Gestures - Single touch for Translation and Placement
mGestureDetector = new GestureDetector(this, new GestureDetector.SimpleOnGestureListener()
{
  @Override
  public boolean onSingleTapUp(MotionEvent e)
  {
    onSingleTap(e);
    return true;
  }

  @Override
  public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)
  {
    if (e2.getPointerCount() == 1 && ...)
    {
      double angle = findCameraAngleFromOrigin();
      double speed = 0.005d;

      if (angle / 90d < 1) //Quadrant 1
      {
        double transX = -(distanceY * (angle / 90d)) + (distanceX * ((90d - angle) / 90d));
        double transY = (distanceY * ((90d - angle) / 90d)) + (distanceX * (angle / 90d));
        mTranslationX.set(mTranslationX.size() - 1, (float) (mTranslationX.get(mTranslationX.size() - 1) + (transX * -speed)));
        mTranslationZ.set(mTranslationZ.size() - 1, (float) (mTranslationZ.get(mTranslationZ.size() - 1) + (transY * -speed)));
      }
      else if (angle / 90d < 2) //Quadrant 2
      {
        angle -= 90d;
        double transX = (distanceX * (angle / 90d)) + (distanceY * ((90d - angle) / 90d));
        double transY = (-distanceX * ((90d - angle) / 90d)) + (distanceY * (angle / 90d));
        mTranslationX.set(mTranslationX.size() - 1, (float) (mTranslationX.get(mTranslationX.size() - 1) + (transX * speed)));
        mTranslationZ.set(mTranslationZ.size() - 1, (float) (mTranslationZ.get(mTranslationZ.size() - 1) + (transY * speed)));
      }
      else if (angle / 90d < 3) //Quadrant 3
      {
        angle -= 180d;
        double transX = (distanceY * (angle / 90d)) + (-distanceX * ((90d - angle) / 90d));
        double transY = (-distanceY * ((90d - angle) / 90d)) + (-distanceX * (angle / 90d));
        mTranslationX.set(mTranslationX.size() - 1, (float) (mTranslationX.get(mTranslationX.size() - 1) + (transX * -speed)));
        mTranslationZ.set(mTranslationZ.size() - 1, (float) (mTranslationZ.get(mTranslationZ.size() - 1) + (transY * -speed)));
      }
      else  //Quadrant 4
      {
        angle -= 270d;
        double transX = (-distanceX * (angle / 90d)) + (-distanceY * ((90d - angle) / 90d));
        double transY = (distanceX * ((90d - angle) / 90d)) + (-distanceY * (angle / 90d));
        mTranslationX.set(mTranslationX.size() - 1, (float) (mTranslationX.get(mTranslationX.size() - 1) + (transX * speed)));
        mTranslationZ.set(mTranslationZ.size() - 1, (float) (mTranslationZ.get(mTranslationZ.size() - 1) + (transY * speed)));
      }
      return true;
    }
    return false;
  }
}

EDIT: Update to code

Answer 1

I wasn't able to figure out how to find the distance from the camera points, but I was able to at least find the difference in the phone's rotation, which is closer. I accomplished it by the code below. I'm still not happy with the results, so I'll post updates later on when I find a more effective solution.

private double getDegree(double value1, double value2)
{
    double firstAngle = value1 * 90;
    double secondAngle = value2 * 90;
    if (secondAngle >= 0 && firstAngle >= 0)
    {
        Log.d(TAG, "FIRST QUADRANT");
        return firstAngle; // first quadrant
    }
    else if (secondAngle < 0 && firstAngle >= 0)
    {
        Log.d(TAG, "SECOND QUADRANT");
        return 90 + (90 - firstAngle); //second quadrant
    }
    else if (secondAngle < 0 && firstAngle < 0)
    {
        Log.d(TAG, "THIRD QUADRANT");
        return 180 - firstAngle; //third quadrant
    }
    else
    {
        Log.d(TAG, "FOURTH QUADRANT");
        return 270 + (90 + firstAngle); //fourth quadrant
    }
}

private double findCameraAngleFromOrigin()
{
    double angle = getDegree(mCurrentCameraMatrix[2], mCurrentCameraMatrix[0]) - getDegree(mOriginCameraMatrix[2], mOriginCameraMatrix[0]);
    if (angle < 0)
        return angle + 360;
    return angle;
}

@Override
public void onDrawFrame(GL10 gl)
{
    ...
    //When creating a new object
    Anchor anchor = hit.createAnchor();
    mAnchors.add(anchor);
    camera.getDisplayOrientedPose().toMatrix( mOriginCameraMatrix, 0);

    //During each draw frame
    camera.getDisplayOrientedPose().toMatrix( mCurrentCameraMatrix, 0);

    int ac = 0;
    for (Anchor anchor : mAnchors)
    {
      if (anchor.getTrackingState() != TrackingState.TRACKING)
      {
        continue;
      }
      // Get the current pose of an Anchor in world space. The Anchor pose is updated
      // during calls to session.update() as ARCore refines its estimate of the world.
      anchor.getPose().toMatrix(mAnchorMatrix, 0);

      // Update and draw the model
      if (mModelSet)
      {
        if (mScaleFactors.size() <= ac)
        {
          mScaleFactors.add(1.0f);
        }
        if (mRotationThetas.size() <= ac)
        {
          mRotationThetas.add(0.0f);
        }
        if (mTranslationX.size() <= ac)
        {
          mTranslationX.add(viewmtx[3]);
        }
        if (mTranslationZ.size() <= ac)
        {
          mTranslationZ.add(viewmtx[11]);
        }

        translateMatrix(mTranslationX.get(ac), 0, mTranslationZ.get(ac));
        rotateYAxisMatrix(mRotationThetas.get(ac));

        ObjectRenderer virtualObject = mVirtualObjects.get(mAnchorReferences.get(ac));
        virtualObject.updateModelMatrix(mAnchorMatrix, mScaleFactors.get(ac));
        virtualObject.draw(viewmtx, projmtx, lightIntensity);
      }
      ac++;
    }
}

This is kind of hard to track, so I'll probably just post the entire class once I feel more comfortable with the implementation and code cleanup.