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:
Daniel Wolf 2016-05-02 20:31:59 +02:00
parent 9eef09145e
commit 2f31c5aa61
23 changed files with 784 additions and 243 deletions

View File

@ -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

66
src/BoundedTimeline.h Normal file
View File

@ -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;
};

39
src/ContinuousTimeline.h Normal file
View File

@ -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;
};

View File

@ -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";

View File

@ -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;
};

View File

@ -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;
}

View File

@ -4,7 +4,6 @@
// Defines a subset of the Arpabet
enum class Phone {
None,
Unknown,
/////////

View File

@ -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...)

View File

@ -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;

View File

@ -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);

View File

@ -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() << ")";
}

View File

@ -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>

View File

@ -2,7 +2,6 @@
#include <string.h>
#include "WaveFileReader.h"
#include "ioTools.h"
#include <array>
using std::runtime_error;
using fmt::format;

View File

@ -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;

View File

@ -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);

View File

@ -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;

View File

@ -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);
}

View File

@ -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);

View File

@ -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 (...) {

View File

@ -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);

View File

@ -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;
}
}
}
}

View File

@ -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;
}
}
}
}

View File

@ -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;
}
}
}
}
}