1516 lines
44 KiB
C++
1516 lines
44 KiB
C++
// Copyright NVIDIA Corporation 2006 -- Ignacio Castano <icastano@nvidia.com>
|
|
|
|
#include "nvmesh.h" // pch
|
|
|
|
#include "Atlas.h"
|
|
#include "Util.h"
|
|
#include "AtlasBuilder.h"
|
|
#include "AtlasPacker.h"
|
|
#include "SingleFaceMap.h"
|
|
#include "OrthogonalProjectionMap.h"
|
|
#include "LeastSquaresConformalMap.h"
|
|
#include "ParameterizationQuality.h"
|
|
|
|
//#include "nvmesh/export/MeshExportOBJ.h"
|
|
|
|
#include "nvmesh/halfedge/Mesh.h"
|
|
#include "nvmesh/halfedge/Face.h"
|
|
#include "nvmesh/halfedge/Vertex.h"
|
|
|
|
#include "nvmesh/MeshBuilder.h"
|
|
#include "nvmesh/MeshTopology.h"
|
|
#include "nvmesh/param/Util.h"
|
|
#include "nvmesh/geometry/Measurements.h"
|
|
|
|
#include "nvmath/Vector.inl"
|
|
#include "nvmath/Fitting.h"
|
|
#include "nvmath/Box.inl"
|
|
#include "nvmath/ProximityGrid.h"
|
|
#include "nvmath/Morton.h"
|
|
|
|
#include "nvcore/StrLib.h"
|
|
#include "nvcore/Array.inl"
|
|
#include "nvcore/HashMap.inl"
|
|
|
|
using namespace nv;
|
|
|
|
|
|
/// Ctor.
|
|
Atlas::Atlas()
|
|
{
|
|
}
|
|
|
|
// Dtor.
|
|
Atlas::~Atlas()
|
|
{
|
|
deleteAll(m_meshChartsArray);
|
|
}
|
|
|
|
uint Atlas::chartCount() const
|
|
{
|
|
uint count = 0;
|
|
foreach(c, m_meshChartsArray) {
|
|
count += m_meshChartsArray[c]->chartCount();
|
|
}
|
|
return count;
|
|
}
|
|
|
|
const Chart * Atlas::chartAt(uint i) const
|
|
{
|
|
foreach(c, m_meshChartsArray) {
|
|
uint count = m_meshChartsArray[c]->chartCount();
|
|
|
|
if (i < count) {
|
|
return m_meshChartsArray[c]->chartAt(i);
|
|
}
|
|
|
|
i -= count;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
Chart * Atlas::chartAt(uint i)
|
|
{
|
|
foreach(c, m_meshChartsArray) {
|
|
uint count = m_meshChartsArray[c]->chartCount();
|
|
|
|
if (i < count) {
|
|
return m_meshChartsArray[c]->chartAt(i);
|
|
}
|
|
|
|
i -= count;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
// Extract the charts and add to this atlas.
|
|
void Atlas::addMeshCharts(MeshCharts * meshCharts)
|
|
{
|
|
m_meshChartsArray.append(meshCharts);
|
|
}
|
|
|
|
void Atlas::extractCharts(const HalfEdge::Mesh * mesh)
|
|
{
|
|
MeshCharts * meshCharts = new MeshCharts(mesh);
|
|
meshCharts->extractCharts();
|
|
addMeshCharts(meshCharts);
|
|
}
|
|
|
|
void Atlas::computeCharts(const HalfEdge::Mesh * mesh, const SegmentationSettings & settings, const Array<uint> & unchartedMaterialArray)
|
|
{
|
|
MeshCharts * meshCharts = new MeshCharts(mesh);
|
|
meshCharts->computeCharts(settings, unchartedMaterialArray);
|
|
addMeshCharts(meshCharts);
|
|
}
|
|
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
/// Compute a seamless texture atlas.
|
|
bool Atlas::computeSeamlessTextureAtlas(bool groupFaces/*= true*/, bool scaleTiles/*= false*/, uint w/*= 1024*/, uint h/* = 1024*/)
|
|
{
|
|
// Implement seamless texture atlas similar to what ZBrush does. See also:
|
|
// "Meshed Atlases for Real-Time Procedural Solid Texturing"
|
|
// http://graphics.cs.uiuc.edu/~jch/papers/rtpst.pdf
|
|
|
|
// Other methods that we should experiment with:
|
|
//
|
|
// Seamless Texture Atlases:
|
|
// http://www.cs.jhu.edu/~bpurnomo/STA/index.html
|
|
//
|
|
// Rectangular Multi-Chart Geometry Images:
|
|
// http://graphics.cs.uiuc.edu/~jch/papers/rmcgi.pdf
|
|
//
|
|
// Discrete differential geometry also provide a way of constructing
|
|
// seamless quadrangulations as shown in:
|
|
// http://www.geometry.caltech.edu/pubs/TACD06.pdf
|
|
//
|
|
|
|
#pragma message(NV_FILE_LINE "TODO: Implement seamless texture atlas.")
|
|
|
|
if (groupFaces)
|
|
{
|
|
// @@ TODO.
|
|
}
|
|
else
|
|
{
|
|
// @@ Create one atlas per face.
|
|
}
|
|
|
|
if (scaleTiles)
|
|
{
|
|
// @@ TODO
|
|
}
|
|
|
|
/*
|
|
if (!isQuadMesh(m_mesh)) {
|
|
// Only handle quads for now.
|
|
return false;
|
|
}
|
|
|
|
// Each face is a chart.
|
|
const uint faceCount = m_mesh->faceCount();
|
|
m_chartArray.resize(faceCount);
|
|
|
|
for(uint f = 0; f < faceCount; f++) {
|
|
m_chartArray[f].faceArray.clear();
|
|
m_chartArray[f].faceArray.append(f);
|
|
}
|
|
|
|
// Map each face to a separate square.
|
|
|
|
// Determine face layout according to width and height.
|
|
float aspect = float(m_width) / float(m_height);
|
|
|
|
uint i = 2;
|
|
uint total = (m_width / (i+1)) * (m_height / (i+1));
|
|
while(total > faceCount) {
|
|
i *= 2;
|
|
total = (m_width / (i+1)) * (m_height / (i+1));
|
|
}
|
|
|
|
uint tileSize = i / 2;
|
|
|
|
int x = 0;
|
|
int y = 0;
|
|
|
|
m_result = new HalfEdge::Mesh();
|
|
|
|
// Once you have that it's just matter of traversing the faces.
|
|
for(uint f = 0; f < faceCount; f++) {
|
|
// Compute texture coordinates.
|
|
Vector2 tex[4];
|
|
tex[0] = Vector2(float(x), float(y));
|
|
tex[1] = Vector2(float(x+tileSize), float(y));
|
|
tex[2] = Vector2(float(x+tileSize), float(y+tileSize));
|
|
tex[3] = Vector2(float(x), float(y+tileSize));
|
|
|
|
Array<uint> indexArray(4);
|
|
|
|
const HalfEdge::Face * face = m_mesh->faceAt(f);
|
|
|
|
int i = 0;
|
|
for(HalfEdge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance(), i++) {
|
|
const HalfEdge::Edge * edge = it.current();
|
|
const HalfEdge::Vertex * vertex = edge->from();
|
|
|
|
HalfEdge::Vertex * newVertex = m_result->addVertex(vertex->id(), vertex->pos());
|
|
|
|
newVertex->setTex(Vector3(tex[i], 0));
|
|
newVertex->setNor(vertex->nor());
|
|
|
|
indexArray.append(m_result->vertexCount() + 1);
|
|
}
|
|
|
|
m_result->addFace(indexArray);
|
|
|
|
// Move to the next tile.
|
|
x += tileSize + 1;
|
|
if (x + tileSize > m_width) {
|
|
x = 0;
|
|
y += tileSize + 1;
|
|
}
|
|
}
|
|
*/
|
|
|
|
return false;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
void Atlas::parameterizeCharts()
|
|
{
|
|
foreach(i, m_meshChartsArray) {
|
|
m_meshChartsArray[i]->parameterizeCharts();
|
|
}
|
|
}
|
|
|
|
|
|
float Atlas::packCharts(int quality, float texelsPerUnit, bool blockAlign, bool conservative)
|
|
{
|
|
AtlasPacker packer(this);
|
|
packer.packCharts(quality, texelsPerUnit, blockAlign, conservative);
|
|
return packer.computeAtlasUtilization();
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Ctor.
|
|
MeshCharts::MeshCharts(const HalfEdge::Mesh * mesh) : m_mesh(mesh)
|
|
{
|
|
}
|
|
|
|
// Dtor.
|
|
MeshCharts::~MeshCharts()
|
|
{
|
|
deleteAll(m_chartArray);
|
|
}
|
|
|
|
|
|
void MeshCharts::extractCharts()
|
|
{
|
|
const uint faceCount = m_mesh->faceCount();
|
|
|
|
int first = 0;
|
|
Array<uint> queue(faceCount);
|
|
|
|
BitArray bitFlags(faceCount);
|
|
bitFlags.clearAll();
|
|
|
|
for (uint f = 0; f < faceCount; f++)
|
|
{
|
|
if (bitFlags.bitAt(f) == false)
|
|
{
|
|
// Start new patch. Reset queue.
|
|
first = 0;
|
|
queue.clear();
|
|
queue.append(f);
|
|
bitFlags.setBitAt(f);
|
|
|
|
while (first != queue.count())
|
|
{
|
|
const HalfEdge::Face * face = m_mesh->faceAt(queue[first]);
|
|
|
|
// Visit face neighbors of queue[first]
|
|
for (HalfEdge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance())
|
|
{
|
|
const HalfEdge::Edge * edge = it.current();
|
|
nvDebugCheck(edge->pair != NULL);
|
|
|
|
if (!edge->isBoundary() && /*!edge->isSeam()*/
|
|
//!(edge->from()->tex() != edge->pair()->to()->tex() || edge->to()->tex() != edge->pair()->from()->tex()))
|
|
!(edge->from() != edge->pair->to() || edge->to() != edge->pair->from())) // Preserve existing seams (not just texture seams).
|
|
{
|
|
const HalfEdge::Face * neighborFace = edge->pair->face;
|
|
nvDebugCheck(neighborFace != NULL);
|
|
|
|
if (bitFlags.bitAt(neighborFace->id) == false)
|
|
{
|
|
queue.append(neighborFace->id);
|
|
bitFlags.setBitAt(neighborFace->id);
|
|
}
|
|
}
|
|
}
|
|
|
|
first++;
|
|
}
|
|
|
|
Chart * chart = new Chart();
|
|
chart->build(m_mesh, queue);
|
|
|
|
m_chartArray.append(chart);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
LSCM:
|
|
- identify sharp features using local dihedral angles.
|
|
- identify seed faces farthest from sharp features.
|
|
- grow charts from these seeds.
|
|
|
|
MCGIM:
|
|
- phase 1: chart growth
|
|
- grow all charts simultaneously using dijkstra search on the dual graph of the mesh.
|
|
- graph edges are weighted based on planarity metric.
|
|
- metric uses distance to global chart normal.
|
|
- terminate when all faces have been assigned.
|
|
- phase 2: seed computation:
|
|
- place new seed of the chart at the most interior face.
|
|
- most interior is evaluated using distance metric only.
|
|
|
|
- method repeates the two phases, until the location of the seeds does not change.
|
|
- cycles are detected by recording all the previous seeds and chartification terminates.
|
|
|
|
D-Charts:
|
|
|
|
- Uniaxial conic metric:
|
|
- N_c = axis of the generalized cone that best fits the chart. (cone can a be cylinder or a plane).
|
|
- omega_c = angle between the face normals and the axis.
|
|
- Fitting error between chart C and tringle t: F(c,t) = (N_c*n_t - cos(omega_c))^2
|
|
|
|
- Compactness metrics:
|
|
- Roundness:
|
|
- C(c,t) = pi * D(S_c,t)^2 / A_c
|
|
- S_c = chart seed.
|
|
- D(S_c,t) = length of the shortest path inside the chart betwen S_c and t.
|
|
- A_c = chart area.
|
|
- Straightness:
|
|
- P(c,t) = l_out(c,t) / l_in(c,t)
|
|
- l_out(c,t) = lenght of the edges not shared between C and t.
|
|
- l_in(c,t) = lenght of the edges shared between C and t.
|
|
|
|
- Combined metric:
|
|
- Cost(c,t) = F(c,t)^alpha + C(c,t)^beta + P(c,t)^gamma
|
|
- alpha = 1, beta = 0.7, gamma = 0.5
|
|
|
|
|
|
|
|
|
|
Our basic approach:
|
|
- Just one iteration of k-means?
|
|
- Avoid dijkstra by greedily growing charts until a threshold is met. Increase threshold and repeat until no faces left.
|
|
- If distortion metric is too high, split chart, add two seeds.
|
|
- If chart size is low, try removing chart.
|
|
|
|
|
|
Postprocess:
|
|
- If topology is not disk:
|
|
- Fill holes, if new faces fit proxy.
|
|
- Find best cut, otherwise.
|
|
- After parameterization:
|
|
- If boundary self-intersects:
|
|
- cut chart along the closest two diametral boundary vertices, repeat parametrization.
|
|
- what if the overlap is on an appendix? How do we find that out and cut appropiately?
|
|
- emphasize roundness metrics to prevent those cases.
|
|
- If interior self-overlaps: preserve boundary parameterization and use mean-value map.
|
|
|
|
*/
|
|
|
|
|
|
SegmentationSettings::SegmentationSettings()
|
|
{
|
|
// Charts have no area or boundary limits right now.
|
|
maxChartArea = NV_FLOAT_MAX;
|
|
maxBoundaryLength = NV_FLOAT_MAX;
|
|
|
|
proxyFitMetricWeight = 1.0f;
|
|
roundnessMetricWeight = 0.1f;
|
|
straightnessMetricWeight = 0.25f;
|
|
normalSeamMetricWeight = 1.0f;
|
|
textureSeamMetricWeight = 0.1f;
|
|
}
|
|
|
|
|
|
|
|
void MeshCharts::computeCharts(const SegmentationSettings & settings, const Array<uint> & unchartedMaterialArray)
|
|
{
|
|
Chart * vertexMap = NULL;
|
|
|
|
if (unchartedMaterialArray.count() != 0) {
|
|
vertexMap = new Chart();
|
|
vertexMap->buildVertexMap(m_mesh, unchartedMaterialArray);
|
|
|
|
if (vertexMap->faceCount() == 0) {
|
|
delete vertexMap;
|
|
vertexMap = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
AtlasBuilder builder(m_mesh);
|
|
|
|
if (vertexMap != NULL) {
|
|
// Mark faces that do not need to be charted.
|
|
builder.markUnchartedFaces(vertexMap->faceArray());
|
|
|
|
m_chartArray.append(vertexMap);
|
|
}
|
|
|
|
if (builder.facesLeft != 0) {
|
|
|
|
// Tweak these values:
|
|
const float maxThreshold = 2;
|
|
const uint growFaceCount = 32;
|
|
const uint maxIterations = 4;
|
|
|
|
builder.settings = settings;
|
|
|
|
//builder.settings.proxyFitMetricWeight *= 0.75; // relax proxy fit weight during initial seed placement.
|
|
//builder.settings.roundnessMetricWeight = 0;
|
|
//builder.settings.straightnessMetricWeight = 0;
|
|
|
|
// This seems a reasonable estimate.
|
|
uint maxSeedCount = max(6U, builder.facesLeft);
|
|
|
|
// Create initial charts greedely.
|
|
nvDebug("### Placing seeds\n");
|
|
builder.placeSeeds(maxThreshold, maxSeedCount);
|
|
nvDebug("### Placed %d seeds (max = %d)\n", builder.chartCount(), maxSeedCount);
|
|
|
|
builder.updateProxies();
|
|
|
|
builder.mergeCharts();
|
|
|
|
#if 1
|
|
nvDebug("### Relocating seeds\n");
|
|
builder.relocateSeeds();
|
|
|
|
nvDebug("### Reset charts\n");
|
|
builder.resetCharts();
|
|
|
|
if (vertexMap != NULL) {
|
|
builder.markUnchartedFaces(vertexMap->faceArray());
|
|
}
|
|
|
|
builder.settings = settings;
|
|
|
|
nvDebug("### Growing charts\n");
|
|
|
|
// Restart process growing charts in parallel.
|
|
uint iteration = 0;
|
|
while (true)
|
|
{
|
|
if (!builder.growCharts(maxThreshold, growFaceCount))
|
|
{
|
|
nvDebug("### Can't grow anymore\n");
|
|
|
|
// If charts cannot grow more: fill holes, merge charts, relocate seeds and start new iteration.
|
|
|
|
nvDebug("### Filling holes\n");
|
|
builder.fillHoles(maxThreshold);
|
|
nvDebug("### Using %d charts now\n", builder.chartCount());
|
|
|
|
builder.updateProxies();
|
|
|
|
nvDebug("### Merging charts\n");
|
|
builder.mergeCharts();
|
|
nvDebug("### Using %d charts now\n", builder.chartCount());
|
|
|
|
nvDebug("### Reseeding\n");
|
|
if (!builder.relocateSeeds())
|
|
{
|
|
nvDebug("### Cannot relocate seeds anymore\n");
|
|
|
|
// Done!
|
|
break;
|
|
}
|
|
|
|
if (iteration == maxIterations)
|
|
{
|
|
nvDebug("### Reached iteration limit\n");
|
|
break;
|
|
}
|
|
iteration++;
|
|
|
|
nvDebug("### Reset charts\n");
|
|
builder.resetCharts();
|
|
|
|
if (vertexMap != NULL) {
|
|
builder.markUnchartedFaces(vertexMap->faceArray());
|
|
}
|
|
|
|
nvDebug("### Growing charts\n");
|
|
}
|
|
};
|
|
#endif
|
|
|
|
// Make sure no holes are left!
|
|
nvDebugCheck(builder.facesLeft == 0);
|
|
|
|
const uint chartCount = builder.chartArray.count();
|
|
for (uint i = 0; i < chartCount; i++)
|
|
{
|
|
Chart * chart = new Chart();
|
|
m_chartArray.append(chart);
|
|
|
|
chart->build(m_mesh, builder.chartFaces(i));
|
|
}
|
|
}
|
|
|
|
|
|
const uint chartCount = m_chartArray.count();
|
|
|
|
// Build face indices.
|
|
m_faceChart.resize(m_mesh->faceCount());
|
|
m_faceIndex.resize(m_mesh->faceCount());
|
|
|
|
for (uint i = 0; i < chartCount; i++)
|
|
{
|
|
const Chart * chart = m_chartArray[i];
|
|
|
|
const uint faceCount = chart->faceCount();
|
|
for (uint f = 0; f < faceCount; f++)
|
|
{
|
|
uint idx = chart->faceAt(f);
|
|
m_faceChart[idx] = i;
|
|
m_faceIndex[idx] = f;
|
|
}
|
|
}
|
|
|
|
// Build an exclusive prefix sum of the chart vertex counts.
|
|
m_chartVertexCountPrefixSum.resize(chartCount);
|
|
|
|
if (chartCount > 0)
|
|
{
|
|
m_chartVertexCountPrefixSum[0] = 0;
|
|
|
|
for (uint i = 1; i < chartCount; i++)
|
|
{
|
|
const Chart * chart = m_chartArray[i-1];
|
|
m_chartVertexCountPrefixSum[i] = m_chartVertexCountPrefixSum[i-1] + chart->vertexCount();
|
|
}
|
|
|
|
m_totalVertexCount = m_chartVertexCountPrefixSum[chartCount - 1] + m_chartArray[chartCount-1]->vertexCount();
|
|
}
|
|
else
|
|
{
|
|
m_totalVertexCount = 0;
|
|
}
|
|
}
|
|
|
|
|
|
void MeshCharts::parameterizeCharts()
|
|
{
|
|
ParameterizationQuality globalParameterizationQuality;
|
|
|
|
// Parameterize the charts.
|
|
uint diskCount = 0;
|
|
const uint chartCount = m_chartArray.count();
|
|
for (uint i = 0; i < chartCount; i++)\
|
|
{
|
|
Chart * chart = m_chartArray[i];
|
|
|
|
bool isValid = false;
|
|
|
|
if (chart->isVertexMapped()) {
|
|
continue;
|
|
}
|
|
|
|
if (chart->isDisk())
|
|
{
|
|
diskCount++;
|
|
|
|
ParameterizationQuality chartParameterizationQuality;
|
|
|
|
if (chart->faceCount() == 1) {
|
|
computeSingleFaceMap(chart->unifiedMesh());
|
|
|
|
chartParameterizationQuality = ParameterizationQuality(chart->unifiedMesh());
|
|
}
|
|
else {
|
|
computeOrthogonalProjectionMap(chart->unifiedMesh());
|
|
ParameterizationQuality orthogonalQuality(chart->unifiedMesh());
|
|
|
|
computeLeastSquaresConformalMap(chart->unifiedMesh());
|
|
ParameterizationQuality lscmQuality(chart->unifiedMesh());
|
|
|
|
// If the orthogonal projection produces better results, just use that.
|
|
// @@ It may be dangerous to do this, because isValid() does not detect self-overlaps.
|
|
// @@ Another problem is that with very thin patches with nearly zero parametric area, the results of our metric are not accurate.
|
|
/*if (orthogonalQuality.isValid() && orthogonalQuality.rmsStretchMetric() < lscmQuality.rmsStretchMetric()) {
|
|
computeOrthogonalProjectionMap(chart->unifiedMesh());
|
|
chartParameterizationQuality = orthogonalQuality;
|
|
}
|
|
else*/ {
|
|
chartParameterizationQuality = lscmQuality;
|
|
}
|
|
|
|
// If conformal map failed,
|
|
|
|
// @@ Experiment with other parameterization methods.
|
|
//computeCircularBoundaryMap(chart->unifiedMesh());
|
|
//computeConformalMap(chart->unifiedMesh());
|
|
//computeNaturalConformalMap(chart->unifiedMesh());
|
|
//computeGuidanceGradientMap(chart->unifiedMesh());
|
|
}
|
|
|
|
//ParameterizationQuality chartParameterizationQuality(chart->unifiedMesh());
|
|
|
|
isValid = chartParameterizationQuality.isValid();
|
|
|
|
if (!isValid)
|
|
{
|
|
nvDebug("*** Invalid parameterization.\n");
|
|
#if 0
|
|
// Dump mesh to inspect problem:
|
|
static int pieceCount = 0;
|
|
|
|
StringBuilder fileName;
|
|
fileName.format("invalid_chart_%d.obj", pieceCount++);
|
|
exportMesh(chart->unifiedMesh(), fileName.str());
|
|
#endif
|
|
}
|
|
|
|
// @@ Check that parameterization quality is above a certain threshold.
|
|
|
|
// @@ Detect boundary self-intersections.
|
|
|
|
globalParameterizationQuality += chartParameterizationQuality;
|
|
}
|
|
|
|
if (!isValid)
|
|
{
|
|
//nvDebugBreak();
|
|
// @@ Run the builder again, but only on this chart.
|
|
//AtlasBuilder builder(chart->chartMesh());
|
|
}
|
|
|
|
// Transfer parameterization from unified mesh to chart mesh.
|
|
chart->transferParameterization();
|
|
|
|
}
|
|
|
|
nvDebug(" Parameterized %d/%d charts.\n", diskCount, chartCount);
|
|
nvDebug(" RMS stretch metric: %f\n", globalParameterizationQuality.rmsStretchMetric());
|
|
nvDebug(" MAX stretch metric: %f\n", globalParameterizationQuality.maxStretchMetric());
|
|
nvDebug(" RMS conformal metric: %f\n", globalParameterizationQuality.rmsConformalMetric());
|
|
nvDebug(" RMS authalic metric: %f\n", globalParameterizationQuality.maxAuthalicMetric());
|
|
}
|
|
|
|
|
|
|
|
Chart::Chart() : m_chartMesh(NULL), m_unifiedMesh(NULL), m_isDisk(false), m_isVertexMapped(false)
|
|
{
|
|
}
|
|
|
|
void Chart::build(const HalfEdge::Mesh * originalMesh, const Array<uint> & faceArray)
|
|
{
|
|
// Copy face indices.
|
|
m_faceArray = faceArray;
|
|
|
|
const uint meshVertexCount = originalMesh->vertexCount();
|
|
|
|
m_chartMesh = new HalfEdge::Mesh();
|
|
m_unifiedMesh = new HalfEdge::Mesh();
|
|
|
|
Array<uint> chartMeshIndices;
|
|
chartMeshIndices.resize(meshVertexCount, ~0);
|
|
|
|
Array<uint> unifiedMeshIndices;
|
|
unifiedMeshIndices.resize(meshVertexCount, ~0);
|
|
|
|
// Add vertices.
|
|
const uint faceCount = faceArray.count();
|
|
for (uint f = 0; f < faceCount; f++)
|
|
{
|
|
const HalfEdge::Face * face = originalMesh->faceAt(faceArray[f]);
|
|
nvDebugCheck(face != NULL);
|
|
|
|
for(HalfEdge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance())
|
|
{
|
|
const HalfEdge::Vertex * vertex = it.current()->vertex;
|
|
const HalfEdge::Vertex * unifiedVertex = vertex->firstColocal();
|
|
|
|
if (unifiedMeshIndices[unifiedVertex->id] == ~0)
|
|
{
|
|
unifiedMeshIndices[unifiedVertex->id] = m_unifiedMesh->vertexCount();
|
|
|
|
nvDebugCheck(vertex->pos == unifiedVertex->pos);
|
|
m_unifiedMesh->addVertex(vertex->pos);
|
|
}
|
|
|
|
if (chartMeshIndices[vertex->id] == ~0)
|
|
{
|
|
chartMeshIndices[vertex->id] = m_chartMesh->vertexCount();
|
|
m_chartToOriginalMap.append(vertex->id);
|
|
m_chartToUnifiedMap.append(unifiedMeshIndices[unifiedVertex->id]);
|
|
|
|
HalfEdge::Vertex * v = m_chartMesh->addVertex(vertex->pos);
|
|
v->nor = vertex->nor;
|
|
v->tex = vertex->tex;
|
|
}
|
|
}
|
|
}
|
|
|
|
// This is ignoring the canonical map:
|
|
// - Is it really necessary to link colocals?
|
|
|
|
m_chartMesh->linkColocals();
|
|
//m_unifiedMesh->linkColocals(); // Not strictly necessary, no colocals in the unified mesh. # Wrong.
|
|
|
|
// This check is not valid anymore, if the original mesh vertices were linked with a canonical map, then it might have
|
|
// some colocal vertices that were unlinked. So, the unified mesh might have some duplicate vertices, because firstColocal()
|
|
// is not guaranteed to return the same vertex for two colocal vertices.
|
|
//nvCheck(m_chartMesh->colocalVertexCount() == m_unifiedMesh->vertexCount());
|
|
|
|
// Is that OK? What happens in meshes were that happens? Does anything break? Apparently not...
|
|
|
|
|
|
|
|
Array<uint> faceIndices(7);
|
|
|
|
// Add faces.
|
|
for (uint f = 0; f < faceCount; f++)
|
|
{
|
|
const HalfEdge::Face * face = originalMesh->faceAt(faceArray[f]);
|
|
nvDebugCheck(face != NULL);
|
|
|
|
faceIndices.clear();
|
|
|
|
for(HalfEdge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance())
|
|
{
|
|
const HalfEdge::Vertex * vertex = it.current()->vertex;
|
|
nvDebugCheck(vertex != NULL);
|
|
|
|
faceIndices.append(chartMeshIndices[vertex->id]);
|
|
}
|
|
|
|
m_chartMesh->addFace(faceIndices);
|
|
|
|
faceIndices.clear();
|
|
|
|
for(HalfEdge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance())
|
|
{
|
|
const HalfEdge::Vertex * vertex = it.current()->vertex;
|
|
nvDebugCheck(vertex != NULL);
|
|
|
|
vertex = vertex->firstColocal();
|
|
|
|
faceIndices.append(unifiedMeshIndices[vertex->id]);
|
|
}
|
|
|
|
m_unifiedMesh->addFace(faceIndices);
|
|
}
|
|
|
|
m_chartMesh->linkBoundary();
|
|
m_unifiedMesh->linkBoundary();
|
|
|
|
//exportMesh(m_unifiedMesh.ptr(), "debug_input.obj");
|
|
|
|
if (m_unifiedMesh->splitBoundaryEdges()) {
|
|
m_unifiedMesh = unifyVertices(m_unifiedMesh.ptr());
|
|
}
|
|
|
|
//exportMesh(m_unifiedMesh.ptr(), "debug_split.obj");
|
|
|
|
// Closing the holes is not always the best solution and does not fix all the problems.
|
|
// We need to do some analysis of the holes and the genus to:
|
|
// - Find cuts that reduce genus.
|
|
// - Find cuts to connect holes.
|
|
// - Use minimal spanning trees or seamster.
|
|
if (!closeHoles()) {
|
|
/*static int pieceCount = 0;
|
|
StringBuilder fileName;
|
|
fileName.format("debug_hole_%d.obj", pieceCount++);
|
|
exportMesh(m_unifiedMesh.ptr(), fileName.str());*/
|
|
}
|
|
|
|
m_unifiedMesh = triangulate(m_unifiedMesh.ptr());
|
|
|
|
//exportMesh(m_unifiedMesh.ptr(), "debug_triangulated.obj");
|
|
|
|
|
|
// Analyze chart topology.
|
|
MeshTopology topology(m_unifiedMesh.ptr());
|
|
m_isDisk = topology.isDisk();
|
|
|
|
// This is sometimes failing, when triangulate fails to add a triangle, it generates a hole in the mesh.
|
|
//nvDebugCheck(m_isDisk);
|
|
|
|
/*if (!m_isDisk) {
|
|
static int pieceCount = 0;
|
|
StringBuilder fileName;
|
|
fileName.format("debug_hole_%d.obj", pieceCount++);
|
|
exportMesh(m_unifiedMesh.ptr(), fileName.str());
|
|
}*/
|
|
|
|
|
|
#if 0
|
|
if (!m_isDisk) {
|
|
nvDebugBreak();
|
|
|
|
static int pieceCount = 0;
|
|
|
|
StringBuilder fileName;
|
|
fileName.format("debug_nodisk_%d.obj", pieceCount++);
|
|
exportMesh(m_chartMesh.ptr(), fileName.str());
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
void Chart::buildVertexMap(const HalfEdge::Mesh * originalMesh, const Array<uint> & unchartedMaterialArray)
|
|
{
|
|
nvCheck(m_chartMesh == NULL && m_unifiedMesh == NULL);
|
|
|
|
m_isVertexMapped = true;
|
|
|
|
// Build face indices.
|
|
m_faceArray.clear();
|
|
|
|
const uint meshFaceCount = originalMesh->faceCount();
|
|
for (uint f = 0; f < meshFaceCount; f++) {
|
|
const HalfEdge::Face * face = originalMesh->faceAt(f);
|
|
|
|
if (unchartedMaterialArray.contains(face->material)) {
|
|
m_faceArray.append(f);
|
|
}
|
|
}
|
|
|
|
const uint faceCount = m_faceArray.count();
|
|
|
|
if (faceCount == 0) {
|
|
return;
|
|
}
|
|
|
|
|
|
// @@ The chartMesh construction is basically the same as with regular charts, don't duplicate!
|
|
|
|
const uint meshVertexCount = originalMesh->vertexCount();
|
|
|
|
m_chartMesh = new HalfEdge::Mesh();
|
|
|
|
Array<uint> chartMeshIndices;
|
|
chartMeshIndices.resize(meshVertexCount, ~0);
|
|
|
|
// Vertex map mesh only has disconnected vertices.
|
|
for (uint f = 0; f < faceCount; f++)
|
|
{
|
|
const HalfEdge::Face * face = originalMesh->faceAt(m_faceArray[f]);
|
|
nvDebugCheck(face != NULL);
|
|
|
|
for (HalfEdge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance())
|
|
{
|
|
const HalfEdge::Vertex * vertex = it.current()->vertex;
|
|
|
|
if (chartMeshIndices[vertex->id] == ~0)
|
|
{
|
|
chartMeshIndices[vertex->id] = m_chartMesh->vertexCount();
|
|
m_chartToOriginalMap.append(vertex->id);
|
|
|
|
HalfEdge::Vertex * v = m_chartMesh->addVertex(vertex->pos);
|
|
v->nor = vertex->nor;
|
|
v->tex = vertex->tex; // @@ Not necessary.
|
|
}
|
|
}
|
|
}
|
|
|
|
// @@ Link colocals using the original mesh canonical map? Build canonical map on the fly? Do we need to link colocals at all for this?
|
|
//m_chartMesh->linkColocals();
|
|
|
|
Array<uint> faceIndices(7);
|
|
|
|
// Add faces.
|
|
for (uint f = 0; f < faceCount; f++)
|
|
{
|
|
const HalfEdge::Face * face = originalMesh->faceAt(m_faceArray[f]);
|
|
nvDebugCheck(face != NULL);
|
|
|
|
faceIndices.clear();
|
|
|
|
for(HalfEdge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance())
|
|
{
|
|
const HalfEdge::Vertex * vertex = it.current()->vertex;
|
|
nvDebugCheck(vertex != NULL);
|
|
nvDebugCheck(chartMeshIndices[vertex->id] != ~0);
|
|
|
|
faceIndices.append(chartMeshIndices[vertex->id]);
|
|
}
|
|
|
|
HalfEdge::Face * new_face = m_chartMesh->addFace(faceIndices);
|
|
nvDebugCheck(new_face != NULL);
|
|
}
|
|
|
|
m_chartMesh->linkBoundary();
|
|
|
|
|
|
const uint chartVertexCount = m_chartMesh->vertexCount();
|
|
|
|
Box bounds;
|
|
bounds.clearBounds();
|
|
|
|
for (uint i = 0; i < chartVertexCount; i++) {
|
|
HalfEdge::Vertex * vertex = m_chartMesh->vertexAt(i);
|
|
bounds.addPointToBounds(vertex->pos);
|
|
}
|
|
|
|
ProximityGrid grid;
|
|
grid.init(bounds, chartVertexCount);
|
|
|
|
for (uint i = 0; i < chartVertexCount; i++) {
|
|
HalfEdge::Vertex * vertex = m_chartMesh->vertexAt(i);
|
|
grid.add(vertex->pos, i);
|
|
}
|
|
|
|
|
|
#if 0
|
|
// Arrange vertices in a rectangle.
|
|
vertexMapWidth = ftoi_ceil(sqrtf(float(chartVertexCount)));
|
|
vertexMapHeight = (chartVertexCount + vertexMapWidth - 1) / vertexMapWidth;
|
|
nvDebugCheck(vertexMapWidth >= vertexMapHeight);
|
|
|
|
int x = 0, y = 0;
|
|
for (uint i = 0; i < chartVertexCount; i++) {
|
|
HalfEdge::Vertex * vertex = m_chartMesh->vertexAt(i);
|
|
|
|
vertex->tex.x = float(x);
|
|
vertex->tex.y = float(y);
|
|
|
|
x++;
|
|
if (x == vertexMapWidth) {
|
|
x = 0;
|
|
y++;
|
|
nvCheck(y < vertexMapHeight);
|
|
}
|
|
}
|
|
|
|
#elif 0
|
|
// Arrange vertices in a rectangle, traversing grid in 3D morton order and laying them down in 2D morton order.
|
|
vertexMapWidth = ftoi_ceil(sqrtf(float(chartVertexCount)));
|
|
vertexMapHeight = (chartVertexCount + vertexMapWidth - 1) / vertexMapWidth;
|
|
nvDebugCheck(vertexMapWidth >= vertexMapHeight);
|
|
|
|
int n = 0;
|
|
uint32 texelCode = 0;
|
|
|
|
uint cellsVisited = 0;
|
|
|
|
const uint32 cellCodeCount = grid.mortonCount();
|
|
for (uint32 cellCode = 0; cellCode < cellCodeCount; cellCode++) {
|
|
int cell = grid.mortonIndex(cellCode);
|
|
if (cell < 0) continue;
|
|
|
|
cellsVisited++;
|
|
|
|
const Array<uint> & indexArray = grid.cellArray[cell].indexArray;
|
|
|
|
foreach(i, indexArray) {
|
|
uint idx = indexArray[i];
|
|
HalfEdge::Vertex * vertex = m_chartMesh->vertexAt(idx);
|
|
|
|
//vertex->tex.x = float(n % rectangleWidth) + 0.5f;
|
|
//vertex->tex.y = float(n / rectangleWidth) + 0.5f;
|
|
|
|
// Lay down the points in z order too.
|
|
uint x, y;
|
|
do {
|
|
x = decodeMorton2X(texelCode);
|
|
y = decodeMorton2Y(texelCode);
|
|
texelCode++;
|
|
} while (x >= U32(vertexMapWidth) || y >= U32(vertexMapHeight));
|
|
|
|
vertex->tex.x = float(x);
|
|
vertex->tex.y = float(y);
|
|
|
|
n++;
|
|
}
|
|
}
|
|
|
|
nvDebugCheck(cellsVisited == grid.cellArray.count());
|
|
nvDebugCheck(n == chartVertexCount);
|
|
|
|
#else
|
|
|
|
uint texelCount = 0;
|
|
|
|
const float positionThreshold = 0.01f;
|
|
const float normalThreshold = 0.01f;
|
|
|
|
uint verticesVisited = 0;
|
|
uint cellsVisited = 0;
|
|
|
|
Array<int> vertexIndexArray;
|
|
vertexIndexArray.resize(chartVertexCount, -1); // Init all indices to -1.
|
|
|
|
// Traverse vertices in morton order. @@ It may be more interesting to sort them based on orientation.
|
|
const uint cellCodeCount = grid.mortonCount();
|
|
for (uint cellCode = 0; cellCode < cellCodeCount; cellCode++) {
|
|
int cell = grid.mortonIndex(cellCode);
|
|
if (cell < 0) continue;
|
|
|
|
cellsVisited++;
|
|
|
|
const Array<uint> & indexArray = grid.cellArray[cell].indexArray;
|
|
|
|
foreach(i, indexArray) {
|
|
uint idx = indexArray[i];
|
|
HalfEdge::Vertex * vertex = m_chartMesh->vertexAt(idx);
|
|
|
|
nvDebugCheck(vertexIndexArray[idx] == -1);
|
|
|
|
Array<uint> neighbors;
|
|
grid.gather(vertex->pos, positionThreshold, /*ref*/neighbors);
|
|
|
|
// Compare against all nearby vertices, cluster greedily.
|
|
foreach(j, neighbors) {
|
|
uint otherIdx = neighbors[j];
|
|
|
|
if (vertexIndexArray[otherIdx] != -1) {
|
|
HalfEdge::Vertex * otherVertex = m_chartMesh->vertexAt(otherIdx);
|
|
|
|
if (distance(vertex->pos, otherVertex->pos) < positionThreshold &&
|
|
distance(vertex->nor, otherVertex->nor) < normalThreshold)
|
|
{
|
|
vertexIndexArray[idx] = vertexIndexArray[otherIdx];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If index not assigned, assign new one.
|
|
if (vertexIndexArray[idx] == -1) {
|
|
vertexIndexArray[idx] = texelCount++;
|
|
}
|
|
|
|
verticesVisited++;
|
|
}
|
|
}
|
|
|
|
nvDebugCheck(cellsVisited == grid.cellArray.count());
|
|
nvDebugCheck(verticesVisited == chartVertexCount);
|
|
|
|
vertexMapWidth = ftoi_ceil(sqrtf(float(texelCount)));
|
|
vertexMapWidth = (vertexMapWidth + 3) & ~3; // Width aligned to 4.
|
|
vertexMapHeight = vertexMapWidth == 0 ? 0 : (texelCount + vertexMapWidth - 1) / vertexMapWidth;
|
|
//vertexMapHeight = (vertexMapHeight + 3) & ~3; // Height aligned to 4.
|
|
nvDebugCheck(vertexMapWidth >= vertexMapHeight);
|
|
|
|
nvDebug("Reduced vertex count from %d to %d.\n", chartVertexCount, texelCount);
|
|
|
|
#if 0
|
|
// This lays down the clustered vertices linearly.
|
|
for (uint i = 0; i < chartVertexCount; i++) {
|
|
HalfEdge::Vertex * vertex = m_chartMesh->vertexAt(i);
|
|
|
|
int idx = vertexIndexArray[i];
|
|
|
|
vertex->tex.x = float(idx % vertexMapWidth);
|
|
vertex->tex.y = float(idx / vertexMapWidth);
|
|
}
|
|
#else
|
|
// Lay down the clustered vertices in morton order.
|
|
|
|
Array<uint> texelCodes;
|
|
texelCodes.resize(texelCount);
|
|
|
|
// For each texel, assign one morton code.
|
|
uint texelCode = 0;
|
|
for (uint i = 0; i < texelCount; i++) {
|
|
uint x, y;
|
|
do {
|
|
x = decodeMorton2X(texelCode);
|
|
y = decodeMorton2Y(texelCode);
|
|
texelCode++;
|
|
} while (x >= U32(vertexMapWidth) || y >= U32(vertexMapHeight));
|
|
|
|
texelCodes[i] = texelCode - 1;
|
|
}
|
|
|
|
for (uint i = 0; i < chartVertexCount; i++) {
|
|
HalfEdge::Vertex * vertex = m_chartMesh->vertexAt(i);
|
|
|
|
int idx = vertexIndexArray[i];
|
|
if (idx != -1) {
|
|
uint texelCode = texelCodes[idx];
|
|
uint x = decodeMorton2X(texelCode);
|
|
uint y = decodeMorton2Y(texelCode);
|
|
|
|
vertex->tex.x = float(x);
|
|
vertex->tex.y = float(y);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static void getBoundaryEdges(HalfEdge::Mesh * mesh, Array<HalfEdge::Edge *> & boundaryEdges)
|
|
{
|
|
nvDebugCheck(mesh != NULL);
|
|
|
|
const uint edgeCount = mesh->edgeCount();
|
|
|
|
BitArray bitFlags(edgeCount);
|
|
bitFlags.clearAll();
|
|
|
|
boundaryEdges.clear();
|
|
|
|
// Search for boundary edges. Mark all the edges that belong to the same boundary.
|
|
for (uint e = 0; e < edgeCount; e++)
|
|
{
|
|
HalfEdge::Edge * startEdge = mesh->edgeAt(e);
|
|
|
|
if (startEdge != NULL && startEdge->isBoundary() && bitFlags.bitAt(e) == false)
|
|
{
|
|
nvDebugCheck(startEdge->face != NULL);
|
|
nvDebugCheck(startEdge->pair->face == NULL);
|
|
|
|
startEdge = startEdge->pair;
|
|
|
|
const HalfEdge::Edge * edge = startEdge;
|
|
do {
|
|
nvDebugCheck(edge->face == NULL);
|
|
nvDebugCheck(bitFlags.bitAt(edge->id/2) == false);
|
|
|
|
bitFlags.setBitAt(edge->id / 2);
|
|
edge = edge->next;
|
|
} while(startEdge != edge);
|
|
|
|
boundaryEdges.append(startEdge);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
bool Chart::closeLoop(uint start, const Array<HalfEdge::Edge *> & loop)
|
|
{
|
|
const uint vertexCount = loop.count() - start;
|
|
|
|
nvDebugCheck(vertexCount >= 3);
|
|
if (vertexCount < 3) return false;
|
|
|
|
nvDebugCheck(loop[start]->vertex->isColocal(loop[start+vertexCount-1]->to()));
|
|
|
|
// If the hole is planar, then we add a single face that will be properly triangulated later.
|
|
// If the hole is not planar, we add a triangle fan with a vertex at the hole centroid.
|
|
// This is still a bit of a hack. There surely are better hole filling algorithms out there.
|
|
|
|
Array<Vector3> points;
|
|
points.resize(vertexCount);
|
|
for (uint i = 0; i < vertexCount; i++) {
|
|
points[i] = loop[start+i]->vertex->pos;
|
|
}
|
|
|
|
bool isPlanar = Fit::isPlanar(vertexCount, points.buffer());
|
|
|
|
if (isPlanar) {
|
|
// Add face and connect edges.
|
|
HalfEdge::Face * face = m_unifiedMesh->addFace();
|
|
for (uint i = 0; i < vertexCount; i++) {
|
|
HalfEdge::Edge * edge = loop[start + i];
|
|
|
|
edge->face = face;
|
|
edge->setNext(loop[start + (i + 1) % vertexCount]);
|
|
}
|
|
face->edge = loop[start];
|
|
|
|
nvDebugCheck(face->isValid());
|
|
}
|
|
else {
|
|
// If the polygon is not planar, we just cross our fingers, and hope this will work:
|
|
|
|
// Compute boundary centroid:
|
|
Vector3 centroidPos(0);
|
|
|
|
for (uint i = 0; i < vertexCount; i++) {
|
|
centroidPos += points[i];
|
|
}
|
|
|
|
centroidPos *= (1.0f / vertexCount);
|
|
|
|
HalfEdge::Vertex * centroid = m_unifiedMesh->addVertex(centroidPos);
|
|
|
|
// Add one pair of edges for each boundary vertex.
|
|
for (uint j = vertexCount-1, i = 0; i < vertexCount; j = i++) {
|
|
HalfEdge::Face * face = m_unifiedMesh->addFace(centroid->id, loop[start+j]->vertex->id, loop[start+i]->vertex->id);
|
|
nvDebugCheck(face != NULL);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool Chart::closeHoles()
|
|
{
|
|
nvDebugCheck(!m_isVertexMapped);
|
|
|
|
Array<HalfEdge::Edge *> boundaryEdges;
|
|
getBoundaryEdges(m_unifiedMesh.ptr(), boundaryEdges);
|
|
|
|
uint boundaryCount = boundaryEdges.count();
|
|
if (boundaryCount <= 1)
|
|
{
|
|
// Nothing to close.
|
|
return true;
|
|
}
|
|
|
|
// Compute lengths and areas.
|
|
Array<float> boundaryLengths;
|
|
//Array<Vector3> boundaryCentroids;
|
|
|
|
for (uint i = 0; i < boundaryCount; i++)
|
|
{
|
|
const HalfEdge::Edge * startEdge = boundaryEdges[i];
|
|
nvCheck(startEdge->face == NULL);
|
|
|
|
//float boundaryEdgeCount = 0;
|
|
float boundaryLength = 0.0f;
|
|
//Vector3 boundaryCentroid(zero);
|
|
|
|
const HalfEdge::Edge * edge = startEdge;
|
|
do {
|
|
Vector3 t0 = edge->from()->pos;
|
|
Vector3 t1 = edge->to()->pos;
|
|
|
|
//boundaryEdgeCount++;
|
|
boundaryLength += length(t1 - t0);
|
|
//boundaryCentroid += edge->vertex()->pos;
|
|
|
|
edge = edge->next;
|
|
} while(edge != startEdge);
|
|
|
|
boundaryLengths.append(boundaryLength);
|
|
//boundaryCentroids.append(boundaryCentroid / boundaryEdgeCount);
|
|
}
|
|
|
|
|
|
// Find disk boundary.
|
|
uint diskBoundary = 0;
|
|
float maxLength = boundaryLengths[0];
|
|
|
|
for (uint i = 1; i < boundaryCount; i++)
|
|
{
|
|
if (boundaryLengths[i] > maxLength)
|
|
{
|
|
maxLength = boundaryLengths[i];
|
|
diskBoundary = i;
|
|
}
|
|
}
|
|
|
|
|
|
// Sew holes.
|
|
/*for (uint i = 0; i < boundaryCount; i++)
|
|
{
|
|
if (diskBoundary == i)
|
|
{
|
|
// Skip disk boundary.
|
|
continue;
|
|
}
|
|
|
|
HalfEdge::Edge * startEdge = boundaryEdges[i];
|
|
nvCheck(startEdge->face() == NULL);
|
|
|
|
boundaryEdges[i] = m_unifiedMesh->sewBoundary(startEdge);
|
|
}
|
|
|
|
exportMesh(m_unifiedMesh.ptr(), "debug_sewn.obj");*/
|
|
|
|
//bool hasNewHoles = false;
|
|
|
|
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
// @@ Close loop is wrong, after closing a loop, we do not only have to add the face, but make sure that every edge in he loop is pointing to the right place.
|
|
|
|
// Close holes.
|
|
for (uint i = 0; i < boundaryCount; i++)
|
|
{
|
|
if (diskBoundary == i)
|
|
{
|
|
// Skip disk boundary.
|
|
continue;
|
|
}
|
|
|
|
HalfEdge::Edge * startEdge = boundaryEdges[i];
|
|
nvDebugCheck(startEdge != NULL);
|
|
nvDebugCheck(startEdge->face == NULL);
|
|
|
|
#if 1
|
|
Array<HalfEdge::Vertex *> vertexLoop;
|
|
Array<HalfEdge::Edge *> edgeLoop;
|
|
|
|
HalfEdge::Edge * edge = startEdge;
|
|
do {
|
|
HalfEdge::Vertex * vertex = edge->next->vertex; // edge->to()
|
|
|
|
uint i;
|
|
for (i = 0; i < vertexLoop.count(); i++) {
|
|
if (vertex->isColocal(vertexLoop[i])) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool isCrossing = (i != vertexLoop.count());
|
|
|
|
if (isCrossing) {
|
|
|
|
HalfEdge::Edge * prev = edgeLoop[i]; // Previous edge before the loop.
|
|
HalfEdge::Edge * next = edge->next; // Next edge after the loop.
|
|
|
|
nvDebugCheck(prev->to()->isColocal(next->from()));
|
|
|
|
// Close loop.
|
|
edgeLoop.append(edge);
|
|
closeLoop(i+1, edgeLoop);
|
|
|
|
// Link boundary loop.
|
|
prev->setNext(next);
|
|
vertex->setEdge(next);
|
|
|
|
// Start over again.
|
|
vertexLoop.clear();
|
|
edgeLoop.clear();
|
|
|
|
edge = startEdge;
|
|
vertex = edge->to();
|
|
}
|
|
|
|
vertexLoop.append(vertex);
|
|
edgeLoop.append(edge);
|
|
|
|
edge = edge->next;
|
|
} while(edge != startEdge);
|
|
|
|
closeLoop(0, edgeLoop);
|
|
#endif
|
|
|
|
/*
|
|
|
|
// Add face and connect boundary edges.
|
|
HalfEdge::Face * face = m_unifiedMesh->addFace();
|
|
face->setEdge(startEdge);
|
|
|
|
HalfEdge::Edge * edge = startEdge;
|
|
do {
|
|
edge->setFace(face);
|
|
|
|
edge = edge->next();
|
|
} while(edge != startEdge);
|
|
|
|
*/
|
|
|
|
|
|
/*
|
|
uint edgeCount = 0;
|
|
HalfEdge::Edge * edge = startEdge;
|
|
do {
|
|
edgeCount++;
|
|
edge = edge->next();
|
|
} while(edge != startEdge);
|
|
|
|
|
|
|
|
// Count edges in this boundary.
|
|
uint edgeCount = 0;
|
|
HalfEdge::Edge * edge = startEdge;
|
|
do {
|
|
edgeCount++;
|
|
edge = edge->next();
|
|
} while(edge != startEdge);
|
|
|
|
// Trivial hole, fill with one triangle. This actually works for all convex boundaries with non colinear vertices.
|
|
if (edgeCount == 3) {
|
|
// Add face and connect boundary edges.
|
|
HalfEdge::Face * face = m_unifiedMesh->addFace();
|
|
face->setEdge(startEdge);
|
|
|
|
edge = startEdge;
|
|
do {
|
|
edge->setFace(face);
|
|
|
|
edge = edge->next();
|
|
} while(edge != startEdge);
|
|
|
|
// @@ Implement the above using addFace, it should now work with existing edges, as long as their face pointers is zero.
|
|
|
|
}
|
|
else {
|
|
// Ideally we should:
|
|
// - compute best fit plane of boundary vertices.
|
|
// - project boundary polygon onto plane.
|
|
// - triangulate boundary polygon.
|
|
// - add faces of the resulting triangulation.
|
|
|
|
// I don't have a good triangulator available. A more simple solution that works in more (but not all) cases:
|
|
// - compute boundary centroid.
|
|
// - add vertex centroid.
|
|
// - connect centroid vertex with boundary vertices.
|
|
// - connect radial edges with boundary edges.
|
|
|
|
// This should work for non-convex boundaries with colinear vertices as long as the kernel of the polygon is not empty.
|
|
|
|
// Compute boundary centroid:
|
|
Vector3 centroid_pos(0);
|
|
Vector2 centroid_tex(0);
|
|
|
|
HalfEdge::Edge * edge = startEdge;
|
|
do {
|
|
centroid_pos += edge->vertex()->pos;
|
|
centroid_tex += edge->vertex()->tex;
|
|
edge = edge->next();
|
|
} while(edge != startEdge);
|
|
|
|
centroid_pos *= (1.0f / edgeCount);
|
|
centroid_tex *= (1.0f / edgeCount);
|
|
|
|
HalfEdge::Vertex * centroid = m_unifiedMesh->addVertex(centroid_pos);
|
|
centroid->tex = centroid_tex;
|
|
|
|
// Add one pair of edges for each boundary vertex.
|
|
edge = startEdge;
|
|
do {
|
|
HalfEdge::Edge * next = edge->next();
|
|
|
|
nvCheck(edge->face() == NULL);
|
|
HalfEdge::Face * face = m_unifiedMesh->addFace(centroid->id(), edge->from()->id(), edge->to()->id());
|
|
|
|
if (face != NULL) {
|
|
nvCheck(edge->face() == face);
|
|
}
|
|
else {
|
|
hasNewHoles = true;
|
|
}
|
|
|
|
edge = next;
|
|
} while(edge != startEdge);
|
|
}
|
|
*/
|
|
}
|
|
|
|
/*nvDebugCheck(!hasNewHoles);
|
|
|
|
if (hasNewHoles) {
|
|
// Link boundary again, in case closeHoles created new holes!
|
|
m_unifiedMesh->linkBoundary();
|
|
}*/
|
|
|
|
// Because some algorithms do not expect sparse edge buffers.
|
|
//m_unifiedMesh->compactEdges();
|
|
|
|
// In case we messed up:
|
|
//m_unifiedMesh->linkBoundary();
|
|
|
|
getBoundaryEdges(m_unifiedMesh.ptr(), boundaryEdges);
|
|
|
|
boundaryCount = boundaryEdges.count();
|
|
nvDebugCheck(boundaryCount == 1);
|
|
|
|
//exportMesh(m_unifiedMesh.ptr(), "debug_hole_filled.obj");
|
|
|
|
return boundaryCount == 1;
|
|
}
|
|
|
|
|
|
// Transfer parameterization from unified mesh to chart mesh.
|
|
void Chart::transferParameterization() {
|
|
nvDebugCheck(!m_isVertexMapped);
|
|
|
|
uint vertexCount = m_chartMesh->vertexCount();
|
|
for (uint v = 0; v < vertexCount; v++) {
|
|
HalfEdge::Vertex * vertex = m_chartMesh->vertexAt(v);
|
|
HalfEdge::Vertex * unifiedVertex = m_unifiedMesh->vertexAt(mapChartVertexToUnifiedVertex(v));
|
|
vertex->tex = unifiedVertex->tex;
|
|
}
|
|
}
|
|
|
|
float Chart::computeSurfaceArea() const {
|
|
return nv::computeSurfaceArea(m_chartMesh.ptr()) * scale;
|
|
}
|
|
|
|
float Chart::computeParametricArea() const {
|
|
// This only makes sense in parameterized meshes.
|
|
nvDebugCheck(m_isDisk);
|
|
nvDebugCheck(!m_isVertexMapped);
|
|
|
|
return nv::computeParametricArea(m_chartMesh.ptr());
|
|
}
|
|
|
|
Vector2 Chart::computeParametricBounds() const {
|
|
// This only makes sense in parameterized meshes.
|
|
nvDebugCheck(m_isDisk);
|
|
nvDebugCheck(!m_isVertexMapped);
|
|
|
|
Box bounds;
|
|
bounds.clearBounds();
|
|
|
|
uint vertexCount = m_chartMesh->vertexCount();
|
|
for (uint v = 0; v < vertexCount; v++) {
|
|
HalfEdge::Vertex * vertex = m_chartMesh->vertexAt(v);
|
|
bounds.addPointToBounds(Vector3(vertex->tex, 0));
|
|
}
|
|
|
|
return bounds.extents().xy();
|
|
}
|