SmartRange.hh 15.2 KB
Newer Older
Max Lyon's avatar
Max Lyon committed
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
/* ========================================================================= *
 *                                                                           *
 *                               OpenMesh                                    *
 *           Copyright (c) 2001-2019, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openmesh.org                               *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenMesh.                                            *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
 *                                                                           *
 * ========================================================================= */


#pragma once

#include <utility>
Max Lyon's avatar
Max Lyon committed
46 47
#include <array>
#include <vector>
48
#include <set>
Max Lyon's avatar
Max Lyon committed
49 50 51 52 53 54 55 56 57

//== NAMESPACES ===============================================================

namespace OpenMesh {

//== FORWARD DECLARATION ======================================================

//== CLASS DEFINITION =========================================================

Max Lyon's avatar
Max Lyon committed
58 59 60 61 62 63 64 65 66 67
namespace  {

struct Identity
{
  template <typename T>
  T operator()(const T& _t) const { return _t; }
};

}

Max Lyon's avatar
Max Lyon committed
68 69 70
template <typename RangeT, typename HandleT, typename Functor>
struct FilteredSmartRangeT;

Max Lyon's avatar
Max Lyon committed
71 72 73 74
/// Base class for all smart range types
template <typename RangeT, typename HandleT>
struct SmartRangeT
{
Max Lyon's avatar
Max Lyon committed
75 76 77 78
  using Handle = HandleT;
  using SmartRange = SmartRangeT<RangeT, HandleT>;
  using Range = RangeT;

Max Lyon's avatar
Max Lyon committed
79 80
  // TODO: Someone with better c++ knowledge may improve the code below.

Max Lyon's avatar
Max Lyon committed
81 82 83 84 85 86
  /** @brief Computes the sum of elements.
   *
   * Computes the sum of all elements in the range after applying the functor \p f.
   *
   *  @param f Functor that is applied to all elements before computing the sum
   */
Max Lyon's avatar
Max Lyon committed
87
  template <typename Functor>
88
  auto sum(Functor&& f) -> typename std::decay<decltype (f(std::declval<HandleT>()))>::type
Max Lyon's avatar
Max Lyon committed
89 90 91 92 93
  {
    auto range = static_cast<const RangeT*>(this);
    auto begin = range->begin();
    auto end   = range->end();
    assert(begin != end);
94
    typename std::decay<decltype (f(*begin))>::type result = f(*begin);
Max Lyon's avatar
Max Lyon committed
95 96 97
    auto it = begin;
    ++it;
    for (; it != end; ++it)
98 99
        result += f(*it);
    return result;
Max Lyon's avatar
Max Lyon committed
100 101
  }

Max Lyon's avatar
Max Lyon committed
102 103 104 105 106 107
  /** @brief Computes the average of elements.
   *
   * Computes the average of all elements in the range after applying the functor \p f.
   *
   *  @param f Functor that is applied to all elements before computing the average.
   */
108
  template <typename Functor>
109
  auto avg(Functor&& f) -> typename std::decay<decltype (f(std::declval<HandleT>()))>::type
110 111 112 113 114
  {
    auto range = static_cast<const RangeT*>(this);
    auto begin = range->begin();
    auto end   = range->end();
    assert(begin != end);
115
    typename std::decay<decltype (f(*begin))>::type result = f(*begin);
116 117 118 119 120
    auto it = begin;
    ++it;
    int n_elements = 1;
    for (; it != end; ++it)
    {
121
        result += f(*it);
122 123
      ++n_elements;
    }
124
    return (1.0 / n_elements) * result;
125 126
  }

127 128 129 130 131 132 133
  /** @brief Check if any element fulfils condition.
  *
  * Checks if functor \p f returns true for any of the elements in the range.
  * Returns true if that is the case, false otherwise.
  *
  *  @param f Functor that is evaluated for all elements.
  */
134 135 136 137 138 139 140 141 142 143
  template <typename Functor>
  auto any_of(Functor&& f) -> bool
  {
    auto range = static_cast<const RangeT*>(this);
    for (auto e : *range)
      if (f(e))
        return true;
    return false;
  }

144 145 146 147 148 149 150
  /** @brief Check if all elements fulfil condition.
  *
  * Checks if functor \p f returns true for all of the elements in the range.
  * Returns true if that is the case, false otherwise.
  *
  *  @param f Functor that is evaluated for all elements.
  */
151 152 153 154 155 156 157 158 159 160
  template <typename Functor>
  auto all_of(Functor&& f) -> bool
  {
    auto range = static_cast<const RangeT*>(this);
    for (auto e : *range)
      if (!f(e))
        return false;
    return true;
  }

Max Lyon's avatar
Max Lyon committed
161 162 163 164 165 166 167 168 169
  /** @brief Convert range to array.
  *
  * Converts the range of elements into an array of objects returned by functor \p f.
  * The size of the array needs to be provided by the user. If the size is larger than the number of
  * elements in the range, the remaining entries of the array will be uninitialized.
  *
  *  @param f Functor that is applied to all elements before putting them into the array. If no functor is provided
  *           the array will contain the handles.
  */
Max Lyon's avatar
Max Lyon committed
170
  template <int n, typename Functor = Identity>
171
  auto to_array(Functor&& f = {}) -> std::array<typename std::decay<decltype (f(std::declval<HandleT>()))>::type, n>
Max Lyon's avatar
Max Lyon committed
172 173
  {
    auto range = static_cast<const RangeT*>(this);
174
    std::array<typename std::decay<decltype (f(std::declval<HandleT>()))>::type, n> res;
Max Lyon's avatar
Max Lyon committed
175 176 177 178 179 180 181 182
    auto it = range->begin();
    auto end = range->end();
    int i = 0;
    while (i < n && it != end)
      res[i++] = f(*(it++));
    return res;
  }

Max Lyon's avatar
Max Lyon committed
183 184 185 186 187 188 189
  /** @brief Convert range to vector.
  *
  * Converts the range of elements into a vector of objects returned by functor \p f.
  *
  *  @param f Functor that is applied to all elements before putting them into the vector. If no functor is provided
  *           the vector will contain the handles.
  */
Max Lyon's avatar
Max Lyon committed
190
  template <typename Functor = Identity>
191
  auto to_vector(Functor&& f = {}) -> std::vector<typename std::decay<decltype (f(std::declval<HandleT>()))>::type>
Max Lyon's avatar
Max Lyon committed
192 193
  {
    auto range = static_cast<const RangeT*>(this);
194
    std::vector<typename std::decay<decltype (f(std::declval<HandleT>()))>::type> res;
Max Lyon's avatar
Max Lyon committed
195
    for (const auto& e : *range)
Max Lyon's avatar
Max Lyon committed
196 197 198 199
      res.push_back(f(e));
    return res;
  }

200 201 202 203 204 205 206 207
  /** @brief Convert range to set.
  *
  * Converts the range of elements into a set of objects returned by functor \p f.
  *
  *  @param f Functor that is applied to all elements before putting them into the set. If no functor is provided
  *           the set will contain the handles.
  */
  template <typename Functor = Identity>
208
  auto to_set(Functor&& f = {}) -> std::set<typename std::decay<decltype (f(std::declval<HandleT>()))>::type>
209 210
  {
    auto range = static_cast<const RangeT*>(this);
211
    std::set<typename std::decay<decltype (f(std::declval<HandleT>()))>::type> res;
212 213 214 215 216
    for (const auto& e : *range)
      res.insert(f(e));
    return res;
  }

217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
  /** @brief Get the first element that fulfills a condition.
  *
  * Finds the first element of the range for which the functor \p f evaluates to true.
  * Returns an invalid handle if none evaluates to true
  *
  *  @param f Functor that is applied to all elements before putting them into the set. If no functor is provided
  *           the set will contain the handles.
  */
  template <typename Functor>
  auto first(Functor&& f = {}) -> HandleT
  {
    auto range = static_cast<const RangeT*>(this);
    for (const auto& e : *range)
      if (f(e))
        return e;
    return HandleT();
  }

Max Lyon's avatar
Max Lyon committed
235 236 237 238 239 240
  /** @brief Compute minimum.
  *
  * Computes the minimum of all objects returned by functor \p f.
  *
  *  @param f Functor that is applied to all elements before computing minimum.
  */
241
  template <typename Functor>
242
  auto min(Functor&& f) -> typename std::decay<decltype (f(std::declval<HandleT>()))>::type
Max Lyon's avatar
Max Lyon committed
243
  {
244 245
    using std::min;

Max Lyon's avatar
Max Lyon committed
246 247 248 249 250
    auto range = static_cast<const RangeT*>(this);
    auto it    = range->begin();
    auto end   = range->end();
    assert(it != end);

251
    typename std::decay<decltype (f(std::declval<HandleT>()))>::type res = f(*it);
Max Lyon's avatar
Max Lyon committed
252 253 254
    ++it;

    for (; it != end; ++it)
255
      res = min(res, f(*it));
Max Lyon's avatar
Max Lyon committed
256

257
    return res;
Max Lyon's avatar
Max Lyon committed
258 259
  }

260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
  /** @brief Compute minimal element.
  *
  * Computes the element that minimizes \p f.
  *
  *  @param f Functor that is applied to all elements before comparing.
  */
  template <typename Functor>
  auto argmin(Functor&& f) -> HandleT
  {
    auto range = static_cast<const RangeT*>(this);
    auto it    = range->begin();
    auto min_it = it;
    auto end   = range->end();
    assert(it != end);

    typename std::decay<decltype (f(std::declval<HandleT>()))>::type curr_min = f(*it);
    ++it;

    for (; it != end; ++it)
    {
      auto val = f(*it);
      if (val < curr_min)
      {
        curr_min = val;
        min_it = it;
      }
    }

    return *min_it;
  }

Max Lyon's avatar
Max Lyon committed
291 292 293 294 295 296
  /** @brief Compute maximum.
  *
  * Computes the maximum of all objects returned by functor \p f.
  *
  *  @param f Functor that is applied to all elements before computing maximum.
  */
297
  template <typename Functor>
298
  auto max(Functor&& f) -> typename std::decay<decltype (f(std::declval<HandleT>()))>::type
Max Lyon's avatar
Max Lyon committed
299
  {
300 301
    using std::max;

Max Lyon's avatar
Max Lyon committed
302 303 304 305 306
    auto range = static_cast<const RangeT*>(this);
    auto it    = range->begin();
    auto end   = range->end();
    assert(it != end);

307
    typename std::decay<decltype (f(std::declval<HandleT>()))>::type res = f(*it);
Max Lyon's avatar
Max Lyon committed
308 309 310
    ++it;

    for (; it != end; ++it)
311
      res = max(res, f(*it));
Max Lyon's avatar
Max Lyon committed
312

313 314 315
    return res;
  }

316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347

  /** @brief Compute maximal element.
  *
  * Computes the element that maximizes \p f.
  *
  *  @param f Functor that is applied to all elements before comparing.
  */
  template <typename Functor>
  auto argmax(Functor&& f) -> HandleT
  {
    auto range = static_cast<const RangeT*>(this);
    auto it    = range->begin();
    auto max_it = it;
    auto end   = range->end();
    assert(it != end);

    typename std::decay<decltype (f(std::declval<HandleT>()))>::type curr_max = f(*it);
    ++it;

    for (; it != end; ++it)
    {
      auto val = f(*it);
      if (val > curr_max)
      {
        curr_max = val;
        max_it = it;
      }
    }

    return *max_it;
  }

Max Lyon's avatar
Max Lyon committed
348 349 350 351 352 353 354
  /** @brief Computes minimum and maximum.
  *
  * Computes the minimum and maximum of all objects returned by functor \p f. Result is returned as std::pair
  * containing minimum as first and maximum as second element.
  *
  *  @param f Functor that is applied to all elements before computing maximum.
  */
355
  template <typename Functor>
356 357
  auto minmax(Functor&& f) -> std::pair<typename std::decay<decltype (f(std::declval<HandleT>()))>::type,
                                        typename std::decay<decltype (f(std::declval<HandleT>()))>::type>
358 359
  {
    return std::make_pair(this->min(f), this->max(f));
Max Lyon's avatar
Max Lyon committed
360 361 362
  }


363 364 365 366 367 368
  /** @brief Compute number of elements that satisfy a given predicate.
  *
  * Computes the numer of elements which satisfy functor \p f.
  *
  *  @param f Predicate that elements have to satisfy in order to be counted.
  */
Max Lyon's avatar
Max Lyon committed
369 370 371 372 373 374 375 376 377 378
  template <typename Functor>
  auto count_if(Functor&& f) -> int
  {
    int count = 0;
    auto range = static_cast<const RangeT*>(this);
    for (const auto& e : *range)
      if (f(e))
        ++count;
    return count;
  }
379 380


Max Lyon's avatar
Max Lyon committed
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395
  /** @brief Apply a functor to each element.
  *
  * Calls functor \p f with each element as parameter
  *
  *  @param f Functor that is called for each element.
  */
  template <typename Functor>
  auto for_each(Functor&& f) -> void
  {
    auto range = static_cast<const RangeT*>(this);
    for (const auto& e : *range)
      f(e);
  }


Max Lyon's avatar
Max Lyon committed
396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452
  /** @brief Only iterate over a subset of elements
   *
   * Returns a smart range which skips all elements that do not satisfy functor \p f
   *
   * @param f Functor that needs to be evaluated to true if the element should not be skipped.
   */
  template <typename Functor>
  auto filtered(Functor&& f) -> FilteredSmartRangeT<SmartRange, Handle, typename std::decay<Functor>::type>
  {
    auto range = static_cast<const RangeT*>(this);
    auto b = (*range).begin();
    auto e = (*range).end();
    return FilteredSmartRangeT<SmartRange, Handle, typename std::decay<Functor>::type>(f, b, e);
  }

};


/// Class which applies a filter when iterating over elements
template <typename RangeT, typename HandleT, typename Functor>
struct FilteredSmartRangeT : public SmartRangeT<FilteredSmartRangeT<RangeT, HandleT, Functor>, HandleT>
{
  using BaseRange = SmartRangeT<FilteredSmartRangeT<RangeT, HandleT, Functor>, HandleT>;
  using BaseIterator = decltype((std::declval<typename RangeT::Range>().begin()));

  struct FilteredIterator : public BaseIterator
  {

    FilteredIterator(Functor f, BaseIterator it, BaseIterator end): BaseIterator(it), f_(f), end_(end)
    {
      if (!f_(*(*this))) // if start is not valid go to first valid one
        operator++();
    }

    FilteredIterator& operator++()
    {
      if (BaseIterator::operator==(end_)) // don't go past end
        return *this;

      // go to next valid one
      do
        BaseIterator::operator++();
      while (BaseIterator::operator!=(end_) && !f_(*(*this)));
      return *this;
    }

    Functor f_;
    BaseIterator end_;
  };

  FilteredSmartRangeT(Functor f, BaseIterator begin, BaseIterator end) : f_(f), begin_(begin), end_(end){}
  FilteredIterator begin() const { return FilteredIterator(f_, begin_, end_); }
  FilteredIterator end()   const { return FilteredIterator(f_, end_, end_); }

  Functor f_;
  BaseIterator begin_;
  BaseIterator end_;
Max Lyon's avatar
Max Lyon committed
453 454 455 456 457 458 459 460 461
};



//=============================================================================
} // namespace OpenMesh
//=============================================================================

//=============================================================================