cornerstone对图像数据这块翻了下文档没找到拦截器之类的方法，所以我目前的实现是修改了image的源数据，取消锐化的时候无视imagecache，再重新请求一次wodo拿到原始pixeldata；或者也可以把原始缓存下来，但是在内存和流量里我选择流量，需求里要锐化一整个序列，薄层数据集大对内存负担重。

先看锐化过程的主要代码，imageIds是当前所选序列的imageId集合，获取所有image的数据然后对pixeldata进行锐化处理，并且遍历到当前显示的那张图像时，强制updateImage一下更新canvas视图。

// view的操作
const sharpenSeries = () => {
            let promiseAll = [];
            lodash.forEach(imageIds, (imageId) => {
                promiseAll.push(loadAndCacheImagePlus(imageId));
            })
            Promise.all(promiseAll).then((imageData) => {
                for (let i = 0; i < imageData.length; i++) {
                    const image = imageData[i];
                    if (!image.sharpen) {
                        image.sharpen = true;
                        const _pixelData = sharpen(_.cloneDeep(image.getPixelData()), image.width, image.height);
                        const [min, max] = getMinMaxPixelData(_pixelData);
                        image.getPixelData = () => {
                            return _pixelData;
                        }
                        image.minPixelValue = min;
                        image.maxPixelValue = max;
                        image.cachedLut = undefined;
                        if (currentSeriesIndex === i) {
                            cornerstone.updateImage(activeElement, true)
                        }
                    }
                }
                propsFromDispatch.closeGlobalLoading();
            }).catch((e) => {
                propsFromDispatch.closeGlobalLoading();
                console.log('open sharpen load image error:', e);
            })
    }

要注意的是不仅要修改pixelData数据，还要修改Image中的min、max像素值和lut缓存，从源码来看cachedLut得要设置成undefined才会重新generate，null是不行的。min和max会影响一些对图像的处理，比如伪彩，走到storedPixelDataToCanvasImageDataPseudocolorLUT会有minPixelValue的逻辑，min是错的的话rgba可能会是undefined，rgba[1]那儿就直接报错了

以下是锐化的卷积操作代码：

// sharpen.js
function convolve(pixelData, width, height, kernel) {
    const kernelSize = Math.sqrt(kernel.length);
    const halfKernelSize = Math.floor(kernelSize / 2);
    const output = new Int16Array(pixelData.length);
    for (let y = halfKernelSize; y < height - halfKernelSize; y++) {
        for (let x = halfKernelSize; x < width - halfKernelSize; x++) {
            let sum = 0;
            for (let ky = 0; ky < kernelSize; ky++) {
                for (let kx = 0; kx < kernelSize; kx++) {
                    const pixelIndex = (y + ky - halfKernelSize) * width + (x + kx - halfKernelSize);
                    sum += pixelData[pixelIndex] * kernel[ky * kernelSize + kx];
                }
            }

            const outputIndex = y * width + x;
            output[outputIndex] = Math.round(sum);
        }
    }
    return output;
}

export function sharpen(pixels, width, height) {

    const kernel = [
        0, -1, 0,
        -1, 5, -1,
        0, -1, 0
    ];

    return convolve(pixels, width, height, kernel);
}

取消锐化，就重新做了一遍图像加载，由于我们项目里对loadAndCacheImage做了封装（具体可以参考预加载那篇），所以在loadAndCacheImagePlus的时候传入一个forceRefresh参数，强制获取新数据则 cornerstone.imageCache.removeImageLoadObject(imageId)把缓存删掉，重新请求

imagePromise.then((image) => {
    image.sharpen = false;
    if (currentSeriesIndex === index) {
        cornerstone.displayImage(activeElement, image);
        cornerstone.updateImage(activeElement, true);
    }
}, (e) => {
    console.log('close sharpen load image error:', e);
})