StretchedImageFilter.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2010 The Gridarta Developers.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
package net.sf.gridarta.model.face;
 
import java.awt.Point;
import java.awt.Polygon;
import java.awt.image.ColorModel;
import java.awt.image.ImageFilter;
import org.jetbrains.annotations.NotNull;
 
public class StretchedImageFilter extends ImageFilter {
 
    private static final ColorModel RGB_DEFAULT_COLOR_MODEL = ColorModel.getRGBdefault();
 
    private long stretchFactor;
 
    private int width;
 
    private int height;
 
    private int @NotNull [] raster = new int[0];
 
    private int @NotNull [] pixels = new int[0];
 
    @NotNull
    private static final Point @NotNull [] point = { new Point(), new Point(), new Point(), new Point() };
 
    @NotNull
    private static final Point @NotNull [] point2 = { new Point(), new Point(), new Point(), new Point() };
 
    private static final double @NotNull [] slope = { 0.0, 0.0, 0.0, 0.0 };
 
    private final int @NotNull [] stdTileHalfLen = { 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 11, 11, 10, 10, 9, 9, 8, 8, 7, 7, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0 };
 
    @NotNull
    private static final Polygon polygon = new Polygon();
 
    public void setStretchedFactor(final long stretchFactor) {
        this.stretchFactor = stretchFactor;
    }
 
    @Override
    public void setDimensions(final int width, final int height) {
        this.width = width;
        this.height = height;
        final int newHeight = height + (int) ((stretchFactor >> 24) & 0xff);
        pixels = new int[width * height];
        raster = new int[width * newHeight];
        super.setDimensions(width, newHeight);
    }
 
    @Override
    public void setHints(final int hints) {
        super.setHints(COMPLETESCANLINES | TOPDOWNLEFTRIGHT);
    }
 
    @Override
    public void setPixels(final int x, final int y, final int w, final int h, @NotNull final ColorModel model, final byte @NotNull [] pixels, final int off, final int scansize) {
        int srcOff = off;
        int dstOff = y * width + x;
        for (int yc = 0; yc < h; yc++) {
            for (int xc = 0; xc < w; xc++) {
                this.pixels[dstOff++] = model.getRGB(pixels[srcOff++] & 0xff);
            }
            srcOff += scansize - w;
            dstOff += width - w;
        }
    }
 
    @Override
    public void setPixels(final int x, final int y, final int w, final int h, @NotNull final ColorModel model, @NotNull final int @NotNull [] pixels, final int off, final int scansize) {
        int srcOff = off;
        int dstOff = y * width + x;
        for (int yc = 0; yc < h; yc++) {
            for (int xc = 0; xc < w; xc++) {
                this.pixels[dstOff++] = model.getRGB(pixels[srcOff++]);
            }
            srcOff += scansize - w;
            dstOff += width - w;
        }
    }
 
    private static void determineLine(final int idx, final int sx, final int sy, final int ex, final int ey) {
        point[idx].x = sx;
        point[idx].y = sy;
        point2[idx].x = ex;
        point2[idx].y = ey;
        final double xDiff = Math.abs(sx - ex);
        final double yDiff = Math.abs(sy - ey);
        slope[idx] = xDiff == 0 ? 0.0 : yDiff / xDiff;
    }
 
    private static void determineLines(final int n, final int e, final int s, final int w) {
        determineLine(0, 2, 10 - w + n, 22, 0);
        determineLine(1, 2, 12 - w + n, 22, 22 + n - s);
        determineLine(2, 45, 10 - e + n, 25, 0);
        determineLine(3, 45, 12 - e + n, 25, 22 + n - s);
    }
 
    public static boolean coordsInTile(final long stretch, final int x, final int y) {
        final int n = (int) (stretch >> 24) & 0xff;
        final int e = (int) (stretch >> 16) & 0xff;
        final int w = (int) (stretch >> 8) & 0xff;
        final int s = (int) stretch & 0xff;
        determineLines(n, e, s, w);
 
        polygon.reset();
        polygon.addPoint(point2[0].x - 1, point2[0].y - 1);
        polygon.addPoint(point2[2].x + 1, point2[2].y - 1);
        polygon.addPoint(point[2].x + 3, point[2].y - 1);
        polygon.addPoint(point[3].x + 3, point[3].y + 1);
        polygon.addPoint(point2[3].x + 1, point2[3].y + 2);
        polygon.addPoint(point2[1].x - 1, point2[1].y + 2);
        polygon.addPoint(point[1].x - 3, point[1].y + 1);
        polygon.addPoint(point[0].x - 3, point[0].y - 1);
 
        return polygon.contains(x, y);
    }
 
    private void copyPixelToPixel(final int x, final int y, final int x2, final int y2, final double brightness, final int wd, final int ht, final int wd2, final int ht2, @NotNull final ColorModel model) {
        if (x < 0 || y < 0 || x2 < 0 || y2 < 0 || x >= wd || x2 >= wd2 || y >= ht || y2 >= ht2) {
            return;
        }
 
        final int color = model.getRGB(pixels[y * wd + x]);
 
        final int a = (color >> 24) & 0xff;
        if (a == 0) {
            return;
        }
        final int r1 = (color >> 16) & 0xff;
        final int g1 = (color >> 8) & 0xff;
        final int b1 = color & 0xff;
 
        final int r = Math.min(255, (int) (r1 * brightness));
        final int g = Math.min(255, (int) (g1 * brightness));
        final int b = Math.min(255, (int) (b1 * brightness));
        raster[y2 * wd2 + x2] = (a << 24) | (r << 16) | (g << 8) | b;
    }
 
    private void copyVerticalLine(final int srcX, final int srcSy, final int srcEy, final int destX, final int destSy, final int destEy, final double brightness, final boolean extra, final int wd, final int ht, final int wd2, final int ht2, @NotNull final ColorModel model) {
        final int minSrcY = Math.min(srcSy, srcEy);
        final int maxSrcY = Math.max(srcSy, srcEy);
        final int minDestY = Math.min(destSy, destEy);
        final int maxDestY = Math.max(destSy, destEy);
        final int srcH = maxSrcY - minSrcY;
        final int destH = maxDestY - minDestY;
 
        if (destH == 0) {
            copyPixelToPixel(srcX, srcH == 0 ? minSrcY : (maxSrcY - minSrcY) / 2, destX, minDestY, brightness, wd, ht, wd2, ht2, model);
            return;
        }
 
        if (srcH == 0) {
            final int pixel = model.getRGB(pixels[minSrcY * wd + srcX]);
            for (int y = minDestY; y <= maxDestY; y++) {
                raster[y * wd2 + destX] = pixel;
            }
            return;
        }
 
        /* The stretching */
        final double ratio = srcH / (double) destH;
 
        for (int y = 0; y <= destH; y++) {
            final int goY = minDestY + y;
            final int getY = (int) (minSrcY + (y * ratio));
            copyPixelToPixel(srcX, getY, destX, goY, brightness, wd, ht, wd2, ht2, model);
        }
 
        if (extra && maxDestY + 1 < ht2) {
            copyPixelToPixel(srcX, maxSrcY, destX, maxDestY + 1, brightness, wd, ht, wd2, ht2, model);
        }
    }
 
    private void stretch(final int wd, final int ht, @NotNull final ColorModel model) {
        final int n = (int) (stretchFactor >> 24) & 0xff;
        final int e = (int) (stretchFactor >> 16) & 0xff;
        final int w = (int) (stretchFactor >> 8) & 0xff;
        final int s = (int) stretchFactor & 0xff;
 
        final int wd2 = wd;
        final int ht2 = ht + n;
 
        final boolean flat = n != 0 || e != 0 || w != 0 || s != 0;
 
        final double eDark;
        final double wDark;
        if (w > e) {
            wDark = 1.0 - ((w - e) / 25.0);
            eDark = n > 0 || s > 0 ? wDark : 1.0;
        } else if (e > w) {
            eDark = 1.0 + ((e - w) / 25.0);
            wDark = s > 0 || n > 0 ? eDark : 1.0;
        } else {
            eDark = 1.0;
            wDark = 1.0;
        }
 
        determineLines(n, e, s, w);
 
        for (int lnNum = 0; lnNum < 4; lnNum += 2) {
            final int destSx = point[lnNum].x;
            final int destSy = point[lnNum].y;
            final int destEx = point2[lnNum].x;
            final int destEy = point2[lnNum].y;
            final double destSlope = slope[lnNum];
 
            final int destSy2 = point[lnNum + 1].y;
            final int destEy2 = point2[lnNum + 1].y;
            final double destSlope2 = slope[lnNum + 1];
 
            final int destYInc = destSy > destEy ? -1 : 1;
            final int destXInc = destSx > destEx ? -1 : 1;
            final int destYInc2 = destSy2 > destEy2 ? -1 : 1;
 
            int dx = destSx;
            int dy = destSy;
            double kicker = 0.0;
            int y2 = destSy2;
            double kicker2 = 0.0;
            boolean atLeastOne = false;
 
            while ((destSlope != 0.0 && dx != destEx && dy != destEy) || (!atLeastOne && destSlope == 0.0)) {
                atLeastOne = true;
 
                if (kicker >= 1.0) {
                    kicker -= 1.0;
                    dy += destYInc;
                }
 
                if (kicker2 >= 1.0) {
                    kicker2 -= 1.0;
                    y2 += destYInc2;
                }
 
                final int srcLen = stdTileHalfLen[dx];
 
                copyVerticalLine(dx, 11 + srcLen, 11 - srcLen, dx, dy, y2, lnNum < 2 ? wDark : eDark, flat, wd, ht, wd2, ht2, model);
 
                dx += destXInc;
 
                kicker += destSlope;
                kicker2 += destSlope2;
            }
        }
 
        for (int dx = 22; dx < 22 + 2; dx++) {
            copyVerticalLine(dx, 0, 23, dx, 0, 23 + n - s, wDark, flat, wd, ht, wd2, ht2, model);
        }
 
        for (int dx = 24; dx < 24 + 2; dx++) {
            copyVerticalLine(dx, 0, 23, dx, 0, 23 + n - s, eDark, flat, wd, ht, wd2, ht2, model);
        }
 
        for (int dx = 0; dx < 2; dx++) {
            copyPixelToPixel(dx, 11, dx, 11 + n - w, wDark, wd, ht, wd2, ht2, model);
        }
 
        for (int dx = 46; dx < 48; dx++) {
            copyPixelToPixel(dx, 11, dx, 11 + n - e, eDark, wd, ht, wd2, ht2, model);
        }
    }
 
    @Override
    public void imageComplete(final int status) {
        if (status != IMAGEERROR && status != IMAGEABORTED) {
            stretch(width, height, RGB_DEFAULT_COLOR_MODEL);
            super.setPixels(0, 0, width, height + (int) ((stretchFactor >> 24) & 0xff), RGB_DEFAULT_COLOR_MODEL, raster, 0, width);
        }
        super.imageComplete(status);
    }
 
}