← Back to branch summary

~siretart/ubuntu/utopic/blender/libav10

« back to all changes in this revision

Viewing changes to extern/eltopo/common/runstats.cpp

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2012-07-23 08:54:18 UTC
  • mfrom: (14.2.16 sid)
  • mto: (14.2.19 sid)
  • mto: This revision was merged to the branch mainline in revision 42.
  • Revision ID: package-import@ubuntu.com-20120723085418-9foz30v6afaf5ffs
Tags: 2.63a-2
http://bugs.debian.org/658075
* debian/: Cycles support added (Closes: #658075)
  For now, this top feature has been enabled only
  on [any-amd64 any-i386] architectures because
  of OpenImageIO failing on all others
* debian/: scripts installation path changed
  from /usr/lib to /usr/share:
  + debian/patches/: patchset re-worked for path changing
  + debian/control: "Breaks" field added on yafaray-exporter

Show diffs side-by-side

added added

removed removed

Lines of Context:
extern/eltopo/common/runstats.cpp
 
1
/*
 
2
 *  runstats.cpp
 
3
 *  eltopo3d_project
 
4
 *
 
5
 *  Created by tyson on 21/04/11.
 
6
 *
 
7
 */
 
8
 
 
9
#include <runstats.h>
 
10
 
 
11
#include <commonoptions.h>
 
12
#include <fstream>
 
13
 
 
14
// ------------------------------------------------------------------
 
15
 
 
16
void RunStats::set_int( std::string name, int64_t value )
 
17
{
 
18
    int_stats[name] = value;
 
19
}
 
20
 
 
21
void RunStats::add_to_int( std::string name, int64_t increment )
 
22
{
 
23
    int64_t value = 0;
 
24
    bool exists = get_int( name, value );
 
25
    if ( !exists )
 
26
    {
 
27
        value = 0;
 
28
    }
 
29
    value += increment;
 
30
    set_int( name, value );
 
31
}
 
32
 
 
33
int64_t RunStats::get_int( std::string name )
 
34
{
 
35
    std::map<std::string, int64_t>::iterator iter = int_stats.find( name );
 
36
    if (  iter == int_stats.end() ) { return ~0; }
 
37
    return iter->second;
 
38
}
 
39
 
 
40
bool RunStats::get_int( std::string name, int64_t& value )
 
41
{
 
42
    std::map<std::string, int64_t>::iterator iter = int_stats.find( name );
 
43
    if ( iter == int_stats.end() )
 
44
    {
 
45
        return false;
 
46
    }
 
47
    value = iter->second;
 
48
    return true;  
 
49
}
 
50
 
 
51
void RunStats::update_min_int( std::string name, int64_t value )
 
52
{
 
53
    int64_t current_min;
 
54
    bool exists = get_int( name, current_min );
 
55
    if ( !exists ) { current_min = value; }
 
56
    int_stats[name] = std::min( value, current_min );
 
57
}
 
58
 
 
59
void RunStats::update_max_int( std::string name, int64_t value )
 
60
{
 
61
    int64_t current_max;
 
62
    bool exists = get_int( name, current_max );
 
63
    if ( !exists ) { current_max = value; }
 
64
    int_stats[name] = std::max( value, current_max );
 
65
}
 
66
 
 
67
// ------------------------------------------------------------------
 
68
 
 
69
void RunStats::set_double( std::string name, double value )
 
70
{
 
71
    double_stats[name] = value;
 
72
}
 
73
 
 
74
void RunStats::add_to_double( std::string name, double increment )
 
75
{
 
76
    double value = 0;
 
77
    bool exists = get_double( name, value );
 
78
    if ( !exists )
 
79
    {
 
80
        value = 0;
 
81
    }
 
82
    value += increment;
 
83
    set_double( name, value );
 
84
}
 
85
 
 
86
double RunStats::get_double( std::string name )
 
87
{
 
88
    std::map<std::string, double>::iterator iter = double_stats.find( name );
 
89
    if ( iter == double_stats.end() ) { return UNINITIALIZED_DOUBLE; }
 
90
    return iter->second;
 
91
}
 
92
 
 
93
bool RunStats::get_double( std::string name, double& value )
 
94
{
 
95
    std::map<std::string, double>::iterator iter = double_stats.find( name );
 
96
    if ( iter == double_stats.end() )
 
97
    {
 
98
        return false;
 
99
    }
 
100
    value = iter->second;
 
101
    return true;     
 
102
}
 
103
 
 
104
void RunStats::update_min_double( std::string name, double value )
 
105
{
 
106
    double current_min;
 
107
    bool exists = get_double( name, current_min );
 
108
    if ( !exists ) { current_min = value; }
 
109
    double_stats[name] = std::min( value, current_min );
 
110
}
 
111
 
 
112
void RunStats::update_max_double( std::string name, double value )
 
113
{
 
114
    double current_max;
 
115
    bool exists = get_double( name, current_max );
 
116
    if ( !exists ) { current_max = value; }
 
117
    double_stats[name] = std::max( value, current_max );
 
118
}
 
119
 
 
120
// ------------------------------------------------------------------
 
121
 
 
122
void RunStats::add_per_frame_int( std::string name, int frame, int64_t value )
 
123
{
 
124
    std::vector<PerFrameInt>& sequence = per_frame_int_stats[name];
 
125
    sequence.push_back( PerFrameInt(frame,value) );
 
126
}
 
127
 
 
128
bool RunStats::get_per_frame_ints( std::string name, std::vector<PerFrameInt>& sequence )
 
129
{
 
130
    std::map<std::string, std::vector<PerFrameInt> >::iterator iter = per_frame_int_stats.find( name );
 
131
    if ( iter == per_frame_int_stats.end() )
 
132
    {
 
133
        return false;
 
134
    }
 
135
    sequence = iter->second;
 
136
    return true;  
 
137
}
 
138
 
 
139
// ------------------------------------------------------------------
 
140
 
 
141
void RunStats::add_per_frame_double( std::string name, int frame, double value )
 
142
{
 
143
    std::vector<PerFrameDouble>& sequence = per_frame_double_stats[name];
 
144
    sequence.push_back( PerFrameDouble(frame,value) );
 
145
}
 
146
 
 
147
bool RunStats::get_per_frame_doubles( std::string name, std::vector<PerFrameDouble>& sequence )
 
148
{
 
149
    std::map<std::string, std::vector<PerFrameDouble> >::iterator iter = per_frame_double_stats.find( name );
 
150
    if ( iter == per_frame_double_stats.end() )
 
151
    {
 
152
        return false;
 
153
    }
 
154
    sequence = iter->second;
 
155
    return true;  
 
156
}
 
157
 
 
158
// ------------------------------------------------------------------
 
159
 
 
160
void RunStats::write_to_file( const char* filename )
 
161
{
 
162
    std::ofstream file( filename );
 
163
    
 
164
    // ----------
 
165
    if ( !int_stats.empty() )
 
166
    {
 
167
        file << "int_stats: " << std::endl << "----------" << std::endl;
 
168
        std::map<std::string, int64_t>::iterator int_iterator = int_stats.begin();
 
169
        for ( ; int_iterator != int_stats.end(); ++int_iterator )
 
170
        {
 
171
            file << int_iterator->first << ": " << int_iterator->second << std::endl;
 
172
        }   
 
173
        file << std::endl;
 
174
    }
 
175
    
 
176
    // ----------
 
177
    
 
178
    if ( !double_stats.empty() )
 
179
    {
 
180
        file << "double_stats: " << std::endl << "----------" << std::endl;
 
181
        std::map<std::string, double>::iterator double_iterator = double_stats.begin();
 
182
        for ( ; double_iterator != double_stats.end(); ++double_iterator )
 
183
        {
 
184
            file << double_iterator->first << ": " << double_iterator->second << std::endl;
 
185
        }
 
186
        file << std::endl;
 
187
    }
 
188
    
 
189
    // ----------
 
190
    
 
191
    if ( !per_frame_int_stats.empty() )
 
192
    {
 
193
        file << "per_frame_int_stats: " << std::endl << "----------" << std::endl;
 
194
        std::map<std::string, std::vector<PerFrameInt> >::iterator pfi_iter = per_frame_int_stats.begin();
 
195
        for ( ; pfi_iter != per_frame_int_stats.end(); ++pfi_iter )
 
196
        {
 
197
            file << pfi_iter->first << ": " << std::endl;
 
198
            std::vector<PerFrameInt>& sequence = pfi_iter->second;
 
199
            for ( unsigned int i = 0; i < sequence.size(); ++i )
 
200
            {
 
201
                file << sequence[i].first << " " << sequence[i].second << std::endl;
 
202
            }
 
203
        }
 
204
        file << std::endl;
 
205
    }   
 
206
    
 
207
    // ----------
 
208
    
 
209
    if ( !per_frame_double_stats.empty() )
 
210
    {
 
211
        file << "per_frame_double_stats: " << std::endl << "----------" << std::endl;
 
212
        std::map<std::string, std::vector<PerFrameDouble> >::iterator pfd_iter = per_frame_double_stats.begin();
 
213
        for ( ; pfd_iter != per_frame_double_stats.end(); ++pfd_iter )
 
214
        {
 
215
            file << pfd_iter->first << ": " << std::endl;
 
216
            std::vector<PerFrameDouble>& sequence = pfd_iter->second;
 
217
            for ( unsigned int i = 0; i < sequence.size(); ++i )
 
218
            {
 
219
                file << sequence[i].first << " " << sequence[i].second << std::endl;
 
220
            }
 
221
        }
 
222
        file << std::endl;      
 
223
    }
 
224
    
 
225
}
 
226
 
 
227
// ------------------------------------------------------------------
 
228
 
 
229
void RunStats::clear()
 
230
{
 
231
    int_stats.clear();
 
232
    double_stats.clear();
 
233
    per_frame_int_stats.clear();
 
234
    per_frame_double_stats.clear();
 
235
}
 
236
 
 
237
 
 
238
 
 
239