corkscrew.h

Go to the documentation of this file.

#pragma once

 
#include "fl/allocator.h"
#include "fl/geometry.h"
#include "fl/math_macros.h"
#include "fl/tile2x2.h"
#include "fl/vector.h"
 
namespace fl {

struct CorkscrewInput {
    float totalHeight = 23.25; // Total height of the corkscrew in centimeters
                               // for 144 densly wrapped up over 19 turns
    float totalAngle = 19.f * 2 * PI; // Default to 19 turns
    float offsetCircumference = 0;    // Optional offset for gap accounting
    uint16_t numLeds = 144;           // Default to dense 144 leds.
    bool invert = false;              // If true, reverse the mapping order
    CorkscrewInput() = default;
    CorkscrewInput(float height, float total_angle, float offset = 0,
                   uint16_t leds = 144, bool invertMapping = false)
        : totalHeight(height), totalAngle(total_angle),
          offsetCircumference(offset), numLeds(leds), invert(invertMapping) {}
};
 
struct CorkscrewOutput {
    uint16_t width = 0;  // Width of cylindrical map (circumference of one turn)
    uint16_t height = 0; // Height of cylindrical map (total vertical segments)
    fl::vector<fl::vec2f, fl::allocator_psram<fl::vec2f>>
        mapping; // Full precision mapping from corkscrew to cylindrical
    CorkscrewOutput() = default;
 
    class iterator {
    public:
        using value_type = vec2f;
        using difference_type = int32_t;
        using pointer = vec2f*;
        using reference = vec2f&;
 
        iterator(CorkscrewOutput* owner, size_t position)
            : owner_(owner), position_(position) {}
 
        vec2f& operator*() const {
            return owner_->mapping[position_];
        }
 
        iterator& operator++() {
            ++position_;
            return *this;
        }
 
        iterator operator++(int) {
            iterator temp = *this;
            ++position_;
            return temp;
        }
 
        bool operator==(const iterator& other) const {
            return position_ == other.position_;
        }
 
        bool operator!=(const iterator& other) const {
            return position_ != other.position_;
        }
 
    private:
        CorkscrewOutput* owner_;
        size_t position_;
    };
 
    iterator begin() {
        return iterator(this, 0);
    }
 
    iterator end() {
        return iterator(this, mapping.size());
    }
    fl::Tile2x2_u8 at(int16_t x, int16_t y) const;
};
 
class Corkscrew {
  public:
    using Input = CorkscrewInput;
    using Output = CorkscrewOutput;
    using iterator = CorkscrewOutput::iterator;
 
    Corkscrew(const Input &input);
    Corkscrew(const Corkscrew &) = default;
 
    vec2f at(uint16_t i) const;
    // This is a splatted pixel. This is will look way better than
    // using at(), because it uses 2x2 neighboor sampling.
    Tile2x2_u8 at_splat(uint16_t i) const;
    size_t size() const;
 
    iterator begin() {
        return mOutput.begin();
    }
 
    iterator end() {
        return mOutput.end();
    }

 
    static CorkscrewOutput generateMap(const Input &input);
 
    Output& access() {
        return mOutput;
    }
 
    const Output& access() const {
        return mOutput;
    }
 
  private:
    Input mInput;            // The input parameters defining the corkscrew
    CorkscrewOutput mOutput; // The resulting cylindrical mapping
};
 
} // namespace fl