Algorithmes de sous-échantillonnage d'image

Quelle est la meilleure ré-échantillonnage de l'algorithme que je peux utiliser pour diviser une image en la moitié de sa taille d'origine. La vitesse est de première importance, mais il ne devrait pas dégrader la qualité trop mauvaise. J'essaie de générer une image de la pyramide.

J'ai été à l'origine de la planification de sauter pixels. Est-ce la meilleure façon de procéder? De ce que j'ai lu que l'image produite par pixel sauter est trop forte. Quelqu'un qui a essayé ce commentaire. Mes images contiennent des données cartographiques sorte de c'.

source d'informationauteur sleeping.ninja | 2011-05-26

  1. 26

    Sauter des pixels de l'aliasing, où les changements de fréquence (comme l'alternance lumière/obscurité bandes) sera converti en basses fréquences (tels que la constante de lumière ou d'obscurité).

    Le moyen le plus rapide pour réduire de moitié sans aliasing est en moyenne de 2x2 pixels en un seul pixel. De meilleurs résultats peuvent être plus complexes de réduction des noyaux, mais ils vont se faire au détriment de la vitesse.

    Edit: Voici quelques exemples de techniques discutées jusqu'à présent.

    Ignorant tous les autres pixels, vous pouvez voir que les résultats ne sont pas très bon en regardant la légende sur le côté gauche. C'est presque illisible:

    Algorithmes de sous-échantillonnage d'image

    En moyenne tous les grille 2x2 - Le texte est maintenant forte et lisible:

    Algorithmes de sous-échantillonnage d'image

    Flou gaussien, comme suggéré par R. - un peu floues, mais plus lisible jusqu'à un certain point. La quantité de flou peut être réglé pour donner des résultats différents:

    Algorithmes de sous-échantillonnage d'image

    R. est également correcte sur la courbe Gamma affectant les résultats, mais cela ne devrait être visible dans les applications les plus exigeantes. Mes exemples ont été faites sans correction gamma.

  2. 6

    De la désagrégation, de la zone d'étalement (voir la Marque de la réponse) est à proximité des meilleurs que vous allez obtenir.

    La principale autre candidat est gaussienne, avec un légèrement plus grand rayon. Cela permettra d'accroître le flou un peu, ce qui pourrait être vu comme un inconvénient, mais rendrait le flou de plus en plus uniforme plutôt que d'dépend de l'alignement des pixels mod 2.

    Dans le cas où il n'est pas immédiatement clair ce que je veux dire, considérer le pixel modèles 0,0,2,2,0,0 et 0,0,0,2,2,0. Avec zone moyenne, ils étaient à la baisse de 0,2,0 et 0,1,1, respectivement, sera net et lumineux, tandis que l'autre sera floue et sombre. À l'aide d'un filtre plus long, à la fois flous, mais ils apparaissent de plus en plus semblables, qui sans doute des questions à des observateurs humains.

    Une autre question à examiner est de gamma. À moins que le gamma est linéaire, deux pixels d'intensité k aura beaucoup moins d'intensité que d'un seul pixel d'intensité 2*k. Si votre filtre effectue suffisamment de flou, il pourrait ne pas beaucoup d'importance, mais avec la région de la plaine-filtre de moyenne, il peut être un problème majeur. La seule façon de contourner ce que je sais c'est d'appliquer et d'inverser la courbe gamma avant et après la mise à l'échelle...

  3. 4

    Si la vitesse est un problème, comme mentionné, je recommande de prendre un Bloc 2x2 et de calculer la moyenne du pixel. La qualité n'est pas le meilleur qui peut être atteint, mais à proximité. Vous pouvez provoquer cet algorithme pour montrer ses faiblesses, mais sur la plupart des images que vous ne verrez pas de différence, qui justifieraient le nombre de fois plus de temps de calcul.
    Vous aussi vous n'avez pas la moindre surcharge de la mémoire.
    Si la couleur de la résolution peut être abaissé à 6bit par canal, voici une jolie façon rapide qui vous empêche de la décomposition de l'ARGB canaux (ici en supposant 32bit ARGB):

    destPixel[x,y] = ((sourcePixel[2*x  ,2*y  ]>>2)&0x3f3f3f3f) +
                 ((sourcePixel[2*x+1,2*y  ]>>2)&0x3f3f3f3f) +
                 ((sourcePixel[2*x  ,2*y+1]>>2)&0x3f3f3f3f) +
                 ((sourcePixel[2*x+1,2*y+1]>>2)&0x3f3f3f3f);

    Des effets secondaires de cette alogrithm est, que s'il est enregistré en tant que fichiers PNG, la taille du fichier est plus petit.
    C'est à quoi il ressemble:
    Algorithmes de sous-échantillonnage d'image

  4. 2

    J'ai essayé de généraliser Thilo Köhler la solution (mais en Python):

    STRIDE = 2
MASK = 0x3F3F3F3F
color = 0
for Δx, Δy in itertools.product(range(STRIDE), repeat=2):
    color += (get_pixel(x + Δx, y + Δy) //STRIDE) & MASK

    Cela fonctionne bien pour la mise à l'échelle par 2 (quart de la taille de résultat), mais ne fonctionne pas pour la mise à l'échelle par 3 ou 4 ou d'autres valeurs int. Est-il possible de généraliser ce?

    BTW pour les non-Pythoneux pour la boucle ci-dessus est équivalent à ceci (sauf que la première version est évolutive par la modification de la FOULÉE):

    for Δx, Δy in [(0, 0), (0, 1), (1, 0), (1, 1)]:
    color += (get_pixel(x + Δx, y + Δy) //STRIDE) & MASK

    Je suis en utilisant 32 bits ARGB valeurs.

  5. 1

    La NetPBM suite inclut un utilitaire appelé pamscalequi offre quelques options pour le sous-échantillonnage. Il est open source, donc vous pouvez essayer les différentes options, puis copier l'algorithme que vous aimez le plus (ou simplement l'utiliser libnetpbm).