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
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
|
/*
* 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
*
*
* Sieve.C
*
* Implementation of class Sieve.
*
* Lippold Haken, 20 Jan 2001
* loris@cerlsoundgroup.org
*
* http://www.cerlsoundgroup.org/Loris/
*
*/
#if HAVE_CONFIG_H
#include "config.h"
#endif
#include "Sieve.h"
#include "Breakpoint.h"
#include "LorisExceptions.h"
#include "Notifier.h"
#include "Partial.h"
#include "PartialList.h"
#include "PartialUtils.h"
#include <algorithm>
// begin namespace
namespace Loris {
// ---------------------------------------------------------------------------
// Sieve constructor
// ---------------------------------------------------------------------------
//! Construct a new Sieve using the specified partial fade
//! time. If unspecified, the default fade time (same as the
//! default fade time for the Distiller) is used.
//!
//! \param partialFadeTime is the extra time (in seconds)
//! added to each end of a Partial to accomodate
//! the fade to and from zero amplitude. Fade time
//! must be non-negative. A default value is used
//! if unspecified.
//! \throw InvalidArgument if partialFadeTime is negative.
//
Sieve::Sieve( double partialFadeTime ) :
_fadeTime( partialFadeTime )
{
if ( _fadeTime < 0.0 )
{
Throw( InvalidArgument, "the Partial fade time must be non-negative" );
}
}
// Definition of a comparitor for sorting a collection of pointers
// to Partials by label (increasing) and duration (decreasing), so
// that Partial ptrs are arranged by label, with the lowest labels
// first, and then with the longest Partials having each label
// before the shorter ones.
struct SortPartialPtrs :
public std::binary_function< const Partial *, const Partial *, bool >
{
bool operator()( const Partial * lhs, const Partial * rhs ) const
{
return ( lhs->label() != rhs->label() ) ?
( lhs->label() < rhs->label() ) :
( lhs->duration() > rhs->duration() );
}
};
// Definition of predicate for finding the end of a Patial *
// range having a common label.
struct PartialPtrLabelNE :
public std::unary_function< const Partial *, bool >
{
int label;
PartialPtrLabelNE( int l ) : label(l) {}
bool operator()( const Partial * p ) const
{ return p->label() != label; }
};
// ---------------------------------------------------------------------------
// find_overlapping (template function)
// ---------------------------------------------------------------------------
// Iterate over a range of Partials (presumably) with same labeling.
// The range is specified by iterators over a collection of pointers
// to Partials (not Partials themselves). Return the first position
// in the specified range corresponding to a Partial that overlaps
// (in time) the specified Partial, p, or the end of the range if
// no Partials in the range overlap.
//
// Overlap is defined by the minimum time gap between Partials
// (minGapTime), so Partials that have less then minGapTime
// between them are considered overlapping.
//
template <typename Iter> // Iter is the position of a Partial *
Iter
find_overlapping( Partial & p, double minGapTime, Iter start, Iter end)
{
for ( Iter it = start; it != end; ++it )
{
// skip if other partial is already sifted out.
if ( (*it)->label() == 0 )
continue;
// skip the source Partial:
// (identity test: compare addresses)
// (this is a sanity check, should not happen since
// src should be at position end)
Assert( (*it) != &p );
// test for overlap:
if ( p.startTime() < (*it)->endTime() + minGapTime &&
p.endTime() + minGapTime > (*it)->startTime() )
{
// Does the overlapping Partial have longer duration?
// (this should never be true, since the Partials
// are sorted by duration)
Assert( p.duration() <= (*it)->duration() );
#if Debug_Loris
debugger << "Partial starting " << p.startTime() << ", "
<< p.begin().breakpoint().frequency() << " ending "
<< p.endTime() << ", " << (--p.end()).breakpoint().frequency()
<< " zapped by overlapping Partial starting "
<< (*it)->startTime() << ", " << (*it)->begin().breakpoint().frequency()
<< " ending " << (*it)->endTime() << ", "
<< (--(*it)->end()).breakpoint().frequency() << endl;
#endif
return it;
}
}
// no overlapping Partial found:
return end;
}
// ---------------------------------------------------------------------------
// sift_ptrs (private helper)
// ---------------------------------------------------------------------------
//! Sift labeled Partials. If any two Partials having the same (non-zero)
//! label overlap in time (where overlap includes the fade time at both
//! ends of each Partial), then set the label of the Partial having the
//! shorter duration to zero. Sifting is performed on a collection of
//! pointers to Partials so that the it can be performed without changing
//! the order of the Partials in the sequence.
//!
//! \param ptrs is a collection of pointers to the Partials in the
//! sequence to be sifted.
void
Sieve::sift_ptrs( PartialPtrs & ptrs )
{
// the minimum gap between Partials is twice the
// specified fadeTime:
double minGapTime = _fadeTime * 2.;
// sort the collection of pointers to Partials:
// (sort is by increasing label, then
// decreasing duration)
std::sort( ptrs.begin(), ptrs.end(), SortPartialPtrs() );
PartialPtrs::iterator sift_begin = ptrs.begin();
PartialPtrs::iterator sift_end = ptrs.end();
int zapped = 0;
// iterate over labels and sift each one:
PartialPtrs::iterator lowerbound = sift_begin;
while ( lowerbound != sift_end )
{
int label = (*lowerbound)->label();
// first the first element in l after sieve_begin
// having a label not equal to 'label':
PartialPtrs::iterator upperbound =
std::find_if( lowerbound, sift_end, PartialPtrLabelNE(label) );
#ifdef Debug_Loris
// don't want to compute this iterator distance unless debugging:
debugger << "sifting Partials labeled " << label << endl;
debugger << "Sieve found " << std::distance( lowerbound, upperbound ) <<
" Partials labeled " << label << endl;
#endif
// sift all partials with this label, unless the
// label is 0:
if ( label != 0 )
{
PartialPtrs::iterator it;
for ( it = lowerbound; it != upperbound; ++it )
{
// find_overlapping only needs to consider Partials on the
// half-open range [lowerbound, it), because all
// Partials after it are shorter, thanks to the
// sorting of the sift_set:
if( it != find_overlapping( **it, minGapTime, lowerbound, it ) )
{
(*it)->setLabel(0);
++zapped;
}
}
}
// advance Partial set iterator:
lowerbound = upperbound;
}
#ifdef Debug_Loris
debugger << "Sifted out (relabeled) " << zapped << " of " << ptrs.size() << "." << endl;
#endif
}
} // end of namespace Loris
|