|
|
#ifndef SCIQLOP_DATASERIESMERGEHELPER_H
|
|
|
#define SCIQLOP_DATASERIESMERGEHELPER_H
|
|
|
|
|
|
template <int Dim>
|
|
|
class DataSeries;
|
|
|
|
|
|
namespace detail {
|
|
|
|
|
|
/**
|
|
|
* Scope that can be used for a merge operation
|
|
|
* @tparam FEnd the type of function that will be executed at the end of the scope
|
|
|
*/
|
|
|
template <typename FEnd>
|
|
|
struct MergeScope {
|
|
|
explicit MergeScope(FEnd end) : m_End{end} {}
|
|
|
virtual ~MergeScope() noexcept { m_End(); }
|
|
|
FEnd m_End;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Creates a scope for merge operation
|
|
|
* @tparam end the function executed at the end of the scope
|
|
|
*/
|
|
|
template <typename FEnd>
|
|
|
MergeScope<FEnd> scope(FEnd end)
|
|
|
{
|
|
|
return MergeScope<FEnd>{end};
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Enum used to position a data series relative to another during a merge operation
|
|
|
*/
|
|
|
enum class MergePosition { LOWER_THAN, GREATER_THAN, EQUAL, OVERLAP };
|
|
|
|
|
|
/**
|
|
|
* Computes the position of the first data series relative to the second data series
|
|
|
* @param lhs the first data series
|
|
|
* @param rhs the second data series
|
|
|
* @return the merge position computed
|
|
|
* @remarks the data series must not be empty
|
|
|
*/
|
|
|
template <int Dim>
|
|
|
MergePosition mergePosition(DataSeries<Dim> &lhs, DataSeries<Dim> &rhs)
|
|
|
{
|
|
|
Q_ASSERT(!lhs.isEmpty() && !rhs.isEmpty());
|
|
|
|
|
|
// Case lhs < rhs
|
|
|
auto lhsLast = --lhs.cend();
|
|
|
auto rhsFirst = rhs.cbegin();
|
|
|
if (lhsLast->x() < rhsFirst->x()) {
|
|
|
return MergePosition::LOWER_THAN;
|
|
|
}
|
|
|
|
|
|
// Case lhs > rhs
|
|
|
auto lhsFirst = lhs.cbegin();
|
|
|
auto rhsLast = --rhs.cend();
|
|
|
if (lhsFirst->x() > rhsLast->x()) {
|
|
|
return MergePosition::GREATER_THAN;
|
|
|
}
|
|
|
|
|
|
// Other cases
|
|
|
auto equal = std::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin(), rhs.cend(),
|
|
|
[](const auto &it1, const auto &it2) {
|
|
|
return it1.x() == it2.x() && it1.values() == it2.values();
|
|
|
});
|
|
|
return equal ? MergePosition::EQUAL : MergePosition::OVERLAP;
|
|
|
}
|
|
|
|
|
|
} // namespace detail
|
|
|
|
|
|
|
|
|
/// Helper used to merge two DataSeries
|
|
|
/// @sa DataSeries
|
|
|
struct DataSeriesMergeHelper {
|
|
|
/// Merges the source data series into the dest data series. Data of the source data series are
|
|
|
/// consumed
|
|
|
template <int Dim>
|
|
|
static void merge(DataSeries<Dim> &source, DataSeries<Dim> &dest)
|
|
|
{
|
|
|
// Creates a scope to clear source data series at the end of the merge
|
|
|
auto _ = detail::scope([&source]() { source.clear(); });
|
|
|
|
|
|
// Case : source data series is empty -> no merge is made
|
|
|
if (source.isEmpty()) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// Case : dest data series is empty -> we simply swap the data
|
|
|
if (dest.isEmpty()) {
|
|
|
std::swap(dest.m_XAxisData, source.m_XAxisData);
|
|
|
std::swap(dest.m_ValuesData, source.m_ValuesData);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// Gets the position of the source in relation to the destination
|
|
|
auto sourcePosition = detail::mergePosition(source, dest);
|
|
|
|
|
|
switch (sourcePosition) {
|
|
|
case detail::MergePosition::LOWER_THAN:
|
|
|
case detail::MergePosition::GREATER_THAN: {
|
|
|
auto prepend = sourcePosition == detail::MergePosition::LOWER_THAN;
|
|
|
dest.m_XAxisData->add(*source.m_XAxisData, prepend);
|
|
|
dest.m_ValuesData->add(*source.m_ValuesData, prepend);
|
|
|
break;
|
|
|
}
|
|
|
case detail::MergePosition::EQUAL:
|
|
|
// the data series equal each other : no merge made
|
|
|
break;
|
|
|
case detail::MergePosition::OVERLAP: {
|
|
|
// the two data series overlap : merge is made
|
|
|
auto temp = dest.clone();
|
|
|
if (auto tempSeries = dynamic_cast<DataSeries<Dim> *>(temp.get())) {
|
|
|
// Makes the merge :
|
|
|
// - Data are sorted by x-axis values
|
|
|
// - If two entries are in the source range and the other range, only one entry
|
|
|
// is retained as result
|
|
|
// - The results are stored directly in the data series
|
|
|
dest.clear();
|
|
|
std::set_union(
|
|
|
tempSeries->cbegin(), tempSeries->cend(), source.cbegin(), source.cend(),
|
|
|
std::back_inserter(dest),
|
|
|
[](const auto &it1, const auto &it2) { return it1.x() < it2.x(); });
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
default:
|
|
|
Q_ASSERT(false);
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
#endif // SCIQLOP_DATASERIESMERGEHELPER_H
|
|
|
|
