Added EMD histogram comparison support.

src/amberscript/parser.cc

@@ -1386,6 +1386,8 @@ Result Parser::ParseExpect() {
     return Result("missing buffer name between EXPECT and EQ_BUFFER");
   if (token->AsString() == "RMSE_BUFFER")
     return Result("missing buffer name between EXPECT and RMSE_BUFFER");
+  if (token->AsString() == "EMD_BUFFER")
+    return Result("missing buffer name between EXPECT and EMD_BUFFER");
 
   size_t line = tokenizer_->GetCurrentLine();
   auto* buffer = script_->GetBuffer(token->AsString());
@@ -1398,7 +1400,8 @@ Result Parser::ParseExpect() {
   if (!token->IsString())
     return Result("Invalid comparator in EXPECT command");
 
-  if (token->AsString() == "EQ_BUFFER" || token->AsString() == "RMSE_BUFFER") {
+  if (token->AsString() == "EQ_BUFFER" || token->AsString() == "RMSE_BUFFER" ||
+      token->AsString() == "EMD_BUFFER") {
     auto type = token->AsString();
 
     token = tokenizer_->NextToken();
@@ -1446,6 +1449,22 @@ Result Parser::ParseExpect() {
       if (!r.IsSuccess())
         return r;
 
+      cmd->SetTolerance(token->AsFloat());
+    } else if (type == "EMD_BUFFER") {
+      cmd->SetComparator(CompareBufferCommand::Comparator::kEmd);
+
+      token = tokenizer_->NextToken();
+      if (!token->IsString() && token->AsString() == "TOLERANCE")
+        return Result("Missing TOLERANCE for EXPECT EMD_BUFFER");
+
+      token = tokenizer_->NextToken();
+      if (!token->IsInteger() && !token->IsDouble())
+        return Result("Invalid TOLERANCE for EXPECT EMD_BUFFER");
+
+      Result r = token->ConvertToDouble();
+      if (!r.IsSuccess())
+        return r;
+
       cmd->SetTolerance(token->AsFloat());
     }
 

src/buffer.cc

@@ -81,7 +81,7 @@ double CalculateDiff(const Format::Segment* seg,
     return Sub<uint32_t>(buf1, buf2);
   if (type::Type::IsUint64(mode, num_bits))
     return Sub<uint64_t>(buf1, buf2);
-  // TOOD(dsinclair): Handle float16 ...
+  // TODO(dsinclair): Handle float16 ...
   if (type::Type::IsFloat16(mode, num_bits)) {
     assert(false && "Float16 suppport not implemented");
     return 0.0;
@@ -115,16 +115,9 @@ Result Buffer::CopyTo(Buffer* buffer) const {
 }
 
 Result Buffer::IsEqual(Buffer* buffer) const {
-  if (!buffer->format_->Equal(format_))
-    return Result{"Buffers have a different format"};
-  if (buffer->element_count_ != element_count_)
-    return Result{"Buffers have a different size"};
-  if (buffer->width_ != width_)
-    return Result{"Buffers have a different width"};
-  if (buffer->height_ != height_)
-    return Result{"Buffers have a different height"};
-  if (buffer->bytes_.size() != bytes_.size())
-    return Result{"Buffers have a different number of values"};
+  auto result = CheckCompability(buffer);
+  if (!result.IsSuccess())
+    return result;
 
   uint32_t num_different = 0;
   uint32_t first_different_index = 0;
@@ -177,7 +170,7 @@ std::vector<double> Buffer::CalculateDiffs(const Buffer* buffer) const {
   return diffs;
 }
 
-Result Buffer::CompareRMSE(Buffer* buffer, float tolerance) const {
+Result Buffer::CheckCompability(Buffer* buffer) const {
   if (!buffer->format_->Equal(format_))
     return Result{"Buffers have a different format"};
   if (buffer->element_count_ != element_count_)
@@ -189,6 +182,14 @@ Result Buffer::CompareRMSE(Buffer* buffer, float tolerance) const {
   if (buffer->ValueCount() != ValueCount())
     return Result{"Buffers have a different number of values"};
 
+  return Result{};
+}
+
+Result Buffer::CompareRMSE(Buffer* buffer, float tolerance) const {
+  auto result = CheckCompability(buffer);
+  if (!result.IsSuccess())
+    return result;
+
   auto diffs = CalculateDiffs(buffer);
   double sum = 0.0;
   for (const auto val : diffs)
@@ -204,6 +205,82 @@ Result Buffer::CompareRMSE(Buffer* buffer, float tolerance) const {
   return {};
 }
 
+std::vector<double> Buffer::GetHistogramForChannel(uint32_t channel,
+                                                   uint32_t num_bins) const {
+  std::vector<double> bins(num_bins, 0.0);
+  auto* buf_ptr = GetValues<uint8_t>();
+  const auto& segments = format_->GetSegments();
+  const auto comp = segments[channel].GetComponent();
+  auto num_channels = format_->ValuesPerElement();
+  buf_ptr += channel * comp->SizeInBytes();
+  for (size_t i = 0; i < ElementCount(); ++i) {
+    const auto bin = *reinterpret_cast<const uint8_t*>(buf_ptr);
+    bins[bin]++;
+    // Assumes unpacked format where all channels have the same bit size
+    buf_ptr += comp->SizeInBytes() * num_channels;
+  }
+
+  return bins;
+}
+
+Result Buffer::CompareHistogramEMD(Buffer* buffer, float tolerance) const {
+  auto result = CheckCompability(buffer);
+  if (!result.IsSuccess())
+    return result;
+
+  const int num_bins = 256;
+  auto num_channels = format_->ValuesPerElement();
+
+  for (auto segment : format_->GetSegments()) {
+    if (!segment.GetComponent()->IsUint8() || num_channels != 4)
+      return Result(
+          "EMD comparison only supports 8bit unorm format with four channels.");
+  }
+
+  std::vector<std::vector<double>> histograms[2];
+  for (uint32_t c = 0; c < num_channels; ++c) {
+    histograms[0].push_back(GetHistogramForChannel(c, num_bins));
+    histograms[1].push_back(buffer->GetHistogramForChannel(c, num_bins));
+  }
+
+  // Normalize histograms
+  for (uint32_t i = 0; i < 2; ++i)
+    for (uint32_t c = 0; c < num_channels; ++c) {
+      double total = 0;
+      for (auto value : histograms[i][c])
+        total += value;
+      for (auto& value : histograms[i][c])
+        value /= total;
+    }
+
+  double max_emd = 0;
+
+  for (uint32_t c = 0; c < num_channels; ++c) {
+    std::vector<double> diffs(histograms[0][c].size());
+    for (size_t i = 0; i < histograms[0][c].size(); ++i)
+      diffs[i] = histograms[0][c][i] - histograms[1][c][i];
+    // Accumulate diffs
+    for (size_t i = 1; i < histograms[0][c].size(); ++i)
+      diffs[i] += diffs[i - 1];
+    // Take absolute value and calculate total
+    double diff_total = 0;
+    for (auto diff : diffs)
+      diff_total += fabs(diff);
+    // Normalize diff
+    diff_total /= num_bins;
+
+    if (diff_total > max_emd)
+      max_emd = diff_total;
+  }
+
+  if (max_emd > static_cast<double>(tolerance)) {
+    return Result("Histogram EMD value of " + std::to_string(max_emd) +
+                  " is greater than tolerance of " + std::to_string(tolerance));
+  }
+
+  return {};
+}
+
 Result Buffer::SetData(const std::vector<Value>& data) {
   return SetDataWithOffset(data, 0);
 }

src/buffer.h

@@ -192,10 +192,21 @@ class Buffer {
   /// Succeeds only if both buffer contents are equal
   Result IsEqual(Buffer* buffer) const;
 
+  /// Returns a histogram
+  std::vector<double> GetHistogramForChannel(uint32_t channel,
+                                             uint32_t num_bins) const;
+
+  /// Checks if buffers are compatible for comparison
+  Result CheckCompability(Buffer* buffer) const;
+
   /// Compare the RMSE of this buffer against |buffer|. The RMSE must be
   /// less than |tolerance|.
   Result CompareRMSE(Buffer* buffer, float tolerance) const;
 
+  /// Compare the histogram EMD of this buffer against |buffer|. The EMD must be
+  /// less than |tolerance|.
+  Result CompareHistogramEMD(Buffer* buffer, float tolerance) const;
+
  private:
   uint32_t WriteValueFromComponent(const Value& value,
                                    FormatMode mode,

src/command.h

@@ -212,7 +212,7 @@ class DrawArraysCommand : public PipelineCommand {
 /// A command to compare two buffers.
 class CompareBufferCommand : public Command {
  public:
-  enum class Comparator { kEq, kRmse };
+  enum class Comparator { kEq, kRmse, kEmd };
 
   CompareBufferCommand(Buffer* buffer_1, Buffer* buffer_2);
   ~CompareBufferCommand() override;

src/executor.cc

@@ -128,6 +128,8 @@ Result Executor::ExecuteCommand(Engine* engine, Command* cmd) {
     switch (compare->GetComparator()) {
       case CompareBufferCommand::Comparator::kRmse:
         return buffer_1->CompareRMSE(buffer_2, compare->GetTolerance());
+      case CompareBufferCommand::Comparator::kEmd:
+        return buffer_1->CompareHistogramEMD(buffer_2, compare->GetTolerance());
       case CompareBufferCommand::Comparator::kEq:
         return buffer_1->IsEqual(buffer_2);
     }

tests/cases/buffer_emd.amber

@@ -0,0 +1,70 @@
+#!amber
+#
+# Copyright 2019 The Amber 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
+#
+#     https://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.
+
+SHADER vertex vtex_shader GLSL
+#version 430
+
+layout(location = 0) in vec4 position;
+layout(location = 0) out vec4 frag_color;
+
+layout(set = 0, binding = 0) readonly buffer block1 {
+  vec4 in_color;
+};
+
+void main() {
+  gl_Position = position;
+  frag_color = vec4(0.25, 0.5, 0.75, 1.0);
+}
+END
+
+SHADER fragment frag_shader GLSL
+#version 430
+
+layout(location = 0) in vec4 frag_color;
+layout(location = 0) out vec4 final_color;
+
+void main() {
+  final_color = frag_color;
+}
+END
+
+BUFFER frame1 FORMAT B8G8R8A8_UNORM
+BUFFER frame2 FORMAT B8G8R8A8_UNORM
+
+PIPELINE graphics pipeline1
+  ATTACH vtex_shader
+  ATTACH frag_shader
+
+  FRAMEBUFFER_SIZE 256 256
+  BIND BUFFER frame1 AS color LOCATION 0
+END
+
+PIPELINE graphics pipeline2
+  ATTACH vtex_shader
+  ATTACH frag_shader
+
+  FRAMEBUFFER_SIZE 256 256
+  BIND BUFFER frame2 AS color LOCATION 0
+END
+
+CLEAR pipeline1
+CLEAR pipeline2
+# Draw a rect to different parts of the frame buffers.
+# Histograms will still match.
+RUN pipeline1 DRAW_RECT POS   0   0 SIZE 128 128
+RUN pipeline2 DRAW_RECT POS   128 128 SIZE 128 128
+
+EXPECT frame1 EMD_BUFFER frame2 TOLERANCE 0.1