From 177df04d2b7f357ebe41f1a9809ab68b6f948082 Mon Sep 17 00:00:00 2001 From: Naushir Patuck Date: Wed, 27 Jul 2022 09:55:17 +0100 Subject: ipa: raspberrypi: Code refactoring to match style guidelines Refactor all the source files in src/ipa/raspberrypi/ 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 Reviewed-by: Laurent Pinchart Signed-off-by: Laurent Pinchart --- src/ipa/raspberrypi/controller/pwl.cpp | 130 ++++++++++++++++----------------- 1 file changed, 65 insertions(+), 65 deletions(-) (limited to 'src/ipa/raspberrypi/controller/pwl.cpp') diff --git a/src/ipa/raspberrypi/controller/pwl.cpp b/src/ipa/raspberrypi/controller/pwl.cpp index 130c820b..24ff3ea3 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(); @@ -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 f) const +void Pwl::map(std::function 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 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 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_) -- cgit v1.2.1