| Message ID | 20220725134639.4572-7-naush@raspberrypi.com |
|---|---|
| State | Superseded |
| Headers | show |
| Series |
|
| Related | show |
Hi Naush, Thank you for the patch. On Mon, Jul 25, 2022 at 02:46:30PM +0100, Naushir Patuck via libcamera-devel wrote: > Refactor the remaining files under src/ipa/raspberrypi/controller/* to match the > recommended formatting guidelines for the libcamera project. The vast majority > of changes in this commit comprise of switching from snake_case to CamelCase, > and starting class member functions with a lower case character. > > Signed-off-by: Naushir Patuck <naush@raspberrypi.com> > > Signed-off-by: Naushir Patuck <naush@raspberrypi.com> One is enough :-) > --- > src/ipa/raspberrypi/controller/focus_status.h | 2 +- > src/ipa/raspberrypi/controller/histogram.cpp | 34 ++--- > src/ipa/raspberrypi/controller/histogram.hpp | 10 +- > src/ipa/raspberrypi/controller/metadata.hpp | 16 +-- > src/ipa/raspberrypi/controller/pwl.cpp | 130 +++++++++--------- > src/ipa/raspberrypi/controller/pwl.hpp | 48 +++---- > 6 files changed, 121 insertions(+), 119 deletions(-) > > diff --git a/src/ipa/raspberrypi/controller/focus_status.h b/src/ipa/raspberrypi/controller/focus_status.h > index ace2fe2c317a..656455100b45 100644 > --- a/src/ipa/raspberrypi/controller/focus_status.h > +++ b/src/ipa/raspberrypi/controller/focus_status.h > @@ -18,7 +18,7 @@ extern "C" { > > struct FocusStatus { > unsigned int num; > - uint32_t focus_measures[FOCUS_REGIONS]; > + uint32_t focusMeasures[FOCUS_REGIONS]; > }; > > #ifdef __cplusplus > diff --git a/src/ipa/raspberrypi/controller/histogram.cpp b/src/ipa/raspberrypi/controller/histogram.cpp > index 9916b3ed7f71..e865bef0057b 100644 > --- a/src/ipa/raspberrypi/controller/histogram.cpp > +++ b/src/ipa/raspberrypi/controller/histogram.cpp > @@ -11,25 +11,25 @@ > > using namespace RPiController; > > -uint64_t Histogram::CumulativeFreq(double bin) const > +uint64_t Histogram::cumulativeFreq(double bin) const > { > if (bin <= 0) > return 0; > - else if (bin >= Bins()) > - return Total(); > + else if (bin >= bins()) > + return total(); > int b = (int)bin; > return cumulative_[b] + > (bin - b) * (cumulative_[b + 1] - cumulative_[b]); > } > > -double Histogram::Quantile(double q, int first, int last) const > +double Histogram::quantile(double q, int first, int last) const > { > if (first == -1) > first = 0; > if (last == -1) > last = cumulative_.size() - 2; > assert(first <= last); > - uint64_t items = q * Total(); > + uint64_t items = q * total(); > while (first < last) // binary search to find the right bin > { > int middle = (first + last) / 2; > @@ -45,20 +45,20 @@ double Histogram::Quantile(double q, int first, int last) const > return first + frac; > } > > -double Histogram::InterQuantileMean(double q_lo, double q_hi) const > +double Histogram::interQuantileMean(double qLo, double qHi) const > { > - assert(q_hi > q_lo); > - double p_lo = Quantile(q_lo); > - double p_hi = Quantile(q_hi, (int)p_lo); > - double sum_bin_freq = 0, cumul_freq = 0; > - for (double p_next = floor(p_lo) + 1.0; p_next <= ceil(p_hi); > - p_lo = p_next, p_next += 1.0) { > - int bin = floor(p_lo); > + assert(qHi > qLo); > + double pLo = quantile(qLo); > + double pHi = quantile(qHi, (int)pLo); > + double sumBinFreq = 0, cumulFreq = 0; > + for (double pNext = floor(pLo) + 1.0; pNext <= ceil(pHi); > + pLo = pNext, pNext += 1.0) { > + int bin = floor(pLo); > double freq = (cumulative_[bin + 1] - cumulative_[bin]) * > - (std::min(p_next, p_hi) - p_lo); > - sum_bin_freq += bin * freq; > - cumul_freq += freq; > + (std::min(pNext, pHi) - pLo); > + sumBinFreq += bin * freq; > + cumulFreq += freq; > } > // add 0.5 to give an average for bin mid-points > - return sum_bin_freq / cumul_freq + 0.5; > + return sumBinFreq / cumulFreq + 0.5; > } > diff --git a/src/ipa/raspberrypi/controller/histogram.hpp b/src/ipa/raspberrypi/controller/histogram.hpp > index 90f5ac78e8c6..4ff5a56b0243 100644 > --- a/src/ipa/raspberrypi/controller/histogram.hpp > +++ b/src/ipa/raspberrypi/controller/histogram.hpp > @@ -27,15 +27,15 @@ public: > cumulative_.push_back(cumulative_.back() + > histogram[i]); > } > - uint32_t Bins() const { return cumulative_.size() - 1; } > - uint64_t Total() const { return cumulative_[cumulative_.size() - 1]; } > + uint32_t bins() const { return cumulative_.size() - 1; } > + uint64_t total() const { return cumulative_[cumulative_.size() - 1]; } > // Cumulative frequency up to a (fractional) point in a bin. > - uint64_t CumulativeFreq(double bin) const; > + uint64_t cumulativeFreq(double bin) const; > // Return the (fractional) bin of the point q (0 <= q <= 1) through the > // histogram. Optionally provide limits to help. > - double Quantile(double q, int first = -1, int last = -1) const; > + double quantile(double q, int first = -1, int last = -1) const; > // Return the average histogram bin value between the two quantiles. > - double InterQuantileMean(double q_lo, double q_hi) const; > + double interQuantileMean(double qLo, double qHi) const; > > private: > std::vector<uint64_t> cumulative_; > diff --git a/src/ipa/raspberrypi/controller/metadata.hpp b/src/ipa/raspberrypi/controller/metadata.hpp > index 51e576cfab95..a79a67d42cce 100644 > --- a/src/ipa/raspberrypi/controller/metadata.hpp > +++ b/src/ipa/raspberrypi/controller/metadata.hpp > @@ -22,26 +22,26 @@ public: > > Metadata(Metadata const &other) > { > - std::scoped_lock other_lock(other.mutex_); > + std::scoped_lock otherLock(other.mutex_); > data_ = other.data_; > } > > Metadata(Metadata &&other) > { > - std::scoped_lock other_lock(other.mutex_); > + std::scoped_lock otherLock(other.mutex_); > data_ = std::move(other.data_); > other.data_.clear(); > } > > template<typename T> > - void Set(std::string const &tag, T const &value) > + void set(std::string const &tag, T const &value) > { > std::scoped_lock lock(mutex_); > data_[tag] = value; > } > > template<typename T> > - int Get(std::string const &tag, T &value) const > + int get(std::string const &tag, T &value) const > { > std::scoped_lock lock(mutex_); > auto it = data_.find(tag); > @@ -51,7 +51,7 @@ public: > return 0; > } > > - void Clear() > + void clear() > { > std::scoped_lock lock(mutex_); > data_.clear(); > @@ -72,14 +72,14 @@ public: > return *this; > } > > - void Merge(Metadata &other) > + void merge(Metadata &other) > { > std::scoped_lock lock(mutex_, other.mutex_); > data_.merge(other.data_); > } > > template<typename T> > - T *GetLocked(std::string const &tag) > + T *getLocked(std::string const &tag) > { > // This allows in-place access to the Metadata contents, > // for which you should be holding the lock. > @@ -90,7 +90,7 @@ public: > } > > template<typename T> > - void SetLocked(std::string const &tag, T const &value) > + void setLocked(std::string const &tag, T const &value) > { > // Use this only if you're holding the lock yourself. > data_[tag] = value; > diff --git a/src/ipa/raspberrypi/controller/pwl.cpp b/src/ipa/raspberrypi/controller/pwl.cpp > index 130c820b559f..24ff3ea34f5f 100644 > --- a/src/ipa/raspberrypi/controller/pwl.cpp > +++ b/src/ipa/raspberrypi/controller/pwl.cpp > @@ -12,7 +12,7 @@ > > using namespace RPiController; > > -void Pwl::Read(boost::property_tree::ptree const ¶ms) > +void Pwl::read(boost::property_tree::ptree const ¶ms) > { > for (auto it = params.begin(); it != params.end(); it++) { > double x = it->second.get_value<double>(); > @@ -24,24 +24,24 @@ void Pwl::Read(boost::property_tree::ptree const ¶ms) > assert(points_.size() >= 2); > } > > -void Pwl::Append(double x, double y, const double eps) > +void Pwl::append(double x, double y, const double eps) > { > if (points_.empty() || points_.back().x + eps < x) > points_.push_back(Point(x, y)); > } > > -void Pwl::Prepend(double x, double y, const double eps) > +void Pwl::prepend(double x, double y, const double eps) > { > if (points_.empty() || points_.front().x - eps > x) > points_.insert(points_.begin(), Point(x, y)); > } > > -Pwl::Interval Pwl::Domain() const > +Pwl::Interval Pwl::domain() const > { > return Interval(points_[0].x, points_[points_.size() - 1].x); > } > > -Pwl::Interval Pwl::Range() const > +Pwl::Interval Pwl::range() const > { > double lo = points_[0].y, hi = lo; > for (auto &p : points_) > @@ -49,18 +49,16 @@ Pwl::Interval Pwl::Range() const > return Interval(lo, hi); > } > > -bool Pwl::Empty() const > +bool Pwl::empty() const > { > return points_.empty(); > } > > -double Pwl::Eval(double x, int *span_ptr, bool update_span) const > +double Pwl::eval(double x, int *spanPtr, bool updateSpan) const > { > - int span = findSpan(x, span_ptr && *span_ptr != -1 > - ? *span_ptr > - : points_.size() / 2 - 1); > - if (span_ptr && update_span) > - *span_ptr = span; > + int span = findSpan(x, spanPtr && *spanPtr != -1 ? *spanPtr : points_.size() / 2 - 1); > + if (spanPtr && updateSpan) > + *spanPtr = span; > return points_[span].y + > (x - points_[span].x) * (points_[span + 1].y - points_[span].y) / > (points_[span + 1].x - points_[span].x); > @@ -70,31 +68,31 @@ int Pwl::findSpan(double x, int span) const > { > // Pwls are generally small, so linear search may well be faster than > // binary, though could review this if large PWls start turning up. > - int last_span = points_.size() - 2; > + int lastSpan = points_.size() - 2; > // some algorithms may call us with span pointing directly at the last > // control point > - span = std::max(0, std::min(last_span, span)); > - while (span < last_span && x >= points_[span + 1].x) > + span = std::max(0, std::min(lastSpan, span)); > + while (span < lastSpan && x >= points_[span + 1].x) > span++; > while (span && x < points_[span].x) > span--; > return span; > } > > -Pwl::PerpType Pwl::Invert(Point const &xy, Point &perp, int &span, > +Pwl::PerpType Pwl::invert(Point const &xy, Point &perp, int &span, > const double eps) const > { > assert(span >= -1); > - bool prev_off_end = false; > + bool prevOffEnd = false; > for (span = span + 1; span < (int)points_.size() - 1; span++) { > - Point span_vec = points_[span + 1] - points_[span]; > - double t = ((xy - points_[span]) % span_vec) / span_vec.Len2(); > + Point spanVec = points_[span + 1] - points_[span]; > + double t = ((xy - points_[span]) % spanVec) / spanVec.len2(); > if (t < -eps) // off the start of this span > { > if (span == 0) { > perp = points_[span]; > return PerpType::Start; > - } else if (prev_off_end) { > + } else if (prevOffEnd) { > perp = points_[span]; > return PerpType::Vertex; > } > @@ -104,32 +102,32 @@ Pwl::PerpType Pwl::Invert(Point const &xy, Point &perp, int &span, > perp = points_[span + 1]; > return PerpType::End; > } > - prev_off_end = true; > + prevOffEnd = true; > } else // a true perpendicular > { > - perp = points_[span] + span_vec * t; > + perp = points_[span] + spanVec * t; > return PerpType::Perpendicular; > } > } > return PerpType::None; > } > > -Pwl Pwl::Inverse(bool *true_inverse, const double eps) const > +Pwl Pwl::inverse(bool *trueInverse, const double eps) const > { > bool appended = false, prepended = false, neither = false; > Pwl inverse; > > for (Point const &p : points_) { > - if (inverse.Empty()) > - inverse.Append(p.y, p.x, eps); > + if (inverse.empty()) > + inverse.append(p.y, p.x, eps); > else if (std::abs(inverse.points_.back().x - p.y) <= eps || > std::abs(inverse.points_.front().x - p.y) <= eps) > /* do nothing */; > else if (p.y > inverse.points_.back().x) { > - inverse.Append(p.y, p.x, eps); > + inverse.append(p.y, p.x, eps); > appended = true; > } else if (p.y < inverse.points_.front().x) { > - inverse.Prepend(p.y, p.x, eps); > + inverse.prepend(p.y, p.x, eps); > prepended = true; > } else > neither = true; > @@ -138,63 +136,65 @@ Pwl Pwl::Inverse(bool *true_inverse, const double eps) const > // This is not a proper inverse if we found ourselves putting points > // onto both ends of the inverse, or if there were points that couldn't > // go on either. > - if (true_inverse) > - *true_inverse = !(neither || (appended && prepended)); > + if (trueInverse) > + *trueInverse = !(neither || (appended && prepended)); > > return inverse; > } > > -Pwl Pwl::Compose(Pwl const &other, const double eps) const > +Pwl Pwl::compose(Pwl const &other, const double eps) const > { > - double this_x = points_[0].x, this_y = points_[0].y; > - int this_span = 0, other_span = other.findSpan(this_y, 0); > - Pwl result({ { this_x, other.Eval(this_y, &other_span, false) } }); > - while (this_span != (int)points_.size() - 1) { > - double dx = points_[this_span + 1].x - points_[this_span].x, > - dy = points_[this_span + 1].y - points_[this_span].y; > + double thisX = points_[0].x, thisY = points_[0].y; > + int thisSpan = 0, otherSpan = other.findSpan(thisY, 0); > + Pwl result({ { thisX, other.eval(thisY, &otherSpan, false) } }); > + while (thisSpan != (int)points_.size() - 1) { > + double dx = points_[thisSpan + 1].x - points_[thisSpan].x, > + dy = points_[thisSpan + 1].y - points_[thisSpan].y; > if (abs(dy) > eps && > - other_span + 1 < (int)other.points_.size() && > - points_[this_span + 1].y >= > - other.points_[other_span + 1].x + eps) { > + otherSpan + 1 < (int)other.points_.size() && > + points_[thisSpan + 1].y >= > + other.points_[otherSpan + 1].x + eps) { > // next control point in result will be where this > // function's y reaches the next span in other > - this_x = points_[this_span].x + > - (other.points_[other_span + 1].x - > - points_[this_span].y) * dx / dy; > - this_y = other.points_[++other_span].x; > - } else if (abs(dy) > eps && other_span > 0 && > - points_[this_span + 1].y <= > - other.points_[other_span - 1].x - eps) { > + thisX = points_[thisSpan].x + > + (other.points_[otherSpan + 1].x - > + points_[thisSpan].y) * > + dx / dy; > + thisY = other.points_[++otherSpan].x; > + } else if (abs(dy) > eps && otherSpan > 0 && > + points_[thisSpan + 1].y <= > + other.points_[otherSpan - 1].x - eps) { > // next control point in result will be where this > // function's y reaches the previous span in other > - this_x = points_[this_span].x + > - (other.points_[other_span + 1].x - > - points_[this_span].y) * dx / dy; > - this_y = other.points_[--other_span].x; > + thisX = points_[thisSpan].x + > + (other.points_[otherSpan + 1].x - > + points_[thisSpan].y) * > + dx / dy; > + thisY = other.points_[--otherSpan].x; > } else { > // we stay in the same span in other > - this_span++; > - this_x = points_[this_span].x, > - this_y = points_[this_span].y; > + thisSpan++; > + thisX = points_[thisSpan].x, > + thisY = points_[thisSpan].y; > } > - result.Append(this_x, other.Eval(this_y, &other_span, false), > + result.append(thisX, other.eval(thisY, &otherSpan, false), > eps); > } > return result; > } > > -void Pwl::Map(std::function<void(double x, double y)> f) const > +void Pwl::map(std::function<void(double x, double y)> f) const > { > for (auto &pt : points_) > f(pt.x, pt.y); > } > > -void Pwl::Map2(Pwl const &pwl0, Pwl const &pwl1, > +void Pwl::map2(Pwl const &pwl0, Pwl const &pwl1, > std::function<void(double x, double y0, double y1)> f) > { > int span0 = 0, span1 = 0; > double x = std::min(pwl0.points_[0].x, pwl1.points_[0].x); > - f(x, pwl0.Eval(x, &span0, false), pwl1.Eval(x, &span1, false)); > + f(x, pwl0.eval(x, &span0, false), pwl1.eval(x, &span1, false)); > while (span0 < (int)pwl0.points_.size() - 1 || > span1 < (int)pwl1.points_.size() - 1) { > if (span0 == (int)pwl0.points_.size() - 1) > @@ -205,28 +205,28 @@ void Pwl::Map2(Pwl const &pwl0, Pwl const &pwl1, > x = pwl1.points_[++span1].x; > else > x = pwl0.points_[++span0].x; > - f(x, pwl0.Eval(x, &span0, false), pwl1.Eval(x, &span1, false)); > + f(x, pwl0.eval(x, &span0, false), pwl1.eval(x, &span1, false)); > } > } > > -Pwl Pwl::Combine(Pwl const &pwl0, Pwl const &pwl1, > +Pwl Pwl::combine(Pwl const &pwl0, Pwl const &pwl1, > std::function<double(double x, double y0, double y1)> f, > const double eps) > { > Pwl result; > - Map2(pwl0, pwl1, [&](double x, double y0, double y1) { > - result.Append(x, f(x, y0, y1), eps); > + map2(pwl0, pwl1, [&](double x, double y0, double y1) { > + result.append(x, f(x, y0, y1), eps); > }); > return result; > } > > -void Pwl::MatchDomain(Interval const &domain, bool clip, const double eps) > +void Pwl::matchDomain(Interval const &domain, bool clip, const double eps) > { > int span = 0; > - Prepend(domain.start, Eval(clip ? points_[0].x : domain.start, &span), > + prepend(domain.start, eval(clip ? points_[0].x : domain.start, &span), > eps); > span = points_.size() - 2; > - Append(domain.end, Eval(clip ? points_.back().x : domain.end, &span), > + append(domain.end, eval(clip ? points_.back().x : domain.end, &span), > eps); > } > > @@ -237,7 +237,7 @@ Pwl &Pwl::operator*=(double d) > return *this; > } > > -void Pwl::Debug(FILE *fp) const > +void Pwl::debug(FILE *fp) const Candidate for another patch, maybe this should be turned into an operator<<(std::ostream &). Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> > { > fprintf(fp, "Pwl {\n"); > for (auto &p : points_) > diff --git a/src/ipa/raspberrypi/controller/pwl.hpp b/src/ipa/raspberrypi/controller/pwl.hpp > index 484672f64095..4a38d1df5a33 100644 > --- a/src/ipa/raspberrypi/controller/pwl.hpp > +++ b/src/ipa/raspberrypi/controller/pwl.hpp > @@ -17,24 +17,26 @@ class Pwl > { > public: > struct Interval { > - Interval(double _start, double _end) : start(_start), end(_end) > + Interval(double _start, double _end) > + : start(_start), end(_end) > { > } > double start, end; > - bool Contains(double value) > + bool contains(double value) > { > return value >= start && value <= end; > } > - double Clip(double value) > + double clip(double value) > { > return value < start ? start > : (value > end ? end : value); > } > - double Len() const { return end - start; } > + double len() const { return end - start; } > }; > struct Point { > Point() : x(0), y(0) {} > - Point(double _x, double _y) : x(_x), y(_y) {} > + Point(double _x, double _y) > + : x(_x), y(_y) {} > double x, y; > Point operator-(Point const &p) const > { > @@ -50,23 +52,23 @@ public: > } > Point operator*(double f) const { return Point(x * f, y * f); } > Point operator/(double f) const { return Point(x / f, y / f); } > - double Len2() const { return x * x + y * y; } > - double Len() const { return sqrt(Len2()); } > + double len2() const { return x * x + y * y; } > + double len() const { return sqrt(len2()); } > }; > Pwl() {} > Pwl(std::vector<Point> const &points) : points_(points) {} > - void Read(boost::property_tree::ptree const ¶ms); > - void Append(double x, double y, const double eps = 1e-6); > - void Prepend(double x, double y, const double eps = 1e-6); > - Interval Domain() const; > - Interval Range() const; > - bool Empty() const; > + void read(boost::property_tree::ptree const ¶ms); > + void append(double x, double y, const double eps = 1e-6); > + void prepend(double x, double y, const double eps = 1e-6); > + Interval domain() const; > + Interval range() const; > + bool empty() const; > // Evaluate Pwl, optionally supplying an initial guess for the > // "span". The "span" may be optionally be updated. If you want to know > // the "span" value but don't have an initial guess you can set it to > // -1. > - double Eval(double x, int *span_ptr = nullptr, > - bool update_span = true) const; > + double eval(double x, int *spanPtr = nullptr, > + bool updateSpan = true) const; > // Find perpendicular closest to xy, starting from span+1 so you can > // call it repeatedly to check for multiple closest points (set span to > // -1 on the first call). Also returns "pseudo" perpendiculars; see > @@ -78,31 +80,31 @@ public: > Vertex, // vertex of Pwl is closest point > Perpendicular // true perpendicular found > }; > - PerpType Invert(Point const &xy, Point &perp, int &span, > + PerpType invert(Point const &xy, Point &perp, int &span, > const double eps = 1e-6) const; > // Compute the inverse function. Indicate if it is a proper (true) > // inverse, or only a best effort (e.g. input was non-monotonic). > - Pwl Inverse(bool *true_inverse = nullptr, const double eps = 1e-6) const; > + Pwl inverse(bool *trueInverse = nullptr, const double eps = 1e-6) const; > // Compose two Pwls together, doing "this" first and "other" after. > - Pwl Compose(Pwl const &other, const double eps = 1e-6) const; > + Pwl compose(Pwl const &other, const double eps = 1e-6) const; > // Apply function to (x,y) values at every control point. > - void Map(std::function<void(double x, double y)> f) const; > + void map(std::function<void(double x, double y)> f) const; > // Apply function to (x, y0, y1) values wherever either Pwl has a > // control point. > - static void Map2(Pwl const &pwl0, Pwl const &pwl1, > + static void map2(Pwl const &pwl0, Pwl const &pwl1, > std::function<void(double x, double y0, double y1)> f); > // Combine two Pwls, meaning we create a new Pwl where the y values are > // given by running f wherever either has a knot. > static Pwl > - Combine(Pwl const &pwl0, Pwl const &pwl1, > + combine(Pwl const &pwl0, Pwl const &pwl1, > std::function<double(double x, double y0, double y1)> f, > const double eps = 1e-6); > // Make "this" match (at least) the given domain. Any extension my be > // clipped or linear. > - void MatchDomain(Interval const &domain, bool clip = true, > + void matchDomain(Interval const &domain, bool clip = true, > const double eps = 1e-6); > Pwl &operator*=(double d); > - void Debug(FILE *fp = stdout) const; > + void debug(FILE *fp = stdout) const; > > private: > int findSpan(double x, int span) const;
diff --git a/src/ipa/raspberrypi/controller/focus_status.h b/src/ipa/raspberrypi/controller/focus_status.h index ace2fe2c317a..656455100b45 100644 --- a/src/ipa/raspberrypi/controller/focus_status.h +++ b/src/ipa/raspberrypi/controller/focus_status.h @@ -18,7 +18,7 @@ extern "C" { struct FocusStatus { unsigned int num; - uint32_t focus_measures[FOCUS_REGIONS]; + uint32_t focusMeasures[FOCUS_REGIONS]; }; #ifdef __cplusplus diff --git a/src/ipa/raspberrypi/controller/histogram.cpp b/src/ipa/raspberrypi/controller/histogram.cpp index 9916b3ed7f71..e865bef0057b 100644 --- a/src/ipa/raspberrypi/controller/histogram.cpp +++ b/src/ipa/raspberrypi/controller/histogram.cpp @@ -11,25 +11,25 @@ using namespace RPiController; -uint64_t Histogram::CumulativeFreq(double bin) const +uint64_t Histogram::cumulativeFreq(double bin) const { if (bin <= 0) return 0; - else if (bin >= Bins()) - return Total(); + else if (bin >= bins()) + return total(); int b = (int)bin; return cumulative_[b] + (bin - b) * (cumulative_[b + 1] - cumulative_[b]); } -double Histogram::Quantile(double q, int first, int last) const +double Histogram::quantile(double q, int first, int last) const { if (first == -1) first = 0; if (last == -1) last = cumulative_.size() - 2; assert(first <= last); - uint64_t items = q * Total(); + uint64_t items = q * total(); while (first < last) // binary search to find the right bin { int middle = (first + last) / 2; @@ -45,20 +45,20 @@ double Histogram::Quantile(double q, int first, int last) const return first + frac; } -double Histogram::InterQuantileMean(double q_lo, double q_hi) const +double Histogram::interQuantileMean(double qLo, double qHi) const { - assert(q_hi > q_lo); - double p_lo = Quantile(q_lo); - double p_hi = Quantile(q_hi, (int)p_lo); - double sum_bin_freq = 0, cumul_freq = 0; - for (double p_next = floor(p_lo) + 1.0; p_next <= ceil(p_hi); - p_lo = p_next, p_next += 1.0) { - int bin = floor(p_lo); + assert(qHi > qLo); + double pLo = quantile(qLo); + double pHi = quantile(qHi, (int)pLo); + double sumBinFreq = 0, cumulFreq = 0; + for (double pNext = floor(pLo) + 1.0; pNext <= ceil(pHi); + pLo = pNext, pNext += 1.0) { + int bin = floor(pLo); double freq = (cumulative_[bin + 1] - cumulative_[bin]) * - (std::min(p_next, p_hi) - p_lo); - sum_bin_freq += bin * freq; - cumul_freq += freq; + (std::min(pNext, pHi) - pLo); + sumBinFreq += bin * freq; + cumulFreq += freq; } // add 0.5 to give an average for bin mid-points - return sum_bin_freq / cumul_freq + 0.5; + return sumBinFreq / cumulFreq + 0.5; } diff --git a/src/ipa/raspberrypi/controller/histogram.hpp b/src/ipa/raspberrypi/controller/histogram.hpp index 90f5ac78e8c6..4ff5a56b0243 100644 --- a/src/ipa/raspberrypi/controller/histogram.hpp +++ b/src/ipa/raspberrypi/controller/histogram.hpp @@ -27,15 +27,15 @@ public: cumulative_.push_back(cumulative_.back() + histogram[i]); } - uint32_t Bins() const { return cumulative_.size() - 1; } - uint64_t Total() const { return cumulative_[cumulative_.size() - 1]; } + uint32_t bins() const { return cumulative_.size() - 1; } + uint64_t total() const { return cumulative_[cumulative_.size() - 1]; } // Cumulative frequency up to a (fractional) point in a bin. - uint64_t CumulativeFreq(double bin) const; + uint64_t cumulativeFreq(double bin) const; // Return the (fractional) bin of the point q (0 <= q <= 1) through the // histogram. Optionally provide limits to help. - double Quantile(double q, int first = -1, int last = -1) const; + double quantile(double q, int first = -1, int last = -1) const; // Return the average histogram bin value between the two quantiles. - double InterQuantileMean(double q_lo, double q_hi) const; + double interQuantileMean(double qLo, double qHi) const; private: std::vector<uint64_t> cumulative_; diff --git a/src/ipa/raspberrypi/controller/metadata.hpp b/src/ipa/raspberrypi/controller/metadata.hpp index 51e576cfab95..a79a67d42cce 100644 --- a/src/ipa/raspberrypi/controller/metadata.hpp +++ b/src/ipa/raspberrypi/controller/metadata.hpp @@ -22,26 +22,26 @@ public: Metadata(Metadata const &other) { - std::scoped_lock other_lock(other.mutex_); + std::scoped_lock otherLock(other.mutex_); data_ = other.data_; } Metadata(Metadata &&other) { - std::scoped_lock other_lock(other.mutex_); + std::scoped_lock otherLock(other.mutex_); data_ = std::move(other.data_); other.data_.clear(); } template<typename T> - void Set(std::string const &tag, T const &value) + void set(std::string const &tag, T const &value) { std::scoped_lock lock(mutex_); data_[tag] = value; } template<typename T> - int Get(std::string const &tag, T &value) const + int get(std::string const &tag, T &value) const { std::scoped_lock lock(mutex_); auto it = data_.find(tag); @@ -51,7 +51,7 @@ public: return 0; } - void Clear() + void clear() { std::scoped_lock lock(mutex_); data_.clear(); @@ -72,14 +72,14 @@ public: return *this; } - void Merge(Metadata &other) + void merge(Metadata &other) { std::scoped_lock lock(mutex_, other.mutex_); data_.merge(other.data_); } template<typename T> - T *GetLocked(std::string const &tag) + T *getLocked(std::string const &tag) { // This allows in-place access to the Metadata contents, // for which you should be holding the lock. @@ -90,7 +90,7 @@ public: } template<typename T> - void SetLocked(std::string const &tag, T const &value) + void setLocked(std::string const &tag, T const &value) { // Use this only if you're holding the lock yourself. data_[tag] = value; diff --git a/src/ipa/raspberrypi/controller/pwl.cpp b/src/ipa/raspberrypi/controller/pwl.cpp index 130c820b559f..24ff3ea34f5f 100644 --- a/src/ipa/raspberrypi/controller/pwl.cpp +++ b/src/ipa/raspberrypi/controller/pwl.cpp @@ -12,7 +12,7 @@ using namespace RPiController; -void Pwl::Read(boost::property_tree::ptree const ¶ms) +void Pwl::read(boost::property_tree::ptree const ¶ms) { for (auto it = params.begin(); it != params.end(); it++) { double x = it->second.get_value<double>(); @@ -24,24 +24,24 @@ void Pwl::Read(boost::property_tree::ptree const ¶ms) assert(points_.size() >= 2); } -void Pwl::Append(double x, double y, const double eps) +void Pwl::append(double x, double y, const double eps) { if (points_.empty() || points_.back().x + eps < x) points_.push_back(Point(x, y)); } -void Pwl::Prepend(double x, double y, const double eps) +void Pwl::prepend(double x, double y, const double eps) { if (points_.empty() || points_.front().x - eps > x) points_.insert(points_.begin(), Point(x, y)); } -Pwl::Interval Pwl::Domain() const +Pwl::Interval Pwl::domain() const { return Interval(points_[0].x, points_[points_.size() - 1].x); } -Pwl::Interval Pwl::Range() const +Pwl::Interval Pwl::range() const { double lo = points_[0].y, hi = lo; for (auto &p : points_) @@ -49,18 +49,16 @@ Pwl::Interval Pwl::Range() const return Interval(lo, hi); } -bool Pwl::Empty() const +bool Pwl::empty() const { return points_.empty(); } -double Pwl::Eval(double x, int *span_ptr, bool update_span) const +double Pwl::eval(double x, int *spanPtr, bool updateSpan) const { - int span = findSpan(x, span_ptr && *span_ptr != -1 - ? *span_ptr - : points_.size() / 2 - 1); - if (span_ptr && update_span) - *span_ptr = span; + int span = findSpan(x, spanPtr && *spanPtr != -1 ? *spanPtr : points_.size() / 2 - 1); + if (spanPtr && updateSpan) + *spanPtr = span; return points_[span].y + (x - points_[span].x) * (points_[span + 1].y - points_[span].y) / (points_[span + 1].x - points_[span].x); @@ -70,31 +68,31 @@ int Pwl::findSpan(double x, int span) const { // Pwls are generally small, so linear search may well be faster than // binary, though could review this if large PWls start turning up. - int last_span = points_.size() - 2; + int lastSpan = points_.size() - 2; // some algorithms may call us with span pointing directly at the last // control point - span = std::max(0, std::min(last_span, span)); - while (span < last_span && x >= points_[span + 1].x) + span = std::max(0, std::min(lastSpan, span)); + while (span < lastSpan && x >= points_[span + 1].x) span++; while (span && x < points_[span].x) span--; return span; } -Pwl::PerpType Pwl::Invert(Point const &xy, Point &perp, int &span, +Pwl::PerpType Pwl::invert(Point const &xy, Point &perp, int &span, const double eps) const { assert(span >= -1); - bool prev_off_end = false; + bool prevOffEnd = false; for (span = span + 1; span < (int)points_.size() - 1; span++) { - Point span_vec = points_[span + 1] - points_[span]; - double t = ((xy - points_[span]) % span_vec) / span_vec.Len2(); + Point spanVec = points_[span + 1] - points_[span]; + double t = ((xy - points_[span]) % spanVec) / spanVec.len2(); if (t < -eps) // off the start of this span { if (span == 0) { perp = points_[span]; return PerpType::Start; - } else if (prev_off_end) { + } else if (prevOffEnd) { perp = points_[span]; return PerpType::Vertex; } @@ -104,32 +102,32 @@ Pwl::PerpType Pwl::Invert(Point const &xy, Point &perp, int &span, perp = points_[span + 1]; return PerpType::End; } - prev_off_end = true; + prevOffEnd = true; } else // a true perpendicular { - perp = points_[span] + span_vec * t; + perp = points_[span] + spanVec * t; return PerpType::Perpendicular; } } return PerpType::None; } -Pwl Pwl::Inverse(bool *true_inverse, const double eps) const +Pwl Pwl::inverse(bool *trueInverse, const double eps) const { bool appended = false, prepended = false, neither = false; Pwl inverse; for (Point const &p : points_) { - if (inverse.Empty()) - inverse.Append(p.y, p.x, eps); + if (inverse.empty()) + inverse.append(p.y, p.x, eps); else if (std::abs(inverse.points_.back().x - p.y) <= eps || std::abs(inverse.points_.front().x - p.y) <= eps) /* do nothing */; else if (p.y > inverse.points_.back().x) { - inverse.Append(p.y, p.x, eps); + inverse.append(p.y, p.x, eps); appended = true; } else if (p.y < inverse.points_.front().x) { - inverse.Prepend(p.y, p.x, eps); + inverse.prepend(p.y, p.x, eps); prepended = true; } else neither = true; @@ -138,63 +136,65 @@ Pwl Pwl::Inverse(bool *true_inverse, const double eps) const // This is not a proper inverse if we found ourselves putting points // onto both ends of the inverse, or if there were points that couldn't // go on either. - if (true_inverse) - *true_inverse = !(neither || (appended && prepended)); + if (trueInverse) + *trueInverse = !(neither || (appended && prepended)); return inverse; } -Pwl Pwl::Compose(Pwl const &other, const double eps) const +Pwl Pwl::compose(Pwl const &other, const double eps) const { - double this_x = points_[0].x, this_y = points_[0].y; - int this_span = 0, other_span = other.findSpan(this_y, 0); - Pwl result({ { this_x, other.Eval(this_y, &other_span, false) } }); - while (this_span != (int)points_.size() - 1) { - double dx = points_[this_span + 1].x - points_[this_span].x, - dy = points_[this_span + 1].y - points_[this_span].y; + double thisX = points_[0].x, thisY = points_[0].y; + int thisSpan = 0, otherSpan = other.findSpan(thisY, 0); + Pwl result({ { thisX, other.eval(thisY, &otherSpan, false) } }); + while (thisSpan != (int)points_.size() - 1) { + double dx = points_[thisSpan + 1].x - points_[thisSpan].x, + dy = points_[thisSpan + 1].y - points_[thisSpan].y; if (abs(dy) > eps && - other_span + 1 < (int)other.points_.size() && - points_[this_span + 1].y >= - other.points_[other_span + 1].x + eps) { + otherSpan + 1 < (int)other.points_.size() && + points_[thisSpan + 1].y >= + other.points_[otherSpan + 1].x + eps) { // next control point in result will be where this // function's y reaches the next span in other - this_x = points_[this_span].x + - (other.points_[other_span + 1].x - - points_[this_span].y) * dx / dy; - this_y = other.points_[++other_span].x; - } else if (abs(dy) > eps && other_span > 0 && - points_[this_span + 1].y <= - other.points_[other_span - 1].x - eps) { + thisX = points_[thisSpan].x + + (other.points_[otherSpan + 1].x - + points_[thisSpan].y) * + dx / dy; + thisY = other.points_[++otherSpan].x; + } else if (abs(dy) > eps && otherSpan > 0 && + points_[thisSpan + 1].y <= + other.points_[otherSpan - 1].x - eps) { // next control point in result will be where this // function's y reaches the previous span in other - this_x = points_[this_span].x + - (other.points_[other_span + 1].x - - points_[this_span].y) * dx / dy; - this_y = other.points_[--other_span].x; + thisX = points_[thisSpan].x + + (other.points_[otherSpan + 1].x - + points_[thisSpan].y) * + dx / dy; + thisY = other.points_[--otherSpan].x; } else { // we stay in the same span in other - this_span++; - this_x = points_[this_span].x, - this_y = points_[this_span].y; + thisSpan++; + thisX = points_[thisSpan].x, + thisY = points_[thisSpan].y; } - result.Append(this_x, other.Eval(this_y, &other_span, false), + result.append(thisX, other.eval(thisY, &otherSpan, false), eps); } return result; } -void Pwl::Map(std::function<void(double x, double y)> f) const +void Pwl::map(std::function<void(double x, double y)> f) const { for (auto &pt : points_) f(pt.x, pt.y); } -void Pwl::Map2(Pwl const &pwl0, Pwl const &pwl1, +void Pwl::map2(Pwl const &pwl0, Pwl const &pwl1, std::function<void(double x, double y0, double y1)> f) { int span0 = 0, span1 = 0; double x = std::min(pwl0.points_[0].x, pwl1.points_[0].x); - f(x, pwl0.Eval(x, &span0, false), pwl1.Eval(x, &span1, false)); + f(x, pwl0.eval(x, &span0, false), pwl1.eval(x, &span1, false)); while (span0 < (int)pwl0.points_.size() - 1 || span1 < (int)pwl1.points_.size() - 1) { if (span0 == (int)pwl0.points_.size() - 1) @@ -205,28 +205,28 @@ void Pwl::Map2(Pwl const &pwl0, Pwl const &pwl1, x = pwl1.points_[++span1].x; else x = pwl0.points_[++span0].x; - f(x, pwl0.Eval(x, &span0, false), pwl1.Eval(x, &span1, false)); + f(x, pwl0.eval(x, &span0, false), pwl1.eval(x, &span1, false)); } } -Pwl Pwl::Combine(Pwl const &pwl0, Pwl const &pwl1, +Pwl Pwl::combine(Pwl const &pwl0, Pwl const &pwl1, std::function<double(double x, double y0, double y1)> f, const double eps) { Pwl result; - Map2(pwl0, pwl1, [&](double x, double y0, double y1) { - result.Append(x, f(x, y0, y1), eps); + map2(pwl0, pwl1, [&](double x, double y0, double y1) { + result.append(x, f(x, y0, y1), eps); }); return result; } -void Pwl::MatchDomain(Interval const &domain, bool clip, const double eps) +void Pwl::matchDomain(Interval const &domain, bool clip, const double eps) { int span = 0; - Prepend(domain.start, Eval(clip ? points_[0].x : domain.start, &span), + prepend(domain.start, eval(clip ? points_[0].x : domain.start, &span), eps); span = points_.size() - 2; - Append(domain.end, Eval(clip ? points_.back().x : domain.end, &span), + append(domain.end, eval(clip ? points_.back().x : domain.end, &span), eps); } @@ -237,7 +237,7 @@ Pwl &Pwl::operator*=(double d) return *this; } -void Pwl::Debug(FILE *fp) const +void Pwl::debug(FILE *fp) const { fprintf(fp, "Pwl {\n"); for (auto &p : points_) diff --git a/src/ipa/raspberrypi/controller/pwl.hpp b/src/ipa/raspberrypi/controller/pwl.hpp index 484672f64095..4a38d1df5a33 100644 --- a/src/ipa/raspberrypi/controller/pwl.hpp +++ b/src/ipa/raspberrypi/controller/pwl.hpp @@ -17,24 +17,26 @@ class Pwl { public: struct Interval { - Interval(double _start, double _end) : start(_start), end(_end) + Interval(double _start, double _end) + : start(_start), end(_end) { } double start, end; - bool Contains(double value) + bool contains(double value) { return value >= start && value <= end; } - double Clip(double value) + double clip(double value) { return value < start ? start : (value > end ? end : value); } - double Len() const { return end - start; } + double len() const { return end - start; } }; struct Point { Point() : x(0), y(0) {} - Point(double _x, double _y) : x(_x), y(_y) {} + Point(double _x, double _y) + : x(_x), y(_y) {} double x, y; Point operator-(Point const &p) const { @@ -50,23 +52,23 @@ public: } Point operator*(double f) const { return Point(x * f, y * f); } Point operator/(double f) const { return Point(x / f, y / f); } - double Len2() const { return x * x + y * y; } - double Len() const { return sqrt(Len2()); } + double len2() const { return x * x + y * y; } + double len() const { return sqrt(len2()); } }; Pwl() {} Pwl(std::vector<Point> const &points) : points_(points) {} - void Read(boost::property_tree::ptree const ¶ms); - void Append(double x, double y, const double eps = 1e-6); - void Prepend(double x, double y, const double eps = 1e-6); - Interval Domain() const; - Interval Range() const; - bool Empty() const; + void read(boost::property_tree::ptree const ¶ms); + void append(double x, double y, const double eps = 1e-6); + void prepend(double x, double y, const double eps = 1e-6); + Interval domain() const; + Interval range() const; + bool empty() const; // Evaluate Pwl, optionally supplying an initial guess for the // "span". The "span" may be optionally be updated. If you want to know // the "span" value but don't have an initial guess you can set it to // -1. - double Eval(double x, int *span_ptr = nullptr, - bool update_span = true) const; + double eval(double x, int *spanPtr = nullptr, + bool updateSpan = true) const; // Find perpendicular closest to xy, starting from span+1 so you can // call it repeatedly to check for multiple closest points (set span to // -1 on the first call). Also returns "pseudo" perpendiculars; see @@ -78,31 +80,31 @@ public: Vertex, // vertex of Pwl is closest point Perpendicular // true perpendicular found }; - PerpType Invert(Point const &xy, Point &perp, int &span, + PerpType invert(Point const &xy, Point &perp, int &span, const double eps = 1e-6) const; // Compute the inverse function. Indicate if it is a proper (true) // inverse, or only a best effort (e.g. input was non-monotonic). - Pwl Inverse(bool *true_inverse = nullptr, const double eps = 1e-6) const; + Pwl inverse(bool *trueInverse = nullptr, const double eps = 1e-6) const; // Compose two Pwls together, doing "this" first and "other" after. - Pwl Compose(Pwl const &other, const double eps = 1e-6) const; + Pwl compose(Pwl const &other, const double eps = 1e-6) const; // Apply function to (x,y) values at every control point. - void Map(std::function<void(double x, double y)> f) const; + void map(std::function<void(double x, double y)> f) const; // Apply function to (x, y0, y1) values wherever either Pwl has a // control point. - static void Map2(Pwl const &pwl0, Pwl const &pwl1, + static void map2(Pwl const &pwl0, Pwl const &pwl1, std::function<void(double x, double y0, double y1)> f); // Combine two Pwls, meaning we create a new Pwl where the y values are // given by running f wherever either has a knot. static Pwl - Combine(Pwl const &pwl0, Pwl const &pwl1, + combine(Pwl const &pwl0, Pwl const &pwl1, std::function<double(double x, double y0, double y1)> f, const double eps = 1e-6); // Make "this" match (at least) the given domain. Any extension my be // clipped or linear. - void MatchDomain(Interval const &domain, bool clip = true, + void matchDomain(Interval const &domain, bool clip = true, const double eps = 1e-6); Pwl &operator*=(double d); - void Debug(FILE *fp = stdout) const; + void debug(FILE *fp = stdout) const; private: int findSpan(double x, int span) const;