//**********************************************************
//forward computation: without epi
//*********************************************************
void FECG(char** filNamBEM, char** filNamMFree, char** filOutput,
char** TransOutput)
{
matEg engine(MAX_BUF);
cout << "\n **construct BEM class**\n" << endl;
BEM_source bem(filNamBEM, filNamMFree, Tri3);
cout << "\n **BEM Computing**\n" << endl;
bem.BEMCompute(filOutput);
int numSur = bem.getNumSur();
int numVol = bem.getNumVol();
double* K = bem.getBEMK();
// mwArray K(numSur,numSur,bem.getBEMK());
// transpose(K,numSur,);
double* Ka = bem.getBEMKa();
// mwArray Ka(1,numSur,bem.getBEMKa());
double* M = bem.getMFree();
// transpose(M);
engine.Open(NULL);
engine.addData(K, "K", numSur, numSur);
engine.addData(Ka, "Ka", 1, numSur);
engine.evalString("K = K.'");
engine.evalString("K = vertcat(K,Ka)");
engine.addData(M, "M", numVol, numSur + 1);
engine.evalString("M = M.'");
// mwArray M(numVol,numSur+1,bem.getMFree());
// mwArray Trans = inv(ctranspose(K)*K)*ctranspose(K)*M;
engine.evalString(" Trans = inv(ctranspose(K)*K)*ctranspose(K)*M");
/* FILE* fid = fopen(TransOutput,"wb");
double* d = mxGetPr(Trans.GetData());
int row,col;
row = size(&col,Trans);
fwrite(d,sizeof(double),row*col,fid);
fclose(fid);
*/
cout << "writing Trans files \n" << endl;
double* Trans = new double[numSur * numVol];
engine.getData(Trans, "Trans");
writeFile(TransOutput[0], Trans, sizeof(double), numSur * numVol, "wb");
delete[] Trans;
engine.Close();
}
int main( int argc, char** argv )
{
Surface_mesh surface_mesh;
if (argc!=2){
std::cerr << "Usage: " << argv[0] << " input.off\n";
return EXIT_FAILURE;
}
std::ifstream is(argv[1]);
if(!is){
std::cerr << "Filename provided is invalid\n";
return EXIT_FAILURE;
}
is >> surface_mesh ;
if (!CGAL::is_triangle_mesh(surface_mesh)){
std::cerr << "Input geometry is not triangulated." << std::endl;
return EXIT_FAILURE;
}
Surface_mesh::Property_map<halfedge_descriptor,std::pair<Point_3, Point_3> > constrained_halfedges;
constrained_halfedges = surface_mesh.add_property_map<halfedge_descriptor,std::pair<Point_3, Point_3> >("h:vertices").first;
std::size_t nb_border_edges=0;
BOOST_FOREACH(halfedge_descriptor hd, halfedges(surface_mesh)){
if(CGAL::is_border(hd,surface_mesh)){
constrained_halfedges[hd] = std::make_pair(surface_mesh.point(source(hd,surface_mesh)),
surface_mesh.point(target(hd,surface_mesh)));
++nb_border_edges;
}
}
// Contract the surface mesh as much as possible
SMS::Count_stop_predicate<Surface_mesh> stop(0);
Border_is_constrained_edge_map bem(surface_mesh);
// This the actual call to the simplification algorithm.
// The surface mesh and stop conditions are mandatory arguments.
int r = SMS::edge_collapse
(surface_mesh
,stop
,CGAL::parameters::edge_is_constrained_map(bem)
.get_placement(Placement(bem))
);
std::cout << "\nFinished...\n" << r << " edges removed.\n"
<< surface_mesh.number_of_edges() << " final edges.\n";
std::ofstream os( argc > 2 ? argv[2] : "out.off" );
os.precision(17);
os << surface_mesh;
// now check!
BOOST_FOREACH(halfedge_descriptor hd, halfedges(surface_mesh)){
if(CGAL::is_border(hd,surface_mesh)){
--nb_border_edges;
if(constrained_halfedges[hd] != std::make_pair(surface_mesh.point(source(hd,surface_mesh)),
surface_mesh.point(target(hd,surface_mesh)))){
std::cerr << "oops. send us a bug report\n";
}
}
}
assert( nb_border_edges==0 );
return EXIT_SUCCESS;
}
//**********************************************************
//foward computation: with epi
//**********************************************************
void FECG(char** filNamBEM, char** filNamMFree, char** filOutMFree,
char** filOutBEM, char** TransOutput)
{
matEg* engine = new matEg(MAX_BUF);
//Laplacian part
BEM_nosource bem2(filNamBEM, filNamMFree, Tri3);
bem2.BEMCompute(filOutBEM);
int numSur_t = bem2.getNumSur();
double* Kt = bem2.getBEMK();
double* Pt = bem2.getBEMP();
for (int i = 0; i < numSur_t * numSur_t; i++)
Pt[i] = DKe / DTe * Pt[i];
//Possoin part
BEM_source bem(filNamBEM, filNamMFree, Tri3);
bem.BEMCompute(filOutMFree);
int numSur_h = bem.getNumSur();
int numVol = bem.getNumVol();
double* Kh = bem.getBEMK();
double* Ph = bem.getBEMP();
double* Ma = bem.getMFree();
//begin engine***********************
engine->Open(NULL);
engine->addData(Kt, "Kt", numSur_t, numSur_t);
engine->evalString("Kt = transpose(Kt)");
engine->addData(Pt, "Pt", numSur_t, numSur_t);
engine->evalString("Pt = transpose(Pt)");
engine->addData(Kh, "Kh", numSur_h, numSur_h);
engine->evalString("Kh = transpose(Kh)");
engine->addData(Ph, "Ph", numSur_h, numSur_h);
engine->evalString("Ph = transpose(Ph)");
engine->addData(Ma, "Ma", numVol, numSur_h + 1);
engine->evalString("numSur_h = size(Kh,1)");
engine->evalString("numSur_t = size(Kt,1)");
engine->evalString("numVol = size(Ma,1)");
engine->evalString("Ma = transpose(Ma)");
engine->evalString("M = Ma(1:numSur_h,:)");
//begin to couple
engine->evalString("K = horzcat(Kh,zeros(numSur_h,numSur_t - numSur_h))");
engine->evalString("K = vertcat(K,zeros(numSur_t - numSur_h,numSur_t))");
engine->evalString("P = horzcat(Ph,zeros(numSur_h,numSur_t - numSur_h))");
engine->evalString(
"I = horzcat(zeros(numSur_t - numSur_h,numSur_h),eye(numSur_t - numSur_h))");
engine->evalString("P = vertcat(P,I)");
engine->evalString("P = P*inv(Pt)*Kt");
engine->evalString(
"Trans = inv(K+P)*vertcat(M,zeros(numSur_t - numSur_h,numVol))");
double* Trans = new double[numSur_t * numVol];
engine->getData(Trans, "Trans");
writeFile(TransOutput[0], Trans, sizeof(double), numSur_t * numVol, "wb");
delete[] Trans;
engine->Close();
delete engine;
}
