Java TangoCoordinateFramePair类代码示例

import com.google.atap.tangoservice.TangoCoordinateFramePair; //导入依赖的package包/类
private static DeviceExtrinsics setupExtrinsics(Tango tango) {
    // Create camera to IMU transform.
    TangoCoordinateFramePair framePair = new TangoCoordinateFramePair();
    framePair.baseFrame = TangoPoseData.COORDINATE_FRAME_IMU;
    framePair.targetFrame = TangoPoseData.COORDINATE_FRAME_CAMERA_COLOR;
    TangoPoseData imuToRgbPose = tango.getPoseAtTime(0.0, framePair);

    // Create device to IMU transform.
    framePair.targetFrame = TangoPoseData.COORDINATE_FRAME_DEVICE;
    TangoPoseData imuToDevicePose = tango.getPoseAtTime(0.0, framePair);

    // Create depth camera to IMU transform.
    framePair.targetFrame = TangoPoseData.COORDINATE_FRAME_CAMERA_DEPTH;
    TangoPoseData imuToDepthPose = tango.getPoseAtTime(0.0, framePair);

    return new DeviceExtrinsics(imuToDevicePose, imuToRgbPose, imuToDepthPose);
}
 

import com.google.atap.tangoservice.TangoCoordinateFramePair; //导入依赖的package包/类
/**
 * Setup the extrinsics of the device.
 */
private void setUpExtrinsics() {
    // Get device to imu matrix.
    TangoPoseData device2IMUPose = new TangoPoseData();
    TangoCoordinateFramePair framePair = new TangoCoordinateFramePair();
    framePair.baseFrame = TangoPoseData.COORDINATE_FRAME_IMU;
    framePair.targetFrame = TangoPoseData.COORDINATE_FRAME_DEVICE;
    device2IMUPose = mTango.getPoseAtTime(0.0, framePair);
    mRenderer.getModelMatCalculator().SetDevice2IMUMatrix(
            device2IMUPose.getTranslationAsFloats(), device2IMUPose.getRotationAsFloats());

    // Get color camera to imu matrix.
    TangoPoseData color2IMUPose = new TangoPoseData();
    framePair.baseFrame = TangoPoseData.COORDINATE_FRAME_IMU;
    framePair.targetFrame = TangoPoseData.COORDINATE_FRAME_CAMERA_COLOR;
    color2IMUPose = mTango.getPoseAtTime(0.0, framePair);

    mRenderer.getModelMatCalculator().SetColorCamera2IMUMatrix(
            color2IMUPose.getTranslationAsFloats(), color2IMUPose.getRotationAsFloats());
}
 

import com.google.atap.tangoservice.TangoCoordinateFramePair; //导入依赖的package包/类
/**
 * Calculates and stores the fixed transformations between the device and the various sensors
 * to be used later for transformations between frames.
 */
private void setupExtrinsics() {
    // Create Camera to IMU Transform
    TangoCoordinateFramePair framePair = new TangoCoordinateFramePair();
    framePair.baseFrame = TangoPoseData.COORDINATE_FRAME_IMU;
    framePair.targetFrame = TangoPoseData.COORDINATE_FRAME_CAMERA_COLOR;
    TangoPoseData imuTrgbPose = mTango.getPoseAtTime(0.0, framePair);

    // Create Device to IMU Transform
    framePair.targetFrame = TangoPoseData.COORDINATE_FRAME_DEVICE;
    TangoPoseData imuTdevicePose = mTango.getPoseAtTime(0.0, framePair);

    // Create Depth camera to IMU Transform
    framePair.targetFrame = TangoPoseData.COORDINATE_FRAME_CAMERA_DEPTH;
    TangoPoseData imuTdepthPose = mTango.getPoseAtTime(0.0, framePair);

    mRenderer.setupExtrinsics(imuTdevicePose, imuTrgbPose, imuTdepthPose);
}
 

import com.google.atap.tangoservice.TangoCoordinateFramePair; //导入依赖的package包/类
/**
 * Set up the callback listeners for the Tango service, then begin using the Motion
 * Tracking API. This is called in response to the user clicking the 'Start' Button.
 */
private void setTangoListeners() {
    // Lock configuration and connect to Tango.
    // Select coordinate frame pair.
    final ArrayList<TangoCoordinateFramePair> framePairs =
            new ArrayList<TangoCoordinateFramePair>();
    framePairs.add(new TangoCoordinateFramePair(
            TangoPoseData.COORDINATE_FRAME_START_OF_SERVICE,
            TangoPoseData.COORDINATE_FRAME_DEVICE));

    // Listen for new Tango data
    mTango.connectListener(framePairs, new OnTangoUpdateListener() {
        @Override
        public void onPoseAvailable(final TangoPoseData pose) {
            // We are not using TangoPoseData for this application.
        }

        @Override
        public void onXyzIjAvailable(TangoXyzIjData xyzIj) {
            // We are not using onXyzIjAvailable for this app.
        }

        @Override
        public void onPointCloudAvailable(final TangoPointCloudData pointCloudData) {
            logPointCloud(pointCloudData);
        }

        @Override
        public void onTangoEvent(final TangoEvent event) {
            // Ignoring TangoEvents.
        }

        @Override
        public void onFrameAvailable(int cameraId) {
            // We are not using onFrameAvailable for this application.
        }
    });
}
 

import com.google.atap.tangoservice.TangoCoordinateFramePair; //导入依赖的package包/类
/**
 * Set up the callback listeners for the Tango service, then begin using the Motion
 * Tracking API. This is called in response to the user clicking the 'Start' Button.
 */
private void setTangoListeners() {
    // Lock configuration and connect to Tango
    // Select coordinate frame pair
    final ArrayList<TangoCoordinateFramePair> framePairs =
            new ArrayList<TangoCoordinateFramePair>();
    framePairs.add(new TangoCoordinateFramePair(
            TangoPoseData.COORDINATE_FRAME_START_OF_SERVICE,
            TangoPoseData.COORDINATE_FRAME_DEVICE));

    // Listen for new Tango data
    mTango.connectListener(framePairs, new OnTangoUpdateListener() {
        @Override
        public void onPoseAvailable(final TangoPoseData pose) {
            logPose(pose);
        }

        @Override
        public void onXyzIjAvailable(TangoXyzIjData xyzIj) {
            // We are not using onXyzIjAvailable for this app.
        }

        @Override
        public void onPointCloudAvailable(TangoPointCloudData pointCloud) {
            // We are not using onPointCloudAvailable for this app.
        }

        @Override
        public void onTangoEvent(final TangoEvent event) {
            // Ignoring TangoEvents.
        }

        @Override
        public void onFrameAvailable(int cameraId) {
            // We are not using onFrameAvailable for this application.
        }
    });
}
 

import com.google.atap.tangoservice.TangoCoordinateFramePair; //导入依赖的package包/类
/**
 * Set up the callback listeners for the Tango service, then begin using the Motion
 * Tracking API. This is called in response to the user clicking the 'Start' Button.
 */
private void setTangoListeners() {
    // Lock configuration and connect to Tango
    // Select coordinate frame pair
    final ArrayList<TangoCoordinateFramePair> framePairs =
            new ArrayList<TangoCoordinateFramePair>();
    framePairs.add(new TangoCoordinateFramePair(
            TangoPoseData.COORDINATE_FRAME_START_OF_SERVICE,
            TangoPoseData.COORDINATE_FRAME_DEVICE));

    // Listen for new Tango data
    mTango.connectListener(framePairs, new Tango.OnTangoUpdateListener() {
        @Override
        public void onPoseAvailable(final TangoPoseData pose) {
            logPose(pose);
        }

        @Override
        public void onXyzIjAvailable(TangoXyzIjData xyzIj) {
            // We are not using onXyzIjAvailable for this app.
        }

        @Override
        public void onPointCloudAvailable(TangoPointCloudData pointCloud) {
            // We are not using onPointCloudAvailable for this app.
        }

        @Override
        public void onTangoEvent(final TangoEvent event) {
            // Ignoring TangoEvents.
        }

        @Override
        public void onFrameAvailable(int cameraId) {
            // We are not using onFrameAvailable for this application.
        }
    });
}
 

import com.google.atap.tangoservice.TangoCoordinateFramePair; //导入依赖的package包/类
protected void connectTango() {
    TangoUx.StartParams params = new TangoUx.StartParams();
    tangoUx.start(params);
    TangoConfig config = tango.getConfig(TangoConfig.CONFIG_TYPE_DEFAULT);
    config.putBoolean(TangoConfig.KEY_BOOLEAN_LOWLATENCYIMUINTEGRATION, true);
    config.putBoolean(TangoConfig.KEY_BOOLEAN_COLORCAMERA, true);
    tango.connect(config);
    ArrayList<TangoCoordinateFramePair> framePairs = new ArrayList<>();
    framePairs.add(SOS_T_DEVICE_FRAME_PAIR);
    framePairs.add(DEVICE_T_PREVIOUS_FRAME_PAIR);
    tango.connectListener(framePairs, this);
    setupCameraProperties(tango);
}
 

import com.google.atap.tangoservice.TangoCoordinateFramePair; //导入依赖的package包/类
private void startCameraPreview() {
    // Connect to color camera
	tangoCameraPreview.connectToTangoCamera(mTango,
			TangoCameraIntrinsics.TANGO_CAMERA_COLOR);
	// Use default configuration for Tango Service.
	TangoConfig config = mTango.getConfig(TangoConfig.CONFIG_TYPE_DEFAULT);
	mTango.connect(config);
	
	// No need to add any coordinate frame pairs since we are not using 
	// pose data. So just initialize.
	ArrayList<TangoCoordinateFramePair> framePairs = new ArrayList<TangoCoordinateFramePair>();
	mTango.connectListener(framePairs, new OnTangoUpdateListener() {
		@Override
		public void onPoseAvailable(TangoPoseData pose) {
			// We are not using OnPoseAvailable for this app
		}

		@Override
		public void onFrameAvailable(int cameraId) {
		    
		    // Check if the frame available is for the camera we want and
		    // update its frame on the camera preview.
			if (cameraId == TangoCameraIntrinsics.TANGO_CAMERA_COLOR) {
				tangoCameraPreview.onFrameAvailable();
			}
		}

		@Override
		public void onXyzIjAvailable(TangoXyzIjData xyzIj) {
			// We are not using OnPoseAvailable for this app
		}

		@Override
		public void onTangoEvent(TangoEvent event) {
			// We are not using OnPoseAvailable for this app
		}
	});
}
 

import com.google.atap.tangoservice.TangoCoordinateFramePair; //导入依赖的package包/类
private void setupExtrinsics() {
    TangoCoordinateFramePair framePair = new TangoCoordinateFramePair();
    framePair.baseFrame = TangoPoseData.COORDINATE_FRAME_IMU;
    framePair.targetFrame = TangoPoseData.COORDINATE_FRAME_CAMERA_COLOR;
    TangoPoseData imuTColorCameraPose = mTango.getPoseAtTime(0.0, framePair);

    framePair.targetFrame = TangoPoseData.COORDINATE_FRAME_CAMERA_DEPTH;
    TangoPoseData imuTDepthCameraPose = mTango.getPoseAtTime(0.0, framePair);

    framePair.targetFrame = TangoPoseData.COORDINATE_FRAME_DEVICE;
    TangoPoseData imuTDevicePose = mTango.getPoseAtTime(0.0, framePair);

    mRenderer.setupExtrinsics(imuTDevicePose, imuTColorCameraPose, imuTDepthCameraPose);
}
 

import com.google.atap.tangoservice.TangoCoordinateFramePair; //导入依赖的package包/类
private void startCameraPreview() {
    // Connect to color camera
	tangoCameraPreview.connectToTangoCamera(mTango,
			TangoCameraIntrinsics.TANGO_CAMERA_COLOR);
	// Use default configuration for Tango Service.
	TangoConfig config = mTango.getConfig(TangoConfig.CONFIG_TYPE_DEFAULT);
	mTango.connect(config);
	mIsConnected = true;
	
	// No need to add any coordinate frame pairs since we are not using 
	// pose data. So just initialize.
	ArrayList<TangoCoordinateFramePair> framePairs = new ArrayList<TangoCoordinateFramePair>();
	mTango.connectListener(framePairs, new OnTangoUpdateListener() {
		@Override
		public void onPoseAvailable(TangoPoseData pose) {
			// We are not using OnPoseAvailable for this app
		}

		@Override
		public void onFrameAvailable(int cameraId) {
		    
		    // Check if the frame available is for the camera we want and
		    // update its frame on the camera preview.
			if (cameraId == TangoCameraIntrinsics.TANGO_CAMERA_COLOR) {
				tangoCameraPreview.onFrameAvailable();
			}
		}

		@Override
		public void onXyzIjAvailable(TangoXyzIjData xyzIj) {
			// We are not using OnPoseAvailable for this app
		}

		@Override
		public void onTangoEvent(TangoEvent event) {
			// We are not using OnPoseAvailable for this app
		}
	});
}
 

import com.google.atap.tangoservice.TangoCoordinateFramePair; //导入依赖的package包/类
/**
 * Use the TangoSupport library with point cloud data to calculate the plane of
 * the world feature pointed at the location the camera is looking at and update the
 * renderer to show a 3D object in that location.
 */
private void doFitPlane(float u, float v) {
    // Get the current device pose
    TangoCoordinateFramePair framePair = new TangoCoordinateFramePair(
            TangoPoseData.COORDINATE_FRAME_START_OF_SERVICE,
            TangoPoseData.COORDINATE_FRAME_DEVICE);
    TangoPoseData devicePose = mTango.getPoseAtTime(0.0, framePair);

    // Perform plane fitting with the latest available point cloud data
    TangoSupport.IntersectionPointPlaneModelPair planeModel =
            mPointCloudManager.fitPlane(u, v, devicePose, mRenderer.getPoseCalculator());
    mRenderer.updateObjectPose(planeModel.intersectionPoint, planeModel.planeModel, devicePose);
}
 

import com.google.atap.tangoservice.TangoCoordinateFramePair; //导入依赖的package包/类
/**
 * Configure the Tango service and connect it to callbacks.
 */
private void connectTango() {
    // Use default configuration for Tango Service, plus low latency
    // IMU integration and area learning.
    TangoConfig config = mTango.getConfig(TangoConfig.CONFIG_TYPE_DEFAULT);
    // NOTE: Low latency integration is necessary to achieve a precise alignment of virtual
    // objects with the RBG image and produce a good AR effect.
    config.putBoolean(TangoConfig.KEY_BOOLEAN_LOWLATENCYIMUINTEGRATION, true);
    config.putBoolean(TangoConfig.KEY_BOOLEAN_DEPTH, true);
    // NOTE: Area learning is necessary to achieve better precision is pose estimation
    config.putBoolean(TangoConfig.KEY_BOOLEAN_LEARNINGMODE, true);
    config.putBoolean(TangoConfig.KEY_BOOLEAN_COLORCAMERA, true);
    mTango.connect(config);

    // No need to add any coordinate frame pairs since we are not
    // using pose data. So just initialize.
    ArrayList<TangoCoordinateFramePair> framePairs = new ArrayList<TangoCoordinateFramePair>();
    mTango.connectListener(framePairs, new OnTangoUpdateListener() {
        @Override
        public void onPoseAvailable(TangoPoseData pose) {
            // We are not using OnPoseAvailable for this app.
        }

        @Override
        public void onFrameAvailable(int cameraId) {
            // Check if the frame available is for the camera we want and update its frame
            // on the view.
            if (cameraId == TangoCameraIntrinsics.TANGO_CAMERA_COLOR) {
                // Mark a camera frame is available for rendering in the OpenGL thread
                mIsFrameAvailableTangoThread.set(true);
                mSurfaceView.requestRender();
            }
        }

        @Override
        public void onXyzIjAvailable(TangoXyzIjData xyzIj) {
            // Save the cloud and point data for later use.
            mPointCloudManager.updateXyzIj(xyzIj);
        }

        @Override
        public void onTangoEvent(TangoEvent event) {
            // We are not using OnTangoEvent for this app.
        }
    });

    mIntrinsics = mTango.getCameraIntrinsics(TangoCameraIntrinsics.TANGO_CAMERA_COLOR);
}
 

import com.google.atap.tangoservice.TangoCoordinateFramePair; //导入依赖的package包/类
/**
 * Set up the callback listeners for the Tango service, then begin using the Motion
 * Tracking API. This is called in response to the user clicking the 'Start' Button.
 */
private void setTangoListeners() {
    // Lock configuration and connect to Tango
    // Select coordinate frame pair
    ArrayList<TangoCoordinateFramePair> framePairs = new ArrayList<TangoCoordinateFramePair>();

    // Listen for new Tango data
    mTango.connectListener(framePairs, new OnTangoUpdateListener() {
        @Override
        public void onPoseAvailable(final TangoPoseData pose) {
            // We are not using TangoPoseData for this application.
        }

        @Override
        public void onXyzIjAvailable(TangoXyzIjData xyzIj) {
            // We are not using onXyzIjAvailable for this app.
        }

        @Override
        public void onPointCloudAvailable(final TangoPointCloudData pointCloudData) {
            logPointCloud(pointCloudData);
        }

        @Override
        public void onTangoEvent(final TangoEvent event) {
            // Ignoring TangoEvents.
        }

        @Override
        public void onFrameAvailable(int cameraId) {
            // This will get called every time a new RGB camera frame is available to be
            // rendered.
            Log.d(TAG, "onFrameAvailable");

            if (cameraId == TangoCameraIntrinsics.TANGO_CAMERA_COLOR) {
                // Now that we are receiving onFrameAvailable callbacks, we can switch
                // to RENDERMODE_WHEN_DIRTY to drive the render loop from this callback.
                // This will result on a frame rate of  approximately 30FPS, in synchrony with
                // the RGB camera driver.
                // If you need to render at a higher rate (i.e.: if you want to render complex
                // animations smoothly) you  can use RENDERMODE_CONTINUOUSLY throughout the
                // application lifecycle.
                if (mSurfaceView.getRenderMode() != GLSurfaceView.RENDERMODE_WHEN_DIRTY) {
                    mSurfaceView.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
                }

                // Note that the RGB data is not passed as a parameter here.
                // Instead, this callback indicates that you can call
                // the {@code updateTexture()} method to have the
                // RGB data copied directly to the OpenGL texture at the native layer.
                // Since that call needs to be done from the OpenGL thread, what we do here is
                // set-up a flag to tell the OpenGL thread to do that in the next run.
                // NOTE: Even if we are using a render by request method, this flag is still
                // necessary since the OpenGL thread run requested below is not guaranteed
                // to run in synchrony with this requesting call.
                mIsFrameAvailableTangoThread.set(true);
                // Trigger an OpenGL render to update the OpenGL scene with the new RGB data.
                mSurfaceView.requestRender();
            }
        }
    });
}
 

import com.google.atap.tangoservice.TangoCoordinateFramePair; //导入依赖的package包/类
/**
 * Set up the TangoConfig and the listeners for the Tango service, then begin using the Motion
 * Tracking API. This is called in response to the user clicking the 'Start' Button.
 */
private void setTangoListeners() {
    // Lock configuration and connect to Tango
    // Select coordinate frame pair
    final ArrayList<TangoCoordinateFramePair> framePairs = new ArrayList<TangoCoordinateFramePair>();
    framePairs.add(new TangoCoordinateFramePair(
            TangoPoseData.COORDINATE_FRAME_START_OF_SERVICE,
            TangoPoseData.COORDINATE_FRAME_DEVICE));
    // Listen for new Tango data
    mTango.connectListener(framePairs, new OnTangoUpdateListener() {

        @Override
        public void onPoseAvailable(final TangoPoseData pose) {
            //Make sure to have atomic access to Tango Pose Data so that
            //render loop doesn't interfere while Pose call back is updating
            // the data.
            synchronized (sharedLock) {
                mPose = pose;
                mDeltaTime = (float) (pose.timestamp - mPreviousTimeStamp) * SECS_TO_MILLISECS;
                mPreviousTimeStamp = (float) pose.timestamp;
                // Log whenever Motion Tracking enters an invalid state
                if (!mIsAutoRecovery && (pose.statusCode == TangoPoseData.POSE_INVALID)) {
                    Log.w(TAG, "Invalid State");
                }
                if (mPreviousPoseStatus != pose.statusCode) {
                    count = 0;
                }
                count++;
                mPreviousPoseStatus = pose.statusCode;
                // Update the OpenGL renderable objects with the new Tango Pose
                // data
                float[] translation = pose.getTranslationAsFloats();
                if(!mRenderer.isValid()){
                    return;
                }
                mRenderer.getTrajectory().updateTrajectory(translation);
                mRenderer.getModelMatCalculator().updateModelMatrix(translation,
                        pose.getRotationAsFloats());
            }
        }

        @Override
        public void onXyzIjAvailable(TangoXyzIjData arg0) {
            // We are not using TangoXyzIjData for this application
        }

        @Override
        public void onTangoEvent(final TangoEvent event) {
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    mTangoEventTextView.setText(event.eventKey + ": " + event.eventValue);
                }
            });
        }

        @Override
        public void onFrameAvailable(int cameraId) {
            // We are not using onFrameAvailable for this application
        }
    });
}
 

import com.google.atap.tangoservice.TangoCoordinateFramePair; //导入依赖的package包/类
/**
 * Set up the callback listeners for the Tango service, then begin using the Motion
 * Tracking API. This is called in response to the user clicking the 'Start' Button.
 */
private void setTangoListeners() {
    // Lock configuration and connect to Tango
    // Select coordinate frame pair
    final ArrayList<TangoCoordinateFramePair> framePairs = new ArrayList<TangoCoordinateFramePair>();
    framePairs.add(new TangoCoordinateFramePair(
            TangoPoseData.COORDINATE_FRAME_START_OF_SERVICE,
            TangoPoseData.COORDINATE_FRAME_DEVICE));

    // Listen for new Tango data
    mTango.connectListener(framePairs, new OnTangoUpdateListener() {

        @Override
        public void onPoseAvailable(final TangoPoseData pose) {
            // Update the OpenGL renderable objects with the new Tango Pose data.
            // Note that locking for thread safe access with the OpenGL loop is done entirely
            // in the renderer.
            mRenderer.updateDevicePose(pose);
            
            // Make sure to have atomic access to Tango Pose Data so that the UI
            // the UI loop doesn't interfere while Pose call back is updating the data
            synchronized (mUiThreadLock) {
                mPose = pose;

                //Now lets log some interesting statistics of Motion Tracking like
                // Delta Time between two Poses, number of poses since the initialization state.
                mDeltaTime = (float) (pose.timestamp - mPreviousTimeStamp) * SECS_TO_MILLISECS;
                mPreviousTimeStamp = (float) pose.timestamp;
                // Log whenever Motion Tracking enters an invalid state
                if (!mIsAutoRecovery && (pose.statusCode == TangoPoseData.POSE_INVALID)) {
                    Log.w(TAG, "Invalid State");
                }
                if (mPreviousPoseStatus != pose.statusCode) {
                    mCount = 0;
                }
                mCount++;
                mPreviousPoseStatus = pose.statusCode;
            }
        }

        @Override
        public void onXyzIjAvailable(TangoXyzIjData arg0) {
            // We are not using TangoXyzIjData for this application
        }

        @Override
        public void onTangoEvent(final TangoEvent event) {
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    mTangoEventTextView.setText(event.eventKey + ": " + event.eventValue);
                }
            });
        }

        @Override
        public void onFrameAvailable(int cameraId) {
            // We are not using onFrameAvailable for this application
        }
    });
}