Miniatury obrazków bez zewnętrznych bibliotek

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.Locale;
import javax.imageio.ImageIO;

/**
 * Miniatury obrazków bez zewnętrznych bibliotek — skryptyJAVA.pl
 * Zapisz jako: MiniaturyObrazkow.java
 */
public class MiniaturyObrazkow {

    /** ImageIO.read nie rzuca wyjątku dla nieznanego formatu — po prostu zwraca null. */
    public static BufferedImage wczytaj(Path plik) throws IOException {
        BufferedImage obrazek = ImageIO.read(plik.toFile());
        if (obrazek == null) { throw new IOException("Brak dekodera dla: " + plik.getFileName()); }
        return obrazek;
    }

    /** Miniatura wpisana w ramkę z zachowaniem proporcji; mniejszego obrazka nie powiększa. */
    public static BufferedImage miniatura(BufferedImage zrodlo, int maksSzerokosc,
                                          int maksWysokosc, boolean zachowajAlfe) {
        if (maksSzerokosc < 1 || maksWysokosc < 1) {
            throw new IllegalArgumentException("Wymiary ramki muszą być dodatnie.");
        }
        double skala = Math.min(1.0, Math.min(maksSzerokosc / (double) zrodlo.getWidth(),
                maksWysokosc / (double) zrodlo.getHeight()));
        int szerokosc = Math.max(1, (int) Math.round(zrodlo.getWidth() * skala));
        int wysokosc = Math.max(1, (int) Math.round(zrodlo.getHeight() * skala));
        return przeskaluj(zrodlo, szerokosc, wysokosc, zachowajAlfe);
    }

    /** Wycina największy kwadrat ze środka i skaluje go dokładnie do zadanego boku. */
    public static BufferedImage kwadratZeSrodka(BufferedImage zrodlo, int bok, boolean zachowajAlfe) {
        if (bok < 1) { throw new IllegalArgumentException("Bok kwadratu musi być dodatni."); }
        int krawedz = Math.min(zrodlo.getWidth(), zrodlo.getHeight());
        int lewy = (zrodlo.getWidth() - krawedz) / 2;
        int gorny = (zrodlo.getHeight() - krawedz) / 2;
        // getSubimage nie kopiuje pikseli — zwraca okno na ten sam raster co oryginał
        BufferedImage kadr = zrodlo.getSubimage(lewy, gorny, krawedz, krawedz);
        return przeskaluj(kadr, bok, bok, zachowajAlfe);
    }

    /** Właściwe skalowanie: nowy bufor, dobre filtrowanie i zawsze dispose() na końcu. */
    private static BufferedImage przeskaluj(BufferedImage zrodlo, int szerokosc,
                                            int wysokosc, boolean zachowajAlfe) {
        BufferedImage cel = new BufferedImage(szerokosc, wysokosc,
                zachowajAlfe ? BufferedImage.TYPE_INT_ARGB : BufferedImage.TYPE_INT_RGB);
        Graphics2D grafika = cel.createGraphics();
        try {
            grafika.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                    RenderingHints.VALUE_INTERPOLATION_BICUBIC);
            grafika.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
            grafika.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            if (!zachowajAlfe) {
                // TYPE_INT_RGB startuje od czerni — bez zamalowania alfa wyjdzie na czarno
                grafika.setColor(Color.WHITE);
                grafika.fillRect(0, 0, szerokosc, wysokosc);
            }
            grafika.drawImage(zrodlo, 0, 0, szerokosc, wysokosc, null);
        } finally {
            grafika.dispose();   // Graphics2D trzyma zasoby systemowe — zwolnij je zawsze
        }
        return cel;
    }

    /** Zapisuje przez osobny plik roboczy, więc błąd enkodera nie niszczy starego celu. */
    public static void zapisz(BufferedImage obrazek, String format, Path plik) throws IOException {
        String nazwaFormatu = format.toLowerCase(Locale.ROOT);
        Path cel = plik.toAbsolutePath().normalize();
        Path katalog = cel.getParent();
        if (katalog == null) { throw new IOException("Plik docelowy musi mieć katalog nadrzędny."); }
        Files.createDirectories(katalog);
        Path tymczasowy = Files.createTempFile(katalog, "obraz-", ".tmp");
        try {
            if (!ImageIO.write(obrazek, nazwaFormatu, tymczasowy.toFile())) {
                throw new IOException(ImageIO.getImageWritersByFormatName(nazwaFormatu).hasNext()
                        ? "Enkoder " + nazwaFormatu
                                + " nie przyjmuje obrazu tego typu (kanał alfa?)."
                        : "ImageIO nie zna formatu zapisu: " + nazwaFormatu);
            }
            Files.move(tymczasowy, cel, StandardCopyOption.REPLACE_EXISTING);
        } finally {
            Files.deleteIfExists(tymczasowy);
        }
    }

    /** Rysuje przykład: barwny gradient i przezroczysty narożnik, bez pliku wejściowego. */
    private static BufferedImage narysujPrzyklad(int szerokosc, int wysokosc) {
        BufferedImage plotno = new BufferedImage(szerokosc, wysokosc, BufferedImage.TYPE_INT_ARGB);
        for (int y = 0; y < wysokosc; y++) {
            for (int x = 0; x < szerokosc; x++) {
                int alfa = (x + y < szerokosc / 3) ? 0 : 255;
                int kolor = (x * 255 / szerokosc) << 16 | (y * 255 / wysokosc) << 8 | 130;
                plotno.setRGB(x, y, alfa << 24 | kolor);
            }
        }
        return plotno;
    }

    /** Zapisuje w formacie wziętym z rozszerzenia i wypisuje parametry wyniku. */
    private static void zapiszIOpisz(String etykieta, BufferedImage obrazek, Path katalog,
                                     String nazwa) throws IOException {
        Path plik = katalog.resolve(nazwa);
        zapisz(obrazek, nazwa.substring(nazwa.lastIndexOf('.') + 1), plik);
        System.out.printf(Locale.ROOT, "%-24s %4dx%-4d alfa:%-6b %6d B  %s%n", etykieta, obrazek.getWidth(),
                obrazek.getHeight(), obrazek.getColorModel().hasAlpha(), Files.size(plik), nazwa);
    }

    // ── PRZYKŁADY ───────────────────────────────────────────
    public static void main(String[] args) throws IOException {
        Path katalog = Files.createTempDirectory("miniatury-demo-");
        try {
            zapiszIOpisz("oryginał (PNG z alfą)", narysujPrzyklad(900, 600), katalog, "duzy.png");
            BufferedImage zrodlo = wczytaj(katalog.resolve("duzy.png"));
            zapiszIOpisz("wpisana w 320x320", miniatura(zrodlo, 320, 320, true), katalog, "mini.png");
            zapiszIOpisz("na białym tle", miniatura(zrodlo, 320, 320, false), katalog, "mini.jpg");
            zapiszIOpisz("kwadrat ze środka", kwadratZeSrodka(zrodlo, 128, true), katalog, "awatar.png");
            Files.writeString(katalog.resolve("udawany.png"), "Tekst — kłamie tylko rozszerzenie.");
            try {
                wczytaj(katalog.resolve("udawany.png"));
            } catch (IOException wyjatek) {
                System.out.println("\nOczekiwany błąd: " + wyjatek.getMessage());
            }
            System.out.println("ARGB prosto do JPEG, bez spłaszczania, ImageIO.write zwraca: "
                    + ImageIO.write(zrodlo, "jpg", katalog.resolve("odrzut.jpg").toFile()));
        } finally {
            try (var smieci = Files.list(katalog)) {
                for (Path smiec : smieci.toList()) { Files.deleteIfExists(smiec); }
            }
            Files.deleteIfExists(katalog);
            System.out.println("Usunięto katalog demonstracyjny.");
        }
    }
}