/* * Copyright (C) 2010 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.example.android.accelerometerplay; import android.app.Activity; import android.content.Context; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.Canvas; import android.graphics.BitmapFactory.Options; import android.hardware.Sensor; import android.hardware.SensorEvent; import android.hardware.SensorEventListener; import android.hardware.SensorManager; import android.os.Bundle; import android.os.PowerManager; import android.os.PowerManager.WakeLock; import android.util.DisplayMetrics; import android.view.Display; import android.view.Surface; import android.view.View; import android.view.WindowManager; /** * This is an example of using the accelerometer to integrate the device's * acceleration to a position using the Verlet method. This is illustrated with * a very simple particle system comprised of a few iron balls freely moving on * an inclined wooden table. The inclination of the virtual table is controlled * by the device's accelerometer. * * @see SensorManager * @see SensorEvent * @see Sensor */ public class AccelerometerPlayActivity extends Activity { private SimulationView mSimulationView; private SensorManager mSensorManager; private PowerManager mPowerManager; private WindowManager mWindowManager; private Display mDisplay; private WakeLock mWakeLock; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // Get an instance of the SensorManager mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE); // Get an instance of the PowerManager mPowerManager = (PowerManager) getSystemService(POWER_SERVICE); // Get an instance of the WindowManager mWindowManager = (WindowManager) getSystemService(WINDOW_SERVICE); mDisplay = mWindowManager.getDefaultDisplay(); // Create a bright wake lock mWakeLock = mPowerManager.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, getClass() .getName()); // instantiate our simulation view and set it as the activity's content mSimulationView = new SimulationView(this); setContentView(mSimulationView); } @Override protected void onResume() { super.onResume(); /* * when the activity is resumed, we acquire a wake-lock so that the * screen stays on, since the user will likely not be fiddling with the * screen or buttons. */ mWakeLock.acquire(); // Start the simulation mSimulationView.startSimulation(); } @Override protected void onPause() { super.onPause(); /* * When the activity is paused, we make sure to stop the simulation, * release our sensor resources and wake locks */ // Stop the simulation mSimulationView.stopSimulation(); // and release our wake-lock mWakeLock.release(); } class SimulationView extends View implements SensorEventListener { // diameter of the balls in meters private static final float sBallDiameter = 0.004f; private static final float sBallDiameter2 = sBallDiameter * sBallDiameter; // friction of the virtual table and air private static final float sFriction = 0.1f; private Sensor mAccelerometer; private long mLastT; private float mLastDeltaT; private float mXDpi; private float mYDpi; private float mMetersToPixelsX; private float mMetersToPixelsY; private Bitmap mBitmap; private Bitmap mWood; private float mXOrigin; private float mYOrigin; private float mSensorX; private float mSensorY; private long mSensorTimeStamp; private long mCpuTimeStamp; private float mHorizontalBound; private float mVerticalBound; private final ParticleSystem mParticleSystem = new ParticleSystem(); /* * Each of our particle holds its previous and current position, its * acceleration. for added realism each particle has its own friction * coefficient. */ class Particle { private float mPosX; private float mPosY; private float mAccelX; private float mAccelY; private float mLastPosX; private float mLastPosY; private float mOneMinusFriction; Particle() { // make each particle a bit different by randomizing its // coefficient of friction final float r = ((float) Math.random() - 0.5f) * 0.2f; mOneMinusFriction = 1.0f - sFriction + r; } public void computePhysics(float sx, float sy, float dT, float dTC) { // Force of gravity applied to our virtual object final float m = 1000.0f; // mass of our virtual object final float gx = -sx * m; final float gy = -sy * m; /* * �F = mA <=> A = �F / m We could simplify the code by * completely eliminating "m" (the mass) from all the equations, * but it would hide the concepts from this sample code. */ final float invm = 1.0f / m; final float ax = gx * invm; final float ay = gy * invm; /* * Time-corrected Verlet integration The position Verlet * integrator is defined as x(t+�t) = x(t) + x(t) - x(t-�t) + * a(t)�t�2 However, the above equation doesn't handle variable * �t very well, a time-corrected version is needed: x(t+�t) = * x(t) + (x(t) - x(t-�t)) * (�t/�t_prev) + a(t)�t�2 We also add * a simple friction term (f) to the equation: x(t+�t) = x(t) + * (1-f) * (x(t) - x(t-�t)) * (�t/�t_prev) + a(t)�t�2 */ final float dTdT = dT * dT; final float x = mPosX + mOneMinusFriction * dTC * (mPosX - mLastPosX) + mAccelX * dTdT; final float y = mPosY + mOneMinusFriction * dTC * (mPosY - mLastPosY) + mAccelY * dTdT; mLastPosX = mPosX; mLastPosY = mPosY; mPosX = x; mPosY = y; mAccelX = ax; mAccelY = ay; } /* * Resolving constraints and collisions with the Verlet integrator * can be very simple, we simply need to move a colliding or * constrained particle in such way that the constraint is * satisfied. */ public void resolveCollisionWithBounds() { final float xmax = mHorizontalBound; final float ymax = mVerticalBound; final float x = mPosX; final float y = mPosY; if (x > xmax) { mPosX = xmax; } else if (x < -xmax) { mPosX = -xmax; } if (y > ymax) { mPosY = ymax; } else if (y < -ymax) { mPosY = -ymax; } } } /* * A particle system is just a collection of particles */ class ParticleSystem { static final int NUM_PARTICLES = 15; private Particle mBalls[] = new Particle[NUM_PARTICLES]; ParticleSystem() { /* * Initially our particles have no speed or acceleration */ for (int i = 0; i < mBalls.length; i++) { mBalls[i] = new Particle(); } } /* * Update the position of each particle in the system using the * Verlet integrator. */ private void updatePositions(float sx, float sy, long timestamp) { final long t = timestamp; if (mLastT != 0) { final float dT = (float) (t - mLastT) * (1.0f / 1000000000.0f); if (mLastDeltaT != 0) { final float dTC = dT / mLastDeltaT; final int count = mBalls.length; for (int i = 0; i < count; i++) { Particle ball = mBalls[i]; ball.computePhysics(sx, sy, dT, dTC); } } mLastDeltaT = dT; } mLastT = t; } /* * Performs one iteration of the simulation. First updating the * position of all the particles and resolving the constraints and * collisions. */ public void update(float sx, float sy, long now) { // update the system's positions updatePositions(sx, sy, now); // We do no more than a limited number of iterations final int NUM_MAX_ITERATIONS = 10; /* * Resolve collisions, each particle is tested against every * other particle for collision. If a collision is detected the * particle is moved away using a virtual spring of infinite * stiffness. */ boolean more = true; final int count = mBalls.length; for (int k = 0; k < NUM_MAX_ITERATIONS && more; k++) { more = false; for (int i = 0; i < count; i++) { Particle curr = mBalls[i]; for (int j = i + 1; j < count; j++) { Particle ball = mBalls[j]; float dx = ball.mPosX - curr.mPosX; float dy = ball.mPosY - curr.mPosY; float dd = dx * dx + dy * dy; // Check for collisions if (dd <= sBallDiameter2) { /* * add a little bit of entropy, after nothing is * perfect in the universe. */ dx += ((float) Math.random() - 0.5f) * 0.0001f; dy += ((float) Math.random() - 0.5f) * 0.0001f; dd = dx * dx + dy * dy; // simulate the spring final float d = (float) Math.sqrt(dd); final float c = (0.5f * (sBallDiameter - d)) / d; curr.mPosX -= dx * c; curr.mPosY -= dy * c; ball.mPosX += dx * c; ball.mPosY += dy * c; more = true; } } /* * Finally make sure the particle doesn't intersects * with the walls. */ curr.resolveCollisionWithBounds(); } } } public int getParticleCount() { return mBalls.length; } public float getPosX(int i) { return mBalls[i].mPosX; } public float getPosY(int i) { return mBalls[i].mPosY; } } public void startSimulation() { /* * It is not necessary to get accelerometer events at a very high * rate, by using a slower rate (SENSOR_DELAY_UI), we get an * automatic low-pass filter, which "extracts" the gravity component * of the acceleration. As an added benefit, we use less power and * CPU resources. */ mSensorManager.registerListener(this, mAccelerometer, SensorManager.SENSOR_DELAY_UI); } public void stopSimulation() { mSensorManager.unregisterListener(this); } public SimulationView(Context context) { super(context); mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER); DisplayMetrics metrics = new DisplayMetrics(); getWindowManager().getDefaultDisplay().getMetrics(metrics); mXDpi = metrics.xdpi; mYDpi = metrics.ydpi; mMetersToPixelsX = mXDpi / 0.0254f; mMetersToPixelsY = mYDpi / 0.0254f; // rescale the ball so it's about 0.5 cm on screen Bitmap ball = BitmapFactory.decodeResource(getResources(), R.drawable.ball); final int dstWidth = (int) (sBallDiameter * mMetersToPixelsX + 0.5f); final int dstHeight = (int) (sBallDiameter * mMetersToPixelsY + 0.5f); mBitmap = Bitmap.createScaledBitmap(ball, dstWidth, dstHeight, true); Options opts = new Options(); opts.inDither = true; opts.inPreferredConfig = Bitmap.Config.RGB_565; mWood = BitmapFactory.decodeResource(getResources(), R.drawable.wood, opts); } @Override protected void onSizeChanged(int w, int h, int oldw, int oldh) { // compute the origin of the screen relative to the origin of // the bitmap mXOrigin = (w - mBitmap.getWidth()) * 0.5f; mYOrigin = (h - mBitmap.getHeight()) * 0.5f; mHorizontalBound = ((w / mMetersToPixelsX - sBallDiameter) * 0.5f); mVerticalBound = ((h / mMetersToPixelsY - sBallDiameter) * 0.5f); } @Override public void onSensorChanged(SensorEvent event) { if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER) return; /* * record the accelerometer data, the event's timestamp as well as * the current time. The latter is needed so we can calculate the * "present" time during rendering. In this application, we need to * take into account how the screen is rotated with respect to the * sensors (which always return data in a coordinate space aligned * to with the screen in its native orientation). */ switch (mDisplay.getRotation()) { case Surface.ROTATION_0: mSensorX = event.values[0]; mSensorY = event.values[1]; break; case Surface.ROTATION_90: mSensorX = -event.values[1]; mSensorY = event.values[0]; break; case Surface.ROTATION_180: mSensorX = -event.values[0]; mSensorY = -event.values[1]; break; case Surface.ROTATION_270: mSensorX = event.values[1]; mSensorY = -event.values[0]; break; } mSensorTimeStamp = event.timestamp; mCpuTimeStamp = System.nanoTime(); } @Override protected void onDraw(Canvas canvas) { /* * draw the background */ canvas.drawBitmap(mWood, 0, 0, null); /* * compute the new position of our object, based on accelerometer * data and present time. */ final ParticleSystem particleSystem = mParticleSystem; final long now = mSensorTimeStamp + (System.nanoTime() - mCpuTimeStamp); final float sx = mSensorX; final float sy = mSensorY; particleSystem.update(sx, sy, now); final float xc = mXOrigin; final float yc = mYOrigin; final float xs = mMetersToPixelsX; final float ys = mMetersToPixelsY; final Bitmap bitmap = mBitmap; final int count = particleSystem.getParticleCount(); for (int i = 0; i < count; i++) { /* * We transform the canvas so that the coordinate system matches * the sensors coordinate system with the origin in the center * of the screen and the unit is the meter. */ final float x = xc + particleSystem.getPosX(i) * xs; final float y = yc - particleSystem.getPosY(i) * ys; canvas.drawBitmap(bitmap, x, y, null); } // and make sure to redraw asap invalidate(); } @Override public void onAccuracyChanged(Sensor sensor, int accuracy) { } } }
0 comments:
Post a Comment