void operator()( const range_t& r ) {
count_t end = r.end();
volatile count_t anchor = 0;
for( count_t i = r.begin(); i < end; ++i )
anchor += i;
my_sum = anchor;
}
bool additive_noise(
const range_t<tscalar>& noise_range,
const gauss_kernel_t<tscalar>& kernel,
const range_t<tscalar>& output_range,
tmatrix& src, tgetter getter, tsetter setter)
{
random_t<tscalar> noiser(noise_range.min(), noise_range.max());
// create random noise map
typename tensor::matrix_types_t<tscalar>::tmatrix noisemap(src.rows(), src.cols());
tensor::transform(noisemap, noisemap, [&] (tvalue) { return noiser(); });
// smooth the noise map
inplace_separable_filter(kernel, range_t<tscalar>(noiser.min(), noiser.max()), noisemap,
[] (tscalar v) { return v; },
[] (tscalar, tscalar v) { return v; });
// add the noise map to the input matrix
tensor::transform(src, noisemap, src, [&] (tvalue value, tscalar noise)
{
return setter(value, math::cast<tvalue>(output_range.clamp(noise + getter(value))));
});
// OK
return true;
}
void run ( const range_t& r, Partitioner& p ) const {
count_t end = r.end();
if ( my_depth > 1 )
for ( count_t i = r.begin(); i < end; ++i )
tbb::parallel_for( range_t(0, IterRange, IterGrain), NestingForBody(my_depth - 1), p );
else
for ( count_t i = r.begin(); i < end; ++i )
tbb::parallel_for( range_t(0, IterRange, IterGrain), SimpleForBody(), p );
}
void operator()(const range_t& range) {
const size_t i_end = range.end();
if(!range.empty()) {
for(size_t i = range.begin(); i != i_end; ++i) {
if(closerToExtremum(points[i])) {
extrXPoint = points[i];
}
}
}
}
void operator()(const range_t& range) const {
util::rng the_rng(range.begin());
const size_t i_end = range.end();
size_t count = 0;
#if USECONCVEC
points.grow_to_at_least(i_end);
#else // Locked enlarge to a not thread-safe STD::VECTOR
grow_vector_to_at_least(pushBackMutex,points,i_end);
#endif // USECONCVEC
for(size_t i = range.begin(); i != i_end; ++i) {
points[i]=util::GenerateRNDPoint<double>(count,the_rng,util::rng::max_rand);
}
}
void Audio::paint(Painter& painter) {
const auto r = screen_rect();
constexpr int db_min = -96;
constexpr int db_max = 0;
constexpr int db_delta = db_max - db_min;
const range_t<int> x_rms_range { 0, r.width() - 1 };
const auto x_rms = x_rms_range.clip((rms_db_ - db_min) * r.width() / db_delta);
const range_t<int> x_max_range { x_rms + 1, r.width() };
const auto x_max = x_max_range.clip((max_db_ - db_min) * r.width() / db_delta);
const Rect r0 {
static_cast<ui::Coord>(r.left()), r.top(),
static_cast<ui::Dim>(x_rms), r.height()
};
painter.fill_rectangle(
r0,
Color::green()
);
const Rect r1 {
static_cast<ui::Coord>(r.left() + x_rms), r.top(),
1, r.height()
};
painter.fill_rectangle(
r1,
Color::black()
);
const Rect r2 {
static_cast<ui::Coord>(r.left() + x_rms + 1), r.top(),
static_cast<ui::Dim>(x_max - (x_rms + 1)), r.height()
};
painter.fill_rectangle(
r2,
Color::red()
);
const Rect r3 {
static_cast<ui::Coord>(r.left() + x_max), r.top(),
static_cast<ui::Dim>(r.width() - x_max), r.height()
};
painter.fill_rectangle(
r3,
Color::black()
);
}
void operator()(const range_t& range) const {
util::rng the_rng(range.begin());
const size_t i_end = range.end();
size_t count = 0, j = 0;
point_t tmp_vec[grainSize];
for(size_t i=range.begin(); i!=i_end; ++i) {
tmp_vec[j++] = util::GenerateRNDPoint<double>(count, the_rng, util::rng::max_rand);
}
//Here we have race condition. Elements being written to may be still under construction.
//For C++ 2003 it is workarounded by vector element type which default constructor does not touch memory,
//it being constructed on. See comments near default ctor of point class for more details.
//Strictly speaking it is UB.
//TODO: need to find more reliable/correct way
points.grow_to_at_least(range.end());
std::copy(tmp_vec, tmp_vec+j,points.begin()+range.begin());
}
void operator()(const range_t& range) {
const size_t i_end = range.end();
size_t j = 0;
double cp;
point_t tmp_vec[grainSize];
for(size_t i = range.begin(); i != i_end; ++i) {
if( (initialSet[i] != p1) && (initialSet[i] != p2) ) {
cp = util::cross_product(p1, p2, initialSet[i]);
if(cp>0) {
tmp_vec[j++] = initialSet[i];
if(cp>howFar) {
farPoint = initialSet[i];
howFar = cp;
}
}
}
}
appendVector(tmp_vec, j, reducedSet);
}
void operator()( const range_t& range ) {
const size_t i_end = range.end();
double cp;
for(size_t i=range.begin(); i!=i_end; ++i) {
if( (initialSet[i] != p1) && (initialSet[i] != p2) ) {
cp = util::cross_product(p1, p2, initialSet[i]);
if(cp>0) {
#if USECONCVEC
reducedSet.push_back(initialSet[i]);
#else // Locked push_back to a not thread-safe STD::VECTOR
{
mutex_t::scoped_lock lock(pushBackMutex);
reducedSet.push_back(initialSet[i]);
}
#endif // USECONCVEC
if(cp>howFar) {
farPoint = initialSet[i];
howFar = cp;
}
}
}
}
}
void operator()(const range_t& range) const {
util::rng the_rng(range.begin());
const size_t i_end = range.end();
size_t count = 0, j = 0;
point_t tmp_vec[grainSize];
for(size_t i=range.begin(); i!=i_end; ++i) {
tmp_vec[j++] = util::GenerateRNDPoint<double>(count,the_rng,util::rng::max_rand);
}
#if USECONCVEC
grow_vector_to_at_least(points,range.end());
#else // USE STD::VECTOR
grow_vector_to_at_least(insertMutex,points,range.end());
#endif // USECONCVEC
std::copy(tmp_vec, tmp_vec+j,points.begin()+range.begin());
}
void TracePlot::paintMid(QPainter &painter, QRect &rect, range_t<off_t> sampleRange)
{
int samplesPerColumn = sampleRange.length() / rect.width();
int samplesPerTile = tileWidth * samplesPerColumn;
off_t tileID = sampleRange.minimum / samplesPerTile;
off_t tileOffset = sampleRange.minimum % samplesPerTile; // Number of samples to skip from first image tile
int xOffset = tileOffset / samplesPerColumn; // Number of columns to skip from first image tile
// Paint first (possibly partial) tile
painter.drawPixmap(
QRect(rect.x(), rect.y(), tileWidth - xOffset, height()),
getTile(tileID++, samplesPerTile),
QRect(xOffset, 0, tileWidth - xOffset, height())
);
// Paint remaining tiles
for (int x = tileWidth - xOffset; x < rect.right(); x += tileWidth) {
painter.drawPixmap(
QRect(x, rect.y(), tileWidth, height()),
getTile(tileID++, samplesPerTile)
);
}
}
void TracePlot::drawTile(QString key, const QRect &rect, range_t<off_t> sampleRange)
{
QImage image(rect.size(), QImage::Format_ARGB32);
image.fill(Qt::transparent);
QPainter painter(&image);
painter.setRenderHint(QPainter::Antialiasing, true);
auto firstSample = sampleRange.minimum;
auto length = sampleRange.length();
// Is it a 2-channel (complex) trace?
if (auto src = dynamic_cast<SampleSource<std::complex<float>>*>(sampleSource.get())) {
auto samples = src->getSamples(firstSample, length);
if (samples == nullptr)
return;
painter.setPen(Qt::red);
plotTrace(painter, rect, reinterpret_cast<float*>(samples.get()), length, 2);
painter.setPen(Qt::blue);
plotTrace(painter, rect, reinterpret_cast<float*>(samples.get())+1, length, 2);
// Otherwise is it single channel?
} else if (auto src = dynamic_cast<SampleSource<float>*>(sampleSource.get())) {
auto samples = src->getSamples(firstSample, length);
if (samples == nullptr)
return;
painter.setPen(Qt::green);
plotTrace(painter, rect, samples.get(), length, 1);
} else {
throw std::runtime_error("TracePlot::paintMid: Unsupported source type");
}
emit imageReady(key, image);
}
void operator()( const range_t& r ) const {
count_t end = (r.end() + 1) * (r.end() + 1);
volatile count_t anchor = 0;
for( count_t i = r.begin() * r.begin(); i < end; ++i )
anchor += i;
}
bool inplace_separable_filter(const tkernel& kernel, const range_t<tscalar>& range,
tmatrix& src, tgetter getter, tsetter setter)
{
const int rows = static_cast<int>(src.rows());
const int cols = static_cast<int>(src.cols());
const int ksize = static_cast<int>(kernel.size());
const int krad = ksize / 2;
if (ksize != (2 * krad + 1))
{
return false;
}
std::vector<tscalar> buff(std::max(rows, cols));
// horizontal filter
for (int r = 0; r < rows; r ++)
{
for (int c = 0; c < cols; c ++)
{
buff[c] = math::cast<tscalar>(getter(src(r, c)));
}
for (int c = 0; c < cols; c ++)
{
tscalar v = 0;
for (int k = -krad; k <= krad; k ++)
{
const int cc = math::clamp(k + c, 0, cols - 1);
v += kernel[k + krad] * buff[cc];
}
src(r, c) = setter(src(r, c), math::cast<tvalue>(range.clamp(v)));
}
}
// vertical filter
for (int c = 0; c < cols; c ++)
{
for (int r = 0; r < rows; r ++)
{
buff[r] = math::cast<tscalar>(getter(src(r, c)));
}
for (int r = 0; r < rows; r ++)
{
tscalar v = 0;
for (int k = -krad; k <= krad; k ++)
{
const int rr = math::clamp(k + r, 0, rows - 1);
v += kernel[k + krad] * buff[rr];
}
src(r, c) = setter(src(r, c), math::cast<tvalue>(range.clamp(v)));
}
}
// OK
return true;
}
void RSSI::paint(Painter& painter) {
const auto r = screen_rect();
constexpr int rssi_sample_range = 256;
constexpr float rssi_voltage_min = 0.4;
constexpr float rssi_voltage_max = 2.2;
constexpr float adc_voltage_max = 3.3;
constexpr int raw_min = rssi_sample_range * rssi_voltage_min / adc_voltage_max;
constexpr int raw_max = rssi_sample_range * rssi_voltage_max / adc_voltage_max;
constexpr int raw_delta = raw_max - raw_min;
const range_t<int> x_avg_range { 0, r.width() - 1 };
const auto x_avg = x_avg_range.clip((avg_ - raw_min) * r.width() / raw_delta);
const range_t<int> x_min_range { 0, x_avg };
const auto x_min = x_min_range.clip((min_ - raw_min) * r.width() / raw_delta);
const range_t<int> x_max_range { x_avg + 1, r.width() };
const auto x_max = x_max_range.clip((max_ - raw_min) * r.width() / raw_delta);
const Rect r0 {
static_cast<ui::Coord>(r.left()), r.top(),
static_cast<ui::Dim>(x_min), r.height()
};
painter.fill_rectangle(
r0,
Color::blue()
);
const Rect r1 {
static_cast<ui::Coord>(r.left() + x_min), r.top(),
static_cast<ui::Dim>(x_avg - x_min), r.height()
};
painter.fill_rectangle(
r1,
Color::red()
);
const Rect r2 {
static_cast<ui::Coord>(r.left() + x_avg), r.top(),
1, r.height()
};
painter.fill_rectangle(
r2,
Color::white()
);
const Rect r3 {
static_cast<ui::Coord>(r.left() + x_avg + 1), r.top(),
static_cast<ui::Dim>(x_max - (x_avg + 1)), r.height()
};
painter.fill_rectangle(
r3,
Color::red()
);
const Rect r4 {
static_cast<ui::Coord>(r.left() + x_max), r.top(),
static_cast<ui::Dim>(r.width() - x_max), r.height()
};
painter.fill_rectangle(
r4,
Color::black()
);
if (pwmrssi_enabled) {
const range_t<int> pwmrssi_avg_range { 0, 96 };
const auto pwmrssi_avg = pwmrssi_avg_range.clip((avg_ - raw_min) * 96 / raw_delta);
baseband::set_pwmrssi(pwmrssi_avg, true);
}
}
