# 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.
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();

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, b \in \mathbb{R}^2$, zwischen denen eine Kante verläuft, ist $a - b$ der Vektor der von $b$ nach $a$ und $b - a$ der Vektor der von $a$ nach $b$ 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 }.