LVRModelBridge.cpp

Go to the documentation of this file.

#include "LVRModelBridge.hpp"

#include "lvr2/geometry/Matrix4.hpp"

#include <vtkTransform.h>
#include <vtkActor.h>
#include <vtkProperty.h>

namespace lvr2
{

class LVRMeshBufferBridge;

LVRModelBridge::LVRModelBridge(ModelPtr model) :
    m_pointBridge(new LVRPointBufferBridge(model->m_pointCloud)),
    m_meshBridge(new LVRMeshBufferBridge(model->m_mesh))
{
    m_pose.p = 0.0;
    m_pose.r = 0.0;
    m_pose.t = 0.0;
    m_pose.x = 0.0;
    m_pose.y = 0.0;
    m_pose.z = 0.0;
    if(validMeshBridge()) {
        if (!m_meshBridge->hasTextures())
        {
            m_meshBridge->getMeshActor()->GetProperty()->BackfaceCullingOff();
        }
        else
        {
            vtkSmartPointer<vtkProperty> prop = vtkProperty::New();
            prop->BackfaceCullingOff();
            m_meshBridge->getTexturedActors()->ApplyProperties(prop);
        }
    }
}

LVRModelBridge::LVRModelBridge(const LVRModelBridge& b)
{
    m_pointBridge = b.m_pointBridge;
    m_meshBridge = b.m_meshBridge;
    m_pose = b.m_pose;
}

bool LVRModelBridge::validPointBridge()
{
    return (m_pointBridge->getNumPoints() > 0) ? true : false;
}

bool LVRModelBridge::validMeshBridge()
{
    return (m_meshBridge->getNumTriangles() > 0) ? true : false;
}

void LVRModelBridge::setPose(const Pose& pose)
{
    m_pose = pose;
    vtkSmartPointer<vtkTransform> transform =  vtkSmartPointer<vtkTransform>::New();
    transform->PostMultiply();
    transform->RotateX(pose.r);
    transform->RotateY(pose.t);
    transform->RotateZ(pose.p);
    transform->Translate(pose.x, pose.y, pose.z);

    doStuff(transform);

}

void LVRModelBridge::setTransform(const Transformd &transform)
{
    vtkSmartPointer<vtkTransform> t = vtkSmartPointer<vtkTransform>::New();
    vtkSmartPointer<vtkMatrix4x4> m = vtkSmartPointer<vtkMatrix4x4>::New();

    // For some reason we have to copy the matrix
    // values manually...
    const double* arr = transform.data();
    int j = 0;
    for(int i = 0; i < 16; i++)
    {
        if((i % 4) == 0)
        {
            j = 0;
        }
        double v = arr[i];
        m->SetElement(i / 4, j, v);
        j++;
    }

    t->PostMultiply();
    t->SetMatrix(m);
    doStuff(t);
}

void LVRModelBridge::doStuff(vtkSmartPointer<vtkTransform> transform)
{
    if(validPointBridge())
    {
        m_pointBridge->getPointCloudActor()->SetUserTransform(transform);
    }

    if(validMeshBridge())
    {
        if (!m_meshBridge->hasTextures())
        {
            m_meshBridge->getMeshActor()->SetUserTransform(transform);
        }
        else
        {
            vtkSmartPointer<vtkActorCollection> col = m_meshBridge->getTexturedActors();
            col->InitTraversal();
            for (int i = 0; i < col->GetNumberOfItems(); i++)
            {
                col->GetNextActor()->SetUserTransform(transform);
            }
        }
    }
}


Pose LVRModelBridge::getPose()
{
    return m_pose;
}

void LVRModelBridge::addActors(vtkSmartPointer<vtkRenderer> renderer)
{
    if(validPointBridge())
    {
        renderer->AddActor(m_pointBridge->getPointCloudActor());
    }

    if(validMeshBridge())
    {
        // For simple meshes we only need to add a sigle actor to
        // render it. For textured meshes we add a actor collection
        // (one actor per texture).
        if(!m_meshBridge->hasTextures())
        {
            vtkSmartPointer<vtkActor> actor = m_meshBridge->getMeshActor();
            renderer->AddActor(actor);
            actor->GetProperty()->BackfaceCullingOff();
        }
        else
        {
                vtkSmartPointer<vtkActorCollection> collection = m_meshBridge->getTexturedActors();
                collection->InitTraversal();
                for(vtkIdType i = 0; i < collection->GetNumberOfItems(); i++)
                {
                        renderer->AddActor(collection->GetNextActor());
                }

        }
    }
}

void LVRModelBridge::removeActors(vtkSmartPointer<vtkRenderer> renderer)
{
    if(validPointBridge()) renderer->RemoveActor(m_pointBridge->getPointCloudActor());
    if(validMeshBridge()) renderer->RemoveActor(m_meshBridge->getMeshActor());
}

void LVRModelBridge::setVisibility(bool visible)
{
    if(validPointBridge()) m_pointBridge->setVisibility(visible);
    if(validMeshBridge()) m_meshBridge->setVisibility(visible);
}

void LVRModelBridge::setNormalsVisibility(bool visible)
{
    if(validPointBridge()) m_pointBridge->setNormalsVisibility(visible);
}

LVRModelBridge::~LVRModelBridge()
{
    // TODO Auto-generated destructor stub
}

} /* namespace lvr2 */