void color_intersections(
const Eigen::MatrixXd & V,
const Eigen::MatrixXi & F,
const Eigen::MatrixXd & U,
const Eigen::MatrixXi & G,
Eigen::MatrixXd & C,
Eigen::MatrixXd & D)
{
using namespace igl;
using namespace igl::cgal;
using namespace Eigen;
MatrixXi IF;
const bool first_only = false;
intersect_other(V,F,U,G,first_only,IF);
C.resize(F.rows(),3);
C.col(0).setConstant(0.4);
C.col(1).setConstant(0.8);
C.col(2).setConstant(0.3);
D.resize(G.rows(),3);
D.col(0).setConstant(0.4);
D.col(1).setConstant(0.3);
D.col(2).setConstant(0.8);
for(int f = 0;f<IF.rows();f++)
{
C.row(IF(f,0)) = RowVector3d(1,0.4,0.4);
D.row(IF(f,1)) = RowVector3d(0.8,0.7,0.3);
}
}
void NeighbourJoining::configure(const MatrixXf& D, MatrixXf& currentD, MatrixXi& rowsID, int numOccupiedNodes) {
numObservableNodes = rowsID.rows();
numCurrentNodes = numObservableNodes;
//allocates memory for the latent nodes
rowsID.conservativeResize((2 * numObservableNodes - 2), 1);
//gives latent nodes IDs
for (int i = numObservableNodes; i < 2 * numObservableNodes - 2; ++i) {
rowsID(i) = i + numOccupiedNodes;
}
sort(rowsID.data(), rowsID.data() + rowsID.size());
//cout << "rowsID after sort:" << rowsID.transpose(); cout << endl;
//copies distances of selected Nodes
int offseti = 0; int offsetj = 0;
for (int i = 0; i < numObservableNodes; ++i) {
while (rowsID(i) != i + offseti)
++offseti;
offsetj = 0;
for (int j = 0; j < numObservableNodes; ++j) {
while (rowsID(j) != j + offsetj)
++offsetj;
currentD(i, j) = D(i + offseti, j + offsetj);
currentD(j, i) = currentD(i, j);
}
}
//cout << "copied matrix: " << endl; printMatrix(currentD);
}
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;
}
int main(int argc, char *argv[])
{
using namespace Eigen;
using namespace std;
MatrixXd V;
MatrixXi F;
igl::readOFF("../shared/decimated-knight.off",V,F);
// 100 random indicies into rows of F
VectorXi I;
igl::floor((0.5*(VectorXd::Random(100,1).array()+1.)*F.rows()).eval(),I);
// 50 random indicies into rows of I
VectorXi J;
igl::floor((0.5*(VectorXd::Random(50,1).array()+1.)*I.rows()).eval(),J);
// K = I(J);
VectorXi K;
igl::slice(I,J,K);
// default green for all faces
MatrixXd C = RowVector3d(0.4,0.8,0.3).replicate(F.rows(),1);
// Red for each in K
MatrixXd R = RowVector3d(1.0,0.3,0.3).replicate(K.rows(),1);
// C(K,:) = R
igl::slice_into(R,K,1,C);
// Plot the mesh with pseudocolors
igl::viewer::Viewer viewer;
viewer.data.set_mesh(V, F);
viewer.data.set_colors(C);
viewer.launch();
}
void ConsistencyTest::replaceWithMain()
{
cout<<"########START CONSISTENCY TESTS######"<<endl;
cout<<"----Constants for the test"<<endl;
//Const across all tests
printThisOften = 0.1;
printForThisManySeconds = 10;
timeIterations = 1;
gravity = -10;
rayleighCoeff = 0;
material_model = "neo";
solver = "newton";
objectName = "spring";
int spaceStep = 0;
char method = 'i';
string tetmesh_code = "-pRq1.7";
string spaceDescription = tetmesh_code;
double implicitTimestep = 1e-1;
cout<<"----Constants for the test"<<endl;
//Time stuff------
time_t now = time(0);
string dt = ctime(&now);//local time, replace all spaces and new lines
dt.erase('\n');
replace(dt.begin(), dt.end(), ' ', '-');
//-----------------
MatrixXd V;
MatrixXi F;
MatrixXd B;
MatrixXd TV;
MatrixXi TT;
MatrixXi TF;
igl::readOBJ(TUTORIAL_SHARED_PATH "shared/"+objectName+".obj", V, F);
igl::copyleft::tetgen::tetrahedralize(V,F,tetmesh_code, TV, TT, TF);
igl::barycenter(TV, TT, B);
spaceStep =TT.rows();
if(method == 'i'){
string printHere = CONSISTENCY_TEST_SAVE_PATH"TestsResults/ConsistencyTests/objectName:"+objectName+"/implicit_euler@"+material_model+"@"+solver+"/"+to_string(spaceStep)+"tets@"+tetmesh_code+"/timestep:"+to_string(implicitTimestep)+"/";
test(implicitTimestep, method, printHere, TT, TV, B);
}else if(method == 'n'){
cout<<"Not Yet, fill in the same thing for newmark"<<endl;
}else if(method = 'e'){
cout<<"Use an implicit method instead"<<endl;
}else{
cout<<"Lolz"<<endl;
exit(0);
}
return;
}
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++;
}
}
}
IGL_INLINE void igl::exterior_edges(
const Eigen::MatrixXi & F,
Eigen::MatrixXi & E)
{
using namespace Eigen;
using namespace std;
assert(F.cols() == 3);
const size_t m = F.rows();
MatrixXi all_E,sall_E,sort_order;
// Sort each edge by index
all_edges(F,all_E);
sort(all_E,2,true,sall_E,sort_order);
// Find unique edges
MatrixXi uE;
VectorXi IA,EMAP;
unique_rows(sall_E,uE,IA,EMAP);
VectorXi counts = VectorXi::Zero(uE.rows());
for(size_t a = 0;a<3*m;a++)
{
counts(EMAP(a)) += (sort_order(a)==0?1:-1);
}
E.resize(all_E.rows(),2);
{
int e = 0;
const size_t nue = uE.rows();
// Append each unique edge with a non-zero amount of signed occurances
for(size_t ue = 0; ue<nue; ue++)
{
const int count = counts(ue);
size_t i,j;
if(count == 0)
{
continue;
}else if(count < 0)
{
i = uE(ue,1);
j = uE(ue,0);
}else if(count > 0)
{
i = uE(ue,0);
j = uE(ue,1);
}
// Append edge for every repeated entry
const int abs_count = abs(count);
for(size_t k = 0;k<abs_count;k++)
{
E(e,0) = i;
E(e,1) = j;
e++;
}
}
E.conservativeResize(e,2);
}
}
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);
}
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;
}
void parameters::Mstep(datafile dat, model mod){
const MatrixXi & omega=mod.Get_model(),mat=dat.Get_mat_datafile();
const VectorXd & eff=dat.Get_eff_datafile();
for (int k=0;k<m_proba.cols();k++){
m_propor(k)= (eff.array()*(m_proba.col(k)).array()/m_proba.rowwise().sum().array()).sum() / eff.sum();
for (int b=0;b<mat.cols();b++){
if ((omega.row(k).array()==b).any()){
const VectorXi & who=mod.Get_var_block(k,b);
m_param[k][b].Mstep(who,mat,m_proba_block[k].col(b),m_proba.col(k).array()/m_proba.rowwise().sum().array(),eff);
}
}
}
}
void FScore::calculate_from_confusion_matrix(const MatrixXi &cmat) {
// Sometimes a class is never predicted, leading to a sum that is 0.
// When dividing later, there can be a nan. Avoid setting the value to 1.
// Setting to 1 is correct because the value to divide will be 0.
VectorXi sums = cmat.colwise().sum().unaryExpr(std::ptr_fun(avoid_zero));
recall_ = cmat.cast<double>().diagonal().array() / sums.cast<double>().array();
sums = cmat.rowwise().sum().unaryExpr(std::ptr_fun(avoid_zero));
precision_ = cmat.cast<double>().diagonal().array() / sums.cast<double>().array();
// Apply the same fix to the sum of the recall and precision arrays.
VectorXd s = (recall_ + precision_).unaryExpr(std::ptr_fun(avoid_zero_double));
fscore_ = 2 * recall_.array() * precision_.array() / s.array();
}
int main(int, char**)
{
cout.precision(3);
MatrixXi m = MatrixXi::Random(3,4);
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is the reverse of m:" << endl << m.reverse() << endl;
cout << "Here is the coefficient (1,0) in the reverse of m:" << endl
<< m.reverse()(1,0) << endl;
cout << "Let us overwrite this coefficient with the value 4." << endl;
m.reverse()(1,0) = 4;
cout << "Now the matrix m is:" << endl << m << endl;
return 0;
}
double nominal_entropy_gain(const VectorXi &values, const VectorXi &classes) {
MatrixXi T = get_cross_table(values, classes);
MatrixXi total_per_value = T.rowwise().sum();
VectorXd probability_of_value = total_per_value.cast<double>() /values.rows();
MatrixXd fractions_yx = divide_colwise( T.cast<double>(),
total_per_value.cast<double>());
double epsilon = std::numeric_limits<double>::epsilon();
double invlog = 1 / std::log(2);
MatrixXd H = (- invlog) * fractions_yx.array() *
(fractions_yx.array() + epsilon).log().array();
double total_entropy = probability_of_value.transpose() * H.rowwise().sum();
VectorXi counts = T.colwise().sum();
double gain = entropy(counts.cast<double>()) - total_entropy;
return gain;
}
double nominal_gini_gain(const VectorXi &values, const VectorXi &classes) {
MatrixXi T = get_cross_table(values, classes);
// total_per_value(k) is the number of times that value k appears
MatrixXi total_per_value = T.rowwise().sum();
VectorXd probability_of_value = total_per_value.cast<double>() /values.rows();
// Fraction of each class per value
MatrixXd fractions_yx = divide_colwise( T.cast<double>(),
total_per_value.cast<double>());
// Gini impurity for each value: sum fractions^2 over the rows
VectorXd G = fractions_yx.array().square().rowwise().sum();
double total_gini = 1 - probability_of_value.transpose() * G;
VectorXi counts = T.colwise().sum();
double gain = gini(counts.cast<double>()) - total_gini;
return gain;
}
static void updateSentenceCounts(MatrixXi& counts, const Sentence& sentence) {
int last_tag = -1;
for (const pair<Tag, string>& taggedWord : sentence.words) {
int tag = taggedWord.first;
assert (last_tag+1 < counts.rows());
assert(tag+1 < counts.cols());
counts(tag+1, last_tag+1) += 1;
last_tag = tag;
}
// Now update transition to final state.
counts(counts.cols()-1, last_tag+1) += 1;
}
MatrixXi duplicatematrix(int n){
MatrixXi D;
D.setZero(n*n,n*(n-1)/2 + n);
int k = n;
int l = n;
for(int i=0;i<n;i++){
D(i*n+i,i) = 1;
for(int j=i+1;j<n;j++){
D(i*n + j,k++) = 1;
D(j*n + i,l++) = 1;
}
}
return D;
}
void printMatrix(MatrixXi &mat, string &crypted) {
int n = mat.rows();
for(int i = 0; i < n; ++i) {
char c = (mat(i, 0) % 26) + 65;
crypted += c;
}
}
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;
}
}
}
static void initCounts(MatrixXi& counts, size_t size) {
counts = counts.Constant(size, size,
1); // prior counts for Laplace smoothing, 0 for MLE
// No transitions to initial state!
for (size_t i = 0; i < size; i++)
counts(0, i) = 0;
}
// Read a surface mesh from a {.obj|.off|.mesh} files
// Inputs:
// mesh_filename path to {.obj|.off|.mesh} file
// Outputs:
// V #V by 3 list of mesh vertex positions
// F #F by 3 list of triangle indices
// Returns true only if successfuly able to read file
bool load_mesh_from_file(
const std::string mesh_filename,
Eigen::MatrixXd & V,
Eigen::MatrixXi & F)
{
using namespace std;
using namespace igl;
using namespace Eigen;
string dirname, basename, extension, filename;
pathinfo(mesh_filename,dirname,basename,extension,filename);
transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
bool success = false;
if(extension == "obj")
{
success = readOBJ(mesh_filename,V,F);
}else if(extension == "off")
{
success = readOFF(mesh_filename,V,F);
}else if(extension == "mesh")
{
// Unused Tets read from .mesh file
MatrixXi Tets;
success = readMESH(mesh_filename,V,Tets,F);
// We're not going to use any input tets. Only the surface
if(Tets.size() > 0 && F.size() == 0)
{
// If Tets read, but no faces then use surface of tet volume
}else
{
// Rearrange vertices so that faces come first
VectorXi IM;
faces_first(V,F,IM);
// Dont' bother reordering Tets, but this is how one would:
//Tets =
// Tets.unaryExpr(bind1st(mem_fun( static_cast<VectorXi::Scalar&
// (VectorXi::*)(VectorXi::Index)>(&VectorXi::operator())),
// &IM)).eval();
// Don't throw away any interior vertices, since user may want weights
// there
}
}else
{
cerr<<"Error: Unknown shape file format extension: ."<<extension<<endl;
return false;
}
return success;
}
void igl::is_boundary_edge(
const Eigen::PlainObjectBase<DerivedE> & E,
const Eigen::PlainObjectBase<DerivedF> & F,
Eigen::PlainObjectBase<DerivedB> & B)
{
using namespace Eigen;
using namespace std;
// Should be triangles
assert(F.cols() == 3);
// Should be edges
assert(E.cols() == 2);
// number of faces
const int m = F.rows();
// Collect all directed edges after E
MatrixXi EallE(E.rows()+3*m,2);
EallE.block(0,0,E.rows(),E.cols()) = E;
for(int e = 0;e<3;e++)
{
for(int f = 0;f<m;f++)
{
for(int c = 0;c<2;c++)
{
// 12 20 01
EallE(E.rows()+m*e+f,c) = F(f,(c+1+e)%3);
}
}
}
// sort directed edges into undirected edges
MatrixXi sorted_EallE,_;
sort(EallE,2,true,sorted_EallE,_);
// Determine unique undirected edges E and map to directed edges EMAP
MatrixXi uE;
VectorXi EMAP;
unique_rows(sorted_EallE,uE,_,EMAP);
// Counts of occurances
VectorXi N = VectorXi::Zero(uE.rows());
for(int e = 0;e<EMAP.rows();e++)
{
N(EMAP(e))++;
}
B.resize(E.rows());
// Look of occurances of 2: one for original and another for boundary
for(int e = 0;e<E.rows();e++)
{
B(e) = (N(EMAP(e)) == 2);
}
}
int main(int argc, char *argv[])
{
using namespace Eigen;
using namespace std;
MatrixXd V;
MatrixXi F;
// Load a mesh in OFF format
igl::readOFF("../shared/cheburashka.off", V, F);
// Read scalar function values from a file, U: #V by 1
VectorXd U;
igl::readDMAT("../shared/cheburashka-scalar.dmat",U);
// Compute gradient operator: #F*3 by #V
SparseMatrix<double> G;
igl::grad(V,F,G);
// Compute gradient of U
MatrixXd GU = Map<const MatrixXd>((G*U).eval().data(),F.rows(),3);
// Compute gradient magnitude
const VectorXd GU_mag = GU.rowwise().norm();
igl::viewer::Viewer viewer;
viewer.data.set_mesh(V, F);
// Compute pseudocolor for original function
MatrixXd C;
igl::jet(U,true,C);
// // Or for gradient magnitude
//igl::jet(GU_mag,true,C);
viewer.data.set_colors(C);
// Average edge length divided by average gradient (for scaling)
const double max_size = igl::avg_edge_length(V,F) / GU_mag.mean();
// Draw a black segment in direction of gradient at face barycenters
MatrixXd BC;
igl::barycenter(V,F,BC);
const RowVector3d black(0,0,0);
viewer.data.add_edges(BC,BC+max_size*GU, black);
// Hide wireframe
viewer.core.show_lines = false;
viewer.launch();
}
static void countsToProbs(MatrixXd& probs, const MatrixXi counts) {
// Now form probability matrix from counts
for (size_t col = 0; col < counts.cols(); col++) {
double sum = 0;
for (size_t row = 0; row < counts.rows(); row++) {
sum += counts(row, col);
}
assert(sum > 0);
for (size_t row = 0; row < counts.rows(); row++) {
probs(row, col) = counts(row, col) / sum;
// NaN != NaN, this tests that it's not NaN
assert(probs(row, col) == probs(row, col));
assert(probs(row, col) >= 0);
assert(probs(row, col) <= 1);
}
}
}
// function used internally, which computes lasso fits for subsets containing a
// small number of observations (typically only 3) and returns the indices of
// the respective h observations with the smallest absolute residuals
MatrixXi sparseSubsets(const MatrixXd& x, const VectorXd& y,
const double& lambda, const int& h, const MatrixXi& subsets,
const bool& normalize, const bool& useIntercept,
const double& eps, const bool& useGram) {
const int nsamp = subsets.cols();
MatrixXi indices(h, nsamp);
for(int k = 0; k < nsamp; k++) {
// compute lasso fit
double intercept, crit;
VectorXd coefficients, residuals;
fastLasso(x, y, lambda, true, subsets.col(k), normalize, useIntercept,
eps, useGram, false, intercept, coefficients, residuals, crit);
// find h observations with smallest absolute residuals
indices.col(k) = findSmallest(residuals.cwiseAbs(), h);
}
return indices;
}
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);
}
Density_2(const MatrixXd& X,
const VectorXd& f,
const MatrixXi& tri) : gen(clock())
{
size_t N = X.rows();
assert(X.cols() == 2);
assert(f.cols() == 1);
assert(f.rows() == N);
assert(tri.cols() == 3);
CGAL::Triangulation_incremental_builder_2<T> builder(_t);
builder.begin_triangulation();
// add vertices
std::vector<T::Vertex_handle> vertices(N);
for (size_t i = 0; i < N; ++i)
{
Point p(X(i,0),X(i,1));
vertices[i] = builder.add_vertex(Point(X(i,0), X(i,1)));
vertices[i]->info() = i;
}
// add faces
size_t Nt = tri.rows();
for (size_t i = 0; i < Nt; ++i)
{
int a = tri(i,0), b = tri(i,1), c = tri(i,2);
builder.add_face(vertices[a], vertices[b], vertices[c]);
}
builder.end_triangulation();
// compute functions
for (T::Finite_faces_iterator it = _t.finite_faces_begin ();
it != _t.finite_faces_end(); ++it)
{
size_t a = it->vertex(0)->info();
size_t b = it->vertex(1)->info();
size_t c = it->vertex(2)->info();
_functions[it] = Function(vertices[a]->point(), f[a],
vertices[b]->point(), f[b],
vertices[c]->point(), f[c]);
}
}
void parameters::Probapost(model mod, const MatrixXi & mat){
const MatrixXi & omega=mod.Get_model();
m_proba=MatrixXd::Ones(mat.rows(),omega.rows());
for (int k = 0; k < omega.rows(); ++k) {
m_proba_block[k]=m_proba_block[k].Ones(mat.rows(),(omega.rowwise().maxCoeff()(k)+1));
for (int b = 0; b < (omega.rowwise().maxCoeff()(k)+1); ++b){
if ((omega.row(k).array()==b).any()){
const VectorXi & who=mod.Get_var_block(k,b);
if (who.rows()>1){
m_proba_block[k].col(b)=m_param[k][b].proba_indpt(who,mat)+m_param[k][b].proba_dpt(who,mat);
}else{
m_proba_block[k].col(b)=m_param[k][b].proba_indpt(who,mat);
}
}
}
m_proba.col(k)=m_propor(k)* (m_proba_block[k].rowwise().prod()).array();
}
}
bool EventModel::loadEventData(QFile& qFile)
{
beginResetModel();
clearModel();
// Read events
MatrixXi events;
if(!MNE::read_events(qFile, events)) {
qDebug() << "Error while reading events.";
return false;
}
//std::cout << events << endl;
qDebug() << QString("Events read from %1").arg(qFile.fileName());
//set loaded fiff event data
for(int i = 0; i < events.rows(); i++) {
m_dataSamples.append(events(i,0));
m_dataTypes.append(events(i,2));
m_dataIsUserEvent.append(0);
}
//Set filtered events to original
m_dataSamples_Filtered = m_dataSamples;
m_dataTypes_Filtered = m_dataTypes;
m_dataIsUserEvent_Filtered = m_dataIsUserEvent;
//Create type string list
m_eventTypeList.clear();
for(int i = 0; i<m_dataTypes.size(); i++)
if(!m_eventTypeList.contains(QString().number(m_dataTypes[i])))
m_eventTypeList<<QString().number(m_dataTypes[i]);
emit updateEventTypes("All");
endResetModel();
m_bFileloaded = true;
return true;
}
void NeighbourJoining::calcNJ(MatrixXf& D, MatrixXi& rowsID, BuildNJTree& LTM,
int numOccupiedNodes) {
MatrixXf currentD(rowsID.rows() + 1, rowsID.rows() + 1);
configure(D, currentD, rowsID, numOccupiedNodes);
MatrixXf Q(currentD.rows(), currentD.cols());
LTM.configure(rowsID, numOccupiedNodes);
//BuildNJTree* LTM = new BuildNJTree(D.rows() + numOccupiedNodes, rowsID);
//grows LTM till there are at least two nodes left
while (numCurrentNodes > 2) {
calcQ(currentD, Q);
findMinQ(Q, rowsID, pair);
updateD(D, currentD, pair, 2 * numObservableNodes - numCurrentNodes + numOccupiedNodes);
calcNewD(currentD, rowsID, pair);
LTM.addClosestPair(pair);
--numCurrentNodes;
}
LTM.connectLast2Nodes();
}
//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;
}
}
}
