[PYTHON] Traitement d'image 100 coups Q9, Q10 (filtre) speedup

Récemment, j'ai commencé à frapper 100 traitement d'image. https://qiita.com/yoyoyo_/items/2ef53f47f87dcf5d1e14

Récemment, j'étais un peu intéressé par le traitement d'image et je voulais bien utiliser numpy, donc je suis très reconnaissant pour cette série de problèmes, mais je ne suis pas satisfait des exemples de réponse de Q.9. Filtre gaussien et Q.10. Filtre médian. Il y avait (je ne veux pas utiliser l'instruction for en python!), J'ai donc écrit un processus qui utilise numpy autant que possible et comparé la vitesse.

Le code que j'ai écrit cette fois:

def gaussian_filter(_img, filter_matrix):
    # assume that fY and fX is odd number
    (fY, fX) = filter_matrix.shape
    mY = (fY - 1) // 2
    mX = (fX - 1) // 2

    (Y, X, C) = _img.shape
    img = np.zeros((Y + mY*2, X + mX*2, C))
    img[mY:Y+mY, mX:X+mX, :] = _img

    out_img = np.zeros_like(_img, np.float32)
    for dy in range (fY):
        for dx in range(fX):
            out_img += filter_matrix[dy][dx] * img[dy:Y+dy, dx:X+dx, :]
    return out_img.astype(np.uint8)

En tournant y, x de filter_matrix avec for au lieu de y, x de l'image, l'ajout dans l'image peut utiliser pour de numpy. Comparaison de vitesse Nous avons appelé gaussian_filter 100 fois et avons comparé le nombre de secondes nécessaires. Puisque la commande time est utilisée, le temps pour un chargement d'image est inclus, mais je ne pense pas que cela affectera beaucoup de gens.

Méthode	temps
Ce code	0.72
Le modèle de réponse	50.60

N'est-ce pas accablant? Q10 Concernant le filtre médian, je pense qu'il peut être accéléré en créant une image (?) Of H * W * (filter_size) puis en faisant np.median (axis = 2) sur cette image. .. ~~ C'est fait.

def median_filter(_img, filter_size):
    # assume that filter_size is odd
    half_size = (filter_size - 1) // 2
    (Y, X, C) = _img.shape
    img = np.zeros((Y + half_size*2, X + half_size*2, C))
    img[half_size:Y+half_size, half_size:X+half_size, :] = _img

    out_img = np.zeros_like(_img)
    for c in range(C):
        big_ch_img = np.zeros((Y, X, filter_size**2))
        for fy in range(filter_size):
            for fx in range(filter_size):
                ch = fy * filter_size + fx
                big_ch_img[:,:,ch] = img[fy:fy+Y, fx:fx+X,c]
        out_img[:,:,c] = np.median(big_ch_img, axis=2)
    return out_img

Le temps de mesure était de 1,71 seconde contre 302,98 secondes.

Au fait, je n'ai pas trouvé de moyen d'éviter d'utiliser l'instruction for pour la mise en commun, alors faites-le moi savoir si quelqu'un le sait.