Php Imagick:：thumbnailImage（）和Imagick:：adaptiveResizeImage（）之间的差异

首先，我知道

Imagick:：resizeImage

给了我更多的选择

有人能告诉我这两种方法使用哪种过滤器吗

它们似乎创建了几乎相同的图像，除了（在我的测试图像上）thumbnailImage（）1从左上角移动了一个像素

更新

---

我发现这两种方法是ImageMagick的

MagickThumbnailImage

和

MagickAdaptiveResizeImage

。他们的文档没有指定使用哪些过滤器。

使用thumbnailImage对的调用链是MagickThumbnailImage->ResizeImage，其中LanczosFilter的过滤器类型似乎被设置为默认值（除非该图像与过滤器关联）

adaptiveResize image的调用链是MagickAdaptiveResizeImage->AdaptiveResizeImage->InterpologiveResizeImage（图像、列、行、网格InterpologePixel）->InterpologeMagickPixelPacket

“网格插值像素”类型的InterpolateMagickPixelPacket中的代码如下所示

case MeshInterpolatePixel:
{
  PointInfo
    delta,
    luma;

  p=GetCacheViewVirtualPixels(image_view,x_offset,y_offset,2,2,
    exception);
  if (p == (const PixelPacket *) NULL)
    {
      status=MagickFalse;
      break;
    }
  indexes=GetCacheViewVirtualIndexQueue(image_view);
  for (i=0; i < 4L; i++)
  {
    GetMagickPixelPacket(image,pixels+i);
    AlphaBlendMagickPixelPacket(image,p+i,indexes+i,pixels+i,alpha+i);
  }
  delta.x=x-x_offset;
  delta.y=y-y_offset;
  luma.x=fabs(MagickPixelLuma(pixels+0)-MagickPixelLuma(pixels+3));
  luma.y=fabs(MagickPixelLuma(pixels+1)-MagickPixelLuma(pixels+2));
  if (luma.x < luma.y)
    {
      /*
        Diagonal 0-3 NW-SE.
      */
      if (delta.x <= delta.y)
        {
          /*
            Bottom-left triangle  (pixel:2, diagonal: 0-3).
          */
          delta.y=1.0-delta.y;
          gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
          gamma=PerceptibleReciprocal(gamma);
          pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
            pixels[3].red,pixels[0].red);
          pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
            pixels[3].green,pixels[0].green);
          pixel->blue=gamma*MeshInterpolate(&delta,pixels[2].blue,
            pixels[3].blue,pixels[0].blue);
          if (image->colorspace == CMYKColorspace)
            pixel->index=gamma*MeshInterpolate(&delta,pixels[2].index,
              pixels[3].index,pixels[0].index);
          gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
          pixel->opacity=gamma*MeshInterpolate(&delta,pixels[2].opacity,
            pixels[3].opacity,pixels[0].opacity);
        }
      else
        {
          /*
            Top-right triangle (pixel:1, diagonal: 0-3).
          */
          delta.x=1.0-delta.x;
          gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
          gamma=PerceptibleReciprocal(gamma);
          pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
            pixels[0].red,pixels[3].red);
          pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
            pixels[0].green,pixels[3].green);
          pixel->blue=gamma*MeshInterpolate(&delta,pixels[1].blue,
            pixels[0].blue,pixels[3].blue);
          if (image->colorspace == CMYKColorspace)
            pixel->index=gamma*MeshInterpolate(&delta,pixels[1].index,
              pixels[0].index,pixels[3].index);
          gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
          pixel->opacity=gamma*MeshInterpolate(&delta,pixels[1].opacity,
            pixels[0].opacity,pixels[3].opacity);
        }
    }
  else
    {
      /*
        Diagonal 1-2 NE-SW.
      */
      if (delta.x <= (1.0-delta.y))
        {
          /*
            Top-left triangle (pixel: 0, diagonal: 1-2).
          */
          gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
          gamma=PerceptibleReciprocal(gamma);
          pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
            pixels[1].red,pixels[2].red);
          pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
            pixels[1].green,pixels[2].green);
          pixel->blue=gamma*MeshInterpolate(&delta,pixels[0].blue,
            pixels[1].blue,pixels[2].blue);
          if (image->colorspace == CMYKColorspace)
            pixel->index=gamma*MeshInterpolate(&delta,pixels[0].index,
              pixels[1].index,pixels[2].index);
          gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
          pixel->opacity=gamma*MeshInterpolate(&delta,pixels[0].opacity,
            pixels[1].opacity,pixels[2].opacity);
        }
      else
        {
          /*
            Bottom-right triangle (pixel: 3, diagonal: 1-2).
          */
          delta.x=1.0-delta.x;
          delta.y=1.0-delta.y;
          gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
          gamma=PerceptibleReciprocal(gamma);
          pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
            pixels[2].red,pixels[1].red);
          pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,
            pixels[2].green,pixels[1].green);
          pixel->blue=gamma*MeshInterpolate(&delta,pixels[3].blue,
            pixels[2].blue,pixels[1].blue);
          if (image->colorspace == CMYKColorspace)
            pixel->index=gamma*MeshInterpolate(&delta,pixels[3].index,
              pixels[2].index,pixels[1].index);
          gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
          pixel->opacity=gamma*MeshInterpolate(&delta,pixels[3].opacity,
            pixels[2].opacity,pixels[1].opacity);
        }
    }
  break;
}

case mesh插值epixel:
{
点信息
三角洲，
卢马；
p=GetCacheViewVirtualPixels（图像视图，x偏移，y偏移，2,2，
例外情况）；
如果（p==（常量像素数据包*）为空）
{
状态=MagickFalse；
打破
}
索引=GetCacheViewVirtualIndexQueue（图像视图）；
对于（i=0；i<4L；i++）
{
GetMagickPixelPacket（图像，像素+i）；
AlphaBlendMagickPixelPacket（图像，p+i，索引+i，像素+i，alpha+i）；
}
δx=x-x_偏移量；
δy=y-y_偏移量；
luma.x=fabs（MagickPixelLuma（像素+0）-MagickPixelLuma（像素+3））；
y=fabs（MagickPixelLuma（像素+1）-MagickPixelLuma（像素+2））；
if（luma.x绿色=gamma*网格插值（&delta，像素[2]。绿色，
像素[3]。绿色，像素[0]。绿色）；
像素->蓝色=gamma*网格插值（&delta，像素[2]。蓝色，
像素[3]。蓝色，像素[0]。蓝色）；
如果（图像->颜色空间==CMYKColorspace）
像素->索引=gamma*网格插值（&delta，像素[2]。索引，
像素[3]。索引，像素[0]。索引；
gamma=网格插值（&delta，1.0,1.0,1.0）；
像素->不透明度=gamma*网格插值（&delta，像素[2]。不透明度，
像素[3]。不透明度，像素[0]。不透明度）；
}
其他的
{
/*
右上三角形（像素：1，对角线：0-3）。
*/
δx=1.0-δx；
gamma=网格插值（&delta，α[1]，α[0]，α[3]）；
gamma=可感知的交互（gamma）；
像素->红色=伽马*网格插值（&D），像素[1]。红色，
像素[0]。红色，像素[3]。红色）；
像素->绿色=gamma*网格插值（&delta，像素[1]。绿色，
像素[0]。绿色，像素[3]。绿色）；
像素->蓝色=gamma*网格插值（&delta，像素[1]。蓝色，
像素[0]。蓝色，像素[3]。蓝色）；
如果（图像->颜色空间==CMYKColorspace）
像素->索引=gamma*网格插值（&delta，像素[1]。索引，
像素[0]。索引，像素[3]。索引）；
gamma=网格插值（&delta，1.0,1.0,1.0）；
像素->不透明度=gamma*网格插值（&delta，像素[1]。不透明度，
像素[0]。不透明度，像素[3]。不透明度）；
}
}
其他的
{
/*
对角线1-2东北-西南。
*/
如果（delta.x red=gamma*mesh插值（&delta，像素[0]），则为红色，
像素[1]。红色，像素[2]。红色）；
像素->绿色=伽马*网格插值（&D），像素[0]。绿色，
像素[1]。绿色，像素[2]。绿色）；
像素->蓝色=gamma*网格插值（&delta，像素[0]。蓝色，
像素[1]。蓝色，像素[2]。蓝色）；
如果（图像->颜色空间==CMYKColorspace）
像素->索引=gamma*网格插值（&delta，像素[0]。索引，
像素[1]。索引，像素[2]。索引）；
gamma=网格插值（&delta，1.0,1.0,1.0）；
像素->不透明度=gamma*网格插值（&delta，像素[0]。不透明度，
像素[1]。不透明度，像素[2]。不透明度）；
}
其他的
{
/*
右下三角形（像素：3，对角线：1-2）。
*/
δx=1.0-δx；
δy=1.0-δy；
gamma=网格插值（&delta，α[3]，α[2]，α[1]）；
gamma=可感知的交互（gamma）；
像素->红色=伽马*网格插值（&D），像素[3]。红色，
像素[2]。红色，像素[1]。红色）；
像素->绿色=gamma*网格插值（&delta，像素[3]。绿色，
像素[2]。绿色，像素[1]。绿色）；
像素->蓝色=gamma*网格插值（&delta，像素[3]。蓝色，
像素[2]。蓝色，像素[1]。蓝色）；
如果（图像->颜色空间==CMYKColorspace）
像素->索引=gamma*网格插值（&delta，像素[3]。索引，
像素[2]。索引，像素[1]。索引）；
gamma=网格插值（&delta，1.0,1.0,1.0）；
像素->不透明度=gamma*网格插值（&delta，像素[3]。不透明度，
像素[2]。不透明度，像素[1]。不透明度）；
}
}
打破
}

---

因此，它没有使用任何已定义的过滤器。

您可以发布一个图像和代码示例吗？这听起来像是一个bug。