Commit | Line | Data |
---|---|---|
80500544 | 1 | package be.nikiroo.utils.ui; |
b771aed5 NR |
2 | |
3 | import java.awt.Color; | |
4 | import java.awt.Dimension; | |
5 | import java.awt.Graphics; | |
6 | import java.awt.Image; | |
7 | import java.awt.image.BufferedImage; | |
8 | import java.awt.image.ImageObserver; | |
9 | ||
10 | /** | |
11 | * This class converts an {@link Image} into a textual representation that can | |
12 | * be displayed to the user in a TUI. | |
13 | * | |
14 | * @author niki | |
15 | */ | |
80500544 | 16 | public class ImageTextAwt { |
b771aed5 NR |
17 | private Image image; |
18 | private Dimension size; | |
19 | private String text; | |
20 | private boolean ready; | |
21 | private Mode mode; | |
22 | private boolean invert; | |
23 | ||
24 | /** | |
80500544 | 25 | * The rendering modes supported by this {@link ImageTextAwt} to convert |
b771aed5 NR |
26 | * {@link Image}s into text. |
27 | * | |
28 | * @author niki | |
29 | * | |
30 | */ | |
31 | public enum Mode { | |
32 | /** | |
33 | * Use 5 different "colours" which are actually Unicode | |
34 | * {@link Character}s representing | |
35 | * <ul> | |
36 | * <li>space (blank)</li> | |
37 | * <li>low shade (░)</li> | |
38 | * <li>medium shade (▒)</li> | |
39 | * <li>high shade (▓)</li> | |
40 | * <li>full block (█)</li> | |
41 | * </ul> | |
42 | */ | |
43 | DITHERING, | |
44 | /** | |
45 | * Use "block" Unicode {@link Character}s up to quarter blocks, thus in | |
46 | * effect doubling the resolution both in vertical and horizontal space. | |
47 | * Note that since 2 {@link Character}s next to each other are square, | |
48 | * we will use 4 blocks per 2 blocks for w/h resolution. | |
49 | */ | |
50 | DOUBLE_RESOLUTION, | |
51 | /** | |
52 | * Use {@link Character}s from both {@link Mode#DOUBLE_RESOLUTION} and | |
53 | * {@link Mode#DITHERING}. | |
54 | */ | |
55 | DOUBLE_DITHERING, | |
56 | /** | |
57 | * Only use ASCII {@link Character}s. | |
58 | */ | |
59 | ASCII, | |
60 | } | |
61 | ||
62 | /** | |
80500544 | 63 | * Create a new {@link ImageTextAwt} with the given parameters. Defaults to |
b771aed5 NR |
64 | * {@link Mode#DOUBLE_DITHERING} and no colour inversion. |
65 | * | |
66 | * @param image | |
67 | * the source {@link Image} | |
68 | * @param size | |
69 | * the final text size to target | |
70 | */ | |
80500544 | 71 | public ImageTextAwt(Image image, Dimension size) { |
b771aed5 NR |
72 | this(image, size, Mode.DOUBLE_DITHERING, false); |
73 | } | |
74 | ||
75 | /** | |
80500544 | 76 | * Create a new {@link ImageTextAwt} with the given parameters. |
b771aed5 NR |
77 | * |
78 | * @param image | |
79 | * the source {@link Image} | |
80 | * @param size | |
81 | * the final text size to target | |
82 | * @param mode | |
83 | * the mode of conversion | |
84 | * @param invert | |
85 | * TRUE to invert colours rendering | |
86 | */ | |
80500544 | 87 | public ImageTextAwt(Image image, Dimension size, Mode mode, boolean invert) { |
b771aed5 NR |
88 | setImage(image); |
89 | setSize(size); | |
90 | setMode(mode); | |
91 | setColorInvert(invert); | |
92 | } | |
93 | ||
94 | /** | |
95 | * Change the source {@link Image}. | |
96 | * | |
97 | * @param image | |
98 | * the new {@link Image} | |
99 | */ | |
100 | public void setImage(Image image) { | |
101 | this.text = null; | |
102 | this.ready = false; | |
103 | this.image = image; | |
104 | } | |
105 | ||
106 | /** | |
80500544 | 107 | * Change the target size of this {@link ImageTextAwt}. |
b771aed5 NR |
108 | * |
109 | * @param size | |
110 | * the new size | |
111 | */ | |
112 | public void setSize(Dimension size) { | |
113 | this.text = null; | |
114 | this.ready = false; | |
115 | this.size = size; | |
116 | } | |
117 | ||
118 | /** | |
119 | * Change the image-to-text mode. | |
120 | * | |
121 | * @param mode | |
122 | * the new {@link Mode} | |
123 | */ | |
124 | public void setMode(Mode mode) { | |
125 | this.mode = mode; | |
126 | this.text = null; | |
127 | this.ready = false; | |
128 | } | |
129 | ||
130 | /** | |
131 | * Set the colour-invert mode. | |
132 | * | |
133 | * @param invert | |
134 | * TRUE to inverse the colours | |
135 | */ | |
136 | public void setColorInvert(boolean invert) { | |
137 | this.invert = invert; | |
138 | this.text = null; | |
139 | this.ready = false; | |
140 | } | |
141 | ||
142 | /** | |
143 | * Check if the colours are inverted. | |
144 | * | |
145 | * @return TRUE if the colours are inverted | |
146 | */ | |
147 | public boolean isColorInvert() { | |
148 | return invert; | |
149 | } | |
150 | ||
151 | /** | |
152 | * Return the textual representation of the included {@link Image}. | |
153 | * | |
154 | * @return the {@link String} representation | |
155 | */ | |
156 | public String getText() { | |
157 | if (text == null) { | |
158 | if (image == null || size == null || size.width == 0 | |
cd0c27d2 | 159 | || size.height == 0) { |
b771aed5 | 160 | return ""; |
cd0c27d2 | 161 | } |
b771aed5 NR |
162 | |
163 | int mult = 1; | |
cd0c27d2 | 164 | if (mode == Mode.DOUBLE_RESOLUTION || mode == Mode.DOUBLE_DITHERING) { |
b771aed5 | 165 | mult = 2; |
cd0c27d2 | 166 | } |
b771aed5 | 167 | |
ce060f5a NR |
168 | Dimension srcSize = getSize(image); |
169 | srcSize = new Dimension(srcSize.width * 2, srcSize.height); | |
170 | int x = 0; | |
171 | int y = 0; | |
172 | ||
b771aed5 NR |
173 | int w = size.width * mult; |
174 | int h = size.height * mult; | |
175 | ||
ce060f5a NR |
176 | // Default = original ratio or original size if none |
177 | if (w < 0 || h < 0) { | |
178 | if (w < 0 && h < 0) { | |
179 | w = srcSize.width * mult; | |
180 | h = srcSize.height * mult; | |
181 | } else { | |
182 | double ratioSrc = (double) srcSize.width | |
183 | / (double) srcSize.height; | |
184 | if (w < 0) { | |
185 | w = (int) Math.round(h * ratioSrc); | |
186 | } else { | |
187 | h = (int) Math.round(w / ratioSrc); | |
188 | } | |
189 | } | |
190 | } | |
191 | ||
192 | // Fail safe: we consider this to be too much | |
193 | if (w > 1000 || h > 1000) { | |
194 | return "[IMAGE TOO BIG]"; | |
195 | } | |
196 | ||
b771aed5 NR |
197 | BufferedImage buff = new BufferedImage(w, h, |
198 | BufferedImage.TYPE_INT_ARGB); | |
199 | ||
200 | Graphics gfx = buff.getGraphics(); | |
201 | ||
ce060f5a NR |
202 | double ratioAsked = (double) (w) / (double) (h); |
203 | double ratioSrc = (double) srcSize.height / (double) srcSize.width; | |
204 | double ratio = ratioAsked * ratioSrc; | |
b771aed5 | 205 | if (srcSize.width < srcSize.height) { |
b771aed5 NR |
206 | h = (int) Math.round(ratio * h); |
207 | y = (buff.getHeight() - h) / 2; | |
208 | } else { | |
ce060f5a | 209 | w = (int) Math.round(w / ratio); |
b771aed5 NR |
210 | x = (buff.getWidth() - w) / 2; |
211 | } | |
212 | ||
213 | if (gfx.drawImage(image, x, y, w, h, new ImageObserver() { | |
cd0c27d2 | 214 | @Override |
b771aed5 NR |
215 | public boolean imageUpdate(Image img, int infoflags, int x, |
216 | int y, int width, int height) { | |
80500544 | 217 | ImageTextAwt.this.ready = true; |
b771aed5 NR |
218 | return true; |
219 | } | |
220 | })) { | |
221 | ready = true; | |
222 | } | |
223 | ||
224 | while (!ready) { | |
225 | try { | |
226 | Thread.sleep(100); | |
227 | } catch (InterruptedException e) { | |
228 | } | |
229 | } | |
230 | ||
231 | gfx.dispose(); | |
232 | ||
233 | StringBuilder builder = new StringBuilder(); | |
234 | ||
ce060f5a | 235 | for (int row = 0; row + (mult - 1) < buff.getHeight(); row += mult) { |
cd0c27d2 | 236 | if (row > 0) { |
b771aed5 | 237 | builder.append('\n'); |
cd0c27d2 | 238 | } |
b771aed5 | 239 | |
ce060f5a | 240 | for (int col = 0; col + (mult - 1) < buff.getWidth(); col += mult) { |
b771aed5 NR |
241 | if (mult == 1) { |
242 | char car = ' '; | |
243 | float brightness = getBrightness(buff.getRGB(col, row)); | |
244 | if (mode == Mode.DITHERING) | |
245 | car = getDitheringChar(brightness, " ░▒▓█"); | |
246 | if (mode == Mode.ASCII) | |
247 | car = getDitheringChar(brightness, " .-+=o8#"); | |
248 | ||
249 | builder.append(car); | |
250 | } else if (mult == 2) { | |
251 | builder.append(getBlockChar( // | |
252 | buff.getRGB(col, row),// | |
253 | buff.getRGB(col + 1, row),// | |
254 | buff.getRGB(col, row + 1),// | |
255 | buff.getRGB(col + 1, row + 1),// | |
256 | mode == Mode.DOUBLE_DITHERING// | |
257 | )); | |
258 | } | |
259 | } | |
260 | } | |
261 | ||
262 | text = builder.toString(); | |
263 | } | |
264 | ||
265 | return text; | |
266 | } | |
267 | ||
268 | @Override | |
269 | public String toString() { | |
270 | return getText(); | |
271 | } | |
272 | ||
273 | /** | |
274 | * Return the size of the given {@link Image}. | |
275 | * | |
276 | * @param img | |
277 | * the image to measure | |
278 | * | |
279 | * @return the size | |
280 | */ | |
281 | static private Dimension getSize(Image img) { | |
282 | Dimension size = null; | |
283 | while (size == null) { | |
284 | int w = img.getWidth(null); | |
285 | int h = img.getHeight(null); | |
286 | if (w > -1 && h > -1) { | |
287 | size = new Dimension(w, h); | |
288 | } else { | |
289 | try { | |
290 | Thread.sleep(100); | |
291 | } catch (InterruptedException e) { | |
292 | } | |
293 | } | |
294 | } | |
295 | ||
296 | return size; | |
297 | } | |
298 | ||
299 | /** | |
300 | * Return the {@link Character} corresponding to the given brightness level | |
301 | * from the evenly-separated given {@link Character}s. | |
302 | * | |
303 | * @param brightness | |
304 | * the brightness level | |
305 | * @param cars | |
306 | * the {@link Character}s to choose from, from less bright to | |
307 | * most bright; <b>MUST</b> contain at least one | |
308 | * {@link Character} | |
309 | * | |
310 | * @return the {@link Character} to use | |
311 | */ | |
312 | private char getDitheringChar(float brightness, String cars) { | |
313 | int index = Math.round(brightness * (cars.length() - 1)); | |
314 | return cars.charAt(index); | |
315 | } | |
316 | ||
317 | /** | |
318 | * Return the {@link Character} corresponding to the 4 given colours in | |
319 | * {@link Mode#DOUBLE_RESOLUTION} or {@link Mode#DOUBLE_DITHERING} mode. | |
320 | * | |
321 | * @param upperleft | |
322 | * the upper left colour | |
323 | * @param upperright | |
324 | * the upper right colour | |
325 | * @param lowerleft | |
326 | * the lower left colour | |
327 | * @param lowerright | |
328 | * the lower right colour | |
329 | * @param dithering | |
330 | * TRUE to use {@link Mode#DOUBLE_DITHERING}, FALSE for | |
331 | * {@link Mode#DOUBLE_RESOLUTION} | |
332 | * | |
333 | * @return the {@link Character} to use | |
334 | */ | |
335 | private char getBlockChar(int upperleft, int upperright, int lowerleft, | |
336 | int lowerright, boolean dithering) { | |
337 | int choice = 0; | |
cd0c27d2 NR |
338 | |
339 | if (getBrightness(upperleft) > 0.5f) { | |
b771aed5 | 340 | choice += 1; |
cd0c27d2 NR |
341 | } |
342 | if (getBrightness(upperright) > 0.5f) { | |
b771aed5 | 343 | choice += 2; |
cd0c27d2 NR |
344 | } |
345 | if (getBrightness(lowerleft) > 0.5f) { | |
b771aed5 | 346 | choice += 4; |
cd0c27d2 NR |
347 | } |
348 | if (getBrightness(lowerright) > 0.5f) { | |
b771aed5 | 349 | choice += 8; |
cd0c27d2 | 350 | } |
b771aed5 NR |
351 | |
352 | switch (choice) { | |
353 | case 0: | |
354 | return ' '; | |
355 | case 1: | |
356 | return '▘'; | |
357 | case 2: | |
358 | return '▝'; | |
359 | case 3: | |
360 | return '▀'; | |
361 | case 4: | |
362 | return '▖'; | |
363 | case 5: | |
364 | return '▌'; | |
365 | case 6: | |
366 | return '▞'; | |
367 | case 7: | |
368 | return '▛'; | |
369 | case 8: | |
370 | return '▗'; | |
371 | case 9: | |
372 | return '▚'; | |
373 | case 10: | |
374 | return '▐'; | |
375 | case 11: | |
376 | return '▜'; | |
377 | case 12: | |
378 | return '▄'; | |
379 | case 13: | |
380 | return '▙'; | |
381 | case 14: | |
382 | return '▟'; | |
383 | case 15: | |
384 | if (dithering) { | |
385 | float avg = 0; | |
386 | avg += getBrightness(upperleft); | |
387 | avg += getBrightness(upperright); | |
388 | avg += getBrightness(lowerleft); | |
389 | avg += getBrightness(lowerright); | |
390 | avg /= 4; | |
391 | ||
9db215c6 NR |
392 | // Since all the quarters are > 0.5, avg is between 0.5 and 1.0 |
393 | // So, expand the range of the value | |
394 | avg = (avg - 0.5f) * 2; | |
395 | ||
396 | // Do not use the " " char, as it would make a | |
397 | // "all quarters > 0.5" pixel go black | |
398 | return getDitheringChar(avg, "░▒▓█"); | |
b771aed5 | 399 | } |
cd0c27d2 NR |
400 | |
401 | return '█'; | |
b771aed5 NR |
402 | } |
403 | ||
404 | return ' '; | |
405 | } | |
406 | ||
407 | /** | |
408 | * Temporary array used so not to create a lot of new ones. | |
409 | */ | |
410 | private float[] tmp = new float[4]; | |
411 | ||
412 | /** | |
413 | * Return the brightness value to use from the given ARGB colour. | |
414 | * | |
415 | * @param argb | |
416 | * the argb colour | |
417 | * | |
418 | * @return the brightness to sue for computations | |
419 | */ | |
420 | private float getBrightness(int argb) { | |
cd0c27d2 | 421 | if (invert) { |
b771aed5 | 422 | return 1 - rgb2hsb(argb, tmp)[2]; |
cd0c27d2 NR |
423 | } |
424 | ||
b771aed5 NR |
425 | return rgb2hsb(argb, tmp)[2]; |
426 | } | |
427 | ||
428 | /** | |
429 | * Convert the given ARGB colour in HSL/HSB, either into the supplied array | |
430 | * or into a new one if array is NULL. | |
431 | * | |
432 | * <p> | |
433 | * ARGB pixels are given in 0xAARRGGBB format, while the returned array will | |
434 | * contain Hue, Saturation, Lightness/Brightness, Alpha, in this order. H, | |
435 | * S, L and A are all ranging from 0 to 1 (indeed, H is in 1/360th). | |
436 | * </p> | |
437 | * pixel | |
438 | * | |
439 | * @param argb | |
440 | * the ARGB colour pixel to convert | |
441 | * @param array | |
442 | * the array to convert into or NULL to create a new one | |
443 | * | |
444 | * @return the array containing the HSL/HSB converted colour | |
445 | */ | |
446 | static float[] rgb2hsb(int argb, float[] array) { | |
447 | int a, r, g, b; | |
448 | a = ((argb & 0xff000000) >> 24); | |
449 | r = ((argb & 0x00ff0000) >> 16); | |
450 | g = ((argb & 0x0000ff00) >> 8); | |
451 | b = ((argb & 0x000000ff)); | |
452 | ||
cd0c27d2 | 453 | if (array == null) { |
b771aed5 | 454 | array = new float[4]; |
cd0c27d2 NR |
455 | } |
456 | ||
b771aed5 NR |
457 | Color.RGBtoHSB(r, g, b, array); |
458 | ||
459 | array[3] = a; | |
460 | ||
461 | return array; | |
462 | ||
463 | // // other implementation: | |
464 | // | |
465 | // float a, r, g, b; | |
466 | // a = ((argb & 0xff000000) >> 24) / 255.0f; | |
467 | // r = ((argb & 0x00ff0000) >> 16) / 255.0f; | |
468 | // g = ((argb & 0x0000ff00) >> 8) / 255.0f; | |
469 | // b = ((argb & 0x000000ff)) / 255.0f; | |
470 | // | |
471 | // float rgbMin, rgbMax; | |
472 | // rgbMin = Math.min(r, Math.min(g, b)); | |
473 | // rgbMax = Math.max(r, Math.max(g, b)); | |
474 | // | |
475 | // float l; | |
476 | // l = (rgbMin + rgbMax) / 2; | |
477 | // | |
478 | // float s; | |
479 | // if (rgbMin == rgbMax) { | |
480 | // s = 0; | |
481 | // } else { | |
482 | // if (l <= 0.5) { | |
483 | // s = (rgbMax - rgbMin) / (rgbMax + rgbMin); | |
484 | // } else { | |
485 | // s = (rgbMax - rgbMin) / (2.0f - rgbMax - rgbMin); | |
486 | // } | |
487 | // } | |
488 | // | |
489 | // float h; | |
490 | // if (r > g && r > b) { | |
491 | // h = (g - b) / (rgbMax - rgbMin); | |
492 | // } else if (g > b) { | |
493 | // h = 2.0f + (b - r) / (rgbMax - rgbMin); | |
494 | // } else { | |
495 | // h = 4.0f + (r - g) / (rgbMax - rgbMin); | |
496 | // } | |
497 | // h /= 6; // from 0 to 1 | |
498 | // | |
499 | // return new float[] { h, s, l, a }; | |
500 | // | |
501 | // // // natural mode: | |
502 | // // | |
503 | // // int aa = (int) Math.round(100 * a); | |
504 | // // int hh = (int) (360 * h); | |
505 | // // if (hh < 0) | |
506 | // // hh += 360; | |
507 | // // int ss = (int) Math.round(100 * s); | |
508 | // // int ll = (int) Math.round(100 * l); | |
509 | // // | |
510 | // // return new int[] { hh, ss, ll, aa }; | |
511 | } | |
512 | } |