com.google.ar.core.Anchor Java Examples

void handleResolveAnchorError(Anchor anchor, boolean notTracking,
                              Anchor.CloudAnchorState state) {

    if (mPairingStateChangeListener != null) {
        mPairingStateChangeListener
                .onStateChange(
                        PairView.PairState.PARTNER_RESOLVE_ERROR,
                        state, false);
    }

    if (anchor != null) {
        anchor.detach();
    }

    readyToSetAnchor = false;
    partnerReadyToSetAnchor = false;

    mRoomDbManager.setAnchorResolutionError(mUserUid);
}
 

@JavascriptInterface
public void registerAnchor(final String requestId, final float[] matrix) {
    if (requestId == null || matrix == null) {
        return;
    }

    mSurfaceView.queueEvent(new Runnable() {
        @Override
        public void run() {
            Pose anchorPose = Pose.makeTranslation(matrix[12], matrix[13], matrix[14]);
            Anchor anchor = mSession.createAnchor(anchorPose);

            final String scriptString = "ARCoreBridge.registerAnchorResponse('" + requestId + "', '" + String.valueOf(anchor.hashCode()) + "');";
            evaluateWebViewJavascript(scriptString);
        }
    });
}
 

private static boolean isReturnableStatus(Anchor.CloudAnchorState status) {
    switch (status) {
        case SUCCESS:
        case ERROR_INTERNAL:
        case ERROR_NOT_AUTHORIZED:
        case ERROR_SERVICE_UNAVAILABLE:
        case ERROR_RESOURCE_EXHAUSTED:
        case ERROR_HOSTING_DATASET_PROCESSING_FAILED:
        case ERROR_CLOUD_ID_NOT_FOUND:
        case ERROR_RESOLVING_LOCALIZATION_NO_MATCH:
        case ERROR_RESOLVING_SDK_VERSION_TOO_NEW:
        case ERROR_RESOLVING_SDK_VERSION_TOO_OLD:
            return true;
        case NONE:
        case TASK_IN_PROGRESS:
        default:
            return false;
    }
}
 

public void setTrackingStates(Frame frame, Anchor anchor) {
    trackingState = frame.getCamera().getTrackingState();
    anchorTrackingState = anchor == null ? null : anchor.getTrackingState();

    if (trackingState != TrackingState.TRACKING && !mNotTrackingEscalating) {
        mNotTrackingEscalating = true;
        mHandler.postDelayed(mTrackingIndicatorTimeoutRunnable,
                SURFACE_RENDER_TIMEOUT_INTERVAL);
    }

    if (trackingState == TrackingState.TRACKING) {
        resetTrackingTimeout();
    }

    updateUI();
}
 

public void setAnchorTracking(Anchor anchor) {
    String trackingStateString = null;
    if (anchor != null) {
        switch (anchor.getTrackingState()) {
            case TRACKING:
                trackingStateString = "Anchor TRACKING";
                break;
            case PAUSED:
                trackingStateString = "Anchor PAUSED tracking";
                break;
            case STOPPED:
                trackingStateString = "Anchor STOPPED tracking";
                break;
        }
    }
    mAnchorTrackingTextView.setText(trackingStateString);
}
 

/**
 * Resolve an anchor with the given ID
 */
public void resolveAnchorFromAnchorId() {
    mHostManager.resolveHostedAnchor(
            mAnchorId, new HostedAnchorManager.AnchorResolvedListener() {
                @Override
                public void onAnchorResolved(final Anchor anchor,
                                             final Anchor.CloudAnchorState state, boolean notTracking) {
                    if (isInRoom() && mPartnerInFlow) {
                        if (notTracking || state != Anchor.CloudAnchorState.SUCCESS) {
                            handleResolveAnchorError(anchor, notTracking, state);

                            String reason = null;
                            if (notTracking) {
                                reason = AnalyticsEvents.VALUE_PAIR_ERROR_SYNC_REASON_NOT_TRACKING;
                            } else if (state != null) {
                                reason = state.toString();
                            }

                            Fa.get().send(AnalyticsEvents.EVENT_PAIR_ERROR_SYNC,
                                    AnalyticsEvents.PARAM_PAIR_ERROR_SYNC_REASON, reason);
                            return;
                        }
                        mAnchor = anchor;

                        // set anchor resolved in room before activity so that strokes
                        // can be added
                        mRoomDbManager.setAnchorResolved(mUserUid);

                        if (mAnchorStateListener != null) {
                            mAnchorStateListener.setAnchor(anchor);
                        }
                    }
                }
            });
}
 

private void addNode(ArFragment fragment, Anchor createAnchor, ModelRenderable renderable) {

        AnchorNode anchorNode = new AnchorNode(createAnchor);
        TransformableNode transformableNode = new TransformableNode(fragment.getTransformationSystem());
        transformableNode.setRenderable(renderable);
        transformableNode.setParent(anchorNode);
        fragment.getArSceneView().getScene().addChild(anchorNode);
        transformableNode.select();
    }
 

private void clearAll() {
    Collection<Anchor> anchors = arFragment.getArSceneView().getSession().getAllAnchors();
    Log.w(TAG, "clearAll: " + anchors.size());
    if (anchors.size() > 0) {
        for (Anchor anchor : anchors) {
            anchor.detach();
        }
    }
}
 

public void removeAnchor(String identifier) {
	if (_anchors.containsKey(identifier)) {
		Anchor a = _anchors.get(identifier);
		a.detach();
		_anchors.remove(identifier);
	} else {
		DeviceLog.warning("Anchor with identifier: " + identifier + " doesn't exist.");
	}
}
 

public void addAnchor(String identifier, String matrix) {
	if (_session == null) {
		DeviceLog.warning("Session is null. Not adding anchor.");
		return;
	}

	String[] floats = matrix.split(",");
	if (floats.length != 16) {
		DeviceLog.warning("Matrix doesn't have 16 elements. Not adding anchor.");
		return;
	}

	float[] anchorMatrix = new float[16];
	for (int i = 0; i < 16; i++) {
		try {
			anchorMatrix[i] = Float.parseFloat(floats[i]);
		} catch (NumberFormatException ignored) {
			DeviceLog.warning("Cannot parse matrix. Not adding anchor.");
			return;
		}
	}

	float quaternion[] = new float[4];
	matrix4x4ToQuaternion(anchorMatrix, quaternion);
	float translation[] = new float[3];
	matrix4x4ToTranslation(anchorMatrix, translation);

	Pose pose = new Pose(translation, quaternion);
	Anchor a = _session.createAnchor(pose);
	_anchors.put(identifier, a);
}
 

/**
 * This method obtains a hosted anchor using the ARCore S&P APIs, and then makes the results
 * available via the response listener.
 *
 * @param anchorId The anchor ID of the anchor
 * @param listener The listener which should be invoked when the results become available.
 */
public synchronized boolean resolveHostedAnchor(String anchorId,
                                                AnchorResolvedListener listener) {
    checkSessionNotNull();

    try {
        Anchor tempAnchor = session.resolveCloudAnchor(anchorId);
        Anchor.CloudAnchorState state = tempAnchor.getCloudAnchorState();
        Log.d(TAG, "resolveHostedAnchor: " + state);
        if (isReturnableStatus(state)) {
            Log.d(TAG, "resolveHostedAnchor: returnable status");
            if (listener != null) {
                listener.onAnchorResolved(tempAnchor, state, false);
            }
        } else {
            pendingResolve = new Pair<>(tempAnchor, listener);
        }

        return true;
    } catch (NotTrackingException e) {
        Log.w(TAG, "resolveHostedAnchor: error ", e);
        if (listener != null) {
            listener.onAnchorResolved(null, null, true);
        }
        return false;
    }
}
 

/**
 * This method hosts an anchor using the ARCore S&P APIs.
 *
 * @param anchor   The anchor to be hosted.
 * @param listener The listener to be invoked when the results become available.
 */
public synchronized void hostAnchor(Anchor anchor, AnchorHostedListener listener) {
    checkSessionNotNull();
    Anchor cloudAnchor = session.hostCloudAnchor(anchor);
    if (listener != null) {
        pendingHost = new Pair<>(cloudAnchor, listener);
    }
}
 

@Override
void handleResolveAnchorError(Anchor anchor, boolean notTracking,
                              Anchor.CloudAnchorState state) {
    if (mPairedOrPairing == JOINING) {
        if (mPairingStateChangeListener != null) {
            mPairingStateChangeListener.onStateChange(GLOBAL_RESOLVE_ERROR, state, notTracking);
        }

        if (anchor != null) {
            anchor.detach();
        }
    } else {
        super.handleResolveAnchorError(anchor, notTracking, state);
    }
}
 

@Override
public void onStateChange(final PairState state,
                          final Anchor.CloudAnchorState cloudAnchorState,
                          final boolean notTracking) {
    handler.post(new Runnable() {
        @Override
        public void run() {
            if (notTracking) {
                setState(state, "NotTrackingException");
            } else {
                setState(state, cloudAnchorState == null ? null : cloudAnchorState.toString());
            }
        }
    });
}
 

@Override
public void clearAnchor(Anchor anchor) {
    if (anchor != null && anchor.equals(mAnchor)) {
        for (Stroke stroke : mStrokes) {
            stroke.offsetFromPose(mAnchor.getPose());
        }
        mAnchor = null;
        Matrix.setIdentityM(mLineShaderRenderer.mModelMatrix, 0);
    }
}
 

@Override
public void setAnchor(Anchor anchor) {
    mAnchor = anchor;

    for (Stroke stroke : mStrokes) {
        Log.d(TAG, "setAnchor: pushing line");
        stroke.offsetToPose(mAnchor.getPose());
        mPairSessionManager.addStroke(stroke);
    }

    mLineShaderRenderer.bNeedsUpdate.set(true);
}
 

void update() {
    final Frame frame;
    try {
        frame = mSession.update();
    } catch (CameraNotAvailableException e) {
        e.printStackTrace();
        return;
    }
    final Camera camera = frame.getCamera();

    if (camera.getTrackingState() == TrackingState.PAUSED) {
        return;
    }

    camera.getViewMatrix(mViewMatrix, 0);
    camera.getProjectionMatrix(mProjectionMatrix, 0, 0.02f, 20.0f);

    final String cameraUpdateString = "ARCoreBridge.viewProjectionMatrixUpdate('" + serializeArray(mViewMatrix) +"', '"+ serializeArray(mProjectionMatrix) + "');";
    evaluateWebViewJavascript(cameraUpdateString);

    HashMap<String, float[]> anchorMap = new HashMap<>();

    for (Anchor anchor : mSession.getAllAnchors()) {
        if (anchor.getTrackingState() != TrackingState.TRACKING) {
            continue;
        }

        final float[] anchorPoseMatrix = new float[16];
        anchor.getPose().toMatrix(anchorPoseMatrix, 0);
        anchorMap.put(String.valueOf(anchor.hashCode()), anchorPoseMatrix);
    }

    if (anchorMap.size() > 0) {
        JSONObject jsonAnchors = new JSONObject(anchorMap);
        final String anchorUpdateScript = "ARCoreBridge.anchorTransformUpdate('" + jsonAnchors.toString() + "');";
        evaluateWebViewJavascript(anchorUpdateScript);
    }

    if (frame.getLightEstimate().getState() != LightEstimate.State.NOT_VALID) {
        final float[] colorCorrectionRgba = new float[4];
        frame.getLightEstimate().getColorCorrection(colorCorrectionRgba, 0);
        
        final String lightEstimateUpdateScript = "ARCoreBridge.lightingEstimateUpdate(" +
                String.valueOf(frame.getLightEstimate().getPixelIntensity()) + ", " +
                convertRgbaToTemperature(colorCorrectionRgba) + ");";
        evaluateWebViewJavascript(lightEstimateUpdateScript);
    }

    // Image Recognition
    Collection<AugmentedImage> updatedAugmentedImages = frame.getUpdatedTrackables(AugmentedImage.class);
    for (AugmentedImage img : updatedAugmentedImages) {
        if (img.getTrackingState() == TrackingState.TRACKING) {
            if (img.getName().equals("SumerianAnchorImage")) {
                imageAnchorCreated(img);
            }
        }
    }
}
 

public LocationNode(Anchor anchor, LocationMarker locationMarker, LocationScene locationScene) {
    super(anchor);
    this.locationMarker = locationMarker;
    this.locationScene = locationScene;
}
 

public void refreshAnchorsIfRequired(Frame frame) {
    if (anchorsNeedRefresh) {
        anchorsNeedRefresh = false;

        for (int i = 0; i < mLocationMarkers.size(); i++) {
            try {

                int markerDistance = (int) Math.round(
                        LocationUtils.distance(
                                mLocationMarkers.get(i).latitude,
                                deviceLocation.currentBestLocation.getLatitude(),
                                mLocationMarkers.get(i).longitude,
                                deviceLocation.currentBestLocation.getLongitude(),
                                0,
                                0)
                );

                float markerBearing = deviceOrientation.currentDegree + (float) LocationUtils.bearing(
                        deviceLocation.currentBestLocation.getLatitude(),
                        deviceLocation.currentBestLocation.getLongitude(),
                        mLocationMarkers.get(i).latitude,
                        mLocationMarkers.get(i).longitude);

                markerBearing = markerBearing + bearingAdjustment;
                markerBearing = markerBearing % 360;

                double rotation = Math.floor(markerBearing);
                rotation = rotation * Math.PI / 180;

                int renderDistance = markerDistance;

                // Limit the distance of the Anchor within the scene.
                // Prevents uk.co.appoly.arcorelocation.rendering issues.
                if (renderDistance > distanceLimit)
                    renderDistance = distanceLimit;

                // Adjustment to add markers on horizon, instead of just directly in front of camera
                double heightAdjustment = Math.round(renderDistance * (Math.tan(Math.toRadians(deviceOrientation.pitch))));

                // Raise distant markers for better illusion of distance
                // Hacky - but it works as a temporary measure
                int cappedRealDistance = markerDistance > 500 ?  500 : markerDistance;
                if (renderDistance != markerDistance)
                    heightAdjustment += 0.01F * (cappedRealDistance - renderDistance);

                float x = 0;
                float z = -renderDistance;

                float zRotated = (float) (z * Math.cos(rotation) - x * Math.sin(rotation));
                float xRotated = (float) -(z * Math.sin(rotation) + x * Math.cos(rotation));

                // Current camera height
                float y = frame.getCamera().getDisplayOrientedPose().ty();

                // Don't immediately assign newly created anchor in-case of exceptions
                Anchor newAnchor = mSession.createAnchor(
                        frame.getCamera().getPose()
                                .compose(Pose.makeTranslation(xRotated, y + (float) heightAdjustment, zRotated)));

                mLocationMarkers.get(i).anchor = newAnchor;

                mLocationMarkers.get(i).renderer.createOnGlThread(mContext, markerDistance);

            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }
}
 

@Override
public void onDrawFrame(GL10 gl) {
  // Clear screen to notify driver it should not load any pixels from previous frame.
  GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);

  // If we are ready to import the object and haven't done so yet, do it now.
  if (mReadyToImport && virtualObject == null) {
    importDownloadedObject();
  }

  if (session == null) {
    return;
  }
  // Notify ARCore session that the view size changed so that the perspective matrix and
  // the video background can be properly adjusted.
  displayRotationHelper.updateSessionIfNeeded(session);

  try {
    session.setCameraTextureName(backgroundRenderer.getTextureId());

    // Obtain the current frame from ARSession. When the configuration is set to
    // UpdateMode.BLOCKING (it is by default), this will throttle the rendering to the
    // camera framerate.
    Frame frame = session.update();
    Camera camera = frame.getCamera();

    // Handle one tap per frame.
    handleTap(frame, camera);

    // Draw background.
    backgroundRenderer.draw(frame);

    // If not tracking, don't draw 3d objects.
    if (camera.getTrackingState() == TrackingState.PAUSED) {
      return;
    }

    // Get projection matrix.
    float[] projmtx = new float[16];
    camera.getProjectionMatrix(projmtx, 0, 0.1f, 100.0f);

    // Get camera matrix and draw.
    float[] viewmtx = new float[16];
    camera.getViewMatrix(viewmtx, 0);

    // Compute lighting from average intensity of the image.
    // The first three components are color scaling factors.
    // The last one is the average pixel intensity in gamma space.
    final float[] colorCorrectionRgba = new float[4];
    frame.getLightEstimate().getColorCorrection(colorCorrectionRgba, 0);

    // Visualize tracked points.
    PointCloud pointCloud = frame.acquirePointCloud();
    pointCloudRenderer.update(pointCloud);
    pointCloudRenderer.draw(viewmtx, projmtx);

    // Application is responsible for releasing the point cloud resources after
    // using it.
    pointCloud.release();

    // Check if we detected at least one plane. If so, hide the loading message.
    if (messageSnackbarHelper.isShowing()) {
      for (Plane plane : session.getAllTrackables(Plane.class)) {
        if (plane.getTrackingState() == TrackingState.TRACKING) {
          messageSnackbarHelper.hide(this);
          break;
        }
      }
    }

    // Visualize planes.
    planeRenderer.drawPlanes(
        session.getAllTrackables(Plane.class), camera.getDisplayOrientedPose(), projmtx);

    // Visualize anchors created by touch.
    float scaleFactor = 1.0f;
    for (Anchor anchor : anchors) {
      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(anchorMatrix, 0);

      // Update and draw the model.
      if (virtualObject != null) {
        virtualObject.updateModelMatrix(anchorMatrix, ASSET_SCALE * scaleFactor);
        virtualObject.draw(viewmtx, projmtx, colorCorrectionRgba);

        // If we haven't yet showing the attribution toast, do it now.
        if (!mShowedAttributionToast) {
          showAttributionToast();
        }
      }
    }

  } catch (Throwable t) {
    // Avoid crashing the application due to unhandled exceptions.
    Log.e(TAG, "Exception on the OpenGL thread", t);
  }
}
 

void onStateChange(PairView.PairState state,
Anchor.CloudAnchorState cloudAnchorState, boolean notTracking);
 

/**
 * Update the HostManager with the most recent updatedAnchors to get host status
 */
public void onUpdate(Collection<Anchor> updatedAnchors) {
    if (isInRoom()) {
        mHostManager.onUpdate(updatedAnchors);
    }
}
 

@Override
public void onDrawFrame(GL10 gl) {
    // Clear screen to notify driver it should not load any pixels from previous frame.
    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);

    if (session == null) {
        return;
    }
    // Notify ARCore session that the view size changed so that the perspective matrix and
    // the video background can be properly adjusted.
    displayRotationHelper.updateSessionIfNeeded(session);

    try {
        session.setCameraTextureName(backgroundRenderer.getTextureId());

        // Obtain the current frame from ARSession. When the configuration is set to
        // UpdateMode.BLOCKING (it is by default), this will throttle the rendering to the
        // camera framerate.
        Frame frame = session.update();
        Camera camera = frame.getCamera();

        // Handle taps. Handling only one tap per frame, as taps are usually low frequency
        // compared to frame rate.

        MotionEvent tap = queuedSingleTaps.poll();
        if (tap != null && camera.getTrackingState() == TrackingState.TRACKING) {
            for (HitResult hit : frame.hitTest(tap)) {
                // Check if any plane was hit, and if it was hit inside the plane polygon
                Trackable trackable = hit.getTrackable();
                // Creates an anchor if a plane or an oriented point was hit.
                if ((trackable instanceof Plane && ((Plane) trackable).isPoseInPolygon(hit.getHitPose()))
                    || (trackable instanceof Point
                    && ((Point) trackable).getOrientationMode()
                    == Point.OrientationMode.ESTIMATED_SURFACE_NORMAL)) {
                    // Hits are sorted by depth. Consider only closest hit on a plane or oriented point.
                    // Cap the number of objects created. This avoids overloading both the
                    // rendering system and ARCore.
                    if (anchors.size() >= 20) {
                        anchors.get(0).detach();
                        anchors.remove(0);
                    }
                    // Adding an Anchor tells ARCore that it should track this position in
                    // space. This anchor is created on the Plane to place the 3D model
                    // in the correct position relative both to the world and to the plane.
                    anchors.add(hit.createAnchor());
                    break;
                }
            }
        }


        // Draw background, which is the what the camera is actually capturing.
        backgroundRenderer.draw(frame);

        // Check if we detected at least one plane. If so, hide the loading message.
        if (messageSnackbar != null) {
            for (Plane plane : session.getAllTrackables(Plane.class)) {
                if (plane.getType() == com.google.ar.core.Plane.Type.HORIZONTAL_UPWARD_FACING
                    && plane.getTrackingState() == TrackingState.TRACKING) {
                    hideLoadingMessage();
                    break;
                }
            }
        }


        // If not tracking, don't draw 3d objects.
        if (camera.getTrackingState() == TrackingState.PAUSED) {
            return;
        }
        // Get projection matrix.
        float[] projmtx = new float[16];
        camera.getProjectionMatrix(projmtx, 0, 0.1f, 100.0f);

        // Get camera matrix and draw.
        float[] viewmtx = new float[16];
        camera.getViewMatrix(viewmtx, 0);

        // Visualize anchors created by touch.
        // ie get the anchors from taps and now draw a cube for each place.
        float scaleFactor = 1.0f;
        for (Anchor anchor : anchors) {
            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(anchorMatrix, 0);

            // Update and draw the model and its shadow.
            mCube.updateModelMatrix(anchorMatrix, scaleFactor);
            mCube.draw(viewmtx, projmtx);
        }

    } catch (Throwable t) {
        // Avoid crashing the application due to unhandled exceptions.
        Log.e(TAG, "Exception on the OpenGL thread", t);
    }
}
 

/**
 * This method is invoked when the results of a HostAnchor call are available.
 *
 * @param anchor   The hosted anchor.
 * @param anchorId The anchor ID of the hosted anchor.
 * @param state    The final status of the call.
 */
void onAnchorHosted(Anchor anchor, String anchorId, Anchor.CloudAnchorState state);
 

/**
 * This method is invoked when the results of a GetHostedAnchor call are available.
 *
 * @param anchor The resolved anchor.
 * @param state  The final status of the call.
 */
void onAnchorResolved(Anchor anchor, Anchor.CloudAnchorState state, boolean notTracking);
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    if (!checkIsSupportedDeviceOrFinish(this)) {
        Toast.makeText(getApplicationContext(), "Device not supported", Toast.LENGTH_LONG).show();
    }

    setContentView(R.layout.activity_main);

    arFragment = (ArFragment) getSupportFragmentManager().findFragmentById(R.id.ux_fragment);
    tvDistance = findViewById(R.id.tvDistance);


    initModel();

    arFragment.setOnTapArPlaneListener((hitResult, plane, motionEvent) -> {
        if (cubeRenderable == null)
            return;

        // Creating Anchor.
        Anchor anchor = hitResult.createAnchor();
        AnchorNode anchorNode = new AnchorNode(anchor);
        anchorNode.setParent(arFragment.getArSceneView().getScene());

        clearAnchor();

        currentAnchor = anchor;
        currentAnchorNode = anchorNode;


        TransformableNode node = new TransformableNode(arFragment.getTransformationSystem());
        node.setRenderable(cubeRenderable);
        node.setParent(anchorNode);
        arFragment.getArSceneView().getScene().addOnUpdateListener(this);
        arFragment.getArSceneView().getScene().addChild(anchorNode);
        node.select();


    });


}
 

void clearAnchor(Anchor anchor); 

void setAnchor(Anchor anchor);