Class ReorderingPixelIteratorAny

src/fl/channels/channel.cpp.hpp:48–115

@brief Encapsulates pixel iterator construction with optional XYMap reordering

/// @brief Encapsulates pixel iterator construction with optional XYMap reordering
class ReorderingPixelIteratorAny {
  private:
    /// @brief Get thread-local buffer for addressing transformation
    /// @return Reference to thread-local CRGB vector (reused across calls)
    static fl::vector<CRGB>& getReorderBufferTLS() {
        return SingletonThreadLocal<fl::vector<CRGB>>::instance();
    }
    fl::optional<PixelController<RGB, 1, 0xFFFFFFFF>> mAddressedController;
    PixelIteratorAny mPixelIterator;

  public:
    /// @brief Construct pixel iterator with optional addressing transformation
    /// @param pixels Source pixel controller
    /// @param addressing Optional XYMap for transformation
    /// @param rgbOrder RGB color order
    /// @param rgbw RGBW settings
    /// @param channelName Channel name for error messages
    ReorderingPixelIteratorAny(
        PixelController<RGB, 1, 0xFFFFFFFF>& pixels,
        const XYMap* addressing,
        EOrder rgbOrder,
        Rgbw rgbw,
        Rgbww rgbww,
        const fl::string& channelName)
        : mPixelIterator(pixels, rgbOrder, rgbw, rgbww) {

        // Apply addressing transformation if configured
        if (addressing) {
            u16 numLeds = pixels.size();
            u16 width = addressing->getWidth();
            u16 height = addressing->getHeight();
            u16 expectedLeds = width * height;

            // Validate that XYMap dimensions match channel LED count
            if (expectedLeds != numLeds) {
                FL_ERROR("Channel '" << channelName << "': XYMap dimensions (" << width << "x" << height
                        << "=" << expectedLeds << ") don't match LED count (" << numLeds
                        << "). Addressing transformation may produce unexpected results.");
            }

            // Cast mData to CRGB array
            const CRGB* pixelArray = (const CRGB*)pixels.mData;

            // Get thread-local buffer (reuses allocation if size unchanged)
            fl::vector<CRGB>& buffer = getReorderBufferTLS();
            buffer.clear();
            buffer.resize(numLeds);

            // Fill buffer by mapping each physical index to its source
            for (u16 physicalIdx = 0; physicalIdx < numLeds; physicalIdx++) {
                u16 x = physicalIdx % width;
                u16 y = physicalIdx / width;
                u16 sourceIdx = addressing->mapToIndex(x, y);
                buffer[physicalIdx] = (sourceIdx < numLeds) ? pixelArray[sourceIdx] : CRGB::Black;
            }

            // Construct PixelController with reordered buffer
            mAddressedController.emplace(