Question

我对取整结果有疑问。我有梯度矩阵，我的结果几乎与假设的相同。差不多。

我尝试使用FLOOR / ROUND / CEIL，但它没有任何改善。

uint16_t t1=0,t2=0,t3=0;
float a,b,c;
uint16_t value=0;
for (int j = 0; j < count; j++) {
    t1 = ceil(rgbLeft->r +(floor((rgbRight->r - rgbLeft->r) * j) / (count-1)));
    t2 = ceil(rgbLeft->g +(floor((rgbRight->g - rgbLeft->g) * j) / (count-1)));
    t3 = ceil(rgbLeft->b + (floor(rgbRight->b - rgbLeft->b) * j) / (count-1));

    value = (t1 << 11) | (t2 << 5) | (t3);
    vec.push_back(value);
}

输入

count始终为16。这是16x8的sizeof矩阵。我把这样的结构：

   typedef struct{
       unsigned int r:5;
       unsigned int g:6;
       unsigned int b:5;
   }RGB;

rgbLeft和rgbRight是RGB结构。例如，输入为1和16。我得到line：

0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F 0010

此示例的输入是1 16 16 1.（开头，结尾，结尾，结尾）。

首先，我从输入（1,16,16,1）中创建结构rgbLeft和rgbRight（val是开始顶部（rgbLeft），结束停止（rgbRight）

rgb->r = (val >> 11);
rgb->g = (val >> 5);
rgb->b = (val);

之后，我使用

uint16_t t1=0,t2=0,t3=0;
float a,b,c;
uint16_t value=0;
for (int j = 0; j < count; j++) {
    t1 = ceil(rgbLeft->r +(floor((rgbRight->r - rgbLeft->r) * j) / (count-1)));
    t2 = ceil(rgbLeft->g +(floor((rgbRight->g - rgbLeft->g) * j) / (count-1)));
    t3 = ceil(rgbLeft->b + (floor(rgbRight->b - rgbLeft->b) * j) / (count-1));

    value = (t1 << 11) | (t2 << 5) | (t3);
    vec.push_back(value);
}

最后我得到了：

0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F 0010

0002 0002 0003 0004 0005 0006 0006 0007 0008 0009 000A 000A 000B 000C 000D 000E

0004 0004 0005 0005 0006 0006 0007 0007 0008 0008 0009 < strong> 0009 000A 000A 000B 000C

0006 0006 0006 0006 0007 0007 0007 0007 0008 0008 0008 0008 0009 0009 0009 000A

0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008

000A 0009 0009 0009 0008 0008 0008 0008 0007 0007 0007 0007 0006 0006 0006 0006

000C 000B 000A 000A 0009 0009 0008 0008 0007 0007 0006 0006 0005 0005 0004 0004

000E 000D 000C 000B 000A 000A 0009 0008 0007 0006 0006 0005 0004 0003 0002 0002

0010 000F 000E 000D 000C 000B 000A 0009 0008 0007 0006 0005 0004 0003 0002 0001

但是我想（??）我必须有这样的东西：

0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F 0010

0002 0003 0004 0005 0005 0006 0007 0008 0008 0009 000A 000B 000B 000C 000D 000E

0004 0005 0005 0006 0006 0007 0007 0008 0008 0009 0009 < strong> 000A 000A 000B 000B 000C

0006 0006 0007 0007 0007 0007 0008 0008 0008 0008 0009 0009 0009 0009 000A 000A

0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008

000A 000A 0009 0009 0009 0009 0008 0008 0008 0008 0007 0007 0007 0007 0006 0006

000C 000B 000B 000A 000A 0009 0009 0008 0008 0007 0007 0006 0006 0005 0005 0004

000E 000D 000C 000B 000B 000A 0009 0008 0008 0007 0006 0005 0005 0004 0003 0002

0010 000F 000E 000D 000C 000B 000A 0009 0008 0007 0006 0005 0004 0003 0002 0001

例如输入0 0 3200 1800可以...

此处是测试每行的示例代码：

https://wandbox.org/permlink/bdkxrjxYtq6LHhMg

编辑。

我更改一点代码：

uint8_t t1=0,t2=0,t3=0;
int a=0,b=0,c=0;
uint16_t value=0;
for (int j = 0; j < count; j++) {
    t1 =round(rgbLeft->r + (((floor(rgbRight->r - rgbLeft->r) * j) / (count-1))));
    t2 =round(rgbLeft->g + (((floor(rgbRight->g - rgbLeft->g) * j) / (count-1))));
    t3 =round(rgbLeft->b + (((floor(rgbRight->b - rgbLeft->b) * j) / (count-1))));


    value = (t1 << 11) | (t2 << 5) | (t3);
    vec.push_back(value);
}

我得到

0001 0002 0003 0004 0005 0006 0007 0008 0009 000A 000B 000C 000D 000E 000F 0010

0002 0003 0004 0004 0005 0006 0007 0008 0008 0009 000A 000B 000C 000C 000D 000E

0004 0005 0005 0006 0006 0007 0007 0008 0008 0009 0009 000A 000A 000B 000B 000B 000C

0006 0006 0007 0007 0007 0007 0008 0008 0008 0008 0009 0009 0009 0009 000A 000A

0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008 0008

000A 000A 0009 0009 0009 0009 0008 0008 0008 0008 0007 0007 0007 0007 0006 0006

000C 000B 000B 000B 000A 000A 0009 0009 0008 0008 0007 0007 0006 0006 0005 0005 0004

000E 000D 000C 000C 000B 000A 0009 0008 0008 0007 0006 0005 0004 0004 0003 0002

0010 000F 000E 000D 000C 000B 000A 0009 0008 0007 0006 0005 0004 0003 0002 0001

假设有4点不同！

编辑：

tl：1

tr 16

bl 16

br 1

 RGB RGBtl, RGBtr, RGBbl, RGBbr;
        std::vector<uint16_t> firstColumn,lastColumn;

   valueToColorRGB(&RGBtl,tl);
   valueToColorRGB(&RGBtr,tr);
   valueToColorRGB(&RGBbl,bl);
   valueToColorRGB(&RGBbr,br);
   colorRGBtoVector(firstColumn,&RGBtl,&RGBbl,size.height);
   colorRGBtoVector(lastColumn,&RGBtr,&RGBbr,size.height);
    for (int j = 0; j < size.height; j++) {
        tl = firstColumn[j];
        tr = lastColumn[j];

        valueToColorRGB(&RGBtl,tl);
        valueToColorRGB(&RGBtr,tr);
        colorRGBtoVector2(vec3,&RGBtl,&RGBtr,size.width);
    }

valueToColorRGB(RGB *rgb, const uint16_t &val){
    rgb->r = (val >> 11);
    rgb->g = (val >> 5);
    rgb->b = (val);
}
colorRGBtoVector2(std::vector<uint16_t> &vec, RGB *rgbLeft, RGB *rgbRight, const uint16_t &count){
    uint8_t t1=0,t2=0,t3=0;
    int a=0,b=0,c=0;
    uint16_t value=0;
    for (int j = 0; j < count; j++) {
        t1 =(rgbLeft->r + ((floor(rgbRight->r - rgbLeft->r) * j) / (count-1)));
        t2 =(rgbLeft->g + ((floor(rgbRight->g - rgbLeft->g) * j) / (count-1)));
        t3 =(rgbLeft->b + ((floor(rgbRight->b - rgbLeft->b) * j) / (count-1)));


        value = (t1 << 11) | (t2 << 5) | (t3);
        vec.push_back(value);
    }
}

Answer 1

Your actual question可能归结为：

idk为什么（14-2）* 1/15 + 2 = 2

这是从您将获得的值中提取的：

rgbRight：14U
rgbLeft：2U
count：16
j：1

您的问题方程t3 = ceil(rgbLeft->b + (floor(rgbRight->b - rgbLeft->b) * j) / (count-1))将按以下顺序显示：

rgbRight->b - rgbLeft->b：12U
floor(rgbRight->b - rgbLeft->b)：12.0
floor(rgbRight->b - rgbLeft->b) * j：12.0
count - 1：15
(floor(rgbRight->b - rgbLeft->b) * j) / (count-1)：0.8
rgbLeft->b + (floor(rgbRight->b - rgbLeft->b) * j) / (count-1)：2.8
ceil(rgbLeft->b + (floor(rgbRight->b - rgbLeft->b) * j) / (count-1))：3.0

最后，对t3的分配 back 将强制转换为 3U not 2U，但会忽略警告。

我相信让您感到困惑的是，your linked tester 不使用double s ：(unsigned int)start.b + (((stop.b - start.b) * i) / (elems - 1))，其播放顺序如下：

(unsigned int)start.b：2U
stop.b - start.b：12U
(stop.b - start.b) * i：12
elems - 1：15
((stop.b - start.b) * i) / (elems - 1)：0
(unsigned int)start.b + (((stop.b - start.b) * i) / (elems - 1))：2U

请注意，此列表中的 5 执行整数除法，因此返回 0 ，而上一个列表中的 5 执行浮点除法并返回 0.8 。

我的代码获得正确的梯度有什么问题？

1 个答案: