图片自动锐化

复制from PIL import Image, ImageFilter
import numpy as np

def unsharp_mask(image_path: str, radius: float = 1.5, amount: float = 1.0, threshold: int = 0) -> Image.Image:
    """
    USM 锐化：原图 - 高斯模糊 = 细节层，细节层 * amount + 原图
    """
    img = Image.open(image_path).convert("RGB")
    # 高斯模糊提取低频
    blurred = img.filter(ImageFilter.GaussianBlur(radius=radius))
    img_arr = np.array(img, dtype=np.float32)
    blur_arr = np.array(blurred, dtype=np.float32)
    # 细节 = 原图 - 模糊
    detail = img_arr - blur_arr
    # 阈值掩码：只增强超过阈值的边缘
    mask = np.abs(detail) > threshold
    sharpened = img_arr + amount * detail * mask
    sharpened = np.clip(sharpened, 0, 255).astype(np.uint8)
    return Image.fromarray(sharpened)

# 使用示例
result = unsharp_mask("input.jpg", radius=1.5, amount=1.2, threshold=10)
result.save("sharpened.jpg")
print("已保存 sharpened.jpg")

复制package main

import (
	"fmt"
	"image"
	"image/jpeg"
	"os"

	"github.com/disintegration/imaging"
)

func unsharpMask(img image.Image, radius float64, amount float64, threshold float64) image.Image {
	// 高斯模糊
	blurred := imaging.Blur(img, radius)
	// 逐像素叠加细节
	bounds := img.Bounds()
	result := imaging.Clone(img)
	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
		for x := bounds.Min.X; x < bounds.Max.X; x++ {
			r1, g1, b1, _ := img.At(x, y).RGBA()
			r2, g2, b2, _ := blurred.At(x, y).RGBA()
			dr := int(r1>>8) - int(r2>>8)
			dg := int(g1>>8) - int(g2>>8)
			db := int(b1>>8) - int(b2>>8)
			// 阈值判断
			if abs(dr) < int(threshold) && abs(dg) < int(threshold) && abs(db) < int(threshold) {
				continue
			}
			newR := clamp(int(r1>>8) + int(float64(dr)*amount))
			newG := clamp(int(g1>>8) + int(float64(dg)*amount))
			newB := clamp(int(b1>>8) + int(float64(db)*amount))
			result.Set(x, y, image.RGBA{uint8(newR), uint8(newG), uint8(newB), 255})
		}
	}
	return result
}

func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

func clamp(x int) int {
	if x < 0 {
		return 0
	}
	if x > 255 {
		return 255
	}
	return x
}

func main() {
	f, _ := os.Open("input.jpg")
	defer f.Close()
	img, _ := jpeg.Decode(f)
	result := unsharpMask(img, 1.5, 1.0, 10.0)
	out, _ := os.Create("sharpened.jpg")
	defer out.Close()
	jpeg.Encode(out, result, &jpeg.Options{Quality: 95})
	fmt.Println("已保存 sharpened.jpg")
}

复制// 浏览器端 USM 锐化（Canvas + 卷积近似）
function unsharpMask(imageData, radius = 1.5, amount = 1.0, threshold = 10) {
  const w = imageData.width, h = imageData.height;
  const src = new Uint8ClampedArray(imageData.data);
  const blurred = new Uint8ClampedArray(src.length);

  // 简单高斯模糊（3x3 近似）
  const kernel = [1, 2, 1, 2, 4, 2, 1, 2, 1];
  const kSum = 16;
  for (let y = 1; y < h - 1; y++) {
    for (let x = 1; x < w - 1; x++) {
      let r = 0, g = 0, b = 0;
      for (let ky = -1; ky <= 1; ky++) {
        for (let kx = -1; kx <= 1; kx++) {
          const idx = ((y + ky) * w + (x + kx)) * 4;
          const k = kernel[(ky + 1) * 3 + (kx + 1)];
          r += src[idx] * k;
          g += src[idx + 1] * k;
          b += src[idx + 2] * k;
        }
      }
      const i = (y * w + x) * 4;
      blurred[i] = r / kSum;
      blurred[i + 1] = g / kSum;
      blurred[i + 2] = b / kSum;
      blurred[i + 3] = 255;
    }
  }

  // USM 叠加
  const output = new Uint8ClampedArray(src.length);
  for (let i = 0; i < src.length; i += 4) {
    const dr = src[i] - blurred[i];
    const dg = src[i + 1] - blurred[i + 1];
    const db = src[i + 2] - blurred[i + 2];
    if (Math.abs(dr) < threshold && Math.abs(dg) < threshold && Math.abs(db) < threshold) {
      output[i] = src[i];
      output[i + 1] = src[i + 1];
      output[i + 2] = src[i + 2];
    } else {
      output[i] = Math.min(255, Math.max(0, src[i] + dr * amount));
      output[i + 1] = Math.min(255, Math.max(0, src[i + 1] + dg * amount));
      output[i + 2] = Math.min(255, Math.max(0, src[i + 2] + db * amount));
    }
    output[i + 3] = 255;
  }

  return new ImageData(output, w, h);
}

// 使用示例（从 Canvas 获取 ImageData）
const canvas = document.getElementById('canvas');
const ctx = canvas.getContext('2d');
const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
const sharpened = unsharpMask(imageData, 1.5, 1.0, 10);
ctx.putImageData(sharpened, 0, 0);
console.log('锐化完成');