• About
• Gallery
• Download
• Documentation
• Publications
• Community

include/voreen/modules/base/processors/image/labelingmath.h

/**********************************************************************
 *                                                                    *
 * Voreen - The Volume Rendering Engine                               *
 *                                                                    *
 * Copyright (C) 2005-2010 The Voreen Team. <http://www.voreen.org>   *
 *                                                                    *
 * This file is part of the Voreen software package. Voreen is free   *
 * software: you can redistribute it and/or modify it under the terms *
 * of the GNU General Public License version 2 as published by the    *
 * Free Software Foundation.                                          *
 *                                                                    *
 * Voreen 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 General Public License for more details.                       *
 *                                                                    *
 * You should have received a copy of the GNU General Public License  *
 * in the file "LICENSE.txt" along with this program.                 *
 * If not, see <http://www.gnu.org/licenses/>.                        *
 *                                                                    *
 * The authors reserve all rights not expressly granted herein. For   *
 * non-commercial academic use see the license exception specified in *
 * the file "LICENSE-academic.txt". To get information about          *
 * commercial licensing please contact the authors.                   *
 *                                                                    *
 **********************************************************************/

#ifndef VRN_LABELINGMATH_H
#define VRN_LABELINGMATH_H

#include <cmath>
#include <vector>
#include "tgt/math.h"
#include "tgt/vector.h"
#include "tgt/matrix.h"
#include "tgt/tgt_gl.h"
#include "tgt/math.h"

namespace labeling {

struct Polynomial {
    int degree;
    float* coeff;
};

//----------------------------------------------------------------------------

class Curve3D {
public:

    Curve3D();

    virtual ~Curve3D() {}

    bool setCtrlPoints(std::vector<tgt::vec3> &ctrlPoints, float curveLength=0.f);

    std::vector<tgt::vec3> getCtrlPoints(){
        return ctrlPoints_;
    }

    virtual tgt::vec3 getCurvePoint(float t)=0;

    virtual tgt::vec3 getTangent(float t)=0;

    virtual float getTangentMagnitude(float t)=0;

    virtual float getSegmentLength(float t1, float t2)=0;

    virtual tgt::vec3 getNextPoint(float &curParam, float offset)=0;

    virtual void shift(tgt::vec3 shiftVector)=0;

protected:

    virtual bool calcFunction(float curveLength=0)=0;

    std::vector<tgt::vec3> ctrlPoints_;

    float paramScale_, paramShift_;

};

//----------------------------------------------------------------------------

class Curve2D {
public:

    Curve2D();

    virtual ~Curve2D() {}

    bool setCtrlPoints(std::vector<tgt::vec2> &ctrlPoints, float curveLength=0.f);

    std::vector<tgt::vec2> getCtrlPoints(){
        return ctrlPoints_;
    }

    virtual tgt::vec2 getCurvePoint(float t)=0;

    virtual tgt::vec2 getTangent(float t)=0;

    virtual float getTangentMagnitude(float t)=0;

    virtual float getSegmentLength(float t1, float t2)=0;

    virtual tgt::vec2 getNextPoint(float &curParam, float offset)=0;

    virtual void shift(tgt::vec2 shiftVector)=0;

protected:

    virtual bool calcFunction(float curveLength=0)=0;

    std::vector<tgt::vec2> ctrlPoints_;

    float paramScale_, paramShift_;

};

//----------------------------------------------------------------------------

class Curve3DPolynomial : public Curve3D {
public:

    Curve3DPolynomial(int degree);

    virtual ~Curve3DPolynomial() {}

    tgt::vec3 getCurvePoint(float t);
    tgt::vec3 getTangent(float t);
    float getTangentMagnitude(float t);
    float getSegmentLength(float t1, float t2);
    tgt::vec3 getNextPoint(float &curParam, float offset);

    void shift(tgt::vec3 shiftVector);

    float* getCoefficientsX(){
        return xfunc_.coeff;
    };

    float* getCoefficientsY(){
        return yfunc_.coeff;
    };

    float* getCoefficientsZ(){
        return zfunc_.coeff;
    };

protected:

    bool calcFunction(float curveLength=0);

    int degree_;
    int numCoeff_;
    Polynomial xfunc_;
    Polynomial yfunc_;
    Polynomial zfunc_;

};

//----------------------------------------------------------------------------

class Curve2DPolynomial : public Curve2D {
public:

    Curve2DPolynomial(int degree);

    virtual ~Curve2DPolynomial() {}

    tgt::vec2 getCurvePoint(float t);
    tgt::vec2 getTangent(float t);
    float getTangentMagnitude(float t);
    float getSegmentLength(float t1, float t2);
    tgt::vec2 getNextPoint(float &curParam, float offset);

    void shift(tgt::vec2 shiftVector);

    float* getCoefficientsX(){
        return xfunc_.coeff;
    };

    float* getCoefficientsY(){
        return yfunc_.coeff;
    };

private:

    bool calcFunction(float curveLength=0);

    int degree_;
    int numCoeff_;
    Polynomial xfunc_;
    Polynomial yfunc_;

};

//----------------------------------------------------------------------------

class BezierPatch {
public:

    BezierPatch(bool useDisplayList=true);

    ~BezierPatch();

    void setCtrlPoints(tgt::vec3* ctrlPoints, int degreeS, int degreeT);

    int getDegreeS();

    int getDegreeT();

    tgt::vec3* getCtrlPoints(int &degreeS, int &degreeT);

    tgt::vec3 getPoint(float s, float t);

    tgt::vec3 getTangentS(float s, float t);

    tgt::vec3 getTangentT(float s, float t);

    tgt::vec3 getNormal(float s, float t);

    void render(int s_steps = 10, int t_steps = 10,
        bool genTexCoords=false, GLuint texUnit=0);

private:
    int degreeS_;
    int degreeT_;
    tgt::vec3* ctrlPoints_;

    GLuint displayList_;
    bool useDisplayList_;
};


//----------------------------------------------------------------------------

template<class T>
class Bitmap {
public:

    Bitmap() {
        data_ = NULL;
        width_ = 0;
        height_ = 0;
        channels_ = 1;
    };

    Bitmap(int width, int height, int channels = 1) {
        data_ = new T[width*height*channels];
        width_ = width;
        height_ = height;
        channels_ = channels;
    };

    Bitmap(T* data, int width, int height, int channels = 1) {
        data_ = data;
        width_ = width;
        height_ = height;
        channels_ = channels;
    };

    ~Bitmap(){
        delete[] data_;
        data_ = 0;
    }

    void setData(T* data, int width, int height, int channels = 1){
        if(data_) {
            delete[] data_;
            data_ = 0;
        }
        data_ = data;
        width_ = width;
        height_ = height;
        channels_ = channels;
    }

    T* getData(){
        return data_;
    }

    inline void setElem(int x, int y, T elem, int channel=0){
        setElem((width_*y + x)*channels_ + channel, elem);
    }

    inline void setElem(int index, T elem){
        data_[index] = elem;
    }

    inline T getElem(int x, int y, int channel=0){
        return getElem((width_*y + x)*channels_ + channel);
    }

    inline T getElem(int index){
        return data_[index];
    }

    inline tgt::Vector2<T> getPixel2Ch(int x, int y){
        return tgt::Vector2<T>(data_[(width_*y + x)*channels_],
            data_[(width_*y + x)*channels_ + 1] );
    }

    inline tgt::Vector3<T> getPixel3Ch(int x, int y){
        x = tgt::clamp(x, 0, width_-1);
        y = tgt::clamp(y, 0, height_-1);
        return tgt::Vector3<T>(data_[(width_*y + x)*channels_],
            data_[(width_*y + x)*channels_ + 1],
            data_[(width_*y + x)*channels_ + 2]  );
    }

    inline tgt::Vector4<T> getPixel4Ch(int x, int y){
        return tgt::Vector4<T>(data_[(width_*y + x)*channels_],
            data_[(width_*y + x)*channels_ + 1],
            data_[(width_*y + x)*channels_ + 2],
            data_[(width_*y + x)*channels_ + 3] );
    }

    void mergeBitmap(const Bitmap<T> &src, int x_offset=0, int y_offset=0){
       for (int x=0; x<src.width_; x++){
            for (int y=0; y<src.height_; y++){
                int xdst = x+x_offset;
                int ydst = y+y_offset;
                for (int ch=0; ch<channels_; ch++){
                    setElem(xdst, ydst,
                        src.data_[(src.width_*y + x)*src.channels_ + ch], ch);
                }
            }
       }
    }

    void blendMax(const Bitmap<T> &src, int x_offset=0, int y_offset=0){
        for (int x=0; x<src.width_; x++){
            for (int y=0; y<src.height_; y++){
                int xdst = x+x_offset;
                int ydst = y+y_offset;
                if (getElem(xdst, ydst, channels_-1) <
                    src.data_[(src.width_*y+x)*src.channels_+(src.channels_-1)] ){
                        for (int ch=0; ch<channels_; ch++){
                            setElem(xdst, ydst,
                                src.data_[(src.width_*y + x)*src.channels_ + ch],
                                ch);
                        }
                }
            }
        }
    }

    void blend(const Bitmap<T> &src, int x_offset=0, int y_offset=0){
        for (int x=0; x<src.width_; x++){
            for (int y=0; y<src.height_; y++){
                int xdst = x+x_offset;
                int ydst = y+y_offset;
                T srcAlpha = src.data_[(src.width_*y+x)*src.channels_+(src.channels_-1)];
                T dstAlpha = (1-srcAlpha)*getElem(xdst, ydst, 3);
                for (int ch=0; ch<channels_; ch++){
                    T elem = getElem(xdst, ydst, ch)*dstAlpha +
                        src.data_[(src.width_*y + x)*src.channels_ + ch]*srcAlpha;
                    setElem(xdst, ydst, elem, ch);
                }
                setElem(xdst, ydst, srcAlpha + (1-srcAlpha)*dstAlpha, channels_-1);
            }
        }
    }

    void freeData(){
        delete[] data_;
        data_ = 0;
    }

    inline int getWidth(){
        return width_;
    }
    inline int getHeight(){
        return height_;
    }

    void setDim(int width, int height, int channels=1){
        delete[] data_;
        data_ = new T[width*height*channels];
        width_ = width;
        height_ = height;
        channels_ = channels;
    }

protected:
    T* data_;
    int width_;
    int height_;
    int channels_;
};

//----------------------------------------------------------------------------

class FirstHitBitmap : public Bitmap<float> {

public:

    tgt::vec3 getPixel3Ch(int x, int y){
        return Bitmap<float>::getPixel3Ch(x, y)*2.f*volumeSize_ - volumeSize_;
    }

    tgt::vec3 calcNormal(int x, int y){
        tgt::vec3 xtangent = getPixel3Ch(x+1,y) - getPixel3Ch(x-1,y);
        tgt::vec3 ytangent = getPixel3Ch(x,y+1) - getPixel3Ch(x,y-1);
        return tgt::normalize( tgt::cross(xtangent, ytangent) );
    }

    tgt::vec3 projectToViewport(tgt::vec3 point, bool round=true){
        tgt::vec4 p4D = transformationMatrix_*tgt::vec4(point, 1.f);
        p4D /= p4D.w; // perspective correction
        tgt::vec3 result;
        if (round)
            result = tgt::vec3( tgt::round(p4D.x), tgt::round(p4D.y) , p4D.z);
        else
            result = tgt::vec3( p4D.x, p4D.y, p4D.z );

        return result;
    }

    tgt::vec3 inverseProject(tgt::vec3 point){
        tgt::vec4 p4D = transformationMatrixInverse_*tgt::vec4(point, 1.f);
        p4D /= p4D.w; // perspective correction
        tgt::vec3 result = tgt::vec3(p4D.x, p4D.y, p4D.z);
        return result;
    }

    void setVolumeSize(tgt::vec3 volumeSize){
        volumeSize_ = volumeSize;
    }

    void calcTransformationMatrix(tgt::mat4 viewMatrix,
            tgt::mat4 projectionMatrix,
            tgt::ivec2 viewportSize) {
        tgt::mat4 scalemat = tgt::mat4::createScale(
                tgt::vec3(viewportSize.x/2.f, viewportSize.y/2.f, 1.f/2.f) );
        tgt::mat4 transmat = tgt::mat4::createTranslation( tgt::vec3(1.f) );

        transformationMatrix_ = scalemat*transmat*projectionMatrix*viewMatrix;
        transformationMatrix_.invert(transformationMatrixInverse_);
    }

private:

    tgt::vec3 volumeSize_;

    tgt::mat4 transformationMatrix_;
    tgt::mat4 transformationMatrixInverse_;

};

} // namespace labeling

#endif //VRN_LABELINGMATH_H

• Getting Started
• Video Tutorials
• Build Instructions
• Adding a Module
• Programming Tutorials
• API Documentation
• FAQ

edit