## analytic metric
metric = SingularMetric(sizeinf, point_metric_file)
## Remesh Skeleton
if options.skeleton:
RemeshSkeleton(liaison, 1.66, sizeinf/100.0, metric).compute()
## Remesh
refineOptions = HashMap()
refineOptions.put("size", str(sizeinf))
refineOptions.put("coplanarity", str(coplanarity))
refineOptions.put("nearLengthRatio", str(options.nearLengthRatio))
refineOptions.put("project", "false")
if options.allowNearNodes:
refineOptions.put("allowNearNodes", "true")
refineAlgo = Remesh(liaison, refineOptions)
refineAlgo.setAnalyticMetric(metric)
refineAlgo.compute();
## Swap
swapOptions = HashMap()
swapOptions.put("coplanarity", str(coplanarity))
swapOptions.put("minCosAfterSwap", "0.3")
SwapEdge(liaison, swapOptions).compute()
## Improve valence
valenceOptions = HashMap()
valenceOptions.put("coplanarity", str(coplanarity))
valenceOptions.put("checkNormals", "false")
ImproveVertexValence(liaison, valenceOptions).compute()
if options.decimateSize or options.decimateTarget:
decimateOptions = HashMap()
if options.decimateSize:
decimateOptions.put("size", str(options.decimateSize))
elif options.decimateTarget:
decimateOptions.put("maxtriangles", str(options.decimateTarget))
if options.coplanarity:
decimateOptions.put("coplanarity", str(options.coplanarity))
QEMDecimateHalfEdge(liaison, decimateOptions).compute()
swapOptions = HashMap()
if options.coplanarity:
swapOptions.put("coplanarity", str(options.coplanarity))
SwapEdge(liaison, swapOptions).compute()
algo = Remesh(liaison, opts)
class RemeshMetric(AnalyticMetric):
def getTargetSize(self, x, y, z, groupId):
return min(200.0, (x - 9000.0)*(x - 9000.0) / 2250.0)
if options.point_metric_file:
if options.rho > 1.0:
algo.setAnalyticMetric(DistanceMetric(options.size, options.point_metric_file, options.rho, options.mixed))
else:
algo.setAnalyticMetric(DistanceMetric(options.size, options.point_metric_file))
elif setAnalytic:
algo.setAnalyticMetric(RemeshMetric());
algo.compute();
#MeshWriter.writeObject3D(algo.getOutputMesh(), outDir, String())
if options.recordFile:
if options.decimateSize or options.decimateTarget:
decimateOptions = HashMap()
if options.decimateSize:
decimateOptions.put("size", str(options.decimateSize))
elif options.decimateTarget:
decimateOptions.put("maxtriangles", str(options.decimateTarget))
if options.coplanarity:
decimateOptions.put("coplanarity", str(options.coplanarity))
QEMDecimateHalfEdge(liaison, decimateOptions).compute()
swapOptions = HashMap()
if options.coplanarity:
swapOptions.put("coplanarity", str(options.coplanarity))
SwapEdge(liaison, swapOptions).compute()
algo = Remesh(liaison, opts)
class RemeshMetric(Remesh.AnalyticMetricInterface):
def getTargetSize(self, x, y, z):
return min(200.0, (x - 9000.0)*(x - 9000.0) / 2250.0)
if options.point_metric_file:
algo.setAnalyticMetric(PointMetric(options.size, options.point_metric_file))
elif setAnalytic:
algo.setAnalyticMetric(RemeshMetric());
algo.compute();
#MeshWriter.writeObject3D(algo.getOutputMesh(), outDir, String())
if options.recordFile:
liaison.getMesh().getTrace().finish()
# Now compute beams
def remesh(**kwargs):
"""
Remesh an existing mesh with a singular analytical metric
"""
# Process coplanarity options
coplanarity = cos(kwargs["coplanarityAngle"] * pi / 180.0)
if kwargs["coplanarity"]:
coplanarity = kwargs["coplanarity"]
safe_coplanarity = kwargs["safe_coplanarity"]
if safe_coplanarity is None:
safe_coplanarity = 0.8
safe_coplanarity = max(coplanarity, safe_coplanarity)
# Build background mesh
try:
liaison = kwargs["liaison"]
except KeyError:
mtb = MeshTraitsBuilder.getDefault3D()
if kwargs["recordFile"]:
mtb.addTraceRecord()
mtb.addNodeSet()
mesh = Mesh(mtb)
if kwargs["recordFile"]:
mesh.getTrace().setDisabled(True)
MeshReader.readObject3D(mesh, kwargs["in_dir"])
liaison = MeshLiaison.create(mesh, mtb)
if kwargs["recordFile"]:
liaison.getMesh().getTrace().setDisabled(False)
liaison.getMesh().getTrace().setLogFile(kwargs["recordFile"])
liaison.getMesh().getTrace().createMesh("mesh", liaison.getMesh())
if kwargs["immutable_border"]:
liaison.mesh.tagFreeEdges(AbstractHalfEdge.IMMUTABLE)
liaison.getMesh().buildRidges(coplanarity)
if kwargs["preserveGroups"]:
liaison.getMesh().buildGroupBoundaries()
immutable_groups = []
if kwargs["immutable_groups_file"]:
f = open(kwargs["immutable_groups_file"])
immutable_groups = f.read().split()
f.close()
liaison.mesh.tagGroups(immutable_groups, AbstractHalfEdge.IMMUTABLE)
if kwargs["recordFile"]:
cmds = [
String("assert self.m.checkNoDegeneratedTriangles()"),
String("assert self.m.checkNoInvertedTriangles()"),
String("assert self.m.checkVertexLinks()"),
String("assert self.m.isValid()"),
]
liaison.getMesh().getTrace().setHooks(cmds)
# Decimate
if kwargs["decimateSize"] or kwargs["decimateTarget"]:
decimateOptions = HashMap()
if kwargs["decimateSize"]:
decimateOptions.put("size", str(kwargs["decimateSize"]))
elif kwargs["decimateTarget"]:
decimateOptions.put("maxtriangles", str(kwargs["decimateTarget"]))
decimateOptions.put("coplanarity", str(safe_coplanarity))
QEMDecimateHalfEdge(liaison, decimateOptions).compute()
swapOptions = HashMap()
swapOptions.put("coplanarity", str(safe_coplanarity))
SwapEdge(liaison, swapOptions).compute()
# Metric
if kwargs["rho"] > 1.0:
# mixed metric
metric = SingularMetric(kwargs["sizeinf"], kwargs["point_metric_file"],
kwargs["rho"], True)
else:
# analytic metric
metric = SingularMetric(kwargs["sizeinf"], kwargs["point_metric_file"])
# Remesh Skeleton
if kwargs["skeleton"]:
RemeshSkeleton(liaison, 1.66, metric, 0.01).compute()
# Remesh
refineOptions = HashMap()
refineOptions.put("size", str(kwargs["sizeinf"]))
refineOptions.put("coplanarity", str(safe_coplanarity))
refineOptions.put("nearLengthRatio", str(kwargs["nearLengthRatio"]))
refineOptions.put("project", "false")
if kwargs["allowNearNodes"]:
refineOptions.put("allowNearNodes", "true")
refineAlgo = Remesh(liaison, refineOptions)
refineAlgo.setAnalyticMetric(metric)
refineAlgo.compute()
if not kwargs["noclean"]:
# Swap
swapOptions = HashMap()
swapOptions.put("coplanarity", str(safe_coplanarity))
swapOptions.put("minCosAfterSwap", "0.3")
SwapEdge(liaison, swapOptions).compute()
# Improve valence
valenceOptions = HashMap()
valenceOptions.put("coplanarity", str(safe_coplanarity))
valenceOptions.put("checkNormals", "false")
ImproveVertexValence(liaison, valenceOptions).compute()
# Smooth
smoothOptions = HashMap()
smoothOptions.put("iterations", str(8))
smoothOptions.put("check", "true")
smoothOptions.put("boundaries", "true")
smoothOptions.put("relaxation", str(0.6))
if safe_coplanarity >= 0.0:
smoothOptions.put("coplanarity", str(safe_coplanarity))
SmoothNodes3DBg(liaison, smoothOptions).compute()
# Remove Degenerated
rdOptions = HashMap()
rdOptions.put("rho", str(kwargs["eratio"]))
RemoveDegeneratedTriangles(liaison, rdOptions).compute()
# remesh beams
if kwargs["wire_size"] > 0.0:
liaison = remesh_beams(
liaison=liaison,
size=kwargs["wire_size"],
rho=kwargs["rho"],
immutable_groups=immutable_groups,
point_metric_file=kwargs["wire_metric_file"],
)
# Output
MeshWriter.writeObject3D(liaison.getMesh(), kwargs["out_dir"], "")
if kwargs["recordFile"]:
liaison.getMesh().getTrace().finish()
decimateOptions.put("maxtriangles", str(options.decimateTarget))
decimateOptions.put("coplanarity", str(coplanarity))
QEMDecimateHalfEdge(liaison, decimateOptions).compute()
swapOptions = HashMap()
swapOptions.put("coplanarity", str(coplanarity))
SwapEdge(liaison, swapOptions).compute()
## Remesh
refineOptions = HashMap()
refineOptions.put("size", str(sizeinf))
refineOptions.put("coplanarity", str(coplanarity))
refineOptions.put("nearLengthRatio", str(options.nearLengthRatio))
refineOptions.put("project", "false")
if options.allowNearNodes:
refineOptions.put("allowNearNodes", "true")
refineAlgo = Remesh(liaison, refineOptions)
if options.rho > 1.0:
## mixed metric
refineAlgo.setAnalyticMetric(SingularMetric(sizeinf, point_metric_file, options.rho, True))
else:
## analytic metric
refineAlgo.setAnalyticMetric(SingularMetric(sizeinf, point_metric_file))
refineAlgo.compute();
## Swap
swapOptions = HashMap()
swapOptions.put("coplanarity", str(coplanarity))
swapOptions.put("minCosAfterSwap", "0.3")
SwapEdge(liaison, swapOptions).compute()
if options.recordFile:
cmds = [ String("assert self.m.checkNoDegeneratedTriangles()"),
String("assert self.m.checkNoInvertedTriangles()"),
String("assert self.m.checkVertexLinks()"),
String("assert self.m.isValid()") ]
liaison.getMesh().getTrace().setHooks(cmds)
## Refine
if options.size is not None:
RefineOpts = HashMap()
RefineOpts.put("size", str(options.size))
RefineOpts.put("coplanarity", str(coplanarity))
if options.allowNearNodes:
RefineOpts.put("allowNearNodes", "true")
RefineOpts.put("nearLengthRatio", str(options.nearLengthRatio))
Remesh(liaison, RefineOpts).compute()
if options.recordFile:
liaison.getMesh().getTrace().finish()
## Swap
swapOptions = HashMap()
swapOptions.put("coplanarity", str(coplanarity))
swapOptions.put("minCosAfterSwap", "0.3")
SwapEdge(liaison, swapOptions).compute()
## Improve valence
valenceOptions = HashMap()
valenceOptions.put("coplanarity", str(coplanarity))
valenceOptions.put("checkNormals", "false")
ImproveVertexValence(liaison, valenceOptions).compute()
if options.decimateSize or options.decimateTarget:
decimateOptions = HashMap()
if options.decimateSize:
decimateOptions.put("size", str(options.decimateSize))
elif options.decimateTarget:
decimateOptions.put("maxtriangles", str(options.decimateTarget))
if options.coplanarity:
decimateOptions.put("coplanarity", str(options.coplanarity))
QEMDecimateHalfEdge(liaison, decimateOptions).compute()
swapOptions = HashMap()
if options.coplanarity:
swapOptions.put("coplanarity", str(options.coplanarity))
SwapEdge(liaison, swapOptions).compute()
algo = Remesh(liaison, opts)
class RemeshMetric(Remesh.AnalyticMetricInterface):
def getTargetSize(self, x, y, z):
return min(200.0, (x - 9000.0) * (x - 9000.0) / 2250.0)
if options.point_metric_file:
algo.setAnalyticMetric(PointMetric(options.size,
options.point_metric_file))
elif setAnalytic:
algo.setAnalyticMetric(RemeshMetric())
algo.compute()
#MeshWriter.writeObject3D(algo.getOutputMesh(), outDir, String())
