What We Will build

git clone https://github.com/JeremyMorgan/Super-Image-Optimizer.git
cd Super-Image-Optimizer/imageoptimizer.app

# On macOS / Linux
python3 -m venv venv
source venv/bin/activate

# On Windows (PowerShell / Command Prompt)
python -m venv venv
venv\Scripts\activate

jeremy@Jeremys-Mac-Studio imageoptimizer %

# app/main.py
import logging
from flask import Blueprint, request, jsonify, send_file
import cv2
import numpy as np
import io
import imghdr
from werkzeug.utils import secure_filename
from PIL import Image

# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

bp = Blueprint('main', __name__)

ALLOWED_IMAGE_TYPES = {"jpeg", "png", "gif", "bmp", "tiff"}

@bp.route('/upload', methods=['POST'])
def upload():
    """
    Handle image upload, compress with OpenCV, and return the compressed image.

    Expects:
      - form file field named 'file' (multipart/form-data)
      - optional form field 'quality' (int 1-100), defaults to 85

    Returns:
      - 200 with image/jpeg binary on success
      - 4xx/5xx JSON error on failure
    """
    try:
        if 'file' not in request.files:
            return jsonify({'error': "No file part in the request"}), 400

        file = request.files['file']
        filename = secure_filename(file.filename)

        if filename == '':
            return jsonify({'error': "No selected file"}), 400

        # Read raw bytes and determine type
        file_bytes = file.read()
        img_type = imghdr.what(None, file_bytes)
        if img_type not in ALLOWED_IMAGE_TYPES:
            return jsonify({'error': f"Unsupported or invalid image type: {img_type}"}), 400

        # Get quality parameter (int between 1 and 100)
        try:
            quality = int(request.form.get('quality', 85))
            quality = max(1, min(100, quality))
        except ValueError:
            quality = 85

        # Decode image bytes for OpenCV
        np_arr = np.frombuffer(file_bytes, np.uint8)
        img = cv2.imdecode(np_arr, cv2.IMREAD_UNCHANGED)
        if img is None:
            logger.error('Failed to decode image: %s', filename)
            return jsonify({'error': 'Failed to decode image'}), 400

        # If image has alpha channel, convert BGRA to BGR. Handle grayscale (2D) images safely.
        if img.ndim == 3 and img.shape[2] == 4:
            img = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)

        # Encode to JPEG with requested quality
        success, buffer = cv2.imencode('.jpg', img, [int(cv2.IMWRITE_JPEG_QUALITY), quality])
        if not success:
            logger.error('Failed to encode image to JPEG: %s', filename)
            return jsonify({'error': 'Failed to encode image'}), 500

        img_io = io.BytesIO(buffer.tobytes())

        # Validate the processed image with Pillow
        try:
            processed_img = Image.open(img_io)
            processed_img.verify()
        except (IOError, SyntaxError) as e:
            logger.error('Failed to process image: %s', e)
            return jsonify({'error': 'Failed to process image'}), 400

        # Reset pointer and return the image
        img_io.seek(0)
        return send_file(img_io, mimetype='image/jpeg', as_attachment=False, download_name=f"optimized_{filename}.jpg")

    except Exception as e:
        logger.exception('An unexpected error occurred: %s', e)
        return jsonify({'error': 'Internal server error'}), 500

// src/App.jsx (snippet)
import { useState, useEffect } from 'react'
// import reactLogo from './assets/react.svg'

curl -X POST -F "file=@photo.jpg" -F "quality=77" http://localhost:5000/upload --output optimized_photo.jpg