toJson()

void fl::ScreenMap::toJson ( const fl::flat_map< string, ScreenMap > & segmentMaps, fl::json * doc )

static

Definition at line 438 of file screenmap.cpp.hpp.

                                    {
 
#if FASTLED_NO_JSON
    FL_WARN("ScreenMap::toJson called with FASTLED_NO_JSON");
    return;
#else
    if (!doc) {
        FL_WARN("ScreenMap::toJson called with nullptr doc");
        return;
    }
 
    // Emits the v2 screenmap shape (issue ledmapper#143):
    //   { "version": 2,
    //     "groups": { "<name>": { "color": "#hex" } },
    //     "segments": [ { "id": "<name>", "group": "<name>",
    //                     "x": [...], "y": [...], "diameter": ... } ] }
    //
    // `pin` is part of the v2 shape but is not emitted here -- see the note
    // at the segment object below. Writing the example value from a comment
    // as data is how it came to be there.
    // Bilingual readers (`ScreenMap::ParseJson`, ledmapper) accept both v1
    // and v2, so any existing on-disk v1 JSON keeps loading. v1 emission
    // is no longer supported.
    *doc = fl::json::object();
 
    fl::json groupsObj = fl::json::object();
    fl::json segmentsArr = fl::json::array();
 
    // Distinct palette so each strip lights up differently in the editor
    // preview without the user having to pick a colour. Cycle on overflow.
    static const char *const kPalette[] = {
        "#3b82f6", "#10b981", "#f59e0b", "#ef4444",
        "#a855f7", "#06b6d4", "#ec4899", "#84cc16",
    };
    constexpr size_t kPaletteSize = sizeof(kPalette) / sizeof(kPalette[0]);
 
    size_t idx = 0;
    for (const auto& kv : segmentMaps) {
        if (kv.second.getLength() == 0) {
            FL_WARN("ScreenMap::toJson called with empty segment: %s", fl::string(kv.first));
            continue;
        }
 
        const auto& name = kv.first;
        const auto& segment = kv.second;
        const float diameter = segment.getDiameter();
 
        fl::json xArray = fl::json::array();
        for (u16 i = 0; i < segment.getLength(); i++) {
            xArray.push_back(fl::json(segment[i].x));
        }
        fl::json yArray = fl::json::array();
        for (u16 i = 0; i < segment.getLength(); i++) {
            yArray.push_back(fl::json(segment[i].y));
        }
 
        fl::json groupObj = fl::json::object();
        groupObj.set("color", fl::json(fl::string(kPalette[idx % kPaletteSize])));
        groupsObj.set(name, groupObj);
 
        fl::json segmentObj = fl::json::object();
        segmentObj.set("id", fl::json(fl::string(name)));
        // No `pin`. The v2 shape carries one and the parser above drops it --
        // it is wiring metadata with nowhere to live on this side -- so there
        // is nothing here to write. What used to be written was the literal
        // `"pin1"` from the shape example in the comment above, copied into
        // the emitter as data.
        //
        // That is worse than omitting it, because it is wrong rather than
        // absent. A three-segment file wired to pin1/pin2/pin3 came back with
        // all three on pin1, and a numeric `"pin": 7` came back as the string
        // `"pin1"`. A consumer reading that mis-wires a strip and has no way
        // to tell; a consumer reading a missing optional key can see that it
        // is missing.
        //
        // Carrying the value through instead is FastLED #3322, which needs
        // somewhere on `ScreenMap` to put it and a decision about the
        // `<int|str>` union. Until then this loses the field visibly rather
        // than rewriting it silently.
        segmentObj.set("group", fl::json(fl::string(name)));
        segmentObj.set("x", xArray);
        segmentObj.set("y", yArray);
        // Only when there is one. `mDiameter` defaults to -1 as a sentinel
        // meaning "unset", and writing that out publishes an impossible
        // physical size: no LED is -1 units across. The parser already reads
        // an absent key back as -1 (both the v1 and v2 paths default it), so
        // omitting round-trips to exactly the same value inside FastLED and
        // stops a consumer from having to know the sentinel.
        //
        // The field's own comment in screenmap.h asked for this and had the
        // sense inverted -- "Only serialized if it's not > 0.0f" -- which is
        // presumably how the writer came to do the opposite.
        if (diameter > 0.0f) {
            segmentObj.set("diameter", fl::json(diameter));
        }
        segmentsArr.push_back(segmentObj);
 
        idx++;
    }
 
    doc->set("version", fl::json(i64(2)));
    doc->set("groups", groupsObj);
    doc->set("segments", segmentsArr);
 
    fl::string debugStr = doc->to_string();
    FL_WARN("ScreenMap::toJson generated JSON: %s", debugStr);
#endif
}

References fl::json::array(), FL_WARN, fl::json::object(), fl::json::push_back(), fl::json::set(), fl::json::to_string(), fl::x, and fl::y.

Referenced by toJsonStr().

Here is the call graph for this function:

Here is the caller graph for this function: