# ❌ 不好：多步处理，多次读写磁盘
gm convert input.jpg -resize 800 /tmp/step1.jpg
gm convert /tmp/step1.jpg -quality 85 /tmp/step2.jpg
gm convert /tmp/step2.jpg -strip output.jpg

# ✅ 好：单步处理，一次读写
gm convert input.jpg -resize 800 -quality 85 -strip output.jpg

# ❌ 不好：先操作后裁剪
gm convert input.jpg -blur 0x5 -crop 400x300 output.jpg

# ✅ 好：先裁剪后操作（处理更少像素）
gm convert input.jpg -crop 400x300 -blur 0x5 output.jpg

# 性能关键环境变量
export OMP_NUM_THREADS=$(nproc)       # 使用全部 CPU 核心
export MAGICK_TMPDIR=/dev/shm/gm-tmp  # RAM 盘临时文件
export MAGICK_MEMORY_LIMIT=4GiB       # 内存限制
export MAGICK_MAP_LIMIT=8GiB          # mmap 限制

mkdir -p /dev/shm/gm-tmp

#!/bin/bash
# benchmark.sh — 不同设置的性能对比

INPUT="large_photo.jpg"  # 4000x3000 JPEG
echo "测试图像: $INPUT ($(gm identify -format '%wx%h' $INPUT))"

# 测试 1：单线程 vs 多线程
echo ""
echo "=== 测试 1：线程数 ==="
for threads in 1 2 4 8; do
  start=$(date +%s%N)
  OMP_NUM_THREADS=$threads gm convert "$INPUT" \
    -resize 800x600 -quality 85 /tmp/bench_t${threads}.jpg
  end=$(date +%s%N)
  ms=$(( (end - start) / 1000000 ))
  echo "  OMP_NUM_THREADS=$threads: ${ms}ms"
done

# 测试 2：临时目录（SSD vs RAM盘）
echo ""
echo "=== 测试 2：临时目录 ==="
for tmpdir in /tmp /dev/shm/gm-tmp; do
  mkdir -p "$tmpdir"
  start=$(date +%s%N)
  MAGICK_TMPDIR=$tmpdir gm convert "$INPUT" \
    -resize 800x600 -quality 85 /tmp/bench_tmp.jpg
  end=$(date +%s%N)
  ms=$(( (end - start) / 1000000 ))
  echo "  MAGICK_TMPDIR=$tmpdir: ${ms}ms"
done

# 测试 3：不同滤波器
echo ""
echo "=== 测试 3：滤波器 ==="
for filter in Lanczos Mitchell Catrom Box Point; do
  start=$(date +%s%N)
  gm convert -filter "$filter" "$INPUT" \
    -resize 800x600 /tmp/bench_filter.jpg
  end=$(date +%s%N)
  ms=$(( (end - start) / 1000000 ))
  echo "  -filter $filter: ${ms}ms"
done

# 生产环境推荐配置（8GB 内存服务器）
export MAGICK_MEMORY_LIMIT=2GiB      # 进程内存限制
export MAGICK_MAP_LIMIT=4GiB         # mmap 映射限制
export MAGICK_DISK_LIMIT=16GiB       # 临时文件限制
export MAGICK_FILE_LIMIT=768         # 打开文件数
export MAGICK_AREA_LIMIT=128MP       # 最大图像面积（128 百万像素）

# 查看当前限制
gm convert -list resource

# 策略 1：限制图像面积
gm convert -limit area 64MP huge_input.jpg output.jpg

# 策略 2：先缩小再处理
gm convert huge_20000x15000.jpg \
  -resize 25% \
  -blur 0x5 \
  -resize 400% \
  output.jpg

# 策略 3：使用更低的 quantum depth（编译时选择）
# quantum-depth=8 而不是 16

# 策略 4：分批处理
find . -name "*.jpg" | head -100 | xargs -P 4 -I {} \
  gm convert {} -resize 800x600 output/{}

#!/bin/bash
# monitor_memory.sh — 监控处理进程的内存使用

PID=$1
MAX_MEM=0

while kill -0 $PID 2>/dev/null; do
  MEM=$(ps -o rss= -p $PID 2>/dev/null)
  if [ -n "$MEM" ] && [ "$MEM" -gt "$MAX_MEM" ]; then
    MAX_MEM=$MEM
  fi
  sleep 0.1
done

echo "最大内存使用: $((MAX_MEM / 1024))MB"

# JPEG 优化组合
gm convert input.jpg \
  -quality 85 \                    # 质量 85（视觉最佳平衡）
  -interlace Plane \               # 渐进式加载
  -sampling-factor 4:2:0 \         # 色度子采样
  -strip \                         # 去除元数据
  -colorspace sRGB \               # 标准色彩空间
  output_optimized.jpg

# PNG 优化组合
gm convert input.png \
  -quality 9 \                     # 最高压缩
  -strip \                         # 去除元数据
  -colors 256 \                    # 限色（如果可接受）
  output_optimized.png

# WebP 优化
gm convert input.jpg \
  -quality 85 \
  -define webp:method=6 \          # 最佳压缩方法
  output.webp

# Python 输入验证示例
import os
from wand.image import Image

ALLOWED_EXTENSIONS = {'.jpg', '.jpeg', '.png', '.webp', '.gif'}
MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
MAX_DIMENSION = 8000

def validate_image(file_path):
    """验证上传的图像文件"""
    # 检查扩展名
    ext = os.path.splitext(file_path)[1].lower()
    if ext not in ALLOWED_EXTENSIONS:
        raise ValueError(f"不支持的格式: {ext}")

    # 检查文件大小
    size = os.path.getsize(file_path)
    if size > MAX_FILE_SIZE:
        raise ValueError(f"文件过大: {size} bytes (最大 {MAX_FILE_SIZE})")

    # 检查图像尺寸
    with Image(filename=file_path) as img:
        if img.width > MAX_DIMENSION or img.height > MAX_DIMENSION:
            raise ValueError(f"尺寸过大: {img.width}x{img.height}")

    return True

import shlex
import subprocess

def safe_gm_convert(input_path, output_path, options):
    """安全的 gm convert 调用"""
    # ❌ 危险：直接拼接字符串
    # cmd = f"gm convert {input_path} {options} {output_path}"

    # ✅ 安全：使用列表参数
    cmd = ['gm', 'convert', input_path]
    cmd.extend(options)
    cmd.append(output_path)

    result = subprocess.run(cmd, capture_output=True, timeout=30)
    return result.returncode == 0

# 参数白名单
ALLOWED_OPTIONS = {
    'resize', 'quality', 'crop', 'rotate', 'flip', 'flop',
    'strip', 'blur', 'sharpen', 'normalize'
}

import tempfile
import os
import uuid

def safe_temp_file(suffix='.jpg'):
    """创建安全的临时文件"""
    tmp_dir = tempfile.mkdtemp(prefix='gm_')
    tmp_file = os.path.join(tmp_dir, f"{uuid.uuid4()}{suffix}")
    return tmp_file, tmp_dir

def cleanup_temp(tmp_dir):
    """清理临时目录"""
    import shutil
    if os.path.exists(tmp_dir):
        shutil.rmtree(tmp_dir)

# 使用
try:
    tmp_file, tmp_dir = safe_temp_file()
    # 处理图像...
finally:
    cleanup_temp(tmp_dir)

# /etc/nginx/conf.d/image-api.conf
upstream gm_api {
    least_conn;
    server 127.0.0.1:5000 weight=1;
    server 127.0.0.1:5001 weight=1;
    server 127.0.0.1:5002 weight=1;
    keepalive 32;
}

server {
    listen 80;
    server_name images.example.com;

    # 限制上传大小
    client_max_body_size 20m;

    # 图像处理 API
    location /api/ {
        proxy_pass http://gm_api;
        proxy_connect_timeout 10s;
        proxy_read_timeout 30s;
        proxy_send_timeout 10s;

        # 缓存结果
        proxy_cache image_cache;
        proxy_cache_valid 200 7d;
        proxy_cache_use_stale error timeout updating;
    }

    # 静态图像缓存
    location /static/image/ {
        expires 30d;
        add_header Cache-Control "public, immutable";

        # 自动 WebP（如果客户端支持）
        set $webp "";
        if ($http_accept ~* "webp") {
            set $webp ".webp";
        }
        try_files $uri$webp $uri =404;
    }
}

# 缓存区域配置（放在 http 块）
proxy_cache_path /var/cache/nginx/images
    levels=1:2 keys_zone=image_cache:100m
    max_size=10g inactive=7d use_temp_path=off;

#!/bin/bash
# healthcheck.sh — GraphicsMagick 服务健康检查

check_gm() {
  # 检查 gm 命令可用
  if ! command -v gm &>/dev/null; then
    echo "❌ GraphicsMagick 未安装"
    return 1
  fi

  # 检查基本功能
  if ! gm convert -size 100x100 xc:red /tmp/gm_health.jpg 2>/dev/null; then
    echo "❌ GraphicsMagick 功能异常"
    return 1
  fi

  # 检查磁盘空间
  local tmp_usage=$(df /tmp | tail -1 | awk '{print $5}' | tr -d '%')
  if [ "$tmp_usage" -gt 90 ]; then
    echo "⚠️ 临时目录空间不足: ${tmp_usage}%"
    return 1
  fi

  # 检查内存
  local mem_free=$(free -m | awk '/^Mem:/{print $7}')
  if [ "$mem_free" -lt 512 ]; then
    echo "⚠️ 可用内存不足: ${mem_free}MB"
    return 1
  fi

  rm -f /tmp/gm_health.jpg
  echo "✅ GraphicsMagick 健康"
  return 0
}

check_gm

# 查看详细错误信息
gm convert -debug all input.jpg output.jpg 2>&1 | head -50

# 查看资源使用
gm convert -list resource

# 查看格式支持
gm convert -list format | grep -i jpeg

# 查看配置
gm convert -list configure

# 逐步测试
gm convert -verbose input.jpg /tmp/test1.jpg 2>&1
gm identify /tmp/test1.jpg

# 查看信息
gm identify photo.jpg
gm identify -format "%wx%h" photo.jpg
gm convert -list format

# 格式转换
gm convert input.png output.jpg
gm convert -quality 85 input.png output.jpg

# 缩放
gm convert -resize 800 input.jpg output.jpg
gm convert -resize "800x600>" input.jpg output.jpg

# 裁剪
gm convert -gravity center -crop 400x300+0+0 input.jpg output.jpg

# 旋转
gm convert -rotate 90 input.jpg output.jpg
gm convert -auto-orient input.jpg output.jpg

# 颜色
gm convert -modulate 110,120,100 input.jpg output.jpg
gm convert -brightness-contrast 10x20 input.jpg output.jpg

# 特效
gm convert -blur 0x5 input.jpg output.jpg
gm convert -sharpen 0x1 input.jpg output.jpg

# 水印
gm composite -dissolve 30 -gravity SouthEast watermark.png photo.jpg output.jpg

# 批量
gm mogrify -path output/ -resize 800 -quality 85 *.jpg

# 去元数据
gm convert -strip input.jpg output.jpg

export OMP_NUM_THREADS=$(nproc)        # 线程数
export MAGICK_TMPDIR=/dev/shm/gm-tmp   # 临时目录
export MAGICK_MEMORY_LIMIT=2GiB        # 内存限制
export MAGICK_MAP_LIMIT=4GiB           # mmap 限制
export MAGICK_DISK_LIMIT=16GiB         # 磁盘限制
export MAGICK_AREA_LIMIT=128MP         # 面积限制