double compute_max_step_from_singularities(const Eigen::MatrixXd& uv, const Eigen::MatrixXi& F, Eigen::MatrixXd& d) { double max_step = INFINITY; // The if statement is outside the for loops to avoid branching/ease parallelizing if (uv.cols() == 2) { for (int f = 0; f < F.rows(); f++) { double min_positive_root = get_min_pos_root_2D(uv,F,d,f); max_step = min(max_step, min_positive_root); } } else { // volumetric deformation for (int f = 0; f < F.rows(); f++) { double min_positive_root = get_min_pos_root_3D(uv,F,d,f); max_step = min(max_step, min_positive_root); } } return max_step; }
/* Train the classifier with the dataset of breastcancer patients from the LibSVM Libary */ void TrainSVMClassifier_BreastCancerDataSet_shouldReturnTrue() { /* Declarating an featurematrixdataset, the first matrix of the matrixpair is the trainingmatrix and the second one is the testmatrix.*/ std::pair<MatrixDoubleType,MatrixDoubleType> matrixDouble; matrixDouble = convertCSVToMatrix<double>(GetTestDataFilePath("Classification/FeaturematrixBreastcancer.csv"),';',0.5,true); m_TrainingMatrixX = matrixDouble.first; m_TestXPredict = matrixDouble.second; /* The declaration of the labelmatrixdataset is equivalent to the declaration of the featurematrixdataset.*/ std::pair<MatrixIntType,MatrixIntType> matrixInt; matrixInt = convertCSVToMatrix<int>(GetTestDataFilePath("Classification/LabelmatrixBreastcancer.csv"),';',0.5,false); m_TrainingLabelMatrixY = matrixInt.first; m_TestYPredict = matrixInt.second; /* Setting of the SVM-Parameters*/ classifier = mitk::LibSVMClassifier::New(); classifier->SetGamma(1/(double)(m_TrainingMatrixX.cols())); classifier->SetSvmType(0); classifier->SetKernelType(2); /* Train the classifier, by giving trainingdataset for the labels and features. The result in an colunmvector of the labels.*/ classifier->Train(m_TrainingMatrixX,m_TrainingLabelMatrixY); Eigen::MatrixXi classes = classifier->Predict(m_TestXPredict); /* Testing the matching between the calculated colunmvector and the result of the SVM */ unsigned int maxrows = classes.rows(); bool isYPredictVector = false; int count = 0; for(int i= 0; i < maxrows; i++){ if(classes(i,0) == m_TestYPredict(i,0)){ isYPredictVector = true; count++; } } MITK_INFO << 100*count/(double)(maxrows) << "%"; MITK_TEST_CONDITION(isIntervall<int>(m_TestYPredict,classes,75,100),"Testvalue is in range."); }
bool BlockSparseMatrix::ConjugateGradientSolve(const Eigen::MatrixXd& rhs, Eigen::MatrixXd& sol) { return LltSolve(rhs, sol); MatrixSolver* solver = new PCGSolver(); int numRows = rhs.rows(); int numCols = rhs.cols(); int num = numRows * numCols; double* result = new double[num]; double* rhsData = new double[num]; int ithElem = 0; for (int i = 0; i < numCols; ++i) { for (int j = 0; j < numRows; ++j) { rhsData[ithElem++] = rhs(j, i); } } if (mbCSRDirty) { mCSREquivalent.ConvertFromBlockSparseMatrix(*this); mbCSRDirty = false; } solver->SetMatrix(&mCSREquivalent); solver->SetRHS(rhsData, numCols); solver->Solve(result, true); sol = Eigen::MatrixXd::Zero(numRows, numCols); ithElem = 0; for (int i = 0; i < numCols; ++i) { for (int j = 0; j < numRows; ++j) { sol(j, i) = result[ithElem++]; } } delete[] rhsData; delete[] result; delete solver; return true; }
// Derived from code by Yohann Solaro ( http://listengine.tuxfamily.org/lists.tuxfamily.org/eigen/2010/01/msg00187.html ) // see : http://en.wikipedia.org/wiki/Moore-Penrose_pseudoinverse#The_general_case_and_the_SVD_method Eigen::MatrixXd pinv( const Eigen::MatrixXd &b, double rcond ) { // TODO: Figure out why it wants fewer rows than columns // if ( a.rows()<a.cols() ) // return false; bool flip = false; Eigen::MatrixXd a; if( a.rows() < a.cols() ) { a = b.transpose(); flip = true; } else a = b; // SVD Eigen::JacobiSVD<Eigen::MatrixXd> svdA; svdA.compute( a, Eigen::ComputeFullU | Eigen::ComputeThinV ); Eigen::JacobiSVD<Eigen::MatrixXd>::SingularValuesType vSingular = svdA.singularValues(); // Build a diagonal matrix with the Inverted Singular values // The pseudo inverted singular matrix is easy to compute : // is formed by replacing every nonzero entry by its reciprocal (inversing). Eigen::VectorXd vPseudoInvertedSingular( svdA.matrixV().cols() ); for (int iRow=0; iRow<vSingular.rows(); iRow++) { if ( fabs(vSingular(iRow)) <= rcond ) { vPseudoInvertedSingular(iRow)=0.; } else vPseudoInvertedSingular(iRow)=1./vSingular(iRow); } // A little optimization here Eigen::MatrixXd mAdjointU = svdA.matrixU().adjoint().block( 0, 0, vSingular.rows(), svdA.matrixU().adjoint().cols() ); // Pseudo-Inversion : V * S * U' Eigen::MatrixXd a_pinv = (svdA.matrixV() * vPseudoInvertedSingular.asDiagonal()) * mAdjointU; if( flip ) { a = a.transpose(); a_pinv = a_pinv.transpose(); } return a_pinv; }
IGL_INLINE void igl::n_polyvector_general(const Eigen::MatrixXd &V, const Eigen::MatrixXi &F, const Eigen::VectorXi& b, const Eigen::MatrixXd& bc, const Eigen::VectorXi &I, Eigen::MatrixXd &output) { Eigen::VectorXi isConstrained = Eigen::VectorXi::Constant(F.rows(),0); Eigen::MatrixXd cfW = Eigen::MatrixXd::Constant(F.rows(),bc.cols(),0); for(unsigned i=0; i<b.size();++i) { isConstrained(b(i)) = 1; cfW.row(b(i)) << bc.row(i); } int n = I.rows(); igl::GeneralPolyVectorFieldFinder<Eigen::MatrixXd, Eigen::MatrixXi> pvff(V,F,n); pvff.solve(isConstrained, cfW, I, output); }
//! Function to read the amplitudes and fundamental argument multiplers for tidal corrections std::pair< Eigen::MatrixXd, Eigen::MatrixXd > readAmplitudesAndFundamentalArgumentMultipliers( const std::string amplitudesFile, const std::string fundamentalArgumentMultipliersFile, const double minimumAmplitude ) { // Read amplitudes and fundamental argument multipliers into matrices. Eigen::MatrixXd amplitudesRaw = input_output::readMatrixFromFile( amplitudesFile ); Eigen::MatrixXd fundamentalArgumentMultipliersRaw = input_output::readMatrixFromFile( fundamentalArgumentMultipliersFile ); // Check whether amplitudes and fundamental argument multipliers matrices have same number of rows if( amplitudesRaw.rows( ) != fundamentalArgumentMultipliersRaw.rows( ) ) { throw std::runtime_error( "Amplitude and argument multipler files contain unequal set of entries" ); } // Check whether number of columns in fundamental argument multiplier matrix is equal to 6. if( fundamentalArgumentMultipliersRaw.cols( ) != 6 ) { throw std::runtime_error( "Number of columns in fundamental argument multipler matrix not equal to 6" ); } // If acceptance amplitude is larger than 0.0 check RSS of amplitudes for each entry. Eigen::MatrixXd fundamentalArgumentMultipliers, amplitudes; if( minimumAmplitude > 0.0 ) { // Filter raw data and remove entries with RSS amplitude that is too low std::pair< Eigen::MatrixXd, Eigen::MatrixXd > filteredData = filterRawDataForAmplitudes( fundamentalArgumentMultipliersRaw, amplitudesRaw, minimumAmplitude ); amplitudes = filteredData.first; fundamentalArgumentMultipliers = filteredData.second; } // If all amplitudes are to be expected, raw data is same as return data. else { amplitudes = amplitudesRaw; fundamentalArgumentMultipliers = fundamentalArgumentMultipliersRaw; } // return amplitudes and fundamental argument multipliers. return std::pair< Eigen::MatrixXd, Eigen::MatrixXd >( amplitudes, fundamentalArgumentMultipliers ); }
void RBMTestCase::inputGradient() { OpenANN::OutputInfo info; info.dimensions.push_back(3); OpenANN::RBM layer(3, 2, 1, 0.01, 0.0, true); LayerAdapter opt(layer, info); Eigen::MatrixXd X = Eigen::MatrixXd::Random(2, 3); Eigen::MatrixXd Y = Eigen::MatrixXd::Random(2, 2); opt.trainingSet(X, Y); Eigen::MatrixXd gradient = opt.inputGradient(); ASSERT_EQUALS(gradient.rows(), 2); Eigen::MatrixXd estimatedGradient = OpenANN::FiniteDifferences:: inputGradient(X, Y, opt); ASSERT_EQUALS(estimatedGradient.rows(), 2); for(int j = 0; j < gradient.rows(); j++) for(int i = 0; i < gradient.cols(); i++) ASSERT_EQUALS_DELTA(gradient(j, i), estimatedGradient(j, i), 1e-10); }
//------------------------------------------------------------------------------ void LocalAssembler::assemble_exterior_facet(Eigen::MatrixXd& A, UFC& ufc, const std::vector<double>& vertex_coordinates, const ufc::cell& ufc_cell, const Cell& cell, const Facet& facet, const std::size_t local_facet, const MeshFunction<std::size_t>* domains) { // Skip if there are no exterior facet integrals if (!ufc.form.has_exterior_facet_integrals()) return; // Extract default exterior facet integral ufc::exterior_facet_integral* integral = ufc.default_exterior_facet_integral.get(); // Get integral for sub domain (if any) if (domains && !domains->empty()) integral = ufc.get_exterior_facet_integral((*domains)[facet]); // Skip integral if zero if (!integral) return; // Update to current cell ufc.update(cell, vertex_coordinates, ufc_cell, integral->enabled_coefficients()); // Tabulate exterior facet tensor integral->tabulate_tensor(ufc.A.data(), ufc.w(), vertex_coordinates.data(), local_facet, ufc_cell.orientation); // Stuff a_ufc.A into A const std::size_t M = A.rows(); const std::size_t N = A.cols(); for (std::size_t i = 0; i < M; i++) for (std::size_t j = 0; j < N; j++) A(i, j) += ufc.A[N*i + j]; }
void BranchList::smoothBranchPositions() { for (int i = 0; i < mBranches.size(); i++) { Eigen::MatrixXd positions = mBranches[i]->getPositions(); int numberOfInputPoints = positions.cols(); int controlPointFactor = 5; int numberOfControlPoints = numberOfInputPoints / controlPointFactor; vtkCardinalSplinePtr splineX = vtkSmartPointer<vtkCardinalSpline>::New(); vtkCardinalSplinePtr splineY = vtkSmartPointer<vtkCardinalSpline>::New(); vtkCardinalSplinePtr splineZ = vtkSmartPointer<vtkCardinalSpline>::New(); if (numberOfControlPoints >= 2) { //add control points to spline for(int j=0; j<numberOfControlPoints; j++) { int indexP = (j*numberOfInputPoints)/numberOfControlPoints; splineX->AddPoint(indexP,positions(0,indexP)); splineY->AddPoint(indexP,positions(1,indexP)); splineZ->AddPoint(indexP,positions(2,indexP)); } //Always add the last point to complete spline splineX->AddPoint(numberOfInputPoints-1,positions(0,numberOfInputPoints-1)); splineY->AddPoint(numberOfInputPoints-1,positions(1,numberOfInputPoints-1)); splineZ->AddPoint(numberOfInputPoints-1,positions(2,numberOfInputPoints-1)); //evaluate spline - get smoothed positions Eigen::MatrixXd smoothingResult(3 , numberOfInputPoints); for(int j=0; j<numberOfInputPoints; j++) { double splineParameter = j; smoothingResult(0,j) = splineX->Evaluate(splineParameter); smoothingResult(1,j) = splineY->Evaluate(splineParameter); smoothingResult(2,j) = splineZ->Evaluate(splineParameter); } mBranches[i]->setPositions(smoothingResult); } } }
//! Initialize atmosphere table reader. void TabulatedAtmosphere::initialize( const std::string& atmosphereTableFile ) { // Locally store the atmosphere table file name. atmosphereTableFile_ = atmosphereTableFile; Eigen::MatrixXd containerOfAtmosphereTableFileData = input_output::readMatrixFromFile( atmosphereTableFile_, " \t", "%" ); // Check whether data is present in the file. if ( containerOfAtmosphereTableFileData.rows( ) < 1 || containerOfAtmosphereTableFileData.cols( ) < 1 ) { std::cerr << "The atmosphere table file is empty." << std::endl; std::cerr << atmosphereTableFile_ << std::endl; } // Initialize vectors. altitudeData_.resize( containerOfAtmosphereTableFileData.rows( ) ); densityData_.resize( containerOfAtmosphereTableFileData.rows( ) ); pressureData_.resize( containerOfAtmosphereTableFileData.rows( ) ); temperatureData_.resize( containerOfAtmosphereTableFileData.rows( ) ); // Loop through all the strings stored in the container and store the data // in the right Eigen::VectorXd. for ( int i = 0; i < containerOfAtmosphereTableFileData.rows( ); i++ ) { altitudeData_[ i ] = containerOfAtmosphereTableFileData( i, 0 ); densityData_[ i ] = containerOfAtmosphereTableFileData( i, 1 ); pressureData_[ i ] = containerOfAtmosphereTableFileData( i, 2 ); temperatureData_[ i ] = containerOfAtmosphereTableFileData( i, 3 ); } using namespace interpolators; cubicSplineInterpolationForDensity_ = boost::make_shared< CubicSplineInterpolatorDouble >( altitudeData_, densityData_ ); cubicSplineInterpolationForPressure_ = boost::make_shared< CubicSplineInterpolatorDouble >( altitudeData_, pressureData_ ); cubicSplineInterpolationForTemperature_ = boost::make_shared< CubicSplineInterpolatorDouble >( altitudeData_, temperatureData_ ); }
bool pre_draw(igl::opengl::glfw::Viewer & viewer) { using namespace Eigen; using namespace std; if(viewer.core.is_animating) { // Interpolate pose and identity RotationList anim_pose(pose.size()); for(int e = 0;e<pose.size();e++) { anim_pose[e] = pose[e].slerp(anim_t,Quaterniond::Identity()); } // Propagate relative rotations via FK to retrieve absolute transformations RotationList vQ; vector<Vector3d> vT; igl::forward_kinematics(C,BE,P,anim_pose,vQ,vT); const int dim = C.cols(); MatrixXd T(BE.rows()*(dim+1),dim); for(int e = 0;e<BE.rows();e++) { Affine3d a = Affine3d::Identity(); a.translate(vT[e]); a.rotate(vQ[e]); T.block(e*(dim+1),0,dim+1,dim) = a.matrix().transpose().block(0,0,dim+1,dim); } // Compute deformation via LBS as matrix multiplication U = M*T; // Also deform skeleton edges MatrixXd CT; MatrixXi BET; igl::deform_skeleton(C,BE,T,CT,BET); viewer.data().set_vertices(U); viewer.data().set_edges(CT,BET,sea_green); viewer.data().compute_normals(); anim_t += anim_t_dir; anim_t_dir *= (anim_t>=1.0 || anim_t<=0.0?-1.0:1.0); } return false; }
IGL_INLINE void igl::ViewerData::add_points(const Eigen::MatrixXd& P, const Eigen::MatrixXd& C) { Eigen::MatrixXd P_temp; // If P only has two columns, pad with a column of zeros if (P.cols() == 2) { P_temp = Eigen::MatrixXd::Zero(P.rows(),3); P_temp.block(0,0,P.rows(),2) = P; } else P_temp = P; int lastid = points.rows(); points.conservativeResize(points.rows() + P_temp.rows(),6); for (unsigned i=0; i<P_temp.rows(); ++i) points.row(lastid+i) << P_temp.row(i), i<C.rows() ? C.row(i) : C.row(C.rows()-1); dirty |= DIRTY_OVERLAY_POINTS; }
// Trying to assign from matrix to noOfPoints void mitk::LibSVMClassifier::ReadXValues(LibSVM::svm_problem * problem, LibSVM::svm_node** xSpace, const Eigen::MatrixXd &X) { auto noOfPoints = static_cast<int>(X.rows()); auto features = static_cast<int>(X.cols()); problem->x = static_cast<LibSVM::svm_node **>(malloc(sizeof(LibSVM::svm_node *) * noOfPoints)); (*xSpace) = static_cast<LibSVM::svm_node *> (malloc(sizeof(LibSVM::svm_node) * noOfPoints * (features+1))); for (int row = 0; row < noOfPoints; ++row) { for (int col = 0; col < features; ++col) { (*xSpace)[row*features + col].index = col; (*xSpace)[row*features + col].value = X(row,col); } (*xSpace)[row*features + features].index = -1; problem->x[row] = &((*xSpace)[row*features]); } }
bool init_weights( const Eigen::MatrixXd & V, const Eigen::MatrixXi & F, const Eigen::MatrixXd & C, const Eigen::MatrixXi & BE, Eigen::MatrixXd & W) { using namespace igl; using namespace Eigen; // Mesh with samples on skeleton // New vertices of tet mesh, V prefaces VV MatrixXd VV; MatrixXi TT,FF,CE; VectorXi P; if(!mesh_with_skeleton(V,F,C,P,BE,CE,10,VV,TT,FF)) { return false; } // List of boundary indices (aka fixed value indices into VV) VectorXi b; // List of boundary conditions of each weight function MatrixXd bc; if(!boundary_conditions(VV,TT,C,P,BE,CE,b,bc)) { return false; } // compute BBW // Default bbw data and flags BBWData bbw_data; bbw_data.active_set_params.max_iter = 4; // Weights matrix if(!bbw(VV,TT,b,bc,bbw_data,W)) { return false; } // Normalize weights to sum to one normalize_row_sums(W,W); W.conservativeResize(V.rows(),W.cols()); return true; }
double accuracy( const Eigen::MatrixXd& X, const Eigen::VectorXd& y, const Eigen::VectorXd& theta ) { const unsigned N = X.rows(), K = X.cols(); // Eigen:::VectorXd p; // p.resize(N, 0); p.setZero(); double correct = 0.0; Eigen::VectorXd xtheta = X*theta; Eigen::VectorXd predicted; maths::Sigmoid()( predicted, xtheta ); std::cout << predicted << std::endl; for ( size_t i = 0; i < N; ++i ) { int p = predicted[i]> 0.5 ? 1 : 0; // printf("%d, %d, %f\n", ) if ( p == y(i,0) ) ++correct; } return correct / N; }
void setMatrix(PETScMatrix& m, Eigen::MatrixXd const& tmp) { using IndexType = PETScMatrix::IndexType; auto const rows = tmp.rows(); auto const cols = tmp.cols(); assert(rows == m.getNumberOfRows() && cols == m.getNumberOfColumns()); m.setZero(); std::vector<IndexType> row_idcs(rows); std::vector<IndexType> col_idcs(cols); std::iota(row_idcs.begin(), row_idcs.end(), 0); std::iota(col_idcs.begin(), col_idcs.end(), 0); // PETSc wants row-major Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> tmp_ = tmp; m.add(row_idcs, col_idcs, tmp_); }
double computePlaneToPlaneHomographyError( const Eigen::MatrixXd &points1, const Eigen::MatrixXd &points2, const Eigen::MatrixXd &H, Eigen::VectorXd &error ) { double sum = 0; unsigned int nPoints = points1.cols(); error.resize( nPoints ); for( unsigned int i = 0; i < nPoints; i++ ) { Eigen::Vector3d p1 = H * points1.col(i).homogeneous(); Eigen::Vector3d p2 = points2.col(i).homogeneous(); p1 /= p1[2]; double err = (p1 - p2).norm(); sum += error[i] = err * err; } return sum / double( nPoints ); }
void PCATestCase::dimensionalityReduction() { OpenANN::RandomNumberGenerator rng; const int N = 100; const int D = 5; Eigen::MatrixXd X(N, D); rng.fillNormalDistribution(X); // Strong correlation Eigen::MatrixXd A = Eigen::MatrixXd::Identity(D, D) * 0.5 + Eigen::MatrixXd::Ones(D, D); Eigen::MatrixXd Xt = X * A.transpose(); // Dimensionality reduction OpenANN::PCA pca(1); pca.fit(Xt); Eigen::MatrixXd Y = pca.transform(Xt); ASSERT_EQUALS(Y.rows(), N); ASSERT_EQUALS(Y.cols(), 1); ASSERT_EQUALS(pca.explainedVarianceRatio().rows(), 1); ASSERT(pca.explainedVarianceRatio().sum() > 0.9); }
//============================================================================== Eigen::VectorXd Spline::evaluatePolynomial( const Eigen::MatrixXd& _coefficients, double _t, int _derivative) { const auto numOutputs = _coefficients.rows(); const auto numCoeffs = _coefficients.cols(); const auto timeVector = common::SplineProblem<>::createTimeVector(_t, _derivative, numCoeffs); const auto derivativeMatrix = common::SplineProblem<>::createCoefficientMatrix(numCoeffs); const auto derivativeVector = derivativeMatrix.row(_derivative); const auto evaluationVector = derivativeVector.cwiseProduct(timeVector.transpose()); Eigen::VectorXd outputVector(numOutputs); for (int ioutput = 0; ioutput < numOutputs; ++ioutput) outputVector[ioutput] = _coefficients.row(ioutput).dot(evaluationVector); return outputVector; }
Eigen::VectorXd BicZ_j_cpp(Eigen::MatrixXd X,Eigen::MatrixXd Z,Eigen::VectorXd Bic_vide_vect,Eigen::VectorXd BicOld,double methode,int j) { int size=X.cols(); int sizerow = X.rows(); Eigen::VectorXd BicRes(size); Eigen::MatrixXd mat_var_a_droite; int k; //debut de la boucle colonne de Z BicRes=BicOld; //colonne de Z sur laquelle on va travailler (variable a gauche) Eigen::VectorXd colZ=Z.block(0,j,size,1); int newsize=colZ.sum(); //si la somme de la colonne=0 alors on appelle mixmod if(newsize==0) { BicRes(j)=Bic_vide_vect(j); } else { //calcul du nouveau BIC mat_var_a_droite.resize(sizerow,newsize); k=0; //on echerche l'emplacement des 1 dans le vecteur colonne (variables a droite) for(int p=0;p<size;p++) { if (colZ(p)==1) { //on regroupe les variables a droite dans une matrice mat_var_a_droite.block(0,k,sizerow,1)=X.block(0,p,sizerow,1); k=k+1; }//fin if }//fin for j //calcul de son BIC en appellant OLS (les parametres sont : Y=X[,colonne],X=X[,matrice des variables à droite]) BicRes(j)=BicLoc_cpp(mat_var_a_droite,X.block(0,j,sizerow,1),"T",methode); }//fin else return BicRes; }
// Helpers that draws the most common meshes IGL_INLINE void igl::ViewerData::set_mesh(const Eigen::MatrixXd& _V, const Eigen::MatrixXi& _F) { using namespace std; Eigen::MatrixXd V_temp; // If V only has two columns, pad with a column of zeros if (_V.cols() == 2) { V_temp = Eigen::MatrixXd::Zero(_V.rows(),3); V_temp.block(0,0,_V.rows(),2) = _V; } else V_temp = _V; if (V.rows() == 0 && F.rows() == 0) { clear(); V = V_temp; F = _F; compute_normals(); uniform_colors(Eigen::Vector3d(51.0/255.0,43.0/255.0,33.3/255.0), Eigen::Vector3d(255.0/255.0,228.0/255.0,58.0/255.0), Eigen::Vector3d(255.0/255.0,235.0/255.0,80.0/255.0)); grid_texture(); } else { if (_V.rows() == V.rows() && _F.rows() == F.rows()) { V = V_temp; F = _F; } else cerr << "ERROR (set_mesh): The new mesh has a different number of vertices/faces. Please clear the mesh before plotting."; } dirty |= DIRTY_FACE | DIRTY_POSITION; }
void ODELCPSolver::transferToODEFormulation(const Eigen::MatrixXd& _A, const Eigen::VectorXd& _b, Eigen::MatrixXd* _AOut, Eigen::VectorXd* _bOut, int _numDir, int _numContacts) { int numOtherConstrs = _A.rows() - _numContacts * (2 + _numDir); int n = _numContacts * 3 + numOtherConstrs; Eigen::MatrixXd AIntermediate = Eigen::MatrixXd::Zero(n, _A.cols()); *_AOut = Eigen::MatrixXd::Zero(n, n); *_bOut = Eigen::VectorXd::Zero(n); int offset = _numDir / 4; for (int i = 0; i < _numContacts; ++i) { AIntermediate.row(i) = _A.row(i); (*_bOut)[i] = _b[i]; AIntermediate.row(_numContacts + i * 2 + 0) = _A.row(_numContacts + i * _numDir + 0); AIntermediate.row(_numContacts + i * 2 + 1) = _A.row(_numContacts + i * _numDir + offset); (*_bOut)[_numContacts + i * 2 + 0] = _b[_numContacts + i * _numDir + 0]; (*_bOut)[_numContacts + i * 2 + 1] = _b[_numContacts + i * _numDir + offset]; } for (int i = 0; i < numOtherConstrs; i++) { AIntermediate.row(_numContacts * 3 + i) = _A.row(_numContacts * (_numDir + 2) + i); (*_bOut)[_numContacts * 3 + i] = _b[_numContacts * (_numDir + 2) + i]; } for (int i = 0; i < _numContacts; ++i) { _AOut->col(i) = AIntermediate.col(i); _AOut->col(_numContacts + i * 2 + 0) = AIntermediate.col(_numContacts + i * _numDir + 0); _AOut->col(_numContacts + i * 2 + 1) = AIntermediate.col(_numContacts + i * _numDir + offset); } for (int i = 0; i < numOtherConstrs; i++) _AOut->col(_numContacts * 3 + i) = AIntermediate.col(_numContacts * (_numDir + 2) + i); }
void evaluateSVDSPQRSolver(const Eigen::MatrixXd& A, const Eigen::VectorXd& b, const Eigen::VectorXd& x, double tol = 1e-9) { cholmod_common cholmod; cholmod_l_start(&cholmod); cholmod_sparse* A_CS = aslam::calibration::eigenDenseToCholmodSparseCopy(A, &cholmod); cholmod_dense b_CD; aslam::calibration::eigenDenseToCholmodDenseView(b, &b_CD); Eigen::VectorXd x_est; aslam::calibration::LinearSolver linearSolver; for (std::ptrdiff_t i = 1; i < A.cols(); ++i) { // double before = aslam::calibration::Timestamp::now(); linearSolver.solve(A_CS, &b_CD, i, x_est); // double after = aslam::calibration::Timestamp::now(); double error = (b - A * x_est).norm(); // std::cout << std::fixed << std::setprecision(18) << "noscale: " << "error: " // << error << " est_diff: " << (x - x_est).norm() << " time: " // << after - before << std::endl; ASSERT_NEAR(error, 0, tol); linearSolver.getOptions().columnScaling = true; // before = aslam::calibration::Timestamp::now(); linearSolver.solve(A_CS, &b_CD, i, x_est); // after = aslam::calibration::Timestamp::now(); error = (b - A * x_est).norm(); // std::cout << std::fixed << std::setprecision(18) << "onscale: " << "error: " // << error << " est_diff: " << (x - x_est).norm() << " time: " // << after - before << std::endl; linearSolver.getOptions().columnScaling = false; ASSERT_NEAR(error, 0, tol); // std::cout << "SVD rank: " << linearSolver.getSVDRank() << std::endl; // std::cout << "SVD rank deficiency: " << linearSolver.getSVDRankDeficiency() // << std::endl; // std::cout << "QR rank: " << linearSolver.getQRRank() << std::endl; // std::cout << "QR rank deficiency: " // << linearSolver.getQRRankDeficiency() << std::endl; // std::cout << "SV gap: " << linearSolver.getSvGap() << std::endl; } cholmod_l_free_sparse(&A_CS, &cholmod); cholmod_l_finish(&cholmod); }
Evrot::Evrot(Eigen::MatrixXd& X, int method): mMethod(method), mNumDims(X.cols()), mNumData(X.rows()), mNumAngles((int)(mNumDims*(mNumDims-1)/2)), // get the number of angles ik(Eigen::VectorXi(mNumAngles)), jk(Eigen::VectorXi(mNumAngles)), mX(X), mClusters(std::vector<std::vector<int> >(mNumDims)) //allocate clusters vector { // build index mapping (to index upper triangle) int k = 0; for( int i=0; i<mNumDims-1; i++ ){ for( int j=i+1; j<=mNumDims-1; j++ ){ ik[k] = i; jk[k] = j; k++; } } evrot(); }
IGL_INLINE void igl::ViewerData::set_edges( const Eigen::MatrixXd& P, const Eigen::MatrixXi& E, const Eigen::MatrixXd& C) { using namespace Eigen; lines.resize(E.rows(),9); assert(C.cols() == 3); for(int e = 0;e<E.rows();e++) { RowVector3d color; if(C.size() == 3) { color<<C; }else if(C.rows() == E.rows()) { color<<C.row(e); } lines.row(e)<< P.row(E(e,0)), P.row(E(e,1)), color; } dirty |= DIRTY_OVERLAY_LINES; }
std::tuple<Eigen::MatrixXd, Eigen::MatrixXd> lu_no_pivoting(const Eigen::MatrixXd & A) { Eigen::MatrixXd Acopy = A; int n = Acopy.rows(); assert(n == Acopy.cols()); Eigen::MatrixXd L(n,n); Eigen::MatrixXd U(n,n); L.triangularView<Eigen::StrictlyUpper>().setZero(); U.triangularView<Eigen::StrictlyLower>().setZero(); for (int k=0; k<n-1; k++) { lu_helper(k, n, &Acopy, &L, &U); } L(n-1,n-1) = 1; U(n-1,n-1) = Acopy(n-1,n-1); return std::make_tuple(L,U); }
void MassRegistration::show(std::vector<Eigen::MatrixXd> Xv, bool save, std::string filename, bool stop){ viewer->removeAllPointClouds(); srand(0); for(unsigned int xi = 0; xi < Xv.size(); xi++){ Eigen::MatrixXd X = Xv[xi]; pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZRGBNormal>); int r = 256*(1+(rand()%4))/4 - 1;//255*((xi+1) & 1); int g = 256*(1+(rand()%4))/4 - 1;//255*((xi+1) & 1); int b = 256*(1+(rand()%4))/4 - 1;//255*(xi & 1); unsigned int nr_data = X.cols(); cloud->points.clear(); for(unsigned int i = 0; i < nr_data; i++){ pcl::PointXYZRGBNormal p; p.x = X(0,i); p.y = X(1,i); p.z = X(2,i); p.b = r; p.g = g; p.r = b; cloud->points.push_back(p); } char buf [1024]; sprintf(buf,"cloud%i",xi); viewer->addPointCloud<pcl::PointXYZRGBNormal> (cloud, pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGBNormal>(cloud), buf); } if(!save){ viewer->spin(); }else{ viewer->spinOnce(); } //void pcl::visualization::PCLVisualizerInteractorStyle::saveScreenshot ( const std::string & file ) if(save){ printf("saving: %s\n",filename.c_str()); viewer->saveScreenshot(filename); } viewer->removeAllPointClouds(); }
Balloon::Balloon(double r, double dt, Eigen::MatrixXd positions, Eigen::MatrixXi faces) : ParticleObject(r) { m_radius = r; m_step = dt; m_positions = positions; m_speeds = Eigen::MatrixXd::Zero(positions.rows(), positions.cols()); m_forces = Eigen::MatrixXd::Zero(m_positions.rows(), m_positions.cols()); m_num_point = m_positions.rows(); m_mass = m_mass_all / (double)m_num_point; c = 2.0*sqrt(m_mass*k)/3.0; m_faces = faces; m_faceactive = Eigen::VectorXi::Zero(m_faces.rows()); for(int i=0; i<m_faceactive.rows(); i++) { m_faceactive(i) = 1; } igl::adjacency_list(m_faces, m_adjacency_list); igl::triangle_triangle_adjacency(m_positions, m_faces, m_facetoface); std::vector<std::vector<int>> tmp_list; igl::vertex_triangle_adjacency(m_positions, m_faces, m_vertextoface, tmp_list); initEdges(); computeNormals(); calcAveRadius(); m_threshold_ratio = Eigen::VectorXd::Ones(m_edges.rows()) * threshold_ratio; // for(int i=0; i<m_positions.rows(); i++){ // // std::cout << "adjacent to " << i << ": " << m_adjacency_list[i].size() << std::endl; // } // for(int i=0; i<m_positions.rows(); i++){ // // std::cout << "normal " << i << ": " << m_normals.norm() << std::endl; // } }
QPair<Eigen::MatrixXd, QList<int> > Epidetect::prepareData(Eigen::MatrixXd mat) { MatrixXd trimmedMatrix; QList<int> stimLocations; QStringList badChs = m_pFiffInfo->bads; QStringList chNames = m_pFiffInfo->ch_names; trimmedMatrix.resize(mat.rows()- badChs.size(), mat.cols()); int j = 0; for (int i=0 ; i < mat.rows(); i++) { QString type = m_pFiffInfo->channel_type(i); if (type == "stim") stimLocations << i; if (!(badChs.contains(chNames[i]))) { if ((type != "stim") && (type != "ecg") && (type != "eeg")) { trimmedMatrix.row(j) = mat.row(i); j++; } } } qSort(stimLocations); trimmedMatrix.conservativeResize(j,trimmedMatrix.cols()); QPair<MatrixXd, QList<int> > out; out.first = trimmedMatrix; out.second = stimLocations; return out; }
//============================================================================== void Spline::addSegment( const Eigen::MatrixXd& _coefficients, double _duration, const statespace::StateSpace::State* _startState) { if (_duration <= 0.) throw std::invalid_argument("Duration must be positive."); if (static_cast<std::size_t>(_coefficients.rows()) != mStateSpace->getDimension()) throw std::invalid_argument("Incorrect number of dimensions."); if (_coefficients.cols() < 1) throw std::invalid_argument("At least one coefficient is required."); PolynomialSegment segment; segment.mCoefficients = _coefficients; segment.mDuration = _duration; segment.mStartState = mStateSpace->allocateState(); mStateSpace->copyState(_startState, segment.mStartState); mSegments.emplace_back(std::move(segment)); }