int main(int argc, char **argv) {
options.parse(argc, argv);
carve::input::Input inputs;
std::vector<carve::mesh::MeshSet<3> *> polys;
std::vector<carve::line::PolylineSet *> lines;
std::vector<carve::point::PointSet *> points;
if (options.file == "") {
readPLY(std::cin, inputs);
} else {
if (endswith(options.file, ".ply")) {
readPLY(options.file, inputs);
} else if (endswith(options.file, ".vtk")) {
readVTK(options.file, inputs);
} else if (endswith(options.file, ".obj")) {
readOBJ(options.file, inputs);
}
}
for (std::list<carve::input::Data *>::const_iterator i = inputs.input.begin(); i != inputs.input.end(); ++i) {
carve::mesh::MeshSet<3> *p;
carve::point::PointSet *ps;
carve::line::PolylineSet *l;
if ((p = carve::input::Input::create<carve::mesh::MeshSet<3> >(*i)) != NULL) {
if (options.canonicalize) p->canonicalize();
if (options.obj) {
writeOBJ(std::cout, p);
} else if (options.vtk) {
writeVTK(std::cout, p);
} else {
writePLY(std::cout, p, options.ascii);
}
delete p;
} else if ((l = carve::input::Input::create<carve::line::PolylineSet>(*i)) != NULL) {
if (options.obj) {
writeOBJ(std::cout, l);
} else if (options.vtk) {
writeVTK(std::cout, l);
} else {
writePLY(std::cout, l, options.ascii);
}
delete l;
} else if ((ps = carve::input::Input::create<carve::point::PointSet>(*i)) != NULL) {
if (options.obj) {
std::cerr << "Can't write a point set in .obj format" << std::endl;
} else if (options.vtk) {
std::cerr << "Can't write a point set in .vtk format" << std::endl;
} else {
writePLY(std::cout, ps, options.ascii);
}
delete ps;
}
}
return 0;
}
void Foam::directions::writeOBJ
(
Ostream& os,
const point& pt0,
const point& pt1,
label& vertI
)
{
writeOBJ(os, pt0);
writeOBJ(os, pt1);
os << "l " << vertI + 1 << ' ' << vertI + 2 << endl;
vertI += 2;
}
void Foam::directions::writeOBJ
(
const fileName& fName,
const primitiveMesh& mesh,
const vectorField& dirs
)
{
Pout<< "Writing cell info to " << fName << " as vectors at the cellCentres"
<< endl << endl;
OFstream xDirStream(fName);
label vertI = 0;
forAll(dirs, celli)
{
const point& ctr = mesh.cellCentres()[celli];
// Calculate local length scale
scalar minDist = great;
const labelList& nbrs = mesh.cellCells()[celli];
forAll(nbrs, nbrI)
{
minDist = min(minDist, mag(mesh.cellCentres()[nbrs[nbrI]] - ctr));
}
scalar scale = 0.5*minDist;
writeOBJ(xDirStream, ctr, ctr + scale*dirs[celli], vertI);
}
void primitiveMixingPlanePatch::writePatches(const word& patchName)
{
OFstream osNew("faces.obj");
forAll(localPoints_, i)
{
writeOBJ(osNew, localPoints_[i]);
}
void Foam::DelaunayMeshTools::writeOBJ
(
const fileName& fName,
const Triangulation& t,
const indexedVertexEnum::vertexType pointType
)
{
writeOBJ(fName, t, pointType, pointType);
}
int main(int argc, char **argv) {
options.parse(argc, argv);
carve::poly::Polyhedron *poly = readModel(options.file);
if (!poly) exit(1);
std::vector<carve::poly::Vertex<3> > out_vertices = poly->vertices;
std::vector<carve::poly::Face<3> > out_faces;
size_t N = 0;
for (size_t i = 0; i < poly->faces.size(); ++i) {
carve::poly::Face<3> &f = poly->faces[i];
N += f.nVertices() - 2;
}
out_faces.reserve(N);
for (size_t i = 0; i < poly->faces.size(); ++i) {
carve::poly::Face<3> &f = poly->faces[i];
std::vector<carve::triangulate::tri_idx> result;
std::vector<const carve::poly::Polyhedron::vertex_t *> vloop;
f.getVertexLoop(vloop);
carve::triangulate::triangulate(carve::poly::p2_adapt_project<3>(f.project), vloop, result);
if (options.improve) {
carve::triangulate::improve(carve::poly::p2_adapt_project<3>(f.project), vloop, result);
}
for (size_t j = 0; j < result.size(); ++j) {
out_faces.push_back(carve::poly::Face<3>(
&out_vertices[poly->vertexToIndex_fast(vloop[result[j].a])],
&out_vertices[poly->vertexToIndex_fast(vloop[result[j].b])],
&out_vertices[poly->vertexToIndex_fast(vloop[result[j].c])]
));
}
}
carve::poly::Polyhedron *result = new carve::poly::Polyhedron(out_faces, out_vertices);
if (options.canonicalize) result->canonicalize();
if (options.obj) {
writeOBJ(std::cout, result);
} else if (options.vtk) {
writeVTK(std::cout, result);
} else {
writePLY(std::cout, result, options.ascii);
}
delete result;
delete poly;
}
/**
* writes a surface as a given format
*/
int writeSurface(surface *surf, char *filename, enum SURFACE_FORMAT format) {
switch(format) {
case OFF:
return writeOFF(surf,filename);
break;
case OBJ:
return writeOBJ(surf,filename);
break;
case MGHSURF:
return writeMGHsurf(surf,filename);
break;
default:
fprintf(stderr,"writeSurface(): unsupported format\n");
break;
}
return SR_FAILURE;
}
int main(int argc, char **argv) {
options.parse(argc, argv);
carve::mesh::MeshSet<3> *poly;
if (options.axis == Options::ERR) {
std::cerr << "need to specify a closure plane." << std::endl;
exit(1);
}
if (options.file == "-") {
poly = readPLYasMesh(std::cin);
} else if (endswith(options.file, ".ply")) {
poly = readPLYasMesh(options.file);
} else if (endswith(options.file, ".vtk")) {
poly = readVTKasMesh(options.file);
} else if (endswith(options.file, ".obj")) {
poly = readOBJasMesh(options.file);
}
if (poly == NULL) {
std::cerr << "failed to load polyhedron" << std::endl;
exit(1);
}
std::cerr << "poly aabb = " << poly->getAABB() << std::endl;
if (poly->getAABB().compareAxis(carve::geom::axis_pos(options.axis, options.pos)) == 0) {
std::cerr << "poly aabb intersects closure plane." << std::endl;
exit(1);
}
for (size_t i = 0; i < poly->meshes.size(); ++i) {
carve::mesh::MeshSet<3>::mesh_t *mesh = poly->meshes[i];
const size_t N = mesh->open_edges.size();
if (N == 0) continue;
mesh->faces.reserve(N + 1);
carve::mesh::MeshSet<3>::edge_t *start = mesh->open_edges[0];
std::vector<carve::mesh::MeshSet<3>::edge_t *> edges_to_close;
edges_to_close.resize(N);
carve::mesh::MeshSet<3>::edge_t *edge = start;
size_t j = 0;
do {
edges_to_close[j++] = edge;
edge = edge->perimNext();
} while (edge != start);
CARVE_ASSERT(j == N);
std::vector<carve::mesh::MeshSet<3>::vertex_t> projected;
projected.resize(N);
for (j = 0; j < N; ++j) {
edge = edges_to_close[j];
projected[j].v = edge->vert->v;
projected[j].v.v[options.axis] = options.pos;
}
for (j = 0; j < N; ++j) {
edge = edges_to_close[j];
carve::mesh::MeshSet<3>::face_t *quad =
new carve::mesh::MeshSet<3>::face_t(edge->v2(), edge->v1(), &projected[j], &projected[(j+1)%N]);
quad->mesh = mesh;
edge->rev = quad->edge;
quad->edge->rev = edge;
mesh->faces.push_back(quad);
}
for (j = 0; j < N; ++j) {
carve::mesh::MeshSet<3>::edge_t *e1 = edges_to_close[j]->rev->prev;
carve::mesh::MeshSet<3>::edge_t *e2 = edges_to_close[(j+1)%N]->rev->next;
e1->rev = e2;
e2->rev = e1;
}
for (j = 0; j < N; ++j) {
edge = edges_to_close[j]->rev;
edge->validateLoop();
}
carve::mesh::MeshSet<3>::face_t *loop =
carve::mesh::MeshSet<3>::face_t::closeLoop(edges_to_close[0]->rev->next->next);
loop->mesh = mesh;
mesh->faces.push_back(loop);
poly->collectVertices();
}
if (options.obj) {
writeOBJ(std::cout, poly);
} else if (options.vtk) {
writeVTK(std::cout, poly);
} else {
writePLY(std::cout, poly, options.ascii);
}
return 0;
}
forAll(pts, i)
{
writeOBJ(pts[i], os);
}
forAll(pointLabels, i)
{
writeOBJ(os, points[pointLabels[i]]);
}
void Foam::processorPolyPatch::calcGeometry(PstreamBuffers& pBufs)
{
if (Pstream::parRun())
{
{
UIPstream fromNeighbProc(neighbProcNo(), pBufs);
fromNeighbProc
>> neighbFaceCentres_
>> neighbFaceAreas_
>> neighbFaceCellCentres_;
}
// My normals
vectorField faceNormals(size());
// Neighbour normals
vectorField nbrFaceNormals(neighbFaceAreas_.size());
// Face match tolerances
scalarField tols =
calcFaceTol(*this, points(), faceCentres());
// Calculate normals from areas and check
forAll(faceNormals, facei)
{
scalar magSf = mag(faceAreas()[facei]);
scalar nbrMagSf = mag(neighbFaceAreas_[facei]);
scalar avSf = (magSf + nbrMagSf)/2.0;
if (magSf < ROOTVSMALL && nbrMagSf < ROOTVSMALL)
{
// Undetermined normal. Use dummy normal to force separation
// check. (note use of sqrt(VSMALL) since that is how mag
// scales)
faceNormals[facei] = point(1, 0, 0);
nbrFaceNormals[facei] = faceNormals[facei];
}
else if (mag(magSf - nbrMagSf) > matchTolerance()*sqr(tols[facei]))
{
fileName nm
(
boundaryMesh().mesh().time().path()
/name()+"_faces.obj"
);
Pout<< "processorPolyPatch::calcGeometry : Writing my "
<< size()
<< " faces to OBJ file " << nm << endl;
writeOBJ(nm, *this, points());
OFstream ccStr
(
boundaryMesh().mesh().time().path()
/name() + "_faceCentresConnections.obj"
);
Pout<< "processorPolyPatch::calcGeometry :"
<< " Dumping cell centre lines between"
<< " corresponding face centres to OBJ file" << ccStr.name()
<< endl;
label vertI = 0;
forAll(faceCentres(), faceI)
{
const point& c0 = neighbFaceCentres_[faceI];
const point& c1 = faceCentres()[faceI];
writeOBJ(ccStr, c0, c1, vertI);
}
FatalErrorIn
(
"processorPolyPatch::calcGeometry()"
) << "face " << facei << " area does not match neighbour by "
<< 100*mag(magSf - nbrMagSf)/avSf
<< "% -- possible face ordering problem." << endl
<< "patch:" << name()
<< " my area:" << magSf
<< " neighbour area:" << nbrMagSf
<< " matching tolerance:"
<< matchTolerance()*sqr(tols[facei])
<< endl
<< "Mesh face:" << start()+facei
<< " vertices:"
<< UIndirectList<point>(points(), operator[](facei))()
<< endl
<< "If you are certain your matching is correct"
<< " you can increase the 'matchTolerance' setting"
<< " in the patch dictionary in the boundary file."
<< endl
<< "Rerun with processor debug flag set for"
<< " more information." << exit(FatalError);
}
else
{
int main(int argc, char **argv) {
std::vector<std::string> tokens;
options.parse(argc, argv);
if (options.args.size() != 2) {
std::cerr << options.usageStr();
exit(1);
}
carve::mesh::MeshSet<3> *object = load(options.args[0]);
if (object == NULL) {
std::cerr << "failed to load object file [" << options.args[0] << "]" << std::endl;
exit(1);
}
carve::mesh::MeshSet<3> *planes = load(options.args[1]);
if (planes == NULL) {
std::cerr << "failed to load split plane file [" << options.args[1] << "]" << std::endl;
exit(1);
}
carve::mesh::MeshSet<3> *result = NULL;
carve::csg::CSG csg;
if (options.triangulate) {
#if !defined(DISABLE_GLU_TRIANGULATOR)
if (options.glu_triangulate) {
csg.hooks.registerHook(new GLUTriangulator, carve::csg::CSG::Hooks::PROCESS_OUTPUT_FACE_BIT);
if (options.improve) {
csg.hooks.registerHook(new carve::csg::CarveTriangulationImprover, carve::csg::CSG::Hooks::PROCESS_OUTPUT_FACE_BIT);
}
} else {
#endif
if (options.improve) {
csg.hooks.registerHook(new carve::csg::CarveTriangulatorWithImprovement, carve::csg::CSG::Hooks::PROCESS_OUTPUT_FACE_BIT);
} else {
csg.hooks.registerHook(new carve::csg::CarveTriangulator, carve::csg::CSG::Hooks::PROCESS_OUTPUT_FACE_BIT);
}
#if !defined(DISABLE_GLU_TRIANGULATOR)
}
#endif
} else if (options.no_holes) {
csg.hooks.registerHook(new carve::csg::CarveHoleResolver, carve::csg::CSG::Hooks::PROCESS_OUTPUT_FACE_BIT);
}
Slice slice_collector(object, planes);
result = csg.compute(object, planes, slice_collector, NULL, carve::csg::CSG::CLASSIFY_EDGE);
if (result) {
result->separateMeshes();
if (options.canonicalize) result->canonicalize();
if (options.obj) {
writeOBJ(std::cout, result);
} else if (options.vtk) {
writeVTK(std::cout, result);
} else {
writePLY(std::cout, result, options.ascii);
}
}
if (object) delete object;
if (planes) delete planes;
if (result) delete result;
}
void writeOBJ(std::string &out_file, const carve::line::PolylineSet *lines, bool ascii) {
std::ofstream out(out_file.c_str(), std::ios_base::binary);
if (!out.is_open()) { std::cerr << "File '" << out_file << "' could not be opened." << std::endl; return; }
writeOBJ(out, lines);
}
void writeOBJ(std::string &out_file, const carve::poly::Polyhedron *poly) {
std::ofstream out(out_file.c_str(), std::ios_base::binary);
if (!out.is_open()) { std::cerr << "File '" << out_file << "' could not be opened." << std::endl; return; }
writeOBJ(out, poly);
}
