列举1个log-Gabor的pytorch代码

以下是一个log-Gabor的pytorch代码：

import torch
import torch.nn.functional as F
import numpy as np

def log_gabor_filter(size, sigma, wavelength, orientation):
    """生成一个log-Gabor滤波器"""
    radius = size // 2
    y, x = np.ogrid[-radius:radius+1, -radius:radius+1]
    x *= np.cos(orientation)
    y *= np.sin(orientation)
    radius_squared = x**2 + y**2
    filter = np.exp(-0.5 * (np.log(radius_squared / sigma**2)**2)) * np.cos(2 * np.pi * radius / wavelength)
    return torch.from_numpy(filter).float()

filter = log_gabor_filter(64, 5, 10, np.pi/4)
image = torch.randn(1, 1, 256, 256)
filtered_image = F.conv2d(image, filter.view(1, 1, 64, 64), padding=32)

相关问题

log-Gabor的pytorch代码

我可以回答这个问题，以下是一个log-Gabor的pytorch代码示例：

import torch
import torch.nn.functional as F
import numpy as np

def log_gabor_filter(size, sigma, theta, lambd, gamma):
    """Generate a log-Gabor filter."""
    x, y = np.meshgrid(np.linspace(-size/2, size/2, size), np.linspace(-size/2, size/2, size))
    x_theta = x * np.cos(theta) + y * np.sin(theta)
    y_theta = -x * np.sin(theta) + y * np.cos(theta)
    gb = np.exp(-(np.log(x_theta**2 + y_theta**2) / 2 / np.log(sigma))**2) * np.cos(2 * np.pi * x_theta / lambd + gamma)
    return gb

class LogGaborFilter(torch.nn.Module):
    """Log-Gabor filter layer."""
    def __init__(self, size, sigma, theta, lambd, gamma):
        super(LogGaborFilter, self).__init__()
        self.filter = torch.nn.Parameter(torch.Tensor(log_gabor_filter(size, sigma, theta, lambd, gamma)))
        self.filter.requiresGrad = False

    def forward(self, x):
        return F.conv2d(x, self.filter.expand(x.shape[1], -1, -1, -1), padding=self.filter.shape[1]//2)

这个代码实现了一个log-Gabor滤波器层，可以用于图像处理任务。

log-gabor滤波器python代码

以下是 log-gabor 滤波器的 Python 代码：

import numpy as np
import cv2

def log_gabor_filter(image, sigma, theta, Lambda, psi, gamma):
    # 计算图像的傅里叶变换
    fft_image = np.fft.fft2(image)
    fft_shift_image = np.fft.fftshift(fft_image)

    # 构造 log-gabor 滤波器
    rows, cols = image.shape
    u, v = np.meshgrid(np.arange(-cols/2, cols/2), np.arange(-rows/2, rows/2))
    radius = np.sqrt(u**2 + v**2)
    radius[0, 0] = 1
    theta = theta * np.pi / 180
    wavelength = Lambda
    fo = 1.0 / wavelength
    sigma_f = fo / np.pi * np.sqrt(np.log(2) / 2) * (np.power(2, gamma) + 1) / (np.power(2, gamma) - 1)
    sigma_x = sigma / fo
    sigma_y = sigma / fo / gamma
    x_theta = u * np.cos(theta) + v * np.sin(theta)
    y_theta = -u * np.sin(theta) + v * np.cos(theta)
    gb = np.exp(-0.5 * (np.power(x_theta, 2) / np.power(sigma_x, 2) + np.power(y_theta, 2) / np.power(sigma_y, 2))) * np.cos(2 * np.pi * fo * x_theta + psi)
    gb = gb * (radius <= radius.max() / 2)

    # 对图像进行滤波
    filtered_image = np.fft.ifft2(np.fft.ifftshift(fft_shift_image * gb))

    return np.abs(filtered_image)

# 测试代码
if __name__ == '__main__':
    image = cv2.imread('lena.jpg', cv2.IMREAD_GRAYSCALE)
    filtered_image = log_gabor_filter(image, 10, 0, 10, 0, 0.5)
    cv2.imshow('filtered image', filtered_image.astype(np.uint8))
    cv2.waitKey(0)
    cv2.destroyAllWindows()

希望能对你有所帮助！