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