Comment dois-je faire de haute qualité de mise à l'échelle d'une image?

Je suis en train d'écrire un peu de code pour mettre à l'échelle un 32 bits RGBA image en C/C++. J'ai écrit quelques tentatives qui ont connu un certain succès, mais ils sont lents, et surtout la qualité de la taille d'image n'est pas acceptable.

J'ai comparé la même image à l'échelle en OpenGL (c'est à dire ma carte vidéo) et ma routine et c'est miles de distance en qualité. J'ai Cherché sur Google Code, parcouru source arbres de ce que je pensais serait de jeter un peu de lumière (SDL, Allegro, wxWidgets, CxImage, GD, ImageMagick, etc.) mais généralement, leur code est alambiqué et dispersées au-dessus de l'endroit ou criblé avec l'assembleur et peu ou pas de commentaires. J'ai aussi lu plusieurs articles sur Wikipédia et ailleurs, et je ne suis pas à trouver une explication claire de ce dont j'ai besoin. Je comprends les concepts de base de l'interpolation et de l'échantillonnage, mais j'ai du mal à obtenir de l'algorithme de droit. Je ne veux PAS compter sur une bibliothèque externe pour l'un de routine et avoir à les convertir à leur format d'image et à l'arrière. D'ailleurs, j'aimerais savoir comment le faire moi-même de toute façon. 🙂

J'ai vu une question similaire posée sur un débordement de pile avant, mais ce n'était pas vraiment répondu de cette façon, mais je suis en espérant qu'il ya quelqu'un là-bas qui peut m'aider à déplacer dans la bonne direction. Peut-être m'indiquer certains des articles ou des pseudo-code... rien pour m'aider à apprendre et à faire.

Voici ce que je suis à la recherche de:

  1. Pas de l'assembleur (je suis en train d'écrire très portable code pour plusieurs types de processeurs).
  2. Pas de dépendances sur les bibliothèques externes.
  3. Je suis principalement concernée par la mise à l'échelle vers le BAS, mais aussi besoin d'écrire une échelle de routine plus tard.
  4. Qualité du résultat et la clarté de l'algorithme est le plus important (je peux l'optimiser plus tard).

Ma routine essentiellement prend la forme suivante:

DrawScaled(uint32 *src, uint32 *dst, 
      src_x, src_y, src_w, src_h, 
      dst_x, dst_y, dst_w, dst_h );

Merci!

Mise à JOUR: Pour clarifier, j'ai besoin de quelque chose de plus avancé que d'une case rééchantillonnage pour désagrégation qui brouille l'image en trop. Je soupçonne ce que je veux, c'est une sorte de bicubique (ou d'autres) filtre qui est un peu l'inverse d'une interpolation bicubique algorithme (c'est à dire chaque destination pixel est calculée à partir de tous de contribuer pixels source combinée avec un algorithme de pondération qui empêche les choses de sharp.

Exemple

Voici un exemple de ce que je reçois de la wxWidgets BoxResample algorithme vs ce que je veux sur un 256x256 bitmap mis à l'échelle pour 55x55.

  • www.free_image_hosting.net/uploads/1a25434e0b.png

Et enfin:

  • www.free_image_hosting.net/uploads/eec3065e2f.png

l'origine de 256x256 pixels de l'image

  • J'ai pris votre image source et de ré-appliquer la mise à l'échelle en utilisant wxWidgets pour obtenir le suivant freeimagehosting.net/image.php?128f096527.png Comme vous pouvez le voir, il n'est pas tout à fait aussi forte que l'OpenGL, mais c'est bien l'anti-aliasing et beaucoup plus nette que votre wx exemple.