cxCustomMetricRep.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 "cxCustomMetricRep.h"
 
#include <boost/shared_ptr.hpp>
#include <vtkRenderer.h>
#include <vtkCamera.h>
#include <vtkImageActor.h>
#include <vtkSelectVisiblePoints.h>
#include "cxTypeConversions.h"
#include "cxCustomMetric.h"
#include "cxLogger.h"
#include "cxBoundingBox3D.h"
#include "cxGeometricRep.h"
#include "cxMesh.h"
#include "cxImage.h"
#include "cxImage2DRep3D.h"
#include "cxGraphicalPrimitives.h"
 
 
namespace cx
{
 
CustomMetricRepPtr CustomMetricRep::New(const QString& uid)
{
    return wrap_new(new CustomMetricRep(), uid);
}
 
CustomMetricRep::CustomMetricRep()
{
}
 
void CustomMetricRep::clear()
{
        DataMetricRep::clear();
        mMeshGeometry.clear();
        for(int i = 0; i < mImageGeometryProxy.size(); ++i)
        {
                this->getRenderer()->RemoveActor(mImageGeometryProxy[i]->getActor());
        }
        mImageGeometryProxy.clear();
}
 
CustomMetricPtr CustomMetricRep::getCustomMetric()
{
    return boost::dynamic_pointer_cast<CustomMetric>(mMetric);
}
 
void CustomMetricRep::onModifiedStartRender()
{
        if (!mMetric)
                return;
 
        this->updateModel();
        this->drawText();
}
 
void CustomMetricRep::onEveryRender()
{
        this->hideDistanceMetrics();
}
 
void CustomMetricRep::updateModel()
{
        this->clear();
        CustomMetricPtr custom = this->getCustomMetric();
 
        if (!this->getView() || !custom)
           return;
 
        DataPtr model = custom->getModel();
 
        if(custom->modelIsImage())
                this->updateImageModel(model);
        else
                this->updateMeshModel(model);
        this->createDistanceMarkers();
}
 
void CustomMetricRep::updateImageModel(DataPtr model)
{
        ImagePtr imageModel = boost::dynamic_pointer_cast<Image>(model);
 
        if(!imageModel && !imageModel->is2D())
                return;
 
        CustomMetricPtr custom = this->getCustomMetric();
        std::vector<Transform3D> pos = custom->calculateOrientations();
 
        mImageGeometryProxy.resize(pos.size());
 
        for(unsigned i = 0; i < mImageGeometryProxy.size(); ++i)
        {
                if(!mImageGeometryProxy[i])
                        mImageGeometryProxy[i] = cx::Image2DProxy::New();
 
                mImageGeometryProxy[i]->setImage(imageModel);
                this->getRenderer()->AddActor(mImageGeometryProxy[i]->getActor());
 
                mImageGeometryProxy[i]->setTransformOffset(pos[i]);
        }
}
 
void CustomMetricRep::updateMeshModel(DataPtr model)
{
        MeshPtr meshModel = boost::dynamic_pointer_cast<Mesh>(model);
 
        CustomMetricPtr custom = this->getCustomMetric();
        std::vector<Transform3D> pos = custom->calculateOrientations();
 
        mMeshGeometry.resize(pos.size());
 
        for (unsigned i=0; i<mMeshGeometry.size(); ++i)
        {
                if (!mMeshGeometry[i])
                {
                        mMeshGeometry[i].reset(new GraphicalGeometric);
                        mMeshGeometry[i]->setRenderer(this->getRenderer());
                }
 
                mMeshGeometry[i]->setMesh(meshModel);
 
                mMeshGeometry[i]->setTransformOffset(pos[i]);
 
                custom->updateTexture(meshModel, pos[i]);
        }
 
}
 
void CustomMetricRep::createDistanceMarkers()
{
        mDistanceText.clear();
        CustomMetricPtr custom = this->getCustomMetric();
        if(!custom->getModel() || !custom->getShowDistanceMarkers())
                return;
        std::vector<Transform3D> pos = custom->calculateOrientations();
 
        if(pos.size() < 2)
                return;
 
        DoubleBoundingBox3D bounds = custom->getModel()->boundingBox();
 
 
        vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
        points->SetNumberOfPoints(pos.size());
 
        mDistanceText.resize(pos.size());
        Vector3D pos_0 = custom->getZeroPosition();
        for(unsigned i = 0; i < mDistanceText.size(); ++i)
        {
                Vector3D pos_i = pos[i].coord(Vector3D(0,0,0));
                double distance = (pos_i - pos_0).length();
                Vector3D textpos = bounds.center();
                textpos[2] = bounds.bottomLeft()[2];
                mDistanceText[i] = this->createDistanceText(pos[i].coord(textpos), distance);
 
                Vector3D point = pos[i].coord(textpos);
                vtkIdType pointId = i;
                points->SetPoint(pointId, point.data());
        }
}
 
CaptionText3DPtr CustomMetricRep::createDistanceText(Vector3D pos, double distance)
{
        CaptionText3DPtr text = CaptionText3DPtr(new CaptionText3D(this->getRenderer()));
        text->setColor(mMetric->getColor());
        text->setText(QString("%1").arg(distance));
 
        text->setPosition(pos);
        text->placeAboveCenter();
        text->setSize(mLabelSize / 100);
 
        return text;
}
 
//Hide the distance metrics if outside the view port, obscured by other structures, or of too far from the camera
void CustomMetricRep::hideDistanceMetrics()
{
        if(mDistanceText.empty())
                return;
        static vtkSmartPointer<vtkSelectVisiblePoints> visPts = vtkSmartPointer<vtkSelectVisiblePoints>::New();
        visPts->SetRenderer(this->getRenderer());
        float * zbuffer = visPts->Initialize(true);
 
        for(unsigned i = 0; i < mDistanceText.size(); ++i)
        {
                Vector3D pos = mDistanceText[i]->getPosition();
                bool visible = visPts->IsPointOccluded(pos.data(), zbuffer);
                bool closeToCamera = this->isCloseToCamera(pos);
                mDistanceText[i]->setVisibility(visible && closeToCamera);
        }
        delete zbuffer;
}
 
bool CustomMetricRep::isCloseToCamera(Vector3D pos)
{
        double distanceThreshold = this->getCustomMetric()->getDistanceMarkerVisibility();
        Vector3D cameraPos(this->getRenderer()->GetActiveCamera()->GetPosition());
        Vector3D diff = cameraPos - pos;
        double distance = diff.norm();
        if(distance < distanceThreshold)
                return true;
        return false;
}
 
}