axlPoint.cpp

Go to the documentation of this file.

/* axlPoint.cpp ---
 *
 * Author: Meriadeg Perrinel
 * Copyright (C) 2008 - Meriadeg Perrinel, Inria.
 * Created: Tue Nov  9 16:58:59 2010 (+0100)
 * Version: $Id$
 * Last-Updated: Tue Nov  9 17:09:38 2010 (+0100)
 *           By: Meriadeg Perrinel
 *     Update #: 19
 */

/* Commentary:
 *
 */

/* Change log:
 *
 */

#include "axlPoint.h"

#include <dtkCoreSupport/dtkGlobal.h>

// /////////////////////////////////////////////////////////////////
// axlPointPrivate
// /////////////////////////////////////////////////////////////////

class axlPointPrivate
{
public:
    double coordinates[3];

};

// /////////////////////////////////////////////////////////////////
// axlPoint implementation
// /////////////////////////////////////////////////////////////////


axlPoint::axlPoint(QObject *parent) : axlAbstractData(), d(new axlPointPrivate)
{
    this->setObjectName(this->identifier());
    d->coordinates[0] = 0.0;
    d->coordinates[1] = 0.0;
    d->coordinates[2] = 0.0;
}


axlPoint::axlPoint(double x, double y, double z, QObject *parent) : axlAbstractData(), d(new axlPointPrivate)
{
    this->setObjectName(this->identifier());
    d->coordinates[0] = x;
    d->coordinates[1] = y;
    d->coordinates[2] = z;
}


axlPoint::axlPoint(const axlPoint& other) : axlAbstractData(), d(new axlPointPrivate)
{
    this->setObjectName(this->identifier());
    this->setParent(other.parent());
    d->coordinates[0] = other.d->coordinates[0];
    d->coordinates[1] = other.d->coordinates[1];
    d->coordinates[2] = other.d->coordinates[2];
}


axlPoint::axlPoint(const axlPoint *other) : axlAbstractData(), d(new axlPointPrivate)
{
    this->setObjectName(this->identifier());
    this->setParent(other->parent());
    d->coordinates[0] = other->d->coordinates[0];
    d->coordinates[1] = other->d->coordinates[1];
    d->coordinates[2] = other->d->coordinates[2];
}


axlPoint::axlPoint(double *p, QObject *parent): d(new axlPointPrivate)
{
    // There is no verification of p;
    this->setObjectName(this->identifier());
    d->coordinates[0] = p[0];
    d->coordinates[1] = p[1];
    d->coordinates[2] = p[2];
}


axlPoint::~axlPoint(void)
{
    delete d;

    d = NULL;
}


axlPoint& axlPoint::operator=(const axlPoint& other)
{
    d->coordinates[0] = other.d->coordinates[0];
    d->coordinates[1] = other.d->coordinates[1];
    d->coordinates[2] = other.d->coordinates[2];

    return (*this);
}


axlPoint& axlPoint::operator+=(const axlPoint& other)
{
    d->coordinates[0] += other.d->coordinates[0];
    d->coordinates[1] += other.d->coordinates[1];
    d->coordinates[2] += other.d->coordinates[2];

    return (*this);
}


axlPoint& axlPoint::operator-=(const axlPoint& other)
{
    d->coordinates[0] -= other.d->coordinates[0];
    d->coordinates[1] -= other.d->coordinates[1];
    d->coordinates[2] -= other.d->coordinates[2];

    return (*this);
}


axlPoint& axlPoint::operator*=(double scalar)
{
    d->coordinates[0] *= scalar;
    d->coordinates[1] *= scalar;
    d->coordinates[2] *= scalar;

    return (*this);
}


axlPoint& axlPoint::operator/=(double scalar)
{
    if(!(scalar != 0.)) {
        qWarning() << DTK_PRETTY_FUNCTION << "Preventing division by 0. Operand not affected.";
        return (*this);
    }

    d->coordinates[0] /= scalar;
    d->coordinates[1] /= scalar;
    d->coordinates[2] /= scalar;

    return (*this);
}




axlPoint axlPoint::operator+(const axlPoint& other) const
{
    axlPoint result(d->coordinates[0] + other.d->coordinates[0],
            d->coordinates[1] + other.d->coordinates[1],
            d->coordinates[2] + other.d->coordinates[2] );
    return result;
}


axlPoint axlPoint::operator-(const axlPoint& other) const
{
    axlPoint result(d->coordinates[0] - other.d->coordinates[0],
            d->coordinates[1] - other.d->coordinates[1],
            d->coordinates[2] - other.d->coordinates[2]);
    return result;
}


axlPoint axlPoint::operator*(double scalar) const
{
    axlPoint result(d->coordinates[0] * scalar,
            d->coordinates[1] * scalar,
            d->coordinates[2] * scalar);
    return result;
}


double axlPoint::operator*(const axlPoint& other) const
{
    return (d->coordinates[0] * other[0]
            + d->coordinates[1] * other[1]
            + d->coordinates[2] * other[2]);

}
bool axlPoint::operator<(const axlPoint& other) const{
    return  (d->coordinates[0] < other.x()
            || (!(other.x() == d->coordinates[0]) && d->coordinates[1] < other.y())
            || (!(other.x() == d->coordinates[0]) && !(other.y() == d->coordinates[1]) && d->coordinates[2] < other.z()));
}




axlPoint axlPoint::operator/(double scalar) const
{
    if(!(scalar != 0.)) {
        qWarning() << DTK_PRETTY_FUNCTION << "Preventing division by 0. Returning default point";
        return axlPoint();
    }

    axlPoint result(d->coordinates[0] / scalar,
            d->coordinates[1] / scalar,
            d->coordinates[2] / scalar);

    return result;
}

void axlPoint::transformAsPoint(double matrix[12]) {
    this->setCoordinates(
                d->coordinates[0] * matrix[0] + d->coordinates[1] * matrix[1] + d->coordinates[2] * matrix[2] + matrix[3],
            d->coordinates[0] * matrix[4] + d->coordinates[1] * matrix[5] + d->coordinates[2] * matrix[6] + matrix[7],
            d->coordinates[0] * matrix[8] + d->coordinates[1] * matrix[9] + d->coordinates[2] * matrix[10] + matrix[11]
            );
}

void axlPoint::transformAsVector(double matrix[12]) {
    this->setCoordinates(
                d->coordinates[0] * matrix[0] + d->coordinates[1] * matrix[1] + d->coordinates[2] * matrix[2],
            d->coordinates[0] * matrix[4] + d->coordinates[1] * matrix[5] + d->coordinates[2] * matrix[6],
            d->coordinates[0] * matrix[8] + d->coordinates[1] * matrix[9] + d->coordinates[2] * matrix[10]
            );
}


bool axlPoint::operator== (const axlPoint& point2) const {
    return (this->x() == point2.x()
            && this->y() == point2.y()
            && this->z() == point2.z());
}

bool axlPoint::operator !=(const axlPoint& point2) const {
    return !(*this == point2);
}



double axlPoint::x(void) const
{
    return d->coordinates[0];
}


double axlPoint::y(void) const
{
    return d->coordinates[1];
}


double axlPoint::z(void) const
{
    return d->coordinates[2];
}


double axlPoint::operator [] (int i) const
{
    //assert( i>=0 && i<3);
    return d->coordinates[i];
}


double& axlPoint::x(void)
{
    return d->coordinates[0];
}


double& axlPoint::y(void)
{
    return d->coordinates[1];
}


double& axlPoint::z(void)
{
    return d->coordinates[2];
}


double& axlPoint::operator [] (int i)
{
    //assert( i>=0 && i<3);
    return d->coordinates[i];
}


void axlPoint::setCoordinates(double x, double y, double z)
{
    d->coordinates[0] = x;
    d->coordinates[1] = y;
    d->coordinates[2] = z;
//    this->touchGeometry();
}



//void axlPoint::updateCoordinates(double x, double y, double z)
//{
//    this->setCoordinates(x,y,z);
//    this->touchGeometry();
//}

void axlPoint::touchX(double x)
{
    d->coordinates[0] = x;

    this->touchGeometry();
}

void axlPoint::touchY(double y)
{
    d->coordinates[1] = y;

    this->touchGeometry();
}

void axlPoint::touchZ(double z)
{
    d->coordinates[2] = z;

    this->touchGeometry();
}

void axlPoint::normalize(void)
{
    double n = this->norm();
    if(n > 0.0005)
    {
        d->coordinates[0] /= n;
        d->coordinates[1] /= n;
        d->coordinates[2] /= n;
    }
}

axlPoint& axlPoint::normalized(void)  {
    double n = this->norm();
    if(n > 0.0005)
    {
        d->coordinates[0] /= n;
        d->coordinates[1] /= n;
        d->coordinates[2] /= n;
    }
    return *this;
}



bool axlPoint::isEqualTo(axlPoint *point){
    return (d->coordinates[0]==point->x() && d->coordinates[1]==point->y() && d->coordinates[2]==point->z());
}


double *axlPoint::coordinates(void) const
{
    return d->coordinates ;
}

double axlPoint::norm() const
{
    return sqrt(d->coordinates[0] * d->coordinates[0] + d->coordinates[1] * d->coordinates[1] + d->coordinates[2] * d->coordinates[2]);
}


double axlPoint::distance(const axlPoint& lhs, const axlPoint& rhs)
{
    double dx = rhs.d->coordinates[0] - lhs.d->coordinates[0];
    double dy = rhs.d->coordinates[1] - lhs.d->coordinates[1];
    double dz = rhs.d->coordinates[2] - lhs.d->coordinates[2];

    return qSqrt(dx*dx + dy*dy + dz*dz);
}


double axlPoint::distance(axlPoint *lhs, axlPoint *rhs)
{
    double dx = rhs->d->coordinates[0] - lhs->d->coordinates[0];
    double dy = rhs->d->coordinates[1] - lhs->d->coordinates[1];
    double dz = rhs->d->coordinates[2] - lhs->d->coordinates[2];

    return qSqrt(dx*dx + dy*dy + dz*dz);
}


axlPoint axlPoint::crossProduct(const axlPoint& lhs, const axlPoint& rhs)
{
    return axlPoint(
                lhs.d->coordinates[1]*rhs.d->coordinates[2] - lhs.d->coordinates[2]*rhs.d->coordinates[1],
            lhs.d->coordinates[2]*rhs.d->coordinates[0] - lhs.d->coordinates[0]*rhs.d->coordinates[2],
            lhs.d->coordinates[0]*rhs.d->coordinates[1] - lhs.d->coordinates[1]*rhs.d->coordinates[0]
            );
}


axlPoint* axlPoint::crossProduct(axlPoint *lhs, axlPoint *rhs)
{
    return new axlPoint(
                lhs->d->coordinates[1]*rhs->d->coordinates[2] - lhs->d->coordinates[2]*rhs->d->coordinates[1],
            lhs->d->coordinates[2]*rhs->d->coordinates[0] - lhs->d->coordinates[0]*rhs->d->coordinates[2],
            lhs->d->coordinates[0]*rhs->d->coordinates[1] - lhs->d->coordinates[1]*rhs->d->coordinates[0]
            );
}


double axlPoint::dotProduct(const axlPoint& lhs, const axlPoint& rhs) {
    return lhs.x()*rhs.x() + lhs.y()*rhs.y() + lhs.z()*rhs.z();
}

double axlPoint::dotProduct(axlPoint *lhs, axlPoint *rhs) {
    return lhs->x()*rhs->x() + lhs->y()*rhs->y() + lhs->z()*rhs->z();
}


// /////////////////////////////////////////////////////////////////
// Debug operators
// /////////////////////////////////////////////////////////////////

QDebug operator<<(QDebug dbg, axlPoint point)
{
    dbg.nospace() << QString("axlPoint: (%1, %2, %3)").arg(point.x()).arg(point.y()).arg(point.z());

    return dbg.space();
}

QDebug operator<<(QDebug dbg, axlPoint& point)
{
    dbg.nospace() << QString("axlPoint: (%1, %2, %3)").arg(point.x()).arg(point.y()).arg(point.z());

    return dbg.space();
}

QDebug operator<<(QDebug dbg, axlPoint *point)
{
    dbg.nospace() << QString("axlPoint: (%1, %2, %3)").arg(point->x()).arg(point->y()).arg(point->z());

    return dbg.space();
}

QString axlPoint::description(void) const
{
    QString result = "axlPoint";
    result.append("\nX : "+QString::number(d->coordinates[0]) + "\nY : "+QString::number(d->coordinates[1]) + "\nZ : "+QString::number(d->coordinates[2]));
    return result;
}

QString axlPoint::identifier(void) const
{
    return "axlPoint";
}

//void axlPoint::onXChanged(double x)
//{
//    d->coordinates[0] = x;
//}

//void axlPoint::onYChanged(double y)
//{
//    d->coordinates[1] = y;
//}

//void axlPoint::onZChanged(double z)
//{
//    d->coordinates[2] = z;
//}


QVariantList axlPoint::convertDataToQVariant(void) const{
    QVariantList list;
    QVariant id = QVariant::fromValue(identifier());
    QVariant x = QVariant::fromValue(d->coordinates[0]);
    QVariant y = QVariant::fromValue(d->coordinates[1]);
    QVariant z = QVariant::fromValue(d->coordinates[2]);
    list.append(id);
    list.append(x);
    list.append(y);
    list.append(z);
    QVariant name = QVariant::fromValue(objectName());
    list.append(name);

    return list;

}

int axlPoint::convertQVariantToData(const QVariantList &data){
    QVariant x = data.at(1);
    QVariant y = data.at(2);
    QVariant z = data.at(3);
    QString name = data.last().toString();
    setObjectName(name);
    setCoordinates(qvariant_cast<double>(x),qvariant_cast<double>(y),qvariant_cast<double>(z) );
    return 1;
}

//to be registered to the data factory.
dtkAbstractData *createaxlPoint(void)
{
    return new axlPoint;
}

// /////////////////////////////////////////////////////////////////
// axlPoint documentation
// /////////////////////////////////////////////////////////////////