图片裁剪工具

// 使用 Canvas 裁剪图片
function cropImage(image, x, y, width, height) {
    const canvas = document.createElement('canvas');
    canvas.width = width;
    canvas.height = height;
    
    const ctx = canvas.getContext('2d');
    ctx.drawImage(image, x, y, width, height, 0, 0, width, height);
    
    return canvas;
}

// 中心裁剪为指定尺寸
function centerCrop(image, targetWidth, targetHeight) {
    const sourceWidth = image.width;
    const sourceHeight = image.height;
    
    // 计算缩放比例
    const scaleX = targetWidth / sourceWidth;
    const scaleY = targetHeight / sourceHeight;
    const scale = Math.max(scaleX, scaleY);
    
    // 计算裁剪区域
    const scaledWidth = sourceWidth * scale;
    const scaledHeight = sourceHeight * scale;
    const x = (scaledWidth - targetWidth) / 2 / scale;
    const y = (scaledHeight - targetHeight) / 2 / scale;
    
    return cropImage(image, x, y, targetWidth / scale, targetHeight / scale);
}

// 按比例裁剪
function aspectCrop(image, aspectRatio) {
    const sourceWidth = image.width;
    const sourceHeight = image.height;
    const sourceAspect = sourceWidth / sourceHeight;
    
    let cropWidth, cropHeight;
    
    if (sourceAspect > aspectRatio) {
        // 原图更宽，裁剪宽度
        cropHeight = sourceHeight;
        cropWidth = sourceHeight * aspectRatio;
    } else {
        // 原图更高，裁剪高度
        cropWidth = sourceWidth;
        cropHeight = sourceWidth / aspectRatio;
    }
    
    const x = (sourceWidth - cropWidth) / 2;
    const y = (sourceHeight - cropHeight) / 2;
    
    return cropImage(image, x, y, cropWidth, cropHeight);
}

// 使用示例
const img = new Image();
img.onload = () => {
    // 自由裁剪
    const cropped1 = cropImage(img, 100, 100, 200, 200);
    
    // 中心裁剪为正方形
    const cropped2 = centerCrop(img, 300, 300);
    
    // 裁剪为16:9比例
    const cropped3 = aspectCrop(img, 16/9);
    
    // 显示裁剪结果
    document.body.appendChild(cropped1);
};
img.src = 'image.jpg';

from PIL import Image

def crop_image(input_path, output_path, left, top, width, height):
    """
    裁剪图片
    :param input_path: 输入图片路径
    :param output_path: 输出图片路径
    :param left: 左上角 x 坐标
    :param top: 左上角 y 坐标
    :param width: 裁剪宽度
    :param height: 裁剪高度
    """
    img = Image.open(input_path)
    
    # 定义裁剪区域 (left, top, right, bottom)
    crop_box = (left, top, left + width, top + height)
    cropped_img = img.crop(crop_box)
    
    cropped_img.save(output_path)
    print(f'裁剪完成，尺寸: {cropped_img.size}')

def center_crop(input_path, output_path, size):
    """
    从中心裁剪为正方形
    :param size: 输出尺寸
    """
    img = Image.open(input_path)
    width, height = img.size
    
    left = (width - size) // 2
    top = (height - size) // 2
    
    cropped = img.crop((left, top, left + size, top + size))
    cropped.save(output_path)
    print(f'中心裁剪完成，尺寸: {cropped.size}')

def aspect_crop(input_path, output_path, aspect_ratio):
    """
    按比例裁剪
    :param aspect_ratio: 宽高比 (width/height)
    """
    img = Image.open(input_path)
    width, height = img.size
    current_aspect = width / height
    
    if current_aspect > aspect_ratio:
        # 原图更宽，裁剪宽度
        new_width = int(height * aspect_ratio)
        left = (width - new_width) // 2
        top = 0
        right = left + new_width
        bottom = height
    else:
        # 原图更高，裁剪高度
        new_height = int(width / aspect_ratio)
        left = 0
        top = (height - new_height) // 2
        right = width
        bottom = top + new_height
    
    cropped = img.crop((left, top, right, bottom))
    cropped.save(output_path)
    print(f'比例裁剪完成，尺寸: {cropped.size}')

def smart_resize_and_crop(input_path, output_path, target_width, target_height):
    """
    智能调整大小并裁剪（保持比例填充目标尺寸）
    """
    img = Image.open(input_path)
    
    # 计算缩放比例
    img_ratio = img.width / img.height
    target_ratio = target_width / target_height
    
    if img_ratio > target_ratio:
        # 原图更宽，按高度缩放
        new_height = target_height
        new_width = int(new_height * img_ratio)
    else:
        # 原图更高，按宽度缩放
        new_width = target_width
        new_height = int(new_width / img_ratio)
    
    # 缩放图片
    resized = img.resize((new_width, new_height), Image.LANCZOS)
    
    # 中心裁剪
    left = (new_width - target_width) // 2
    top = (new_height - target_height) // 2
    cropped = resized.crop((left, top, left + target_width, top + target_height))
    
    cropped.save(output_path)
    print(f'智能裁剪完成，最终尺寸: {cropped.size}')

# 使用示例
crop_image('input.jpg', 'output.jpg', 100, 100, 300, 300)
center_crop('input.jpg', 'avatar.jpg', 200)
aspect_crop('input.jpg', 'wide.jpg', 16/9)
smart_resize_and_crop('input.jpg', 'banner.jpg', 1920, 1080)

const sharp = require('sharp');

async function cropImage(inputPath, outputPath, left, top, width, height) {
    await sharp(inputPath)
        .extract({ left, top, width, height })
        .toFile(outputPath);
    console.log('裁剪完成');
}

async function centerCrop(inputPath, outputPath, size) {
    const metadata = await sharp(inputPath).metadata();
    const { width, height } = metadata;
    
    const left = Math.floor((width - size) / 2);
    const top = Math.floor((height - size) / 2);
    
    await sharp(inputPath)
        .extract({ left, top, width: size, height: size })
        .toFile(outputPath);
    console.log('中心裁剪完成');
}

async function smartCrop(inputPath, outputPath, width, height) {
    // 使用 sharp 的 cover 方法实现智能裁剪
    await sharp(inputPath)
        .resize(width, height, {
            fit: 'cover',
            position: 'center'
        })
        .toFile(outputPath);
    console.log('智能裁剪完成');
}

async function resizeWithCrop(inputPath, outputPath, maxWidth, maxHeight) {
    const metadata = await sharp(inputPath).metadata();
    const { width: originalWidth, height: originalHeight } = metadata;
    
    const ratio = Math.min(maxWidth / originalWidth, maxHeight / originalHeight);
    const newWidth = Math.floor(originalWidth * ratio);
    const newHeight = Math.floor(originalHeight * ratio);
    
    await sharp(inputPath)
        .resize(newWidth, newHeight)
        .toFile(outputPath);
    console.log('缩放完成');
}

// 使用示例
cropImage('input.jpg', 'output.jpg', 100, 100, 300, 300);
centerCrop('input.jpg', 'avatar.jpg', 200);
smartCrop('input.jpg', 'banner.jpg', 1920, 1080);
resizeWithCrop('input.jpg', 'thumbnail.jpg', 300, 300);

import java.awt.*;
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
import java.io.File;

public class ImageCropper {
    
    public static void cropImage(String inputPath, String outputPath, 
                                  int x, int y, int width, int height) throws Exception {
        BufferedImage originalImage = ImageIO.read(new File(inputPath));
        
        // 创建裁剪后的图片
        BufferedImage croppedImage = originalImage.getSubimage(x, y, width, height);
        
        // 保存裁剪后的图片
        ImageIO.write(croppedImage, "jpg", new File(outputPath));
        
        System.out.println("裁剪完成，尺寸: " + croppedImage.getWidth() + 
                           "x" + croppedImage.getHeight());
    }
    
    public static void centerCrop(String inputPath, String outputPath, int size) throws Exception {
        BufferedImage originalImage = ImageIO.read(new File(inputPath));
        int width = originalImage.getWidth();
        int height = originalImage.getHeight();
        
        int x = (width - size) / 2;
        int y = (height - size) / 2;
        
        cropImage(inputPath, outputPath, x, y, size, size);
    }
    
    public static void smartResizeAndCrop(String inputPath, String outputPath, 
                                           int targetWidth, int targetHeight) throws Exception {
        BufferedImage originalImage = ImageIO.read(new File(inputPath));
        int originalWidth = originalImage.getWidth();
        int originalHeight = originalImage.getHeight();
        
        // 计算缩放比例
        double ratio = Math.min(
            (double) targetWidth / originalWidth,
            (double) targetHeight / originalHeight
        );
        
        int newWidth = (int) (originalWidth * ratio);
        int newHeight = (int) (originalHeight * ratio);
        
        // 缩放图片
        BufferedImage resizedImage = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_RGB);
        Graphics2D g2d = resizedImage.createGraphics();
        g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
        g2d.drawImage(originalImage, 0, 0, newWidth, newHeight, null);
        g2d.dispose();
        
        // 中心裁剪
        int x = (newWidth - targetWidth) / 2;
        int y = (newHeight - targetHeight) / 2;
        BufferedImage croppedImage = resizedImage.getSubimage(x, y, targetWidth, targetHeight);
        
        ImageIO.write(croppedImage, "jpg", new File(outputPath));
        System.out.println("智能裁剪完成");
    }
    
    public static void main(String[] args) throws Exception {
        cropImage("input.jpg", "output.jpg", 100, 100, 300, 300);
        centerCrop("input.jpg", "avatar.jpg", 200);
        smartResizeAndCrop("input.jpg", "banner.jpg", 1920, 1080);
    }
}