Skip to content

Commit 5b53138

Browse files
TomSawTomSaw
committed
Update color_test
1 parent da75597 commit 5b53138

File tree

8 files changed

+163
-98
lines changed

8 files changed

+163
-98
lines changed

‎src/modm/ui/color/gray.hpp

Lines changed: 42 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -45,17 +45,47 @@ class GrayD : public modm::UnsignedScaling<D>
4545
// OPTIMIZE Calc with fixed point instead float
4646
0.2125 * float(GrayD(rgb.getRed()).value) +
4747
0.7154 * float(GrayD(rgb.getGreen()).value) +
48-
0.0721 * float(GrayD(rgb.getblue()).value)
48+
0.0721 * float(GrayD(rgb.getBlue()).value)
4949
)
5050
{}
5151

5252
template<ColorHsv C>
5353
constexpr GrayD(const C& hsv) : UnsignedScaling<D>(hsv.getValue())
5454
{}
5555

56+
GrayD& operator+=(const ValueType& value) {
57+
modm::Saturated<ValueType&> result(this->value);
58+
result+=value;
59+
this->max_cutoff();
60+
61+
return *this;
62+
}
63+
64+
GrayD& operator+=(const GrayD& other) {
65+
modm::Saturated<ValueType&> result(this->value);
66+
result+=other.value;
67+
this->max_cutoff();
68+
69+
return *this;
70+
}
71+
72+
GrayD& operator-=(const ValueType& value) {
73+
modm::Saturated<ValueType&> result(this->value);
74+
result-=value;
75+
this->max_cutoff();
76+
77+
return *this;
78+
}
79+
80+
GrayD& operator-=(const GrayD& other) {
81+
modm::Saturated<ValueType&> result(this->value);
82+
result-=other.value;
83+
this->max_cutoff();
84+
85+
return *this;
86+
}
87+
5688
// IMPLEMENT
57-
// operator+=() {}
58-
// operator-=() {}
5989
// operator*=() {}
6090

6191
template<std::integral U>
@@ -64,15 +94,15 @@ class GrayD : public modm::UnsignedScaling<D>
6494
result+=value;
6595

6696
// When all digits of ValueType are used, std::min should optimize away
67-
return {std::min(result.getValue(), UnsignedScaling<D>::max)};
97+
return {std::min(result.getValue(), this->max)};
6898
}
6999

70-
GrayD operator+(const GrayD<D>& other) const {
100+
GrayD operator+(const GrayD& other) const {
71101
modm::Saturated<ValueType> result(this->value);
72102
result+=other.value;
73103

74104
// When all digits of ValueType are used, std::min should optimize away
75-
return {std::min(result.getValue(), UnsignedScaling<D>::max)};
105+
return {std::min(result.getValue(), this->max)};
76106
}
77107

78108
template<std::integral U>
@@ -81,10 +111,10 @@ class GrayD : public modm::UnsignedScaling<D>
81111
result-=value;
82112

83113
// When all digits of ValueType are used, std::min should optimize away
84-
return {std::min(result.getValue(), UnsignedScaling<D>::max)};
114+
return {std::min(result.getValue(), this->max)};
85115
}
86116

87-
GrayD operator-(const GrayD<D>& other) const {
117+
GrayD operator-(const GrayD& other) const {
88118
modm::Saturated<ValueType> result(this->value);
89119
result -= other.value;
90120

@@ -97,7 +127,7 @@ class GrayD : public modm::UnsignedScaling<D>
97127
result *= scale;
98128

99129
// When all digits of ValueType are used, std::min should optimize away
100-
return {std::min(result.getValue(), UnsignedScaling<D>::max)};
130+
return {std::min(result.getValue(), this->max)};
101131
}
102132

103133
template<std::floating_point ScaleType>
@@ -112,6 +142,9 @@ class GrayD : public modm::UnsignedScaling<D>
112142

113143
private:
114144

145+
template<int>
146+
friend class GrayD;
147+
115148
template <int V>
116149
friend modm::IOStream &
117150
operator<<(modm::IOStream &, const GrayD<V> &);

‎src/modm/ui/color/hsv.hpp

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,8 @@
1717
#include "concepts.hpp"
1818
#include "gray.hpp"
1919

20+
#include <modm/math/utils/arithmetic_traits.hpp>
21+
2022
namespace modm::color
2123
{
2224
/**
@@ -71,6 +73,19 @@ class HsvD
7173
constexpr bool
7274
operator==(const HsvD& other) const = default;
7375

76+
// Output in a human readable format
77+
// Hue in deg, Sat in pct, Value in pct
78+
void iostream_human_readable(IOStream& io) {
79+
using CalcTypeHue = modm::WideType<typename HueType::ValueType>;
80+
io << (CalcTypeHue(hue.getValue()) * 360 / hue.max) << "deg\t";
81+
82+
using CalcTypeSaturation = modm::WideType<typename SaturationType::ValueType>;
83+
io << (CalcTypeSaturation(saturation.getValue()) * 100 / saturation.max) << "%\t";
84+
85+
using CalcTypeValue = modm::WideType<typename ValueType::ValueType>;
86+
io << (CalcTypeValue(value.getValue()) * 100 / value.max) << "%";
87+
}
88+
7489
private:
7590
HueType hue{0}; // TODO Hue may not saturate but wrap for arithmetic operations
7691
SaturationType saturation{0};

‎src/modm/ui/color/unsigned_scaling.hpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -105,6 +105,7 @@ class UnsignedScaling {
105105
protected:
106106
ValueType value = 0;
107107

108+
inline void max_cutoff() { value = std::min(value, max); }
108109
private:
109110
template<int>
110111
friend class UnsignedScaling;

‎src/modm/ui/graphic/buffer_gray.hpp

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -221,6 +221,15 @@ class Buffer<G, R>
221221
friend class Buffer;
222222
};
223223

224+
template<Resolution R>
225+
using BufferMonochrome = Buffer<Monochrome, R>;
226+
227+
template<Resolution R>
228+
using BufferGray2222 = Buffer<Gray2, R>;
229+
230+
template<Resolution R>
231+
using BufferGray44 = Buffer<Gray4, R>;
232+
224233
} // namespace modm
225234

226235
#include "buffer_gray_impl.hpp"

‎src/modm/ui/graphic/buffer_gray_impl.hpp

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -26,14 +26,14 @@ Buffer<G, R>::writeImage(Decoder<C, Accessor> decoder, Point origin)
2626
{
2727
const Section clipping = this->getIntersection(Rectangle(origin, decoder.size));
2828

29-
// IMPLEMENT
29+
// IMPLEMENT write other color Buffer to GrayBuffer
3030
(void)clipping;
3131
}
3232

3333
template<ColorGrayBase2 G, Resolution R>
3434
template<template<typename> class Accessor>
3535
void
36-
// FIXME GreyT<W> not yet supported
36+
// FIXME GrayT<W> not yet supported
3737
Buffer<G, R>::writeImage(Decoder<G, Accessor> decoder, Point origin)
3838
{
3939
const Section clipping = this->getIntersection(Rectangle(origin, decoder.size));
@@ -134,8 +134,7 @@ void
134134
Buffer<G, R>::clear(G color)
135135
{
136136
// OPTIMIZE Make this impossible fast by using DMA
137-
// TODO Better expression for color.value ? 0xFF : 0x00
138-
std::fill(buffer[0], buffer[0] + R.x * HB, color.getValue() ? 0xFF : 0x00);
137+
std::fill(buffer[0], buffer[0] + R.x * HB, Gray8(color).getValue());
139138
this->cursor = {0, 0};
140139
}
141140

‎src/modm/ui/graphic/canvas.hpp

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -13,17 +13,20 @@
1313

1414
#include <modm/ui/shape/point.hpp>
1515
#include <modm/ui/shape/section.hpp>
16+
#include <modm/ui/color/concepts.hpp>
1617

1718
using namespace modm::shape;
1819

1920
namespace modm::graphic
2021
{
2122

22-
// @brief Concept for function or functor, that takes a Point and returns a Color
23+
/**
24+
* @brief Function or functor comcept, returning a Color for each Point you pass
25+
*/
2326
template <typename F>
2427
concept ColorPattern = requires(F p)
2528
{
26-
{ p.operator()(modm::shape::Point()) } -> Color; // -> std::convertible_to<modm::color::Rgb888>;
29+
{ p.operator()(modm::shape::Point()) } -> modm::color::Color; // -> std::convertible_to<modm::color::Rgb888>;
2730
};
2831

2932
using Resolution = Point;

‎test/modm/ui/color/color_test.cpp

Lines changed: 80 additions & 71 deletions
Original file line numberDiff line numberDiff line change
@@ -15,101 +15,110 @@
1515
#include <modm/debug/logger.hpp>
1616
#include <algorithm>
1717

18+
using namespace modm;
1819
using namespace modm::color;
1920

20-
void ColorTest::testRgbCopyConstructors() {
21-
RgbT<uint8_t> rgb8(html::Orchid);
22-
RgbT<uint8_t> rgb8_b(rgb8);
21+
void ColorTest::testGrayConstructors() {
22+
Gray8 gray8(127);
23+
Gray8 gray8_b(gray8);
24+
TEST_ASSERT_EQUALS(gray8, gray8_b);
25+
26+
Gray4 gray4(7);
27+
gray4 += 3;
28+
TEST_ASSERT_EQUALS(gray4.getValue(), 10);
29+
gray4 -= 1;
30+
TEST_ASSERT_EQUALS(gray4.getValue(), 9);
31+
gray4 -= 42; // under-saturation
32+
TEST_ASSERT_EQUALS(gray4.getValue(), 0);
33+
gray4 += 66; // over-saturation
34+
TEST_ASSERT_EQUALS(gray4.getValue(), 0b00001111);
35+
gray4 -= 3;
36+
TEST_ASSERT_EQUALS(gray4.getValue(), 0b00001100);
37+
38+
// not supported
39+
// gray4 -= -6; // another over-saturation
40+
// TEST_ASSERT_EQUALS(gray4.getValue(), 0b00001111);
41+
42+
43+
gray8 = gray4; // upscaling
44+
TEST_ASSERT_EQUALS(gray8.getValue(), 0b11001100);
45+
GrayD<13> gray13 = gray4; // more upscaling
46+
TEST_ASSERT_EQUALS(gray13.getValue(), 0b0001100110011000); // last digit rounds down for odd D
47+
gray4 = gray13; // downscaling
48+
TEST_ASSERT_EQUALS(gray4.getValue(), 0b00001100);
49+
}
50+
51+
void ColorTest::testRgbConstructors() {
52+
Rgb888 rgb8(html::Orchid);
53+
Rgb888 rgb8_b(rgb8);
2354
TEST_ASSERT_EQUALS(rgb8, rgb8_b);
2455

25-
RgbT<uint16_t> rgb16(rgb8);
26-
TEST_ASSERT_EQUALS(uint16_t(rgb8.red) << 8, rgb16.red);
27-
TEST_ASSERT_EQUALS(uint16_t(rgb8.green) << 8, rgb16.green);
28-
TEST_ASSERT_EQUALS(uint16_t(rgb8.blue) << 8, rgb16.blue);
56+
Rgb161616 rgb16(rgb8);
2957

30-
RgbT<uint8_t> rgb8_c(rgb16);
58+
Rgb888 rgb8_c(rgb16);
3159
TEST_ASSERT_EQUALS(rgb8, rgb8_c);
3260
}
3361

34-
void ColorTest::testHsvCopyConstructors() {
35-
HsvT<uint8_t> hsv8(html::Orchid);
36-
HsvT<uint8_t> hsv8_b(hsv8);
62+
void ColorTest::testHsvConstructors() {
63+
Hsv888 hsv8(html::Orchid);
64+
Hsv888 hsv8_b(hsv8);
3765
TEST_ASSERT_EQUALS(hsv8, hsv8_b);
3866

39-
HsvT<uint16_t> hsv16(hsv8);
40-
TEST_ASSERT_EQUALS(uint16_t(hsv8.hue) << 8, hsv16.hue);
41-
TEST_ASSERT_EQUALS(uint16_t(hsv8.saturation) << 8, hsv16.saturation);
42-
TEST_ASSERT_EQUALS(uint16_t(hsv8.value) << 8, hsv16.value);
67+
Hsv161616 hsv16(hsv8);
4368

44-
HsvT<uint8_t> hsv8_c(hsv16);
69+
Hsv888 hsv8_c(hsv16);
4570
TEST_ASSERT_EQUALS(hsv8, hsv8_c);
4671
}
4772

48-
void ColorTest::testBrightnessCopyConstructors() {
49-
BrightnessT<uint8_t> brightness8(127);
50-
BrightnessT<uint8_t> brightness8_b(brightness8);
51-
TEST_ASSERT_EQUALS(brightness8.value, brightness8_b.value);
52-
53-
BrightnessT<uint16_t> brightness16(brightness8);
54-
TEST_ASSERT_EQUALS(uint16_t(brightness8.value) << 8, brightness16.value);
55-
56-
BrightnessT<uint8_t> brightness8_c(brightness16);
57-
TEST_ASSERT_EQUALS(brightness8.value, brightness8_c.value);
58-
}
59-
6073
void ColorTest::testConvertion_8bit()
6174
{
62-
RgbT<uint8_t> rgb(124, 128, 10);
75+
Rgb888 rgb(124, 128, 10);
6376

64-
HsvT<uint8_t> hsv(rgb);
65-
TEST_ASSERT_EQUALS(hsv.hue, 43);
66-
TEST_ASSERT_EQUALS(hsv.saturation, 235);
67-
TEST_ASSERT_EQUALS(hsv.value, 128);
77+
Hsv888 hsv(rgb);
78+
TEST_ASSERT_EQUALS(hsv.getHue(), 43);
79+
TEST_ASSERT_EQUALS(hsv.getSaturation(), 235);
80+
TEST_ASSERT_EQUALS(hsv.getValue(), 128);
6881

69-
BrightnessT<uint8_t> brightness(rgb);
70-
TEST_ASSERT_EQUALS(brightness.value, 118);
82+
Gray8 gray(rgb);
83+
TEST_ASSERT_EQUALS(gray.getValue(), 118);
7184
}
7285

73-
// TODO 16bit convertion not yet working
74-
// see hsv_impl.hpp and rgb_impl.hpp
75-
// void ColorTest::testConvertion_16bit()
76-
// {
77-
// RgbT<uint8_t> rgb8(html::Orchid);
78-
// HsvT<uint8_t> hsv8(rgb8);
79-
// HsvT<uint16_t> hsv16(hsv8);
8086

81-
// RgbT<uint16_t> rgb16(rgb8);
82-
// HsvT<uint16_t> hsv16_b(rgb16);
87+
void ColorTest::testConvertion_16bit()
88+
{
89+
Rgb888 rgb8(html::Orchid);
90+
Hsv888 hsv8(rgb8);
91+
Hsv161616 hsv16(hsv8);
8392

84-
// // Test, if rgb->hsv conversion produces the same result for 8 and 16bits
85-
// TEST_ASSERT_EQUALS(hsv16, hsv16_b);
86-
// }
93+
Rgb161616 rgb16(rgb8);
94+
Hsv161616 hsv16_b(rgb16);
95+
96+
// Test, if rgb->hsv conversion produces the same result for 8 and 16bits
97+
// FIXME test fails
98+
// TEST_ASSERT_EQUALS(hsv16, hsv16_b);
99+
}
87100

88101
void ColorTest::testRgbHsvPingPongConvertion_8bit()
89102
{
90-
RgbT<uint8_t> rgb8(html::Orchid);
91-
HsvT<uint8_t> hsv8(rgb8);
92-
RgbT<uint8_t> rgb8_b(hsv8);
93-
94-
// Can't prevent some conversion-loss. Tolerate it or use more digits for your target type
95-
using namespace modm;
96-
TEST_ASSERT_TRUE(modm::Tolerance::isValueInTolerance(rgb8.red, rgb8_b.red, 1_pct));
97-
TEST_ASSERT_TRUE(modm::Tolerance::isValueInTolerance(rgb8.green, rgb8_b.green, 1_pct));
98-
TEST_ASSERT_TRUE(modm::Tolerance::isValueInTolerance(rgb8.blue, rgb8_b.blue, 1_pct));
103+
Rgb888 rgb8(html::Orchid);
104+
Hsv888 hsv8(rgb8);
105+
Rgb888 rgb8_b(hsv8);
106+
107+
// Convertion may distort - allow some tolerance.
108+
TEST_ASSERT_TRUE(modm::Tolerance::isValueInTolerance(rgb8.getRed().getValue(), rgb8_b.getRed().getValue(), 1_pct));
109+
TEST_ASSERT_TRUE(modm::Tolerance::isValueInTolerance(rgb8.getGreen().getValue(), rgb8_b.getGreen().getValue(), 1_pct));
110+
TEST_ASSERT_TRUE(modm::Tolerance::isValueInTolerance(rgb8.getBlue().getValue(), rgb8_b.getBlue().getValue(), 1_pct));
99111
}
100112

101-
// TODO 16bit convertion not yet working
102-
// see hsv_impl.hpp and rgb_impl.hpp
103-
// void ColorTest::testRgbHsvPingPongConvertion_16bit()
104-
// {
105-
// // Rgb->Hsv->Rgb, both 16 bit
106-
// RgbT<uint16_t> rgb16(html::Orchid);
107-
// HsvT<uint16_t> hsv16(rgb16);
108-
// RgbT<T> rgb16_b(hsv16);
109-
110-
// // Convertion can distort - allow some tolerance.
111-
// using namespace modm;
112-
// TEST_ASSERT_TRUE(modm::Tolerance::isValueInTolerance(rgb.red, rgb16_b.red, 1_pct));
113-
// TEST_ASSERT_TRUE(modm::Tolerance::isValueInTolerance(rgb.green, rgb16_b.green, 1_pct));
114-
// TEST_ASSERT_TRUE(modm::Tolerance::isValueInTolerance(rgb.blue, rgb16_b.blue, 1_pct));
115-
// }
113+
void ColorTest::testRgbHsvPingPongConvertion_16bit()
114+
{
115+
// Rgb->Hsv->Rgb, both 16 bit
116+
Rgb161616 rgb16(html::Orchid);
117+
Hsv161616 hsv16(rgb16);
118+
Rgb161616 rgb16_b(hsv16);
119+
120+
// Convertion may distort - allow some tolerance.
121+
TEST_ASSERT_TRUE(modm::Tolerance::isValueInTolerance(rgb16.getRed().getValue(), rgb16_b.getRed().getValue(), 1_pct));
122+
TEST_ASSERT_TRUE(modm::Tolerance::isValueInTolerance(rgb16.getGreen().getValue(), rgb16_b.getGreen().getValue(), 1_pct));
123+
TEST_ASSERT_TRUE(modm::Tolerance::isValueInTolerance(rgb16.getBlue().getValue(), rgb16_b.getBlue().getValue(), 1_pct));
124+
}

0 commit comments

Comments
 (0)