source/TriangleExtractor.cpp

Go to the documentation of this file.

/*
 *  TriangleExtractor.cpp
 *
 * Copyright (c) 2007, 2008, 2009, University of Karlsruhe (for members see AUTHORS file)
 *
 * ISC License
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 *  Created by Manfred Kroehnert on 14.11.07.
 */

#include "../include/IPSA/TriangleExtractor.h"
#include "../include/IPSA/VertexStorage.h"

#include <Inventor/SbLinear.h>
#include <Inventor/SoPrimitiveVertex.h>
#include <Inventor/actions/SoCallbackAction.h>
#include <Inventor/nodes/SoCoordinate3.h>
#include <Inventor/nodes/SoIndexedFaceSet.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/nodes/SoTranslation.h>

#include <iostream>

TriangleExtractor::TriangleExtractor(SoNode* object /*= NULL*/)
{
                this->result = new TriangleCallbackResult();
                this->ivModel = object;
}

TriangleExtractor::~TriangleExtractor()
{
                delete result;
}

void TriangleExtractor::execute(const SbVec3f& transvec)
{
                // reduce the complexity of the given Iv model
                SoSeparator* colModel = new SoSeparator;
                SoTranslation* t = new SoTranslation;
                t->translation.setValue(transvec);
                SoComplexity* complexity = new SoComplexity();
                complexity->value = 0.3f;
                colModel->addChild( t );
                colModel->addChild( complexity );
                colModel->addChild( ivModel );
                colModel->ref();
                // create callback action and extract the triangles
                SoCallbackAction cbAction;
                cbAction.addTriangleCallback( SoShape::getClassTypeId(), &TriangleExtractor::TriangleCB, this->result );
                cbAction.apply( colModel );

                colModel->unref();
}

VertexStorage<odeVertexType>* TriangleExtractor::getResult()
{
                // index count is actually only 3/4 of the count stored
                // int ifs->coordIndex because a -1 is stored at the end
                // of each index group
                int indexCount = this->result->ifs->coordIndex.getNum() * 3 / 4;
                VertexStorage<odeVertexType>* newVertexStorage =
                                new VertexStorage<odeVertexType>(this->result->coord3idx, indexCount);

                // first step: extract all the points
                SoMFVec3f vertices = result->coord3->point;
                for (int i = 0; i < result->coord3idx; i++)
                {
                                SbVec3f vertex = vertices[i];
                                odeVertexType triangle;
                                triangle[0] = vertex[0];
                                triangle[1] = vertex[1];
                                triangle[2] = vertex[2];
                                newVertexStorage->appendVertex( triangle );
                }

                // second step: extract the vertex indices
                SoMFInt32 coordIndex = result->ifs->coordIndex;
                for (int i = 0; i < coordIndex.getNum(); i += 4)
                {
                                newVertexStorage->appendVertexIndices( coordIndex[i + 0],
                                                                                                      coordIndex[i + 1],
                                                                                                      coordIndex[i + 2] );
                }
                return newVertexStorage;
}

void TriangleExtractor::TriangleCB(void* data, SoCallbackAction* action,
                const SoPrimitiveVertex* v1,
                const SoPrimitiveVertex* v2,
                const SoPrimitiveVertex* v3)
{
                TriangleCallbackResult* tcr = static_cast<TriangleCallbackResult*> (data);
                if (NULL == tcr)
                                return;

                SbMatrix mm = action->getModelMatrix();
                SbVec3f triangle[3];

                if ( (v1->getPoint() == v2->getPoint()) ||
                     (v1->getPoint() == v3->getPoint()) ||
                     (v2->getPoint() == v3->getPoint()) )
                {
                                printf("-- Vertex (%d) is degenerated, skipping.\n", tcr->coord3idx);
                                return;
                }

                // This only takes the properties in the ivModel-node into account,
                // like scaling or internal transformation:
                mm.multVecMatrix(v1->getPoint(), triangle[0]);
                mm.multVecMatrix(v2->getPoint(), triangle[1]);
                mm.multVecMatrix(v3->getPoint(), triangle[2]);

                int32_t indices[] = { 0, 0, 0, -1};
                for ( int i = 0; i < 3; i++ )
                {
                                // use returned index if point already present
                                // otherwise add point and increment the index count
                                int index = tcr->coord3->point.find( triangle[i], TRUE );
                                if ( index == -1 )
                                {
                                                indices[i] = tcr->coord3idx;
                                                tcr->coord3idx++;
                                }
                                else
                                {
                                                indices[i] = index;
                                }
                }
                // set additional indices
                int oldsize = tcr->ifs->coordIndex.getNum();
                tcr->ifs->coordIndex.setNum(oldsize + 4);
                tcr->ifs->coordIndex.setValues(oldsize, 4, indices);

                // (Note that it would likely be desirable to grab normal vectors,
                // materials and / or texture coordinates in a real-world
                // application. How to do this is not shown by the above code,
                // but it is not much different from the extraction of vertex
                // coordinates.)
}

---