SensingCartesian.cpp

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of RCI project
 *
 * Copyright (C) 2011 by Arne Nordmann <anordman at cor-lab dot uni-bielefeld dot de>
 *
 * This file may be licensed under the terms of the
 * GNU Lesser General Public License Version 3 (the ``LGPL''),
 * or (at your option) any later version.
 *
 * Software distributed under the License is distributed
 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
 * express or implied. See the LGPL for the specific language
 * governing rights and limitations.
 *
 * You should have received a copy of the LGPL along with this
 * program. If not, go to http://www.gnu.org/licenses/lgpl.html
 * or write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The development of this software was supported by:
 *   CoR-Lab, Research Institute for Cognition and Robotics
 *     Bielefeld University
 *
 * ============================================================ */

#include "rci/SensingCartesian.h"

namespace rci {

OrientationPtr OrientationSensing::getOrientation() const {
    if (!orientation) {
        throw std::runtime_error("No orientation given yet");
    }
    return this->orientation;
}

void OrientationSensing::updateOrientation(OrientationPtr orient) {
    this->orientation = orient;
}

OrientationSensing::OrientationSensing() :
        orientation() {
}

OrientationSensing::~OrientationSensing() {
}

TranslationPtr TranslationSensing::getTranslation() const {
    if (!translation) {
        throw std::runtime_error("No translation given yet");
    }
    return this->translation;
}

void TranslationSensing::updateTranslation(TranslationPtr translat) {
    this->translation = translat;
}

TranslationSensing::TranslationSensing() :
        translation() {
}

TranslationSensing::~TranslationSensing() {
}

PosePtr PoseSensing::getPose() const {
    if (!translation) {
        throw std::runtime_error("Pose incomplete; no translation given yet.");
    }
    if (!orientation) {
        throw std::runtime_error("Pose incomplete; no orientation given yet.");
    }
    return PosePtr(new Pose(translation, orientation));
}

void PoseSensing::updatePose(PosePtr pose) {
    if (pose == NULL) {
        throw std::runtime_error("[PoseSensing::updatePose] Got null pointer!");
    }
    this->updateTranslation(pose->getTranslation());
    this->updateOrientation(pose->getOrientation());
}

void PoseSensing::updatePose(TranslationPtr transl, OrientationPtr orient) {
    this->updateTranslation(transl);
    this->updateOrientation(orient);
}

PoseSensing::PoseSensing() :
        TranslationSensing(), OrientationSensing() {
}

PoseSensing::~PoseSensing() {
}

TranslationalVelocityPtr TranslationalVelocitySensing::getTranslationalVelocity() const {
    if (!veltranslational) {
        throw std::runtime_error("No translational velocity given yet");
    }
    return this->veltranslational;
}

void TranslationalVelocitySensing::updateTranslationalVelocity(
        TranslationalVelocityPtr tvel) {
    this->veltranslational = tvel;
}

TranslationalVelocitySensing::TranslationalVelocitySensing() :
        veltranslational() {
}

TranslationalVelocitySensing::~TranslationalVelocitySensing() {
}

RotationalVelocityPtr RotationalVelocitySensing::getRotationalVelocity() const {
    if (!velrotational) {
        throw std::runtime_error("No rotational velocity given yet");
    }
    return this->velrotational;
}

void RotationalVelocitySensing::updateRotationalVelocity(
        RotationalVelocityPtr rvel) {
    this->velrotational = rvel;
}

RotationalVelocitySensing::RotationalVelocitySensing() :
        velrotational() {
}

RotationalVelocitySensing::~RotationalVelocitySensing() {
}

void CartesianVelocitySensing::updateVelocity(TranslationalVelocityPtr transvel,
        RotationalVelocityPtr rotvel) {
    this->updateTranslationalVelocity(transvel);
    this->updateRotationalVelocity(rotvel);
}

VelocityPtr CartesianVelocitySensing::getVelocity() {
    throw std::runtime_error("Not yet implemented");
}

CartesianVelocitySensing::CartesianVelocitySensing() :
        TranslationalVelocitySensing(), RotationalVelocitySensing() {
}

CartesianVelocitySensing::~CartesianVelocitySensing() {
}

TranslationalAccelerationPtr TranslationalAccelerationSensing::getTranslationalAcceleration() const {
    if (!acctranslational) {
        throw std::runtime_error("No translational acceleration given yet");
    }
    return this->acctranslational;
}

void TranslationalAccelerationSensing::updateTranslationalAcceleration(
        TranslationalAccelerationPtr tacc) {
    this->acctranslational = tacc;
}

TranslationalAccelerationSensing::TranslationalAccelerationSensing() :
        acctranslational() {
}

TranslationalAccelerationSensing::~TranslationalAccelerationSensing() {
}

RotationalAccelerationPtr RotationalAccelerationSensing::getRotationalAcceleration() const {
    if (!accrotational) {
        throw std::runtime_error("No rotational acceleration given yet");
    }
    return this->accrotational;
}

void RotationalAccelerationSensing::updateRotationalAcceleration(
        RotationalAccelerationPtr racc) {
    this->accrotational = racc;
}

RotationalAccelerationSensing::RotationalAccelerationSensing() :
        accrotational() {
}

RotationalAccelerationSensing::~RotationalAccelerationSensing() {
}

void CartesianAccelerationSensing::updateAcceleration(
        TranslationalAccelerationPtr transacc,
        RotationalAccelerationPtr rotacc) {
    this->updateTranslationalAcceleration(transacc);
    this->updateRotationalAcceleration(rotacc);
}

AccelerationPtr CartesianAccelerationSensing::getAcceleration() {
    throw std::runtime_error("Not yet implemented");
}

CartesianAccelerationSensing::CartesianAccelerationSensing() :
        TranslationalAccelerationSensing(), RotationalAccelerationSensing() {
}

CartesianAccelerationSensing::~CartesianAccelerationSensing() {
}

}