Image Optimization

from PIL import Image
import io
import base64

def optimize_image_for_classification(image_path: str, max_size_kb: int = 400) -> str:
    """
    Optimize an image to stay within size limits.

    Args:
        image_path: Path to the image file
        max_size_kb: Maximum size in KB (default 400KB to stay under 500KB limit with JSON overhead)

    Returns:
        Base64-encoded optimized image
    """
    # Open the image
    img = Image.open(image_path)

    # Convert RGBA to RGB (remove alpha channel)
    if img.mode == 'RGBA':
        img = img.convert('RGB')

    # Start with reasonable dimensions
    max_dimension = 1024
    quality = 85

    while True:
        # Resize if too large
        if max(img.size) > max_dimension:
            img.thumbnail((max_dimension, max_dimension), Image.Resampling.LANCZOS)

        # Save to bytes with current quality
        buffer = io.BytesIO()
        img.save(buffer, format='JPEG', quality=quality, optimize=True)
        size_kb = buffer.tell() / 1024

        # Check if we're within limits
        if size_kb <= max_size_kb:
            buffer.seek(0)
            return base64.b64encode(buffer.read()).decode('utf-8')

        # Reduce quality or dimensions for next iteration
        if quality > 60:
            quality -= 10
        else:
            max_dimension = int(max_dimension * 0.8)
            img = Image.open(image_path)  # Reload to avoid cumulative resizing
            if img.mode == 'RGBA':
                img = img.convert('RGB')

        # Safety check
        if max_dimension < 256:
            raise ValueError("Cannot optimize image small enough while maintaining readability")

# Usage
image_base64 = optimize_image_for_classification("photo.jpg", max_size_kb=400)

# Send to ClassifAI
response = requests.post(
    "https://api.classifai.dev/classify",
    json={
        "content": [{"type": "image", "content": image_base64}],
        "labels": ["cat", "dog", "bird"]
    }
)

const sharp = require('sharp');
const fs = require('fs').promises;

async function optimizeImageForClassification(imagePath, maxSizeKB = 400) {
  let quality = 85;
  let width = 1024;

  while (true) {
    // Resize and compress
    const buffer = await sharp(imagePath)
      .resize(width, width, {
        fit: 'inside',
        withoutEnlargement: true
      })
      .jpeg({ quality, mozjpeg: true })
      .toBuffer();

    const sizeKB = buffer.length / 1024;

    if (sizeKB <= maxSizeKB) {
      return buffer.toString('base64');
    }

    // Reduce quality or dimensions
    if (quality > 60) {
      quality -= 10;
    } else {
      width = Math.floor(width * 0.8);
    }

    if (width < 256) {
      throw new Error('Cannot optimize image small enough');
    }
  }
}

// Usage
const imageBase64 = await optimizeImageForClassification('photo.jpg', 400);

const response = await fetch('https://api.classifai.dev/classify', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    content: [{ type: 'image', content: imageBase64 }],
    labels: ['cat', 'dog', 'bird']
  })
});

# Example: Multiple images in one request
images = []
for path in ['img1.jpg', 'img2.jpg', 'img3.jpg']:
    # Optimize each image to ~130KB (400KB / 3 images)
    img_base64 = optimize_image_for_classification(path, max_size_kb=130)
    images.append({"type": "image", "content": img_base64})

response = requests.post(
    "https://api.classifai.dev/classify",
    json={
        "content": images,
        "labels": ["relevant", "not_relevant"]
    }
)