在 C++ 向量中平均重复属性的最佳方法

Question

我有一个std::vector<PLY>，它包含许多结构：

struct PLY {
    int x;
    int y;
    int greyscale;
}

某些 PLY 的位置可能是重复的 x 和 y，但不一定是它们的 greyscale 值。找到那些（位置）重复项并将其替换为单个 PLY 实例的最佳方法是什么，该实例的灰度值代表所有重复项的平均灰度？

例如：PLY a{1,1,188} 是 PLY b{1,1,255} 的副本。相同的 (x,y) 位置可能不同的灰度。

Answer 1

根据您对Ply 的描述，您需要这些运算符：

auto operator==(const Ply& a, const Ply& b)
{
  return a.x == b.x && a.y == b.y;
}
auto operator<(const Ply& a, const Ply& b)
{
  // whenever you can be lazy!
  return std::make_pair(a.x, a.y) < std::make_pair(b.x, b.y);
}

非常重要：如果定义“如果 x 和 y 相同，则两个 Ply 相同”不是一般有效的，那么定义忽略 greyscale 的比较器运算符是一个坏主意。在这种情况下，您应该定义单独的函数对象或非运算符函数并将它们传递给函数。

有一个很好的经验法则，一个函数不应该有超过一个循环。因此，我们定义了这个辅助函数，而不是嵌套的 2 个 for 循环，它计算连续重复的平均值并返回连续重复范围的结尾：

// prereq: [begin, end) has at least one element
//         i.e. begin != end
template <class It>
auto compute_average_duplicates(It begin, It end) -> std::pair<int, It>
   // (sadly not C++17) concepts:
   //requires requires(It i) { {*i} -> Ply; }
{
  auto it = begin + 1;
  int sum = begin->greyscale;
  for (; it != end && *begin == *it; ++it) {
    sum += it->greyscale;
  }
  // you might need rounding instead of truncation:
  return std::make_pair(sum / std::distance(begin, it), it);
}

有了这个，我们可以得到我们的算法：

auto foo()
{
  std::vector<Ply> v = {{1, 5, 10}, {2, 4, 6}, {1, 5, 2}};

  std::sort(std::begin(v), std::end(v));

  for (auto i = std::begin(v); i != std::end(v); ++i) { 
    decltype(i) j;
    int average;

    std::tie(average, j) = compute_average_duplicates(i, std::end(v));

    // C++17 (coming soon in a compiler near you):
    // auto [average, j] = compute_average_duplicates(i, std::end(v));

    if (i + 1 == j)
      continue;

    i->greyscale = average;
    v.erase(i + 1, j);
    // std::vector::erase Invalidates iterators and references
    // at or after the point of the erase
    // which means i remains valid, and `++i` (from the for) is correct
  }
}

Answer 2

您可以先应用字典排序。在排序期间，您应该注意溢出的greyscale。使用目前的方法，你会有一些舍入误差，但它会很小，因为我先求和，然后再取平均值。

在第二部分中，您需要从数组中删除重复项。我使用了额外的索引数组来复制每个元素不超过一次。如果您对 x、y 或 greyscale 有一些禁止值，则可以使用它，因此无需额外的数组即可相处。

struct PLY {
    int x;
    int y;
    int greyscale;
};

int main()
{
    struct comp
    {
        bool operator()(const PLY &a, const PLY &b) { return a.x != b.x ? a.x < b.x : a.y < b.y; }
    };
    vector<PLY> v{ {1,1,1}, {1,2,2}, {1,1,2}, {1,3,5}, {1,2,7} };
    sort(begin(v), end(v), comp());

    vector<bool> ind(v.size(), true);
    int s = 0;
    for (int i = 1; i < v.size(); ++i)
    {
        if (v[i].x == v[i - 1].x &&v[i].y == v[i - 1].y)
        {
            v[s].greyscale += v[i].greyscale;
            ind[i] = false;
        }
        else
        {
            int d = i - s;
            if (d != 1)
            {
                v[s].greyscale /= d;
            }
            s = i;
        }
    }

    s = 0;
    for (int i = 0; i < v.size(); ++i)
    {
        if (ind[i])
        {
            if (s != i)
            {
                v[s] = v[i];
            }
            ++s;
        }
    }
    v.resize(s);
}

Answer 3

所以你需要检查一下，PLY a1 { 1,1,1 }; 是否与 PLY a2 {2,2,1}; 重复
如此简单的方法是覆盖operator == 以检查a1.x == a2.x 和a1.y == a2.y。在您编写自己的函数removeDuplicates(std::vector<PLU>& mPLY); 后，将使用该向量的迭代器，进行比较并删除。但如果您想过于频繁地从数组中间删除，最好使用std::list。