c++ - 如何返回定义明确的内存部分？例如图像数据中像素的颜色值

Question

我需要对图像进行一些操作。图像可以是彩色/灰度和 8 位/16 位。我想在不使用任何第三方库(opencv、IPP 等)的情况下完成此操作。

我有:

• 图片数据为void *。
• 图片的宽度和高度。
• channel 数量
• 每个颜色 channel 的位分辨率。

我正在考虑使用以下结构来表示颜色和图像。

颜色结构

template<typename ColorDataType, std::size_t channelCount = 3, std::size_t bitResolution = 8>
struct Color
{
    using DataType = ColorDataType;
    std::array<DataType, channelCount> colorData;
};

图像结构

template<typename ColorType>
class Image
{
    std::size_t width;
    std::size_t height;
    ColorType::DataType * data; // Or a unique_ptr<DataType[]> haven't decided on the ownership yet.

public:
    Image(std::size_t inWidth, std::size_t inHeight, ColorType::DataType * inData)
    :   width(inWidth), height(inHeight), data(inData)
    {}

    Color & GetColor(std::size_t row, std::size_t col)
    {
        // How can I return a color element here that could be manipulated from the receiving side?
        // The change should be reflected in the memory addressed by data pointer.
    }
};

返回一部分图像数据以便我以后可以对其进行操作的最佳方法是什么？我也希望有一个 const 机制，以防我的图像是 const。

附加信息:要求更多的是将给定的数据流视为维度为 3-D 矩阵:

1. 图片行
2. 图片栏
3. 图片的颜色

第 3 个维度 Color 可以有 1 个或 3 个元素，具体取决于图像是灰度图像还是 RGB 图像。我希望有一种方法可以根据提供的行和列访问图像的 Color 元素，并能够根据收到的 Color 元素编辑数据流中的真实数据。

通过这样做，我希望将颜色表示为一个单独的实体，这样我就可以说“颜色具有数据类型、 channel 计数和位分辨率”，而图像由特定的颜色类型组成

Answer 1

我假设您的 Color 类知道关于它自己的一切，只需从一个指向您的内存的指针就可以构造它。为了让它实际操作您的图像，将迭代器传递到 data 到 Color 的构造函数并存储这些迭代器。每次操作颜色对象时，确保(注意线程安全!)也操作迭代器后面的数据。

如果你不想强制你的接收者接受引用，你也可以返回 decltype(auto)来自 GetColor。

我在 2D 数组类中使用了类似的东西，我希望有类似于 operator[][] 的东西:

#include <cassert>
#include <vector>

template <typename T> class Matrix {

  std::vector<T> _matrix;
  const int _rows;
  const int _cols;

public:
  Matrix(int rows, int cols, T def) : _matrix(rows * cols, def), _rows(rows), _cols(cols) {}
  Matrix(int rows, int cols) : Matrix(rows, cols, T()) {}

  class Row {
  private:
    Matrix<T> &_m;
    const int _row;

  public:
    Row(Matrix<T> &m, int row) : _m(m), _row(row) {}

    decltype(auto) operator[](int col) {
      assert(col >= 0);
      assert(col < _m.cols());
      return _m._matrix[_row * _m.cols() + col];
    }
  };
  friend class Row;

  Row operator[](int row) {
    assert(row >= 0);
    assert(row < _rows);
    return Row(*this, row);
  }

  int rows() const { return _rows; }
  int cols() const { return _cols; }
};

编辑:这应该更像您正在寻找的内容:

#include <array>
#include <cassert>
#include <iostream>
#include <vector>

template <std::size_t channelCount = 3, std::size_t bitResolution = 8> struct Color {
private:
  std::vector<int>::iterator begin;

public:
  Color(std::vector<int>::iterator begin) : begin(begin) {}

  std::string toString() const {
    std::string rep = "(";
    for (std::size_t i = 0; i < channelCount; ++i) {
      rep += std::to_string(*(begin + i));
      if (i + 1 < channelCount)
        rep += ", ";
    }
    rep += ")";
    return rep;
  }

  template <std::size_t channel> void setChannelColor(int color) {
    static_assert(channel < channelCount);
    *(begin + channel) = color;
  }

  static constexpr std::size_t getChannelCount() { return channelCount; }
  static constexpr std::size_t getBitResolution() { return bitResolution; }
};

template <class ColorTypeT> class Image {
  using ColorType = Color<ColorTypeT::getChannelCount(), ColorTypeT::getBitResolution()>;
  static constexpr std::size_t channelCount = ColorTypeT::getChannelCount();
  static constexpr std::size_t bitResolution = ColorTypeT::getBitResolution();
  std::size_t width;
  std::size_t height;
  std::vector<int> data;

public:
  Image(std::size_t inWidth, std::size_t inHeight, std::vector<int> inData) : width(inWidth), height(inHeight), data(std::move(inData)) {}

  decltype(auto) GetColor(std::size_t row, std::size_t col) { return ColorType(data.begin() + (row * width + col) * channelCount); }

  std::size_t getWidth() const { return width; }
  std::size_t getHeight() const { return height; }
};

template <class Image> void printImage(Image &image) {
  for (std::size_t i = 0; i < image.getHeight(); ++i) {
    for (std::size_t j = 0; j < image.getWidth(); ++j) {
      std::cout << image.GetColor(i, j).toString() << " ";
    }
    std::cout << std::endl;
  }
}

int main(void) {
  std::vector<int> data = {255, 0, 0, 0, 255, 255, 0, 0, 0, 128, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 0, 255, 0, 0, 0, 0, 255};
  using Color1 = Color<3, 8>;
  using Color2 = Color<1, 8>;
  Image<Color1> i1{3, 3, data};
  Image<Color2> i2{9, 3, data};

  printImage(i1);
  std::cout << std::endl;
  printImage(i2);
  std::cout << std::endl;

  i1.GetColor(0, 0).setChannelColor<1>(128);
  //  i2.GetColor(0, 0).setChannelColor<2>(128); // static_assert fails
  i2.GetColor(0, 0).setChannelColor<0>(128);

  printImage(i1);
  std::cout << std::endl;
  printImage(i2);

  return 0;
}

它还没有考虑分辨率，但这应该不会有太多工作。

编辑:这两个类现在没有“连接”，您可以插入任何具有方法 getChannelCount 和 getBitResolution 的东西。要强制执行此操作，您可以使用 concept :

template<typename T>
concept bool ColorType = requires(T a) {
    { a.getChannelCount() } -> std::size_t { a.getBitResolution() } -> std::size_t;
};

然后将 Image 类的定义更改为:

template <ColorType ColorTypeT> class Image

clang 尚不支持此功能，但是 GCC 8 支持。