blob: 410f6f447077ba54fcb124f8fe69d7986f056bbf (
plain)
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
|
/* SPDX-License-Identifier: BSD-2-Clause */
/*
* Copyright (C) 2019, Raspberry Pi Ltd
*
* lux.cpp - Lux control algorithm
*/
#include <math.h>
#include <linux/bcm2835-isp.h>
#include <libcamera/base/log.h>
#include "../device_status.h"
#include "lux.h"
using namespace RPiController;
using namespace libcamera;
using namespace std::literals::chrono_literals;
LOG_DEFINE_CATEGORY(RPiLux)
#define NAME "rpi.lux"
Lux::Lux(Controller *controller)
: Algorithm(controller)
{
/*
* Put in some defaults as there will be no meaningful values until
* Process has run.
*/
status_.aperture = 1.0;
status_.lux = 400;
}
char const *Lux::name() const
{
return NAME;
}
int Lux::read(const libcamera::YamlObject ¶ms)
{
auto value = params["reference_shutter_speed"].get<double>();
if (!value)
return -EINVAL;
referenceShutterSpeed_ = *value * 1.0us;
value = params["reference_gain"].get<double>();
if (!value)
return -EINVAL;
referenceGain_ = *value;
referenceAperture_ = params["reference_aperture"].get<double>(1.0);
value = params["reference_Y"].get<double>();
if (!value)
return -EINVAL;
referenceY_ = *value;
value = params["reference_lux"].get<double>();
if (!value)
return -EINVAL;
referenceLux_ = *value;
currentAperture_ = referenceAperture_;
return 0;
}
void Lux::setCurrentAperture(double aperture)
{
currentAperture_ = aperture;
}
void Lux::prepare(Metadata *imageMetadata)
{
std::unique_lock<std::mutex> lock(mutex_);
imageMetadata->set("lux.status", status_);
}
void Lux::process(StatisticsPtr &stats, Metadata *imageMetadata)
{
DeviceStatus deviceStatus;
if (imageMetadata->get("device.status", deviceStatus) == 0) {
double currentGain = deviceStatus.analogueGain;
double currentAperture = deviceStatus.aperture.value_or(currentAperture_);
uint64_t sum = 0;
uint32_t num = 0;
uint32_t *bin = stats->hist[0].g_hist;
const int numBins = sizeof(stats->hist[0].g_hist) /
sizeof(stats->hist[0].g_hist[0]);
for (int i = 0; i < numBins; i++)
sum += bin[i] * (uint64_t)i, num += bin[i];
/* add .5 to reflect the mid-points of bins */
double currentY = sum / (double)num + .5;
double gainRatio = referenceGain_ / currentGain;
double shutterSpeedRatio =
std::chrono::duration(referenceShutterSpeed_) /
std::chrono::duration(deviceStatus.shutterSpeed);
double apertureRatio = referenceAperture_ / currentAperture;
double yRatio = currentY * (65536 / numBins) / referenceY_;
double estimatedLux = shutterSpeedRatio * gainRatio *
apertureRatio * apertureRatio *
yRatio * referenceLux_;
LuxStatus status;
status.lux = estimatedLux;
status.aperture = currentAperture;
LOG(RPiLux, Debug) << ": estimated lux " << estimatedLux;
{
std::unique_lock<std::mutex> lock(mutex_);
status_ = status;
}
/*
* Overwrite the metadata here as well, so that downstream
* algorithms get the latest value.
*/
imageMetadata->set("lux.status", status);
} else
LOG(RPiLux, Warning) << ": no device metadata";
}
/* Register algorithm with the system. */
static Algorithm *create(Controller *controller)
{
return (Algorithm *)new Lux(controller);
}
static RegisterAlgorithm reg(NAME, &create);
|
