1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
/*
* This is the Loris C++ Class Library, implementing analysis,
* manipulation, and synthesis of digitized sounds using the Reassigned
* Bandwidth-Enhanced Additive Sound Model.
*
* Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY, without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*
* LinearEnvelope.C
*
* Implementation of class LinearEnvelope.
*
* Kelly Fitz, 23 April 2005
* loris@cerlsoundgroup.org
*
* http://www.cerlsoundgroup.org/Loris/
*
*/
#if HAVE_CONFIG_H
#include "config.h"
#endif
#include "LinearEnvelope.h"
// begin namespace
namespace Loris {
// ---------------------------------------------------------------------------
// constructor
// ---------------------------------------------------------------------------
//! Construct a new LinearEnvelope having no
//! breakpoints (and an implicit value of 0 everywhere).
//
LinearEnvelope::LinearEnvelope( void )
{
}
// ---------------------------------------------------------------------------
// constructor with initial (or constant) value
// ---------------------------------------------------------------------------
//! Construct and return a new LinearEnvelope having a
//! single breakpoint at 0 (and an implicit value everywhere)
//! of initialValue.
//!
//! \param initialValue is the value of this LinearEnvelope
//! at time 0.
//
LinearEnvelope::LinearEnvelope( double initialValue )
{
insertBreakpoint( 0., initialValue );
}
// ---------------------------------------------------------------------------
// clone
// ---------------------------------------------------------------------------
//! Return an exact copy of this LinearEnvelope
//! (polymorphic copy, following the Prototype pattern).
//
LinearEnvelope *
LinearEnvelope::clone( void ) const
{
return new LinearEnvelope( *this );
}
// ---------------------------------------------------------------------------
// insert
// ---------------------------------------------------------------------------
//! Insert a breakpoint representing the specified (time, value)
//! pair into this LinearEnvelope. If there is already a
//! breakpoint at the specified time, it will be replaced with
//! the new breakpoint.
//!
//! \param time is the time at which to insert a new breakpoint
//! \param value is the value of the new breakpoint
//
void
LinearEnvelope::insert( double time, double value )
{
(*this)[time] = value;
}
// ---------------------------------------------------------------------------
// operator+=
// ---------------------------------------------------------------------------
//! Add a constant value to this LinearEnvelope and return a reference
//! to self.
//!
//! \param offset is the value to add to all points in the envelope
LinearEnvelope & LinearEnvelope::operator+=( double offset )
{
for ( iterator it = begin(); it != end(); ++it )
{
it->second += offset;
}
return *this;
}
// ---------------------------------------------------------------------------
// operator*=
// ---------------------------------------------------------------------------
//! Scale this LinearEnvelope by a constant value and return a reference
//! to self.
//!
//! \param scale is the value by which to multiply to all points in
//! the envelope
LinearEnvelope & LinearEnvelope::operator*=( double scale )
{
for ( iterator it = begin(); it != end(); ++it )
{
it->second *= scale;
}
return *this;
}
// ---------------------------------------------------------------------------
// operator/ (non-member binary operator)
// ---------------------------------------------------------------------------
//! Divide constant value by a LinearEnvelope and return a new
//! LinearEnvelope. No shortcut implementation for this one,
//! don't inline.
LinearEnvelope operator/( double num, LinearEnvelope env )
{
for ( LinearEnvelope::iterator it = env.begin(); it != env.end(); ++it )
{
it->second = num / it->second;
}
return env;
}
// ---------------------------------------------------------------------------
// valueAt
// ---------------------------------------------------------------------------
//! Return the linearly-interpolated value of this LinearEnvelope at
//! the specified time.
//!
//! \param t is the time at which to evaluate this LinearEnvelope.
//
double
LinearEnvelope::valueAt( double t ) const
{
// return zero if no breakpoints have been specified:
if ( size() == 0 )
{
return 0.;
}
const_iterator it = lower_bound( t );
if ( it == begin() )
{
// t is less than the first breakpoint, extend:
return it->second;
}
else if ( it == end() )
{
// t is greater than the last breakpoint, extend:
// (no direct way to access the last element of a map)
return (--it)->second;
}
else
{
// linear interpolation between consecutive breakpoints:
double xgreater = it->first;
double ygreater = it->second;
--it;
double xless = it->first;
double yless = it->second;
double alpha = (t - xless) / (xgreater - xless);
return ( alpha * ygreater ) + ( (1. - alpha) * yless );
}
}
} // end of namespace Loris
|