1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
/* See LICENSE file for copyright and license details. */
#include "stream.h"
#include "util.h"
#include <fcntl.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
USAGE("luma-stream")
#define PROCESS(TYPE)\
do {\
size_t i;\
TYPE a, y;\
for (i = 0; i < n; i += colour->pixel_size) {\
a = ((TYPE *)(luma->buf + i))[1];\
a *= ((TYPE *)(luma->buf + i))[3];\
y = ((TYPE *)(colour->buf + i))[1];\
((TYPE *)(colour->buf + i))[0] += y * a - y;\
((TYPE *)(colour->buf + i))[1] = y * a;\
((TYPE *)(colour->buf + i))[2] += y * a - y;\
/*
* Note, this changes the luma only, not the saturation,
* so the result may look a bit weird. To change both
* you can use `blind-arithm mul`.
*
* Explaination of algorithm:
*
* Y is the luma, but (X, Z) is not the chroma,
* but in CIELAB, L* is the luma and (a*, *b) is
* the chroma. Multiplying
*
* ⎛0 1 0⎞
* ⎜1 −1 0⎟
* ⎝0 1 −1⎠
*
* (X Y Z)' gives a colour model similar to
* CIE L*a*b*: a model where each parameter is
* a linear transformation of the corresponding
* parameter in CIE L*a*b*. The inverse of that
* matrix is
*
* ⎛1 1 0⎞
* ⎜1 0 0⎟
* ⎝0 0 −1⎠
*
* and
*
* ⎛1 1 0⎞⎛a 0 0⎞⎛0 1 0⎞ ⎛1 a−1 0⎞
* ⎜1 0 0⎟⎜0 1 0⎟⎜1 −1 0⎟ = ⎜0 a 0⎟.
* ⎝0 0 −1⎠⎝0 0 1⎠⎝0 1 −1⎠ ⎝0 a−1 1⎠
*
* Explanation of why changing only the luma looks weird:
*
* Consider when you are workings with colours,
* when you want to change the brightness of a
* colour, you multiply all parameters: red, green,
* and blue, with the same value (this is however
* only an approximation in most cases, since you
* are usually usally working with colours that
* have the sRGB transfer function applied to their
* parameters). This action is the same in all
* colour models and colour spaces that are a
* linear transformation of the sRGB colour spaces
* (sans transfer function); this is simply because
* of the properties of linear transformations.
*
* The reason you change brightness this way can
* be explained by how objects reflect colour.
* Objects can only reject colours that are present
* in the light source. A ideal white object will look
* pure red if the light sources is ideal red, and a
* a ideal blue object will pure black in the same
* light source. An object can also not reflect
* colours brighter than the source. When the brightness
* of a light source is changed, the intensity of all
* colours (by wavelength) it emits is multiplied by
* one value. Therefore, when changing the brightness
* it looks most natural when all primaries (red, green,
* and blue) are multiplied by one value, or all
* parameters of the used colour spaces is a linear
* transformation of sRGB, such as CIE XYZ.
*/\
}\
} while (0)
static void process_xyza (struct stream *colour, struct stream *luma, size_t n) {PROCESS(double);}
static void process_xyzaf(struct stream *colour, struct stream *luma, size_t n) {PROCESS(float);}
int
main(int argc, char *argv[])
{
struct stream colour, luma;
void (*process)(struct stream *colour, struct stream *luma, size_t n);
UNOFLAGS(argc != 1);
eopen_stream(&colour, NULL);
eopen_stream(&luma, argv[0]);
if (!strcmp(colour.pixfmt, "xyza"))
process = process_xyza;
else if (!strcmp(colour.pixfmt, "xyza f"))
process = process_xyzaf;
else
eprintf("pixel format %s is not supported, try xyza\n", colour.pixfmt);
fprint_stream_head(stdout, &colour);
efflush(stdout, "<stdout>");
process_two_streams(&colour, &luma, STDOUT_FILENO, "<stdout>", process);
return 0;
}
|
