用Numpy实现的CLAHE函数：

以下是用 Numpy 实现的 CLAHE 函数代码：

import numpy as np
from numpy.lib.stride_tricks import as_strided

def clahe(image, clip_limit=0.03, grid_size=(8,8)):
    # Convert image to grayscale if necessary
    if image.ndim == 3:
        image = np.dot(image[...,:3], [0.2989, 0.5870, 0.1140])
    
    # Calculate histogram for the image
    hist, bins = np.histogram(image.flatten(), 256, [0,256])
    
    # Calculate maximum bin value for the clip limit
    max_bin = np.max(hist)
    clip_limit = max(int(clip_limit*image.size), max_bin)
    
    # Calculate cumulative distribution function (CDF)
    cdf = np.cumsum(hist)
    
    # Calculate CDF for clipped histogram
    clipped_hist = np.clip(hist, 0, clip_limit)
    clipped_cdf = np.cumsum(clipped_hist)
    
    # Calculate equalized pixel values
    equalized_values = (clipped_cdf/cdf.max()*255).astype('uint8')
    
    # Map equalized pixel values to image
    equalized_image = equalized_values[image]
    
    # Create tiles for adaptive histogram equalization
    tile_size = (np.array(image.shape)//np.array(grid_size)).astype(int)
    padded_size = (np.ceil(image.shape/tile_size)*tile_size).astype(int)
    padded_image = np.zeros(padded_size, dtype=image.dtype)
    padded_image[:image.shape[0], :image.shape[1]] = image
    
    tiles = as_strided(padded_image,
                       shape=tuple(grid_size)+tuple(tile_size),
                       strides=padded_image.strides+padded_image.strides)
    
    # Apply adaptive histogram equalization to the tiles
    for i in range(grid_size[0]):
        for j in range(grid_size[1]):
            tile = tiles[i,j]
            tile_hist, _ = np.histogram(tile.flatten(), 256, [0,256])
            tile_max_bin = np.max(tile_hist)
            tile_clip_limit = max(int(clip_limit*tile.size/image.size), tile_max_bin)
            
            tile_cdf = np.cumsum(tile_hist)
            tile_clipped_hist = np.clip(tile_hist, 0, tile_clip_limit)
            tile_clipped_cdf = np.cumsum(tile_clipped_hist)
            
            tile_equalized_values = (tile_clipped_cdf/tile_cdf.max()*255).astype('uint8')
            tile_equalized_image = tile_equalized_values[tile]
            
            tiles[i,j] = tile_equalized_image
    
    # Combine the tiles into a single image
    equalized_image = np.vstack([np.hstack(row) for row in tiles])
    equalized_image = equalized_image[:image.shape[0], :image.shape[1]]
    
    return equalized_image

这个函数接受一个灰度图像作为输入，并使用 Numpy 实现 CLAHE 算法以增强图像。传递给函数的参数包括：

- `image`: 要增强的图像，必须是灰度图像。
- `clip_limit`: 控制 CLAHE 中限制对比度的阈值。
- `grid_size`: 确定图像被分成的网格的大小。

函数中的代码实现了以下步骤：

1. 将图像转换为灰度图像（如果需要）。
2. 计算图像的直方图。
3. 根据限制对比度的阈值计算 CLAHE 中的 clip limit。
4. 计算累积分布函数 (CDF)。
5. 计算 CLAHE 中剪切直方图的 CDF。
6. 计算均衡像素值。
7. 将均衡像素值映射到图像。
8. 创建用于自适应直方图均衡化的瓷砖。
9. 对瓷砖应用自适应直方图均衡化。
10. 将瓷砖组合成单个图像。
11. 返回增强的图像。

这个函数使用 Numpy 的强大功能，包括数组索引、数组计算、数组切片和数组重塑。它还使用了 `as_strided` 函数来创建瓷砖数组和数组视图。