Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-08-07 00:44:38 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Removed deceleration updated app

Browse source
This commit is contained in:
Anthony Thibault 2018-09-20 13:03:17 -07:00
parent 527c0d4195
commit 8c8b30c0f9
2 changed files with 66 additions and 69 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
libraries/controllers/src/controllers/impl/filters/AccelerationLimiterFilter.cpp
View file

@ -39,7 +39,7 @@ static glm::quat deltaRotFromAngularVel(const glm::vec3& omega, float dt) {
} }
static glm::vec3 filterTranslation(const glm::vec3& x0, const glm::vec3& x1, const glm::vec3& x2, const glm::vec3& x3, static glm::vec3 filterTranslation(const glm::vec3& x0, const glm::vec3& x1, const glm::vec3& x2, const glm::vec3& x3,
const glm::vec3& unfilteredVelocity, float dt, const float accLimit, const float decLimit) { float dt, const float accLimit) {
// measure the linear velocities of this step and the previoius step // measure the linear velocities of this step and the previoius step
glm::vec3 v1 = (x3 - x1) / (2.0f * dt); glm::vec3 v1 = (x3 - x1) / (2.0f * dt);
@ -52,9 +52,7 @@ static glm::vec3 filterTranslation(const glm::vec3& x0, const glm::vec3& x1, con
float aLen = glm::length(a); float aLen = glm::length(a);
// pick limit based on if we are moving faster then our target // pick limit based on if we are moving faster then our target
float limit = glm::length(v1) > glm::length(unfilteredVelocity) ? accLimit : decLimit; if (aLen > accLimit) {
if (aLen > limit) {
// Solve for a new `v1`, such that `a` does not exceed `aLimit` // Solve for a new `v1`, such that `a` does not exceed `aLimit`
// This combines two steps: // This combines two steps:
// 1) Computing a limited accelration in the direction of `a`, but with a magnitute of `aLimit`: // 1) Computing a limited accelration in the direction of `a`, but with a magnitute of `aLimit`:
@ -62,7 +60,7 @@ static glm::vec3 filterTranslation(const glm::vec3& x0, const glm::vec3& x1, con
// 2) Computing new `v1` // 2) Computing new `v1`
// `v1 = newA * dt + v0` // `v1 = newA * dt + v0`
// We combine the scalars from step 1 and step 2 into a single term to avoid having to do multiple scalar-vec3 multiplies. // We combine the scalars from step 1 and step 2 into a single term to avoid having to do multiple scalar-vec3 multiplies.
v1 = a * ((limit * dt) / aLen) + v0; v1 = a * ((accLimit * dt) / aLen) + v0;
// apply limited v1 to compute filtered x3 // apply limited v1 to compute filtered x3
return v1 * dt + x2; return v1 * dt + x2;
@ -73,7 +71,7 @@ static glm::vec3 filterTranslation(const glm::vec3& x0, const glm::vec3& x1, con
} }
static glm::quat filterRotation(const glm::quat& q0In, const glm::quat& q1In, const glm::quat& q2In, const glm::quat& q3In, static glm::quat filterRotation(const glm::quat& q0In, const glm::quat& q1In, const glm::quat& q2In, const glm::quat& q3In,
const glm::vec3& unfilteredVelocity, float dt, const float accLimit, const float decLimit) { float dt, const float accLimit) {
// ensure quaternions have the same polarity // ensure quaternions have the same polarity
glm::quat q0 = q0In; glm::quat q0 = q0In;
@ -88,13 +86,10 @@ static glm::quat filterRotation(const glm::quat& q0In, const glm::quat& q1In, co
const glm::vec3 a = (w1 - w0) / dt; const glm::vec3 a = (w1 - w0) / dt;
float aLen = glm::length(a); float aLen = glm::length(a);
// pick limit based on if we are moving faster then our target
float limit = glm::length(w1) > glm::length(unfilteredVelocity) ? accLimit : decLimit;
// clamp the acceleration if it is over the limit // clamp the acceleration if it is over the limit
if (aLen > limit) { if (aLen > accLimit) {
// solve for a new w1, such that a does not exceed the accLimit // solve for a new w1, such that a does not exceed the accLimit
w1 = a * ((limit * dt) / aLen) + w0; w1 = a * ((accLimit * dt) / aLen) + w0;
// apply limited w1 to compute filtered q3 // apply limited w1 to compute filtered q3
return deltaRotFromAngularVel(w1, dt) * q2; return deltaRotFromAngularVel(w1, dt) * q2;
@ -124,14 +119,11 @@ namespace controller {
const float DELTA_TIME = 0.01111111f; const float DELTA_TIME = 0.01111111f;
glm::vec3 unfilteredTranslation = sensorValue.translation; glm::vec3 unfilteredTranslation = sensorValue.translation;
glm::vec3 unfilteredLinearVel = (unfilteredTranslation - _unfilteredPrevPos[1]) / (2.0f * DELTA_TIME); sensorValue.translation = filterTranslation(_prevPos[0], _prevPos[1], _prevPos[2], sensorValue.translation,
sensorValue.translation = filterTranslation(_prevPos[0], _prevPos[1], _prevPos[2], sensorValue.translation, unfilteredLinearVel, DELTA_TIME, _translationAccelerationLimit);
DELTA_TIME, _translationAccelerationLimit, _translationDecelerationLimit);
glm::quat unfilteredRot = sensorValue.rotation; glm::quat unfilteredRot = sensorValue.rotation;
glm::quat unfilteredPrevRot = glm::dot(unfilteredRot, _unfilteredPrevRot[1]) < 0.0f ? -_unfilteredPrevRot[1] : _unfilteredPrevRot[1]; sensorValue.rotation = filterRotation(_prevRot[0], _prevRot[1], _prevRot[2], sensorValue.rotation,
glm::vec3 unfilteredAngularVel = angularVelFromDeltaRot(unfilteredRot * glm::inverse(unfilteredPrevRot), 2.0f * DELTA_TIME); DELTA_TIME, _rotationAccelerationLimit);
sensorValue.rotation = filterRotation(_prevRot[0], _prevRot[1], _prevRot[2], sensorValue.rotation, unfilteredAngularVel,
DELTA_TIME, _rotationAccelerationLimit, _rotationDecelerationLimit);
// remember previous values. // remember previous values.
_prevPos[0] = _prevPos[1]; _prevPos[0] = _prevPos[1];
@ -183,12 +175,9 @@ namespace controller {
bool AccelerationLimiterFilter::parseParameters(const QJsonValue& parameters) { bool AccelerationLimiterFilter::parseParameters(const QJsonValue& parameters) {
if (parameters.isObject()) { if (parameters.isObject()) {
auto obj = parameters.toObject(); auto obj = parameters.toObject();
if (obj.contains(JSON_ROTATION_ACCELERATION_LIMIT) && obj.contains(JSON_ROTATION_DECELERATION_LIMIT) && if (obj.contains(JSON_ROTATION_ACCELERATION_LIMIT) && obj.contains(JSON_TRANSLATION_ACCELERATION_LIMIT)) {
obj.contains(JSON_TRANSLATION_ACCELERATION_LIMIT) && obj.contains(JSON_TRANSLATION_DECELERATION_LIMIT)) {
_rotationAccelerationLimit = (float)obj[JSON_ROTATION_ACCELERATION_LIMIT].toDouble(); _rotationAccelerationLimit = (float)obj[JSON_ROTATION_ACCELERATION_LIMIT].toDouble();
_rotationDecelerationLimit = (float)obj[JSON_ROTATION_DECELERATION_LIMIT].toDouble();
_translationAccelerationLimit = (float)obj[JSON_TRANSLATION_ACCELERATION_LIMIT].toDouble(); _translationAccelerationLimit = (float)obj[JSON_TRANSLATION_ACCELERATION_LIMIT].toDouble();
_translationDecelerationLimit = (float)obj[JSON_TRANSLATION_DECELERATION_LIMIT].toDouble();
return true; return true;
} }
} }

102
scripts/developer/accelerationFilterApp.js
View file

@ -9,72 +9,68 @@ var mappingJson = {
name: "com.highfidelity.testing.accelerationTest", name: "com.highfidelity.testing.accelerationTest",
channels: [ channels: [
{ {
from: "Vive.LeftHand", from: "Standard.LeftHand",
to: "Standard.LeftHand", to: "Actions.LeftHand",
filters: [ filters: [
{ {
type: "accelerationLimiter", type: "accelerationLimiter",
rotationAccelerationLimit: 2000.0, rotationAccelerationLimit: 2000.0,
rotationDecelerationLimit: 4000.0,
translationAccelerationLimit: 100.0, translationAccelerationLimit: 100.0,
translationDecelerationLimit: 200.0
} }
] ]
}, },
{ {
from: "Vive.RightHand", from: "Standard.RightHand",
to: "Standard.RightHand", to: "Actions.RightHand",
filters: [ filters: [
{ {
type: "accelerationLimiter", type: "accelerationLimiter",
rotationAccelerationLimit: 2000.0, rotationAccelerationLimit: 2000.0,
rotationDecelerationLimit: 4000.0,
translationAccelerationLimit: 100.0, translationAccelerationLimit: 100.0,
translationDecelerationLimit: 200.0
} }
] ]
}, },
{ {
from: "Vive.LeftFoot", from: "Standard.LeftFoot",
to: "Standard.LeftFoot", to: "Actions.LeftFoot",
filters: [ filters: [
{ {
type: "exponentialSmoothing", type: "accelerationLimiter",
rotation: 0.15, rotationAccelerationLimit: 2000.0,
translation: 0.3 translationAccelerationLimit: 100.0,
} }
] ]
}, },
{ {
from: "Vive.RightFoot", from: "Standard.RightFoot",
to: "Standard.RightFoot", to: "Actions.RightFoot",
filters: [ filters: [
{ {
type: "exponentialSmoothing", type: "accelerationLimiter",
rotation: 0.15, rotationAccelerationLimit: 2000.0,
translation: 0.3 translationAccelerationLimit: 100.0,
} }
] ]
}, },
{ {
from: "Vive.Hips", from: "Standard.Hips",
to: "Standard.Hips", to: "Actions.Hips",
filters: [ filters: [
{ {
type: "exponentialSmoothing", type: "accelerationLimiter",
rotation: 0.15, rotationAccelerationLimit: 2000.0,
translation: 0.3 translationAccelerationLimit: 100.0,
} }
] ]
}, },
{ {
from: "Vive.Spine2", from: "Standard.Spine2",
to: "Standard.Spine2", to: "Actions.Spine2",
filters: [ filters: [
{ {
type: "exponentialSmoothing", type: "accelerationLimiter",
rotation: 0.15, rotationAccelerationLimit: 2000.0,
translation: 0.3 translationAccelerationLimit: 100.0,
} }
] ]
} }
@ -86,7 +82,7 @@ var mappingJson = {
// //
var TABLET_BUTTON_NAME = "ACCFILT"; var TABLET_BUTTON_NAME = "ACCFILT";
var HTML_URL = "https://s3.amazonaws.com/hifi-public/tony/html/accelerationFilterApp.html"; var HTML_URL = "https://s3.amazonaws.com/hifi-public/tony/html/accelerationFilterApp.html?2";
var tablet = Tablet.getTablet("com.highfidelity.interface.tablet.system"); var tablet = Tablet.getTablet("com.highfidelity.interface.tablet.system");
var tabletButton = tablet.addButton({ var tabletButton = tablet.addButton({
@ -132,42 +128,54 @@ function setTranslationAccelerationLimit(i, value) {
mappingJson.channels[i].filters[0].translationAccelerationLimit = value; mappingJson.channels[i].filters[0].translationAccelerationLimit = value;
mappingChanged(); mappingChanged();
} }
function getTranslationDecelerationLimit(i) {
return mappingJson.channels[i].filters[0].translationDecelerationLimit;
}
function setTranslationDecelerationLimit(i, value) {
mappingJson.channels[i].filters[0].translationDecelerationLimit = value; mappingChanged();
}
function getRotationAccelerationLimit(i) { function getRotationAccelerationLimit(i) {
return mappingJson.channels[i].filters[0].rotationAccelerationLimit; return mappingJson.channels[i].filters[0].rotationAccelerationLimit;
} }
function setRotationAccelerationLimit(i, value) { function setRotationAccelerationLimit(i, value) {
mappingJson.channels[i].filters[0].rotationAccelerationLimit = value; mappingChanged(); mappingJson.channels[i].filters[0].rotationAccelerationLimit = value; mappingChanged();
} }
function getRotationDecelerationLimit(i) {
return mappingJson.channels[i].filters[0].rotationDecelerationLimit;
}
function setRotationDecelerationLimit(i, value) {
mappingJson.channels[i].filters[0].rotationDecelerationLimit = value; mappingChanged();
}
function onWebEventReceived(msg) { function onWebEventReceived(msg) {
if (msg.name === "init-complete") { if (msg.name === "init-complete") {
var values = [ var values = [
{name: "left-hand-translation-acceleration-limit", val: getTranslationAccelerationLimit(LEFT_HAND_INDEX), checked: false}, {name: "left-hand-translation-acceleration-limit", val: getTranslationAccelerationLimit(LEFT_HAND_INDEX), checked: false},
{name: "left-hand-translation-deceleration-limit", val: getTranslationDecelerationLimit(LEFT_HAND_INDEX), checked: false},
{name: "left-hand-rotation-acceleration-limit", val: getRotationAccelerationLimit(LEFT_HAND_INDEX), checked: false}, {name: "left-hand-rotation-acceleration-limit", val: getRotationAccelerationLimit(LEFT_HAND_INDEX), checked: false},
{name: "left-hand-rotation-deceleration-limit", val: getRotationDecelerationLimit(LEFT_HAND_INDEX), checked: false} {name: "right-hand-translation-acceleration-limit", val: getTranslationAccelerationLimit(RIGHT_HAND_INDEX), checked: false},
{name: "right-hand-rotation-acceleration-limit", val: getRotationAccelerationLimit(RIGHT_HAND_INDEX), checked: false},
{name: "left-foot-translation-acceleration-limit", val: getTranslationAccelerationLimit(LEFT_FOOT_INDEX), checked: false},
{name: "left-foot-rotation-acceleration-limit", val: getRotationAccelerationLimit(LEFT_FOOT_INDEX), checked: false},
{name: "right-foot-translation-acceleration-limit", val: getTranslationAccelerationLimit(RIGHT_FOOT_INDEX), checked: false},
{name: "right-foot-rotation-acceleration-limit", val: getRotationAccelerationLimit(RIGHT_FOOT_INDEX), checked: false},
{name: "hips-translation-acceleration-limit", val: getTranslationAccelerationLimit(HIPS_INDEX), checked: false},
{name: "hips-rotation-acceleration-limit", val: getRotationAccelerationLimit(HIPS_INDEX), checked: false},
{name: "spine2-translation-acceleration-limit", val: getTranslationAccelerationLimit(SPINE2_INDEX), checked: false},
{name: "spine2-rotation-acceleration-limit", val: getRotationAccelerationLimit(SPINE2_INDEX), checked: false}
]; ];
tablet.emitScriptEvent(JSON.stringify(values)); tablet.emitScriptEvent(JSON.stringify(values));
} else if (msg.name === "left-hand-translation-acceleration-limit") { } else if (msg.name === "left-hand-translation-acceleration-limit") {
setTranslationAccelerationLimit(LEFT_HAND_INDEX, parseInt(msg.val, 10)); setTranslationAccelerationLimit(LEFT_HAND_INDEX, parseInt(msg.val, 10));
} else if (msg.name === "left-hand-translation-deceleration-limit") {
setTranslationDecelerationLimit(LEFT_HAND_INDEX, parseInt(msg.val, 10));
} else if (msg.name === "left-hand-rotation-acceleration-limit") { } else if (msg.name === "left-hand-rotation-acceleration-limit") {
setRotationAccelerationLimit(LEFT_HAND_INDEX, parseInt(msg.val, 10)); setRotationAccelerationLimit(LEFT_HAND_INDEX, parseInt(msg.val, 10));
} else if (msg.name === "left-hand-rotation-deceleration-limit") { } else if (msg.name === "right-hand-translation-acceleration-limit") {
setRotationDecelerationLimit(LEFT_HAND_INDEX, parseInt(msg.val, 10)); setTranslationAccelerationLimit(RIGHT_HAND_INDEX, parseInt(msg.val, 10));
} else if (msg.name === "right-hand-rotation-acceleration-limit") {
setRotationAccelerationLimit(RIGHT_HAND_INDEX, parseInt(msg.val, 10));
} else if (msg.name === "left-foot-translation-acceleration-limit") {
setTranslationAccelerationLimit(LEFT_FOOT_INDEX, parseInt(msg.val, 10));
} else if (msg.name === "left-foot-rotation-acceleration-limit") {
setRotationAccelerationLimit(LEFT_FOOT_INDEX, parseInt(msg.val, 10));
} else if (msg.name === "right-foot-translation-acceleration-limit") {
setTranslationAccelerationLimit(RIGHT_FOOT_INDEX, parseInt(msg.val, 10));
} else if (msg.name === "right-foot-rotation-acceleration-limit") {
setRotationAccelerationLimit(RIGHT_FOOT_INDEX, parseInt(msg.val, 10));
} else if (msg.name === "hips-translation-acceleration-limit") {
setTranslationAccelerationLimit(HIPS_INDEX, parseInt(msg.val, 10));
} else if (msg.name === "hips-rotation-acceleration-limit") {
setRotationAccelerationLimit(HIPS_INDEX, parseInt(msg.val, 10));
} else if (msg.name === "spine2-translation-acceleration-limit") {
setTranslationAccelerationLimit(SPINE2_INDEX, parseInt(msg.val, 10));
} else if (msg.name === "spine2-rotation-acceleration-limit") {
setRotationAccelerationLimit(SPINE2_INDEX, parseInt(msg.val, 10));
} }
} }