@Override
public void onMapReady(GoogleMap googleMap) {
mMap = googleMap;
mMap.setMyLocationEnabled(true);
Bundle extras = getIntent().getExtras();
float[] lats = {}, lngs = {};
String[] titles = {}, snippets = {};
int[] beers = {};
if (null != extras) {
lats = extras.getFloatArray("Latitudes");
lngs = extras.getFloatArray("Longitudes");
titles = extras.getStringArray("Titles");
snippets = extras.getStringArray("Snippets");
beers = extras.getIntArray("Beers");
}
googleMap.setInfoWindowAdapter(new CustomInfoWindowAdapter());
LatLng ll = null;
for (int i = 0; i < titles.length; i++) {
ll = new LatLng(lats[i], lngs[i]);
MarkerOptions mark = new MarkerOptions().position(ll).title(titles[i]).snippet(snippets[i]);
// Other color if beer has been drunk.
// The argument to defaultMarker() takes a float between 0-360.0,
// check BitmapDescriptorFactory.HUE_*.
// It is possible to create a BitmapDescriptor from drawables etc.
BitmapDescriptor icon;
if (i < beers.length && 0 < beers[i]) {
icon = BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_GREEN);
} else {
icon = BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_RED);
}
mark.icon(icon);
// Add a marker and set the number of beers drunk
Marker marker = mMap.addMarker(mark);
beerMap.put(marker, (beers.length > i ? beers[i] : 0));
}
/* Add propellern */
BitmapDrawable bd = (BitmapDrawable) getResources().getDrawable(R.drawable.proppeller);
Bitmap b = bd.getBitmap();
Bitmap bhalfsize = Bitmap.createScaledBitmap(b, b.getWidth() / 2, b.getHeight() / 2, false);
MarkerOptions propellern =
new MarkerOptions()
.position(PROPELLERN)
.icon(BitmapDescriptorFactory.fromBitmap(bhalfsize));
mMap.addMarker(propellern);
/* See zoom */
if (null == ll || 1 < titles.length) {
// Zoom from far 2.0 (zoomed out) to close 21.0 (zoomed in)
mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(PROPELLERN, 12.2f));
} else {
mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(ll, 12.2f));
}
}
public void loadInstanceState(Bundle bundle) {
float[] locationX = bundle.getFloatArray(LOCATIONX);
float[] locationY = bundle.getFloatArray(LOCATIONY);
int[] weights = bundle.getIntArray(WEIGHT);
PlayerTurn = bundle.getInt(Turn);
player1Score = bundle.getInt(Score1);
player2Score = bundle.getInt(Score2);
int Turn = bundle.getInt(First);
blocks = new ArrayList<Block>();
for (int i = 0; i < locationX.length - 1; i++) {
if (Turn == 1) {
blocks.add(new Block(red, weights[i], locationX[i], locationY[i]));
Turn = 2;
} else {
Turn = 1;
blocks.add(new Block(brown, weights[i], locationX[i], locationY[i]));
}
}
yPositionTracker = locationY[locationY.length - 1];
if (PlayerTurn == 1)
tempBlock =
new Block(
red, weights[weights.length - 1], locationX[locationY.length - 1], yPositionTracker);
else
tempBlock =
new Block(
brown,
weights[weights.length - 1],
locationX[locationY.length - 1],
yPositionTracker);
view.updateScore(String.valueOf(player1Score), String.valueOf(player2Score));
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
setContentView(R.layout.activity_map);
/* ActionBar items */
try {
getActionBar().setHomeButtonEnabled(true);
getActionBar().setDisplayHomeAsUpEnabled(true);
} catch (NullPointerException e) {
Toast.makeText(this, "Something went wrong. Try again.", Toast.LENGTH_SHORT).show();
}
ICON_HEIGHT = getResources().getDimensionPixelSize(R.dimen.mapIconHeight);
// Toast.makeText(this, "onCreate", Toast.LENGTH_SHORT).show();
FragmentManager fm = getFragmentManager();
/* Obtain a reference to the UI element */
MapFragment frag = (MapFragment) fm.findFragmentById(R.id.overworld);
/* Obtain a reference to GoogleMap object associated with the fragment */
worldMap = frag.getMap();
mapClient = new LocationClient(this, this, this);
mapClient = new LocationClient(this, this, this);
ePrefs = PreferenceManager.getDefaultSharedPreferences(this);
Boolean infoShown = ePrefs.getBoolean(infoDialoguePref, false);
if (!infoShown) {
String title = "Map Gallery";
String text = getResources().getString(R.string.mapInfo);
new AlertDialog.Builder(this)
.setTitle(title)
.setMessage(text)
.setPositiveButton(
android.R.string.ok,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
}
})
.show();
SharedPreferences.Editor editor = ePrefs.edit();
editor.putBoolean(infoDialoguePref, true);
editor.commit();
}
if (savedInstanceState != null) {
zoomlevel = savedInstanceState.getFloat("zoom");
loaded = savedInstanceState.getBoolean("loaded");
currentLat = savedInstanceState.getDouble("lat");
currentLng = savedInstanceState.getDouble("lng");
fileToReload = savedInstanceState.getString("redo");
dataRestorer =
new DataRestorer(
savedInstanceState.getStringArrayList("allFiles"),
savedInstanceState.getParcelableArrayList("allBitmaps"),
savedInstanceState.getFloatArray("allLat"),
savedInstanceState.getFloatArray("allLng"));
}
}
@Override
public void onResults(Bundle results) {
lawg.d("[RecognitionListener] onResults()");
ArrayList<String> resultsArray =
results.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION);
float[] confidenceScores = results.getFloatArray(SpeechRecognizer.CONFIDENCE_SCORES);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < resultsArray.size(); i++) {
String word = resultsArray.get(i);
sb.append(word);
if (i != resultsArray.size() - 1) sb.append(", ");
if (TextUtils.equals(word.toLowerCase(), "cheese")) {
captureStillPicture();
}
}
lawg.d("Words detected: \n" + sb.toString());
mDisplayText1.setText(sb.toString());
for (int i = 0; i < resultsArray.size(); i++) {
String word = resultsArray.get(i);
addFloatingWord(word, confidenceScores[i]);
}
// repeat listen
startListening();
}
@Override
protected void onRestoreInstanceState(Parcelable state) {
Bundle savedState = (Bundle) state;
Parcelable superState = savedState.getParcelable(STATE_PARENT);
super.onRestoreInstanceState(superState);
setColor(Color.HSVToColor(savedState.getFloatArray(STATE_COLOR)));
setOpacity(savedState.getInt(STATE_OPACITY));
}
@Override
protected void onRestoreInstanceState(Parcelable state) {
Bundle savedState = (Bundle) state;
Parcelable superState = savedState.getParcelable(STATE_PARENT);
super.onRestoreInstanceState(superState);
setColor(Color.HSVToColor(savedState.getFloatArray(STATE_COLOR)));
setSaturation(savedState.getFloat(STATE_SATURATION));
}
@Override
protected void onRestoreInstanceState(Parcelable state) {
if (state instanceof Bundle) {
Bundle bundle = (Bundle) state;
colorHSV = bundle.getFloatArray("color");
super.onRestoreInstanceState(bundle.getParcelable("super"));
} else {
super.onRestoreInstanceState(state);
}
}
@Override
public void setAccelerometerValues(Message msg) {
Bundle b = msg.getData();
float[] values = b.getFloatArray(AccelerometerListener.VALUES);
float value =
(float) (Math.pow(values[0], 1) + Math.pow(values[1], 1) + Math.pow(values[2], 1));
try {
this.currentMeasure = 50 + (int) value;
this.seekBar.setProgress(currentMeasure);
this.currentEditText.setText("" + currentMeasure);
} catch (Exception e) {
Log.e("", e.getMessage(), e);
}
}
@Override
protected void onRestoreInstanceState(Parcelable state) {
Bundle savedState = (Bundle) state;
Parcelable superState = savedState.getParcelable(STATE_PARENT);
super.onRestoreInstanceState(superState);
setColor(Color.HSVToColor(savedState.getFloatArray(STATE_COLOR)));
if (savedState.containsKey(STATE_SATURATION)) {
setSaturation(savedState.getFloat(STATE_SATURATION));
} else {
setValue(savedState.getFloat(STATE_VALUE));
}
mOrientation = savedState.getBoolean(STATE_ORIENTATION, ORIENTATION_DEFAULT);
}
@Override
protected void onRestoreInstanceState(Parcelable state) {
if (state instanceof Bundle) {
Bundle bundle = (Bundle) state;
mBitmapAlpha = bundle.getFloatArray(STATUS_ALPHAS);
mMessageNumber = bundle.getIntArray(STATUS_MESSAGENUMBER);
mNews = bundle.getBooleanArray(STATUS_NEWS);
for (int i = 0; i < mBitmapAlpha.length; i++) {
mTabstrips.get(i).setBitmapAlpha(mBitmapAlpha[i]);
mTabstrips.get(i).setNews(mNews[i]);
mTabstrips.get(i).setMessageNumber(mMessageNumber[i]);
}
super.onRestoreInstanceState(bundle.getParcelable(INSTANCE_STATUS));
return;
}
super.onRestoreInstanceState(state);
}
@Override
public void onRestoreInstanceState(Parcelable state) {
if (state instanceof Bundle) {
Bundle bundle = (Bundle) state;
normalizedScale = bundle.getFloat("saveScale");
m = bundle.getFloatArray("matrix");
prevMatrix.setValues(m);
prevMatchViewHeight = bundle.getFloat("matchViewHeight");
prevMatchViewWidth = bundle.getFloat("matchViewWidth");
prevViewHeight = bundle.getInt("viewHeight");
prevViewWidth = bundle.getInt("viewWidth");
imageRenderedAtLeastOnce = bundle.getBoolean("imageRendered");
super.onRestoreInstanceState(bundle.getParcelable("instanceState"));
return;
}
super.onRestoreInstanceState(state);
}
@Override
protected void onRestoreInstanceState(Bundle inState) {
float[] data = inState.getFloatArray("Pressure");
if (data != null) {
pressureHistory.clear();
for (float f : data) {
pressureHistory.add((double) f);
}
}
data = inState.getFloatArray("Pressure Smoothing Window");
if (data != null) {
pressureSmoothingWin.clear();
for (float f : data) {
pressureSmoothingWin.push((double) f);
}
}
data = inState.getFloatArray("Altitude");
if (data != null) {
altitudeHistory.clear();
for (float f : data) {
altitudeHistory.add((double) f);
}
}
data = inState.getFloatArray("Altitude Smoothing Window");
if (data != null) {
altitudeSmoothingWin.clear();
for (float f : data) {
altitudeSmoothingWin.push((double) f);
}
}
data = inState.getFloatArray("Temperature");
if (data != null) {
tempHistory.clear();
for (float f : data) {
tempHistory.add((double) f);
}
}
data = inState.getFloatArray("Temperature Smoothing Window");
if (data != null) {
tempSmoothingWin.clear();
for (float f : data) {
tempSmoothingWin.push((double) f);
}
}
plotLongHistory();
}
@SmallTest
@MediumTest
@LargeTest
public void testAllTypes() {
Bundle originalBundle = new Bundle();
putBoolean(BOOLEAN_KEY, originalBundle);
putBooleanArray(BOOLEAN_ARRAY_KEY, originalBundle);
putByte(BYTE_KEY, originalBundle);
putByteArray(BYTE_ARRAY_KEY, originalBundle);
putShort(SHORT_KEY, originalBundle);
putShortArray(SHORT_ARRAY_KEY, originalBundle);
putInt(INT_KEY, originalBundle);
putIntArray(INT_ARRAY_KEY, originalBundle);
putLong(LONG_KEY, originalBundle);
putLongArray(LONG_ARRAY_KEY, originalBundle);
putFloat(FLOAT_KEY, originalBundle);
putFloatArray(FLOAT_ARRAY_KEY, originalBundle);
putDouble(DOUBLE_KEY, originalBundle);
putDoubleArray(DOUBLE_ARRAY_KEY, originalBundle);
putChar(CHAR_KEY, originalBundle);
putCharArray(CHAR_ARRAY_KEY, originalBundle);
putString(STRING_KEY, originalBundle);
putStringList(STRING_LIST_KEY, originalBundle);
originalBundle.putSerializable(SERIALIZABLE_KEY, AccessTokenSource.FACEBOOK_APPLICATION_WEB);
ensureApplicationContext();
SharedPreferencesTokenCachingStrategy cache =
new SharedPreferencesTokenCachingStrategy(getContext());
cache.save(originalBundle);
SharedPreferencesTokenCachingStrategy cache2 =
new SharedPreferencesTokenCachingStrategy(getContext());
Bundle cachedBundle = cache2.load();
Assert.assertEquals(
originalBundle.getBoolean(BOOLEAN_KEY), cachedBundle.getBoolean(BOOLEAN_KEY));
assertArrayEquals(
originalBundle.getBooleanArray(BOOLEAN_ARRAY_KEY),
cachedBundle.getBooleanArray(BOOLEAN_ARRAY_KEY));
Assert.assertEquals(originalBundle.getByte(BYTE_KEY), cachedBundle.getByte(BYTE_KEY));
assertArrayEquals(
originalBundle.getByteArray(BYTE_ARRAY_KEY), cachedBundle.getByteArray(BYTE_ARRAY_KEY));
Assert.assertEquals(originalBundle.getShort(SHORT_KEY), cachedBundle.getShort(SHORT_KEY));
assertArrayEquals(
originalBundle.getShortArray(SHORT_ARRAY_KEY), cachedBundle.getShortArray(SHORT_ARRAY_KEY));
Assert.assertEquals(originalBundle.getInt(INT_KEY), cachedBundle.getInt(INT_KEY));
assertArrayEquals(
originalBundle.getIntArray(INT_ARRAY_KEY), cachedBundle.getIntArray(INT_ARRAY_KEY));
Assert.assertEquals(originalBundle.getLong(LONG_KEY), cachedBundle.getLong(LONG_KEY));
assertArrayEquals(
originalBundle.getLongArray(LONG_ARRAY_KEY), cachedBundle.getLongArray(LONG_ARRAY_KEY));
Assert.assertEquals(originalBundle.getFloat(FLOAT_KEY), cachedBundle.getFloat(FLOAT_KEY));
assertArrayEquals(
originalBundle.getFloatArray(FLOAT_ARRAY_KEY), cachedBundle.getFloatArray(FLOAT_ARRAY_KEY));
Assert.assertEquals(originalBundle.getDouble(DOUBLE_KEY), cachedBundle.getDouble(DOUBLE_KEY));
assertArrayEquals(
originalBundle.getDoubleArray(DOUBLE_ARRAY_KEY),
cachedBundle.getDoubleArray(DOUBLE_ARRAY_KEY));
Assert.assertEquals(originalBundle.getChar(CHAR_KEY), cachedBundle.getChar(CHAR_KEY));
assertArrayEquals(
originalBundle.getCharArray(CHAR_ARRAY_KEY), cachedBundle.getCharArray(CHAR_ARRAY_KEY));
Assert.assertEquals(originalBundle.getString(STRING_KEY), cachedBundle.getString(STRING_KEY));
assertListEquals(
originalBundle.getStringArrayList(STRING_LIST_KEY),
cachedBundle.getStringArrayList(STRING_LIST_KEY));
Assert.assertEquals(
originalBundle.getSerializable(SERIALIZABLE_KEY),
cachedBundle.getSerializable(SERIALIZABLE_KEY));
}
/**
* Retrieve extended data from the request.
*
* @param name The name of the desired item.
* @return the value of an item that previously added with putExtra() or null if no float array
* value was found.
* @see #putExtra(String, float[])
*/
public float[] getFloatArrayExtra(String name) {
return mExtras == null ? null : mExtras.getFloatArray(name);
}
protected void processData(final Context context, Bundle dataBundle) {
if (dataBundle.containsKey(ContinuousProbe.EVENT_TIMESTAMP)
&& dataBundle.containsKey("X")
&& dataBundle.containsKey("Y")
&& dataBundle.containsKey("Z")) {
double[] incomingTimes = dataBundle.getDoubleArray(ContinuousProbe.EVENT_TIMESTAMP);
float[] incomingX = dataBundle.getFloatArray("X");
float[] incomingY = dataBundle.getFloatArray("Y");
float[] incomingZ = dataBundle.getFloatArray("Z");
this.appendValues(incomingX, incomingY, incomingZ, incomingTimes);
final long now = System.currentTimeMillis();
final String key = this.featureKey();
final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
long updateInterval =
Long.parseLong(
prefs.getString(
"config_probe_" + key + "_frequency",
XYZBasicFrequencyFeature.DEFAULT_FREQUENCY))
* 1000;
if (now - this._lastUpdate > updateInterval) // add last updated
// check for config
{
this._lastUpdate = now;
LinearInterpolator interpolator = new LinearInterpolator();
double[] xs = _xValues;
double[] ys = _yValues;
double[] zs = _zValues;
double[] ts = _timestamps;
if (this._currentIndex < BUFFER_SIZE - 1) {
xs = Arrays.copyOfRange(_xValues, 0, this._currentIndex);
ys = Arrays.copyOfRange(_yValues, 0, this._currentIndex);
zs = Arrays.copyOfRange(_zValues, 0, this._currentIndex);
ts = Arrays.copyOfRange(_timestamps, 0, this._currentIndex);
}
// Log.e("PR", "FIRST RAW TIME: " + ts[0] + " LAST RAW TIME: " +
// ts[ts.length - 1]);
// Log.e("PR", "RAW TIME[0]: " + ts[0]);
// Log.e("PR", "RAW TIME[1]: " + ts[1]);
PolynomialSplineFunction fX = interpolator.interpolate(ts, xs);
PolynomialSplineFunction fY = interpolator.interpolate(ts, ys);
PolynomialSplineFunction fZ = interpolator.interpolate(ts, zs);
// double lowFreq = 0.6;
// double highFreq = 7.0;
double durationOffset = ts[0];
double bufferDuration = ts[ts.length - 1] - durationOffset;
double interval = 1.0 / 120.0;
// Log.e("PR", "TS/0: " + ts[0] + " -- TS/-1: " + ts[ts.length -
// 1] + " -- LEN TS: " + ts.length);
// Log.e("PR", "BD: " + bufferDuration + " INT: " + interval);
int twoPow = ts.length == 0 ? 0 : (32 - Integer.numberOfLeadingZeros(ts.length - 1));
int bufferSize = (int) Math.pow(2, twoPow);
// Log.e("PR", "BUFF SIZE: " + bufferSize);
final double[] _interX = new double[bufferSize];
final double[] _interY = new double[bufferSize];
final double[] _interZ = new double[bufferSize];
Arrays.fill(_interX, 0.0);
Arrays.fill(_interY, 0.0);
Arrays.fill(_interZ, 0.0);
interTimes = new double[bufferSize];
for (int i = 0; i < bufferSize; i++) {
interTimes[i] = durationOffset + (i * interval);
// Log.e("PR", "TIME REQUEST: " + time);
// Log.e("PR", "TIME DIFFERENCE: " + (oldTime - time));
if (interTimes[i] > ts[ts.length - 1]) // If the current
// timestamp is
// greater than the
// last recorded
// timestamp, set it
// to the last
// timestamp
interTimes[i] = ts[ts.length - 1];
_interX[i] = fX.value(interTimes[i]);
_interY[i] = fY.value(interTimes[i]);
_interZ[i] = fZ.value(interTimes[i]);
}
// double timeDifference = interTimes[bufferSize - 1] -
// interTimes[0];
// Log.e("PR", "INTERP TIME: " + timeDifference +
// " BUFFER SIZE: " + bufferSize);
// Log.e("PR", "FIRST INTERP TIME: " + interTimes[0] +
// " LAST INTERP TIME: " + interTimes[interTimes.length - 1]);
// Log.e("PR", "INTERP SAMPLE: " + interX[bufferSize - 1] +
// " - " + interY[bufferSize - 1] + " - " + interZ[bufferSize -
// 1]);
final double[] _dynamicX = new double[_interX.length];
final double[] _dynamicY = new double[_interY.length];
final double[] _dynamicZ = new double[_interZ.length];
final double[] _staticX = new double[_interX.length];
final double[] _staticY = new double[_interY.length];
final double[] _staticZ = new double[_interZ.length];
for (int i = 0; i < _interX.length; i++) {
if (i < 2) {
_dynamicX[i] = 0;
_dynamicY[i] = 0;
_dynamicZ[i] = 0;
_staticX[i] = 0;
_staticY[i] = 0;
_staticZ[i] = 0;
} else {
if (i == _dynamicX.length - 1) {
_dynamicX[i] = XYZBasicFrequencyFeature.bpFilter(_interX, this._xBPHistory, i, "X");
_dynamicY[i] = XYZBasicFrequencyFeature.bpFilter(_interY, this._yBPHistory, i, "Y");
_dynamicZ[i] = XYZBasicFrequencyFeature.bpFilter(_interZ, this._zBPHistory, i, "Z");
_staticX[i] = XYZBasicFrequencyFeature.lpFilter(_interX, this._xLPHistory, i, "X");
_staticY[i] = XYZBasicFrequencyFeature.lpFilter(_interY, this._yLPHistory, i, "Y");
_staticZ[i] = XYZBasicFrequencyFeature.lpFilter(_interZ, this._zLPHistory, i, "Z");
} else {
_dynamicX[i] = XYZBasicFrequencyFeature.bpFilter(_interX, this._xBPHistory, i, null);
_dynamicY[i] = XYZBasicFrequencyFeature.bpFilter(_interY, this._yBPHistory, i, null);
_dynamicZ[i] = XYZBasicFrequencyFeature.bpFilter(_interZ, this._zBPHistory, i, null);
_staticX[i] = XYZBasicFrequencyFeature.lpFilter(_interX, this._xLPHistory, i, null);
_staticY[i] = XYZBasicFrequencyFeature.lpFilter(_interY, this._yLPHistory, i, null);
_staticZ[i] = XYZBasicFrequencyFeature.lpFilter(_interZ, this._zLPHistory, i, null);
}
this._xBPHistory[1] = this._xBPHistory[0];
this._xBPHistory[0] = _dynamicX[i];
this._yBPHistory[1] = this._yBPHistory[0];
this._yBPHistory[0] = _dynamicY[i];
this._zBPHistory[1] = this._zBPHistory[0];
this._zBPHistory[0] = _dynamicZ[i];
this._xLPHistory[1] = this._xLPHistory[0];
this._xLPHistory[0] = _staticX[i];
this._yLPHistory[1] = this._yLPHistory[0];
this._yLPHistory[0] = _staticY[i];
this._zLPHistory[1] = this._zLPHistory[0];
this._zLPHistory[0] = _staticZ[i];
}
}
// Log.e("PR", "Inter Sample: " + _interX[_interX.length - 1] +
// " - " + _interY[_interX.length - 1] + " - " +
// _interZ[_interX.length - 1]);
// Log.e("PR", "DY Sample: " + _dynamicX[_dynamicX.length - 1] +
// " - " + _dynamicY[_dynamicX.length - 1] + " - " +
// _dynamicZ[_interX.length - 1]);
// Log.e("PR", "GR Sample: " + _staticX[_staticX.length - 1] +
// " - " + _staticY[_staticY.length - 1] + " - " +
// _staticZ[_staticZ.length - 1]);
double observedFreq = _interX.length / bufferDuration; // (((double)
// this._currentIndex)
// /
// bufferDuration);
// Log.e("PR", "IL: + " + _interX.length + " / BD: " +
// bufferDuration);
// Log.e("PR", "OBS HZ: " + observedFreq);
FastFourierTransformer fft = new FastFourierTransformer(DftNormalization.STANDARD);
Complex[] xFFT = fft.transform(_dynamicX, TransformType.FORWARD);
Complex[] yFFT = fft.transform(_dynamicY, TransformType.FORWARD);
Complex[] zFFT = fft.transform(_dynamicZ, TransformType.FORWARD);
double[] frequencies =
XYZBasicFrequencyFeature.calculateFreqArray(_interX.length, observedFreq);
final double[] _xMaxFreqPowPair =
XYZBasicFrequencyFeature.findPeakFrequency(xFFT, frequencies);
final double[] _yMaxFreqPowPair =
XYZBasicFrequencyFeature.findPeakFrequency(yFFT, frequencies);
final double[] _zMaxFreqPowPair =
XYZBasicFrequencyFeature.findPeakFrequency(zFFT, frequencies);
// Log.e("PR", "FREQS & GEEKS: x:" + _xMaxFreqPowPair[0] + " - "
// + _xMaxFreqPowPair[1] + " y:" + _yMaxFreqPowPair[0] + " - " +
// _yMaxFreqPowPair[1] + " z:" + _zMaxFreqPowPair[0] + " - " +
// _zMaxFreqPowPair[1] );
final XYZBasicFrequencyFeature me = this;
Runnable r =
new Runnable() {
public void run() {
Bundle data = new Bundle();
data.putDouble("TIMESTAMP", now / 1000);
data.putString("PROBE", me.name(context));
boolean incInterpolated =
prefs.getBoolean(
"config_probe_" + key + "_interpolated_enabled",
XYZBasicFrequencyFeature.INTERPOLATED_ENABLED);
boolean incBandpass =
prefs.getBoolean(
"config_probe_" + key + "_bandpass_enabled",
XYZBasicFrequencyFeature.BANDPASS_ENABLED);
boolean incLowpass =
prefs.getBoolean(
"config_probe_" + key + "_lowpass_enabled",
XYZBasicFrequencyFeature.LOWPASS_ENABLED);
if (incInterpolated || incBandpass || incLowpass) {
Bundle sensorData = new Bundle();
synchronized (me) {
sensorData.putDoubleArray("INTERP_TIMESTAMPS", interTimes);
if (incInterpolated) {
sensorData.putDoubleArray("INTER_X", _interX);
sensorData.putDoubleArray("INTER_Y", _interY);
sensorData.putDoubleArray("INTER_Z", _interZ);
}
if (incBandpass) {
sensorData.putDoubleArray("DYNAMIC_X", _dynamicX);
sensorData.putDoubleArray("DYNAMIC_Y", _dynamicY);
sensorData.putDoubleArray("DYNAMIC_Z", _dynamicZ);
}
if (incLowpass) {
sensorData.putDoubleArray("STATIC_X", _staticX);
sensorData.putDoubleArray("STATIC_Y", _staticY);
sensorData.putDoubleArray("STATIC_Z", _staticZ);
}
data.putBundle("CALCULATIONS", sensorData);
}
}
data.putDouble("WINDOW_TIMESTAMP", interTimes[0]);
data.putDouble("POWER_X", _xMaxFreqPowPair[1]);
data.putDouble("POWER_Y", _yMaxFreqPowPair[1]);
data.putDouble("POWER_Z", _zMaxFreqPowPair[1]);
data.putDouble("FREQ_X", _xMaxFreqPowPair[0]);
data.putDouble("FREQ_Y", _yMaxFreqPowPair[0]);
data.putDouble("FREQ_Z", _zMaxFreqPowPair[0]);
me.transmitData(context, data);
}
};
Thread t = new Thread(r);
t.start();
}
}
}