动态查找矩形的边缘

Question

我有2个2D点，​​它们被塞在一起成为一个数组： int square[4] 。 这四个数字被解释为矩形的定义，其中水平线平行于X轴，垂直线平行于Y轴。 然后，数组的元素分别定义：

1. 左边的X坐标
2. 底边的Y坐标
3. 右边缘的X坐标
4. 上边缘的Y坐标

我在这个enum定义了一个绕线顺序：

enum WindingOrder {
    BOTTOM = 0,
    RIGHT,
    TOP,
    LEFT
};

我的代码的最小，完整，可验证的例子是，我得到一个输出第二个数组： int output[4]和输入WindingOrder edge 。 我需要填充output如下：

switch(edge) {
case BOTTOM:
    output[0] = square[0]; output[1] = square[1]; output[2] = square[2]; output[3] = square[1];
    break;
case RIGHT:
    output[0] = square[2]; output[1] = square[1]; output[2] = square[2]; output[3] = square[3];
    break;
case TOP:
    output[0] = square[2]; output[1] = square[3]; output[2] = square[0]; output[3] = square[3];
    break;
case LEFT:
    output[0] = square[0]; output[1] = square[3]; output[2] = square[0]; output[3] = square[1];
    break;
}

我没有结婚到特定WindingOrder安排，我也不关心点的顺序ouptut ，因此，如果改变这些使得这个解我下来。 我想知道的是，我可以构造square索引以在for循环中分配output ， 而不使用if / case / ternary语句（换句话说使用逐位运算）？

所以我想要，给定int i = 0和WindingOrder edge对它们进行WindingOrder edge位操作以找到：

do {
    output[i] = array[???];
} while(++i <= LEFT);

编辑：

我收到了很多静态数组的答案（我相信这是解决这个问题的最佳方法，所以我给了+1）。 但作为一个逻辑问题，我很奇怪为什么很少有位操作可以动态地找到给定边的元素。 因此，例如，如果给定任意edge ，该函数的主体应该如何写入i ： int getIndex(int i, int edge)

Answer 1

这是一个不同的解决方案。 它是静态数组方法的变体，但没有实际数组：索引矩阵内联为计算为常量表达式的32位无符号整数。 通过单个移位选择edge参数的列，最后，通过简单的位移和屏蔽来选择每个数组元素的各个索引。

该解决方案具有以下优点：

• 它很容易理解
• 它不使用测试
• 它不使用静态数组，也不使用任何其他内存位置
• 它独立于缠绕顺序，可以轻松定制任何阵列组件顺序
• 它不使用C99特定语法，这可能在C ++中不可用。

这就像我可以得到一个按位解决方案一样接近。

#include <iostream>

enum WindingOrder { BOTTOM = 0, RIGHT, TOP, LEFT };

void BitwiseWind(int const *input, int *output, enum WindingOrder edge)
{
    unsigned bits = ((0x00010201 << BOTTOM * 2) |
                     (0x02010203 << RIGHT  * 2) |
                     (0x02030003 << TOP    * 2) |
                     (0x00030001 << LEFT   * 2))
                    >> (edge * 2);

    output[0] = input[(bits >> 24) & 3];
    output[1] = input[(bits >> 16) & 3];
    output[2] = input[(bits >>  8) & 3];
    output[3] = input[(bits >>  0) & 3];
}

int main() {
    enum WindingOrder edges[4] = { BOTTOM, RIGHT, TOP, LEFT };
    int rect[4] = { 1, 3, 4, 5 };
    int output[4];

    for (int i = 0; i < 4; i++) {
        BitwiseWind(rect, output, edges[i]);
        std::cout << output[0] << output[1] << output[2] << output[3] << std::endl;
    }
    return 0;
}

使用clang -O3为x86-64编译BitwiseWind生成21条指令，比静态数组版本多6条，但没有任何内存引用。 这有点令人失望，但我希望它可以为ARM目标生成更少的指令，利用位域提取操作码。 顺便提一下，使用output[i] = array[(i+(i==winding)*2)&3];的内联版本output[i] = array[(i+(i==winding)*2)&3]; 产生25条没有任何跳转的指令，而gcc -O3则更糟糕：它通过4次测试和跳转产生了更多的代码。

下面的通用getIndex函数只编译为6 x86指令：

int getIndex(int i, int edge) {
    return (((0x00010201 << BOTTOM * 2) |
             (0x02010203 << RIGHT  * 2) |
             (0x02030003 << TOP    * 2) |
             (0x00030001 << LEFT   * 2))
            >> (edge * 2 + 24 - i * 8)) & 3;
}

Answer 2

是否有一个特殊的原因需要使用大量的按位操作？ 这似乎是一个解决问题的复杂方法？

您似乎非常担心速度，例如，您不想使用模数，因为它很昂贵。 在这种情况下，为什么不只是使用一个非常简单的查找并展开循环？ 关于ideone的例子。

编辑：感谢chqrlie输入。 相应地更新了答案。

#include <iostream>

using namespace std;

enum WindingOrder {
    BOTTOM = 0,
    RIGHT,
    TOP,
    LEFT
};

void DoWinding1(unsigned int const *const in, unsigned int *const out, const enum WindingOrder ord)
{
    static const unsigned int order[4][4] = { [BOTTOM] = {0,1,2,1},
                                              [RIGHT]  = {2,1,2,3},
                                              [TOP]    = {2,3,0,3},
                                              [LEFT]   = {0,3,0,1} };
    out[0] = in[order[ord][0]]; 
    out[1] = in[order[ord][1]];
    out[2] = in[order[ord][2]];
    out[3] = in[order[ord][3]];
}


int main() {
    unsigned int idx;
    unsigned int rect[4] = {1, 3, 4, 5};
    unsigned int out[4] = {0};

    DoWinding1(rect, out, BOTTOM);

    std::cout << out[0] << out[1] << out[2] << out[3] << std::endl;

    return 0;
}

Answer 3

这是未经测试的，在某些细节上可能存在一个小错误，但总体思路应该有效。

将数组复制到输出将使用索引{0,1,2,3} 。 要获得特定边缘，您必须对索引进行一些转换：

                    changed_pos  changed_to
RIGHT : {2,1,2,3}       0           2
TOP   : {0,3,2,3}       1           3
LEFT  : {0,1,0,3}       2           0
BOTTOM: {0,1,2,1}       3           1

所以基本上你必须为你的绕组的特定位置添加2 mod 4 。 所以（就像我说的未经测试）剪断可能看起来像这样

for (size_t i=0; i<4; ++i) {
    output[i] = array[(i+(i==edge)*2)%4];
}

如果比较为真，则将1*2=2 ，否则0*2=0到索引，并执行mod 4以保持在该范围内。

你的enum必须看起来像这样（但我想你自己想出来了）：

enum WindingOrder {
    RIGHT,
    TOP,
    LEFT,
    BOTTOM
};

MWE ：

#include <iostream>
#include <string>
#include <vector>

enum WindingOrder {
    RIGHT=0,
    TOP,
    LEFT,
    BOTTOM
};

int main()
{
    std::vector<int> array = {2,4,8,9};
    std::vector<int> output(4);

    std::vector<WindingOrder> test = {LEFT,RIGHT,BOTTOM,TOP};
    for (auto winding : test) {
        for (size_t i=0; i<4; ++i) {
            output[i] = array[(i+(i==winding)*2)%4];
        }
        std::cout << "winding " << winding << ": " << output[0] << output[1] << output[2] << output[3] << std::endl;
    }
}

Answer 4

是否可以重新定义WindingOrder的值集？ 如果可能的话，这是我的解决方案，它尝试在WindingOrder的值集中编码选择索引，然后只需通过移位和屏蔽解码input[]的选择索引，只要output[]索引迭代。

[感谢chqrlie提供代码库]：

    #include <iostream>

enum WindingOrder {
    // the RIGHT most 4-bits indicate the selection index from input[] to output[0]
    // the LEFT most 4-bits indicate the selection index from input[] to output[3]
    BOTTOM = 0x1210,
    RIGHT = 0x3212,
    TOP = 0x3230,
    LEFT = 0x3010
};

void BitwiseWind(int const *input, int *output, unsigned short edge)
{
    for (size_t i = 0; i < 4; i++)
        output[i] = input[(edge >> (i*4)) & 0x000F];    // decode
}

int main() {
    enum WindingOrder edges[4] = { BOTTOM, RIGHT, TOP, LEFT };
    int rect[4] = { 1, 3, 4, 5 };
    int output[4];

    for (int i = 0; i < 4; i++) {
        BitwiseWind(rect, output, edges[i]);
        std::cout << output[0] << output[1] << output[2] << output[3] << std::endl;
    }
    return 0;
}

通用的getIndex（int i，enum WindingOrder edge）将是：

int getIndex(int i,enum WindingOrder edge)
{
   return ((edge >> (i*4)) & 0x000F);
}

我没有计算它使用了多少指令，但我相信它会很安静。 并且很容易想象它是如何工作的。 :)

Answer 5

从你自己的答案来看，你接近解决方案。 我认为你需要的是卡诺图 ，这是大多数布尔代数问题的通用方法。

假设

然后，数组的元素分别定义：

 input[0]: Left edge's X coordinate input[0]: Bottom edge's Y coordinate input[0]: Right edge's X coordinate input[0]: Top edge's Y coordinate 

我在这个枚举中定义了一个绕线顺序：

 enum WindingOrder { BOTTOM = 0, RIGHT, TOP, LEFT }; 

因为for循环可能看起来像

for (int k = 0; k != 4; ++k) {
    int i = getIndex(k, edge); // calculate i from k and edge
    output[k] = square[i];
}

然后输入是k （ output[k] ）和edge ，输出是i （ square[i] ）。 因为i有2位，所以需要两个逻辑功能。

这里我们使用P = F1(A, B, C, D)和Q = F2(A, B, C, D)来表示逻辑函数，其中A ， B ， C ， D ， P和Q都是单一的位，和

k    = (A << 1) + B;
edge = (C << 1) + D;
i    = (P << 1) + Q;

那么我们需要做的就是从给定条件中推导出两个逻辑函数F1和F2 。

从您给出的switch case语句中，我们可以轻松获得真值表。

k\edge  0   1   3   2
    0   0   2   0   2
    1   1   1   3   3
    3   1   3   1   3
    2   2   2   0   0

然后将其分成两个P和Q真值表。

P   edge    0   1   3   2
k   AB\CD   00  01  11  10
0      00   0   1   0   1
1      01   0   0   1   1
3      11   0   1   0   1
2      10   1   1   0   0

Q   edge    0   1   3   2
k   AB\CD   00  01  11  10
0      00   0   0   0   0
1      01   1   1   1   1
3      11   1   1   1   1
2      10   0   0   0   0

这些是我在开始时提到的卡诺图。 我们可以轻松获得功能。

F1(A, B, C, D) = A~B~C + A~CD + ~B~CD + ~ABC + ~AC~D + BC~D
F2(A, B, C, D) = B

然后程序将是

int getIndex(int k, int edge) {
    int A = (k >> 1) & 1;
    int B = k & 1;
    int C = (edge >> 1) & 1;
    int D = edge & 1;
    int P = A&~B&~C | A&~C&D | ~B&~C&D | ~A&B&C | ~A&C&~D | B&C&~D;
    int Q = B;
    return (P << 1) + Q;
}

通过这里的检查。 当然，您可以使用XOR进一步简化功能。

---

编辑

使用XOR来简化表达式可以在大部分时间内实现，因为A^B == A~B + ~AB 。 但这可能不是你想要的东西。 首先，我认为产品总和（SoP）表达式与使用XOR的更简化版本之间的性能差异很小。 其次，没有通用的方法（据我所知）用XOR简化表达式，所以你必须依靠自己的经验来完成这项工作。

两个变量有16种可能的逻辑函数，但在数字逻辑硬件中，最简单的门电路只实现其中的四种：AND，OR，以及那些（NAND和NOR）的补码。 卡诺图用于简化实际逻辑要求，因此可以使用最少数量的物理逻辑门实现它们。

这里使用了两个常用表达式，产品总和和Sums表达式的乘积 。 这两个表达式可以直接只使用AND和OR逻辑运算符来实现。 它们可以直接用卡诺图来推断。

Answer 6

如果从左侧开始按顺时针顺序定义坐标和方向，

#define  LEFT   0
#define  TOP    1
#define  RIGHT  2
#define  BOTTOM 3

您可以使用

void edge_line(int line[4], const int rect[4], const int edge)
{
    line[0] = rect[   edge      & 2      ];
    line[1] = rect[ ((edge + 3) & 2) + 1 ];
    line[2] = rect[ ((edge + 1) & 2)     ];
    line[3] = rect[  (edge      & 2) + 1 ];
}

复制边线坐标（每个线段按顺时针顺序排列）。 它看起来不是最理想的，但使用-O2 ，GCC-4.8，你基本上得到了

edge_line:
        pushl   %esi
        pushl   %ebx
        movl    20(%esp), %ecx
        movl    16(%esp), %edx
        movl    12(%esp), %eax
        movl    %ecx, %esi
        andl    $2, %esi
        movl    (%edx,%esi,4), %ebx
        movl    %ebx, (%eax)
        leal    3(%ecx), %ebx
        addl    $1, %ecx
        andl    $2, %ebx
        andl    $2, %ecx
        addl    $1, %ebx
        movl    (%edx,%ebx,4), %ebx
        movl    %ebx, 4(%eax)
        movl    (%edx,%ecx,4), %ecx
        movl    %ecx, 8(%eax)
        movl    4(%edx,%esi,4), %edx
        movl    %edx, 12(%eax)
        popl    %ebx
        popl    %esi
        ret

但在64位，甚至更好

edge_line:
        movl    %edx, %ecx
        andl    $2, %ecx
        movslq  %ecx, %rcx
        movl    (%rsi,%rcx,4), %eax
        movl    %eax, (%rdi)
        leal    3(%rdx), %eax
        addl    $1, %edx
        andl    $2, %edx
        andl    $2, %eax
        movslq  %edx, %rdx
        cltq
        movl    4(%rsi,%rax,4), %eax
        movl    %eax, 4(%rdi)
        movl    (%rsi,%rdx,4), %eax
        movl    %eax, 8(%rdi)
        movl    4(%rsi,%rcx,4), %eax
        movl    %eax, 12(%rdi)
        ret

正如您所看到的，没有条件，二元运算符组合并优化到非常少的指令。

编辑添加：

如果我们定义一个getIndex(i, edge)函数，使用三个二进制AND，一个位移（右一个），三个加法和一个减法，

int getIndex(const int i, const int edge)
{
    return (i & 1) + ((edge + 4 - (i & 1) + (i >> 1)) & 2);
}

可以将edge_line()实现为

void edge_line(int line[4], const int rect[4], const int edge)
{
    line[0] = rect[ getIndex(0, edge) ];
    line[1] = rect[ getIndex(1, edge) ];
    line[2] = rect[ getIndex(2, edge) ];
    line[3] = rect[ getIndex(3, edge) ];
}

我们得到与以前完全相同的结果。 在AMD64 / x86-64上使用GCC-4.8.4和-O2编译为

getIndex:
        movl    %edi, %edx
        sarl    %edi
        andl    $1, %edx
        subl    %edx, %esi
        leal    4(%rsi,%rdi), %eax
        andl    $2, %eax
        addl    %edx, %eax
        ret

并

getIndex:
        movl    4(%esp), %eax
        movl    8(%esp), %edx
        movl    %eax, %ecx
        andl    $1, %ecx
        subl    %ecx, %edx
        sarl    %eax
        leal    4(%edx,%eax), %eax
        andl    $2, %eax
        addl    %ecx, %eax
        ret

在i686上。 请注意，我使用四乘四结果表到达上面的表格; 还有其他更严格的方法来构建它，甚至可能有更优化的形式。 因此，我认真地建议在函数上方添加一个巨大的注释，解释意图，最好还显示结果表。 就像是

/* This function returns an array index:
 *    0  for left
 *    1  for top
 *    2  for right
 *    3  for bottom
 * given edge:
 *    0  for left
 *    1  for top
 *    2  for right
 *    3  for bottom
 * and i:
 *    0  for initial x
 *    1  for initial y
 *    2  for final x
 *    3  for final y
 *
 * The result table is
 *     |  edge
 *     | 0 1 2 3
 * ----+-------
 * i=0 | 0 0 2 2
 * i=1 | 3 1 1 3
 * i=2 | 0 2 2 0
 * i=3 | 1 1 3 3
 *
 * Apologies for the write-only code.
*/

或类似的东西。

Answer 7

让我们调用我们的目标变量来用于索引squared ： int index 。

现在我们将创建一个表格，其中包含对edge与i的所需index ，其中edge跨越行， i沿着列向下：

 ║0│1│2│3
═╬═╪═╪═╪═
0║0│1│2│1
─╫─┼─┼─┼─
1║2│1│2│3
─╫─┼─┼─┼─
2║2│3│0│3
─╫─┼─┼─┼─
3║0│3│0│1

正是从这个很明显，最少的显著位index是总是奇数奇数i s乃至甚至i秒。 因此，如果我们能够找到最重要的index我们只需要或者使用i & 1 ，我们就有index 。 因此，让我们创建另一个表，其中包含与i表相同的edge的最重要的index位：

 ║0│1│2│3
═╬═╪═╪═╪═
0║0│0│1│0
─╫─┼─┼─┼─
1║1│0│1│1
─╫─┼─┼─┼─
2║1│1│0│1
─╫─┼─┼─┼─
3║0│1│0│0

我们在这里可以看到几件事：

1. 当i为0或3 ，列相同，仅取决于edge
   • 当edge为1或2时，将设置这些列
2. 当i为1或2 ，列彼此相反
   • 这些列时，只设edge最显著位或只有i最显著位设置

因此，让我们从突破edge开始，将i放入最不重要和最重要的位：

const int ib0 = i & 1;
const int ib1 = (i & 2) >> 1;
const int eb0 = edge & 1;
const int eb1 = (edge & 2) >> 1;

从这里我们可以很容易地发现i是0还是3 ：

const int iXor = ib0 ^ ib1;

对于0 / 3条件：

const int iXorCondition = ib1 ^ eb1;

和1 / 2条件：

const int iNXorCondition = eb0 ^ eb1;

现在我们只需要将它们与各自的iXor结合起来，并放回index的最低位：

const int index = ((iNXorCondition & ~iXor | iXorCondition & iXor) << 1) | ib0;

把这一切放在一个方便的功能中我们得到：

int getIndex(int i, int edge) {
    const int ib0 = i & 1;
    const int ib1 = (i & 2) >> 1;
    const int eb0 = edge & 1;
    const int eb1 = (edge & 2) >> 1;

    const int iXor = ib0 ^ ib1;

    const int iNXorCondition = eb0 ^ eb1;
    const int iXorCondition = ib1 ^ eb1;

    return ((iNXorCondition & ~iXor | iXorCondition & iXor) << 1) | ib0;
}

我在这里写了一个检查实例。

Answer 8

我想知道的是，我可以构造平方索引以在for循环中分配输出，而不使用if / case / ternary语句（换句话说使用逐位运算）？

我会问你在这方面的期望是什么？

我的观点是， switch-case结构通常会被编译器的优化代码完全重组。 IMO最好不要单独留下代码，让编译器这样做。

只有两个条件，其中Id改变了该视图;

• 您正在使用OpenCL（而不是C）编写，并希望优化代码，其中决策分支逻辑可能会对性能造成问题。

• 您希望使用显式编码进行SIMD矢量化。 有一些特殊操作可能会有所帮助，但它是一个编码选项，可以锁定在没有SIMD指令集的情况下在硬件上可能无法正常工作的事情（或者在不同的硬件上执行完全不同）。 值得注意的是，一些编译器可以使用正确的编码进行自动矢量化。

我认为用这些操作编码这些操作很少或没有优势，除了用于C的switch-case 。

Answer 9

这是实现这一目标的一种方法：

do {
    output[i] = square[
                (edge & 1) * (
                    !(i & 1) * ((edge + 1) & 2) + 
                    (i & 1) * (
                        (!((edge - 1)/2)&1) * i + 
                        (((edge - 1)/2)&1) * (4-i)
                    )
                ) +     
                !(edge & 1) * (
                    (i & 1) * (edge + 1) + 
                    !(i & 1) * ((edge & 2) - ((edge & 2)-1) * i)
                )
                ];
} while(++i <= LEFT);

为了帮助您理解我缩进代码，您显然可以擦除所有空格。 我已经把一个标签放在哪里，我想分开两个案例。 顺便说一下，对于两个不同的对称情况，计算分为两个部分，但我用不同的算法解决了每个情况，这样你就可以看到各种方法来实现。