Jsoncpp



  • Hi, ich bin noch Anfänger.
    ich habe eine Jsoncpp Datei und möchte die Euclidische Distanz berechnen bitte wie kann ich das in C++ (Jsoncpp Library) berechnen?
    Die Distanz soll in node_coordinate(x,y) sein.
    void TspLibInstance::readJson(istream& r) {
    Json::Value root;
    int s1;
    int s2;

    r >> root;
    
    name = root.get("name","").asString();
    type = root.get("type","").asString();
    comment = root.get("comment","").asString();
    
    _n = root.get("dimension",0).asInt();
    
    edgeWeightType = root.get("edge_weight_type","").asString();
    edgeWeightFormat = root.get("edge_weight_format","").asString();
    edgeDataFormat = root.get("edge_data_format","").asString();
    nodeCoordType = root.get("node_coord_type","").asString();
    displayDataType = root.get("display_data_type","").asString();
    
    // read edge weights if present
    s1 = root["edge_weights"].size();
    //cout << "edge_weights.size() == " << s1 << endl;
    if (s1 > 0) {
        edgeWeight.clear();
    edgeWeight.resize(s1);
    for (int i=0 ; i<s1 ; i++) {
        s2 = root["edge_weights"][i].size();
        for (int j=0 ; j<s2 ; j++) {
            edgeWeight[i].push_back(root["edge_weights"][i][j].asInt());
        }
    }
    }
    
    // read node coordinates if present
    s1 = root["node_coordinates"].size();
    if (s1 > 0) {
        nodeCoordinates.clear();
    nodeCoordinates.resize(s1);
    for (int i=0 ; i<s1 ; i++) {
        s2 = root["node_coordinates"][i].size();
        for (int j=0 ; j<s2 ; j++) {
            nodeCoordinates[i].push_back(root["node_coordinates"][i][j].asDouble());
        }
    }
    }
    
    // read display data if present
    s1 = root["display_data"].size();
    if (s1 > 0) {
        displayData.clear();
    displayData.resize(s1);
    for (int i=0 ; i<s1 ; i++) {
        s2 = root["display_data"][i].size();
        for (int j=0 ; j<s2 ; j++) {
            displayData[i].push_back(root["display_data"][i][j].asDouble());
        }
    }
    }
    
    // read edge data if present
    s1 = root["edge_data"].size();
    if (s1 > 0) {
        edges.clear();
    for (int i=0 ; i<s1 ; i++) {
        s2 = root["edge_data"][i].size();
    
        assert(s2 == 2);
    
        Edge e;
        e.v = root["edge_data"][i][0].asInt();
        e.w = root["edge_data"][i][1].asInt();
        e.value = 0.0;
        edges.push_back(e);
    }
    }
    
    // bounds
    lb = root.get("lowerbound",-1).asInt64();
    ub = root.get("upperbound",-1).asInt64();
    tourLength = root.get("tourlength",-1).asInt64();
    
    // read solutions
    s1 = root["tour"].size();
    if (s1 > 0) {
        tour.resize(s1);
    for (int i=0 ; i<s1 ; i++) {
        tour[i] = root["tour"][i].asInt();
    }
    }
    

    }



  • @const Distanz zwischen was? Wenn ich den Code richtig interpretiere hast du eine Liste mit Knoten (nodes/vertices) und eine Liste mit Indizes jeweils zweier Knoten, zwischen denen eine Kante (edge) verläuft.

    Ich würde mal vermuten, du willst die Distanzen zwischen den Knoten-Paaren berechnen, die eine Kante haben, ergo die Längen der Kanten berechnen. ist das korrekt?

    Das kannst du direkt in C++ machen, das hat nichts mit der Jsoncpp-Bibliothek zu tun: Hol dir die Koordinaten dieser zwei Knoten und berechne das mit grundlegender Arithmetik, die man in C++ auf double-Werten machen kann.

    Hinweise: Die Quadratwurzel berechnet man mit std::sqrt() aus dem Header <cmath> und die Kante, deren Länge du ermitteln willst, kannst du aus den Knoten Koordinaten mit einfacher Vektor-Arithmetik berechnen:

    Für die Knoten a,bR2a, b \in \mathbb{R}^2, zwischen denen eine Kante verläuft, ist aba - b der Vektor der von bb nach aa und bab - a der Vektor der von aa nach bb läuft. Die Länge eines dieser beiden Vektoren (Pythagoras) ist deine gesuchte Kantenlänge.



  • @Finnegan Distanz für node_coordinate. Das ist ein jsondatei und ich möchte in mein c++ programm zugriff in jsoncpp haben und die distanz berechnen.
    {
    "name" : "att5",
    "comment" : "5 capitals of the US (Padberg/Rinaldi)",
    "type" : "TSP",
    "dimension" : 5,
    "capacity" : 10,
    "edge_weight_type" : "ATT",
    "node_coordinates" : [
    [ 6734, 1453 ],
    [ 2233, 10 ],
    [ 5530, 1424 ],
    [ 401, 841 ],
    [ 3082, 1644 ]
    ]
    }



  • @const Die Distanz zu was? Zu einer anderen node_coordinate oder zum Ursprung ([0, 0])? Ersteres habe ich bereits erklärt, zweiteres ist noch simpler, weil das einfach nur die Länge des Koordinaten-Vektors ist. Für eine Distanz brauche ich zwei Punkte.



  • @Finnegan distanz zu [0,0] in node_coordinates.



  • @Finnegan
    ich habe die node in mein c++ programm geschrieben und die distanz auch. Aber wie kann ich das in mein json Datei zugreifen, um die Datei zu lesen und dort die Distanz zu berechen?
    struct node{
    douvle x,y;

    node(){}
    node(double x, double y){
    this->x =x;
    this->y =y;
    }
    };

    double dist(node u, node v){
    double d = sqrt((u.x -v.x) * (u.x -v.x) + (u.y -v.y) * (u.y-v.y));

    return d;
    }



  • @const Du liest die Koordinaten doch schon in deinem eingangs geposteteten Code in Zeile 37 aus und schreibst sie in einen (vermutlich) std::vector. Bau dir aus denen die Instanzen deines node-struct und ruf damit deine dist-Funktion auf. Wenn du tatsächlich die Distanz zum Ursprung benötigst, dann mach dir noch ne node origin{ 0.0, 0.0 }.


Anmelden zum Antworten