WeightedComponent.h

Go to the documentation of this file.

/*

             *
            ***
           *****
   *********************       Mercenaries Engineering SARL
     *****************              Copyright (C) 2018
       *************
         *********        http://www.mercenaries-engineering.com
        ***********
       ****     ****
      **           **

*/
#pragma once

#include "Points.h"
#include "SparseBuffer.h"

  namespace maquina
  {

    class WeightedComponent
    {
    public:
      WeightedComponent(
        const Points &inputGeometry,  
        const char *weights_name,     
        float weight,                 
        Shape::Topology topology      
      ) : _weight(weight)
      {
        const Value attribute = inputGeometry.read_attribute(weights_name, topology);
        _indexed = *weights_name != '\0' && SparseBufferConstFloat::can_cast(attribute);
        if(_indexed)
        {
          const SparseBufferConstFloat weights(attribute);
          _indices = weights.read_indices();
          _weights = weights.read_values();
          _size = uint32_t(_indices.size());
        }
        else
        {
          _size = uint32_t(inputGeometry.read_points().size());
        }
      }

      WeightedComponent(
        const Points& inputGeometry,  
        float weight                  
      ) : _weight(weight)
      {
        _indexed = false;
        _size = uint32_t(inputGeometry.read_points().size());
      }

      WeightedComponent(
        const SparseBufferConstFloat& weights, 
        float weight                           
      ) : _weight(weight)
      {
        _indexed = true;
        _indices = weights.read_indices();
        _weights = weights.read_values();
        _size = uint32_t(_indices.size());
      }

      bool has_weights() const
      {
        return _indexed;
      }

      class Iterator
      {
      public:
        Iterator(uint32_t index, const WeightedComponent *wc) : _index(index), _wc(wc) {}

        std::pair<uint32_t, float> operator*() const
        {
          if(_wc->_indexed)
            return {_wc->_indices[_index], _wc->_weights[_index]*_wc->_weight};
          else
            return {_index, _wc->_weight};
        }

        uint32_t index() const
        {
          if(_wc->_indexed)
            return _wc->_indices[_index];
          else
            return _index;
        }

        float weight() const
        {
          if(_wc->_indexed)
            return _wc->_weights[_index]*_wc->_weight;
          else
            return _wc->_weight;
        }

        Iterator &operator++()
        {
          assert(_index < _wc->_size);
          _index++;
          return *this;
        }

        Iterator &operator+(uint32_t d)
        {
          assert(_index+d <= _wc->_size);
          _index += d;
          return *this;
        }

        bool operator!=(const Iterator &o) const
        {
          return _index != o._index;
        }

      private:
        uint32_t _index;
        const WeightedComponent *_wc;
      };

      Iterator begin() const
      {
        return {0, this};
      }

      Iterator end() const
      {
        return {_size, this};
      }

      uint32_t size() const
      {
        return _size;
      }
    private:
      uint32_t _size;
      float _weight;
      bool _indexed;
      gsl::span<const uint32_t> _indices;
      gsl::span<const float> _weights;
    };
  }