parseV2SegmentArray()

static bool fl::parseV2SegmentArray ( const fl::json & segmentsArr, fl::flat_map< string, ScreenMap > * segmentMaps, string * err )

static

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

                                                          {
    if (!segmentsArr.has_value() || !segmentsArr.is_array()) {
        *err = "v2 'segments' is not an array";
        return false;
    }
 
    auto arrPtr = segmentsArr.as_array();
    if (!arrPtr) {
        *err = "v2 'segments' array could not be read";
        return false;
    }
 
    for (const auto& elem : *arrPtr) {
        if (!elem) {
            *err = "v2 segment is null";
            return false;
        }
        fl::json segVal(elem);
        if (!segVal.has_value() || !segVal.is_object()) {
            *err = "v2 segment is not an object";
            return false;
        }
 
        // Required: id
        if (!segVal.contains("id") || !segVal["id"].has_value()) {
            *err = "v2 segment missing 'id'";
            return false;
        }
        auto idOpt = segVal["id"].as_string();
        if (!idOpt) {
            *err = "v2 segment 'id' is not a string";
            return false;
        }
        string id = *idOpt;
 
        // Required: x
        if (!segVal.contains("x") || !segVal["x"].has_value() || !segVal["x"].is_array()) {
            *err = "v2 segment '" + id + "' missing or invalid 'x' array";
            return false;
        }
        fl::vector<float> x_array = jsonArrayToFloatVector(segVal["x"]);
 
        // Required: y
        if (!segVal.contains("y") || !segVal["y"].has_value() || !segVal["y"].is_array()) {
            *err = "v2 segment '" + id + "' missing or invalid 'y' array";
            return false;
        }
        fl::vector<float> y_array = jsonArrayToFloatVector(segVal["y"]);
 
        string type = "led_strip";
        if (segVal.contains("type") && segVal["type"].has_value()) {
            auto typeOpt = segVal["type"].as_string();
            if (!typeOpt) { *err = "v2 segment '" + id + "' has invalid 'type'"; return false; }
            type = *typeOpt;
        }
        const bool isWire = type == "el_wire";
        const bool isPanel = type == "el_panel";
        if (type != "led_strip" && !isWire && !isPanel) {
            *err = "v2 segment '" + id + "' has unsupported type '" + type + "'";
            return false;
        }
        if (x_array.size() != y_array.size()) {
            *err = "v2 segment '" + id + "' has mismatched x/y lengths";
            return false;
        }
        const size_t minVertices = isWire ? 2 : isPanel ? 3 : 0;
        if ((isWire || isPanel) && x_array.size() < minVertices) {
            *err = "v2 segment '" + id + "' has too few vertices";
            return false;
        }
        float thickness = 0.0f;
        if (isWire) {
            if (!segVal.contains("thickness") || !segVal["thickness"].has_value()) {
                *err = "v2 el_wire segment '" + id + "' missing thickness";
                return false;
            }
            auto thicknessOpt = segVal["thickness"].as_float();
            if (!thicknessOpt || *thicknessOpt <= 0.0f) {
                *err = "v2 el_wire segment '" + id + "' requires positive thickness";
                return false;
            }
            thickness = static_cast<float>(*thicknessOpt);
        } else if (segVal.contains("thickness")) {
            *err = "v2 segment '" + id + "' thickness is only valid for el_wire";
            return false;
        }
 
        // Optional: diameter (not in canonical v2 but accepted as a backward-compat
        // hint when present; otherwise the per-group `diameter` could be wired here
        // in a future iteration).
        float diameter = -1.0f;
        if (segVal.contains("diameter") && segVal["diameter"].has_value()) {
            auto diameterOpt = segVal["diameter"].as_float();
            if (diameterOpt) {
                diameter = static_cast<float>(*diameterOpt);
            }
        }
 
        auto n = fl::min(x_array.size(), y_array.size());
        ScreenMap segment_map(isWire || isPanel ? 1 : static_cast<u32>(n), diameter);
        if (isWire || isPanel) {
            fl::vector<vec2f> vertices;
            vertices.reserve(n);
            for (size_t i = 0; i < n; i++) vertices.push_back({x_array[i], y_array[i]});
            segment_map.setShape(0, isWire ? ScreenMap::Shape::EL_WIRE : ScreenMap::Shape::EL_PANEL, vertices.data(), static_cast<u32>(n), thickness);
        }
        if (!isWire && !isPanel) {
            for (size_t i = 0; i < n; i++) {
                segment_map.set(static_cast<u16>(i), vec2f{x_array[i], y_array[i]});
            }
        }
        (*segmentMaps)[id] = fl::move(segment_map);
    }
    return true;
}

References fl::json::as_float(), fl::json::as_string(), fl::json::contains(), fl::vector< T >::data(), fl::ScreenMap::Shape::EL_PANEL, fl::ScreenMap::Shape::EL_WIRE, FL_NO_EXCEPT, fl::json::has_value(), fl::json::is_array(), fl::json::is_object(), jsonArrayToFloatVector(), min(), move(), fl::vector< T >::push_back(), fl::vector< T >::reserve(), fl::ScreenMap::set(), fl::ScreenMap::setShape(), and fl::vector_basic::size().

Referenced by fl::ScreenMap::ParseJson().

Here is the call graph for this function:

Here is the caller graph for this function: