Refactoring
* Rewriting Timeline<T> to be sparse, i.e., allow gaps * Added specialized subclasses BoundedTimeline<T> and ContinuousTimeline<T> * Timed<T> and TimeRange: has-a, not is-a * Introducing Timed<void>
This commit is contained in:
parent
9eef09145e
commit
2f31c5aa61
|
@ -118,6 +118,8 @@ set(SOURCE_FILES
|
|||
src/Timed.h
|
||||
src/TimeRange.cpp src/TimeRange.h
|
||||
src/Timeline.h
|
||||
src/BoundedTimeline.h
|
||||
src/ContinuousTimeline.h
|
||||
src/pairs.h
|
||||
src/Exporter.cpp src/Exporter.h
|
||||
)
|
||||
|
@ -130,6 +132,8 @@ target_compile_options(rhubarb PUBLIC ${enableWarningsFlags})
|
|||
set(TEST_FILES
|
||||
tests/stringToolsTests.cpp
|
||||
tests/TimelineTests.cpp
|
||||
tests/BoundedTimelineTests.cpp
|
||||
tests/ContinuousTimelineTests.cpp
|
||||
tests/pairsTests.cpp
|
||||
src/stringTools.cpp src/stringTools.h
|
||||
src/Timeline.h
|
||||
|
|
|
@ -0,0 +1,66 @@
|
|||
#pragma once
|
||||
|
||||
#include "Timeline.h"
|
||||
|
||||
template<typename T>
|
||||
class BoundedTimeline : public Timeline<T> {
|
||||
using Timeline<T>::time_type;
|
||||
using Timeline<T>::equals;
|
||||
|
||||
public:
|
||||
using Timeline<T>::iterator;
|
||||
using Timeline<T>::end;
|
||||
|
||||
explicit BoundedTimeline(TimeRange range) :
|
||||
range(range)
|
||||
{}
|
||||
|
||||
template<typename InputIterator>
|
||||
BoundedTimeline(TimeRange range, InputIterator first, InputIterator last) :
|
||||
range(range)
|
||||
{
|
||||
for (auto it = first; it != last; ++it) {
|
||||
// Virtual function call in constructor. Derived constructors shouldn't call this one!
|
||||
BoundedTimeline<T>::set(*it);
|
||||
}
|
||||
}
|
||||
|
||||
BoundedTimeline(TimeRange range, std::initializer_list<Timed<T>> initializerList) :
|
||||
BoundedTimeline(range, initializerList.begin(), initializerList.end())
|
||||
{}
|
||||
|
||||
TimeRange getRange() const override {
|
||||
return range;
|
||||
}
|
||||
|
||||
using Timeline<T>::set;
|
||||
|
||||
iterator set(Timed<T> timedValue) override {
|
||||
// Exit if the value's range is completely out of bounds
|
||||
if (timedValue.getEnd() <= range.getStart() || timedValue.getStart() >= range.getEnd()) {
|
||||
return end();
|
||||
}
|
||||
|
||||
// Clip the value's range to bounds
|
||||
TimeRange& valueRange = timedValue.getTimeRange();
|
||||
valueRange.resize(max(range.getStart(), valueRange.getStart()), min(range.getEnd(), valueRange.getEnd()));
|
||||
|
||||
return Timeline<T>::set(timedValue);
|
||||
}
|
||||
|
||||
void shift(time_type offset) override {
|
||||
Timeline<T>::shift(offset);
|
||||
range.shift(offset);
|
||||
}
|
||||
|
||||
bool operator==(const BoundedTimeline& rhs) const {
|
||||
return Timeline<T>::equals(rhs) && range == rhs.range;
|
||||
}
|
||||
|
||||
bool operator!=(const BoundedTimeline& rhs) const {
|
||||
return !operator==(rhs);
|
||||
}
|
||||
|
||||
private:
|
||||
TimeRange range;
|
||||
};
|
|
@ -0,0 +1,39 @@
|
|||
#pragma once
|
||||
|
||||
#include "BoundedTimeline.h"
|
||||
|
||||
template<typename T>
|
||||
class ContinuousTimeline : public BoundedTimeline<T> {
|
||||
|
||||
public:
|
||||
ContinuousTimeline(TimeRange range, T defaultValue) :
|
||||
BoundedTimeline(range),
|
||||
defaultValue(defaultValue)
|
||||
{
|
||||
// Virtual function call in constructor. Derived constructors shouldn't call this one!
|
||||
ContinuousTimeline<T>::clear(range);
|
||||
}
|
||||
|
||||
template<typename InputIterator>
|
||||
ContinuousTimeline(TimeRange range, T defaultValue, InputIterator first, InputIterator last) :
|
||||
ContinuousTimeline(range, defaultValue)
|
||||
{
|
||||
// Virtual function calls in constructor. Derived constructors shouldn't call this one!
|
||||
for (auto it = first; it != last; ++it) {
|
||||
ContinuousTimeline<T>::set(*it);
|
||||
}
|
||||
}
|
||||
|
||||
ContinuousTimeline(TimeRange range, T defaultValue, std::initializer_list<Timed<T>> initializerList) :
|
||||
ContinuousTimeline(range, defaultValue, initializerList.begin(), initializerList.end())
|
||||
{}
|
||||
|
||||
using BoundedTimeline<T>::clear;
|
||||
|
||||
void clear(const TimeRange& range) override {
|
||||
set(Timed<T>(range, defaultValue));
|
||||
}
|
||||
|
||||
private:
|
||||
T defaultValue;
|
||||
};
|
|
@ -1,5 +1,4 @@
|
|||
#include "Exporter.h"
|
||||
#include <logging.h>
|
||||
#include <boost/property_tree/ptree.hpp>
|
||||
#include <boost/property_tree/xml_parser.hpp>
|
||||
#include <tools.h>
|
||||
|
@ -43,7 +42,7 @@ std::vector<Timed<Shape>> dummyShapeIfEmpty(const Timeline<Shape>& shapes) {
|
|||
return result;
|
||||
}
|
||||
|
||||
void TSVExporter::exportShapes(const boost::filesystem::path& inputFilePath, const Timeline<Shape>& shapes, std::ostream& outputStream) {
|
||||
void TSVExporter::exportShapes(const boost::filesystem::path& inputFilePath, const ContinuousTimeline<Shape>& shapes, std::ostream& outputStream) {
|
||||
UNUSED(inputFilePath);
|
||||
|
||||
// Output shapes with start times
|
||||
|
@ -55,7 +54,7 @@ void TSVExporter::exportShapes(const boost::filesystem::path& inputFilePath, con
|
|||
outputStream << formatDuration(shapes.getRange().getEnd()) << "\t" << Shape::A << "\n";
|
||||
}
|
||||
|
||||
void XMLExporter::exportShapes(const boost::filesystem::path& inputFilePath, const Timeline<Shape>& shapes, std::ostream& outputStream) {
|
||||
void XMLExporter::exportShapes(const boost::filesystem::path& inputFilePath, const ContinuousTimeline<Shape>& shapes, std::ostream& outputStream) {
|
||||
ptree tree;
|
||||
|
||||
// Add metadata
|
||||
|
@ -94,7 +93,7 @@ string escapeJSONString(const string& s) {
|
|||
return result;
|
||||
}
|
||||
|
||||
void JSONExporter::exportShapes(const boost::filesystem::path& inputFilePath, const Timeline<Shape>& shapes, std::ostream& outputStream) {
|
||||
void JSONExporter::exportShapes(const boost::filesystem::path& inputFilePath, const ContinuousTimeline<Shape>& shapes, std::ostream& outputStream) {
|
||||
// Export as JSON.
|
||||
// I'm not using a library because the code is short enough without one and it lets me control the formatting.
|
||||
outputStream << "{\n";
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
#pragma once
|
||||
|
||||
#include <Shape.h>
|
||||
#include <Timeline.h>
|
||||
#include "ContinuousTimeline.h"
|
||||
#include <boost/filesystem/path.hpp>
|
||||
#include <iostream>
|
||||
|
||||
|
@ -26,20 +26,20 @@ std::istream& operator>>(std::istream& stream, ExportFormat& value);
|
|||
class Exporter {
|
||||
public:
|
||||
virtual ~Exporter() {}
|
||||
virtual void exportShapes(const boost::filesystem::path& inputFilePath, const Timeline<Shape>& shapes, std::ostream& outputStream) = 0;
|
||||
virtual void exportShapes(const boost::filesystem::path& inputFilePath, const ContinuousTimeline<Shape>& shapes, std::ostream& outputStream) = 0;
|
||||
};
|
||||
|
||||
class TSVExporter : public Exporter {
|
||||
public:
|
||||
void exportShapes(const boost::filesystem::path& inputFilePath, const Timeline<Shape>& shapes, std::ostream& outputStream) override;
|
||||
void exportShapes(const boost::filesystem::path& inputFilePath, const ContinuousTimeline<Shape>& shapes, std::ostream& outputStream) override;
|
||||
};
|
||||
|
||||
class XMLExporter : public Exporter {
|
||||
public:
|
||||
void exportShapes(const boost::filesystem::path& inputFilePath, const Timeline<Shape>& shapes, std::ostream& outputStream) override;
|
||||
void exportShapes(const boost::filesystem::path& inputFilePath, const ContinuousTimeline<Shape>& shapes, std::ostream& outputStream) override;
|
||||
};
|
||||
|
||||
class JSONExporter : public Exporter {
|
||||
public:
|
||||
void exportShapes(const boost::filesystem::path& inputFilePath, const Timeline<Shape>& shapes, std::ostream& outputStream) override;
|
||||
void exportShapes(const boost::filesystem::path& inputFilePath, const ContinuousTimeline<Shape>& shapes, std::ostream& outputStream) override;
|
||||
};
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
#include "Phone.h"
|
||||
|
||||
using std::string;
|
||||
using boost::optional;
|
||||
|
||||
PhoneConverter& PhoneConverter::get() {
|
||||
static PhoneConverter converter;
|
||||
|
@ -14,7 +15,6 @@ string PhoneConverter::getTypeName() {
|
|||
|
||||
EnumConverter<Phone>::member_data PhoneConverter::getMemberData() {
|
||||
return member_data{
|
||||
{ Phone::None, "None" },
|
||||
{ Phone::Unknown, "Unknown" },
|
||||
{ Phone::AO, "AO" },
|
||||
{ Phone::AA, "AA" },
|
||||
|
@ -58,8 +58,7 @@ EnumConverter<Phone>::member_data PhoneConverter::getMemberData() {
|
|||
};
|
||||
}
|
||||
|
||||
boost::optional<Phone> PhoneConverter::tryParse(const string& s) {
|
||||
if (s == "SIL") return Phone::None;
|
||||
optional<Phone> PhoneConverter::tryParse(const string& s) {
|
||||
auto result = EnumConverter<Phone>::tryParse(s);
|
||||
return result ? result : Phone::Unknown;
|
||||
}
|
||||
|
|
|
@ -4,7 +4,6 @@
|
|||
|
||||
// Defines a subset of the Arpabet
|
||||
enum class Phone {
|
||||
None,
|
||||
Unknown,
|
||||
|
||||
/////////
|
||||
|
|
|
@ -7,7 +7,6 @@
|
|||
// For reference, see http://sunewatts.dk/lipsync/lipsync/article_02.php
|
||||
// For visual examples, see https://flic.kr/s/aHsj86KR4J. Their shapes "BMP".."L" map to A..H.
|
||||
enum class Shape {
|
||||
Invalid = -1,
|
||||
A, // Closed mouth (silence, M, B, P)
|
||||
B, // Clenched teeth (most vowels, m[e]n)
|
||||
C, // Mouth slightly open (b[ir]d, s[ay], w[i]n...)
|
||||
|
|
|
@ -4,6 +4,11 @@
|
|||
|
||||
using time_type = TimeRange::time_type;
|
||||
|
||||
TimeRange TimeRange::zero() {
|
||||
static TimeRange zero(time_type::zero(), time_type::zero());
|
||||
return zero;
|
||||
}
|
||||
|
||||
TimeRange::TimeRange(time_type start, time_type end) :
|
||||
start(start),
|
||||
end(end)
|
||||
|
@ -23,6 +28,10 @@ time_type TimeRange::getLength() const {
|
|||
return end - start;
|
||||
}
|
||||
|
||||
bool TimeRange::empty() const {
|
||||
return start == end;
|
||||
}
|
||||
|
||||
void TimeRange::resize(const TimeRange& newRange) {
|
||||
start = newRange.start;
|
||||
end = newRange.end;
|
||||
|
|
|
@ -5,6 +5,8 @@ class TimeRange {
|
|||
public:
|
||||
using time_type = centiseconds;
|
||||
|
||||
static TimeRange zero();
|
||||
|
||||
TimeRange(time_type start, time_type end);
|
||||
TimeRange(const TimeRange&) = default;
|
||||
TimeRange(TimeRange&&) = default;
|
||||
|
@ -15,6 +17,7 @@ public:
|
|||
time_type getStart() const;
|
||||
time_type getEnd() const;
|
||||
time_type getLength() const;
|
||||
bool empty() const;
|
||||
|
||||
void resize(const TimeRange& newRange);
|
||||
void resize(time_type start, time_type end);
|
||||
|
|
88
src/Timed.h
88
src/Timed.h
|
@ -4,15 +4,14 @@
|
|||
#include <iostream>
|
||||
|
||||
template<typename TValue>
|
||||
class Timed : public TimeRange {
|
||||
class Timed {
|
||||
public:
|
||||
Timed(time_type start, time_type end, const TValue& value) :
|
||||
TimeRange(start, end),
|
||||
value(value)
|
||||
Timed(TimeRange::time_type start, TimeRange::time_type end, const TValue& value) :
|
||||
Timed(TimeRange(start, end), value)
|
||||
{}
|
||||
|
||||
Timed(const TimeRange& timeRange, const TValue& value) :
|
||||
TimeRange(timeRange),
|
||||
timeRange(timeRange),
|
||||
value(value)
|
||||
{}
|
||||
|
||||
|
@ -22,6 +21,26 @@ public:
|
|||
Timed& operator=(const Timed&) = default;
|
||||
Timed& operator=(Timed&&) = default;
|
||||
|
||||
TimeRange& getTimeRange() {
|
||||
return timeRange;
|
||||
}
|
||||
|
||||
const TimeRange& getTimeRange() const {
|
||||
return timeRange;
|
||||
}
|
||||
|
||||
TimeRange::time_type getStart() const {
|
||||
return timeRange.getStart();
|
||||
}
|
||||
|
||||
TimeRange::time_type getEnd() const {
|
||||
return timeRange.getEnd();
|
||||
}
|
||||
|
||||
void setTimeRange(const TimeRange& timeRange) {
|
||||
this->timeRange = timeRange;
|
||||
}
|
||||
|
||||
TValue& getValue() {
|
||||
return value;
|
||||
}
|
||||
|
@ -30,12 +49,12 @@ public:
|
|||
return value;
|
||||
}
|
||||
|
||||
void setValue(TValue value) {
|
||||
void setValue(const TValue& value) {
|
||||
this->value = value;
|
||||
}
|
||||
|
||||
bool operator==(const Timed& rhs) const {
|
||||
return TimeRange::operator==(rhs) && value == rhs.value;
|
||||
return timeRange == rhs.timeRange && value == rhs.value;
|
||||
}
|
||||
|
||||
bool operator!=(const Timed& rhs) const {
|
||||
|
@ -43,6 +62,7 @@ public:
|
|||
}
|
||||
|
||||
private:
|
||||
TimeRange timeRange;
|
||||
TValue value;
|
||||
};
|
||||
|
||||
|
@ -50,3 +70,57 @@ template<typename T>
|
|||
std::ostream& operator<<(std::ostream& stream, const Timed<T>& timedValue) {
|
||||
return stream << "Timed(" << timedValue.getStart() << ", " << timedValue.getEnd() << ", " << timedValue.getValue() << ")";
|
||||
}
|
||||
|
||||
template<>
|
||||
class Timed<void> {
|
||||
public:
|
||||
Timed(TimeRange::time_type start, TimeRange::time_type end) :
|
||||
Timed(TimeRange(start, end))
|
||||
{}
|
||||
|
||||
Timed(const TimeRange& timeRange) :
|
||||
timeRange(timeRange)
|
||||
{}
|
||||
|
||||
Timed(const Timed&) = default;
|
||||
Timed(Timed&&) = default;
|
||||
|
||||
Timed& operator=(const Timed&) = default;
|
||||
Timed& operator=(Timed&&) = default;
|
||||
|
||||
TimeRange& getTimeRange() {
|
||||
return timeRange;
|
||||
}
|
||||
|
||||
const TimeRange& getTimeRange() const {
|
||||
return timeRange;
|
||||
}
|
||||
|
||||
TimeRange::time_type getStart() const {
|
||||
return timeRange.getStart();
|
||||
}
|
||||
|
||||
TimeRange::time_type getEnd() const {
|
||||
return timeRange.getEnd();
|
||||
}
|
||||
|
||||
void setTimeRange(const TimeRange& timeRange) {
|
||||
this->timeRange = timeRange;
|
||||
}
|
||||
|
||||
bool operator==(const Timed& rhs) const {
|
||||
return timeRange == rhs.timeRange;
|
||||
}
|
||||
|
||||
bool operator!=(const Timed& rhs) const {
|
||||
return !operator==(rhs);
|
||||
}
|
||||
|
||||
private:
|
||||
TimeRange timeRange;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
std::ostream& operator<<(std::ostream& stream, const Timed<void>& timedValue) {
|
||||
return stream << "Timed<void>(" << timedValue.getTimeRange().getStart() << ", " << timedValue.getTimeRange().getEnd() << ")";
|
||||
}
|
||||
|
|
255
src/Timeline.h
255
src/Timeline.h
|
@ -1,7 +1,30 @@
|
|||
#pragma once
|
||||
#include "Timed.h"
|
||||
#include <set>
|
||||
#include <algorithm>
|
||||
#include <boost/optional.hpp>
|
||||
#include <type_traits>
|
||||
#include "tools.h"
|
||||
|
||||
enum class FindMode {
|
||||
SampleLeft,
|
||||
SampleRight,
|
||||
SearchLeft,
|
||||
SearchRight
|
||||
};
|
||||
|
||||
namespace internal {
|
||||
template<typename T>
|
||||
bool valueEquals(const Timed<T>& lhs, const Timed<T>& rhs) {
|
||||
return lhs.getValue() == rhs.getValue();
|
||||
}
|
||||
|
||||
template<>
|
||||
inline bool valueEquals<void>(const Timed<void>& lhs, const Timed<void>& rhs) {
|
||||
UNUSED(lhs);
|
||||
UNUSED(rhs);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
class Timeline {
|
||||
|
@ -16,6 +39,9 @@ private:
|
|||
bool operator()(const time_type& lhs, const Timed<T>& rhs) const {
|
||||
return lhs < rhs.getStart();
|
||||
}
|
||||
bool operator()(const Timed<T>& lhs, const time_type& rhs) const {
|
||||
return lhs.getStart() < rhs;
|
||||
}
|
||||
using is_transparent = int;
|
||||
};
|
||||
|
||||
|
@ -29,14 +55,28 @@ public:
|
|||
|
||||
class reference {
|
||||
public:
|
||||
using const_reference = const T&;
|
||||
|
||||
operator const_reference() const {
|
||||
return timeline.get(time).getValue();
|
||||
operator boost::optional<const T&>() const {
|
||||
auto optional = timeline.get(time);
|
||||
return optional ? optional->getValue() : boost::optional<const T&>();
|
||||
}
|
||||
|
||||
reference& operator=(const T& value) {
|
||||
timeline.set(time, time + time_type(1), value);
|
||||
operator boost::optional<T>() const {
|
||||
auto optional = timeline.get(time);
|
||||
return optional ? optional->getValue() : boost::optional<T>();
|
||||
}
|
||||
|
||||
operator const T&() const {
|
||||
auto optional = timeline.get(time);
|
||||
assert(optional);
|
||||
return optional->getValue();
|
||||
}
|
||||
|
||||
reference& operator=(boost::optional<const T&> value) {
|
||||
if (value) {
|
||||
timeline.set(time, time + time_type(1), *value);
|
||||
} else {
|
||||
timeline.clear(time, time + time_type(1));
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
@ -52,36 +92,22 @@ public:
|
|||
time_type time;
|
||||
};
|
||||
|
||||
explicit Timeline(const Timed<T> timedValue) :
|
||||
elements(),
|
||||
range(timedValue)
|
||||
{
|
||||
if (timedValue.getLength() != time_type::zero()) {
|
||||
elements.insert(timedValue);
|
||||
}
|
||||
};
|
||||
|
||||
explicit Timeline(const TimeRange& timeRange, const T& value = T()) :
|
||||
Timeline(Timed<T>(timeRange, value))
|
||||
{ }
|
||||
|
||||
Timeline(time_type start, time_type end, const T& value = T()) :
|
||||
Timeline(Timed<T>(start, end, value))
|
||||
{}
|
||||
Timeline() {}
|
||||
|
||||
template<typename InputIterator>
|
||||
Timeline(InputIterator first, InputIterator last, const T& value = T()) :
|
||||
Timeline(getRange(first, last), value)
|
||||
{
|
||||
Timeline(InputIterator first, InputIterator last) {
|
||||
for (auto it = first; it != last; ++it) {
|
||||
set(*it);
|
||||
// Virtual function call in constructor. Derived constructors don't call this one.
|
||||
Timeline<T>::set(*it);
|
||||
}
|
||||
}
|
||||
|
||||
explicit Timeline(std::initializer_list<Timed<T>> initializerList, const T& value = T()) :
|
||||
Timeline(initializerList.begin(), initializerList.end(), value)
|
||||
explicit Timeline(std::initializer_list<Timed<T>> initializerList) :
|
||||
Timeline(initializerList.begin(), initializerList.end())
|
||||
{}
|
||||
|
||||
virtual ~Timeline() {}
|
||||
|
||||
bool empty() const {
|
||||
return elements.empty();
|
||||
}
|
||||
|
@ -90,8 +116,10 @@ public:
|
|||
return elements.size();
|
||||
}
|
||||
|
||||
const TimeRange& getRange() const {
|
||||
return range;
|
||||
virtual TimeRange getRange() const {
|
||||
return empty()
|
||||
? TimeRange(time_type::zero(), time_type::zero())
|
||||
: TimeRange(begin()->getStart(), rbegin()->getEnd());
|
||||
}
|
||||
|
||||
iterator begin() const {
|
||||
|
@ -110,79 +138,101 @@ public:
|
|||
return elements.rend();
|
||||
}
|
||||
|
||||
iterator find(time_type time) const {
|
||||
if (time < range.getStart() || time >= range.getEnd()) {
|
||||
return elements.end();
|
||||
iterator find(time_type time, FindMode findMode = FindMode::SampleRight) const {
|
||||
switch (findMode) {
|
||||
case FindMode::SampleLeft: {
|
||||
iterator left = find(time, FindMode::SearchLeft);
|
||||
return left != end() && left->getEnd() >= time ? left : end();
|
||||
}
|
||||
case FindMode::SampleRight: {
|
||||
iterator right = find(time, FindMode::SearchRight);
|
||||
return right != end() && right->getStart() <= time ? right : end();
|
||||
}
|
||||
case FindMode::SearchLeft: {
|
||||
// Get first element starting >= time
|
||||
iterator it = elements.lower_bound(time);
|
||||
|
||||
iterator it = elements.upper_bound(time);
|
||||
--it;
|
||||
return it;
|
||||
// Go one element back
|
||||
return it != begin() ? --it : end();
|
||||
}
|
||||
case FindMode::SearchRight: {
|
||||
// Get first element starting > time
|
||||
iterator it = elements.upper_bound(time);
|
||||
|
||||
// Go one element back
|
||||
if (it != begin()) {
|
||||
iterator left = it;
|
||||
--left;
|
||||
if (left->getEnd() > time) return left;
|
||||
}
|
||||
return it;
|
||||
}
|
||||
default:
|
||||
throw std::invalid_argument("Unexpected find mode.");
|
||||
}
|
||||
}
|
||||
|
||||
const Timed<T>& get(time_type time) const {
|
||||
boost::optional<const Timed<T>&> get(time_type time) const {
|
||||
iterator it = find(time);
|
||||
if (it == elements.end()) {
|
||||
throw std::invalid_argument("Argument out of range.");
|
||||
}
|
||||
return *it;
|
||||
return (it != end()) ? *it : boost::optional<const Timed<T>&>();
|
||||
}
|
||||
|
||||
iterator set(Timed<T> timedValue) {
|
||||
// Make sure the timed value overlaps with our range
|
||||
if (timedValue.getEnd() <= range.getStart() || timedValue.getStart() >= range.getEnd()) {
|
||||
return elements.end();
|
||||
}
|
||||
|
||||
// Make sure the timed value is not empty
|
||||
if (timedValue.getLength() == time_type::zero()) {
|
||||
return elements.end();
|
||||
}
|
||||
|
||||
// Trim the timed value to our range
|
||||
timedValue.resize(
|
||||
std::max(timedValue.getStart(), range.getStart()),
|
||||
std::min(timedValue.getEnd(), range.getEnd()));
|
||||
|
||||
// Extend the timed value if it touches elements with equal value
|
||||
bool isFlushLeft = timedValue.getStart() == range.getStart();
|
||||
if (!isFlushLeft) {
|
||||
iterator elementBefore = find(timedValue.getStart() - time_type(1));
|
||||
if (elementBefore->getValue() == timedValue.getValue()) {
|
||||
timedValue.resize(elementBefore->getStart(), timedValue.getEnd());
|
||||
}
|
||||
}
|
||||
bool isFlushRight = timedValue.getEnd() == range.getEnd();
|
||||
if (!isFlushRight) {
|
||||
iterator elementAfter = find(timedValue.getEnd());
|
||||
if (elementAfter->getValue() == timedValue.getValue()) {
|
||||
timedValue.resize(timedValue.getStart(), elementAfter->getEnd());
|
||||
}
|
||||
}
|
||||
virtual void clear(const TimeRange& range) {
|
||||
// Make sure the time range is not empty
|
||||
if (range.empty()) return;
|
||||
|
||||
// Split overlapping elements
|
||||
splitAt(timedValue.getStart());
|
||||
splitAt(timedValue.getEnd());
|
||||
splitAt(range.getStart());
|
||||
splitAt(range.getEnd());
|
||||
|
||||
// Erase overlapping elements
|
||||
elements.erase(find(timedValue.getStart()), find(timedValue.getEnd()));
|
||||
elements.erase(find(range.getStart(), FindMode::SearchRight), find(range.getEnd(), FindMode::SearchRight));
|
||||
}
|
||||
|
||||
void clear(time_type start, time_type end) {
|
||||
clear(TimeRange(start, end));
|
||||
}
|
||||
|
||||
virtual iterator set(Timed<T> timedValue) {
|
||||
// Make sure the timed value is not empty
|
||||
if (timedValue.getTimeRange().empty()) {
|
||||
return end();
|
||||
}
|
||||
|
||||
// Extend the timed value if it touches elements with equal value
|
||||
iterator elementBefore = find(timedValue.getStart(), FindMode::SampleLeft);
|
||||
if (elementBefore != end() && ::internal::valueEquals(*elementBefore, timedValue)) {
|
||||
timedValue.getTimeRange().resize(elementBefore->getStart(), timedValue.getEnd());
|
||||
}
|
||||
iterator elementAfter = find(timedValue.getEnd(), FindMode::SampleRight);
|
||||
if (elementAfter != end() && ::internal::valueEquals(*elementAfter, timedValue)) {
|
||||
timedValue.getTimeRange().resize(timedValue.getStart(), elementAfter->getEnd());
|
||||
}
|
||||
|
||||
// Erase overlapping elements
|
||||
Timeline::clear(timedValue.getTimeRange());
|
||||
|
||||
// Add timed value
|
||||
return elements.insert(timedValue).first;
|
||||
}
|
||||
|
||||
iterator set(const TimeRange& timeRange, const T& value) {
|
||||
template<typename TElement = T>
|
||||
iterator set(const TimeRange& timeRange, const std::enable_if_t<!std::is_void<TElement>::value, T>& value) {
|
||||
return set(Timed<T>(timeRange, value));
|
||||
}
|
||||
|
||||
iterator set(time_type start, time_type end, const T& value) {
|
||||
template<typename TElement = T>
|
||||
iterator set(time_type start, time_type end, const std::enable_if_t<!std::is_void<TElement>::value, T>& value) {
|
||||
return set(Timed<T>(start, end, value));
|
||||
}
|
||||
|
||||
template<typename TElement = T>
|
||||
std::enable_if_t<std::is_void<TElement>::value, iterator>
|
||||
set(time_type start, time_type end) {
|
||||
return set(Timed<void>(start, end));
|
||||
}
|
||||
|
||||
reference operator[](time_type time) {
|
||||
if (time < range.getStart() || time >= range.getEnd()) {
|
||||
throw std::invalid_argument("Argument out of range.");
|
||||
}
|
||||
return reference(*this, time);
|
||||
}
|
||||
|
||||
|
@ -191,13 +241,12 @@ public:
|
|||
return reference(*this, time);
|
||||
}
|
||||
|
||||
void shift(time_type offset) {
|
||||
virtual void shift(time_type offset) {
|
||||
if (offset == time_type::zero()) return;
|
||||
|
||||
range.shift(offset);
|
||||
set_type newElements;
|
||||
for (Timed<T> element : elements) {
|
||||
element.shift(offset);
|
||||
element.getTimeRange().shift(offset);
|
||||
newElements.insert(element);
|
||||
}
|
||||
elements = std::move(newElements);
|
||||
|
@ -209,44 +258,34 @@ public:
|
|||
Timeline& operator=(Timeline&&) = default;
|
||||
|
||||
bool operator==(const Timeline& rhs) const {
|
||||
return range == rhs.range && elements == rhs.elements;
|
||||
return equals(rhs);
|
||||
}
|
||||
|
||||
bool operator!=(const Timeline& rhs) const {
|
||||
return !operator==(rhs);
|
||||
return !equals(rhs);
|
||||
}
|
||||
|
||||
protected:
|
||||
bool equals(const Timeline& rhs) const {
|
||||
return elements == rhs.elements;
|
||||
}
|
||||
|
||||
private:
|
||||
template<typename InputIterator>
|
||||
static TimeRange getRange(InputIterator first, InputIterator last) {
|
||||
if (first == last) {
|
||||
return TimeRange(time_type::zero(), time_type::zero());
|
||||
}
|
||||
|
||||
time_type start = time_type::max();
|
||||
time_type end = time_type::min();
|
||||
for (auto it = first; it != last; ++it) {
|
||||
start = std::min(start, it->getStart());
|
||||
end = std::max(end, it->getEnd());
|
||||
}
|
||||
return TimeRange(start, end);
|
||||
}
|
||||
|
||||
void splitAt(time_type splitTime) {
|
||||
if (splitTime == range.getStart() || splitTime == range.getEnd()) return;
|
||||
|
||||
iterator elementBefore = find(splitTime - time_type(1));
|
||||
iterator elementAfter = find(splitTime);
|
||||
if (elementBefore != elementAfter) return;
|
||||
if (elementBefore != elementAfter || elementBefore == end()) return;
|
||||
|
||||
Timed<T> tmp = *elementBefore;
|
||||
Timed<T> first = *elementBefore;
|
||||
Timed<T> second = *elementBefore;
|
||||
elements.erase(elementBefore);
|
||||
elements.insert(Timed<T>(tmp.getStart(), splitTime, tmp.getValue()));
|
||||
elements.insert(Timed<T>(splitTime, tmp.getEnd(), tmp.getValue()));
|
||||
first.getTimeRange().resize(first.getStart(), splitTime);
|
||||
elements.insert(first);
|
||||
second.getTimeRange().resize(splitTime, second.getEnd());
|
||||
elements.insert(second);
|
||||
}
|
||||
|
||||
set_type elements;
|
||||
TimeRange range;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
|
|
|
@ -2,7 +2,6 @@
|
|||
#include <string.h>
|
||||
#include "WaveFileReader.h"
|
||||
#include "ioTools.h"
|
||||
#include <array>
|
||||
|
||||
using std::runtime_error;
|
||||
using fmt::format;
|
||||
|
|
|
@ -3,6 +3,7 @@
|
|||
#include <audio/SampleRateConverter.h>
|
||||
#include <boost/optional/optional.hpp>
|
||||
#include <logging.h>
|
||||
#include <pairs.h>
|
||||
|
||||
using std::numeric_limits;
|
||||
using std::vector;
|
||||
|
@ -17,7 +18,7 @@ float getRMS(AudioStream& audioStream, int maxSampleCount = numeric_limits<int>:
|
|||
return sampleCount > 0 ? static_cast<float>(std::sqrt(sum / sampleCount)) : 0.0f;
|
||||
}
|
||||
|
||||
Timeline<bool> detectVoiceActivity(std::unique_ptr<AudioStream> audioStream) {
|
||||
BoundedTimeline<void> detectVoiceActivity(std::unique_ptr<AudioStream> audioStream) {
|
||||
// Make sure audio stream has no DC offset
|
||||
audioStream = removeDCOffset(std::move(audioStream));
|
||||
|
||||
|
@ -29,26 +30,32 @@ Timeline<bool> detectVoiceActivity(std::unique_ptr<AudioStream> audioStream) {
|
|||
// Detect activity
|
||||
const float rms = getRMS(*audioStream->clone(true));
|
||||
const float cutoff = rms / 50;
|
||||
Timeline<bool> activity(audioStream->getTruncatedRange());
|
||||
BoundedTimeline<void> activity(audioStream->getTruncatedRange());
|
||||
for (centiseconds time = centiseconds::zero(); !audioStream->endOfStream(); ++time) {
|
||||
float currentRMS = getRMS(*audioStream, sampleRate / 100);
|
||||
bool active = currentRMS > cutoff;
|
||||
if (active) {
|
||||
activity[time] = true;
|
||||
activity.set(time, time + centiseconds(1));
|
||||
}
|
||||
}
|
||||
|
||||
// Pad each activity to prevent cropping
|
||||
const centiseconds padding(3);
|
||||
for (const auto& element : BoundedTimeline<void>(activity)) {
|
||||
activity.set(element.getStart() - padding, element.getEnd() + padding);
|
||||
}
|
||||
|
||||
// Fill small gaps in activity
|
||||
const centiseconds maxGap(10);
|
||||
for (const auto& element : Timeline<bool>(activity)) {
|
||||
if (!element.getValue() && element.getLength() <= maxGap) {
|
||||
activity.set(static_cast<TimeRange>(element), true);
|
||||
const centiseconds maxGap(5);
|
||||
for (const auto& pair : getPairs(activity)) {
|
||||
if (pair.second.getStart() - pair.first.getEnd() <= maxGap) {
|
||||
activity.set(pair.first.getEnd(), pair.second.getStart());
|
||||
}
|
||||
}
|
||||
|
||||
// Log
|
||||
for (const auto& element : activity) {
|
||||
logging::logTimedEvent("utterance", static_cast<TimeRange>(element), std::string());
|
||||
for (const auto& utterance : activity) {
|
||||
logging::logTimedEvent("utterance", utterance.getTimeRange(), std::string());
|
||||
}
|
||||
|
||||
return activity;
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
#pragma once
|
||||
#include <memory>
|
||||
#include "AudioStream.h"
|
||||
#include <Timeline.h>
|
||||
#include <BoundedTimeline.h>
|
||||
|
||||
Timeline<bool> detectVoiceActivity(std::unique_ptr<AudioStream> audioStream);
|
||||
BoundedTimeline<void> detectVoiceActivity(std::unique_ptr<AudioStream> audioStream);
|
||||
|
|
|
@ -10,8 +10,8 @@
|
|||
#include "ProgressBar.h"
|
||||
#include "logging.h"
|
||||
#include <gsl_util.h>
|
||||
#include "Timeline.h"
|
||||
#include "Exporter.h"
|
||||
#include "ContinuousTimeline.h"
|
||||
|
||||
using std::exception;
|
||||
using std::string;
|
||||
|
@ -113,7 +113,7 @@ int main(int argc, char *argv[]) {
|
|||
const int columnWidth = 30;
|
||||
std::cerr << std::left;
|
||||
std::cerr << std::setw(columnWidth) << "Analyzing input file";
|
||||
Timeline<Phone> phones{};
|
||||
BoundedTimeline<Phone> phones(TimeRange::zero());
|
||||
{
|
||||
ProgressBar progressBar;
|
||||
phones = detectPhones(
|
||||
|
@ -125,7 +125,7 @@ int main(int argc, char *argv[]) {
|
|||
|
||||
// Generate mouth shapes
|
||||
std::cerr << std::setw(columnWidth) << "Generating mouth shapes";
|
||||
Timeline<Shape> shapes = animate(phones);
|
||||
ContinuousTimeline<Shape> shapes = animate(phones);
|
||||
std::cerr << "Done" << std::endl;
|
||||
|
||||
std::cerr << std::endl;
|
||||
|
|
|
@ -5,7 +5,6 @@ using std::map;
|
|||
|
||||
Shape getShape(Phone phone) {
|
||||
switch (phone) {
|
||||
case Phone::None:
|
||||
case Phone::P:
|
||||
case Phone::B:
|
||||
case Phone::M:
|
||||
|
@ -67,11 +66,14 @@ Shape getShape(Phone phone) {
|
|||
}
|
||||
}
|
||||
|
||||
Timeline<Shape> animate(const Timeline<Phone> &phones) {
|
||||
Timeline<Shape> shapes(phones.getRange());
|
||||
for (auto& timedPhone : phones) {
|
||||
Timed<Shape> timedShape(static_cast<TimeRange>(timedPhone), getShape(timedPhone.getValue()));
|
||||
ContinuousTimeline<Shape> animate(const BoundedTimeline<Phone> &phones) {
|
||||
ContinuousTimeline<Shape> shapes(phones.getRange(), Shape::A);
|
||||
for (const auto& timedPhone : phones) {
|
||||
Timed<Shape> timedShape(timedPhone.getTimeRange(), getShape(timedPhone.getValue()));
|
||||
shapes.set(timedShape);
|
||||
}
|
||||
|
||||
for (const auto& timedShape : shapes) {
|
||||
logging::logTimedEvent("shape", timedShape);
|
||||
}
|
||||
|
||||
|
|
|
@ -2,6 +2,6 @@
|
|||
|
||||
#include "Phone.h"
|
||||
#include "Shape.h"
|
||||
#include "Timeline.h"
|
||||
#include "ContinuousTimeline.h"
|
||||
|
||||
Timeline<Shape> animate(const Timeline<Phone>& phones);
|
||||
ContinuousTimeline<Shape> animate(const BoundedTimeline<Phone>& phones);
|
||||
|
|
|
@ -214,7 +214,12 @@ vector<s3wid_t> getWordIds(const vector<string>& words, dict_t& dictionary) {
|
|||
return result;
|
||||
}
|
||||
|
||||
Timeline<Phone> getPhoneAlignment(const vector<s3wid_t>& wordIds, unique_ptr<AudioStream> audioStream, ps_decoder_t& recognizer, ProgressSink& progressSink) {
|
||||
BoundedTimeline<Phone> getPhoneAlignment(
|
||||
const vector<s3wid_t>& wordIds,
|
||||
unique_ptr<AudioStream> audioStream,
|
||||
ps_decoder_t& recognizer,
|
||||
ProgressSink& progressSink)
|
||||
{
|
||||
// Create alignment list
|
||||
lambda_unique_ptr<ps_alignment_t> alignment(
|
||||
ps_alignment_init(recognizer.d2p),
|
||||
|
@ -265,12 +270,14 @@ Timeline<Phone> getPhoneAlignment(const vector<s3wid_t>& wordIds, unique_ptr<Aud
|
|||
|
||||
// Extract phones with timestamps
|
||||
char** phoneNames = recognizer.dict->mdef->ciname;
|
||||
Timeline<Phone> result(audioStream->getTruncatedRange());
|
||||
BoundedTimeline<Phone> result(audioStream->getTruncatedRange());
|
||||
for (ps_alignment_iter_t* it = ps_alignment_phones(alignment.get()); it; it = ps_alignment_iter_next(it)) {
|
||||
// Get phone
|
||||
ps_alignment_entry_t* phoneEntry = ps_alignment_iter_get(it);
|
||||
s3cipid_t phoneId = phoneEntry->id.pid.cipid;
|
||||
char* phoneName = phoneNames[phoneId];
|
||||
string phoneName = phoneNames[phoneId];
|
||||
|
||||
if (phoneName == "SIL") continue;
|
||||
|
||||
// Add entry
|
||||
centiseconds start(phoneEntry->start);
|
||||
|
@ -283,14 +290,15 @@ Timeline<Phone> getPhoneAlignment(const vector<s3wid_t>& wordIds, unique_ptr<Aud
|
|||
return result;
|
||||
}
|
||||
|
||||
Timeline<Phone> detectPhones(
|
||||
BoundedTimeline<Phone> detectPhones(
|
||||
unique_ptr<AudioStream> audioStream,
|
||||
boost::optional<std::string> dialog,
|
||||
ProgressSink& progressSink)
|
||||
{
|
||||
// Pocketsphinx doesn't like empty input
|
||||
if (audioStream->getTruncatedRange().getLength() == centiseconds::zero()) {
|
||||
return Timeline<Phone>{};
|
||||
TimeRange audioRange = audioStream->getTruncatedRange();
|
||||
if (audioRange.empty()) {
|
||||
return BoundedTimeline<Phone>(audioRange);
|
||||
}
|
||||
|
||||
// Discard Pocketsphinx output
|
||||
|
@ -323,7 +331,7 @@ Timeline<Phone> detectPhones(
|
|||
vector<s3wid_t> wordIds = getWordIds(words, *recognizer->dict);
|
||||
|
||||
// Align the word's phones with speech
|
||||
Timeline<Phone> result = getPhoneAlignment(wordIds, std::move(audioStream), *recognizer.get(), alignmentProgressSink);
|
||||
BoundedTimeline<Phone> result = getPhoneAlignment(wordIds, std::move(audioStream), *recognizer.get(), alignmentProgressSink);
|
||||
return result;
|
||||
}
|
||||
catch (...) {
|
||||
|
|
|
@ -5,9 +5,9 @@
|
|||
#include "Phone.h"
|
||||
#include "progressBar.h"
|
||||
#include <boost/optional/optional.hpp>
|
||||
#include "Timeline.h"
|
||||
#include "BoundedTimeline.h"
|
||||
|
||||
Timeline<Phone> detectPhones(
|
||||
BoundedTimeline<Phone> detectPhones(
|
||||
std::unique_ptr<AudioStream> audioStream,
|
||||
boost::optional<std::string> dialog,
|
||||
ProgressSink& progressSink);
|
||||
|
|
|
@ -0,0 +1,105 @@
|
|||
#include <gmock/gmock.h>
|
||||
#include "BoundedTimeline.h"
|
||||
|
||||
using namespace testing;
|
||||
using cs = centiseconds;
|
||||
using std::vector;
|
||||
using boost::optional;
|
||||
using std::initializer_list;
|
||||
|
||||
TEST(BoundedTimeline, constructors_initializeState) {
|
||||
TimeRange range(cs(-5), cs(55));
|
||||
auto args = {
|
||||
Timed<int>(cs(-10), cs(30), 1),
|
||||
Timed<int>(cs(10), cs(40), 2),
|
||||
Timed<int>(cs(50), cs(60), 3)
|
||||
};
|
||||
auto expected = {
|
||||
Timed<int>(cs(-5), cs(10), 1),
|
||||
Timed<int>(cs(10), cs(40), 2),
|
||||
Timed<int>(cs(50), cs(55), 3)
|
||||
};
|
||||
EXPECT_THAT(
|
||||
BoundedTimeline<int>(range, args.begin(), args.end()),
|
||||
ElementsAreArray(expected)
|
||||
);
|
||||
EXPECT_THAT(
|
||||
BoundedTimeline<int>(range, args),
|
||||
ElementsAreArray(expected)
|
||||
);
|
||||
}
|
||||
|
||||
TEST(BoundedTimeline, empty) {
|
||||
BoundedTimeline<int> empty(TimeRange(cs(0), cs(10)));
|
||||
EXPECT_TRUE(empty.empty());
|
||||
EXPECT_THAT(empty, IsEmpty());
|
||||
|
||||
BoundedTimeline<int> nonEmpty(TimeRange(cs(0), cs(10)), { Timed<int>(cs(1), cs(2), 1) });
|
||||
EXPECT_FALSE(nonEmpty.empty());
|
||||
EXPECT_THAT(nonEmpty, Not(IsEmpty()));
|
||||
}
|
||||
|
||||
TEST(BoundedTimeline, getRange) {
|
||||
TimeRange range(cs(0), cs(10));
|
||||
BoundedTimeline<int> empty(range);
|
||||
EXPECT_EQ(range, empty.getRange());
|
||||
|
||||
BoundedTimeline<int> nonEmpty(range, { Timed<int>(cs(1), cs(2), 1) });
|
||||
EXPECT_EQ(range, nonEmpty.getRange());
|
||||
}
|
||||
|
||||
TEST(BoundedTimeline, setAndClear) {
|
||||
TimeRange range(cs(0), cs(10));
|
||||
BoundedTimeline<int> timeline(range);
|
||||
|
||||
// Out of range
|
||||
timeline.set(cs(-10), cs(-1), 1);
|
||||
timeline.set(TimeRange(cs(-5), cs(-1)), 2);
|
||||
timeline.set(Timed<int>(cs(10), cs(15), 3));
|
||||
|
||||
// Overlapping
|
||||
timeline.set(cs(-2), cs(5), 4);
|
||||
timeline.set(TimeRange(cs(-1), cs(1)), 5);
|
||||
timeline.set(Timed<int>(cs(8), cs(12), 6));
|
||||
|
||||
// Within
|
||||
timeline.set(cs(5), cs(9), 7);
|
||||
timeline.set(TimeRange(cs(6), cs(7)), 8);
|
||||
timeline.set(Timed<int>(cs(7), cs(8), 9));
|
||||
|
||||
auto expected = {
|
||||
Timed<int>(cs(0), cs(1), 5),
|
||||
Timed<int>(cs(1), cs(5), 4),
|
||||
Timed<int>(cs(5), cs(6), 7),
|
||||
Timed<int>(cs(6), cs(7), 8),
|
||||
Timed<int>(cs(7), cs(8), 9),
|
||||
Timed<int>(cs(8), cs(9), 7),
|
||||
Timed<int>(cs(9), cs(10), 6)
|
||||
};
|
||||
EXPECT_THAT(timeline, ElementsAreArray(expected));
|
||||
}
|
||||
|
||||
TEST(BoundedTimeline, shift) {
|
||||
BoundedTimeline<int> timeline(TimeRange(cs(0), cs(10)), { { cs(1), cs(2), 1 }, { cs(2), cs(5), 2 }, { cs(7), cs(9), 3 } });
|
||||
BoundedTimeline<int> expected(TimeRange(cs(2), cs(12)), { { cs(3), cs(4), 1 }, { cs(4), cs(7), 2 }, { cs(9), cs(11), 3 } });
|
||||
timeline.shift(cs(2));
|
||||
EXPECT_EQ(expected, timeline);
|
||||
}
|
||||
|
||||
TEST(BoundedTimeline, equality) {
|
||||
vector<BoundedTimeline<int>> timelines = {
|
||||
BoundedTimeline<int>(TimeRange(cs(0), cs(10))),
|
||||
BoundedTimeline<int>(TimeRange(cs(0), cs(10)), { { cs(1), cs(2), 1 } }),
|
||||
BoundedTimeline<int>(TimeRange(cs(1), cs(10)), { { cs(1), cs(2), 1 } })
|
||||
};
|
||||
|
||||
for (size_t i = 0; i < timelines.size(); ++i) {
|
||||
for (size_t j = 0; j < timelines.size(); ++j) {
|
||||
if (i == j) {
|
||||
EXPECT_EQ(timelines[i], BoundedTimeline<int>(timelines[j])) << "i: " << i << ", j: " << j;
|
||||
} else {
|
||||
EXPECT_NE(timelines[i], timelines[j]) << "i: " << i << ", j: " << j;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
|
@ -0,0 +1,105 @@
|
|||
#include <gmock/gmock.h>
|
||||
#include "ContinuousTimeline.h"
|
||||
|
||||
using namespace testing;
|
||||
using cs = centiseconds;
|
||||
using std::vector;
|
||||
using boost::optional;
|
||||
using std::initializer_list;
|
||||
|
||||
TEST(ContinuousTimeline, constructors_initializeState) {
|
||||
TimeRange range(cs(-5), cs(55));
|
||||
int defaultValue = -1;
|
||||
auto args = {
|
||||
Timed<int>(cs(-10), cs(30), 1),
|
||||
Timed<int>(cs(10), cs(40), 2),
|
||||
Timed<int>(cs(50), cs(60), 3)
|
||||
};
|
||||
auto expected = {
|
||||
Timed<int>(cs(-5), cs(10), 1),
|
||||
Timed<int>(cs(10), cs(40), 2),
|
||||
Timed<int>(cs(40), cs(50), defaultValue),
|
||||
Timed<int>(cs(50), cs(55), 3)
|
||||
};
|
||||
EXPECT_THAT(
|
||||
ContinuousTimeline<int>(range, defaultValue, args.begin(), args.end()),
|
||||
ElementsAreArray(expected)
|
||||
);
|
||||
EXPECT_THAT(
|
||||
ContinuousTimeline<int>(range, defaultValue, args),
|
||||
ElementsAreArray(expected)
|
||||
);
|
||||
}
|
||||
|
||||
TEST(ContinuousTimeline, empty) {
|
||||
ContinuousTimeline<int> empty(TimeRange(cs(10), cs(10)), -1);
|
||||
EXPECT_TRUE(empty.empty());
|
||||
EXPECT_THAT(empty, IsEmpty());
|
||||
|
||||
ContinuousTimeline<int> nonEmpty1(TimeRange(cs(0), cs(10)), -1);
|
||||
EXPECT_FALSE(nonEmpty1.empty());
|
||||
EXPECT_THAT(nonEmpty1, Not(IsEmpty()));
|
||||
|
||||
ContinuousTimeline<int> nonEmpty2(TimeRange(cs(0), cs(10)), -1, { Timed<int>(cs(1), cs(2), 1) });
|
||||
EXPECT_FALSE(nonEmpty2.empty());
|
||||
EXPECT_THAT(nonEmpty2, Not(IsEmpty()));
|
||||
}
|
||||
|
||||
TEST(ContinuousTimeline, setAndClear) {
|
||||
TimeRange range(cs(0), cs(10));
|
||||
int defaultValue = -1;
|
||||
ContinuousTimeline<int> timeline(range, defaultValue);
|
||||
|
||||
// Out of range
|
||||
timeline.set(cs(-10), cs(-1), 1);
|
||||
timeline.set(TimeRange(cs(-5), cs(-1)), 2);
|
||||
timeline.set(Timed<int>(cs(10), cs(15), 3));
|
||||
|
||||
// Overlapping
|
||||
timeline.set(cs(-2), cs(3), 4);
|
||||
timeline.set(TimeRange(cs(-1), cs(1)), 5);
|
||||
timeline.set(Timed<int>(cs(8), cs(12), 6));
|
||||
|
||||
// Within
|
||||
timeline.set(cs(5), cs(9), 7);
|
||||
timeline.set(TimeRange(cs(6), cs(7)), 8);
|
||||
timeline.set(Timed<int>(cs(7), cs(8), 9));
|
||||
|
||||
auto expected = {
|
||||
Timed<int>(cs(0), cs(1), 5),
|
||||
Timed<int>(cs(1), cs(3), 4),
|
||||
Timed<int>(cs(3), cs(5), defaultValue),
|
||||
Timed<int>(cs(5), cs(6), 7),
|
||||
Timed<int>(cs(6), cs(7), 8),
|
||||
Timed<int>(cs(7), cs(8), 9),
|
||||
Timed<int>(cs(8), cs(9), 7),
|
||||
Timed<int>(cs(9), cs(10), 6)
|
||||
};
|
||||
EXPECT_THAT(timeline, ElementsAreArray(expected));
|
||||
}
|
||||
|
||||
TEST(ContinuousTimeline, shift) {
|
||||
ContinuousTimeline<int> timeline(TimeRange(cs(0), cs(10)), -1, { { cs(1), cs(2), 1 },{ cs(2), cs(5), 2 },{ cs(7), cs(9), 3 } });
|
||||
ContinuousTimeline<int> expected(TimeRange(cs(2), cs(12)), -1, { { cs(3), cs(4), 1 },{ cs(4), cs(7), 2 },{ cs(9), cs(11), 3 } });
|
||||
timeline.shift(cs(2));
|
||||
EXPECT_EQ(expected, timeline);
|
||||
}
|
||||
|
||||
TEST(ContinuousTimeline, equality) {
|
||||
vector<ContinuousTimeline<int>> timelines = {
|
||||
ContinuousTimeline<int>(TimeRange(cs(0), cs(10)), -1),
|
||||
ContinuousTimeline<int>(TimeRange(cs(0), cs(10)), 1),
|
||||
ContinuousTimeline<int>(TimeRange(cs(0), cs(10)), -1, { { cs(1), cs(2), 1 } }),
|
||||
ContinuousTimeline<int>(TimeRange(cs(1), cs(10)), -1, { { cs(1), cs(2), 1 } })
|
||||
};
|
||||
|
||||
for (size_t i = 0; i < timelines.size(); ++i) {
|
||||
for (size_t j = 0; j < timelines.size(); ++j) {
|
||||
if (i == j) {
|
||||
EXPECT_EQ(timelines[i], ContinuousTimeline<int>(timelines[j])) << "i: " << i << ", j: " << j;
|
||||
} else {
|
||||
EXPECT_NE(timelines[i], timelines[j]) << "i: " << i << ", j: " << j;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
|
@ -6,20 +6,11 @@
|
|||
using namespace testing;
|
||||
using cs = centiseconds;
|
||||
using std::vector;
|
||||
using boost::optional;
|
||||
using std::initializer_list;
|
||||
using boost::none;
|
||||
|
||||
TEST(Timeline, constructors_initializeState) {
|
||||
EXPECT_THAT(
|
||||
Timeline<int>(Timed<int>(cs(10), cs(30), 42)),
|
||||
ElementsAre(Timed<int>(cs(10), cs(30), 42))
|
||||
);
|
||||
EXPECT_THAT(
|
||||
Timeline<int>(TimeRange(cs(10), cs(30)), 42),
|
||||
ElementsAre(Timed<int>(cs(10), cs(30), 42))
|
||||
);
|
||||
EXPECT_THAT(
|
||||
Timeline<int>(cs(10), cs(30), 42),
|
||||
ElementsAre(Timed<int>(cs(10), cs(30), 42))
|
||||
);
|
||||
auto args = {
|
||||
Timed<int>(cs(-10), cs(30), 1),
|
||||
Timed<int>(cs(10), cs(40), 2),
|
||||
|
@ -28,120 +19,176 @@ TEST(Timeline, constructors_initializeState) {
|
|||
auto expected = {
|
||||
Timed<int>(cs(-10), cs(10), 1),
|
||||
Timed<int>(cs(10), cs(40), 2),
|
||||
Timed<int>(cs(40), cs(50), 42),
|
||||
Timed<int>(cs(50), cs(60), 3)
|
||||
};
|
||||
EXPECT_THAT(
|
||||
Timeline<int>(args.begin(), args.end(), 42),
|
||||
Timeline<int>(args.begin(), args.end()),
|
||||
ElementsAreArray(expected)
|
||||
);
|
||||
EXPECT_THAT(
|
||||
Timeline<int>(args, 42),
|
||||
Timeline<int>(args),
|
||||
ElementsAreArray(expected)
|
||||
);
|
||||
}
|
||||
|
||||
TEST(Timeline, constructors_throwForInvalidArgs) {
|
||||
EXPECT_THROW(
|
||||
Timeline<int>(cs(10), cs(9)),
|
||||
std::invalid_argument
|
||||
);
|
||||
}
|
||||
|
||||
TEST(Timeline, empty) {
|
||||
Timeline<int> empty0;
|
||||
EXPECT_TRUE(empty0.empty());
|
||||
EXPECT_THAT(empty0, IsEmpty());
|
||||
|
||||
Timeline<int> empty1{};
|
||||
EXPECT_TRUE(empty1.empty());
|
||||
EXPECT_THAT(empty1, IsEmpty());
|
||||
|
||||
Timeline<int> empty2(cs(1), cs(1));
|
||||
Timeline<int> empty2{ Timed<int>(cs(1), cs(1), 1) };
|
||||
EXPECT_TRUE(empty2.empty());
|
||||
EXPECT_THAT(empty2, IsEmpty());
|
||||
|
||||
Timeline<int> nonEmpty(cs(1), cs(2));
|
||||
Timeline<int> nonEmpty{ Timed<int>(cs(1), cs(2), 1) };
|
||||
EXPECT_FALSE(nonEmpty.empty());
|
||||
EXPECT_THAT(nonEmpty, Not(IsEmpty()));
|
||||
}
|
||||
|
||||
TEST(Timeline, size) {
|
||||
Timeline<int> empty0;
|
||||
EXPECT_EQ(0, empty0.size());
|
||||
EXPECT_THAT(empty0, SizeIs(0));
|
||||
|
||||
Timeline<int> empty1{};
|
||||
EXPECT_EQ(0, empty1.size());
|
||||
EXPECT_THAT(empty1, SizeIs(0));
|
||||
|
||||
Timeline<int> empty2(cs(1), cs(1));
|
||||
Timeline<int> empty2{ Timed<int>(cs(1), cs(1), 1) };
|
||||
EXPECT_EQ(0, empty2.size());
|
||||
EXPECT_THAT(empty2, SizeIs(0));
|
||||
|
||||
Timeline<int> size1(cs(1), cs(10));
|
||||
Timeline<int> size1{ Timed<int>(cs(1), cs(10), 1) };
|
||||
EXPECT_EQ(1, size1.size());
|
||||
EXPECT_THAT(size1, SizeIs(1));
|
||||
|
||||
Timeline<int> size2{Timed<int>(cs(-10), cs(10), 1), Timed<int>(cs(10), cs(11), 5)};
|
||||
Timeline<int> size2{ Timed<int>(cs(-10), cs(10), 1), Timed<int>(cs(10), cs(11), 5) };
|
||||
EXPECT_EQ(2, size2.size());
|
||||
EXPECT_THAT(size2, SizeIs(2));
|
||||
}
|
||||
|
||||
TEST(Timeline, getRange) {
|
||||
Timeline<int> empty0;
|
||||
EXPECT_EQ(TimeRange(cs(0), cs(0)), empty0.getRange());
|
||||
|
||||
Timeline<int> empty1{};
|
||||
EXPECT_EQ(TimeRange(cs(0), cs(0)), empty1.getRange());
|
||||
|
||||
Timeline<int> empty2(cs(1), cs(1));
|
||||
EXPECT_EQ(TimeRange(cs(1), cs(1)), empty2.getRange());
|
||||
Timeline<int> empty2{ Timed<int>(cs(1), cs(1), 1) };
|
||||
EXPECT_EQ(TimeRange(cs(0), cs(0)), empty2.getRange());
|
||||
|
||||
Timeline<int> nonEmpty1(cs(1), cs(10));
|
||||
Timeline<int> nonEmpty1{ Timed<int>(cs(1), cs(10), 1) };
|
||||
EXPECT_EQ(TimeRange(cs(1), cs(10)), nonEmpty1.getRange());
|
||||
|
||||
Timeline<int> nonEmpty2{ Timed<int>(cs(-10), cs(10), 1), Timed<int>(cs(10), cs(11), 5) };
|
||||
Timeline<int> nonEmpty2{ Timed<int>(cs(-10), cs(5), 1), Timed<int>(cs(10), cs(11), 5) };
|
||||
EXPECT_EQ(TimeRange(cs(-10), cs(11)), nonEmpty2.getRange());
|
||||
}
|
||||
|
||||
TEST(Timeline, iterators) {
|
||||
Timeline<int> timeline{ Timed<int>(cs(-5), cs(0), 10), Timed<int>(cs(5), cs(15), 9) };
|
||||
auto expected = { Timed<int>(cs(-5), cs(0), 10), Timed<int>(cs(0), cs(5), 0), Timed<int>(cs(5), cs(15), 9) };
|
||||
auto expected = { Timed<int>(cs(-5), cs(0), 10), Timed<int>(cs(5), cs(15), 9) };
|
||||
EXPECT_THAT(timeline, ElementsAreArray(expected));
|
||||
|
||||
vector<Timed<int>> reversedActual;
|
||||
std::copy(timeline.rbegin(), timeline.rend(), back_inserter(reversedActual));
|
||||
copy(timeline.rbegin(), timeline.rend(), back_inserter(reversedActual));
|
||||
vector<Timed<int>> reversedExpected;
|
||||
std::reverse_copy(expected.begin(), expected.end(), back_inserter(reversedExpected));
|
||||
reverse_copy(expected.begin(), expected.end(), back_inserter(reversedExpected));
|
||||
EXPECT_THAT(reversedActual, ElementsAreArray(reversedExpected));
|
||||
}
|
||||
|
||||
void testFind(const Timeline<int>& timeline, FindMode findMode, const initializer_list<Timed<int>*> expectedResults) {
|
||||
int i = -1;
|
||||
for (Timed<int>* expectedResult : expectedResults) {
|
||||
auto it = timeline.find(cs(++i), findMode);
|
||||
if (expectedResult != nullptr) {
|
||||
EXPECT_NE(it, timeline.end()) << "Timeline: " << timeline << "; findMode: " << static_cast<int>(findMode) << "; i: " << i;
|
||||
if (it != timeline.end()) {
|
||||
EXPECT_EQ(*expectedResult, *it) << "Timeline: " << timeline << "; findMode: " << static_cast<int>(findMode) << "; i: " << i;
|
||||
}
|
||||
} else {
|
||||
EXPECT_EQ(timeline.end(), it) << "Timeline: " << timeline << "; findMode: " << static_cast<int>(findMode) << "; i: " << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Timeline, find) {
|
||||
vector<Timed<int>> elements = {
|
||||
Timed<int>(cs(1), cs(2), 1), // #0
|
||||
Timed<int>(cs(2), cs(4), 2), // #1
|
||||
Timed<int>(cs(4), cs(5), 3) // #2
|
||||
};
|
||||
Timeline<int> timeline(elements.begin(), elements.end());
|
||||
EXPECT_EQ(timeline.end(), timeline.find(cs(-1)));
|
||||
EXPECT_EQ(timeline.end(), timeline.find(cs(0)));
|
||||
EXPECT_EQ(elements[0], *timeline.find(cs(1)));
|
||||
EXPECT_EQ(elements[1], *timeline.find(cs(2)));
|
||||
EXPECT_EQ(elements[1], *timeline.find(cs(3)));
|
||||
EXPECT_EQ(elements[2], *timeline.find(cs(4)));
|
||||
EXPECT_EQ(timeline.end(), timeline.find(cs(5)));
|
||||
Timed<int> a = Timed<int>(cs(1), cs(2), 1);
|
||||
Timed<int> b = Timed<int>(cs(2), cs(5), 2);
|
||||
Timed<int> c = Timed<int>(cs(7), cs(9), 3);
|
||||
Timeline<int> timeline{ a, b, c };
|
||||
|
||||
testFind(timeline, FindMode::SampleLeft, { nullptr, nullptr, &a, &b, &b, &b, nullptr, nullptr, &c, &c, nullptr });
|
||||
testFind(timeline, FindMode::SampleRight, { nullptr, &a, &b, &b, &b, nullptr, nullptr, &c, &c, nullptr, nullptr });
|
||||
testFind(timeline, FindMode::SearchLeft, { nullptr, nullptr, &a, &b, &b, &b, &b, &b, &c, &c, &c });
|
||||
testFind(timeline, FindMode::SearchRight, { &a, &a, &b, &b, &b, &c, &c, &c, &c, nullptr, nullptr });
|
||||
}
|
||||
|
||||
TEST(Timeline, get) {
|
||||
vector<Timed<int>> elements = {
|
||||
Timed<int>(cs(1), cs(2), 1), // #0
|
||||
Timed<int>(cs(2), cs(4), 2), // #1
|
||||
Timed<int>(cs(4), cs(5), 3) // #2
|
||||
};
|
||||
Timeline<int> timeline(elements.begin(), elements.end());
|
||||
EXPECT_THROW(timeline.get(cs(-1)), std::invalid_argument);
|
||||
EXPECT_THROW(timeline.get(cs(0)), std::invalid_argument);
|
||||
EXPECT_EQ(elements[0], timeline.get(cs(1)));
|
||||
EXPECT_EQ(elements[1], timeline.get(cs(2)));
|
||||
EXPECT_EQ(elements[1], timeline.get(cs(3)));
|
||||
EXPECT_EQ(elements[2], timeline.get(cs(4)));
|
||||
EXPECT_THROW(timeline.get(cs(5)), std::invalid_argument);
|
||||
Timed<int> a = Timed<int>(cs(1), cs(2), 1);
|
||||
Timed<int> b = Timed<int>(cs(2), cs(5), 2);
|
||||
Timed<int> c = Timed<int>(cs(7), cs(9), 3);
|
||||
Timeline<int> timeline{ a, b, c };
|
||||
|
||||
initializer_list<Timed<int>*> expectedResults = { nullptr, &a, &b, &b, &b, nullptr, nullptr, &c, &c, nullptr, nullptr };
|
||||
int i = -1;
|
||||
for (Timed<int>* expectedResult : expectedResults) {
|
||||
optional<const Timed<int>&> value = timeline.get(cs(++i));
|
||||
if (expectedResult != nullptr) {
|
||||
EXPECT_TRUE(value) << "i: " << i;
|
||||
if (value) {
|
||||
EXPECT_EQ(*expectedResult, *value) << "i: " << i;
|
||||
}
|
||||
} else {
|
||||
EXPECT_FALSE(value) << "i: " << i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Timeline, clear) {
|
||||
Timeline<int> original{ { cs(1), cs(2), 1 }, { cs(2), cs(5), 2 }, { cs(7), cs(9), 3 } };
|
||||
|
||||
{
|
||||
auto timeline = original;
|
||||
timeline.clear(cs(-10), cs(10));
|
||||
EXPECT_THAT(timeline, IsEmpty());
|
||||
}
|
||||
|
||||
{
|
||||
auto timeline = original;
|
||||
timeline.clear(cs(1), cs(2));
|
||||
Timeline<int> expected{ { cs(2), cs(5), 2 }, { cs(7), cs(9), 3 } };
|
||||
EXPECT_EQ(expected, timeline);
|
||||
}
|
||||
|
||||
{
|
||||
auto timeline = original;
|
||||
timeline.clear(cs(3), cs(4));
|
||||
Timeline<int> expected{ { cs(1), cs(2), 1 }, { cs(2), cs(3), 2 }, { cs(4), cs(5), 2}, { cs(7), cs(9), 3} };
|
||||
EXPECT_EQ(expected, timeline);
|
||||
}
|
||||
|
||||
{
|
||||
auto timeline = original;
|
||||
timeline.clear(cs(6), cs(8));
|
||||
Timeline<int> expected{ { cs(1), cs(2), 1 }, { cs(2), cs(5), 2 }, { cs(8), cs(9), 3 } };
|
||||
EXPECT_EQ(expected, timeline);
|
||||
}
|
||||
|
||||
{
|
||||
auto timeline = original;
|
||||
timeline.clear(cs(8), cs(10));
|
||||
Timeline<int> expected{ { cs(1), cs(2), 1 }, { cs(2), cs(5), 2 }, { cs(7), cs(8), 3 } };
|
||||
EXPECT_EQ(expected, timeline);
|
||||
}
|
||||
}
|
||||
|
||||
void testSetter(std::function<void(const Timed<int>&, Timeline<int>&)> set) {
|
||||
const Timed<int> initial(cs(0), cs(10), 42);
|
||||
Timeline<int> timeline(initial);
|
||||
vector<int> expectedValues(10, 42);
|
||||
Timeline<int> timeline;
|
||||
vector<optional<int>> expectedValues(20, none);
|
||||
auto newElements = {
|
||||
Timed<int>(cs(1), cs(2), 4),
|
||||
Timed<int>(cs(3), cs(6), 4),
|
||||
|
@ -161,35 +208,45 @@ void testSetter(std::function<void(const Timed<int>&, Timeline<int>&)> set) {
|
|||
Timed<int>(cs(6), cs(8), 15),
|
||||
Timed<int>(cs(6), cs(8), 16)
|
||||
};
|
||||
int newElementIndex = -1;
|
||||
for (const auto& newElement : newElements) {
|
||||
++newElementIndex;
|
||||
// Set element in timeline
|
||||
set(newElement, timeline);
|
||||
|
||||
// Update expected value for every index
|
||||
cs elementStart = max(newElement.getStart(), cs(0));
|
||||
cs elementEnd = min(newElement.getEnd(), cs(10));
|
||||
cs elementEnd = newElement.getEnd();
|
||||
for (cs t = elementStart; t < elementEnd; ++t) {
|
||||
expectedValues[t.count()] = newElement.getValue();
|
||||
}
|
||||
|
||||
// Check timeline via indexer
|
||||
for (cs t = cs(0); t < cs(10); ++t) {
|
||||
EXPECT_EQ(expectedValues[t.count()], timeline[t]);
|
||||
optional<const int&> actual = timeline[t];
|
||||
EXPECT_EQ(expectedValues[t.count()], actual ? optional<int>(*actual) : none);
|
||||
}
|
||||
|
||||
// Check timeline via iterators
|
||||
int lastValue = std::numeric_limits<int>::min();
|
||||
Timed<int> lastElement(cs::min(), cs::min(), std::numeric_limits<int>::min());
|
||||
for (const auto& element : timeline) {
|
||||
// No element shound have zero-length
|
||||
EXPECT_LT(cs(0), element.getLength());
|
||||
EXPECT_LT(cs(0), element.getTimeRange().getLength());
|
||||
|
||||
// No two adjacent elements should have the same value; they should have been merged
|
||||
EXPECT_NE(lastValue, element.getValue());
|
||||
lastValue = element.getValue();
|
||||
if (element.getStart() == lastElement.getEnd()) {
|
||||
EXPECT_NE(lastElement.getValue(), element.getValue());
|
||||
}
|
||||
lastElement = element;
|
||||
|
||||
// Element should match expected values
|
||||
for (cs t = element.getStart(); t < element.getEnd(); ++t) {
|
||||
EXPECT_EQ(expectedValues[t.count()], element.getValue());
|
||||
for (cs t = std::max(cs::zero(), element.getStart()); t < element.getEnd(); ++t) {
|
||||
optional<int> expectedValue = expectedValues[t.count()];
|
||||
EXPECT_TRUE(expectedValue) << "Index " << t.count() << " should not have a value, but is within element " << element << ". "
|
||||
<< "newElementIndex: " << newElementIndex;
|
||||
if (expectedValue) {
|
||||
EXPECT_EQ(*expectedValue, element.getValue());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -200,40 +257,68 @@ TEST(Timeline, set) {
|
|||
timeline.set(element);
|
||||
});
|
||||
testSetter([](const Timed<int>& element, Timeline<int>& timeline) {
|
||||
timeline.set(element, element.getValue());
|
||||
timeline.set(element.getTimeRange(), element.getValue());
|
||||
});
|
||||
testSetter([](const Timed<int>& element, Timeline<int>& timeline) {
|
||||
timeline.set(element.getStart(), element.getEnd(), element.getValue());
|
||||
});
|
||||
}
|
||||
|
||||
TEST(Timeline, indexer_get) {
|
||||
Timeline<int> timeline{ { cs(1), cs(2), 1 }, { cs(2), cs(4), 2 }, { cs(6), cs(9), 3 } };
|
||||
vector<optional<int>> expectedValues{ none, 1, 2, 2, none, none, 3, 3, 3 };
|
||||
for (cs t = cs(0); t < cs(9); ++t) {
|
||||
{
|
||||
optional<const int&> actual = timeline[t];
|
||||
EXPECT_EQ(expectedValues[t.count()], actual ? optional<int>(*actual) : none);
|
||||
}
|
||||
{
|
||||
optional<int> actual = timeline[t];
|
||||
EXPECT_EQ(expectedValues[t.count()], actual ? optional<int>(*actual) : none);
|
||||
}
|
||||
if (expectedValues[t.count()]) {
|
||||
{
|
||||
const int& actual = timeline[t];
|
||||
EXPECT_EQ(*expectedValues[t.count()], actual);
|
||||
}
|
||||
{
|
||||
int actual = timeline[t];
|
||||
EXPECT_EQ(*expectedValues[t.count()], actual);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Timeline, indexer_set) {
|
||||
testSetter([](const Timed<int>& element, Timeline<int>& timeline) {
|
||||
for (cs t = element.getStart(); t < element.getEnd(); ++t) {
|
||||
if (t >= timeline.getRange().getStart() && t < timeline.getRange().getEnd()) {
|
||||
timeline[t] = element.getValue();
|
||||
} else {
|
||||
EXPECT_THROW(timeline[t] = element.getValue(), std::invalid_argument);
|
||||
}
|
||||
timeline[t] = element.getValue();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
TEST(Timeline, shift) {
|
||||
Timeline<int> timeline{ { cs(1), cs(2), 1 },{ cs(2), cs(5), 2 },{ cs(7), cs(9), 3 } };
|
||||
Timeline<int> expected{ { cs(3), cs(4), 1 },{ cs(4), cs(7), 2 },{ cs(9), cs(11), 3 } };
|
||||
timeline.shift(cs(2));
|
||||
EXPECT_EQ(expected, timeline);
|
||||
}
|
||||
|
||||
TEST(Timeline, equality) {
|
||||
vector<Timeline<int>> timelines = {
|
||||
Timeline<int>{},
|
||||
Timeline<int>(cs(1), cs(1)),
|
||||
Timeline<int>(cs(1), cs(2)),
|
||||
Timeline<int>(cs(-10), cs(0))
|
||||
Timeline<int>{ { cs(1), cs(2), 0 } },
|
||||
Timeline<int>{ { cs(1), cs(2), 1 } },
|
||||
Timeline<int>{ { cs(-10), cs(0), 0 } }
|
||||
};
|
||||
|
||||
for (size_t i = 0; i < timelines.size(); ++i) {
|
||||
for (size_t j = 0; j < timelines.size(); ++j) {
|
||||
if (i == j) {
|
||||
EXPECT_EQ(timelines[i], Timeline<int>(timelines[j]));
|
||||
EXPECT_EQ(timelines[i], Timeline<int>(timelines[j])) << "i: " << i << ", j: " << j;
|
||||
} else {
|
||||
EXPECT_NE(timelines[i], timelines[j]);
|
||||
EXPECT_NE(timelines[i], timelines[j]) << "i: " << i << ", j: " << j;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue