void NeighbourJoining::calcNewD(MatrixXf& currentD, MatrixXi& rowsID, const Pair& p) { //calculates distances to new node int j = 0; for (int i = 0; i < numCurrentNodes - 1; ++i) { if (i == p.i) j++; currentD(numCurrentNodes, i) = (currentD(p.i, i + j) + currentD(p.j, i + j) - currentD(p.i, p.j)) / 2; currentD(i, numCurrentNodes) = currentD(numCurrentNodes, i); } //cout << "distances to new node: " << currentD.row(numCurrentNodes).head(numCurrentNodes-1) <<endl; //swaps rows and columns so that the closest pair nodes go right and at the bottom of the matrix currentD.row(p.i).head(numCurrentNodes - 1).swap( currentD.row(numCurrentNodes - 1).head(numCurrentNodes - 1)); currentD.col(p.i).head(numCurrentNodes - 1).swap( currentD.col(numCurrentNodes - 1).head(numCurrentNodes - 1)); currentD.row(p.j).head(numCurrentNodes - 1).swap( currentD.row(numCurrentNodes).head(numCurrentNodes - 1)); currentD.col(p.j).head(numCurrentNodes - 1).swap( currentD.col(numCurrentNodes).head(numCurrentNodes - 1)); currentD.diagonal().setZero(); //cout << "new Matrix:" << endl; printMatrix(currentD); //adjusts node IDs to new matrix indices int newNode = 2 * numObservableNodes - numCurrentNodes; rowsID.row(p.i).swap(rowsID.row(numCurrentNodes - 1)); rowsID.row(p.j).swap(rowsID.row(newNode)); //cout << "rowsID: " << rowsID.transpose(); cout << endl; }
void set_submatrix(MatrixXi& M, const MatrixXi& Msub, const VectorXi& ind) { int k = 0; for(int i=0;i<ind.size();i++){ if(ind(i) == 1){ M.row(i) = Msub.row(k); k++; } } }
void WeightedSampling(int m, int N, const MatrixXi &resIndex, vector<int> &sample, int h) { sample.reserve(m); vector<int> seedIndex; RandomSampling(1, N, seedIndex); sample[0] = seedIndex[0]; int prevSelected = seedIndex[0]; ArrayXf w(N); w.setConstant(1); for (int i = 1; i < m; i++) { ArrayXf new_w(N); computeIntersection(resIndex.row(prevSelected), resIndex, h, new_w); w(prevSelected) = 0; w *= new_w; if (w.sum() > 0) { map<double, int> cumulative; typedef std::map<double, int>::iterator it; double acc = 0; for (int j = 0; j < N; j++) { acc += w(j); cumulative[acc] = j; } double linear = rand()*acc/RAND_MAX; prevSelected = cumulative.upper_bound(linear)->second; sample[i] = prevSelected; } else { vector<int> temp_sample; RandomSampling(1, N, temp_sample); prevSelected = temp_sample[0]; sample[i] = prevSelected; } } }
void Utils::saveImage(MatrixXi rawData, string outputFile) { QImage* img = new QImage(rawData.cols(), rawData.rows(), QImage::Format_RGB16); for (int y = 0; y < img->height(); y++) { VectorXi a = rawData.row(y); memcpy(img->scanLine(y), (void*)&a, img->bytesPerLine()); } QString file = QString::fromUtf8(outputFile.c_str()); img->save(file); }
//TODO: Clean up function params size Fixed and size Move are not needed void Simulation::reIndexTVandTT( vector<int> newVertsIndices, int sizeFixed, int sizeMove, MatrixXd& TV, MatrixXi& TT, VectorXd& force, MatrixXd& newTV, MatrixXi& newTT, VectorXd& new_force){ //apply re-index to TV for(unsigned int i=0; i<newVertsIndices.size(); i++){ newTV.row(i) = TV.row(newVertsIndices[i]); new_force.segment<3>(3*i) = force.segment<3>(3*newVertsIndices[i]); } //create map out of newVertsIndex //map keys = newVertsIndex values = old indices in TV //map vals = newVertsIndex index = new indices in TV map<int, int> oldToNewmap; pair<map<int, int>::iterator, bool> err; for(unsigned int i=0; i<newVertsIndices.size(); i++){ err = oldToNewmap.insert(pair<int, int>(newVertsIndices[i], i)); if(err.second==false){ cout<<"ERROR::Simulation.cpp::reIndexTVandTT::>>Map already contains this value("; cout<< err.first->second <<". Indices should not be repeated"<<endl; } } //Check map, see if its working // map<int,int>::iterator it = oldToNewmap.begin(); // for (it=oldToNewmap.begin(); it!=oldToNewmap.end(); ++it) // cout << it->first << " => " << it->second << '\n'; //apply re-index to TT for(int i=0; i< TT.rows(); i++){ for(int j=0; j<4; j++){ newTT.row(i)[j] = oldToNewmap.find(TT.row(i)[j])->second; } } }
MatrixXi get_submatrix(const MatrixXi& M, const VectorXi& ind) { MatrixXi Msub(ind.sum(),M.cols()); int k = 0; for(int i=0;i<M.rows();i++){ if(ind(i) == 1){ Msub.row(k) = M.row(i); k++; } } return Msub; }
parameters::parameters(datafile dat, model nv_mod, model ref_mod,parameters ref_param,int compo,int iter){ const MatrixXi & omega=nv_mod.Get_model(),ref_omega=ref_mod.Get_model(),mat=dat.Get_mat_datafile(); const int g=omega.rows(),unique=mat.rows(); m_proba=ref_param.m_proba; m_proba_block.resize(g); m_param.resize(g); for (int k=0;k<g;k++){ if (k!=compo){ m_param[k].resize(omega.rowwise().maxCoeff()(k)+1); m_param[k]=ref_param.m_param[k]; m_proba_block[k].resize(unique,omega.rowwise().maxCoeff()(k)+1); m_proba_block[k]=ref_param.m_proba_block[k]; for (int b=0;b<(omega.rowwise().maxCoeff()(k)+1) ;b++){ if ((omega.row(k).array()==b).any()){ m_param[k][b]=ref_param.m_param[k][b]; } } }else{ m_param[k].resize(omega.rowwise().maxCoeff()(k)+1); m_proba_block[k].resize(unique,omega.rowwise().maxCoeff()(k)+1); for (int b=0;b<(omega.rowwise().maxCoeff()(k)+1) ;b++){ if ((omega.row(k).array()==b).any()){ if ((((omega.row(k).array()==b)==(ref_omega.row(k).array()==b)).prod())==1){ m_param[k][b]=ref_param.m_param[k][b]; }else{ m_param[k][b]=param_block(k,b,dat,nv_mod,m_proba.col(k).array()/m_proba.rowwise().sum().array(),1); if ((omega.row(k).array()==b).count()>1){ int prem=0; while(omega(k,prem)!=b){prem++;} if (mat.col(prem).maxCoeff()>5){ m_param[k][b]=m_param[k][b].Optimise_gamma(k,b,dat,nv_mod,5,m_proba.col(k).array()/m_proba.rowwise().sum().array(),dat.Get_eff_datafile()); } } } } } } } m_propor=uniforme(g); Probapost( nv_mod , mat ); Compte_nbparam(dat,nv_mod); Likelihood(dat.Get_eff_datafile()); Estimation(1,0,iter,dat,nv_mod); }
TEST(TestEigenHelper, TestSelectRows) { unsigned int rows = 4; unsigned int cols = 5; MatrixXi v(rows, cols); v << 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20; Ints myrows = {1,3}; MatrixXi z = select_rows<int, Ints >(v, myrows); EXPECT_EQ(v.row(1), z.row(0)); EXPECT_EQ(v.row(3), z.row(1)); MatrixXd q = v.cast<double>() / 2; Ints more_rows = {1,0,2}; MatrixXd t = select_rows<double, Ints >(q, more_rows); for(unsigned int i = 0; i < cols; i++) { EXPECT_DOUBLE_EQ(q(1, i), t(0, i)); EXPECT_DOUBLE_EQ(q(0, i), t(1, i)); EXPECT_DOUBLE_EQ(q(2, i), t(2, i)); } }
void computeIntersection(const MatrixXi &thisIndex, const MatrixXi &index, int h, ArrayXf &new_w) { int dataSize = index.rows(); int M = index.cols(); for (int i = 0 ; i < dataSize; i++) new_w(i) = intersect(thisIndex.transpose(), index.row(i).transpose(), M, h); }
IGL_INLINE void igl::reorient_facets_raycast( const Eigen::PlainObjectBase<DerivedV> & V, const Eigen::PlainObjectBase<DerivedF> & F, int rays_total, int rays_minimum, bool facet_wise, bool use_parity, bool is_verbose, Eigen::PlainObjectBase<DerivedI> & I, Eigen::PlainObjectBase<DerivedC> & C) { using namespace Eigen; using namespace std; assert(F.cols() == 3); assert(V.cols() == 3); // number of faces const int m = F.rows(); MatrixXi FF = F; if (facet_wise) { C.resize(m); for (int i = 0; i < m; ++i) C(i) = i; } else { if (is_verbose) cout << "extracting patches... "; bfs_orient(F,FF,C); } if (is_verbose) cout << (C.maxCoeff() + 1) << " components. "; // number of patches const int num_cc = C.maxCoeff()+1; // Init Embree EmbreeIntersector ei; ei.init(V.template cast<float>(),FF); // face normal MatrixXd N; per_face_normals(V,FF,N); // face area Matrix<typename DerivedV::Scalar,Dynamic,1> A; doublearea(V,FF,A); double area_total = A.sum(); // determine number of rays per component according to its area VectorXd area_per_component; area_per_component.setZero(num_cc); for (int f = 0; f < m; ++f) { area_per_component(C(f)) += A(f); } VectorXi num_rays_per_component(num_cc); for (int c = 0; c < num_cc; ++c) { num_rays_per_component(c) = max<int>(static_cast<int>(rays_total * area_per_component(c) / area_total), rays_minimum); } rays_total = num_rays_per_component.sum(); // generate all the rays if (is_verbose) cout << "generating rays... "; uniform_real_distribution<float> rdist; mt19937 prng; prng.seed(time(nullptr)); vector<int > ray_face; vector<Vector3f> ray_ori; vector<Vector3f> ray_dir; ray_face.reserve(rays_total); ray_ori .reserve(rays_total); ray_dir .reserve(rays_total); for (int c = 0; c < num_cc; ++c) { if (area_per_component[c] == 0) { continue; } vector<int> CF; // set of faces per component vector<double> CF_area; for (int f = 0; f < m; ++f) { if (C(f)==c) { CF.push_back(f); CF_area.push_back(A(f)); } } // discrete distribution for random selection of faces with probability proportional to their areas discrete_distribution<int> ddist(CF.size(), 0, CF.size(), [&](double i){ return CF_area[static_cast<int>(i)]; }); // simple ctor of (Iter, Iter) not provided by the stupid VC11/12 for (int i = 0; i < num_rays_per_component[c]; ++i) { int f = CF[ddist(prng)]; // select face with probability proportional to face area float s = rdist(prng); // random barycentric coordinate (reference: Generating Random Points in Triangles [Turk, Graphics Gems I 1990]) float t = rdist(prng); float sqrt_t = sqrtf(t); float a = 1 - sqrt_t; float b = (1 - s) * sqrt_t; float c = s * sqrt_t; Vector3f p = a * V.row(FF(f,0)).template cast<float>().eval() // be careful with the index!!! + b * V.row(FF(f,1)).template cast<float>().eval() + c * V.row(FF(f,2)).template cast<float>().eval(); Vector3f n = N.row(f).cast<float>(); if (n.isZero()) continue; // random direction in hemisphere around n (avoid too grazing angle) Vector3f d; while (true) { d = random_dir().cast<float>(); float ndotd = n.dot(d); if (fabsf(ndotd) < 0.1f) { continue; } if (ndotd < 0) { d *= -1.0f; } break; } ray_face.push_back(f); ray_ori .push_back(p); ray_dir .push_back(d); if (is_verbose && ray_face.size() % (rays_total / 10) == 0) cout << "."; } } if (is_verbose) cout << ray_face.size() << " rays. "; // per component voting: first=front, second=back vector<pair<float, float>> C_vote_distance(num_cc, make_pair(0, 0)); // sum of distance between ray origin and intersection vector<pair<int , int >> C_vote_infinity(num_cc, make_pair(0, 0)); // number of rays reaching infinity vector<pair<int , int >> C_vote_parity(num_cc, make_pair(0, 0)); // sum of parity count for each ray if (is_verbose) cout << "shooting rays... "; #pragma omp parallel for for (int i = 0; i < (int)ray_face.size(); ++i) { int f = ray_face[i]; Vector3f o = ray_ori [i]; Vector3f d = ray_dir [i]; int c = C(f); // shoot ray toward front & back vector<Hit> hits_front; vector<Hit> hits_back; int num_rays_front; int num_rays_back; ei.intersectRay(o, d, hits_front, num_rays_front); ei.intersectRay(o, -d, hits_back , num_rays_back ); if (!hits_front.empty() && hits_front[0].id == f) hits_front.erase(hits_front.begin()); if (!hits_back .empty() && hits_back [0].id == f) hits_back .erase(hits_back .begin()); if (use_parity) { #pragma omp atomic C_vote_parity[c].first += hits_front.size() % 2; #pragma omp atomic C_vote_parity[c].second += hits_back .size() % 2; } else { if (hits_front.empty()) { #pragma omp atomic C_vote_infinity[c].first++; } else { #pragma omp atomic C_vote_distance[c].first += hits_front[0].t; } if (hits_back.empty()) { #pragma omp atomic C_vote_infinity[c].second++; } else { #pragma omp atomic C_vote_distance[c].second += hits_back[0].t; } } } I.resize(m); for(int f = 0; f < m; ++f) { int c = C(f); if (use_parity) { I(f) = C_vote_parity[c].first > C_vote_parity[c].second ? 1 : 0; // Ideally, parity for the front/back side should be 1/0 (i.e., parity sum for all rays should be smaller on the front side) } else { I(f) = (C_vote_infinity[c].first == C_vote_infinity[c].second && C_vote_distance[c].first < C_vote_distance[c].second) || C_vote_infinity[c].first < C_vote_infinity[c].second ? 1 : 0; } // To account for the effect of bfs_orient if (F.row(f) != FF.row(f)) I(f) = 1 - I(f); } if (is_verbose) cout << "done!" << endl; }
void igl::collapse_small_triangles( const Eigen::MatrixXd & V, const Eigen::MatrixXi & F, const double eps, Eigen::MatrixXi & FF) { using namespace Eigen; using namespace std; // Compute bounding box diagonal length double bbd = bounding_box_diagonal(V); MatrixXd l; edge_lengths(V,F,l); VectorXd dblA; doublearea(l,dblA); // Minimum area tolerance const double min_dblarea = 2.0*eps*bbd*bbd; Eigen::VectorXi FIM = colon<int>(0,V.rows()-1); int num_edge_collapses = 0; // Loop over triangles for(int f = 0;f<F.rows();f++) { if(dblA(f) < min_dblarea) { double minl = 0; int minli = -1; // Find shortest edge for(int e = 0;e<3;e++) { if(minli==-1 || l(f,e)<minl) { minli = e; minl = l(f,e); } } double maxl = 0; int maxli = -1; // Find longest edge for(int e = 0;e<3;e++) { if(maxli==-1 || l(f,e)>maxl) { maxli = e; maxl = l(f,e); } } // Be sure that min and max aren't the same maxli = (minli==maxli?(minli+1)%3:maxli); // Collapse min edge maintaining max edge: i-->j // Q: Why this direction? int i = maxli; int j = ((minli+1)%3 == maxli ? (minli+2)%3: (minli+1)%3); assert(i != minli); assert(j != minli); assert(i != j); FIM(F(f,i)) = FIM(F(f,j)); num_edge_collapses++; } } // Reindex faces MatrixXi rF = F; // Loop over triangles for(int f = 0;f<rF.rows();f++) { for(int i = 0;i<rF.cols();i++) { rF(f,i) = FIM(rF(f,i)); } } FF.resize(rF.rows(),rF.cols()); int num_face_collapses=0; // Only keep uncollapsed faces { int ff = 0; // Loop over triangles for(int f = 0;f<rF.rows();f++) { bool collapsed = false; // Check if any indices are the same for(int i = 0;i<rF.cols();i++) { for(int j = i+1;j<rF.cols();j++) { if(rF(f,i)==rF(f,j)) { collapsed = true; num_face_collapses++; break; } } } if(!collapsed) { FF.row(ff++) = rF.row(f); } } // Use conservative resize FF.conservativeResize(ff,FF.cols()); } //cout<<"num_edge_collapses: "<<num_edge_collapses<<endl; //cout<<"num_face_collapses: "<<num_face_collapses<<endl; if(num_edge_collapses == 0) { // There must have been a "collapsed edge" in the input assert(num_face_collapses==0); // Base case return; } //// force base case //return; MatrixXi recFF = FF; return collapse_small_triangles(V,recFF,eps,FF); }
int main(int argc, char *argv[]) { cout << "Usage: " << argv[0] << " [FILENAME].[off|obj|ply] [1-7] [sl]" << endl; cout << "where 1-7 is the cost function to use" << endl; cout << " s = save images at all decimation steps" << endl; cout << " l = disable lighting" << endl; cout << endl; cout << "Keybindings:" << endl; cout << " [space] toggle animation." << endl; cout << " 'r' reset." << endl; cout << " '1' edge collapse." << endl; cout << " '2' vertex split." << endl; cout << " 's' save screenshot." << endl; cout << " 'c' switch color mode." << endl; cout << " 'f' cycle cost function." << endl; cout << endl; // Load a closed manifold mesh string filename; if (argc >= 2) { filename = argv[1]; } else { return 0; } if (argc >= 3) { int idx = stoi(argv[2]) - 1; cost_function_n = idx; if (idx >= 0 && idx < cost_functions.size()) shortest_edge_and_midpoint = *(cost_functions.begin() + idx); } if (!igl::read_triangle_mesh(filename, OV, OF)) { cout << "could not read mesh from \"" << filename << "\"" << endl; return 1; } // compute normals igl::per_face_normals(OV, OF, normals); // Prepare array-based edge data structures and priority queue // EMAP is a map from faces to edges. // Index into it like EMAP(face + i*F.rows()) where i is an edge index // between 0 and 2 corresponding to the three edges of a triangle. VectorXi EMAP; // E is a map from edges to vertices. Given some edge index e, // E(e, 0) and E(e, 1) are the two vertices that the edge is composed of. MatrixXi E; // EF is a map from edges to faces. For some edge index e, // EF(e, 0) and E(e, 1) are the two faces that contain the edge e. MatrixXi EF; // EI is a map from edges to face corners. For some edge index e, // EI(e, 0) is the index i such that EMAP(EF(e, 0) + i*F.rows()) == e and // EI(e, 1) is the index i such that EMAP(EF(e, 1) + i*F.rows()) == e. MatrixXi EI; typedef std::set<std::pair<double, int>> PriorityQueue; // Q stores the list of possible edge collapses and their costs PriorityQueue Q; std::vector<PriorityQueue::iterator> Qit; // If an edge were collapsed, we'd collapse it to these points: MatrixXd C; // Keep some info on edge collapses for reversal and debug reasons int num_collapsed; std::vector<MeshModification> mods; std::vector<int> iters; int total_decimations = 0; const auto &reset_view = [&]() { viewer.data.clear(); viewer.data.set_mesh(V, F); switch (color_mode) { case DISTANCE_VISUALIZATION: generate_distance_field(); case COST_VISUALIZATION: viewer.data.set_colors(colors); break; case SOLID: viewer.data.set_colors(RowVector3d(1.0, 1.0, 1.0)); break; } viewer.data.set_face_based(false); }; // Function to reset original mesh and data structures const auto &reset = [&]() { total_decimations = 0; mods.clear(); iters.clear(); F = OF; V = OV; igl::edge_flaps(F, E, EMAP, EF, EI); Qit.resize(E.rows()); C.resize(E.rows(), V.cols()); colors.resize(V.rows(), 3); colors.setZero(); VectorXd costs(V.rows()); costs.setZero(); for (int e = 0; e < E.rows(); e++) { double cost = e; RowVectorXd p(1, 3); shortest_edge_and_midpoint(e, V, F, E, EMAP, EF, EI, cost, p); C.row(e) = p; Qit[e] = Q.insert(std::pair<double, int>(cost, e)).first; costs(E(e, 0)) += cost; costs(E(e, 1)) += cost; } igl::jet(costs, true, colors); num_collapsed = 0; reset_view(); }; const auto &collapse_edges = [&](igl::viewer::Viewer &viewer) -> bool { // If animating then collapse 10% of edges if (viewer.core.is_animating && !Q.empty()) { bool something_collapsed = false; // collapse edge const int num_iters = 50; // Store the state from before the collapse so that it can be // reversed later. MatrixXd prev_V = V; MatrixXi prev_F = F; MatrixXi prev_E = E; num_collapsed = 0; int total_failures = 0; // If a certain number of failures have // occurred, we exit an infinte fail loop. for (int j = 0; j < num_iters; j++) { int e, e1, e2, f1, f2; std::vector<int> faceInd, vertInd; if (Q.empty()) break; if (!collapse_edge(shortest_edge_and_midpoint, V, F, E, EMAP, EF, EI, Q, Qit, C, e, e1, e2, f1, f2, faceInd)) { total_failures++; j--; if (total_failures > 1000) { break; } continue; } else { total_decimations++; num_collapsed++; } MatrixXi faces(faceInd.size() + 2, 3); faceInd.push_back(f1); faceInd.push_back(f2); for (int i = 0; i < faceInd.size(); i++) { faces.row(i) = prev_F.row(faceInd[i]); // cout << "ffF" << faces.row(i) << endl; } MatrixXd verts(2, 3); vertInd.push_back(prev_E(e, 0)); vertInd.push_back(prev_E(e, 1)); for (int i = 0; i < vertInd.size(); i++) { verts.row(i) = prev_V.row(vertInd[i]); } mods.push_back( MeshModification(vertInd, verts, faceInd, faces)); something_collapsed = true; } if (something_collapsed) { iters.push_back(num_collapsed); reset_view(); } } cout << "Collapsed an Edge\n" << "Decimations: " << total_decimations << "\n"; return false; }; // function to reverse edge collapse const auto &uncollapse_edges = [&](igl::viewer::Viewer &viewer) -> bool { if (viewer.core.is_animating && !mods.empty() && !iters.empty()) { int max_iter = iters.back(); iters.pop_back(); for (int i = 0; i < max_iter; i++) { MeshModification mod = mods.back(); mods.pop_back(); total_decimations--; for (int i = 0; i < mod.vertInd.size(); i++) { V.row(mod.vertInd[i]) = mod.verts.row(i); } for (int i = 0; i < mod.faceInd.size(); i++) { F.row(mod.faceInd[i]) = mod.faces.row(i); } } reset_view(); cout << "Uncollapsed an Edge\n" << "Decimations: " << total_decimations << "\n"; } }; const auto &save_images = [&]() -> bool { reset(); viewer.draw(); save_screenshot(viewer, "images/before.png"); char fn[100]; char command[512]; ofstream distfile("surface_distances", ofstream::trunc); for (int i = 0; i <= 50; i++) { collapse_edges(viewer); distfile << generate_distance_field() << endl; viewer.draw(); sprintf(fn, "images/after%03d.png", i); save_screenshot(viewer, fn); sprintf(command, "composite images/before.png " "images/after%03d.png -compose difference " "images/diff%03d.png ", i, i); system(command); sprintf(command, "composite images/after%03d.png " "images/after%03d.png -compose difference " "images/delta%03d.png ", i, i - 1, i); system(command); cout << "Step " << i << " / 100" << endl; } distfile.close(); exit(EXIT_SUCCESS); }; const auto &key_down = [&](igl::viewer::Viewer &viewer, unsigned char key, int mod) -> bool { switch (key) { case ' ': viewer.core.is_animating ^= 1; break; case 'R': case 'r': reset(); break; case '1': collapse_edges(viewer); break; case '2': uncollapse_edges(viewer); break; case '3': save_images(); break; case 'S': case 's': save_screenshot(viewer, "images/screen.png"); cout << "saved screen to images/screen.png" << endl; break; case 'C': case 'c': ((int &)color_mode)++; ((int &)color_mode) %= MAX_COLOR_MODE; reset_view(); break; case 'F': case 'f': cost_function_n++; cost_function_n %= cost_functions.size(); shortest_edge_and_midpoint = *(cost_functions.begin() + cost_function_n); reset(); break; case 'g': case 'G': cout << generate_distance_field() << endl; break; default: return false; } return true; }; const auto &s_option = [&](igl::viewer::Viewer &viewer) -> bool { if (argc >= 4) { for (char c : string(argv[3])) { switch (c) { case 's': save_images(); break; case 'l': viewer.core.shininess = 1.0; viewer.core.lighting_factor = 0.0; break; } } } }; reset(); viewer.core.is_animating = true; viewer.callback_key_pressed = key_down; viewer.callback_init = s_option; viewer.core.show_lines = false; viewer.core.camera_zoom = 2.0; return viewer.launch(); }
RcppExport SEXP BMEclustering(SEXP mat, SEXP moda, SEXP nb_cluster, SEXP partition_initiale, SEXP nb_init,SEXP stop_criterion){ srand(time(0)); MatrixXi data=convertMatrix<MatrixXi,NumericMatrix>(mat); VectorXi modalite=convertvector<VectorXi,NumericVector>(moda); datafile dataF(data,modalite); NumericMatrix red=convertMatrix<NumericMatrix,MatrixXi>(dataF.Get_mat_datafile()); VectorXi partition_vbles=convertvector<VectorXi,NumericVector>(partition_initiale); MatrixXi m; int g=as<int>(nb_cluster); //int borne=as<int>(nbiter); m.resize(g,partition_vbles.rows()); for (int k=0;k<g;k++){ m.row(k)=partition_vbles; } NumericMatrix test=convertMatrix<NumericMatrix,MatrixXi>(m); int nbinit=as<int>(nb_init); int borne=as<int>(stop_criterion); MCMCAlgo ref(dataF,m,m.rows(),2,1,2,6,borne); for (int ini=0;ini<nbinit;ini++){ MCMCAlgo test(dataF,m,m.rows(),2,1,2,6,borne); if (test.Get_best_bic()>ref.Get_best_bic()){ ref=test; } } //sauvegarde des caractéristiques du modèle NumericMatrix model=convertMatrix<NumericMatrix,MatrixXi>(ref.Get_best_omega()); double bic=ref.Get_best_bic(); double likelihood=ref.Get_best_like(); NumericMatrix probapost=convertMatrix<NumericMatrix,MatrixXd>(ref.Sauv_probapost()); NumericVector localise=convertvector<NumericVector,VectorXi>(dataF.Get_localise()); vector< vector< NumericVector > > tau; vector< vector< vector< NumericVector > > > delta; vector< vector< vector< NumericVector > > > alpha; vector< vector< double > > rho; tau.resize(g); rho.resize(g); delta.resize(g); alpha.resize(g); for (int k=0;k<g;k++){ tau[k].resize(ref.Get_best_omega().row(k).maxCoeff()+1); rho[k].resize(ref.Get_best_omega().row(k).maxCoeff()+1); delta[k].resize(ref.Get_best_omega().row(k).maxCoeff()+1); alpha[k].resize(ref.Get_best_omega().row(k).maxCoeff()+1); for (int b=0;b<=ref.Get_best_omega().row(k).maxCoeff();b++){ //for (int b=0;b<2;b++){ //vectblock[k][b]=ref.Get_rho(k,b); //vector < VectorXd > passe=ref.Get_alpha(k,b); if ((ref.Get_best_omega().row(k).array()==b).count()>0){ vector<VectorXd> passe=ref.Get_alpha(k,b); alpha[k][b].resize((ref.Get_best_omega().row(k).array()==b).count()); for (int loc=0;loc<((ref.Get_best_omega().row(k).array()==b).count());loc++){ alpha[k][b][loc]=convertvector<NumericVector,VectorXd>(passe[loc]); } } if ((ref.Get_best_omega().row(k).array()==b).count()>1){ MatrixXi passe=ref.Get_delta(k,b); delta[k][b].resize(passe.cols()); tau[k][b]=convertvector<NumericVector,VectorXd>(ref.Get_tau(k,b)); for (int loc=0;loc<passe.cols();loc++){ delta[k][b][loc]=convertvector<NumericVector,VectorXi>(passe.col(loc)); } //delta[k][b]=convertMatrix<NumericMatrix,MatrixXi>(ref.Get_delta(k,b)); rho[k][b]=ref.Get_rho(k,b); } } } List param=List::create(Rcpp::Named("tau")=tau,Rcpp::Named("rho")=rho,Rcpp::Named("delta")=delta,Rcpp::Named("alpha")=alpha,Rcpp::Named("proportions")=convertvector<NumericVector,VectorXd>(ref.Get_propor())); List desc_model = List::create(Rcpp::Named("sigma")=model,Rcpp::Named("bic")=bic,Rcpp::Named("likelihood")=likelihood,Rcpp::Named("probapost")=probapost,Rcpp::Named("partition")=localise,Rcpp::Named("nbcluster")=nb_cluster,Rcpp::Named("parameters")=param); return desc_model; }