bool MonocularManhattanBnb::Compute(const PosedCamera& pcam, const vector<ManhattanEdge> edges[], const MatI& orients) { pc = &pcam; vert_axis = 0; for (int i = 1; i < 3; i++) { if (abs(pc->GetRetinaVpt(i)[1]) > abs(pc->GetRetinaVpt(vert_axis)[1])) { vert_axis = i; } } enumerator.Configure(pcam, vert_axis); evaluator.Configure(pcam, vert_axis); DownsampleOrients(orients, est_orients, makeVector(*gvOrientRes, *gvOrientRes)); soln_score = numeric_limits<int>::min(); hypothesis_count = 0; if (enumerator.Compute(edges, bind(&MonocularManhattanBnb::EvaluateHypothesis, this, _1))) { evaluator.PredictImOrientations(soln, soln_orients); DLOG << "Evaluated " << hypothesis_count << " hypotheses"; return true; } else { return false; } }
void MonocularManhattanBnb::TransferBuilding(const SE3<>& new_pose, double floor_z, MatI& orients) { // Compute scaling (TODO: actually use this) DiagonalMatrix<3> Mscale(makeVector(1.0*orients.Cols()/pc->image_size()[0], 1.0*orients.Rows()/pc->image_size()[1], 1.0)); // Invert the pose const SE3<> orig_inv = pc->pose().inverse(); orients.Fill(vert_axis); for (ManhattanBuilding::ConstCnrIt left_cnr = soln.cnrs.begin(); successor(left_cnr) != soln.cnrs.end(); left_cnr++) { ManhattanBuilding::ConstCnrIt right_cnr = successor(left_cnr); //TITLE("Next corner"); int axis = OtherHorizAxis(left_cnr->right_axis); // Compute vertices in the 3D camera frame Vec3 bl = FloorPoint(left_cnr->right_floor, floor_z); Vec3 br = FloorPoint(right_cnr->left_floor, floor_z); Vec3 tl = CeilPoint(left_cnr->right_ceil, bl); Vec3 tr = CeilPoint(right_cnr->left_ceil, br); if (bl[2] < 0) { bl = -bl; br = -br; tl = -tl; tr = -tr; } // Compute vertices in the 3D global frame Vec3 world_tl = orig_inv * tl; Vec3 world_tr = orig_inv * tr; Vec3 world_bl = orig_inv * bl; Vec3 world_br = orig_inv * br; // Compute the wall corners in the other camera Vec3 ret_tl = new_pose * world_tl; Vec3 ret_tr = new_pose * world_tr; Vec3 ret_bl = new_pose * world_bl; Vec3 ret_br = new_pose * world_br; ClipToFront(ret_tr, ret_tl); ClipToFront(ret_br, ret_bl); // Compute the wall corners in the other image Vec3 im_tl = pc->RetToIm(ret_tl); Vec3 im_tr = pc->RetToIm(ret_tr); Vec3 im_bl = pc->RetToIm(ret_bl); Vec3 im_br = pc->RetToIm(ret_br); // Build the polygon and fill vector<Vec3 > poly; poly.push_back(im_tl); poly.push_back(im_bl); poly.push_back(im_br); poly.push_back(im_tr); FillPolygon(poly, orients, axis); } }
int main( int argc, char** argv ) { Vector a = makeVector(3.0,4.0,5.0); Vector b = makeVector(4.0,6.0,9.0); printVector(a); printf("\n"); printVector(b); printf("\n"); Vector sum; sum = add(a,b); printf("Sum of the Vectors: "); printVector(sum); //prints sum of two vectors printf("\n"); /* Vector difference; difference = diff(a,b); printf("Difference of the Vectors: "); printVector(diff); //prints difference of two vectors printf("\n"); */ Vector crossProd; crossProd = crossProduct(a,b); printf("The cross product of the Vectors: "); printVector(crossProd); //prints the cross product of two vectors printf("\n"); double dotProd = dotProduct(a,b); printf("Dot product of the two vectors: %5.5f ", dotProd); // prints dot product of the two vectors printf("\n"); double magA = magnitude(a); printf("Magnitude of vector 'a': %5.5f ", magA);// prints the magnitude of the vector printf("\n"); double magB = magnitude (b); printf("Magnitude of vector 'b': %5.5f ", magB);// prints the magnitude of the vector printf("\n"); return 0; } // main( int, char** )
void generatePageRanks(std::vector<WebPage*>& pages) { #if DEBUG mergeSort(pages, FileNameComp()); #endif // prevent divide by zero errors if (pages.size() == 0) { return; } // get the matrix Matrix m = makeMatrix(pages); // get the starting vector std::vector<double> v = makeVector(pages.size()); #if DEBUG // debugging output std::cout << "Matrix:" << std::endl; for (size_t x = 0; x < m.mySize; ++ x) { for (size_t y = 0; y < m.mySize; ++ y) { std::cout << m[x][y] << "\t"; } std::cout << std::endl; } std::cout << "Vector:" << std::endl; for (size_t x = 0; x < v.size(); ++ x) { std::cout << v[x] << "\t"; } std::cout << std::endl; #endif // iterate and calculate for (size_t i = 0; i < NUM_ITERATIONS; ++ i) { multiply(m, v); } #if DEBUG std::cout << "Answer:" << std::endl; for (size_t x = 0; x < v.size(); ++ x) { std::cout << v[x] << "\t"; } std::cout << std::endl; #endif // put the values in the pages std::vector<WebPage*>::iterator i = pages.begin(); for (size_t ind = 0; ind < v.size(); ++ ind) { (*i)->setPageRank(v[ind]); ++ i; } }
void BuildingStoryUnassignedSpacesVectorController::onChangeRelationship(const model::ModelObject& modelObject, int index, Handle newHandle, Handle oldHandle) { if (modelObject.optionalCast<model::Space>()){ if (index == OS_SpaceFields::BuildingStoryName){ emit itemIds(makeVector()); } } }
void NameManager::setIfName(id_offset id, std::string new_name) { name_map::iterator it = id_to_inst.find(id); if (it != id_to_inst.end()) { uint32_t string_pos = getStringPosition(it->second->opcode()); it->second->SetInOperand(string_pos, std::move(makeVector(new_name.c_str()))); } }
void SpaceSpaceInfiltrationDesignFlowRateVectorController::onChangeRelationship(const model::ModelObject& modelObject, int index, Handle newHandle, Handle oldHandle) { if (modelObject.optionalCast<model::SpaceInfiltrationDesignFlowRate>()) { if (index == OS_SpaceInfiltration_DesignFlowRateFields::SpaceorSpaceTypeName) { emit itemIds(makeVector()); } } }
void Ploter::plotCorrectedHll(string filename){ ofstream file(filename); string line; int x1, x2; double y1, y2; x1 = 0; y1 = 0; x2 = CARDMAX/STEP-1; y2 = 0; uint64_t hash; uint64_t hash128[2]; vector<double> estimates = makeVector(); int i; vector< vector<double> > tab(CARDMAX/STEP, vector<double>(TESTS)); int ca = 0; for(i = 0; i < TESTS; i ++){ cout << i << endl; Hll hll(14); for(int j = 0; j < CARDMAX; j++){ MurmurHash3_x86_128(&ca, 4, 0, &hash128); ca++; hash = hash128[0]; hll.AddItem64(hash); if(j%STEP == 0){ double count = hll.CountRaw64(); for(int i = 0; i < CARDMAX/STEP-1; i++){ if(estimates[i] <= count && count < estimates[i+1]){ x1 = estimates[i]; y1 = i*STEP; x2 = estimates[i+1]; y2 = (i+1)*STEP; count = interpolation(count, x1, y1, x2, y2); } } //count = interpolation(count, x1, y1, x2, y2); //count = (double)abs(count-j)/j; tab[j/STEP][i]=count; } } } for(int j = 0; j < CARDMAX/STEP; j++){ double sum = 0; for (int k = 0; k < TESTS; k++){ sum= sum + tab[j][k]; } //cout << sum << endl; double median = percentile(tab[j],0.5); double pct01 = percentile(tab[j],0.01); double pct99 = percentile(tab[j],0.99); file << (j*STEP) << "\t" << (double)sum/TESTS << "\t" << (double)median << "\t" << pct01 << "\t" << pct99 << endl; } }
//Left/Right Movement void Camera::strafeCamera(float distance){ Vector vec = makeVector(ViewVector.x-PositionVector.x, ViewVector.y-PositionVector.y, ViewVector.z-PositionVector.z); PositionVector.x = PositionVector.x - vec.z*distance; PositionVector.z = PositionVector.z + vec.x*distance; ViewVector.x = ViewVector.x - vec.z*distance; ViewVector.z = ViewVector.z + vec.x*distance; }
//---------------------------------------------------------- /// @brief _vertexで表される面を三角形分割し、_trisに格納する /// @ref http://javaappletgame.blog34.fc2.com/blog-entry-148.html void CWall::SplitTriangles(){ vector< pair<double,double> > v = _vertex; // コピー _tris.clear(); // _trisの初期化 while( v.size() >= 3 ){ // 原点から最も遠い点を探す int mfar = 0; for(int i=1; i<v.size(); i++){ if( v[mfar].first*v[mfar].first+v[mfar].second*v[mfar].second < v[i].first*v[i].first+v[i].second*v[i].second ) mfar = i; } // 最も遠い点から伸びる2つのベクトルを生成 t_vector v1, v2; v1 = makeVector( v[mfar], v[(mfar+1)%v.size()] ); v2 = makeVector( v[mfar], v[(mfar+v.size()-1)%v.size()] ); // 三角形内部に点があるとき if( IsExistPointInTriangle(v1, v2, v) ){ // 外積の記録 double cr = cross( v1, v2 ); // 見つかるまでループ while(1){ // 1つ横の点を選ぶ mfar = (mfar+1)%v.size(); // ベクトル生成 v1 = makeVector( v[mfar], v[(mfar+1)%v.size()] ); v2 = makeVector( v[mfar], v[(mfar+v.size()-1)%v.size()] ); // 外積の符号が異なる→ループ最初に戻る if( cr*cross(v1,v2) < 0.0 ) continue; // 内部に点があるか確認 // 点がある→ループ最初に戻る if( IsExistPointInTriangle(v1, v2, v) ) continue; // 点がない→脱ループ break; } } // 三角形の3点を_trisに記録 t_triangle t; t.x[0] = v1.sx; t.y[0] = v1.sy; t.x[1] = v1.sx+v1.vx; t.y[1] = v1.sy+v1.vy; t.x[2] = v2.sx+v2.vx; t.y[2] = v2.sy+v2.vy; _tris.push_back(t); // 選ばれた点をvから除外 v.erase( remove( v.begin(), v.end(), v[mfar] ) ); } }
sf::Vector2f Planet::toProjection(sf::Vector2f point, float radius) { float circumference = 2 * PI * radius; float r = sqrt(pow(point.x, 2) + pow(point.y, 2)); float angle = toDegrees(atan2(point.y, point.x)); float r2 = (sqrt(r) * sqrt(circumference / 4)) / (circumference / 4) * radius; sf::Vector2f pos = makeVector(angle, r2, sf::Vector2f(radius, radius)); return pos; }
sf::Vector2f Planet::toPlane(sf::Vector2f point, float radius) { float circumference = 2 * PI * radius; float r = sqrt(pow(point.x, 2) + pow(point.y, 2)); float angle = toDegrees(atan2(point.y, point.x)); float r2 = (pow(r, 2) / radius) / radius * (circumference / 4); sf::Vector2f pos = makeVector(angle, r2, sf::Vector2f(circumference / 4, circumference /4)); return pos; }
void ManhattanBranchAndBound::Configure(const PosedCamera& pcam, int v_axis) { pc = &pcam; // Compute size of a pixel Vec2 a = pc->RetToIm(makeVector(0.0, 0.0)); Vec2 b = pc->RetToIm(makeVector(1.0, 1.0)); px_diam = 1 / norm(a-b); // Cache the vanishing points for efficiency for (int i = 0; i < 3; i++) { vpts[i] = pcam.GetRetinaVpt(i); } vert_axis = v_axis; h1_axis = (vert_axis + 1) % 3; h2_axis = (vert_axis + 2) % 3; vert_vpt = vpts[vert_axis]; // Ensure the horizon line has its positive side at the top of the image horizon = vpts[h1_axis] ^ vpts[h2_axis]; if (horizon[1] < 0) horizon = -horizon; }
void Planet::accelerateObject(Entity *entity) { sf::Vector2f position = entity->getPosition(); sf::Vector2f velocity = entity->getVelocity(); float a = angle(position, m_position); float d = distance(position, m_position); d = (d == 0 ? (float)0.001 : d); float force = GRAVITATIONAL_CONSTANT * entity->getMass() * this->getMass() / pow(d, 2); float acceleration = force / entity->getMass(); velocity += makeVector(a, acceleration); entity->setVelocity(velocity); }
void UtilityBillFuelTypeListController::objectRemoved(boost::shared_ptr<openstudio::detail::WorkspaceObject_Impl> impl, const openstudio::IddObjectType& iddObjectType, const openstudio::UUID& handle) { if (iddObjectType == m_iddObjectType){ // in a ModelObjectTypeListView this is sufficient to say that a new item has been added to our list // however, in this case we need to also check the fuel type if (boost::dynamic_pointer_cast<model::detail::UtilityBill_Impl>(impl)){ if (boost::dynamic_pointer_cast<model::detail::UtilityBill_Impl>(impl)->fuelType() == m_fuelType){ emit itemIds(makeVector()); } } } }
/*--------------------------------------------------------------------*/ static MATRIX uFromAngles(double om, double sgu, double sgl){ MATRIX u; u = makeVector(); if(u == NULL){ return NULL; } vectorSet(u,0,-Cosd(sgl)*Cosd(om)); vectorSet(u,1,Cosd(sgu)*Sind(om) - Sind(sgu)*Sind(sgl)*Cosd(om)); vectorSet(u,2,-Sind(sgu)*Sind(om) - Cosd(sgu)*Sind(sgl)*Cosd(om)); return u; }
//Look around void Camera::rotateCamera(float x, float y){ float angleY = 0.0f; float angleZ = 0.0f; angleY = x/250; angleZ = y/50; ViewVector.y+=angleZ*3; //Rotate_View(-angle_y); Vector vec = makeVector(ViewVector.x-PositionVector.x, ViewVector.y-PositionVector.y, ViewVector.z-PositionVector.z); ViewVector.z = (float) (PositionVector.z + sin(-angleY)*vec.x + cos(-angleY)*vec.z); ViewVector.x = (float) (PositionVector.x + cos(-angleY)*vec.x - sin(-angleY)*vec.z); }
void LoadMapFromVoodooTextFile(const string& text_file, const string& image_pattern, Map& map) { static const string kMagic = "#timeindex"; static const string kPointsHeader = "# 3D Feature Points"; sifstream in(expand_path(text_file)); double Cx, Cy, Cz, Ax, Ay, Az, Hx, Hy, Hz, Vx, Vy, Vz, K3, K5; double sx, sy, Width, Height, ppx, ppy, f, fov; double H0x, H0y, H0z, V0x, V0y, V0z; DLOG << "WARNING: using first camera intrinsics for all cameras"; int i = 0; Vec3 v; bool reading_points = false; boost::format image_fmt(image_pattern); while (!in.eof()) { if (reading_points) { in >> v[0] >> v[1] >> v[2]; map.points.push_back(v); } else { string line; getline(in, line); if (line.substr(0,kMagic.size()) == kMagic) { int id = lexical_cast<int>(line.substr(kMagic.size()+1)); in >> Cx >> Cy >> Cz >> Ax >> Ay >> Az >> Hx >> Hy >> Hz >> Vx >> Vy >> Vz >> K3 >> K5 >> sx >> sy >> Width >> Height >> ppx >> ppy >> f >> fov >> H0x >> H0y >> H0z >> V0x >> V0y >> V0z; string image_file = str(image_fmt % 21);//id); CHECK_PRED1(fs::exists, image_file); Mat3 C; C[0] = makeVector(f/sx, 0, ppx); C[1] = makeVector(0, f/sy, ppx); C[2] = makeVector(0, 0, 1); if (i == 0) { Vec2I image_size = GetImageSize(expand_path(image_file)); map.camera.reset(new LinearCamera(C, image_size)); } Mat3 R; R[0] = makeVector(H0x, H0z, H0y); R[1] = makeVector(V0x, V0z, V0y); R[2] = makeVector(Ax, Az, Ay); Vec3 t = makeVector(-Cx, -Cy, -Cz); SE3<> pose(SO3<>(R), t); map.AddFrame(new Frame(id, image_file, pose)); i++; } else if (line.substr(0, kPointsHeader.size()) == kPointsHeader) {
void dfs(vector<vector<int> > &result, vector<int> &candidates, vector<int> &limits, int space, int index, vector<int> &count) { if (space == 0) { result.push_back(makeVector(index, candidates, count)); return; } int n = candidates.size(); if (n == index) return; int choice = std::min(limits[index], space / candidates[index]); for (int i = choice; i >= 0; i--) { count[index] = i; dfs(result, candidates, limits, space - candidates[index] * i, index + 1, count); } }
Vector mvMulDir(const Matrix matrix, const Vector vector) { Vector newVector = makeVector(0, 0, 0); // Access x,y,z as an array. float* vectorValues = (float*)&vector.x; float* newVectorValues = (float*)&newVector.x; for (int i=0; i<3; i++) for (int j=0; j<3; j++) newVectorValues[i] += matrix.values[i][j] * vectorValues[j]; return newVector; }
/*-----------------------------------------------------------------------------*/ static MATRIX tasReflectionToQC(tasQEPosition r, MATRIX UB){ MATRIX Q, QC; Q = makeVector(); if(Q == NULL){ return NULL; } vectorSet(Q,0,r.qh); vectorSet(Q,1,r.qk); vectorSet(Q,2,r.ql); QC = mat_mul(UB,Q); killVector(Q); return QC; }
/*==================== reciprocal space ==============================*/ static MATRIX tasReflectionToHC(tasQEPosition r, MATRIX B){ MATRIX h = NULL, hc = NULL; h = makeVector(); if(h == NULL){ return NULL; } vectorSet(h,0,r.qh); vectorSet(h,1,r.qk); vectorSet(h,2,r.ql); hc = mat_mul(B,h); killVector(h); return hc; }
void SpaceDesignSpecificationOutdoorAirVectorController::onChangeRelationship(const model::ModelObject& modelObject, int index, Handle newHandle, Handle oldHandle) { if (modelObject.optionalCast<model::Space>()) { if (index == OS_SpaceFields::DesignSpecificationOutdoorAirObjectName) { emit itemIds(makeVector()); } else if (index == OS_SpaceFields::SpaceTypeName) { detachOtherModelObjects(); model::Space space = m_modelObject->cast<model::Space>(); attachOtherModelObjects(space); emit itemIds(makeVector()); } } else if (modelObject.optionalCast<model::Building>()) { if (index == OS_BuildingFields::SpaceTypeName) { detachOtherModelObjects(); model::Space space = m_modelObject->cast<model::Space>(); attachOtherModelObjects(space); emit itemIds(makeVector()); } } else if (modelObject.optionalCast<model::SpaceType>()) { if (index == OS_SpaceTypeFields::DesignSpecificationOutdoorAirObjectName) { emit itemIds(makeVector()); } } }
void calculateEdgeLength(pMesh theMesh, GeomData *pGCData){ int dim = theMesh->getDim(); //double max_edge=.0, avgLength=.0; double elength, Lij[dim]; double Icoord[3], Jcoord[3]; double delta_x = 1e30; // infinity delta_x double versor[3]; int i,j; dblarray vec(3); EIter eit = M_edgeIter(theMesh); while (pEntity edge = EIter_next(eit)){ if (!theMesh->getRefinementDepth(edge)){ E_getVerticesCoord(edge,Icoord,Jcoord); for (j=0; j<dim; j++){ Lij[j] = .0; } makeVector(Jcoord,Icoord,Lij); for (i=0; i<dim; i++){ vec[i] = Lij[i]; } elength = .0; for (i=0; i<dim; i++){ elength += vec[i]*vec[i]; } elength = sqrt(elength); if (elength == .0){ char msg[256]; sprintf(msg,"Edge [%d %d] has null length!",EN_id(edge->get(0,0)),EN_id(edge->get(0,1))); throw Exception(__LINE__,__FILE__,msg); } //cout << "elength = " << elength << endl; pGCData->setEdgeLength(edge,elength); for (i=0; i<dim; i++){ vec[i] /= elength; } //pGCData->setEdgeVec_Unitary(edge,vec); versor[0] = vec[0]; versor[1] = vec[1]; versor[2] = vec[2]; pGCData->setVersor(edge,versor); // get the smallest one if (delta_x > elength){ delta_x = elength; } } } EIter_delete(eit);//throw 1; // if parallel, get the smallest edge from all ranks and then broadcast it. pGCData->setSmallestEdgeLength(P_getMinDbl(delta_x)); }
int main(int argc, char ** argv) { (void) argc; std::ifstream input{argv[1]}; std::string line; std::getline(input, line); while(input) { auto data = makeVector(line); auto pivotCount = countPivots(std::move(data)); std::cout << pivotCount << '\n'; std::getline(input, line); } return 0; }
bool LevelDBDatabase::get(const LevelDBSlice& key, Vector<char>& value) { std::string result; leveldb::ReadOptions readOptions; readOptions.verify_checksums = true; // FIXME: Disable this if the performance impact is too great. const leveldb::Status s = m_db->Get(readOptions, makeSlice(key), &result); if (s.ok()) { value = makeVector(result); return true; } if (s.IsNotFound()) return false; LOG_ERROR("LevelDB get failed: %s", s.ToString().c_str()); return false; }
/* Initialize all pilots */ void reinit_pilots(void) { int plr,r; dllist_free(pilot_list,NULL); pilot_list = 0; for(plr=0;plr<4;plr++) { memset (&players[plr].pilot, 0, sizeof (Pilot)); init_walker(&players[plr].pilot.walker); players[plr].pilot.walker.physics.radius = PILOT_STD_RADIUS; for (r = 0; r < 3; r++) players[plr].pilot.sprite[r] = pilot_sprite[plr][r]; players[plr].pilot.attack_vector = makeVector(1,0); } }
// Codifica uma entrada num arquivo binario utilizando a codificação de Shannon-Fano string encode(string *input, int *sizeB, int *sizeA) { std::vector<Symbol> symbols; unsigned short num_bit = 1; bool flag = false; string file = ""; if ((input != NULL) && (!input->empty())) { file = *input; flag = readFile(input); } if (flag) { *sizeB = input->size(); makeVector(*input,symbols); // Constroi o vector com os simbolos while (symbols.size() > pow(2,num_bit)) // Conta quantos bits serao necessarios para representar os simbolos num_bit++; makeCodes(symbols); // Cria os codigos em Shannon-Fano de cada simbolo string encoded = charToSF(*input,symbols); // String com a mensagem na codificação de Shannon-Fano input->clear(); string output = outArvore(symbols, encoded, input); // Saida do algoritmo de Shannon-Fano *sizeA = output.size(); writeOutput(output, &file); // Escreve a(s) saida(s) no arquivo // Limpando memoria symbols.clear(); // --------------- return output; } return ""; }
int main(int argc, char **argv) { InitVars(argc, argv); if (argc != 4) { DLOG << "Usage: "<<argv[0]<<" truthed_map.pro BASE_INDEX AUX_RANGE"; return 0; } // Input arguments const char* path = argv[1]; int base_id = atoi(argv[2]); vector<int> aux_ids = ParseMultiRange<int>(string(argv[3])); // Never use the base frame as an auxiliary frame vector<int>::iterator new_end = remove(aux_ids.begin(), aux_ids.end(), base_id); aux_ids.erase(new_end, aux_ids.end()); format filepat("out/%s"); DREPORT(base_id, iowrap(aux_ids)); // Load the map Map map; proto::TruthedMap gt_map; map.LoadWithGroundTruth(path, gt_map); // Get the floor and ceiling positions double zfloor = gt_map.floorplan().zfloor(); double zceil = gt_map.floorplan().zceil(); Vec3 vup = map.kfs[0].pc->pose_inverse() * makeVector(0,1,0); if (Sign(zceil-zfloor) == Sign(vup[2])) { swap(zfloor, zceil); } // Set up the reconstruction MultiViewReconstructor mv; Frame* base_frame = map.KeyFrameByIdOrDie(base_id); base_frame->LoadImage(); TITLED("Computing objective function for base frame") mv.Configure(base_frame->image, zfloor, zceil); BOOST_FOREACH(int aux_id, aux_ids) { Frame* frame = map.KeyFrameByIdOrDie(aux_id); frame->LoadImage(); TITLED(str(format("Computing objective function for frame %d")%aux_id)) mv.AddFrame(frame->image); }
void LoadXmlMapWithGroundTruth(const string& path, Map& map, proto::TruthedMap& gt_map, bool include_non_keyframes, bool rotate_map) { ReadProto(path, gt_map); fs::path map_path = fs::path(*gvSequencesDir).parent_path() / gt_map.spec_file(); LoadXmlMap(map_path.string(), map, include_non_keyframes); if (rotate_map) { map.Transform(SO3<>::exp(asToon(gt_map.ln_scene_from_slam()))); double zfloor = gt_map.floorplan().zfloor(); double zceil = gt_map.floorplan().zceil(); Vec3 vup = map.frames[0].image.pc().pose_inverse() * makeVector(0,1,0); if (Sign(zceil-zfloor) == Sign(vup[2])) { gt_map.mutable_floorplan()->set_zfloor(zceil); gt_map.mutable_floorplan()->set_zceil(zfloor); } } }