136 lines
5.1 KiB
C++
136 lines
5.1 KiB
C++
// Copyright 2019 The MediaPipe Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include "mediapipe/util/time_series_util.h"
|
|
|
|
#include <math.h>
|
|
|
|
#include <iostream>
|
|
#include <string>
|
|
|
|
#include "absl/strings/str_cat.h"
|
|
#include "mediapipe/framework/calculator_framework.h"
|
|
#include "mediapipe/framework/formats/time_series_header.pb.h"
|
|
#include "mediapipe/framework/port/logging.h"
|
|
|
|
namespace mediapipe {
|
|
namespace time_series_util {
|
|
|
|
bool LogWarningIfTimestampIsInconsistent(const Timestamp& current_timestamp,
|
|
const Timestamp& initial_timestamp,
|
|
int64 cumulative_samples,
|
|
double sample_rate) {
|
|
// Ignore the "special" timestamp value Done().
|
|
if (current_timestamp == Timestamp::Done()) return true;
|
|
// Don't accept other special timestamp values. We may need to change this
|
|
// depending on how they're used in practice.
|
|
if (!current_timestamp.IsRangeValue()) {
|
|
LOG(WARNING) << "Unexpected special timestamp: "
|
|
<< current_timestamp.DebugString();
|
|
return false;
|
|
}
|
|
|
|
// For non-special timestamp values, check whether the number of
|
|
// samples that have been processed is consistent with amount of
|
|
// time that has elapsed.
|
|
double expected_timestamp_seconds =
|
|
initial_timestamp.Seconds() + cumulative_samples / sample_rate;
|
|
if (fabs(current_timestamp.Seconds() - expected_timestamp_seconds) >
|
|
0.5 / sample_rate) {
|
|
LOG_EVERY_N(WARNING, 20)
|
|
<< std::fixed << "Timestamp " << current_timestamp.Seconds()
|
|
<< " not consistent with number of samples " << cumulative_samples
|
|
<< " and initial timestamp " << initial_timestamp
|
|
<< ". Expected timestamp: " << expected_timestamp_seconds
|
|
<< " Timestamp difference: "
|
|
<< current_timestamp.Seconds() - expected_timestamp_seconds
|
|
<< " sample_rate: " << sample_rate;
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
absl::Status IsTimeSeriesHeaderValid(const TimeSeriesHeader& header) {
|
|
if (header.has_sample_rate() && header.sample_rate() >= 0 &&
|
|
header.has_num_channels() && header.num_channels() >= 0) {
|
|
return absl::OkStatus();
|
|
} else {
|
|
std::string error_message =
|
|
"TimeSeriesHeader is missing necessary fields: "
|
|
"sample_rate or num_channels, or one of their values is negative. ";
|
|
#ifndef MEDIAPIPE_MOBILE
|
|
absl::StrAppend(&error_message, "Got header:\n", header.ShortDebugString());
|
|
#endif
|
|
return tool::StatusInvalid(error_message);
|
|
}
|
|
}
|
|
|
|
absl::Status FillTimeSeriesHeaderIfValid(const Packet& header_packet,
|
|
TimeSeriesHeader* header) {
|
|
CHECK(header);
|
|
if (header_packet.IsEmpty()) {
|
|
return tool::StatusFail("No header found.");
|
|
}
|
|
if (!header_packet.ValidateAsType<TimeSeriesHeader>().ok()) {
|
|
return tool::StatusFail("Packet does not contain TimeSeriesHeader.");
|
|
}
|
|
*header = header_packet.Get<TimeSeriesHeader>();
|
|
return IsTimeSeriesHeaderValid(*header);
|
|
}
|
|
|
|
absl::Status FillMultiStreamTimeSeriesHeaderIfValid(
|
|
const Packet& header_packet, MultiStreamTimeSeriesHeader* header) {
|
|
CHECK(header);
|
|
if (header_packet.IsEmpty()) {
|
|
return tool::StatusFail("No header found.");
|
|
}
|
|
if (!header_packet.ValidateAsType<MultiStreamTimeSeriesHeader>().ok()) {
|
|
return tool::StatusFail(
|
|
"Packet does not contain MultiStreamTimeSeriesHeader.");
|
|
}
|
|
*header = header_packet.Get<MultiStreamTimeSeriesHeader>();
|
|
if (!header->has_time_series_header()) {
|
|
return tool::StatusFail("No time series header found.");
|
|
}
|
|
return IsTimeSeriesHeaderValid(header->time_series_header());
|
|
}
|
|
|
|
absl::Status IsMatrixShapeConsistentWithHeader(const Matrix& matrix,
|
|
const TimeSeriesHeader& header) {
|
|
if (header.has_num_samples() && matrix.cols() != header.num_samples()) {
|
|
return tool::StatusInvalid(absl::StrCat(
|
|
"Matrix size is inconsistent with header. Expected ",
|
|
header.num_samples(), " columns, but found ", matrix.cols()));
|
|
}
|
|
if (header.has_num_channels() && matrix.rows() != header.num_channels()) {
|
|
return tool::StatusInvalid(absl::StrCat(
|
|
"Matrix size is inconsistent with header. Expected ",
|
|
header.num_channels(), " rows, but found ", matrix.rows()));
|
|
}
|
|
return absl::OkStatus();
|
|
}
|
|
|
|
int64 SecondsToSamples(double time_in_seconds, double sample_rate) {
|
|
return round(time_in_seconds * sample_rate);
|
|
}
|
|
|
|
double SamplesToSeconds(int64 num_samples, double sample_rate) {
|
|
DCHECK_NE(sample_rate, 0.0);
|
|
return (num_samples / sample_rate);
|
|
}
|
|
|
|
} // namespace time_series_util
|
|
} // namespace mediapipe
|