Процессор билинейной фильтрации выходы и те же результаты, чем точка выборки ⇐ C++

[Anonymous]

Я добавляю билинейную фильтрацию в свое программное обеспечение для рендеринга C ++. Чтобы подтвердить, что это работает, я пытаюсь снизить тестовое изображение. Это:

, когда я выполняю билинеарное изменение размера, я, к сожалению, получаю почти тот же алиас. Почему ?:

Так выполняется прямое изменение:

Код: Выделить всё

const Graphics::Texture::SharedRGBAImagePtr input_image = Texture::Helper::createRGBAImage("D:\\resizing_test\\input_image.png");

const uint32_t destWidth = input_image->getWidth() / 16;
const uint32_t destHeight = input_image->getHeight() / 16;
Texture::RGB32FImage* resizedImage = new Texture::RGB32FImage(destWidth, destHeight);

for (uint32_t j = 0u; j < destHeight; ++j)
{
for (uint32_t i = 0u; i < destWidth; ++i)
{
const float xnorm = (float)i / (float)destWidth;
const float ynorm = (float)j / (float)destHeight;

#if 1
// Point sampling.
const float xpointSrcFloat = xnorm * ((nbFloat32)input_image->getWidth() - 1.0f);
const float ypointSrcFloat = ynorm * ((nbFloat32)input_image->getHeight() - 1.0f);

const Graphics::RGBAFColor color = input_image->getNormalizedPixelFromPosition(Math::Uvec2((uint32_t)xpointSrcFloat, (uint32_t)ypointSrcFloat));
resizedImage->setPixelFromPosition(Graphics::RGBFColor(color.x, color.y, color.z), Math::Uvec2(i, j));

#else
// Bilinear sampling.
const Graphics::RGBAFColor color = input_image->getNormalizedPixelFromRatio(Math::Vec2(xnorm, ynorm));
resizedImage->setPixelFromPosition(Graphics::RGBFColor(color.x, color.y, color.z), Math::Uvec2(i, j));
#endif
}
}

resizedImage->save("D:\\resizing_test\\ouput_image.png");

Определение getNormalizedPixelfRomposion .

Код: Выделить всё

template 
inline T TImage::getNormalizedPixelFromPosition(const Math::Uvec2& pos) const
{
const float div = isFloatingPointImage() ? 1.0f : 255.0f;
return getPixelFromPosition(pos) / div;
}

Определение getNormalizedPixelfRomratio . Это выполняет билинейную фильтрацию: < /p>
template
inline T TImage::getNormalizedPixelFromRatio(const Math::Vec2& ratio) const
{
const uint32_t widthMinusOne = getWidth() - 1u;
const uint32_t heightMinusOne = getHeight() - 1u;

// The sampling weights.
const Math::Vec2 C00Float = Math::Vec2(ratio.x * (float)getWidth(), ratio.y * (float)getHeight());
const Math::Vec2 weights = glm::fract(C00Float);

// The sampling coordinates.
const Math::Uvec2 C00 = Math::Uvec2(
Math::clamp((uint32_t)C00Float.x, 0u, widthMinusOne),
Math::clamp((uint32_t)C00Float.y, 0u, heightMinusOne));

const Math::Uvec2 C10 = Math::Uvec2(
Math::clamp(C00.x + 1u, 0u, widthMinusOne),
Math::clamp(C00.y, 0u, heightMinusOne));

const Math::Uvec2 C01 = Math::Uvec2(
Math::clamp(C00.x, 0u, widthMinusOne),
Math::clamp(C00.y + 1u, 0u, heightMinusOne));

const Math::Uvec2 C11 = Math::Uvec2(
Math::clamp(C00.x + 1u, 0u, widthMinusOne),
Math::clamp(C00.y + 1u, 0u, heightMinusOne));

// The sampling values.
const T V00 = getNormalizedPixelFromPosition(C00);
const T V10 = getNormalizedPixelFromPosition(C10);
const T V01 = getNormalizedPixelFromPosition(C01);
const T V11 = getNormalizedPixelFromPosition(C11);

// Perform the interpolation.
const auto lerp = [](T t1, T t2, float t3) { return t1 + (t2 - t1) * t3; };

const T p0 = lerp(V00, V01, weights.y);
const T p1 = lerp(V10, V11, weights.y);

return lerp(p0, p1, weights.x);
}
< /code>
Что я делаю не так? Я использую OpenCV для хранения и управления своими изображениями. Когда я использую собственное изменение размера, дает и те же результаты для отбора проб точки. < /P>
inline void BilinearScaling(const RGB32FImage& src, RGB32FImage& dest)
{
cv::resize(src.m_image,
dest.m_image,
cv::Size(dest.getWidth(), dest.getHeight()),
0.0,
0.0,
cv::InterpolationFlags::INTER_LINEAR);
}
< /code>
В любом случае, это не поможет, если он работает, потому что мне нужно интерполировать вручную. Моя конечная цель - интерполировать набор коэффициентов 8 сферических гармоник, а не цвет RGB или RGBA.

Подробнее здесь: https://stackoverflow.com/questions/795 ... t-sampling