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
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
/* SPDX-License-Identifier: BSD-2-Clause */
/*
* Copyright (C) 2019, Raspberry Pi (Trading) Limited
*
* awb.hpp - AWB control algorithm
*/
#pragma once
#include <mutex>
#include <condition_variable>
#include <thread>
#include "../awb_algorithm.hpp"
#include "../pwl.hpp"
#include "../awb_status.h"
namespace RPiController {
// Control algorithm to perform AWB calculations.
struct AwbMode {
void Read(boost::property_tree::ptree const ¶ms);
double ct_lo; // low CT value for search
double ct_hi; // high CT value for search
};
struct AwbPrior {
void Read(boost::property_tree::ptree const ¶ms);
double lux; // lux level
Pwl prior; // maps CT to prior log likelihood for this lux level
};
struct AwbConfig {
AwbConfig() : default_mode(nullptr) {}
void Read(boost::property_tree::ptree const ¶ms);
// Only repeat the AWB calculation every "this many" frames
uint16_t frame_period;
// number of initial frames for which speed taken as 1.0 (maximum)
uint16_t startup_frames;
unsigned int convergence_frames; // approx number of frames to converge
double speed; // IIR filter speed applied to algorithm results
bool fast; // "fast" mode uses a 16x16 rather than 32x32 grid
Pwl ct_r; // function maps CT to r (= R/G)
Pwl ct_b; // function maps CT to b (= B/G)
// table of illuminant priors at different lux levels
std::vector<AwbPrior> priors;
// AWB "modes" (determines the search range)
std::map<std::string, AwbMode> modes;
AwbMode *default_mode; // mode used if no mode selected
// minimum proportion of pixels counted within AWB region for it to be
// "useful"
double min_pixels;
// minimum G value of those pixels, to be regarded a "useful"
uint16_t min_G;
// number of AWB regions that must be "useful" in order to do the AWB
// calculation
uint32_t min_regions;
// clamp on colour error term (so as not to penalise non-grey excessively)
double delta_limit;
// step size control in coarse search
double coarse_step;
// how far to wander off CT curve towards "more purple"
double transverse_pos;
// how far to wander off CT curve towards "more green"
double transverse_neg;
// red sensitivity ratio (set to canonical sensor's R/G divided by this
// sensor's R/G)
double sensitivity_r;
// blue sensitivity ratio (set to canonical sensor's B/G divided by this
// sensor's B/G)
double sensitivity_b;
// The whitepoint (which we normally "aim" for) can be moved.
double whitepoint_r;
double whitepoint_b;
bool bayes; // use Bayesian algorithm
};
class Awb : public AwbAlgorithm
{
public:
Awb(Controller *controller = NULL);
~Awb();
char const *Name() const override;
void Initialise() override;
void Read(boost::property_tree::ptree const ¶ms) override;
unsigned int GetConvergenceFrames() const override;
void SetMode(std::string const &name) override;
void SetManualGains(double manual_r, double manual_b) override;
void SwitchMode(CameraMode const &camera_mode, Metadata *metadata) override;
void Prepare(Metadata *image_metadata) override;
void Process(StatisticsPtr &stats, Metadata *image_metadata) override;
struct RGB {
RGB(double _R = INVALID, double _G = INVALID,
double _B = INVALID)
: R(_R), G(_G), B(_B)
{
}
double R, G, B;
static const double INVALID;
|
