Commit | Line | Data |
---|---|---|
f04d8b1c NR |
1 | package be.nikiroo.jvcard.tui; |
2 | ||
25232463 | 3 | import java.awt.Color; |
f04d8b1c NR |
4 | import java.awt.Graphics; |
5 | import java.awt.Image; | |
6 | import java.awt.image.BufferedImage; | |
7 | import java.awt.image.ImageObserver; | |
8 | ||
9 | import com.googlecode.lanterna.TerminalSize; | |
10 | ||
11 | public class ImageText { | |
12 | private Image image; | |
13 | private TerminalSize size; | |
14 | private String text; | |
15 | private boolean ready; | |
25232463 NR |
16 | private Mode mode; |
17 | private boolean invert; | |
f04d8b1c | 18 | |
25232463 NR |
19 | public enum Mode { |
20 | /** | |
21 | * Use 5 different "colours" which are actually Unicode | |
22 | * {@link Character}s representing | |
23 | * <ul> | |
24 | * <li>space (blank)</li> | |
25 | * <li>low shade (░)</li> | |
26 | * <li>medium shade (▒)</li> | |
27 | * <li>high shade (▓)</li> | |
28 | * <li>full block (█)</li> | |
29 | * </ul> | |
30 | */ | |
31 | DITHERING, | |
32 | /** | |
33 | * Use "block" Unicode {@link Character}s up to quarter blocks, thus in | |
34 | * effect doubling the resolution both in vertical and horizontal space. | |
35 | * Note that since 2 {@link Character}s next to each other are square, | |
36 | * we will use 4 blocks per 2 blocks for w/h resolution. | |
37 | */ | |
38 | DOUBLE_RESOLUTION, | |
39 | /** | |
40 | * Use {@link Character}s from both {@link Mode#DOUBLE_RESOLUTION} and | |
41 | * {@link Mode#DITHERING}. | |
42 | */ | |
43 | DOUBLE_DITHERING, | |
44 | /** | |
45 | * Only use ASCII {@link Character}s. | |
46 | */ | |
47 | ASCII, | |
48 | } | |
49 | ||
50 | public ImageText(Image image, TerminalSize size, Mode mode) { | |
f04d8b1c | 51 | setImage(image, size); |
25232463 | 52 | setMode(mode); |
f04d8b1c NR |
53 | } |
54 | ||
55 | public void setImage(Image image) { | |
56 | setImage(image, size); | |
57 | } | |
58 | ||
59 | public void setImage(TerminalSize size) { | |
60 | setImage(image, size); | |
61 | } | |
62 | ||
63 | public void setImage(Image image, TerminalSize size) { | |
64 | this.text = null; | |
65 | this.ready = false; | |
66 | this.size = size; | |
67 | if (image != null) { | |
68 | this.image = image; | |
69 | } | |
70 | } | |
71 | ||
25232463 NR |
72 | public void setMode(Mode mode) { |
73 | this.mode = mode; | |
74 | this.text = null; | |
75 | this.ready = false; | |
76 | } | |
77 | ||
78 | public void setColorInvert(boolean invert) { | |
79 | this.invert = invert; | |
80 | this.text = null; | |
81 | this.ready = false; | |
82 | } | |
83 | ||
84 | public boolean getColorInvert() { | |
85 | return invert; | |
86 | } | |
87 | ||
f04d8b1c NR |
88 | public String getText() { |
89 | if (text == null) { | |
90 | if (image == null) | |
91 | return ""; | |
92 | ||
25232463 NR |
93 | int mult = 1; |
94 | if (mode == Mode.DOUBLE_RESOLUTION || mode == Mode.DOUBLE_DITHERING) | |
95 | mult = 2; | |
96 | ||
97 | int w = size.getColumns() * mult; | |
98 | int h = size.getRows() * mult; | |
99 | ||
f04d8b1c NR |
100 | BufferedImage buff = new BufferedImage(w, h, |
101 | BufferedImage.TYPE_INT_ARGB); | |
25232463 | 102 | |
f04d8b1c NR |
103 | Graphics gfx = buff.getGraphics(); |
104 | ||
105 | TerminalSize srcSize = getSize(image); | |
25232463 NR |
106 | srcSize = new TerminalSize(srcSize.getColumns() * 2, |
107 | srcSize.getRows()); | |
f04d8b1c NR |
108 | int x = 0; |
109 | int y = 0; | |
25232463 | 110 | |
f04d8b1c | 111 | if (srcSize.getColumns() > srcSize.getRows()) { |
25232463 NR |
112 | double ratio = (double) size.getColumns() |
113 | / (double) size.getRows(); | |
114 | ratio *= (double) srcSize.getRows() | |
f04d8b1c | 115 | / (double) srcSize.getColumns(); |
25232463 | 116 | |
f04d8b1c NR |
117 | h = (int) Math.round(ratio * h); |
118 | y = (buff.getHeight() - h) / 2; | |
119 | } else { | |
25232463 NR |
120 | double ratio = (double) size.getRows() |
121 | / (double) size.getColumns(); | |
122 | ratio *= (double) srcSize.getColumns() | |
f04d8b1c | 123 | / (double) srcSize.getRows(); |
25232463 | 124 | |
f04d8b1c NR |
125 | w = (int) Math.round(ratio * w); |
126 | x = (buff.getWidth() - w) / 2; | |
f04d8b1c NR |
127 | } |
128 | ||
129 | if (gfx.drawImage(image, x, y, w, h, new ImageObserver() { | |
130 | @Override | |
131 | public boolean imageUpdate(Image img, int infoflags, int x, | |
132 | int y, int width, int height) { | |
133 | ImageText.this.ready = true; | |
134 | return true; | |
135 | } | |
136 | })) { | |
137 | ready = true; | |
138 | } | |
139 | ||
140 | while (!ready) { | |
141 | try { | |
142 | Thread.sleep(100); | |
143 | } catch (InterruptedException e) { | |
144 | } | |
145 | } | |
146 | ||
147 | gfx.dispose(); | |
148 | ||
f04d8b1c | 149 | StringBuilder builder = new StringBuilder(); |
25232463 NR |
150 | |
151 | for (int row = 0; row < buff.getHeight(); row += mult) { | |
f04d8b1c NR |
152 | if (row > 0) |
153 | builder.append('\n'); | |
154 | ||
25232463 NR |
155 | for (int col = 0; col < buff.getWidth(); col += mult) { |
156 | if (mult == 1) { | |
157 | if (mode == Mode.DITHERING) | |
158 | builder.append(getDitheringChar(buff.getRGB(col, | |
159 | row))); | |
160 | else | |
161 | // Mode.ASCII | |
162 | builder.append(getAsciiChar(buff.getRGB(col, row))); | |
163 | } else if (mult == 2) { | |
164 | builder.append(getBlockChar( // | |
165 | buff.getRGB(col, row),// | |
166 | buff.getRGB(col + 1, row),// | |
167 | buff.getRGB(col, row + 1),// | |
168 | buff.getRGB(col + 1, row + 1),// | |
169 | mode == Mode.DOUBLE_DITHERING// | |
170 | )); | |
171 | } | |
f04d8b1c NR |
172 | } |
173 | } | |
174 | ||
175 | text = builder.toString(); | |
176 | } | |
177 | ||
178 | return text; | |
179 | } | |
180 | ||
181 | @Override | |
182 | public String toString() { | |
183 | return getText(); | |
184 | } | |
185 | ||
186 | static private TerminalSize getSize(Image img) { | |
187 | TerminalSize size = null; | |
188 | while (size == null) { | |
189 | int w = img.getWidth(null); | |
190 | int h = img.getHeight(null); | |
191 | if (w > -1 && h > -1) { | |
192 | size = new TerminalSize(w, h); | |
193 | } else { | |
194 | try { | |
195 | Thread.sleep(100); | |
196 | } catch (InterruptedException e) { | |
197 | } | |
198 | } | |
199 | } | |
200 | ||
201 | return size; | |
202 | } | |
203 | ||
25232463 NR |
204 | private float[] tmp = new float[4]; |
205 | ||
206 | private char getAsciiChar(int pixel) { | |
207 | float brigthness = getBrightness(pixel, tmp); | |
208 | if (brigthness < 0.20) { | |
209 | return ' '; | |
210 | } else if (brigthness < 0.40) { | |
211 | return '.'; | |
212 | } else if (brigthness < 0.60) { | |
213 | return '+'; | |
214 | } else if (brigthness < 0.80) { | |
215 | return '*'; | |
216 | } else { | |
217 | return '#'; | |
218 | } | |
219 | } | |
220 | ||
221 | private char getDitheringChar(int pixel) { | |
222 | float brigthness = getBrightness(pixel, tmp); | |
223 | if (brigthness < 0.20) { | |
224 | return ' '; | |
225 | } else if (brigthness < 0.40) { | |
226 | return '░'; | |
227 | } else if (brigthness < 0.60) { | |
228 | return '▒'; | |
229 | } else if (brigthness < 0.80) { | |
230 | return '▓'; | |
231 | } else { | |
232 | return '█'; | |
233 | } | |
234 | } | |
235 | ||
236 | private char getBlockChar(int upperleft, int upperright, int lowerleft, | |
237 | int lowerright, boolean dithering) { | |
238 | float trigger = dithering ? 0.20f : 0.50f; | |
f04d8b1c | 239 | int choice = 0; |
25232463 | 240 | if (getBrightness(upperleft, tmp) > trigger) |
f04d8b1c | 241 | choice += 1; |
25232463 | 242 | if (getBrightness(upperright, tmp) > trigger) |
f04d8b1c | 243 | choice += 2; |
25232463 | 244 | if (getBrightness(lowerleft, tmp) > trigger) |
f04d8b1c | 245 | choice += 4; |
25232463 | 246 | if (getBrightness(lowerright, tmp) > trigger) |
f04d8b1c NR |
247 | choice += 8; |
248 | ||
249 | switch (choice) { | |
250 | case 0: | |
251 | return ' '; | |
252 | case 1: | |
253 | return '▘'; | |
254 | case 2: | |
255 | return '▝'; | |
256 | case 3: | |
257 | return '▀'; | |
258 | case 4: | |
259 | return '▖'; | |
260 | case 5: | |
261 | return '▌'; | |
262 | case 6: | |
263 | return '▞'; | |
264 | case 7: | |
265 | return '▛'; | |
266 | case 8: | |
267 | return '▗'; | |
268 | case 9: | |
269 | return '▚'; | |
270 | case 10: | |
271 | return '▐'; | |
272 | case 11: | |
273 | return '▜'; | |
274 | case 12: | |
275 | return '▄'; | |
276 | case 13: | |
277 | return '▙'; | |
278 | case 14: | |
279 | return '▟'; | |
280 | case 15: | |
25232463 NR |
281 | if (dithering) { |
282 | float avg = 0; | |
283 | avg += getBrightness(upperleft, tmp); | |
284 | avg += getBrightness(upperright, tmp); | |
285 | avg += getBrightness(lowerleft, tmp); | |
286 | avg += getBrightness(lowerright, tmp); | |
287 | avg /= 4; | |
288 | ||
289 | if (avg < 0.20) { | |
290 | return ' '; | |
291 | } else if (avg < 0.40) { | |
292 | return '░'; | |
293 | } else if (avg < 0.60) { | |
294 | return '▒'; | |
295 | } else if (avg < 0.80) { | |
296 | return '▓'; | |
297 | } else { | |
298 | return '█'; | |
299 | } | |
300 | } else { | |
301 | return '█'; | |
302 | } | |
f04d8b1c NR |
303 | } |
304 | ||
305 | return ' '; | |
306 | } | |
307 | ||
25232463 NR |
308 | float getBrightness(int argb, float[] array) { |
309 | if (invert) | |
310 | return 1 - rgb2hsb(argb, tmp)[2]; | |
311 | return rgb2hsb(argb, tmp)[2]; | |
312 | } | |
f04d8b1c | 313 | |
25232463 NR |
314 | // return [h, s, l, a]; h/s/b/a: 0 to 1 (h is given in 1/360th) |
315 | // like RGBtoHSB, array can be null or used | |
316 | static float[] rgb2hsb(int argb, float[] array) { | |
317 | int a, r, g, b; | |
318 | a = ((argb & 0xff000000) >> 24); | |
319 | r = ((argb & 0x00ff0000) >> 16); | |
320 | g = ((argb & 0x0000ff00) >> 8); | |
321 | b = ((argb & 0x000000ff)); | |
f04d8b1c | 322 | |
25232463 NR |
323 | if (array == null) |
324 | array = new float[4]; | |
325 | Color.RGBtoHSB(r, g, b, array); | |
f04d8b1c | 326 | |
25232463 | 327 | array[3] = a; |
f04d8b1c | 328 | |
25232463 | 329 | return array; |
f04d8b1c | 330 | |
25232463 NR |
331 | // // other implementation: |
332 | // | |
333 | // float a, r, g, b; | |
334 | // a = ((argb & 0xff000000) >> 24) / 255.0f; | |
335 | // r = ((argb & 0x00ff0000) >> 16) / 255.0f; | |
336 | // g = ((argb & 0x0000ff00) >> 8) / 255.0f; | |
337 | // b = ((argb & 0x000000ff)) / 255.0f; | |
338 | // | |
339 | // float rgbMin, rgbMax; | |
340 | // rgbMin = Math.min(r, Math.min(g, b)); | |
341 | // rgbMax = Math.max(r, Math.max(g, b)); | |
342 | // | |
343 | // float l; | |
344 | // l = (rgbMin + rgbMax) / 2; | |
345 | // | |
346 | // float s; | |
347 | // if (rgbMin == rgbMax) { | |
348 | // s = 0; | |
349 | // } else { | |
350 | // if (l <= 0.5) { | |
351 | // s = (rgbMax - rgbMin) / (rgbMax + rgbMin); | |
352 | // } else { | |
353 | // s = (rgbMax - rgbMin) / (2.0f - rgbMax - rgbMin); | |
354 | // } | |
355 | // } | |
356 | // | |
357 | // float h; | |
358 | // if (r > g && r > b) { | |
359 | // h = (g - b) / (rgbMax - rgbMin); | |
360 | // } else if (g > b) { | |
361 | // h = 2.0f + (b - r) / (rgbMax - rgbMin); | |
362 | // } else { | |
363 | // h = 4.0f + (r - g) / (rgbMax - rgbMin); | |
364 | // } | |
365 | // h /= 6; // from 0 to 1 | |
366 | // | |
367 | // return new float[] { h, s, l, a }; | |
368 | // | |
369 | // // // natural mode: | |
370 | // // | |
371 | // // int aa = (int) Math.round(100 * a); | |
372 | // // int hh = (int) (360 * h); | |
373 | // // if (hh < 0) | |
374 | // // hh += 360; | |
375 | // // int ss = (int) Math.round(100 * s); | |
376 | // // int ll = (int) Math.round(100 * l); | |
377 | // // | |
378 | // // return new int[] { hh, ss, ll, aa }; | |
f04d8b1c NR |
379 | } |
380 | } |