Algorithm 缩小32位RGB图像的最快算法

使用哪种算法将32位RGB图像缩小到自定义分辨率？算法应该平均像素

例如，如果我有100x100个图像，我想要尺寸为20x50的新图像。第一源行的前五个像素的平均值将给出dest的第一个像素，第一源列的前两个像素的平均值将给出dest列的第一个像素

目前我所做的是先缩小X分辨率，然后再缩小Y分辨率。在这个方法中我需要一个临时缓冲区

---

你知道有什么优化的方法吗？

如果你想找一个冗长的解释，我觉得很有帮助。另一方面，如果你在数学公式方面做得更多，有一种快速图像缩小的方法可以解释。

如果你想找一个冗长的解释，我发现这很有帮助。另一方面，如果你在数学公式方面做得更多，就会有一种快速图像缩小的方法被解释。

你忘了提到这个问题最重要的方面：你有多在乎质量。如果您不关心源像素的值是如何被粉碎在一起以创建目标像素的，那么最快的（至少在几乎所有情况下）就是产生最差质量的像素

如果你想用“最快的算法仍然能产生很好的质量”来回答，那么你基本上已经涵盖了整个算法领域，只涉及图像采样/调整大小

您已经概述了算法的初始想法：

第一个像素的前五个像素的平均值 源行将给出源行的第一个像素 目的地

计算源像素上每个通道的平均值可能被认为是微不足道的，您是否正在寻找这样做的示例代码

---

或者你是在找人用更快的方法挑战你的算法初稿吗？

你忘了提到问题最重要的方面：你有多在乎质量。如果您不关心源像素的值是如何被粉碎在一起以创建目标像素的，那么最快的（至少在几乎所有情况下）就是产生最差质量的像素

如果你想用“最快的算法仍然能产生很好的质量”来回答，那么你基本上已经涵盖了整个算法领域，只涉及图像采样/调整大小

您已经概述了算法的初始想法：

第一个像素的前五个像素的平均值 源行将给出源行的第一个像素 目的地

计算源像素上每个通道的平均值可能被认为是微不足道的，您是否正在寻找这样做的示例代码

---

或者你是在找人用更快的方法挑战你的算法初稿吗？

你正在做的是优化方法。唯一快的一个称为最近邻，你只需抓住中间像素的范围，而不试图平均任何他们。如果原始图像中存在任何细节，则质量会明显降低，尽管如果原始图像简单，则质量可以接受。

您所做的是优化方法。唯一快的一个称为最近邻，你只需抓住中间像素的范围，而不试图平均任何他们。如果原始图像中存在任何细节，则质量会显著降低，尽管如果原始图像很简单，则质量可能可以接受。

这将对适当的像素进行平均

 w_ratio = src.w / dest.w
 h_ratio = src.h / dest.h

 dest[x,y] = 
    AVG( src[x * w_ratio + xi, y * h_ratio + yi] ) 
      where
           xi in range (0, w_ratio - 1), inc by 1
           yi in range (0, h_ratio - 1), inc by 1

对于边界条件，执行一个单独的循环（循环中没有if）

下面是一个更像C的代码：

src和dest是位图：
*像素的属性src[x，y] *宽度的属性src.w
*高度的属性src.h

像素已定义为

添加

p1 = p1 + p2     
is same as
p1.r = p1.r + p2.r
p1.g = p1.g + p2.g
...

分部

p1 = p1 / c
p1.r = p1.r / c
p1.g = p1.g / c

使用常数0进行求值

p1 = 0
p1.r = 0
p1.g = 0
...

为了简单起见，当像素组件整数溢出时，我不会考虑这个问题…

float w_ratio = src.w / dest.w;
float h_ratio = src.h / dest.h;
int w_ratio_i = floor(w_ratio);
int h_ratio_i = floor(h_ratio);

wxh = w_ratio*h_ratio;

for (y = 0; y < dest.w; y++)
for (x = 0; x < dest.h; x++){
    pixel temp = 0;     

    int srcx, srcy;
    // we have to use here the floating point value w_ratio, h_ratio
    // otherwise towards the end it can get a little wrong
    // this multiplication can be optimized similarly to Bresenham's line
    srcx = floor(x * w_ratio);
    srcy = floor(y * h_ratio);

    // here we use floored value otherwise it might overflow src bitmap
    for(yi = 0; yi < h_ratio_i; yi++)
    for(xi = 0; xi < w_ratio_i; xi++)
            temp += src[srcx + xi, srcy + yi];
    dest[x,y] = temp / wxh;
}

float w_ratio=src.w/dest.w；
浮动h_比率=src.h/目的地h；
int w_比率=楼层（w_比率）；
int h_比率=楼层（h_比率）；
wxh=w_比*h_比；
对于（y=0；y

---

这是适当像素的平均值

 w_ratio = src.w / dest.w
 h_ratio = src.h / dest.h

 dest[x,y] = 
    AVG( src[x * w_ratio + xi, y * h_ratio + yi] ) 
      where
           xi in range (0, w_ratio - 1), inc by 1
           yi in range (0, h_ratio - 1), inc by 1

对于边界条件，执行一个单独的循环（循环中没有if）

下面是一个更像C的代码：

src和dest是位图：
*像素的属性src[x，y] *宽度的属性src.w
*高度的属性src.h

像素已定义为

添加

p1 = p1 + p2     
is same as
p1.r = p1.r + p2.r
p1.g = p1.g + p2.g
...

分部

p1 = p1 / c
p1.r = p1.r / c
p1.g = p1.g / c

使用常数0进行求值

p1 = 0
p1.r = 0
p1.g = 0
...

为了简单起见，当像素组件整数溢出时，我不会考虑这个问题…

float w_ratio = src.w / dest.w;
float h_ratio = src.h / dest.h;
int w_ratio_i = floor(w_ratio);
int h_ratio_i = floor(h_ratio);

wxh = w_ratio*h_ratio;

for (y = 0; y < dest.w; y++)
for (x = 0; x < dest.h; x++){
    pixel temp = 0;     

    int srcx, srcy;
    // we have to use here the floating point value w_ratio, h_ratio
    // otherwise towards the end it can get a little wrong
    // this multiplication can be optimized similarly to Bresenham's line
    srcx = floor(x * w_ratio);
    srcy = floor(y * h_ratio);

    // here we use floored value otherwise it might overflow src bitmap
    for(yi = 0; yi < h_ratio_i; yi++)
    for(xi = 0; xi < w_ratio_i; xi++)
            temp += src[srcx + xi, srcy + yi];
    dest[x,y] = temp / wxh;
}

float w_ratio=src.w/dest.w；
浮动h_比率=src.h/目的地h；
int w_比率=楼层（w_比率）；
int h_比率=楼层（h_比率）；
wxh=w_比*h_比；
对于（y=0；y