cxFiberBundleRep.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 "cxFiberBundleRep.h"
 
#include "boost/bind.hpp"
#include <vtkActor.h>
#include <vtkProperty.h>
#include <vtkPolyDataMapper.h>
#include <vtkPolyDataNormals.h>
#include <vtkMatrix4x4.h>
#include <vtkRenderer.h>
#include <vtkRibbonFilter.h>
 
#include "cxGraphicalPrimitives.h"
#include "cxView.h"
#include "cxTypeConversions.h"
#include "cxMesh.h"
 
namespace cx
{
FiberBundleRep::FiberBundleRep()
        : RepImpl(), mFiberWidth(.5)
{
        mPolyDataMapper = vtkPolyDataMapperPtr::New();
        mProperty = vtkPropertyPtr::New();
        // mProperty->SetInterpolationToFlat();
        // mProperty->SetInterpolationToGouraud();
 
        mActor = vtkActorPtr::New();
 
        mActor->SetMapper(mPolyDataMapper);
        mActor->SetProperty(mProperty);
}
 
FiberBundleRepPtr FiberBundleRep::New(const QString& uid)
{
        return wrap_new(new FiberBundleRep(), uid);
}
 
QString FiberBundleRep::getType() const
{
        return "FiberBundleRep";
}
 
void FiberBundleRep::setBundle(MeshPtr bundle)
{
        // Already has this bundle assigned
        if (hasBundle(bundle)) return;
 
        std::cout << "New fiber bundle assigned" << std::endl;
 
        if (mBundle)
        {
                disconnect(mBundle.get(), SIGNAL(transformChanged()), this, SLOT(bundleTransformChanged()));
                disconnect(mBundle.get(), SIGNAL(meshChanged()), this, SLOT(bundleChanged()));
        }
 
        mBundle = bundle;
 
        if (mBundle)
        {
                connect(mBundle.get(), SIGNAL(transformChanged()), this, SLOT(bundleTransformChanged()));
                connect(mBundle.get(), SIGNAL(meshChanged()), this, SLOT(bundleChanged()));
        }
 
        bundleChanged();
        this->bundleTransformChanged();
}
 
void FiberBundleRep::addRepActorsToViewRenderer(ViewPtr view)
{
        view->getRenderer()->AddActor(mActor);
 
        if (mViewportListener)
                mViewportListener->startListen(view->getRenderer());
}
 
void FiberBundleRep::removeRepActorsFromViewRenderer(ViewPtr view)
{
        view->getRenderer()->RemoveActor(mActor);
 
        if (mViewportListener)
                mViewportListener->stopListen();
}
 
void FiberBundleRep::bundleChanged()
{
        vtkPolyDataPtr model = mBundle->getVtkPolyData();
 
        if (model)
        {
                QColor color = mBundle->getColor();
                mActor->GetProperty()->SetColor(color.redF(), color.greenF(), color.blueF());
                mActor->GetProperty()->SetOpacity(color.alphaF());
 
                if (!mBundle->getIsWireframe())
                {
                        vtkSmartPointer<vtkRibbonFilter> ribbonFilter = vtkSmartPointer<vtkRibbonFilter>::New();
                        ribbonFilter->SetInputData(model);
                        ribbonFilter->SetWidth(mFiberWidth);
                        ribbonFilter->SetWidthFactor(3);
 
                        mPolyDataMapper->SetInputConnection(ribbonFilter->GetOutputPort());
                }
                else
                {
                        {
                                vtkPolyDataNormalsPtr normals = vtkPolyDataNormalsPtr::New();
                                normals->SetInputData(model);
                                normals->Update();
                                model = normals->GetOutput();
                        }
                        mPolyDataMapper->SetInputData(model);
                        mActor->SetMapper(mPolyDataMapper);
                }
 
                mPolyDataMapper->ScalarVisibilityOn();
                mPolyDataMapper->SetScalarModeToUsePointFieldData();
        }
 
}
 
void FiberBundleRep::bundleTransformChanged()
{
        if (!mBundle) return;
 
        mActor->SetUserMatrix(mBundle->get_rMd().getVtkMatrix());
}
 
} // end namespace