From patchwork Mon Jul 25 13:46:30 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Naushir Patuck X-Patchwork-Id: 16759 Return-Path: X-Original-To: parsemail@patchwork.libcamera.org Delivered-To: parsemail@patchwork.libcamera.org Received: from lancelot.ideasonboard.com (lancelot.ideasonboard.com [92.243.16.209]) by patchwork.libcamera.org (Postfix) with ESMTPS id 8B85AC3275 for ; Mon, 25 Jul 2022 13:46:55 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id 1A92A6332B; Mon, 25 Jul 2022 15:46:55 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=libcamera.org; s=mail; t=1658756815; bh=/oA+UY64Sa9X7XAWhKJ7I25jxVmbsbpb107r6ZDRD3k=; h=To:Date:In-Reply-To:References:Subject:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To: From; b=CChl/EdZqKYmfCYZR4FKoT/SvFiavSHAiqVtQ7SQh2GMzbpcLJsAMM3rahanGuHsD 580r0IXcBuv9f4jifmf2wuiWSuwWu9S/t0NmvY5FoiIAzcTAAi1yw/olJA4eoXuWDz s76+17bzUZHTiuGNXTC6ka0HPzVspKVdDeXP5RAtA+7l2pWFQ4EYUI41B0EnVC/TAy Ge1O63h3WgJKuOvBfRf70XbTblYEqY0WiqMiRG7s8KzvcPN6SsS31cr//rDR2ODhZ5 8wzMdPekwuxkF5FfawFUbi4fX8jCe69yGaY6/8I5nBj6dGm2eVOoFHCoeQYBKHtAtV lhSCEXv+wAmqA== Received: from mail-wr1-x431.google.com (mail-wr1-x431.google.com [IPv6:2a00:1450:4864:20::431]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id CC5B96331B for ; Mon, 25 Jul 2022 15:46:48 +0200 (CEST) Authentication-Results: lancelot.ideasonboard.com; dkim=pass (2048-bit key; unprotected) header.d=raspberrypi.com header.i=@raspberrypi.com header.b="UOEMysRw"; dkim-atps=neutral Received: by mail-wr1-x431.google.com with SMTP id l15so11988001wro.11 for ; Mon, 25 Jul 2022 06:46:48 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=raspberrypi.com; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=DB7D9SSxcToRx5QeYvvjUf+X9BM1Rn5YTfNtB3cDrDM=; b=UOEMysRwcG+6SQLKa3f1DJiGh9PcfmS4rvr63c6gxBG5c0j6A9QR4fqRdfQjlpaFb4 Cqh5IkAjNh8RW51vFJBRnWMaFmbVNHUv7EyEq4ruExYtBz3rM2eWAFeviC6R6KrgrN8f WlBJqSeQLT+JAwF5V7tL1Pf2u4alp7EqvM8eEXkMAizAr38TkaHSPVmt+MrnkI2ia/4R 8Ua91kmNAaV7mce3YnJ1GRlgqNB3PSi4A2hkGAm/Bd0ulZ2fGk21rcvvj5mXrEwUPetH K7Gb8RDYJVM7fvyreu2Rd4yoWa5XO/NtWBrdJ3xsm1KSlb1rq+L57YYtY7/hBEfeVNL7 itLg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=DB7D9SSxcToRx5QeYvvjUf+X9BM1Rn5YTfNtB3cDrDM=; b=h/vLpxn+OUoLhGDGrYff+ZTEyK9l9oYemv4o5XX91JcRtv7NE99k1a7A8cZeFNsqd3 ZQE6gnyG9gS60anvPkTAt6fdaJqtGyRrlTWx9qeM9cOuXILP0JpOXyy6GG6d14JQoFsg J8pTwlkTzLCNY1+TKYgSUZ493j/n50qqDKM69lITgTJXy0QdTtbsJ+kTAo8tKgu0xpuK ZO1w2HAa3Eo+3tqJAeOuZwIhjQDEukJoB5ybZ2QZzelyray0PFSkss7d3LhBWo0zl8D9 MyISdsxDyr/IsoExUDzWkDm/jirB7wy8vGEGQcM6Av+RSLkRdr+hGVxsyHDXd6ABNFe4 kHtg== X-Gm-Message-State: AJIora+s+pvvhumPCkJsjGatILAUQZDAIQNN4jhDHrpm1jesQUCPzpzE C3N+IoCG7eOZP3UdpBy9APzxlW5VYpSEAw== X-Google-Smtp-Source: AGRyM1t4zSOISeK5xq99wFOdxXZJvGaErQEBoSAZPkblSFHX+FHnqW7Q90+iKJ7QCuj2eVvDruAPsw== X-Received: by 2002:a05:6000:15ce:b0:21e:80b4:afda with SMTP id y14-20020a05600015ce00b0021e80b4afdamr5323627wry.85.1658756807824; Mon, 25 Jul 2022 06:46:47 -0700 (PDT) Received: from naush-laptop.localdomain ([93.93.133.154]) by smtp.gmail.com with ESMTPSA id a20-20020a05600c225400b003a32167b8d4sm18054320wmm.13.2022.07.25.06.46.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 25 Jul 2022 06:46:47 -0700 (PDT) To: libcamera-devel@lists.libcamera.org Date: Mon, 25 Jul 2022 14:46:30 +0100 Message-Id: <20220725134639.4572-7-naush@raspberrypi.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220725134639.4572-1-naush@raspberrypi.com> References: <20220725134639.4572-1-naush@raspberrypi.com> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH 06/15] DNI: ipa: raspberrypi: Code refactoring to match style guidelines X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Naushir Patuck via libcamera-devel From: Naushir Patuck Reply-To: Naushir Patuck Errors-To: libcamera-devel-bounces@lists.libcamera.org Sender: "libcamera-devel" 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 Signed-off-by: Naushir Patuck Reviewed-by: Laurent Pinchart --- 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 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 - 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 - 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 - 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 - 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(); @@ -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_) 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 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 f) const; + void map(std::function 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 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 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;