具有不同顺序或变量的模板类（颜色/像素类）

Question

我有两个类模板 Color3_t 和 Color4_t，分别存储 3 和 4 个颜色通道，如下所示：

template <typename TYPE>
struct Color3_t
{
   TYPE Red;
   TYPE Green;
   TYPE Blue;

   void Zero()
   {
      Red = Green = Blue = 0;
   }
   (...)
}

这两个模板都有几个用于反转、交换等颜色通道的功能，我得到了另一个继承这些类的专用模板——以防 TYPE 是半浮点数或浮点数而不是整数。

问题在于颜色通道的顺序：红色、绿色和蓝色目前是固定的——这意味着我必须为其他颜色通道顺序（如 BGR、GRB 等）创建一个 Color3_t 类模板版本。 ）。如何提供不同颜色顺序的参数 - 很可能指向如下颜色结构。

RGB 和 BGR 颜色顺序的颜色数据结构：

template <typename TYPE>
struct ColorRGB_t
{
   TYPE Red;
   TYPE Green;
   TYPE Blue;
};

template <typename TYPE>
struct ColorBGR_t
{
   TYPE Blue;
   TYPE Green;
   TYPE Red;
};

以及我想拥有的东西 - 这显然是错误和不正确的，但应该说明我想要实现的目标。

template <typename TYPE, class COLORORDER<TYPE>>
struct Color3_t : public COLORORDER<TYPE>
{
   void Zero()
   {
      Red = Green = Blue = 0;
   }
   (...)   
};

我也想直接访问每个颜色通道：

typedef Color3_t<BYTE,ColorBGR_t<BYTE>> ColorRGB8bpc;
ColorRGB8bpc oColor;
oColor.Red = 0;

代替：

oColor.SomoObject.Red = 0;

Answer 1

您需要将存储的红色/绿色/蓝色类型向下推送到 Color***_t 类中，如下所示：

template <typename TYPE>
struct ColorRGB_t
{
   typedef TYPE value_type;

   value_type Red;
   value_type Green;
   value_type Blue;
};

template <typename TYPE>
struct ColorBGR_t
{
   typedef TYPE value_type;

   value_type Blue;
   value_type Green;
   value_type Red;
};

然后 Color3 只需采用一个模板参数，它是您的 Color***_t 类型之一：

template <typename Order_t>
struct Color3 : public Order_t
{
   typedef typename Order_t::value_type value_type;

   void Zero()
   {
      //static cast zero here to avoid compiler warnings when value_type is a float or double
      Order_t::Red = Order_t::Green = Order_t::Blue = static_cast<value_type>(0);
   }
};

你将对象声明为：

Color3<ColorBGR_t<float> > c1;
Color3<ColorRGB_t<float> > c2;

这对你有用吗？它避免了在运行时对数组进行索引的开销，并且可以直接使用 Red/Green/Blue 成员，如 c1.Red = 0.0。

Answer 2

好的，这让我想到了。

我的代码基于这样的想法，即基础非虚拟类按照声明的顺序排列在内存中。我认为这不能保证，但 IMO 至少很常见。它还允许您将颜色类型用于不同数量的颜色。

template <typename TYPE> struct R { TYPE Red; };
template <typename TYPE> struct G { TYPE Green; };
template <typename TYPE> struct B { TYPE Blue; };

template <typename Bases>
struct Color : inherit_from<Bases>
{
   // ...
};

typedef Color< generate_color_list<R,G,B>::result_t > ColorRGB_t;
typedef Color< generate_color_list<B,G,R>::result_t > ColorBGR_t;

现在您只需要generate_color_list 和inherit_from。

鉴于这个简单的类型列表定义

struct nil {};

template< typename Head, typename Tail >
struct type_list {
  typedef Head head_type;
  typedef Tail tail_type;
};

这是对颜色类型列表生成器的一种不太普遍的尝试：

template< typename T1, typename T2, typename T3 >
struct generate_color_list {
  typedef type_list< T1, 
          type_list< T2, 
          type_list< T3, nil > > > result_t;
};

这是inherit_from的一个镜头：

template< typename List >
struct inherit_from;

template<>
struct inherit_from<nil> {}

template< typename Head, class Tail >
struct inherit_from< type_list<Head,Tail> >
  : public Head
  , public inherit_from<Tail>
{};

我没有尝试编译任何这些，所以它会出现令人尴尬的错误。我已经脸红了。

Answer 3

我猜你不能在编译时用模板做你想做的事。你可能有 在运行时执行此操作。

要获得您想要的效果，您需要执行以下操作：

template &lt typename TYPE &gt
struct color3channel
{
  TYPE channels[3];

  int rIndex, bIndex, gIndex;

  TYPE getR() const {return channels[rIndex];}
  TYPE getG() const {return channels[gIndex];}
  TYPE getB() const {return channels[bIndex];}
};