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
|
/* -*- Mode: c++ -*- */
/***************************************************************************
* position_power.cc
*
* Wed Jul 24 15:05:27 CEST 2024
* Copyright 2024 Bent Bisballe Nyeng
* deva@aasimon.org
****************************************************************************/
/*
* This file is part of DrumGizmo.
*
* DrumGizmo is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* DrumGizmo 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with DrumGizmo; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
*/
#include "position_power.h"
#include "sample.h"
#include "instrument.h"
#include <set>
#include <algorithm>
Instrument::PowerRange positionPower(const std::vector<Sample*>& samplelist, double position)
{
if(samplelist.empty())
{
return {0.0, 1.0};
}
struct PosPower
{
double position;
double power;
Sample* sample;
};
auto dist_cmp =
[position](const PosPower& a, const PosPower& b)
{
auto position_delta =
std::abs(a.position - position) - std::abs(b.position - position);
if(position_delta != 0)
{
return position_delta < 0.0;
}
return a.sample < b.sample;
};
std::set<PosPower, decltype(dist_cmp)> sorted_samples(dist_cmp);
std::for_each(samplelist.begin(), samplelist.end(),
[&](Sample* s)
{
sorted_samples.insert({s->getPosition(), s->getPower(), s});
});
// Find the smallest, closest set in terms of delta-position against the note position
// and find the contained power range.
double power_min{std::numeric_limits<double>::max()};
double power_max{std::numeric_limits<double>::min()};
auto sample_iter = sorted_samples.begin();
auto final_position_boundary = sample_iter->position;
for(std::size_t i = 0; i < std::max(sorted_samples.size() / 4, std::size_t(1)); ++i)
{
auto power = sample_iter->power;
final_position_boundary = sample_iter->position;
power_min = std::min(power_min, power);
power_max = std::max(power_max, power);
++sample_iter;
}
// Include upcoming samples from the list as long as their distances are contained in
// the final position range.
while(sample_iter != sorted_samples.end())
{
if(sample_iter->position != final_position_boundary)
{
// Position has left the range - and since the list is sorted; stop.
break;
}
auto power = sample_iter->power;
power_min = std::min(power_min, power);
power_max = std::max(power_max, power);
++sample_iter;
}
return {power_min, power_max};
}
|
