0.5.0

Author: asiekierka

docs/changelog/0.5.0.txt

@@ -3,7 +3,10 @@ Improvements:
 * Added .MZM export support for interoperability with MegaZeux.
 * Added a "MegaZeux" platform. It behaves a bit differently from previous ones - only the board width and height can be
   configured, and there are no elements to choose from. Rather, these decisions are performed by the MegaZeux editor.
+    * Note that even though "MegaZeux" is a platform, many parts of the algorithm still assume an ASCII-esque character
+      layout (solid, blending, empty characters).
 * The open/save dialogs now remember the directory they were last used in (per-type) until you close the app.
+* (Very) minor performance improvements.
 
 Bugs fixed:
 

src/main/java/pl/asie/libzzt/Stat.java

@@ -110,6 +110,15 @@ public void readZ(ZInputStream stream) throws IOException {
 		boundStatId = (dataLen < 0) ? -dataLen : 0;
 	}
 
+	public int lengthZ(Platform platform) {
+		int len = (platform == Platform.ZZT ? 33 : 25);
+		if (boundStatId == 0 && data != null) {
+			byte[] dataBytes = data.getBytes(StandardCharsets.ISO_8859_1);
+			len += dataBytes.length;
+		}
+		return len;
+	}
+
 	public void writeZ(ZOutputStream stream) throws IOException {
 		byte[] dataBytes = data != null ? data.getBytes(StandardCharsets.ISO_8859_1) : null;
 		stream.writePByte(this.x);

src/main/java/pl/asie/zima/image/ImageConverter.java

@@ -19,6 +19,7 @@
 package pl.asie.zima.image;
 
 import lombok.AllArgsConstructor;
+import lombok.Data;
 import lombok.Getter;
 import pl.asie.libzzt.Board;
 import pl.asie.libzzt.Element;
@@ -37,9 +38,7 @@
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.HashSet;
-import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 import java.util.function.IntPredicate;
 import java.util.stream.Collectors;
@@ -107,17 +106,27 @@ private Pair<Result, BufferedImage> convertBoardless(BufferedImage inputImage, i
 		List<ElementResult> rules = new ArrayList<>(256 * 256);
 		final int progressSize = width * height;
 		ElementResult[] previewResults = new ElementResult[width * height];
+		ElementResult emptyResult = null;
 		BufferedImage preview = null;
 
 		for (int ich = 0; ich < 256; ich++) {
 			if (fast && (ich != 32 && ich != 176 && ich != 177 && ich != 178 && ich != 219)) continue;
 			if (charCheck != null && !charCheck.test(ich)) continue;
 			for (int ico = 0; ico < 256; ico++) {
 				if (colorCheck != null && !colorCheck.test(ico)) continue;
-				rules.add(new ElementResult(null, false, false, ich, ico));
+				ElementResult result = new ElementResult(null, false, false, ich, ico);
+				if (emptyResult == null) {
+					emptyResult = result;
+				}
+				rules.add(result);
 			}
 		}
 
+		if (emptyResult == null) {
+			emptyResult = new ElementResult(null, false, false, 0, 0);
+		}
+		final ElementResult emptyResultFinal = emptyResult;
+
 		// find lowest-MSE results for each tile, in parallel
 		IntStream.range(0, width * height).parallel().forEach(pos -> {
 			synchronized (progressCallback) {
@@ -127,7 +136,7 @@ private Pair<Result, BufferedImage> convertBoardless(BufferedImage inputImage, i
 			int ix = pos % width;
 			int iy = pos / width;
 
-			ElementResult minResult = null;
+			ElementResult minResult = emptyResultFinal;
 			float minMse = Float.MAX_VALUE;
 			ImageMseCalculator.Applier applyMseFunc = mseCalculator.applyMse(inputImage, ix * visual.getCharWidth(), iy * visual.getCharHeight());
 
@@ -166,6 +175,12 @@ private Pair<Result, BufferedImage> convertBoardless(BufferedImage inputImage, i
 		return new Pair<>(result, preview);
 	}
 
+	@Data
+	private static class ElementRuleResult {
+		private final ElementRule rule;
+		private final List<ElementResult> result;
+	}
+
 	public Pair<Result, BufferedImage> convert(BufferedImage inputImage, ImageConverterRuleset ruleset,
 											  int x, int y, int width, int height, int playerX, int playerY, int maxStatCount, boolean blinkingDisabled,
 											  int maxBoardSize,
@@ -190,7 +205,7 @@ public Pair<Result, BufferedImage> convert(BufferedImage inputImage, ImageConver
 		final BufferedImage image = inputImage;
 
 		List<Triplet<Coord2D, ElementResult, Float>> statfulStrategies = new ArrayList<>();
-		Map<ElementRule, List<ElementResult>> ruleResultMap = new LinkedHashMap<>();
+		List<ElementRuleResult> ruleResultList = new ArrayList<>(ruleset.getRules().size());
 		Set<Element> allowedElements = new HashSet<>();
 		ElementResult[] previewResults = new ElementResult[width * height];
 		float[] previewMse = new float[width * height];
@@ -248,7 +263,7 @@ public Pair<Result, BufferedImage> convert(BufferedImage inputImage, ImageConver
 					break;
 			}
 
-			ruleResultMap.put(rule, proposals.collect(Collectors.toList()));
+			ruleResultList.add(new ElementRuleResult(rule, proposals.collect(Collectors.toList())));
 		}
 
 		// find lowest-MSE results for each tile, in parallel
@@ -276,8 +291,8 @@ public Pair<Result, BufferedImage> convert(BufferedImage inputImage, ImageConver
 			float statfulMse = Float.MAX_VALUE;
 			ImageMseCalculator.Applier applyMseFunc = mseCalculator.applyMse(image, ix * visual.getCharWidth(), iy * visual.getCharHeight());
 
-			for (Map.Entry<ElementRule, List<ElementResult>> ruleResult : ruleResultMap.entrySet()) {
-				List<ElementResult> proposals = ruleResult.getValue();
+			for (ElementRuleResult ruleResult : ruleResultList) {
+				List<ElementResult> proposals = ruleResult.getResult();
 
 				float lowestLocalMse = statlessMse;
 				ElementResult lowestLocalResult = null;
@@ -336,10 +351,8 @@ public Pair<Result, BufferedImage> convert(BufferedImage inputImage, ImageConver
 		int boardSerializationSize = count(board::writeZ);
 		int addedStats = 0;
 
+		Stat stat = new Stat();
 		for (int i = 0; i < statfulStrategies.size(); i++) {
-			if (addedStats >= realMaxStatCount) {
-				break;
-			}
 			Triplet<Coord2D, ElementResult, Float> strategyData = statfulStrategies.get(i);
 			Coord2D coords = strategyData.getFirst();
 			ElementResult result = strategyData.getSecond();
@@ -352,25 +365,28 @@ public Pair<Result, BufferedImage> convert(BufferedImage inputImage, ImageConver
 			previewResults[coords.getY() * width + coords.getX()] = result;
 			board.setElement(x + coords.getX(), y + coords.getY(), result.getElement());
 			board.setColor(x + coords.getX(), y + coords.getY(), result.getColor());
-			Stat stat = new Stat();
+
 			stat.setX(x + coords.getX());
 			stat.setY(y + coords.getY());
 			stat.setCycle(1); // maybe we can reduce this to save CPU cycles?
 			stat.setP1(result.getCharacter());
 
 			if (boardSerializationSize < (realMaxBoardSize - 128)) {
 				// optimization: don't recalc full board size if only RLE could be impacted
-				boardSerializationSize += count(stat::writeZ);
+				boardSerializationSize += stat.lengthZ(platform);
 			} else {
-				boardSerializationSize = count(board::writeZ) + count(stat::writeZ);
+				boardSerializationSize = count(board::writeZ) + stat.lengthZ(platform);
 			}
 			if (boardSerializationSize > realMaxBoardSize) {
 				previewResults[coords.getY() * width + coords.getX()] = prevResult;
 				board.setElement(x + coords.getX(), y + coords.getY(), prevElement);
 				board.setColor(x + coords.getX(), y + coords.getY(), prevColor);
 			} else {
 				board.addStat(stat);
-				addedStats++;
+				if ((++addedStats) >= realMaxStatCount) {
+					break;
+				}
+				stat = new Stat();
 			}
 		}
 
@@ -388,7 +404,7 @@ public Pair<Result, BufferedImage> convert(BufferedImage inputImage, ImageConver
 						Element element = board.getElement(x + ix, y + iy);
 						int color = board.getColor(x + ix, y + iy);
 
-						if (!element.isText() && !element.isStat()) {
+						if (!element.isText() && (!element.isStat() || board.getStatAt(x + ix, y + iy) == null)) {
 							if (!blinkingDisabled && color >= 0x80) {
 								continue;
 							}

src/main/java/pl/asie/zima/image/TrixImageMseCalculator.java

@@ -22,10 +22,11 @@
 import pl.asie.libzzt.TextVisualData;
 
 import java.awt.image.BufferedImage;
+import java.util.HashSet;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 public class TrixImageMseCalculator implements ImageMseCalculator {
-	private static final Set<Integer> blendingChars = Set.of(0, 32, 176, 177, 178, 219);
 	private final TextVisualData visual;
 	private final float contrastReduction;
 	private final float accurateApproximate;
@@ -34,6 +35,7 @@ public class TrixImageMseCalculator implements ImageMseCalculator {
 	private final boolean[][] charLut1x1Precalc;
 	private final float[] colDistPrecalc;
 	private final boolean blinkingDisabled;
+	private final Set<Integer> blendingChars = new HashSet<>();
 
 	private static class ImageLutHolder {
 		private final float[][] dataMacro1x1;
@@ -92,27 +94,32 @@ public TrixImageMseCalculator(TextVisualData visual, boolean blinkingDisabled, f
 			charLutPrecalc[i] = ColorUtils.mix(bg, fg, fgColored / 4.0f);
 		}
 
-		charLut2x2Precalc = new int[256][(visual.getCharWidth() >> 1) * (visual.getCharHeight() >> 1)];
+		int charLut2x2Count = (visual.getCharWidth() >> 1) * (visual.getCharHeight() >> 1);
+		charLut2x2Precalc = new int[256][charLut2x2Count];
 		for (int c = 0; c < 256; c++) {
 			int coff = c * visual.getCharHeight();
+			int[] charLut2x2PrecalcLocal = charLut2x2Precalc[c];
+
 			for (int cy = 0; cy < visual.getCharHeight(); cy += 2) {
 				int charLine1 = (int) visual.getCharData()[coff + cy] & 0xFF;
 				int charLine2 = (int) visual.getCharData()[coff + cy + 1] & 0xFF;
 
 				for (int cx = 0; cx < visual.getCharWidth(); cx += 2) {
 					int charLutIdx = ((charLine1 >> (6 - cx)) & 3) | (((charLine2 >> (6 - cx)) & 3) << 2);
-					charLut2x2Precalc[c][(cy >> 1) * (visual.getCharWidth() >> 1) + (cx >> 1)] = charLutIdx;
+					charLut2x2PrecalcLocal[(cy >> 1) * (visual.getCharWidth() >> 1) + (cx >> 1)] = charLutIdx;
 				}
 			}
 		}
 
 		charLut1x1Precalc = new boolean[256][visual.getCharWidth() * visual.getCharHeight()];
 		for (int c = 0; c < 256; c++) {
 			int coff = c * visual.getCharHeight();
+			boolean[] charLut1x1PrecalcLocal = charLut1x1Precalc[c];
+
 			for (int cy = 0; cy < visual.getCharHeight(); cy++) {
 				int charLine = (int) visual.getCharData()[coff + cy] & 0xFF;
 				for (int cx = 0; cx < visual.getCharWidth(); cx++) {
-					charLut1x1Precalc[c][cy * visual.getCharWidth() + cx] = (charLine & (1 << (7 - cx))) != 0;
+					charLut1x1PrecalcLocal[cy * visual.getCharWidth() + cx] = (charLine & (1 << (7 - cx))) != 0;
 				}
 			}
 		}
@@ -123,31 +130,40 @@ public TrixImageMseCalculator(TextVisualData visual, boolean blinkingDisabled, f
 			int fg = visual.getPalette()[i & 0x0F];
 			colDistPrecalc[i] = ColorUtils.distance(bg, fg);
 		}
+
+		blendingChars.add(176);
+		blendingChars.add(177);
+		blendingChars.add(178);
+		for (int i = 0; i < 256; i++) {
+			if (visual.isCharEmpty(i) || visual.isCharFull(i)) {
+				blendingChars.add(i);
+			}
+		}
 	}
 
 	@Override
 	public Applier applyMse(BufferedImage image, int px, int py) {
 		final ImageLutHolder holder = new ImageLutHolder(visual, image, px, py, visual.getCharWidth(), visual.getCharHeight());
 		float[] mseContrastPrecalc = new float[256];
+		float[] macroRatioPrecalc = new float[256];
 		for (int i = 0; i < 256; i++) {
 			float imgContrast = holder.maxDistance;
 			float chrContrast = colDistPrecalc[i];
 			float contrastDiff = (imgContrast - chrContrast);
 			mseContrastPrecalc[i] = contrastReduction * contrastDiff * contrastDiff;
+
+			macroRatioPrecalc[i] = blendingChars.contains(i) ? 1.0f : accurateApproximate;
 		}
+		final int colorMask = blinkingDisabled ? 0xFF : 0x7F;
 		return (proposed, maxMse) -> {
 			int chr = proposed.getCharacter();
-			int col = blinkingDisabled ? proposed.getColor() : (proposed.getColor() & 0x7F);
+			int col = proposed.getColor() & colorMask;
 
 			float mse = 0.0f;
 			int[] dataMacro2x2 = holder.dataMacro2x2;
 
 			float mseContrastReduction = mseContrastPrecalc[col];
-
-			float macroRatio = accurateApproximate;
-			if (blendingChars.contains(chr)) {
-				macroRatio = 1.0f; // use only macro when blending
-			}
+			float macroRatio = macroRatioPrecalc[chr];
 
 			mse += dataMacro2x2.length * mseContrastReduction;
 			if (mse <= maxMse) {