//=============================================================================
layprop::ViewProperties::ViewProperties() {
addlayer(std::string("_$teLayer_cell"),0,"","","");
_step = 1;
setUU(1);
_marker_angle = 0;
_autopan = false;
}
//=============================================================================
layprop::ViewProperties::ViewProperties() {
addlayer(std::string("_$teLayer_cell"),0,"","","");
_step = 1;
setUU(1);
_marker_angle = 0;
_autopan = false;
_layselmask = laydata::_lmall;
_gdsLayMap = NULL;
_cifLayMap = NULL;
_zeroCross = false;
}
unsigned layprop::ViewProperties::addlayer(std::string name)
{
unsigned layno = _drawprop._layset.rbegin()->first;
while (!addlayer(name, layno)) {layno++;}
return layno;
}
/* Main */
int main(int argc, char* argv[]) {
int nnF = 200000, nnV = 200000, nnT = 1100000;
int nF = 0, nV = 0, nT = 0;
int *face = 0, *facematerial = 0, *facedup = 0, *facematdup = 0;
int *tetra = 0, *tetramaterial = 0;
double *vertex = 0;
int i, nFdup, r, j, medge, msurf, m, k, p;
int nVVert, nLine, nSurface;
int *LineD, *LineP;
double *LineT;
int *SurfL, *SurfI;
double *SurfT;
double *VVert;
int *expCrv;
int nE = 0, nnE = 100000, *edge, *edgematerial;
int va, vb, vc, vd, ve, vf, vg, vh;
int vc1a, vc1b, vc2a, vc2b, vc3a, vc3b;
int arc1a, arc1b, arc2a, arc2b, arc3a, arc3b;
int eab, ebc, ecd, eda, eef, efg, egh, ehe, eae, ebf, ecg, edh;
int ntfix = 0, nvfix = 0;
int izero = 0;
// allocate memory for mesh ctructures
vertex = (double*)malloc(sizeof(double) * 3 * nnV);
face = (int*) malloc(sizeof(int) * 3 * nnF);
facedup = (int*) malloc(sizeof(int) * 3 * nnF);
facematerial = (int*) malloc(sizeof(int) * nnF);
facematdup = (int*) malloc(sizeof(int) * nnF);
tetra = (int*) malloc(sizeof(int) * 4 * nnT);
tetramaterial = (int*) malloc(sizeof(int) * nnT);
edge = (int*) malloc(sizeof(int) * 2 * nnE);
edgematerial = (int*) malloc(sizeof(int) * nnE);
// allocate memory for boundary representation structure
VVert = (double*)malloc(sizeof(double) * 3*100);
nVVert = 0;
LineD = (int*) malloc(sizeof(int) * 3*100);
LineP = (int*) malloc(sizeof(int) * 2*2*100);
LineT = (double*)malloc(sizeof(double) * 2*2*100);
nLine = 0;
SurfL = (int*) malloc(sizeof(int) * 5*100);
SurfI = (int*) malloc(sizeof(int) * 2*2*100);
SurfT = (double*)malloc(sizeof(double) * 4*100);
nSurface = 0;
expCrv = (int*) malloc(sizeof(int) * 100);
memset(expCrv, 0, sizeof(int) * 100);
/***/
#define ADD_VERTEX(X, Y, Z) (VVert[3*nVVert+0] = X, VVert[3*nVVert+1] = Y, VVert[3*nVVert+2] = Z, ++nVVert)
#define EDGE(V1, V2, N, ...) add_edge(LineD, LineP, LineT, &nLine, &medge, V1, V2, N, __VA_ARGS__)
#define SURF(P, C1, C2, D, U1, U2, V1, V2, N, ...) add_surf(SurfL, SurfT, SurfI, &nSurface, &msurf, P, C1, C2, D, U1, U2, V1, V2, N, __VA_ARGS__)
/***/
vc1a = ADD_VERTEX( R1, 0, 0);
vc1b = ADD_VERTEX(-R1, 0, 0);
vc2a = ADD_VERTEX( R2, 0, 0);
vc2b = ADD_VERTEX(-R2, 0, 0);
vc3a = ADD_VERTEX( R3, 0, 0);
vc3b = ADD_VERTEX(-R3, 0, 0);
va = ADD_VERTEX(-Db, -Db, 0);
vb = ADD_VERTEX(-Db, Db, 0);
vc = ADD_VERTEX( Db, Db, 0);
vd = ADD_VERTEX( Db, -Db, 0);
ve = ADD_VERTEX(-Db, -Db, -Db);
vf = ADD_VERTEX(-Db, Db, -Db);
vg = ADD_VERTEX( Db, Db, -Db);
vh = ADD_VERTEX( Db, -Db, -Db);
medge = 0;
/* EDGE(v1, v2, nSurf, [iSurf, iLine, t_0, t1,] ...); */
arc1a = EDGE(vc1a, vc1b, 1, 1, 1, 0.0, M_PI);
arc1b = EDGE(vc1b, vc1a, 1, 1, 1, M_PI, 2.0*M_PI);
arc2a = EDGE(vc2a, vc2b, 1, 1, 2, M_PI, 0.0);
arc2b = EDGE(vc2b, vc2a, 1, 1, 2, 2.0*M_PI, M_PI);
arc3a = EDGE(vc3a, vc3b, 1, 1, 3, 0.0, M_PI);
arc3b = EDGE(vc3b, vc3a, 1, 1, 3, M_PI, 2.0*M_PI);
expCrv[arc1a-1] = 1, expCrv[arc1b-1] = 1;
expCrv[arc2a-1] = 1, expCrv[arc2b-1] = 1;
expCrv[arc3a-1] = 1, expCrv[arc3b-1] = 1;
eab = EDGE(va, vb, 1, 0, 0, 0.0, 0.0);
ebc = EDGE(vb, vc, 1, 0, 0, 0.0, 0.0);
ecd = EDGE(vc, vd, 1, 0, 0, 0.0, 0.0);
eda = EDGE(vd, va, 1, 0, 0, 0.0, 0.0);
eef = EDGE(ve, vf, 1, 0, 0, 0.0, 0.0);
efg = EDGE(vf, vg, 1, 0, 0, 0.0, 0.0);
egh = EDGE(vg, vh, 1, 0, 0, 0.0, 0.0);
ehe = EDGE(vh, ve, 1, 0, 0, 0.0, 0.0);
eae = EDGE(va, ve, 1, 0, 0, 0.0, 0.0);
ebf = EDGE(vb, vf, 1, 0, 0, 0.0, 0.0);
ecg = EDGE(vc, vg, 1, 0, 0, 0.0, 0.0);
edh = EDGE(vd, vh, 1, 0, 0, 0.0, 0.0);
msurf = 0;
/* SURF(iSurf, color1, color2, direction, u0, u1, v0, v1, n, [edge, edge_dir,] ...); */
SURF(1, 2, 11, 0, -Db, Db, -Db, Db, 2, arc1a, 0, arc1b, 0);
SURF(1, 1, 0, 0, -Db, Db, -Db, Db, 4, arc2a, 1, arc2b, 1, arc1a, 1, arc1b, 1);
SURF(1, 2, 12, 0, -Db, Db, -Db, Db, 4, arc3a, 0, arc3b, 0, arc2a, 0, arc2b, 0);
SURF(0, 1, 0, 0, 0.0, 0.0, 0.0, 0.0, 6, arc3a, 1, arc3b, 1, eab, 1, ebc, 1, ecd, 1, eda, 1);
SURF(0, 1, 0, 0, 0.0, 0.0, 0.0, 0.0, 4, eef, 0, efg, 0, egh, 0, ehe, 0);
SURF(0, 1, 0, 0, 0.0, 0.0, 0.0, 0.0, 4, eab, 0, ebf, 0, eef, 1, eae, 1);
SURF(0, 1, 0, 0, 0.0, 0.0, 0.0, 0.0, 4, ebc, 0, ecg, 0, efg, 1, ebf, 1);
SURF(0, 1, 0, 0, 0.0, 0.0, 0.0, 0.0, 4, ecd, 0, edh, 0, egh, 1, ecg, 1);
SURF(0, 1, 0, 0, 0.0, 0.0, 0.0, 0.0, 4, eda, 0, eae, 0, ehe, 1, edh, 1);
tria_dump_front = 0;
tria_debug_front = 0;
region_dump_face = 0;
printf("\n * Generating surface mesh\n");
i = ani3d_surface_edges_boundary_(&nVVert, VVert, &nLine, LineD, LineP, LineT, &nSurface, SurfL, SurfI, SurfT,
NULL, surface_param, line_param, NULL/*periodic*/, fsize,
expCrv,
&nV, vertex, &nF, face, facematerial, &nE, edge, edgematerial,
&nnV, &nnF, &nnE
);
free(VVert), free(LineD), free(LineP), free(LineT), free(SurfL), free(SurfI), free(SurfT);
printf("INFO: nV = %d, nE = %d, nF = %d, nT = %d\n", nV, nE, nF, nT);
/* Generate skin mesh */
printf("\n * Generating skin mesh\n");
nFdup = 0;
addlayer(electrodesize, &nV, vertex-3, nE, edge, edgematerial, &nF, face, facematerial, &nT, tetra, tetramaterial, &nFdup, facedup, facematdup, nnV, nnF, nnT);
fix_vertices(&nV, vertex-3, nF, face, nT, tetra, nFdup, facedup, nE, edge);
printf("INFO: nV = %d, nF = %d, nT = %d\n", nV, nF, nT);
// It could be usefull to dump the triangulation of the surface in case we want to check
// that boundary representation is correct and represents the desired region
if (0) {
write_mesh_gmv("surf.gmv", nV, vertex, nF, face, facematerial, nT, tetra, tetramaterial); // for GMV
write_front ("surf.smv", nV, vertex, nF, face, facematerial); // for smv
// return 0; // do not mesh the volume, just exit
write_mesh_gmv("dups.gmv", nV, vertex, nFdup, facedup, facematdup, nT, tetra, tetramaterial); // for GMV
write_front ("dups.smv", nV, vertex, nFdup, facedup, facematdup); // for smv
}
// We will copy the front, so that it could be used in output in future.
ntfix = nT;
nvfix = nV;
for (i=0; i<nF; i++) {
facedup[3*nFdup+0] = face[3*i+0];
facedup[3*nFdup+1] = face[3*i+1];
facedup[3*nFdup+2] = face[3*i+2];
facematdup[nFdup] = facematerial[i];
nFdup++;
}
// Generate 3D mesh using our own size function fsize()
printf("\n * Generating volume mesh\n");
r = mesh_3d_aft_func_(&nV, vertex, &nF, face, facematerial, &nT, tetra, tetramaterial, &nnV, &nnF, &nnT, fsize);
printf("\nINFO: nV = %d, nF = %d, nT = %d\n", nV, nF, nT);
if (r) {
write_mesh_gmv("fail.gmv", nV, vertex, nF, face, facematerial, nT, tetra, tetramaterial);
} else {
/* Check that 3D mesh corresponds with surface mesh */
/*printf("Checking topology: "), fflush(stdout);*/
if (0 && check_mesh_topology_(&nV, vertex, &nFdup, facedup, &nT, tetra)) printf("FAILED!\n");
else {
/*printf("ok.\n");*/
if (0) {
write_mesh ("bfix.out", nV, vertex, nFdup, facedup, facematdup, nT, tetra, tetramaterial);
write_mesh_gmv_qual("bfix.gmv", nV, vertex, nFdup, facedup, facematdup, nT, tetra, tetramaterial);
}
for (i=0; i<nT; i++) tetramaterial[i] = (tetramaterial[i]==1) ? 2 : tetramaterial[i];
keepskin(&nFdup, facedup, facematdup);
/* Improve mesh quality */
printf("\n * Smoothing volume mesh\n");
fixshape(&nV, vertex, &nT, tetra, tetramaterial, &nFdup, facedup, facematdup, 0, ntfix, nFdup, nnV, nnT, nnF);
keepskin(&nFdup, facedup, facematdup);
// Write output files
write_mesh_gmv_qual("mesh.gmv", nV, vertex, nFdup, facedup, facematdup, nT, tetra, tetramaterial);
/*write_mesh ("mesh.out", nV, vertex, nFdup, facedup, facematdup, nT, tetra, tetramaterial);*/
saveMani(&nV, &nFdup, &nT,
vertex, facedup, tetra, facematdup, tetramaterial,
&izero, &izero, &izero, NULL, NULL, NULL,
&izero, NULL, NULL, "mesh.ani");
}
}
free(vertex);
free(face);
free(facedup);
free(facematerial);
free(facematdup);
free(tetra);
free(tetramaterial);
return 0;
}