← Back to branch summary

~ubuntu-branches/ubuntu/vivid/openwalnut/vivid

« back to all changes in this revision

Viewing changes to .pc/boost153/src/modules/imageExtractor/WMImageExtractor.cpp

  • Committer: Package Import Robot
  • Author(s): Dmitrijs Ledkovs
  • Date: 2013-05-24 03:12:03 UTC
  • Revision ID: package-import@ubuntu.com-20130524031203-l5g1lzm1vd83fupi
Tags: 1.3.1+hg5849-1ubuntu1
Cherrypick boost1.53 pointer cast fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/boost153/src/modules/imageExtractor/WMImageExtractor.cpp
 
1
//---------------------------------------------------------------------------
 
2
//
 
3
// Project: OpenWalnut ( http://www.openwalnut.org )
 
4
//
 
5
// Copyright 2009 OpenWalnut Community, BSV-Leipzig and CNCF-CBS
 
6
// For more information see http://www.openwalnut.org/copying
 
7
//
 
8
// This file is part of OpenWalnut.
 
9
//
 
10
// OpenWalnut is free software: you can redistribute it and/or modify
 
11
// it under the terms of the GNU Lesser General Public License as published by
 
12
// the Free Software Foundation, either version 3 of the License, or
 
13
// (at your option) any later version.
 
14
//
 
15
// OpenWalnut is distributed in the hope that it will be useful,
 
16
// but WITHOUT ANY WARRANTY; without even the implied warranty of
 
17
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
18
// GNU Lesser General Public License for more details.
 
19
//
 
20
// You should have received a copy of the GNU Lesser General Public License
 
21
// along with OpenWalnut. If not, see <http://www.gnu.org/licenses/>.
 
22
//
 
23
//---------------------------------------------------------------------------
 
24
 
 
25
#include <algorithm>
 
26
#include <string>
 
27
#include <sstream>
 
28
#include <vector>
 
29
 
 
30
#include "core/kernel/WKernel.h"
 
31
#include "core/dataHandler/WDataHandler.h"
 
32
#include "core/dataHandler/WDataTexture3D.h"
 
33
#include "core/graphicsEngine/WGEColormapping.h"
 
34
#include "core/common/WPropertyHelper.h"
 
35
 
 
36
#include "WMImageExtractor.xpm"
 
37
#include "WMImageExtractor.h"
 
38
 
 
39
// This line is needed by the module loader to actually find your module.
 
40
W_LOADABLE_MODULE( WMImageExtractor )
 
41
 
 
42
WMImageExtractor::WMImageExtractor():
 
43
    WModule()
 
44
{
 
45
}
 
46
 
 
47
WMImageExtractor::~WMImageExtractor()
 
48
{
 
49
}
 
50
 
 
51
boost::shared_ptr< WModule > WMImageExtractor::factory() const
 
52
{
 
53
    return boost::shared_ptr< WModule >( new WMImageExtractor() );
 
54
}
 
55
 
 
56
const std::string WMImageExtractor::getName() const
 
57
{
 
58
    return "Image Extractor";
 
59
}
 
60
 
 
61
const std::string WMImageExtractor::getDescription() const
 
62
{
 
63
    return "This module allows extracting of single images from a dataset.";
 
64
}
 
65
 
 
66
const char** WMImageExtractor::getXPMIcon() const
 
67
{
 
68
    return imageExtractor_xpm;
 
69
}
 
70
 
 
71
void WMImageExtractor::connectors()
 
72
{
 
73
    m_input = boost::shared_ptr< WModuleInputData < WDataSetSingle  > >(
 
74
        new WModuleInputData< WDataSetSingle >( shared_from_this(), "in", "The input dataset." ) );
 
75
    addConnector( m_input );
 
76
 
 
77
    m_output = boost::shared_ptr< WModuleOutputData < WDataSetScalar  > >(
 
78
        new WModuleOutputData< WDataSetScalar >( shared_from_this(), "out", "The extracted image." ) );
 
79
    addConnector( m_output );
 
80
 
 
81
    WModule::connectors();
 
82
}
 
83
 
 
84
void WMImageExtractor::properties()
 
85
{
 
86
    m_propCondition = boost::shared_ptr< WCondition >( new WCondition() );
 
87
 
 
88
    m_selectedImage = m_properties->addProperty( "Image", "The image to be extracted.", 0, m_propCondition );
 
89
    m_selectedImage->setMin( 0 );
 
90
    m_selectedImage->setMax( 0 );
 
91
 
 
92
    m_minValuePct = m_properties->addProperty( "Min %", "The data value percent that maps to 0.0 in the texture.", 0.0, m_propCondition );
 
93
    m_minValuePct->setMin( 0.0 );
 
94
    m_minValuePct->setMax( 100.0 );
 
95
 
 
96
    m_maxValuePct = m_properties->addProperty( "Max %", "The data value percent that maps to 1.0 in the texture.", 100.0, m_propCondition );
 
97
    m_maxValuePct->setMin( 0.0 );
 
98
    m_maxValuePct->setMax( 100.0 );
 
99
 
 
100
    WModule::properties();
 
101
}
 
102
 
 
103
void WMImageExtractor::activate()
 
104
{
 
105
    if( m_outData )
 
106
    {
 
107
        m_outData->getTexture()->active()->set( m_active->get() );
 
108
    }
 
109
    WModule::activate();
 
110
}
 
111
 
 
112
void WMImageExtractor::moduleMain()
 
113
{
 
114
    m_moduleState.setResetable( true, true );
 
115
    m_moduleState.add( m_input->getDataChangedCondition() );
 
116
    m_moduleState.add( m_propCondition );
 
117
 
 
118
    ready();
 
119
 
 
120
    while( !m_shutdownFlag() )
 
121
    {
 
122
        m_moduleState.wait();
 
123
 
 
124
        if( m_shutdownFlag() )
 
125
        {
 
126
            break;
 
127
        }
 
128
 
 
129
        boost::shared_ptr< WDataSetSingle > newDataSet = m_input->getData();
 
130
        bool dataChanged = ( m_dataSet != newDataSet );
 
131
        bool dataValid   = ( newDataSet );
 
132
 
 
133
        if( dataValid )
 
134
        {
 
135
            if( dataChanged || m_selectedImage->changed() || m_minValuePct->changed() || m_maxValuePct->changed() )
 
136
            {
 
137
                m_dataSet = newDataSet;
 
138
                WAssert( m_dataSet, "" );
 
139
                WAssert( m_dataSet->getValueSet(), "" );
 
140
 
 
141
                if( dataChanged )
 
142
                {
 
143
                    m_selectedImage->setMax( m_dataSet->getValueSet()->dimension() - 1 );
 
144
                    m_selectedImage->ensureValidity( 0 );
 
145
                }
 
146
 
 
147
                // remove the old dataset's properties and de-register from colormapper
 
148
                if( m_outData )
 
149
                {
 
150
                    m_properties->removeProperty( m_outData->getTexture()->getProperties() );
 
151
                    m_infoProperties->removeProperty( m_outData->getTexture()->getInformationProperties() );
 
152
                }
 
153
 
 
154
                std::size_t i = static_cast< std::size_t >( m_selectedImage->get( true ) );
 
155
 
 
156
                boost::shared_ptr< WDataSetScalar > oldOut = m_outData;
 
157
                m_outData = extract( i );
 
158
 
 
159
                if( m_outData )
 
160
                {
 
161
                    setOutputProps();
 
162
                    m_outData->setFilename( makeImageName( i ) );
 
163
                    // provide the texture's properties as own properties
 
164
                    m_properties->addProperty( m_outData->getTexture()->getProperties() );
 
165
                    m_infoProperties->addProperty( m_outData->getTexture()->getInformationProperties() );
 
166
                }
 
167
 
 
168
                // update colormapper
 
169
                // 1: there was some texture and there is a new texture:
 
170
                if( oldOut && m_outData )
 
171
                {
 
172
                    // according to WGEColormapper::replaceTexture, an non-existing old texture causes the new one to be inserted at the end.
 
173
                    WGEColormapping::replaceTexture( oldOut->getTexture(), m_outData->getTexture(), makeImageName( i ) );
 
174
                }
 
175
                // 2: there is no new texture. Remove old one.
 
176
                else if( oldOut )
 
177
                {
 
178
                    // no new texture. Remove old one.
 
179
                    WGEColormapping::deregisterTexture( oldOut->getTexture() );
 
180
                }
 
181
                // 3: there was no texture. Add new one.
 
182
                else if( m_outData )
 
183
                {
 
184
                    // no new texture. Remove old one.
 
185
                    WGEColormapping::registerTexture( m_outData->getTexture(), makeImageName( i ) );
 
186
                }
 
187
 
 
188
                m_output->updateData( m_outData );
 
189
            }
 
190
            else
 
191
            {
 
192
                if( m_outData )
 
193
                {
 
194
                    setOutputProps();
 
195
                }
 
196
            }
 
197
        }
 
198
        else // case !dataValid
 
199
        {
 
200
            if( m_outData )
 
201
            {
 
202
                m_properties->removeProperty( m_outData->getTexture()->getProperties() );
 
203
                m_infoProperties->removeProperty( m_outData->getTexture()->getInformationProperties() );
 
204
                WGEColormapping::deregisterTexture( m_outData->getTexture() );
 
205
            }
 
206
            m_outData = boost::shared_ptr< WDataSetScalar >();
 
207
            m_output->updateData( m_outData );
 
208
        }
 
209
    }
 
210
 
 
211
    debugLog() << "Shutting down...";
 
212
 
 
213
    if( m_outData )
 
214
    {
 
215
        m_properties->removeProperty( m_outData->getTexture()->getProperties() );
 
216
        m_infoProperties->removeProperty( m_outData->getTexture()->getInformationProperties() );
 
217
        WGEColormapping::deregisterTexture( m_outData->getTexture() );
 
218
    }
 
219
 
 
220
    debugLog() << "Finished! Good Bye!";
 
221
}
 
222
 
 
223
boost::shared_ptr< WDataSetScalar > WMImageExtractor::extract( std::size_t i ) const
 
224
{
 
225
    WAssert( m_dataSet, "" );
 
226
    WAssert( m_dataSet->getValueSet(), "" );
 
227
    WAssert( m_dataSet->getGrid(), "" );
 
228
 
 
229
    if( m_dataSet->getValueSet()->order() > 1 || i >= m_dataSet->getValueSet()->dimension() )
 
230
    {
 
231
        return boost::shared_ptr< WDataSetScalar >();
 
232
    }
 
233
 
 
234
    boost::shared_ptr< WGridRegular3D > grid = boost::shared_dynamic_cast< WGridRegular3D >( m_dataSet->getGrid() );
 
235
    WAssert( grid, "" );
 
236
 
 
237
    std::size_t dim = m_dataSet->getValueSet()->dimension();
 
238
 
 
239
    // TODO(reichenbach): use the new valueset function mechanism
 
240
    switch( m_dataSet->getValueSet()->getDataType() )
 
241
    {
 
242
    case W_DT_FLOAT:
 
243
        {
 
244
            boost::shared_ptr< std::vector< float > > values = boost::shared_ptr< std::vector< float > >(
 
245
                new std::vector< float >( m_dataSet->getGrid()->size() ) );
 
246
            boost::shared_ptr< WValueSet< float > > v = boost::shared_dynamic_cast< WValueSet< float > >( m_dataSet->getValueSet() );
 
247
            WAssert( v, "" );
 
248
            for( std::size_t k = 0; k < grid->size(); ++k )
 
249
            {
 
250
                ( *values )[k] =  v->rawData()[ dim * k + i ];
 
251
            }
 
252
 
 
253
            boost::shared_ptr< WValueSet< float > > vs =
 
254
                    boost::shared_ptr< WValueSet< float > >( new WValueSet< float >( 0, 1, values, W_DT_FLOAT ) );
 
255
 
 
256
            return boost::shared_ptr< WDataSetScalar >( new WDataSetScalar( vs, grid ) );
 
257
        }
 
258
    case W_DT_DOUBLE:
 
259
        {
 
260
            boost::shared_ptr< std::vector< double > > values = boost::shared_ptr< std::vector< double > >(
 
261
                new std::vector< double >( m_dataSet->getGrid()->size() ) );
 
262
            boost::shared_ptr< WValueSet< double > > v = boost::shared_dynamic_cast< WValueSet< double > >( m_dataSet->getValueSet() );
 
263
            WAssert( v, "" );
 
264
            for( std::size_t k = 0; k < grid->size(); ++k )
 
265
            {
 
266
                ( *values )[k] =  v->rawData()[ dim * k + i ];
 
267
            }
 
268
 
 
269
            boost::shared_ptr< WValueSet< double > > vs =
 
270
                    boost::shared_ptr< WValueSet< double > >( new WValueSet< double >( 0, 1, values, W_DT_DOUBLE ) );
 
271
 
 
272
            return boost::shared_ptr< WDataSetScalar >( new WDataSetScalar( vs, grid ) );
 
273
        }
 
274
    case W_DT_UINT8:
 
275
        {
 
276
            boost::shared_ptr< std::vector< uint8_t > > values = boost::shared_ptr< std::vector< uint8_t > >(
 
277
                new std::vector< uint8_t >( m_dataSet->getGrid()->size() ) );
 
278
            boost::shared_ptr< WValueSet< uint8_t > > v = boost::shared_dynamic_cast< WValueSet< uint8_t > >( m_dataSet->getValueSet() );
 
279
            WAssert( v, "" );
 
280
            for( std::size_t k = 0; k < grid->size(); ++k )
 
281
            {
 
282
                ( *values )[k] =  v->rawData()[ dim * k + i ];
 
283
            }
 
284
 
 
285
            boost::shared_ptr< WValueSet< uint8_t > > vs =
 
286
                    boost::shared_ptr< WValueSet< uint8_t > >( new WValueSet< uint8_t >( 0, 1, values, W_DT_UINT8 ) );
 
287
 
 
288
            return boost::shared_ptr< WDataSetScalar >( new WDataSetScalar( vs, grid ) );
 
289
        }
 
290
    case W_DT_UINT16:
 
291
        {
 
292
            boost::shared_ptr< std::vector< uint16_t > > values = boost::shared_ptr< std::vector< uint16_t > >(
 
293
                new std::vector< uint16_t >( m_dataSet->getGrid()->size() ) );
 
294
            boost::shared_ptr< WValueSet< uint16_t > > v = boost::shared_dynamic_cast< WValueSet< uint16_t > >( m_dataSet->getValueSet() );
 
295
            WAssert( v, "" );
 
296
            for( std::size_t k = 0; k < grid->size(); ++k )
 
297
            {
 
298
                ( *values )[k] =  v->rawData()[ dim * k + i ];
 
299
            }
 
300
 
 
301
            boost::shared_ptr< WValueSet< uint16_t > > vs =
 
302
                    boost::shared_ptr< WValueSet< uint16_t > >( new WValueSet< uint16_t >( 0, 1, values, W_DT_UINT16 ) );
 
303
 
 
304
            return boost::shared_ptr< WDataSetScalar >( new WDataSetScalar( vs, grid ) );
 
305
        }
 
306
    case W_DT_UINT32:
 
307
        {
 
308
            boost::shared_ptr< std::vector< uint32_t > > values = boost::shared_ptr< std::vector< uint32_t > >(
 
309
                new std::vector< uint32_t >( m_dataSet->getGrid()->size() ) );
 
310
            boost::shared_ptr< WValueSet< uint32_t > > v = boost::shared_dynamic_cast< WValueSet< uint32_t > >( m_dataSet->getValueSet() );
 
311
            WAssert( v, "" );
 
312
            for( std::size_t k = 0; k < grid->size(); ++k )
 
313
            {
 
314
                ( *values )[k] =  v->rawData()[ dim * k + i ];
 
315
            }
 
316
 
 
317
            boost::shared_ptr< WValueSet< uint32_t > > vs =
 
318
                    boost::shared_ptr< WValueSet< uint32_t > >( new WValueSet< uint32_t >( 0, 1, values, W_DT_UINT32 ) );
 
319
 
 
320
            return boost::shared_ptr< WDataSetScalar >( new WDataSetScalar( vs, grid ) );
 
321
        }
 
322
    case W_DT_INT8:
 
323
        {
 
324
            boost::shared_ptr< std::vector< int8_t > > values = boost::shared_ptr< std::vector< int8_t > >(
 
325
                new std::vector< int8_t >( m_dataSet->getGrid()->size() ) );
 
326
            boost::shared_ptr< WValueSet< int8_t > > v = boost::shared_dynamic_cast< WValueSet< int8_t > >( m_dataSet->getValueSet() );
 
327
            WAssert( v, "" );
 
328
            for( std::size_t k = 0; k < grid->size(); ++k )
 
329
            {
 
330
                ( *values )[k] =  v->rawData()[ dim * k + i ];
 
331
            }
 
332
 
 
333
            boost::shared_ptr< WValueSet< int8_t > > vs =
 
334
                    boost::shared_ptr< WValueSet< int8_t > >( new WValueSet< int8_t >( 0, 1, values, W_DT_INT8 ) );
 
335
 
 
336
            return boost::shared_ptr< WDataSetScalar >( new WDataSetScalar( vs, grid ) );
 
337
        }
 
338
    case W_DT_INT16:
 
339
        {
 
340
            boost::shared_ptr< std::vector< int16_t > > values = boost::shared_ptr< std::vector< int16_t > >(
 
341
                new std::vector< int16_t >( m_dataSet->getGrid()->size() ) );
 
342
            boost::shared_ptr< WValueSet< int16_t > > v = boost::shared_dynamic_cast< WValueSet< int16_t > >( m_dataSet->getValueSet() );
 
343
            WAssert( v, "" );
 
344
            for( std::size_t k = 0; k < grid->size(); ++k )
 
345
            {
 
346
                ( *values )[k] =  v->rawData()[ dim * k + i ];
 
347
            }
 
348
 
 
349
            boost::shared_ptr< WValueSet< int16_t > > vs =
 
350
                    boost::shared_ptr< WValueSet< int16_t > >( new WValueSet< int16_t >( 0, 1, values, W_DT_INT16 ) );
 
351
 
 
352
            return boost::shared_ptr< WDataSetScalar >( new WDataSetScalar( vs, grid ) );
 
353
        }
 
354
    case W_DT_SIGNED_INT:
 
355
        {
 
356
            boost::shared_ptr< std::vector< int32_t > > values = boost::shared_ptr< std::vector< int32_t > >(
 
357
                new std::vector< int32_t >( m_dataSet->getGrid()->size() ) );
 
358
            boost::shared_ptr< WValueSet< int32_t > > v = boost::shared_dynamic_cast< WValueSet< int32_t > >( m_dataSet->getValueSet() );
 
359
            WAssert( v, "" );
 
360
            for( std::size_t k = 0; k < grid->size(); ++k )
 
361
            {
 
362
                ( *values )[k] = v->rawData()[ dim * k + i ];
 
363
            }
 
364
 
 
365
            boost::shared_ptr< WValueSet< int32_t > > vs =
 
366
                    boost::shared_ptr< WValueSet< int32_t > >( new WValueSet< int32_t >( 0, 1, values, W_DT_SIGNED_INT ) );
 
367
 
 
368
            return boost::shared_ptr< WDataSetScalar >( new WDataSetScalar( vs, grid ) );
 
369
        }
 
370
    default:
 
371
        warnLog() << "Encountered unsupported data format in ImageExtractor!";
 
372
        return boost::shared_ptr< WDataSetScalar >();
 
373
    }
 
374
}
 
375
 
 
376
const std::string WMImageExtractor::makeImageName( std::size_t i )
 
377
{
 
378
    std::stringstream s;
 
379
    WAssert( m_dataSet, "" );
 
380
    WAssert( m_dataSet->getValueSet(), "" );
 
381
 
 
382
    s << m_dataSet->getFilename() << " (" << i << " of " << m_dataSet->getValueSet()->dimension() << ")";
 
383
    return s.str();
 
384
}
 
385
 
 
386
void WMImageExtractor::setOutputProps()
 
387
{
 
388
    if( m_outData )
 
389
    {
 
390
        double min = m_outData->getMin();
 
391
        double max = m_outData->getMax();
 
392
        float fmin = static_cast< float >( min + ( max - min ) * m_minValuePct->get( true ) * 0.01 );
 
393
        float fmax = static_cast< float >( min + ( max - min ) * m_maxValuePct->get( true ) * 0.01 );
 
394
 
 
395
        m_outData->getTexture()->minimum()->set( fmin );
 
396
        m_outData->getTexture()->scale()->set( std::max( fmax, fmin + 1.0f ) - fmin );
 
397
    }
 
398
}