axlSphere.cpp

Go to the documentation of this file.

/* axlSphere.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 "axlSphere.h"

#include <dtkCoreSupport/dtkGlobal.h>

// /////////////////////////////////////////////////////////////////
// axlSpherePrivate
// /////////////////////////////////////////////////////////////////

class axlSpherePrivate
{
public:
    double coordinates[3];
    double radius;

};

// /////////////////////////////////////////////////////////////////
// axlSphere implementation
// /////////////////////////////////////////////////////////////////


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


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

}


axlSphere::axlSphere(const axlSphere& other) : axlAbstractData(), d(new axlSpherePrivate)
{
    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];
    d->radius = other.d->radius;

}


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

    d = NULL;
}


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

    return (*this);
}


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

    return (*this);
}


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

    return (*this);
}


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

    return (*this);
}


axlSphere& axlSphere::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;
    d->radius /= scalar;

    return (*this);
}


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


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


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


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

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

    return result;
}


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


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


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

double axlSphere::radius(void) const
{
    return d->radius;
}

void axlSphere::setRadius(double radius)
{
    d->radius = radius;
//    this->touchGeometry();
}

void axlSphere::touchRadius(double radius)
{
    d->radius = radius;
    this->touchGeometry();
}

void axlSphere::touchCenter(axlPoint center)
{
    d->coordinates[0] = center.x();
    d->coordinates[1] = center.y();
    d->coordinates[2] = center.z();

    this->touchGeometry();
}

axlPoint axlSphere::centerPoint(void)
{
    axlPoint center(d->coordinates);
//    return (new axlPoint(d->coordinates));
    return center;
}

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

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

void axlSphere::normalize()
{
    double norm = sqrt(d->coordinates[0] * d->coordinates[0] + d->coordinates[1] * d->coordinates[1] + d->coordinates[2] * d->coordinates[2]);
    d->coordinates[0] /= norm;
    d->coordinates[1] /= norm;
    d->coordinates[2] /= norm;
    d->radius /= norm;
}




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


double axlSphere::distance(const axlSphere& lhs, const axlSphere& 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 axlSphere::distance(axlSphere *lhs, axlSphere *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);
}


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

QDebug operator<<(QDebug dbg, axlSphere sphere)
{
    dbg.nospace() << QString("axlSphere: center: (%1, %2, %3) radius : (%4)").arg(sphere.x()).arg(sphere.y()).arg(sphere.z()).arg(sphere.radius());

    return dbg.space();
}

QDebug operator<<(QDebug dbg, axlSphere& sphere)
{
    dbg.nospace() << QString("axlSphere: center: (%1, %2, %3) radius : (%4)").arg(sphere.x()).arg(sphere.y()).arg(sphere.z()).arg(sphere.radius());

    return dbg.space();
}

QDebug operator<<(QDebug dbg, axlSphere *sphere)
{
    dbg.nospace() << QString("axlSphere: center: (%1, %2, %3) radius : (%4)").arg(sphere->x()).arg(sphere->y()).arg(sphere->z()).arg(sphere->radius());

    return dbg.space();
}

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

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

//void axlSphere::emitDataChanged(void)
//{
//    emit dataChanged();
//}

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

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

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

void axlSphere::onRadiusChanged(double radius)
{
    d->radius = radius;
}


QVariantList axlSphere::convertDataToQVariant(void) const{
    QVariantList list;
    QVariant id = QVariant::fromValue(identifier());
    QVariant xcenter = QVariant::fromValue(d->coordinates[0]);
    QVariant ycenter = QVariant::fromValue(d->coordinates[1]);
    QVariant zcenter = QVariant::fromValue(d->coordinates[2]);
    QVariant radius = QVariant::fromValue(d->radius);
    list.append(id);
    list.append(xcenter);
    list.append(ycenter);
    list.append(zcenter);
    list.append(radius);
    QVariant name = QVariant::fromValue(objectName());
    list.append(name);
    return list;

}

int axlSphere::convertQVariantToData(const QVariantList &data){
    setCenter(data.at(1).toDouble(), data.at(2).toDouble(), data.at(3).toDouble());
    setRadius(data.at(4).toDouble());
    setObjectName(data.last().toString());
    return 1;
}

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


// /////////////////////////////////////////////////////////////////
// axlSphere documentation
// /////////////////////////////////////////////////////////////////