void VTKMeshFileExporter::execute() {
if(mFilename == "")
throw Exception("No filename given to the VTKMeshFileExporter");
Mesh::pointer surface = getStaticInputData<Mesh>();
// Get transformation
AffineTransformation::pointer transform = SceneGraph::getAffineTransformationFromData(surface);
std::ofstream file(mFilename.c_str());
if(!file.is_open())
throw Exception("Unable to open the file " + mFilename);
// Write header
file << "# vtk DataFile Version 3.0\n"
"vtk output\n"
"ASCII\n"
"DATASET POLYDATA\n";
// Write vertices
MeshAccess::pointer access = surface->getMeshAccess(ACCESS_READ);
std::vector<MeshVertex> vertices = access->getVertices();
file << "POINTS " << vertices.size() << " float\n";
for(int i = 0; i < vertices.size(); i++) {
MeshVertex vertex = vertices[i];
vertex.position = (transform->matrix()*vertex.position.homogeneous()).head(3);
file << vertex.position.x() << " " << vertex.position.y() << " " << vertex.position.z() << "\n";
}
// Write triangles
std::vector<Vector3ui> triangles = access->getTriangles();
file << "POLYGONS " << surface->getNrOfTriangles() << " " << surface->getNrOfTriangles()*4 << "\n";
for(int i = 0; i < triangles.size(); i++) {
Vector3ui triangle = triangles[i];
file << "3 " << triangle.x() << " " << triangle.y() << " " << triangle.z() << "\n";
}
// Write normals
file << "POINT_DATA " << vertices.size() << "\n";
file << "NORMALS Normals float\n";
for(int i = 0; i < vertices.size(); i++) {
MeshVertex vertex = vertices[i];
// Transform it
vertex.normal = transform->linear()*vertex.normal;
// Normalize it
float length = vertex.normal.norm();
if(length == 0) { // prevent NaN situations
file << "0 1 0\n";
} else {
file << (vertex.normal.x()/length) << " " << (vertex.normal.y()/length) << " " << (vertex.normal.z()/length) << "\n";
}
}
file.close();
}
int VTKMeshExporter::RequestData(
vtkInformation* vtkNotUsed(request),
vtkInformationVector** inputVector,
vtkInformationVector* outputVector) {
update(); // Run FAST pipeline
Mesh::pointer input = getStaticInputData<Mesh>();
MeshAccess::pointer access = input->getMeshAccess(ACCESS_READ);
vtkInformation *outInfo = outputVector->GetInformationObject(0);
vtkPolyData *output = this->GetOutput();
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
points->SetNumberOfPoints(input->getNrOfVertices());
for(int i = 0; i < input->getNrOfVertices(); i++) {
MeshVertex v = access->getVertex(i);
VectorXf position = v.getPosition();
if(input->getDimensions() == 2) {
points->SetPoint(i, position.x(), position.y(), 0);
} else {
points->SetPoint(i, position.x(), position.y(), position.z());
}
}
output->SetPoints(points);
vtkSmartPointer<vtkCellArray> polys = vtkSmartPointer<vtkCellArray>::New();
if(input->getDimensions() == 2) {
for(int i = 0; i < input->getNrOfLines(); i++) {
VectorXui line = access->getLine(i);
polys->InsertNextCell(2);
polys->InsertCellPoint(line.x());
polys->InsertCellPoint(line.y());
}
output->SetLines(polys);
} else {
for(int i = 0; i < input->getNrOfTriangles(); i++) {
VectorXui triangle = access->getTriangle(i);
polys->InsertNextCell(3);
polys->InsertCellPoint(triangle.x());
polys->InsertCellPoint(triangle.y());
polys->InsertCellPoint(triangle.z());
}
output->SetPolys(polys);
}
// TODO if 3D, also export normals
return 1;
}
void MeshRenderer::draw() {
boost::lock_guard<boost::mutex> lock(mMutex);
glEnable(GL_NORMALIZE);
glShadeModel(GL_SMOOTH);
glEnable(GL_LIGHTING);
boost::unordered_map<uint, Mesh::pointer>::iterator it;
for(it = mMeshToRender.begin(); it != mMeshToRender.end(); it++) {
Mesh::pointer surfaceToRender = it->second;
if(surfaceToRender->getDimensions() != 3)
continue;
// Draw the triangles in the VBO
AffineTransformation::pointer transform = SceneGraph::getAffineTransformationFromData(surfaceToRender);
glPushMatrix();
glMultMatrixf(transform->data());
float opacity = mDefaultOpacity;
Color color = mDefaultColor;
ProcessObjectPort port = getInputPort(it->first);
if(mInputOpacities.count(port) > 0) {
opacity = mInputOpacities[port];
}
if(mInputColors.count(port) > 0) {
color = mInputColors[port];
}
// Set material properties
if(opacity < 1) {
// Enable transparency
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
GLfloat GLcolor[] = { color.getRedValue(), color.getGreenValue(), color.getBlueValue(), opacity };
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, GLcolor);
GLfloat specReflection[] = { mDefaultSpecularReflection, mDefaultSpecularReflection, mDefaultSpecularReflection, 1.0f };
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specReflection);
GLfloat shininess[] = { 16.0f };
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
VertexBufferObjectAccess::pointer access = surfaceToRender->getVertexBufferObjectAccess(ACCESS_READ, getMainDevice());
GLuint* VBO_ID = access->get();
// Normal Buffer
glBindBuffer(GL_ARRAY_BUFFER, *VBO_ID);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glVertexPointer(3, GL_FLOAT, 24, 0);
glNormalPointer(GL_FLOAT, 24, (float*)(sizeof(GLfloat)*3));
glDrawArrays(GL_TRIANGLES, 0, surfaceToRender->getNrOfTriangles()*3);
// Release buffer
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
if(opacity < 1) {
// Disable transparency
glDisable(GL_BLEND);
}
glPopMatrix();
}
glDisable(GL_LIGHTING);
glDisable(GL_NORMALIZE);
glColor3f(1.0f, 1.0f, 1.0f); // Reset color
}
