void triSurf::readSurface(const fileName& fName)
{
if( fName.ext() == "fms" || fName.ext() == "FMS" )
{
readFromFMS(fName);
}
else if( fName.ext() == "ftr" || fName.ext() == "FTR" )
{
readFromFTR(fName);
}
else
{
triSurface copySurface(fName);
//- copy the points
triSurfPoints::points_.setSize(copySurface.points().size());
forAll(copySurface.points(), pI)
triSurfPoints::points_[pI] = copySurface.points()[pI];
//- copy the triangles
triSurfFacets::triangles_.setSize(copySurface.size());
forAll(copySurface, tI)
triSurfFacets::triangles_[tI] = copySurface[tI];
//- copy patches
triSurfFacets::patches_ = copySurface.patches();
}
}
void Foam::MeshedSurfaceProxy<Face>::write
(
const fileName& name,
const MeshedSurfaceProxy& surf
)
{
if (debug)
{
Info<< "MeshedSurfaceProxy::write"
"(const fileName&, const MeshedSurfaceProxy&) : "
"writing to " << name
<< endl;
}
word ext = name.ext();
typename writefileExtensionMemberFunctionTable::iterator mfIter =
writefileExtensionMemberFunctionTablePtr_->find(ext);
if (mfIter == writefileExtensionMemberFunctionTablePtr_->end())
{
FatalErrorIn
(
"MeshedSurfaceProxy::write(const fileName&)"
) << "Unknown file extension " << ext << nl << nl
<< "Valid types are :" << endl
<< writeTypes()
<< exit(FatalError);
}
mfIter()(name, surf);
}
void Foam::edgeMesh::write
(
const fileName& name,
const edgeMesh& mesh
)
{
if (debug)
{
Info<< "edgeMesh::write"
"(const fileName&, const edgeMesh&) : "
"writing to " << name
<< endl;
}
const word ext = name.ext();
writefileExtensionMemberFunctionTable::iterator mfIter =
writefileExtensionMemberFunctionTablePtr_->find(ext);
if (mfIter == writefileExtensionMemberFunctionTablePtr_->end())
{
FatalErrorIn
(
"MeshedSurface::write"
"(const fileName&, const MeshedSurface&)"
) << "Unknown file extension " << ext << nl << nl
<< "Valid types are :" << endl
<< writefileExtensionMemberFunctionTablePtr_->sortedToc()
<< exit(FatalError);
}
else
{
mfIter()(name, mesh);
}
}
Foam::autoPtr<Foam::edgeMesh> Foam::edgeMesh::New(const fileName& name)
{
word ext = name.ext();
if (ext == "gz")
{
ext = name.lessExt().ext();
}
return New(name, ext);
}
Foam::autoPtr<Foam::UnsortedMeshedSurface<Face>>
Foam::UnsortedMeshedSurface<Face>::New(const fileName& name)
{
word ext = name.ext();
if (ext == "gz")
{
ext = name.lessExt().ext();
}
return New(name, ext);
}
bool Foam::edgeMesh::canRead
(
const fileName& name,
const bool verbose
)
{
word ext = name.ext();
if (ext == "gz")
{
ext = name.lessExt().ext();
}
return canReadType(ext, verbose);
}
bool Foam::edgeMesh::read(const fileName& name)
{
word ext = name.ext();
if (ext == "gz")
{
fileName unzipName = name.lessExt();
return read(unzipName, unzipName.ext());
}
else
{
return read(name, ext);
}
}
bool Foam::UnsortedMeshedSurface<Face>::canRead
(
const fileName& name,
const bool verbose
)
{
word ext = name.ext();
if (ext == "gz")
{
ext = name.lessExt().ext();
}
return canReadType(ext, verbose);
}
void triSurf::writeSurface(const fileName& fName) const
{
if( fName.ext() == "fms" || fName.ext() == "FMS" )
{
writeToFMS(fName);
}
else if( fName.ext() == "ftr" || fName.ext() == "FTR" )
{
writeToFTR(fName);
}
else
{
const pointField& pts = this->points();
const LongList<labelledTri>& facets = this->facets();
const geometricSurfacePatchList& patches = this->patches();
List<labelledTri> newTrias(facets.size());
forAll(facets, tI)
newTrias[tI] = facets[tI];
triSurface newSurf(newTrias, patches, pts);
newSurf.write(fName);
}
}
void printSourceFileAndLine
(
Ostream& os,
const fileName& filename,
Dl_info *info,
void *addr
)
{
uintptr_t address = uintptr_t(addr);
word myAddress = addressToWord(address);
if (filename.ext() == "so")
{
// Convert address into offset into dynamic library
uintptr_t offset = uintptr_t(info->dli_fbase);
intptr_t relativeAddress = address - offset;
myAddress = addressToWord(relativeAddress);
}
if (filename[0] == '/')
{
string line = pOpen
(
"addr2line -f --demangle=auto --exe "
+ filename
+ " "
+ myAddress,
1
);
if (line == "")
{
os << " addr2line failed";
}
else if (line == "??:0")
{
os << " in " << filename;
}
else
{
string cwdLine(line.replaceAll(cwd() + '/', ""));
string homeLine(cwdLine.replaceAll(home(), '~'));
os << " at " << homeLine.c_str();
}
}
}
void Foam::UnsortedMeshedSurface<Face>::write
(
const fileName& name,
const UnsortedMeshedSurface<Face>& surf
)
{
if (debug)
{
Info<< "UnsortedMeshedSurface::write"
"(const fileName&, const UnsortedMeshedSurface&) : "
"writing to " << name
<< endl;
}
const word ext = name.ext();
typename writefileExtensionMemberFunctionTable::iterator mfIter =
writefileExtensionMemberFunctionTablePtr_->find(ext);
if (mfIter == writefileExtensionMemberFunctionTablePtr_->end())
{
// no direct writer, delegate to proxy if possible
wordHashSet supported = ProxyType::writeTypes();
if (supported.found(ext))
{
MeshedSurfaceProxy<Face>(surf).write(name);
}
else
{
FatalErrorIn
(
"UnsortedMeshedSurface::write"
"(const fileName&, const UnsortedMeshedSurface&)"
) << "Unknown file extension " << ext << nl << nl
<< "Valid types are :" << endl
<< (supported | writeTypes())
<< exit(FatalError);
}
}
else
{
mfIter()(name, surf);
}
}
int main(int argc, char *argv[])
{
argList::noParallel();
argList::validArgs.clear();
argList::validArgs.append("input surface file");
argList args(argc, argv);
const fileName inFileName(args.args()[1]);
if( inFileName.ext() == "fms" )
FatalError << "trying to convert a fms file to itself"
<< exit(FatalError);
fileName outFileName(inFileName.lessExt()+".fms");
const triSurf surface(inFileName);
surface.writeSurface(outFileName);
Info << "End\n" << endl;
return 0;
}
int main(int argc, char *argv[])
{
argList::addNote
(
"write surface mesh regions to separate files"
);
argList::noParallel();
argList::validArgs.append("input surfaceFile");
argList args(argc, argv);
const fileName surfName = args[1];
Info<< "Reading surf from " << surfName << " ..." << nl << endl;
fileName surfBase = surfName.lessExt();
word extension = surfName.ext();
triSurface surf(surfName);
Info<< "Writing regions to separate files ..."
<< nl << endl;
const geometricSurfacePatchList& patches = surf.patches();
forAll(patches, patchi)
{
const geometricSurfacePatch& pp = patches[patchi];
word patchName = pp.name();
if (patchName.empty())
{
patchName = "patch" + Foam::name(patchi);
}
fileName outFile(surfBase + '_' + patchName + '.' + extension);
Info<< " Writing patch " << patchName << " to file " << outFile
<< endl;
// Collect faces of region
boolList includeMap(surf.size(), false);
forAll(surf, facei)
{
const labelledTri& f = surf[facei];
if (f.region() == patchi)
{
includeMap[facei] = true;
}
}
// Subset triSurface
labelList pointMap;
labelList faceMap;
triSurface subSurf
(
surf.subsetMesh
(
includeMap,
pointMap,
faceMap
)
);
subSurf.write(outFile);
}
Info<< "End\n" << endl;
return 0;
}
int main(int argc, char *argv[])
{
argList::addNote
(
"export from surfMesh to various third-party surface formats"
);
argList::noParallel();
argList::validArgs.append("outputFile");
argList::addBoolOption
(
"clean",
"perform some surface checking/cleanup on the input surface"
);
argList::addOption
(
"name",
"name",
"specify an alternative surface name when reading - "
"default is 'default'"
);
argList::addOption
(
"scaleIn",
"factor",
"geometry scaling factor on input - default is 1"
);
argList::addOption
(
"scaleOut",
"factor",
"geometry scaling factor on output - default is 1"
);
argList::addOption
(
"dict",
"file",
"specify an alternative dictionary for constant/coordinateSystems"
);
argList::addOption
(
"from",
"coordinateSystem",
"specify the source coordinate system, applied after '-scaleIn'"
);
argList::addOption
(
"to",
"coordinateSystem",
"specify the target coordinate system, applied before '-scaleOut'"
);
argList args(argc, argv);
Time runTime(args.rootPath(), args.caseName());
const fileName exportName = args[1];
const word importName = args.optionLookupOrDefault<word>("name", "default");
// check that writing is supported
if (!MeshedSurface<face>::canWriteType(exportName.ext(), true))
{
return 1;
}
// get the coordinate transformations
autoPtr<coordinateSystem> fromCsys;
autoPtr<coordinateSystem> toCsys;
if (args.optionFound("from") || args.optionFound("to"))
{
autoPtr<IOobject> ioPtr;
if (args.optionFound("dict"))
{
const fileName dictPath = args["dict"];
ioPtr.set
(
new IOobject
(
(
isDir(dictPath)
? dictPath/coordinateSystems::typeName
: dictPath
),
runTime,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
);
}
else
{
ioPtr.set
(
new IOobject
(
coordinateSystems::typeName,
runTime.constant(),
runTime,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
);
}
if (!ioPtr->headerOk())
{
FatalErrorIn(args.executable())
<< "Cannot open coordinateSystems file\n "
<< ioPtr->objectPath() << nl
<< exit(FatalError);
}
coordinateSystems csLst(ioPtr());
if (args.optionFound("from"))
{
const word csName = args["from"];
const label csIndex = csLst.findIndex(csName);
if (csIndex < 0)
{
FatalErrorIn(args.executable())
<< "Cannot find -from " << csName << nl
<< "available coordinateSystems: " << csLst.toc() << nl
<< exit(FatalError);
}
fromCsys.reset(new coordinateSystem(csLst[csIndex]));
}
if (args.optionFound("to"))
{
const word csName = args["to"];
const label csIndex = csLst.findIndex(csName);
if (csIndex < 0)
{
FatalErrorIn(args.executable())
<< "Cannot find -to " << csName << nl
<< "available coordinateSystems: " << csLst.toc() << nl
<< exit(FatalError);
}
toCsys.reset(new coordinateSystem(csLst[csIndex]));
}
// maybe fix this later
if (fromCsys.valid() && toCsys.valid())
{
FatalErrorIn(args.executable())
<< "Only allowed '-from' or '-to' option at the moment."
<< exit(FatalError);
}
}
surfMesh smesh
(
IOobject
(
importName,
runTime.constant(),
runTime,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
);
Info<< "read surfMesh:\n " << smesh.objectPath() << endl;
// Simply copy for now, but really should have a separate write method
MeshedSurface<face> surf(smesh);
if (args.optionFound("clean"))
{
surf.cleanup(true);
}
scalar scaleIn = 0;
if (args.optionReadIfPresent("scaleIn", scaleIn) && scaleIn > 0)
{
Info<< " -scaleIn " << scaleIn << endl;
surf.scalePoints(scaleIn);
}
if (fromCsys.valid())
{
Info<< " -from " << fromCsys().name() << endl;
tmp<pointField> tpf = fromCsys().localPosition(surf.points());
surf.movePoints(tpf());
}
if (toCsys.valid())
{
Info<< " -to " << toCsys().name() << endl;
tmp<pointField> tpf = toCsys().globalPosition(surf.points());
surf.movePoints(tpf());
}
scalar scaleOut = 0;
if (args.optionReadIfPresent("scaleOut", scaleOut) && scaleOut > 0)
{
Info<< " -scaleOut " << scaleOut << endl;
surf.scalePoints(scaleOut);
}
surf.writeStats(Info);
Info<< endl;
Info<< "writing " << exportName << endl;
surf.write(exportName);
Info<< "\nEnd\n" << endl;
return 0;
}
int main(int argc, char *argv[])
{
argList::addNote
(
"convert between surface formats"
);
argList::noParallel();
argList::validArgs.append("inputFile");
argList::validArgs.append("outputFile");
argList::addBoolOption
(
"clean",
"perform some surface checking/cleanup on the input surface"
);
argList::addOption
(
"scaleIn",
"factor",
"geometry scaling factor on input"
);
argList::addOption
(
"scaleOut",
"factor",
"geometry scaling factor on output"
);
#include "addDictOption.H"
argList::addOption
(
"from",
"system",
"specify the source coordinate system, applied after '-scaleIn'"
);
argList::addOption
(
"to",
"system",
"specify the target coordinate system, applied before '-scaleOut'"
);
argList::addBoolOption
(
"tri",
"triangulate surface"
);
argList args(argc, argv);
Time runTime(args.rootPath(), args.caseName());
const fileName importName = args[1];
const fileName exportName = args[2];
// disable inplace editing
if (importName == exportName)
{
FatalErrorInFunction
<< "Output file " << exportName << " would overwrite input file."
<< exit(FatalError);
}
// check that reading/writing is supported
if
(
!MeshedSurface<face>::canRead(importName, true)
|| !MeshedSurface<face>::canWriteType(exportName.ext(), true)
)
{
return 1;
}
// get the coordinate transformations
autoPtr<coordinateSystem> fromCsys;
autoPtr<coordinateSystem> toCsys;
if (args.optionFound("from") || args.optionFound("to"))
{
autoPtr<IOobject> csDictIoPtr;
const word dictName("coordinateSystems::typeName");
// Note: cannot use setSystemRunTimeDictionaryIO.H since dictionary
// is in constant
fileName dictPath = "";
if (args.optionFound("dict"))
{
dictPath = args["dict"];
if (isDir(dictPath))
{
dictPath = dictPath / dictName;
}
}
if (dictPath.size())
{
csDictIoPtr.set
(
new IOobject
(
dictPath,
runTime,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
);
}
else
{
csDictIoPtr.set
(
new IOobject
(
dictName,
runTime.constant(),
runTime,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
);
}
if (!csDictIoPtr->headerOk())
{
FatalErrorInFunction
<< "Cannot open coordinateSystems file\n "
<< csDictIoPtr->objectPath() << nl
<< exit(FatalError);
}
coordinateSystems csLst(csDictIoPtr());
if (args.optionFound("from"))
{
const word csName = args["from"];
const label csIndex = csLst.findIndex(csName);
if (csIndex < 0)
{
FatalErrorInFunction
<< "Cannot find -from " << csName << nl
<< "available coordinateSystems: " << csLst.toc() << nl
<< exit(FatalError);
}
fromCsys.reset(new coordinateSystem(csLst[csIndex]));
}
if (args.optionFound("to"))
{
const word csName = args["to"];
const label csIndex = csLst.findIndex(csName);
if (csIndex < 0)
{
FatalErrorInFunction
<< "Cannot find -to " << csName << nl
<< "available coordinateSystems: " << csLst.toc() << nl
<< exit(FatalError);
}
toCsys.reset(new coordinateSystem(csLst[csIndex]));
}
// maybe fix this later
if (fromCsys.valid() && toCsys.valid())
{
FatalErrorInFunction
<< "Only allowed '-from' or '-to' option at the moment."
<< exit(FatalError);
}
}
{
MeshedSurface<face> surf(importName);
if (args.optionFound("clean"))
{
surf.cleanup(true);
}
scalar scaleIn = 0;
if (args.optionReadIfPresent("scaleIn", scaleIn) && scaleIn > 0)
{
Info<< " -scaleIn " << scaleIn << endl;
surf.scalePoints(scaleIn);
}
if (fromCsys.valid())
{
Info<< " -from " << fromCsys().name() << endl;
tmp<pointField> tpf = fromCsys().localPosition(surf.points());
surf.movePoints(tpf());
}
if (toCsys.valid())
{
Info<< " -to " << toCsys().name() << endl;
tmp<pointField> tpf = toCsys().globalPosition(surf.points());
surf.movePoints(tpf());
}
scalar scaleOut = 0;
if (args.optionReadIfPresent("scaleOut", scaleOut) && scaleOut > 0)
{
Info<< " -scaleOut " << scaleOut << endl;
surf.scalePoints(scaleOut);
}
if (args.optionFound("tri"))
{
Info<< "triangulate" << endl;
surf.triangulate();
}
Info<< "writing " << exportName;
surf.write(exportName);
}
Info<< "\nEnd\n" << endl;
return 0;
}
void printSourceFileAndLine
(
Ostream& os,
const fileName& filename,
Dl_info *info,
void *addr
)
{
uintptr_t address = uintptr_t(addr);
word myAddress = addressToWord(address);
#if ! defined(darwin64)
if (filename.ext() == "so")
{
// Convert address into offset into dynamic library
uintptr_t offset = uintptr_t(info->dli_fbase);
intptr_t relativeAddress = address - offset;
myAddress = addressToWord(relativeAddress);
}
#endif
if (filename[0] == '/')
{
string line = pOpen
(
#if ! defined(darwin64)
"addr2line -f --demangle=auto --exe "
+ filename
+ " "
+ myAddress,
1
#else
"echo 'image lookup -a "
+ myAddress
+ " "
+ filename
+ "'"
+ " | xcrun lldb "
+ "-O 'target create --no-dependents -a x86_64 "
+ filename
+ "' -o '"
+ "target modules load -f "
+ filename
+ " __TEXT "
+ addressToWord(reinterpret_cast<const uintptr_t>(info->dli_fbase))
+ "'"
+ " | tail -1"
#endif
);
#if defined(darwin64)
{
const char *buf = line.c_str();
regex_t re;
regmatch_t mt[3];
int st;
regcomp(&re, ".\\+at \\(.\\+\\):\\(\\d\\+\\)", REG_ENHANCED);
st = regexec(&re, buf, 3, mt, 0);
if (st == REG_NOMATCH)
{
line = "??:0";
}
else
{
size_t len = mt[1].rm_eo - mt[1].rm_so;
string fname(buf + mt[1].rm_so, len);
len = mt[2].rm_eo - mt[2].rm_so;
string lnum(buf + mt[2].rm_so, len);
line = fname + ":" + lnum;
}
regfree(&re);
}
#endif
if (line == "")
{
os << " addr2line failed";
}
else if (line == "??:0")
{
line = filename;
string cwdLine(line.replaceAll(cwd() + '/', ""));
string homeLine(cwdLine.replaceAll(home(), '~'));
os << " in " << homeLine.c_str();
}
else
{
string cwdLine(line.replaceAll(cwd() + '/', ""));
string homeLine(cwdLine.replaceAll(home(), '~'));
os << " at " << homeLine.c_str();
}
}
}
int main(int argc, char *argv[])
{
argList::addNote
(
"Convert between edgeMesh formats"
);
argList::noParallel();
argList::validArgs.append("inputFile");
argList::validArgs.append("outputFile");
argList::addOption
(
"scale",
"factor",
"geometry scaling factor - default is 1"
);
argList args(argc, argv);
Time runTime(args.rootPath(), args.caseName());
const fileName importName = args[1];
const fileName exportName = args[2];
// disable inplace editing
if (importName == exportName)
{
FatalErrorInFunction
<< "Output file " << exportName << " would overwrite input file."
<< exit(FatalError);
}
// check that reading/writing is supported
if
(
!edgeMesh::canReadType(importName.ext(), true)
|| !edgeMesh::canWriteType(exportName.ext(), true)
)
{
return 1;
}
edgeMesh mesh(importName);
Info<< "\nRead edgeMesh " << importName << nl;
mesh.writeStats(Info);
Info<< nl
<< "\nwriting " << exportName;
scalar scaleFactor = 0;
if (args.optionReadIfPresent("scale", scaleFactor) && scaleFactor > 0)
{
Info<< " with scaling " << scaleFactor << endl;
mesh.scalePoints(scaleFactor);
}
else
{
Info<< " without scaling" << endl;
}
mesh.write(exportName);
mesh.writeStats(Info);
Info<< endl;
Info<< "\nEnd\n" << endl;
return 0;
}