FazBrowse GitHub Viewer
|
Trending
|
URL:
|
Home
Tools:
[Download Repo ZIP]
[View Raw Code]
[Original HTTPS Page]
TheAlgorithms-Java/Conversions/RgbHsvConversion.java at master · windNight/TheAlgorithms-Java · GitHub
windNight
/
TheAlgorithms-Java
Public
forked from
TheAlgorithms/Java
Notifications
You must be signed in to change notification settings
Fork
1
Star
0
Code
Pull requests
0
Actions
Projects
Security and quality
0
Insights
Additional navigation options
Code
Pull requests
Actions
Projects
Security and quality
Insights
Expand file tree
Breadcrumbs
TheAlgorithms-Java
/
Conversions
/
RgbHsvConversion.java
Copy path
More file actions
More file actions
Latest commit
History
History
History
165 lines (142 loc) · 6.63 KB
Breadcrumbs
TheAlgorithms-Java
/
Conversions
/
RgbHsvConversion.java
Copy path
File metadata and controls
165 lines (142 loc) · 6.63 KB
Raw
Copy raw file
Download raw file
Open symbols panel
Edit and raw actions
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
package
Conversions
;
import
java
.
util
.
Arrays
;
/**
* The RGB color model is an additive color model in which red, green, and blue light are added
* together in various ways to reproduce a broad array of colors. The name of the model comes from
* the initials of the three additive primary colors, red, green, and blue. Meanwhile, the HSV
* representation models how colors appear under light. In it, colors are represented using three
* components: hue, saturation and (brightness-)value. This class provides methods for converting
* colors from one representation to the other. (description adapted from
* https://en.wikipedia.org/wiki/RGB_color_model and https://en.wikipedia.org/wiki/HSL_and_HSV).
*/
public
class
RgbHsvConversion
{
public
static
void
main
(
String
[]
args
) {
// Expected RGB-values taken from https://www.rapidtables.com/convert/color/hsv-to-rgb.html
// Test hsvToRgb-method
assert
Arrays
.
equals
(
hsvToRgb
(
0
,
0
,
0
),
new
int
[] {
0
,
0
,
0
});
assert
Arrays
.
equals
(
hsvToRgb
(
0
,
0
,
1
),
new
int
[] {
255
,
255
,
255
});
assert
Arrays
.
equals
(
hsvToRgb
(
0
,
1
,
1
),
new
int
[] {
255
,
0
,
0
});
assert
Arrays
.
equals
(
hsvToRgb
(
60
,
1
,
1
),
new
int
[] {
255
,
255
,
0
});
assert
Arrays
.
equals
(
hsvToRgb
(
120
,
1
,
1
),
new
int
[] {
0
,
255
,
0
});
assert
Arrays
.
equals
(
hsvToRgb
(
240
,
1
,
1
),
new
int
[] {
0
,
0
,
255
});
assert
Arrays
.
equals
(
hsvToRgb
(
300
,
1
,
1
),
new
int
[] {
255
,
0
,
255
});
assert
Arrays
.
equals
(
hsvToRgb
(
180
,
0.5
,
0.5
),
new
int
[] {
64
,
128
,
128
});
assert
Arrays
.
equals
(
hsvToRgb
(
234
,
0.14
,
0.88
),
new
int
[] {
193
,
196
,
224
});
assert
Arrays
.
equals
(
hsvToRgb
(
330
,
0.75
,
0.5
),
new
int
[] {
128
,
32
,
80
});
// Test rgbToHsv-method
// approximate-assertions needed because of small deviations due to converting between
// int-values and double-values.
assert
approximatelyEqualHsv
(
rgbToHsv
(
0
,
0
,
0
),
new
double
[] {
0
,
0
,
0
});
assert
approximatelyEqualHsv
(
rgbToHsv
(
255
,
255
,
255
),
new
double
[] {
0
,
0
,
1
});
assert
approximatelyEqualHsv
(
rgbToHsv
(
255
,
0
,
0
),
new
double
[] {
0
,
1
,
1
});
assert
approximatelyEqualHsv
(
rgbToHsv
(
255
,
255
,
0
),
new
double
[] {
60
,
1
,
1
});
assert
approximatelyEqualHsv
(
rgbToHsv
(
0
,
255
,
0
),
new
double
[] {
120
,
1
,
1
});
assert
approximatelyEqualHsv
(
rgbToHsv
(
0
,
0
,
255
),
new
double
[] {
240
,
1
,
1
});
assert
approximatelyEqualHsv
(
rgbToHsv
(
255
,
0
,
255
),
new
double
[] {
300
,
1
,
1
});
assert
approximatelyEqualHsv
(
rgbToHsv
(
64
,
128
,
128
),
new
double
[] {
180
,
0.5
,
0.5
});
assert
approximatelyEqualHsv
(
rgbToHsv
(
193
,
196
,
224
),
new
double
[] {
234
,
0.14
,
0.88
});
assert
approximatelyEqualHsv
(
rgbToHsv
(
128
,
32
,
80
),
new
double
[] {
330
,
0.75
,
0.5
});
}
/**
* Conversion from the HSV-representation to the RGB-representation.
*
* @param hue Hue of the color.
* @param saturation Saturation of the color.
* @param value Brightness-value of the color.
* @return The tuple of RGB-components.
*/
public
static
int
[]
hsvToRgb
(
double
hue
,
double
saturation
,
double
value
) {
if
(
hue
<
0
||
hue
>
360
) {
throw
new
IllegalArgumentException
(
"hue should be between 0 and 360"
);
}
if
(
saturation
<
0
||
saturation
>
1
) {
throw
new
IllegalArgumentException
(
"saturation should be between 0 and 1"
);
}
if
(
value
<
0
||
value
>
1
) {
throw
new
IllegalArgumentException
(
"value should be between 0 and 1"
);
}
double
chroma
=
value
*
saturation
;
double
hueSection
=
hue
/
60
;
double
secondLargestComponent
=
chroma
* (
1
-
Math
.
abs
(
hueSection
%
2
-
1
));
double
matchValue
=
value
-
chroma
;
return
getRgbBySection
(
hueSection
,
chroma
,
matchValue
,
secondLargestComponent
);
}
/**
* Conversion from the RGB-representation to the HSV-representation.
*
* @param red Red-component of the color.
* @param green Green-component of the color.
* @param blue Blue-component of the color.
* @return The tuple of HSV-components.
*/
public
static
double
[]
rgbToHsv
(
int
red
,
int
green
,
int
blue
) {
if
(
red
<
0
||
red
>
255
) {
throw
new
IllegalArgumentException
(
"red should be between 0 and 255"
);
}
if
(
green
<
0
||
green
>
255
) {
throw
new
IllegalArgumentException
(
"green should be between 0 and 255"
);
}
if
(
blue
<
0
||
blue
>
255
) {
throw
new
IllegalArgumentException
(
"blue should be between 0 and 255"
);
}
double
dRed
= (
double
)
red
/
255
;
double
dGreen
= (
double
)
green
/
255
;
double
dBlue
= (
double
)
blue
/
255
;
double
value
=
Math
.
max
(
Math
.
max
(
dRed
,
dGreen
),
dBlue
);
double
chroma
=
value
-
Math
.
min
(
Math
.
min
(
dRed
,
dGreen
),
dBlue
);
double
saturation
=
value
==
0
?
0
:
chroma
/
value
;
double
hue
;
if
(
chroma
==
0
) {
hue
=
0
;
}
else
if
(
value
==
dRed
) {
hue
=
60
* (
0
+ (
dGreen
-
dBlue
) /
chroma
);
}
else
if
(
value
==
dGreen
) {
hue
=
60
* (
2
+ (
dBlue
-
dRed
) /
chroma
);
}
else
{
hue
=
60
* (
4
+ (
dRed
-
dGreen
) /
chroma
);
}
hue
= (
hue
+
360
) %
360
;
return
new
double
[] {
hue
,
saturation
,
value
};
}
private
static
boolean
approximatelyEqualHsv
(
double
[]
hsv1
,
double
[]
hsv2
) {
boolean
bHue
=
Math
.
abs
(
hsv1
[
0
] -
hsv2
[
0
]) <
0.2
;
boolean
bSaturation
=
Math
.
abs
(
hsv1
[
1
] -
hsv2
[
1
]) <
0.002
;
boolean
bValue
=
Math
.
abs
(
hsv1
[
2
] -
hsv2
[
2
]) <
0.002
;
return
bHue
&&
bSaturation
&&
bValue
;
}
private
static
int
[]
getRgbBySection
(
double
hueSection
,
double
chroma
,
double
matchValue
,
double
secondLargestComponent
) {
int
red
;
int
green
;
int
blue
;
if
(
hueSection
>=
0
&&
hueSection
<=
1
) {
red
=
convertToInt
(
chroma
+
matchValue
);
green
=
convertToInt
(
secondLargestComponent
+
matchValue
);
blue
=
convertToInt
(
matchValue
);
}
else
if
(
hueSection
>
1
&&
hueSection
<=
2
) {
red
=
convertToInt
(
secondLargestComponent
+
matchValue
);
green
=
convertToInt
(
chroma
+
matchValue
);
blue
=
convertToInt
(
matchValue
);
}
else
if
(
hueSection
>
2
&&
hueSection
<=
3
) {
red
=
convertToInt
(
matchValue
);
green
=
convertToInt
(
chroma
+
matchValue
);
blue
=
convertToInt
(
secondLargestComponent
+
matchValue
);
}
else
if
(
hueSection
>
3
&&
hueSection
<=
4
) {
red
=
convertToInt
(
matchValue
);
green
=
convertToInt
(
secondLargestComponent
+
matchValue
);
blue
=
convertToInt
(
chroma
+
matchValue
);
}
else
if
(
hueSection
>
4
&&
hueSection
<=
5
) {
red
=
convertToInt
(
secondLargestComponent
+
matchValue
);
green
=
convertToInt
(
matchValue
);
blue
=
convertToInt
(
chroma
+
matchValue
);
}
else
{
red
=
convertToInt
(
chroma
+
matchValue
);
green
=
convertToInt
(
matchValue
);
blue
=
convertToInt
(
secondLargestComponent
+
matchValue
);
}
return
new
int
[] {
red
,
green
,
blue
};
}
private
static
int
convertToInt
(
double
input
) {
return
(
int
)
Math
.
round
(
255
*
input
);
}
}
Back
|
FazBrowse Home
|
New Git URL