cxGraphicalPrimitives.cpp

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
                 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
                 
CustusX is released under a BSD 3-Clause license.
                 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/
 
#include "cxGraphicalPrimitives.h"
 
#include "boost/bind.hpp"
#include <vtkSphereSource.h>
#include <vtkLineSource.h>
#include <vtkArcSource.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkCellArray.h>
#include <vtkProperty.h>
#include <vtkRenderer.h>
#include <vtkCommand.h>
#include <vtkFollower.h>
#include <vtkVectorText.h>
#include <vtkCamera.h>
#include "cxTypeConversions.h"
#include "cxBoundingBox3D.h"
#include "vtkArrowSource.h"
#include "vtkMatrix4x4.h"
#include "vtkCaptionActor2D.h"
#include "vtkTextProperty.h"
#include "cxVtkHelperClasses.h"
#include "vtkPolyDataNormals.h"
 
namespace cx
{
 
 
GraphicalGeometricBase::GraphicalGeometricBase(vtkPolyDataAlgorithmPtr source, vtkRendererPtr renderer)
{
        mProperty = vtkPropertyPtr::New();
        mActor = vtkActorPtr::New();
        mActor->SetProperty(mProperty);
}
 
GraphicalGeometricBase::~GraphicalGeometricBase()
{
        this->setRenderer(NULL);
}
 
void GraphicalGeometricBase::setSource(vtkPolyDataAlgorithmPtr source)
{
        mData = vtkPolyDataPtr();
        mSource = source;
 
        if (mSource)
                getMapper()->SetInputConnection(mSource->GetOutputPort());
        else
                getMapper()->SetInputConnection(NULL);
}
 
void GraphicalGeometricBase::setRenderer(vtkRendererPtr renderer)
{
        if (mRenderer)
                mRenderer->RemoveActor(mActor);
 
        mRenderer = renderer;
 
        if (mRenderer)
                mRenderer->AddActor(mActor);
}
 
void GraphicalGeometricBase::setVisibility(bool visible)
{
        mActor->SetVisibility(visible);
}
 
 
void GraphicalGeometricBase::setBackfaceCulling(bool val)
{
        mActor->GetProperty()->SetBackfaceCulling(val);
}
 
void GraphicalGeometricBase::setFrontfaceCulling(bool val)
{
        mActor->GetProperty()->SetFrontfaceCulling(val);
}
 
void GraphicalGeometricBase::setColor(double red, double green, double blue)
{
        mActor->GetProperty()->SetColor(red, green, blue);
}
 
void GraphicalGeometricBase::setColor(Vector3D color)
{
        mActor->GetProperty()->SetColor(color.begin());
}
 
void GraphicalGeometricBase::setPosition(Vector3D point)
{
        mActor->SetPosition(point.begin());
}
 
void GraphicalGeometricBase::setOpacity(double val)
{
        mActor->GetProperty()->SetOpacity(val);
}
 
void GraphicalGeometricBase::setUserMatrix(vtkMatrix4x4 *matrix)
{
        mActor->SetUserMatrix(matrix);
}
 
void GraphicalGeometricBase::setPointSize(int pointSize)
{
        if(pointSize<=0)
                return;
        mProperty->SetPointSize(pointSize);
}
 
void GraphicalGeometricBase::setScalarVisibility(bool show)
{
        getMapper()->SetScalarVisibility(show);
}
 
void GraphicalGeometricBase::setScalarModeToUseCellData()
{
        getMapper()->SetScalarModeToUseCellData();
}
 
Vector3D GraphicalGeometricBase::getPosition() const
{
        return Vector3D(mActor->GetPosition());
}
 
vtkActorPtr GraphicalGeometricBase::getActor()
{
        return mActor;
}
 
vtkPropertyPtr GraphicalGeometricBase::getProperty()
{
        return mProperty;
}
 
vtkPolyDataPtr GraphicalGeometricBase::getPolyData()
{
        if (mSource)
                return mSource->GetOutput();
        else
                return mData;
}
 
vtkPolyDataAlgorithmPtr GraphicalGeometricBase::getSource()
{
        return mSource;
}
 
//--------------------------------------------------------
//--------------------------------------------------------
//-------------------------------------------------------
 
GraphicalPolyData3D::GraphicalPolyData3D(vtkPolyDataAlgorithmPtr source, vtkRendererPtr renderer) :
        GraphicalGeometricBase(source,renderer)
{
        mMapper =  vtkPolyDataMapperPtr::New();
 
        mActor->SetMapper(mMapper);
        setSource(source);
        setRenderer(renderer);
}
 
void GraphicalPolyData3D::setIsWireFrame(bool val)
{
        mActor->GetProperty()->SetRepresentationToWireframe();
}
 
void GraphicalPolyData3D::setData(vtkPolyDataPtr data)
{
        mSource = vtkPolyDataAlgorithmPtr();
        mData = data;
 
        mMapper->SetInputData(mData);
}
 
void GraphicalPolyData3D::setTexture(vtkTexturePtr texture)
{
        mActor->SetTexture(texture);
}
 
 
vtkMapperPtr GraphicalPolyData3D::getMapper()
{
        return mMapper;
}
 
//--------------------------------------------------------
//--------------------------------------------------------
//-------------------------------------------------------
 
GraphicalGlyph3DData::GraphicalGlyph3DData(vtkPolyDataAlgorithmPtr source, vtkRendererPtr renderer) :
        GraphicalGeometricBase(source,renderer)
{
        mMapper = vtkSmartPointer<vtkGlyph3DMapper>::New();
        vtkSmartPointer<vtkArrowSource> arrowSource = vtkSmartPointer<vtkArrowSource>::New();
        mMapper->SetSourceConnection(arrowSource->GetOutputPort());
        mMapper->ScalarVisibilityOn();
        mMapper->SetUseLookupTableScalarRange(1);
        mMapper->SetScalarMode(VTK_SCALAR_MODE_USE_POINT_FIELD_DATA);
        mActor->SetMapper(mMapper);
        setSource(source);
        setRenderer(renderer);
}
 
 
void GraphicalGlyph3DData::setData(vtkPolyDataPtr data)
{
        mData = data;
        if (data)
                mMapper->SetInputData(mData);
}
 
void GraphicalGlyph3DData::setOrientationArray(const char* orientationArray)
{
        mMapper->SetOrientationArray(orientationArray);
}
 
void GraphicalGlyph3DData::setColorArray(const char* colorArray)
{
        if(strlen(colorArray)>0)
        {
                setScalarVisibility(true);
        }else
        {
                setScalarVisibility(false);
        }
        mMapper->SelectColorArray(colorArray);
}
 
 
void GraphicalGlyph3DData::setLUT(const char* lut)
{
        vtkSmartPointer<vtkColorSeries> colorSeries = vtkSmartPointer<vtkColorSeries>::New();
        vtkSmartPointer<vtkLookupTable> table = vtkLookupTable::New();
        colorSeries->SetColorSchemeByName(lut);
        colorSeries->BuildLookupTable(table , vtkColorSeries::ORDINAL);
        mMapper->SetLookupTable(table);
}
 
 
void GraphicalGlyph3DData::setScaleFactor(double scaleFactor)
{
        if(scaleFactor<=0) return;
        mMapper->SetScaleFactor(scaleFactor);
}
 
vtkMapperPtr GraphicalGlyph3DData::getMapper()
{
        return mMapper;
}
 
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
 
GraphicalPoint3D::GraphicalPoint3D(vtkRendererPtr renderer)
{
        //      mRenderer = renderer;
        source = vtkSphereSourcePtr::New();
        source->SetRadius(4);
        //  default:
        //  source->SetThetaResolution(8);
        //  source->SetPhiResolution(8);
        // 24*16 = 384, 8*8=64, 16*12=192
        source->SetThetaResolution(16);
        source->SetPhiResolution(12);
        source->LatLongTessellationOn();
 
        vtkPolyDataNormalsPtr normals = vtkPolyDataNormalsPtr::New();
        normals->SetInputConnection(source->GetOutputPort());
        normals->Update();
 
        mapper = vtkPolyDataMapperPtr::New();
        mapper->SetInputConnection(normals->GetOutputPort());
 
        actor = vtkActorPtr::New();
        actor->SetMapper(mapper);
 
        this->setRenderer(renderer);
}
 
GraphicalPoint3D::~GraphicalPoint3D()
{
        this->setRenderer(NULL);
}
 
void GraphicalPoint3D::setRenderer(vtkRendererPtr renderer)
{
        if (mRenderer)
        {
                mRenderer->RemoveActor(actor);
        }
 
        mRenderer = renderer;
 
        if (mRenderer)
        {
                mRenderer->AddActor(actor);
        }
}
 
void GraphicalPoint3D::setRadius(double radius)
{
        source->SetRadius(radius);
}
 
void GraphicalPoint3D::setColor(QColor color)
{
        setColorAndOpacity(actor->GetProperty(), color);
}
 
void GraphicalPoint3D::setValue(Vector3D point)
{
        actor->SetPosition(point.begin());
}
 
Vector3D GraphicalPoint3D::getValue() const
{
        return Vector3D(actor->GetPosition());
}
 
vtkActorPtr GraphicalPoint3D::getActor()
{
        return actor;
}
 
vtkPolyDataPtr GraphicalPoint3D::getPolyData()
{
        return source->GetOutput();
}
 
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
 
GraphicalLine3D::GraphicalLine3D( vtkRendererPtr renderer)
{
        mRenderer = renderer;
        source = vtkLineSourcePtr::New();
        mapper = vtkPolyDataMapperPtr::New() ;
        actor = vtkActorPtr::New() ;
 
        mapper->SetInputConnection( source->GetOutputPort() );
        actor->SetMapper (mapper );
        this->setRenderer(renderer);
}
 
GraphicalLine3D::~GraphicalLine3D()
{
        this->setRenderer(NULL);
}
 
void GraphicalLine3D::setRenderer(vtkRendererPtr renderer)
{
        if (mRenderer)
        {
                mRenderer->RemoveActor(actor);
        }
 
        mRenderer = renderer;
 
        if (mRenderer)
        {
                mRenderer->AddActor(actor);
        }
}
 
void GraphicalLine3D::setColor(QColor color)
{
        setColorAndOpacity(actor->GetProperty(), color);
}
 
void GraphicalLine3D::setValue(Vector3D point1, Vector3D point2)
{
        source->SetPoint1(point1.begin());
        source->SetPoint2(point2.begin());
}
 
void GraphicalLine3D::setStipple(int stipple)
{
        actor->GetProperty()->SetLineStipplePattern(stipple);
}
 
vtkActorPtr GraphicalLine3D::getActor()
{
        return actor;
}
 
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
 
GraphicalArc3D::GraphicalArc3D( vtkRendererPtr renderer)
{
        mRenderer = renderer;
        source = vtkArcSourcePtr::New();
        source->SetResolution(20);
        mapper = vtkPolyDataMapperPtr::New() ;
        actor = vtkActorPtr::New() ;
 
        mapper->SetInputConnection( source->GetOutputPort() );
        actor->SetMapper (mapper );
        if (mRenderer)
                mRenderer->AddActor(actor);
}
 
GraphicalArc3D::~GraphicalArc3D()
{
        if (mRenderer)
                mRenderer->RemoveActor(actor);
}
 
void GraphicalArc3D::setColor(QColor color)
{
        setColorAndOpacity(actor->GetProperty(), color);
}
 
void GraphicalArc3D::setValue(Vector3D point1, Vector3D point2, Vector3D center)
{
        source->SetPoint1(point1.begin());
        source->SetPoint2(point2.begin());
        source->SetCenter(center.begin());
}
 
void GraphicalArc3D::setStipple(int stipple)
{
        actor->GetProperty()->SetLineStipplePattern(stipple);
}
 
vtkActorPtr GraphicalArc3D::getActor()
{
        return actor;
}
 
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
 
GraphicalArrow3D::GraphicalArrow3D( vtkRendererPtr renderer)
{
        mRenderer = renderer;
        source = vtkArrowSourcePtr::New();
        source->SetTipResolution(24);
        source->SetShaftResolution(24);
        mapper = vtkPolyDataMapperPtr::New() ;
        actor = vtkActorPtr::New() ;
 
        mapper->SetInputConnection( source->GetOutputPort() );
        actor->SetMapper (mapper );
        if (mRenderer)
                mRenderer->AddActor(actor);
}
 
GraphicalArrow3D::~GraphicalArrow3D()
{
        if (mRenderer)
                mRenderer->RemoveActor(actor);
}
 
void GraphicalArrow3D::setColor(QColor color)
{
        setColorAndOpacity(actor->GetProperty(), color);
}
 
void GraphicalArrow3D::setValue(Vector3D base, Vector3D normal, double length)
{
        // find an arbitrary vector k perpendicular to normal:
        Vector3D k = cross(Vector3D(1,0,0), normal);
        if (similar(k, Vector3D(0,0,0)))
                k = cross(Vector3D(0,1,0), normal);
        k = k.normalized();
        Transform3D M = createTransformIJC(normal, k, base);
 
        //      std::cout << "GraphicalArrow3D::setValue  " << base << " - " << normal << std::endl;
        Transform3D S = createTransformScale(Vector3D(length,1,1));
        M = M * S;
        // let arrow shape increase slowly with length:
        //      source->SetTipLength(0.35/sqrt(length));
        //      source->SetTipRadius(0.1*sqrt(length));
        //      source->SetShaftRadius(0.03*sqrt(length));
        source->SetTipLength(0.35);
        source->SetTipRadius(0.1*(length));
        source->SetShaftRadius(0.03*(length));
        actor->SetUserMatrix(M.getVtkMatrix());
}
 
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
 
Rect3D::Rect3D(vtkRendererPtr renderer, QColor color)
{
        mRenderer = renderer;
        mapper = vtkPolyDataMapperPtr::New();
        actor = vtkActorPtr::New();
        setColorAndOpacity(actor->GetProperty(), color);
        actor->SetMapper(mapper);
        if (mRenderer)
                mRenderer->AddActor(actor);
 
        mPolyData = vtkPolyDataPtr::New();
        mPoints = vtkPointsPtr::New();
        mSide = vtkCellArrayPtr::New();
 
        vtkIdType cells[5] = { 0,1,2,3,0 };
        mSide->InsertNextCell(5, cells);
 
        mPolyData->SetPoints(mPoints);
        mapper->SetInputData(mPolyData);
}
 
void Rect3D::setLine(bool on, int width)
{
        if (on)
        {
                mPolyData->SetLines(mSide);
                actor->GetProperty()->SetLineWidth(width);
        }
        else
        {
                mPolyData->SetLines(NULL);
        }
}
 
void Rect3D::setSurface(bool on)
{
        if (on)
        {
                mPolyData->SetPolys(mSide);
                actor->GetProperty()->SetOpacity(1.0); // transparent planes dont work well together with texture volume. Use 1.0
        }
        else
        {
                mPolyData->SetPolys(NULL);
        }
}
 
Rect3D::~Rect3D()
{
        if (mRenderer)
                mRenderer->RemoveActor(actor);
}
 
void Rect3D::setColor(QColor color)
{
        setColorAndOpacity(actor->GetProperty(), color);
}
 
void Rect3D::updatePosition(const DoubleBoundingBox3D bb, const Transform3D& M)
{
        mPoints = vtkPointsPtr::New();
        mPoints->InsertPoint(0, M.coord(bb.corner(0,0,0)).begin());
        mPoints->InsertPoint(1, M.coord(bb.corner(0,1,0)).begin());
        mPoints->InsertPoint(2, M.coord(bb.corner(1,1,0)).begin());
        mPoints->InsertPoint(3, M.coord(bb.corner(1,0,0)).begin());
        mPolyData->SetPoints(mPoints);
}
 
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
 
FollowerText3D::FollowerText3D( vtkRendererPtr renderer)
{
        mText = vtkVectorTextPtr::New();
        vtkPolyDataMapperPtr mapper = vtkPolyDataMapperPtr::New();
        mapper->SetInputConnection(mText->GetOutputPort());
        mFollower = vtkFollowerPtr::New();
        mFollower->SetMapper(mapper);
        Vector3D mTextScale(2,2,2);
        mFollower->SetScale(mTextScale.begin());
 
        this->setSizeInNormalizedViewport(true, 0.025);
        this->setRenderer(renderer);
}
 
void FollowerText3D::setRenderer(vtkRendererPtr renderer)
{
        if (mRenderer)
        {
                mRenderer->RemoveActor(mFollower);
                mViewportListener->stopListen();
        }
 
        mRenderer = renderer;
 
        if (mRenderer)
        {
                mRenderer->AddActor(mFollower);
                mFollower->SetCamera(mRenderer->GetActiveCamera());
                if (mViewportListener)
                        mViewportListener->startListen(mRenderer);
        }
}
 
FollowerText3D::~FollowerText3D()
{
        if (mRenderer)
                mRenderer->RemoveActor(mFollower);
}
 
void FollowerText3D::setSize(double val)
{
        mSize = val;
        this->scaleText();
}
 
void FollowerText3D::setSizeInNormalizedViewport(bool on, double size)
{
        if (on)
        {
                if (!mViewportListener)
                {
                        mViewportListener.reset(new ViewportListener);
                        mViewportListener->setCallback(boost::bind(&FollowerText3D::scaleText, this));
                }
        }
        else
        {
                mViewportListener.reset();
        }
 
        this->setSize(size);
}
 
void FollowerText3D::setColor(QColor color)
{
        setColorAndOpacity(mFollower->GetProperty(), color);
}
 
void FollowerText3D::setText(QString text)
{
        mText->SetText(cstring_cast(text));
}
 
void FollowerText3D::setPosition(Vector3D pos)
{
        mFollower->SetPosition(pos.begin());
}
 
vtkFollowerPtr FollowerText3D::getActor()
{
        return mFollower;
}
 
void FollowerText3D::scaleText()
{
        if (!mViewportListener || !mViewportListener->isListening())
        {
                mFollower->SetScale(Vector3D(mSize,mSize,mSize).begin());
                return;
        }
 
        double size = mViewportListener->getVpnZoom(Vector3D(mFollower->GetPosition()));
 
        double scale = mSize/size;
        //  std::cout << "s= " << size << "  ,scale= " << scale << std::endl;
        Vector3D mTextScale(scale,scale,scale);
        if (mFollower)
                mFollower->SetScale(mTextScale.begin());
}
 
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
 
CaptionText3D::CaptionText3D( vtkRendererPtr renderer)
{
        mText = vtkCaptionActor2DPtr::New();
        mText->BorderOff();
        mText->LeaderOff();
 
        mText->GetCaptionTextProperty()->BoldOff();
        mText->GetCaptionTextProperty()->ItalicOff();
        mText->GetCaptionTextProperty()->ShadowOff();
        mText->SetWidth(10);
        mText->SetHeight(0.03);
 
        this->setRenderer(renderer);
}
 
void CaptionText3D::placeBelowCenter()
{
        mText->SetPosition(-15, -30);
        mText->SetPosition2(15, -10);
}
 
void CaptionText3D::placeAboveCenter()
{
        mText->SetPosition(-15, 2);
}
 
void CaptionText3D::setVisibility(bool visible)
{
        mText->SetVisibility(visible);
}
 
void CaptionText3D::setRenderer(vtkRendererPtr renderer)
{
        if (mRenderer)
        {
                mRenderer->RemoveActor(mText);
        }
 
        mRenderer = renderer;
 
        if (mRenderer)
        {
                mRenderer->AddActor(mText);
        }
}
 
CaptionText3D::~CaptionText3D()
{
        if (mRenderer)
                mRenderer->RemoveActor(mText);
}
 
void CaptionText3D::setSize(double val)
{
        mText->SetHeight(val);
}
 
void CaptionText3D::setColor(QColor color)
{
        mText->GetCaptionTextProperty()->SetColor(getColorAsVector3D(color).begin());
}
 
void CaptionText3D::setText(QString text)
{
        mText->SetCaption(cstring_cast(text));
}
 
void CaptionText3D::setPosition(Vector3D pos)
{
        mPos = pos;
        mText->SetAttachmentPoint(pos.begin());
}
 
Vector3D CaptionText3D::getPosition() const
{
        return mPos;
}
 
vtkCaptionActor2DPtr CaptionText3D::getActor()
{
        return mText;
}
 
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
 
}