← Back to branch summary

~ubuntu-branches/ubuntu/raring/openwalnut/raring

« back to all changes in this revision

Viewing changes to src/modules/writeMesh/WMWriteMesh.cpp

  • Committer: Package Import Robot
  • Author(s): Sebastian Eichelbaum
  • Date: 2012-12-12 11:26:32 UTC
  • mfrom: (3.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20121212112632-xhiuwkxuz5h0idkh
Tags: 1.3.1+hg5849-1
* Minor changes compared to 1.3.0 but included several bug fixes.
* See http://www.openwalnut.org/versions/4

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/modules/writeMesh/WMWriteMesh.cpp
23
23
//---------------------------------------------------------------------------
24
24
 
25
25
#include <string>
 
26
#include <fstream>
 
27
#include <vector>
26
28
 
 
29
#include "core/common/WStringUtils.h"
27
30
#include "core/common/math/WMath.h"
28
31
#include "core/common/WPathHelper.h"
 
32
#include "core/common/WLimits.h"
29
33
#include "core/kernel/WKernel.h"
30
34
#include "WMWriteMesh.xpm"
31
35
#include "WMWriteMesh.h"
91
95
    m_fileTypeSelection = m_properties->addProperty( "File type",  "file type.", m_fileTypeSelectionsList->getSelectorFirst() );
92
96
       WPropertyHelper::PC_SELECTONLYONE::addTo( m_fileTypeSelection );
93
97
 
94
 
    m_writeColors = m_properties->addProperty( "Write colors", "", true, m_propCondition );
 
98
    m_writeColors = m_properties->addProperty( "Write colors", "", true );
95
99
 
96
100
    WModule::properties();
97
101
}
120
124
 
121
125
        m_saveTriggerProp->set( WPVBaseTypes::PV_TRIGGER_READY, false );
122
126
 
123
 
        switch ( m_fileTypeSelection->get( true ).getItemIndexOfSelected( 0 ) )
 
127
        switch( m_fileTypeSelection->get( true ).getItemIndexOfSelected( 0 ) )
124
128
        {
125
129
            case 0:
126
130
                debugLog() << "type VTK ASCII file selected";
157
161
        return false;
158
162
    }
159
163
 
160
 
    const char* c_file = m_meshFile->get().file_string().c_str();
 
164
    const char* c_file = m_meshFile->get().string().c_str();
161
165
    std::ofstream dataFile( c_file, std::ios_base::binary );
162
166
 
163
167
    if( dataFile )
166
170
    }
167
171
    else
168
172
    {
169
 
        WLogger::getLogger()->addLogMessage( "open file failed" + m_meshFile->get().file_string() , "Write Mesh", LL_ERROR );
 
173
        WLogger::getLogger()->addLogMessage( "open file failed" + m_meshFile->get().string() , "Write Mesh", LL_ERROR );
170
174
        return false;
171
175
    }
172
176
 
183
187
    for( size_t i = 0; i < m_triMesh->vertSize(); ++i )
184
188
    {
185
189
        point = m_triMesh->getVertex( i );
186
 
        if( !( myIsfinite( point[0] ) && myIsfinite( point[1] ) && myIsfinite( point[2] ) ) )
 
190
        if( !( !wlimits::isInf( point[0] ) && !wlimits::isInf( point[1] ) && !wlimits::isInf( point[2] ) ) )
187
191
        {
188
192
            WLogger::getLogger()->addLogMessage( "Will not write file from data that contains NAN or INF.", "Write Mesh", LL_ERROR );
189
193
            return false;
215
219
    return true;
216
220
}
217
221
 
218
 
bool WMWriteMesh::saveJson() const
 
222
bool WMWriteMesh::saveJson()
219
223
{
220
224
    if( !m_triMesh )
221
225
    {
234
238
        return false;
235
239
    }
236
240
 
237
 
    const char* c_file = m_meshFile->get().file_string().c_str();
238
 
    std::ofstream dataFile( c_file, std::ios_base::binary );
239
 
 
240
 
    if( dataFile )
241
 
    {
242
 
        WLogger::getLogger()->addLogMessage( "opening file", "Write Mesh", LL_DEBUG );
243
 
    }
244
 
    else
245
 
    {
246
 
        WLogger::getLogger()->addLogMessage( "open file failed" + m_meshFile->get().file_string() , "Write Mesh", LL_ERROR );
247
 
        return false;
248
 
    }
249
 
 
250
 
    dataFile.precision( 7 );
251
 
 
252
 
    WLogger::getLogger()->addLogMessage( "start writing file", "Write Mesh", LL_DEBUG );
253
 
 
254
 
 
255
 
    dataFile << ( "{\n" );
256
 
    dataFile << ( "    \"vertices\" : [" );
257
 
    WPosition point;
258
 
    for( size_t i = 0; i < m_triMesh->vertSize() - 1; ++i )
259
 
    {
260
 
        point = m_triMesh->getVertex( i );
261
 
        if( !( myIsfinite( point[0] ) && myIsfinite( point[1] ) && myIsfinite( point[2] ) ) )
262
 
        {
263
 
            WLogger::getLogger()->addLogMessage( "Will not write file from data that contains NAN or INF.", "Write Mesh", LL_ERROR );
264
 
            return false;
265
 
        }
266
 
        dataFile << point[0] << "," << point[1] << "," << point[2] << ",";
267
 
    }
268
 
    point = m_triMesh->getVertex( m_triMesh->vertSize() - 1 );
269
 
    dataFile << point[0] << "," << point[1] << "," << point[2] << "],\n";
270
 
 
271
 
    dataFile << ( "    \"normals\" : [" );
272
 
    WPosition normal;
273
 
    for( size_t i = 0; i < m_triMesh->vertSize() - 1; ++i )
274
 
    {
275
 
        normal = m_triMesh->getNormal( i );
276
 
        if( !( myIsfinite( normal[0] ) && myIsfinite( normal[1] ) && myIsfinite( normal[2] ) ) )
277
 
        {
278
 
            WLogger::getLogger()->addLogMessage( "Will not write file from data that contains NAN or INF.", "Write Mesh", LL_ERROR );
279
 
            return false;
280
 
        }
281
 
        dataFile << normal[0] << "," << normal[1] << "," << normal[2] << ",";
282
 
    }
283
 
    normal = m_triMesh->getNormal( m_triMesh->vertSize() - 1 );
284
 
    dataFile << normal[0] << "," << normal[1] << "," << normal[2] << "],\n";
285
 
 
286
 
    dataFile << ( "    \"indices\" : [" );
287
 
    for( size_t i = 0; i < m_triMesh->triangleSize() - 1; ++i )
288
 
    {
289
 
        dataFile << m_triMesh->getTriVertId0( i ) << "," <<  m_triMesh->getTriVertId1( i ) << "," <<  m_triMesh->getTriVertId2( i ) << ",";
290
 
    }
291
 
    size_t i = m_triMesh->triangleSize() - 1;
292
 
    dataFile << m_triMesh->getTriVertId0( i ) << "," <<  m_triMesh->getTriVertId1( i ) << "," <<  m_triMesh->getTriVertId2( i ) << "]";
293
 
 
294
 
 
295
 
    if( m_writeColors->get() )
296
 
    {
297
 
        dataFile << ",\n";
298
 
        dataFile << ( "    \"colors\" : [" );
299
 
        for( size_t k = 0; k < m_triMesh->vertSize() - 1; ++k )
300
 
        {
301
 
            osg::Vec4 color = m_triMesh->getVertColor( k );
302
 
 
303
 
            dataFile << color[0] << "," <<  color[1] << "," <<  color[2] << "," <<  color[3] << ",";
304
 
        }
305
 
        osg::Vec4 color = m_triMesh->getVertColor( m_triMesh->vertSize() - 1 );
306
 
        dataFile << color[0] << "," <<  color[1] << "," <<  color[2] << "," <<  color[3] << "]";
307
 
    }
308
 
    dataFile <<  "\n}";
309
 
 
310
 
    dataFile.close();
 
241
    std::vector< boost::shared_ptr< WTriangleMesh > >meshes;
 
242
    meshes = splitMesh( m_triMesh, 65000 );
 
243
 
 
244
    for( size_t k = 0; k < meshes.size(); ++k )
 
245
    {
 
246
        std::string fn = m_meshFile->get().string() + "_" + string_utils::toString( k );
 
247
        const char* c_file = fn.c_str();
 
248
        std::ofstream dataFile( c_file, std::ios_base::binary );
 
249
 
 
250
        if( dataFile )
 
251
        {
 
252
            WLogger::getLogger()->addLogMessage( "opening file", "Write Mesh", LL_DEBUG );
 
253
        }
 
254
        else
 
255
        {
 
256
            WLogger::getLogger()->addLogMessage( "open file failed" + m_meshFile->get().string() , "Write Mesh", LL_ERROR );
 
257
            return false;
 
258
        }
 
259
 
 
260
        dataFile.precision( 5 );
 
261
 
 
262
        WLogger::getLogger()->addLogMessage( "start writing file", "Write Mesh", LL_DEBUG );
 
263
 
 
264
        std::cout << meshes[k]->vertSize() << " vertices and " << meshes[k]->triangleSize() << " triangles" << std::endl;
 
265
        dataFile << ( "{\n" );
 
266
        dataFile << ( "    \"vertices\" : [" );
 
267
        WPosition point;
 
268
        for( size_t i = 0; i < meshes[k]->vertSize() - 1; ++i )
 
269
        {
 
270
            point = meshes[k]->getVertex( i );
 
271
            if( !( !wlimits::isInf( point[0] ) && !wlimits::isInf( point[1] ) && !wlimits::isInf( point[2] ) ) )
 
272
            {
 
273
                WLogger::getLogger()->addLogMessage( "Will not write file from data that contains NAN or INF.", "Write Mesh", LL_ERROR );
 
274
                return false;
 
275
            }
 
276
            dataFile << point[0] << "," << point[1] << "," << point[2] << ",";
 
277
        }
 
278
        point = meshes[k]->getVertex( meshes[k]->vertSize() - 1 );
 
279
        dataFile << point[0] << "," << point[1] << "," << point[2] << "],\n";
 
280
 
 
281
        dataFile << ( "    \"normals\" : [" );
 
282
        WPosition normal;
 
283
        for( size_t i = 0; i < meshes[k]->vertSize() - 1; ++i )
 
284
        {
 
285
            normal = meshes[k]->getNormal( i );
 
286
            if( !( !wlimits::isInf( normal[0] ) && !wlimits::isInf( normal[1] ) && !wlimits::isInf( normal[2] ) ) )
 
287
            {
 
288
                WLogger::getLogger()->addLogMessage( "Will not write file from data that contains NAN or INF.", "Write Mesh", LL_ERROR );
 
289
                return false;
 
290
            }
 
291
            dataFile << normal[0] << "," << normal[1] << "," << normal[2] << ",";
 
292
        }
 
293
        normal = meshes[k]->getNormal( meshes[k]->vertSize() - 1 );
 
294
        dataFile << normal[0] << "," << normal[1] << "," << normal[2] << "],\n";
 
295
 
 
296
        dataFile << ( "    \"indices\" : [" );
 
297
        for( size_t i = 0; i < meshes[k]->triangleSize() - 1; ++i )
 
298
        {
 
299
            dataFile << meshes[k]->getTriVertId0( i ) << "," <<  meshes[k]->getTriVertId1( i ) << "," <<  meshes[k]->getTriVertId2( i ) << ",";
 
300
        }
 
301
        size_t i = meshes[k]->triangleSize() - 1;
 
302
        dataFile << meshes[k]->getTriVertId0( i ) << "," <<  meshes[k]->getTriVertId1( i ) << "," <<  meshes[k]->getTriVertId2( i ) << "]";
 
303
 
 
304
 
 
305
        if( m_writeColors->get() )
 
306
        {
 
307
            dataFile << ",\n";
 
308
            dataFile << ( "    \"colors\" : [" );
 
309
            for( size_t j = 0; j < meshes[k]->vertSize() - 1; ++j )
 
310
            {
 
311
                osg::Vec4 color = meshes[k]->getVertColor( j );
 
312
 
 
313
                dataFile << color[0] << "," <<  color[1] << "," <<  color[2] << "," <<  color[3] << ",";
 
314
            }
 
315
            osg::Vec4 color = meshes[k]->getVertColor( meshes[k]->vertSize() - 1 );
 
316
            dataFile << color[0] << "," <<  color[1] << "," <<  color[2] << "," <<  color[3] << "]";
 
317
        }
 
318
        dataFile <<  "\n}";
 
319
 
 
320
        dataFile.close();
 
321
    }
311
322
    WLogger::getLogger()->addLogMessage( "saving done", "Write Mesh", LL_DEBUG );
312
323
    return true;
313
324
}
 
325
 
 
326
std::vector< boost::shared_ptr< WTriangleMesh > >WMWriteMesh::splitMesh( boost::shared_ptr< WTriangleMesh > triMesh, size_t targetSize )
 
327
{
 
328
    std::vector< boost::shared_ptr< WTriangleMesh > >meshes;
 
329
    if( triMesh->vertSize() <= targetSize )
 
330
    {
 
331
        meshes.push_back( triMesh );
 
332
        return meshes;
 
333
    }
 
334
    size_t currentTri( 0 );
 
335
    size_t id0, id1, id2;
 
336
 
 
337
    while( currentTri < triMesh->triangleSize() )
 
338
    {
 
339
        boost::shared_ptr< WTriangleMesh > newMesh = boost::shared_ptr< WTriangleMesh >( new WTriangleMesh( 0, 0 ) );
 
340
        std::vector<int>newIds( triMesh->vertSize(), -1 );
 
341
        while( newMesh->vertSize() < targetSize )
 
342
        {
 
343
            id0 = triMesh->getTriVertId0( currentTri );
 
344
            id1 = triMesh->getTriVertId1( currentTri );
 
345
            id2 = triMesh->getTriVertId2( currentTri );
 
346
            if( newIds[id0] == -1 )
 
347
            {
 
348
                newIds[id0] = newMesh->vertSize();
 
349
                osg::Vec3 vert = triMesh->getTriVert( currentTri, 0 );
 
350
                newMesh->addVertex( vert.x(), vert.y(), vert.z() );
 
351
                newMesh->setVertexColor( newMesh->vertSize() - 1, triMesh->getVertColor( id0 ) );
 
352
            }
 
353
            if( newIds[id1] == -1 )
 
354
            {
 
355
                newIds[id1] = newMesh->vertSize();
 
356
                osg::Vec3 vert = triMesh->getTriVert( currentTri, 1 );
 
357
                newMesh->addVertex( vert.x(), vert.y(), vert.z() );
 
358
                newMesh->setVertexColor( newMesh->vertSize() - 1, triMesh->getVertColor( id1 ) );
 
359
            }
 
360
            if( newIds[id2] == -1 )
 
361
            {
 
362
                newIds[id2] = newMesh->vertSize();
 
363
                osg::Vec3 vert = triMesh->getTriVert( currentTri, 2 );
 
364
                newMesh->addVertex( vert.x(), vert.y(), vert.z() );
 
365
                newMesh->setVertexColor( newMesh->vertSize() - 1, triMesh->getVertColor( id2 ) );
 
366
            }
 
367
            newMesh->addTriangle( newIds[id0], newIds[id1], newIds[id2] );
 
368
            ++currentTri;
 
369
            if( currentTri == triMesh->triangleSize() )
 
370
            {
 
371
                break;
 
372
            }
 
373
        }
 
374
 
 
375
        meshes.push_back( newMesh );
 
376
    }
 
377
    return meshes;
 
378
}