Direction.h

Go to the documentation of this file.

/*****************************************************************************
 * $CAMITK_LICENCE_BEGIN$
 *
 * CamiTK - Computer Assisted Medical Intervention ToolKit
 * (c) 2001-2021 Univ. Grenoble Alpes, CNRS, Grenoble INP, TIMC, 38000 Grenoble, France
 *
 * Visit http://camitk.imag.fr for more information
 *
 * This file is part of CamiTK.
 *
 * CamiTK is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * CamiTK is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with CamiTK.  If not, see <http://www.gnu.org/licenses/>.
 *
 * $CAMITK_LICENCE_END$
 ****************************************************************************/
 
 
#ifndef DIRECTION_H
#define DIRECTION_H
 
#include <iostream>
 
class Direction {
 
public:
    Direction() {};
    Direction(const unsigned int toward) {
        setToward(toward);
    };
    Direction(double x0, double y0, double z0) {
        setX(x0);
        setY(y0);
        setZ(z0);
    };
    Direction(const Direction& d) {
        x = d.x;
        xState = d.xState;
        y = d.y;
        yState = d.yState;
        z = d.z;
        zState = d.zState;
        towardIndex = d.towardIndex;
    };
 
    Direction& operator=(const Direction& d) {
        x = d.x;
        xState = d.xState;
        y = d.y;
        yState = d.yState;
        z = d.z;
        zState = d.zState;
        towardIndex = d.towardIndex;
        return *this;
    }
 
    void xmlPrint(std::ostream& o) const {
        o << "\t<direction ";
        if (isToward()) {
            o << "toward=\"" << towardIndex << "\"";
        }
        else {
            switch (xState) {
                case NOT_SPECIFIED:
                    break;
                case NULL_DIR:
                    o << "x=\"NULL\" ";
                    break;
                case SPECIFIED:
                    o << "x=\"" << x << "\" ";
                    break;
                default:
                    break;
            }
            switch (yState) {
                case NOT_SPECIFIED:
                    break;
                case NULL_DIR:
                    o << "y=\"NULL\" ";
                    break;
                case SPECIFIED:
                    o << "y=\"" << y << "\" ";
                    break;
                default:
                    break;
            }
            switch (zState) {
                case NOT_SPECIFIED:
                    break;
                case NULL_DIR:
                    o << "z=\"NULL\"";
                    break;
                case SPECIFIED:
                    o << "z=\"" << z << "\"";
                    break;
                default:
                    break;
            }
        }
        o << "/>" << std::endl;
    };
 
    void set(const double x, const double y, const double z) {
        setX(x);
        setY(y);
        setZ(z);
    };
 
    int getToward() const {
        return towardIndex;
    };
 
    void setToward(const unsigned int toward) {
        towardIndex = toward;
        xState = yState = zState = TOWARD;
    };
 
    bool isToward() const {
        return (towardIndex >= 0 && xState == TOWARD && yState == TOWARD && zState == TOWARD);
    };
 
 
 
    double getX() const {
        return x;
    };
 
    bool isXNull() const {
        return (xState == NULL_DIR);
    };
 
    bool isXSpecified() const {
        return (xState == SPECIFIED);
    };
 
    void setNullX() {
        x = 0.0;
        xState = NULL_DIR;
    };
 
    void setX(const double x) {
        this->x = x;
        xState = SPECIFIED;
    };
 
 
    double getY() const {
        return y;
    };
 
    bool isYNull() const {
        return (yState == NULL_DIR);
    };
 
    bool isYSpecified() const {
        return (yState == SPECIFIED);
    };
 
    void setNullY() {
        y = 0.0;
        yState = NULL_DIR;
    };
 
    void setY(const double y) {
        this->y = y;
        yState = SPECIFIED;
    };
 
 
 
    double getZ() const {
        return z;
    };
 
    bool isZNull() const {
        return (zState == NULL_DIR);
    };
 
    bool isZSpecified() const {
        return (zState == SPECIFIED);
    };
 
    void setNullZ() {
        z = 0.0;
        zState = NULL_DIR;
    };
 
    void setZ(const double z) {
        this->z = z;
        zState = SPECIFIED;
    };
 
 
private:
    enum DirState {
        NOT_SPECIFIED,  
        NULL_DIR,       
        SPECIFIED,      
        TOWARD          
    };
 
    double x{0.0};
    double y{0.0};
    double z{0.0};
    DirState xState{NOT_SPECIFIED};
    DirState yState{NOT_SPECIFIED};
    DirState zState{NOT_SPECIFIED};
    int towardIndex{-1};
};
 
#endif //DIRECTION_H