5db8da8105
The issue was caused by including both Python.h and BLI_math.h. Since the macro
definition in Python.h was unconditional, it was necessary to include it first and then
BLI_math.h.
Addressing the issue turned out to affect many Freestyle source files. There were several
other coding flaws that complicated the situation:
1. intern/system/FreestyleConfig.h was abused just to include BLI_math.h which was in
fact unnecessary in FreestyleConfig.h. While addressing this, inclusion of both math.h
and BLI_math.h had to be duly dealt with to avoid a compiler error about round().
2. #include <Python.h> was not properly put in the extern "C" { ... } construct.
3. intern/view_map/Interface0D.h and intern/python/Director.h, both of which included
Python.h, were included from within Freestyle header files that were almost or completely
independent of Python. These non-Python header files were used everywhere in the
Freestyle code base, causing many cases of the reported macro redefinitions.
4. The Director.h file was also declaring 'using namespace Freestyle', which was causing
another scope issue in several Freestyle header files.
This commit is intended to address the first problem above. Subsequent commits will deal
with the other three.
759 lines
23 KiB
C++
759 lines
23 KiB
C++
/*
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
*/
|
|
|
|
/** \file blender/freestyle/intern/view_map/FEdgeXDetector.cpp
|
|
* \ingroup freestyle
|
|
* \brief Detects/flags/builds extended features edges on the WXEdge structure
|
|
* \author Stephane Grabli
|
|
* \date 26/10/2003
|
|
*/
|
|
|
|
#include <float.h>
|
|
|
|
#include "FEdgeXDetector.h"
|
|
|
|
#include "../geometry/GeomUtils.h"
|
|
#include "../geometry/normal_cycle.h"
|
|
|
|
#include "BKE_global.h"
|
|
|
|
namespace Freestyle {
|
|
|
|
void FEdgeXDetector::processShapes(WingedEdge& we)
|
|
{
|
|
bool progressBarDisplay = false;
|
|
Vec3r Min, Max;
|
|
vector<WShape*> wshapes = we.getWShapes();
|
|
WXShape *wxs;
|
|
|
|
if (_pProgressBar != NULL) {
|
|
_pProgressBar->reset();
|
|
_pProgressBar->setLabelText("Detecting feature lines");
|
|
_pProgressBar->setTotalSteps(wshapes.size() * 3);
|
|
_pProgressBar->setProgress(0);
|
|
progressBarDisplay = true;
|
|
}
|
|
|
|
for (vector<WShape*>::const_iterator it = wshapes.begin(); it != wshapes.end(); it++) {
|
|
if (_pRenderMonitor && _pRenderMonitor->testBreak())
|
|
break;
|
|
wxs = dynamic_cast<WXShape*>(*it);
|
|
wxs->bbox(Min, Max);
|
|
_bbox_diagonal = (Max - Min).norm();
|
|
if (_changes) {
|
|
vector<WFace*>& wfaces = wxs->GetFaceList();
|
|
for (vector<WFace*>::iterator wf = wfaces.begin(), wfend = wfaces.end(); wf != wfend; ++wf) {
|
|
WXFace *wxf = dynamic_cast<WXFace*>(*wf);
|
|
wxf->Clear();
|
|
}
|
|
_computeViewIndependant = true;
|
|
}
|
|
else if (!(wxs)->getComputeViewIndependantFlag()) {
|
|
wxs->Reset();
|
|
_computeViewIndependant = false;
|
|
}
|
|
else {
|
|
_computeViewIndependant = true;
|
|
}
|
|
preProcessShape(wxs);
|
|
if (progressBarDisplay)
|
|
_pProgressBar->setProgress(_pProgressBar->getProgress() + 1);
|
|
processBorderShape(wxs);
|
|
if (_computeMaterialBoundaries)
|
|
processMaterialBoundaryShape(wxs);
|
|
processCreaseShape(wxs);
|
|
if (_computeRidgesAndValleys)
|
|
processRidgesAndValleysShape(wxs);
|
|
if (_computeSuggestiveContours)
|
|
processSuggestiveContourShape(wxs);
|
|
processSilhouetteShape(wxs);
|
|
processEdgeMarksShape(wxs);
|
|
if (progressBarDisplay)
|
|
_pProgressBar->setProgress(_pProgressBar->getProgress() + 1);
|
|
|
|
// build smooth edges:
|
|
buildSmoothEdges(wxs);
|
|
|
|
// Post processing for suggestive contours
|
|
if (_computeSuggestiveContours)
|
|
postProcessSuggestiveContourShape(wxs);
|
|
if (progressBarDisplay)
|
|
_pProgressBar->setProgress(_pProgressBar->getProgress() + 1);
|
|
|
|
wxs->setComputeViewIndependantFlag(false);
|
|
_computeViewIndependant = false;
|
|
_changes = false;
|
|
|
|
// reset user data
|
|
(*it)->ResetUserData();
|
|
}
|
|
}
|
|
|
|
// GENERAL STUFF
|
|
////////////////
|
|
void FEdgeXDetector::preProcessShape(WXShape *iWShape)
|
|
{
|
|
_meanK1 = 0;
|
|
_meanKr = 0;
|
|
_minK1 = FLT_MAX;
|
|
_maxK1 = -FLT_MAX;
|
|
_minKr = FLT_MAX;
|
|
_maxKr = -FLT_MAX;
|
|
_nPoints = 0;
|
|
_meanEdgeSize = iWShape->getMeanEdgeSize();
|
|
|
|
vector<WFace*>& wfaces = iWShape->GetFaceList();
|
|
vector<WFace*>::iterator f, fend;
|
|
// view dependant stuff
|
|
for (f = wfaces.begin(), fend = wfaces.end(); f != fend; ++f) {
|
|
preProcessFace((WXFace *)(*f));
|
|
}
|
|
|
|
if (_computeRidgesAndValleys || _computeSuggestiveContours) {
|
|
vector<WVertex*>& wvertices = iWShape->getVertexList();
|
|
for (vector<WVertex*>::iterator wv = wvertices.begin(), wvend = wvertices.end(); wv != wvend; ++wv) {
|
|
// Compute curvatures
|
|
WXVertex *wxv = dynamic_cast<WXVertex*>(*wv);
|
|
computeCurvatures(wxv);
|
|
}
|
|
_meanK1 /= (real)(_nPoints);
|
|
_meanKr /= (real)(_nPoints);
|
|
}
|
|
}
|
|
|
|
void FEdgeXDetector::preProcessFace(WXFace *iFace)
|
|
{
|
|
Vec3r firstPoint = iFace->GetVertex(0)->GetVertex();
|
|
Vec3r N = iFace->GetNormal();
|
|
|
|
// Compute the dot product between V (=_Viewpoint - firstPoint) and N:
|
|
Vec3r V;
|
|
if (_orthographicProjection) {
|
|
V = Vec3r(0.0, 0.0, _Viewpoint.z() - firstPoint.z());
|
|
}
|
|
else {
|
|
V = Vec3r(_Viewpoint - firstPoint);
|
|
}
|
|
N.normalize();
|
|
V.normalize();
|
|
iFace->setDotP(N * V);
|
|
|
|
// compute the distance between the face center and the viewpoint:
|
|
if (_orthographicProjection) {
|
|
iFace->setZ(iFace->center().z() - _Viewpoint.z());
|
|
}
|
|
else {
|
|
Vec3r dist_vec(iFace->center() - _Viewpoint);
|
|
iFace->setZ(dist_vec.norm());
|
|
}
|
|
}
|
|
|
|
void FEdgeXDetector::computeCurvatures(WXVertex *vertex)
|
|
{
|
|
// TODO: for some reason, the 'vertex' may have no associated edges
|
|
// (i.e., WVertex::_EdgeList is empty), which causes a crash due to
|
|
// a subsequent call of WVertex::_EdgeList.front().
|
|
if (vertex->GetEdges().empty()) {
|
|
if (G.debug & G_DEBUG_FREESTYLE) {
|
|
printf("Warning: WVertex %d has no associated edges.\n", vertex->GetId());
|
|
}
|
|
return;
|
|
}
|
|
|
|
// CURVATURE LAYER
|
|
// store all the curvature datas for each vertex
|
|
|
|
//soc unused - real K1, K2
|
|
real cos2theta, sin2theta;
|
|
Vec3r e1, n, v;
|
|
// one vertex curvature info :
|
|
CurvatureInfo *C;
|
|
float radius = _sphereRadius * _meanEdgeSize;
|
|
|
|
// view independant stuff
|
|
if (_computeViewIndependant) {
|
|
C = new CurvatureInfo();
|
|
vertex->setCurvatures(C);
|
|
OGF::NormalCycle ncycle;
|
|
ncycle.begin();
|
|
if (radius > 0) {
|
|
OGF::compute_curvature_tensor(vertex, radius, ncycle);
|
|
}
|
|
else {
|
|
OGF::compute_curvature_tensor_one_ring(vertex, ncycle);
|
|
}
|
|
ncycle.end();
|
|
C->K1 = ncycle.kmin();
|
|
C->K2 = ncycle.kmax();
|
|
C->e1 = ncycle.Kmax(); //ncycle.kmin() * ncycle.Kmax();
|
|
C->e2 = ncycle.Kmin(); //ncycle.kmax() * ncycle.Kmin();
|
|
|
|
real absK1 = fabs(C->K1);
|
|
_meanK1 += absK1;
|
|
if (absK1 > _maxK1)
|
|
_maxK1 = absK1;
|
|
if (absK1 < _minK1)
|
|
_minK1 = absK1;
|
|
}
|
|
// view dependant
|
|
C = vertex->curvatures();
|
|
if (C == 0)
|
|
return;
|
|
|
|
// compute radial curvature :
|
|
n = C->e1 ^ C->e2;
|
|
if (_orthographicProjection) {
|
|
v = Vec3r(0.0, 0.0, _Viewpoint.z() - vertex->GetVertex().z());
|
|
}
|
|
else {
|
|
v = Vec3r(_Viewpoint - vertex->GetVertex());
|
|
}
|
|
C->er = v - (v * n) * n;
|
|
C->er.normalize();
|
|
e1 = C->e1;
|
|
e1.normalize();
|
|
cos2theta = C->er * e1;
|
|
cos2theta *= cos2theta;
|
|
sin2theta = 1 - cos2theta;
|
|
C->Kr = C->K1 * cos2theta + C->K2 * sin2theta;
|
|
real absKr = fabs(C->Kr);
|
|
_meanKr += absKr;
|
|
if (absKr > _maxKr)
|
|
_maxKr = absKr;
|
|
if (absKr < _minKr)
|
|
_minKr = absKr;
|
|
|
|
++_nPoints;
|
|
}
|
|
|
|
// SILHOUETTE
|
|
/////////////
|
|
void FEdgeXDetector::processSilhouetteShape(WXShape *iWShape)
|
|
{
|
|
// Make a first pass on every polygons in order to compute all their silhouette relative values:
|
|
vector<WFace*>& wfaces = iWShape->GetFaceList();
|
|
vector<WFace*>::iterator f, fend;
|
|
for (f = wfaces.begin(), fend = wfaces.end(); f != fend; ++f) {
|
|
ProcessSilhouetteFace((WXFace *)(*f));
|
|
}
|
|
|
|
// Make a pass on the edges to detect the silhouette edges that are not smooth
|
|
vector<WEdge*>::iterator we, weend;
|
|
vector<WEdge*> &wedges = iWShape->getEdgeList();
|
|
for (we = wedges.begin(), weend = wedges.end(); we != weend; ++we) {
|
|
ProcessSilhouetteEdge((WXEdge *)(*we));
|
|
}
|
|
}
|
|
|
|
void FEdgeXDetector::ProcessSilhouetteFace(WXFace *iFace)
|
|
{
|
|
// SILHOUETTE LAYER
|
|
Vec3r normal;
|
|
// Compute the dot products between View direction and N at each vertex of the face:
|
|
Vec3r point;
|
|
int closestPointId = 0;
|
|
real dist, minDist = FLT_MAX;
|
|
int numVertices = iFace->numberOfVertices();
|
|
WXFaceLayer *faceLayer = new WXFaceLayer(iFace, Nature::SILHOUETTE, true);
|
|
for (int i = 0; i < numVertices; i++) {
|
|
point = iFace->GetVertex(i)->GetVertex();
|
|
normal = iFace->GetVertexNormal(i);
|
|
normal.normalize();
|
|
Vec3r V;
|
|
if (_orthographicProjection) {
|
|
V = Vec3r(0.0, 0.0, _Viewpoint.z() - point.z());
|
|
}
|
|
else {
|
|
V = Vec3r(_Viewpoint - point);
|
|
}
|
|
V.normalize();
|
|
real d = normal * V;
|
|
faceLayer->PushDotP(d);
|
|
// Find the point the closest to the viewpoint
|
|
if (_orthographicProjection) {
|
|
dist = point.z() - _Viewpoint.z();
|
|
}
|
|
else {
|
|
Vec3r dist_vec(point - _Viewpoint);
|
|
dist = dist_vec.norm();
|
|
}
|
|
if (dist < minDist) {
|
|
minDist = dist;
|
|
closestPointId = i;
|
|
}
|
|
}
|
|
// Set the closest point id:
|
|
faceLayer->setClosestPointIndex(closestPointId);
|
|
// Add this layer to the face:
|
|
iFace->AddSmoothLayer(faceLayer);
|
|
}
|
|
|
|
void FEdgeXDetector::ProcessSilhouetteEdge(WXEdge *iEdge)
|
|
{
|
|
if (iEdge->nature() & Nature::BORDER)
|
|
return;
|
|
// SILHOUETTE ?
|
|
//-------------
|
|
WXFace *fA = (WXFace *)iEdge->GetaOEdge()->GetaFace();
|
|
WXFace *fB = (WXFace *)iEdge->GetaOEdge()->GetbFace();
|
|
|
|
if ((fA->front()) ^ (fB->front())) { // fA->visible XOR fB->visible (true if one is 0 and the other is 1)
|
|
// The only edges we want to set as silhouette edges in this way are the ones with 2 different normals
|
|
// for 1 vertex for these two faces
|
|
//--------------------
|
|
// In reality we only test the normals for 1 of the 2 vertices.
|
|
if (fA->GetVertexNormal(iEdge->GetaVertex()) == fB->GetVertexNormal(iEdge->GetaVertex()))
|
|
return;
|
|
iEdge->AddNature(Nature::SILHOUETTE);
|
|
if (fB->front())
|
|
iEdge->setOrder(1);
|
|
else
|
|
iEdge->setOrder(-1);
|
|
}
|
|
}
|
|
|
|
// BORDER
|
|
/////////
|
|
void FEdgeXDetector::processBorderShape(WXShape *iWShape)
|
|
{
|
|
if (!_computeViewIndependant)
|
|
return;
|
|
// Make a pass on the edges to detect the BORDER
|
|
vector<WEdge*>::iterator we, weend;
|
|
vector<WEdge*> &wedges = iWShape->getEdgeList();
|
|
for (we = wedges.begin(), weend = wedges.end(); we != weend; ++we) {
|
|
ProcessBorderEdge((WXEdge *)(*we));
|
|
}
|
|
}
|
|
|
|
void FEdgeXDetector::ProcessBorderEdge(WXEdge *iEdge)
|
|
{
|
|
// first check whether it is a border edge: BORDER ?
|
|
//---------
|
|
if (iEdge->GetaFace() == 0) {
|
|
// it is a border edge
|
|
iEdge->AddNature(Nature::BORDER);
|
|
}
|
|
}
|
|
|
|
|
|
// CREASE
|
|
/////////
|
|
void FEdgeXDetector::processCreaseShape(WXShape *iWShape)
|
|
{
|
|
if (!_computeViewIndependant)
|
|
return;
|
|
|
|
// Make a pass on the edges to detect the CREASE
|
|
vector<WEdge*>::iterator we, weend;
|
|
vector<WEdge*> &wedges = iWShape->getEdgeList();
|
|
for (we = wedges.begin(), weend = wedges.end(); we != weend; ++we) {
|
|
ProcessCreaseEdge((WXEdge *)(*we));
|
|
}
|
|
}
|
|
|
|
void FEdgeXDetector::ProcessCreaseEdge(WXEdge *iEdge)
|
|
{
|
|
// CREASE ?
|
|
//---------
|
|
if (iEdge->nature() & Nature::BORDER)
|
|
return;
|
|
WXFace *fA = (WXFace *)iEdge->GetaOEdge()->GetaFace();
|
|
WXFace *fB = (WXFace *)iEdge->GetaOEdge()->GetbFace();
|
|
|
|
WVertex *aVertex = iEdge->GetaVertex();
|
|
if ((fA->GetVertexNormal(aVertex) * fB->GetVertexNormal(aVertex)) <= _creaseAngle)
|
|
iEdge->AddNature(Nature::CREASE);
|
|
}
|
|
|
|
// RIDGES AND VALLEYS
|
|
/////////////////////
|
|
void FEdgeXDetector::processRidgesAndValleysShape(WXShape *iWShape)
|
|
{
|
|
// Don't forget to add the built layer to the face at the end of the ProcessFace:
|
|
//iFace->AddSmoothLayer(faceLayer);
|
|
|
|
if (!_computeViewIndependant)
|
|
return;
|
|
|
|
// Here the curvatures must already have been computed
|
|
vector<WFace*>& wfaces = iWShape->GetFaceList();
|
|
vector<WFace*>::iterator f, fend;
|
|
for (f = wfaces.begin(), fend = wfaces.end(); f != fend; ++f) {
|
|
ProcessRidgeFace((WXFace *)(*f));
|
|
}
|
|
}
|
|
|
|
|
|
// RIDGES
|
|
/////////
|
|
void FEdgeXDetector::ProcessRidgeFace(WXFace *iFace)
|
|
{
|
|
WXFaceLayer *flayer = new WXFaceLayer(iFace, Nature::RIDGE | Nature::VALLEY, false);
|
|
iFace->AddSmoothLayer(flayer);
|
|
|
|
unsigned int numVertices = iFace->numberOfVertices();
|
|
for (unsigned int i = 0; i < numVertices; ++i) {
|
|
WVertex *wv = iFace->GetVertex(i);
|
|
WXVertex *wxv = dynamic_cast<WXVertex*>(wv);
|
|
flayer->PushDotP(wxv->curvatures()->K1);
|
|
}
|
|
|
|
real threshold = 0;
|
|
//real threshold = _maxK1 - (_maxK1 - _meanK1) / 20.0;
|
|
|
|
if (flayer->nPosDotP() != numVertices) {
|
|
if ((fabs(flayer->dotP(0)) < threshold) && (fabs(flayer->dotP(1)) < threshold) &&
|
|
(fabs(flayer->dotP(2)) < threshold))
|
|
{
|
|
flayer->ReplaceDotP(0, 0);
|
|
flayer->ReplaceDotP(1, 0);
|
|
flayer->ReplaceDotP(2, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
void FEdgeXDetector::ProcessRidgeFace(WXFace *iFace)
|
|
{
|
|
// RIDGE LAYER
|
|
// Compute the RidgeFunction, that is the derivative of the ppal curvature along e1 at each vertex of the face
|
|
WVertex *v;
|
|
Vec3r v1v2;
|
|
real t;
|
|
vector<WXFaceLayer*> SmoothLayers;
|
|
WXFaceLayer *faceLayer;
|
|
Face_Curvature_Info *layer_info;
|
|
real K1_a(0), K1_b(0);
|
|
Vec3r Inter_a, Inter_b;
|
|
|
|
// find the ridge layer of the face
|
|
iFace->retrieveSmoothLayers(Nature::RIDGE, SmoothLayers);
|
|
if ( SmoothLayers.size()!=1 )
|
|
return;
|
|
faceLayer = SmoothLayers[0];
|
|
// retrieve the curvature info of this layer
|
|
layer_info = (Face_Curvature_Info *)faceLayer->userdata;
|
|
|
|
int numVertices = iFace->numberOfVertices();
|
|
for (int i = 0; i < numVertices; i++) {
|
|
v = iFace->GetVertex(i);
|
|
// vec_curvature_info[i] contains the curvature info of this vertex
|
|
Vec3r e2 = layer_info->vec_curvature_info[i]->K2*layer_info->vec_curvature_info[i]->e2;
|
|
Vec3r e1 = layer_info->vec_curvature_info[i]->K1*layer_info->vec_curvature_info[i]->e1;
|
|
e2.normalize();
|
|
|
|
WVertex::face_iterator fit = v->faces_begin();
|
|
WVertex::face_iterator fitend = v->faces_end();
|
|
for (; fit != fitend; ++fit) {
|
|
WXFace *wxf = dynamic_cast<WXFace*>(*fit);
|
|
WOEdge *oppositeEdge;
|
|
if (!(wxf->getOppositeEdge(v, oppositeEdge)))
|
|
continue;
|
|
v1v2 = oppositeEdge->GetbVertex()->GetVertex() - oppositeEdge->GetaVertex()->GetVertex();
|
|
GeomUtils::intersection_test res;
|
|
res = GeomUtils::intersectRayPlane(oppositeEdge->GetaVertex()->GetVertex(), v1v2, e2, -(v->GetVertex()*e2),
|
|
t, 1.0e-06);
|
|
if ((res == GeomUtils::DO_INTERSECT) && (t >= 0.0) && (t <= 1.0)) {
|
|
vector<WXFaceLayer*> second_ridge_layer;
|
|
wxf->retrieveSmoothLayers(Nature::RIDGE, second_ridge_layer);
|
|
if (second_ridge_layer.size() != 1)
|
|
continue;
|
|
Face_Curvature_Info *second_layer_info = (Face_Curvature_Info*)second_ridge_layer[0]->userdata;
|
|
|
|
unsigned index1 = wxf->GetIndex(oppositeEdge->GetaVertex());
|
|
unsigned index2 = wxf->GetIndex(oppositeEdge->GetbVertex());
|
|
real K1_1 = second_layer_info->vec_curvature_info[index1]->K1;
|
|
real K1_2 = second_layer_info->vec_curvature_info[index2]->K1;
|
|
real K1 = (1.0 - t) * K1_1 + t * K1_2;
|
|
Vec3r inter((1.0 - t) * oppositeEdge->GetaVertex()->GetVertex() +
|
|
t * oppositeEdge->GetbVertex()->GetVertex());
|
|
Vec3r vtmp(inter - v->GetVertex());
|
|
// is it K1_a or K1_b ?
|
|
if (vtmp * e1 > 0) {
|
|
K1_b = K1;
|
|
Inter_b = inter;
|
|
}
|
|
else {
|
|
K1_a = K1;
|
|
Inter_a = inter;
|
|
}
|
|
}
|
|
}
|
|
// Once we have K1 along the the ppal direction compute the derivative : K1b - K1a put it in DotP
|
|
//real d = fabs(K1_b) - fabs(K1_a);
|
|
real d = 0;
|
|
real threshold = _meanK1 + (_maxK1 - _meanK1) / 7.0;
|
|
//real threshold = _meanK1;
|
|
//if ((fabs(K1_b) > threshold) || ((fabs(K1_a) > threshold)))
|
|
d = (K1_b) - (K1_a) / (Inter_b - Inter_a).norm();
|
|
faceLayer->PushDotP(d);
|
|
//faceLayer->PushDotP(layer_info->vec_curvature_info[i]->K1);
|
|
}
|
|
|
|
// Make the values relevant by checking whether all principal directions have the "same" direction:
|
|
Vec3r e0((layer_info->vec_curvature_info[0]->K1 * layer_info->vec_curvature_info[0]->e1));
|
|
e0.normalize();
|
|
Vec3r e1((layer_info->vec_curvature_info[1]->K1 * layer_info->vec_curvature_info[1]->e1));
|
|
e1.normalize();
|
|
Vec3r e2((layer_info->vec_curvature_info[2]->K1 * layer_info->vec_curvature_info[2]->e1));
|
|
e2.normalize();
|
|
if (e0 * e1 < 0)
|
|
// invert dotP[1]
|
|
faceLayer->ReplaceDotP(1, -faceLayer->dotP(1));
|
|
if (e0 * e2 < 0)
|
|
// invert dotP[2]
|
|
faceLayer->ReplaceDotP(2, -faceLayer->dotP(2));
|
|
|
|
#if 0 // remove the weakest values;
|
|
real minDiff = (_maxK1 - _minK1) / 10.0;
|
|
real minDiff = _meanK1;
|
|
if ((faceLayer->dotP(0) < minDiff) && (faceLayer->dotP(1) < minDiff) && (faceLayer->dotP(2) < minDiff)) {
|
|
faceLayer->ReplaceDotP(0, 0);
|
|
faceLayer->ReplaceDotP(1, 0);
|
|
faceLayer->ReplaceDotP(2, 0);
|
|
}
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
// SUGGESTIVE CONTOURS
|
|
//////////////////////
|
|
|
|
void FEdgeXDetector::processSuggestiveContourShape(WXShape *iWShape)
|
|
{
|
|
// Here the curvatures must already have been computed
|
|
vector<WFace*>& wfaces = iWShape->GetFaceList();
|
|
vector<WFace*>::iterator f, fend;
|
|
for (f = wfaces.begin(), fend = wfaces.end(); f != fend; ++f) {
|
|
ProcessSuggestiveContourFace((WXFace *)(*f));
|
|
}
|
|
}
|
|
|
|
void FEdgeXDetector::ProcessSuggestiveContourFace(WXFace *iFace)
|
|
{
|
|
WXFaceLayer *faceLayer = new WXFaceLayer(iFace, Nature::SUGGESTIVE_CONTOUR, true);
|
|
iFace->AddSmoothLayer(faceLayer);
|
|
|
|
unsigned int numVertices = iFace->numberOfVertices();
|
|
for (unsigned int i = 0; i < numVertices; ++i) {
|
|
WVertex *wv = iFace->GetVertex(i);
|
|
WXVertex *wxv = dynamic_cast<WXVertex*>(wv);
|
|
faceLayer->PushDotP(wxv->curvatures()->Kr);
|
|
}
|
|
|
|
#if 0 // FIXME: find a more clever way to compute the threshold
|
|
real threshold = _meanKr;
|
|
if (faceLayer->nPosDotP()!=numVertices) {
|
|
if ((fabs(faceLayer->dotP(0)) < threshold) && (fabs(faceLayer->dotP(1)) < threshold) &&
|
|
(fabs(faceLayer->dotP(2)) < threshold)) {
|
|
faceLayer->ReplaceDotP(0, 0);
|
|
faceLayer->ReplaceDotP(1, 0);
|
|
faceLayer->ReplaceDotP(2, 0);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void FEdgeXDetector::postProcessSuggestiveContourShape(WXShape *iShape)
|
|
{
|
|
vector<WFace*>& wfaces = iShape->GetFaceList();
|
|
vector<WFace*>::iterator f, fend;
|
|
for (f = wfaces.begin(), fend = wfaces.end(); f != fend; ++f) {
|
|
postProcessSuggestiveContourFace((WXFace *)(*f));
|
|
}
|
|
}
|
|
|
|
void FEdgeXDetector::postProcessSuggestiveContourFace(WXFace *iFace)
|
|
{
|
|
// Compute the derivative of the radial curvature in the radial direction, at the two extremities
|
|
// of the smooth edge.
|
|
// If the derivative is smaller than a given threshold _kr_derivative_epsilon, discard the edge.
|
|
|
|
// Find the suggestive contour layer of the face (zero or one edge).
|
|
vector<WXFaceLayer*> sc_layers;
|
|
iFace->retrieveSmoothEdgesLayers(Nature::SUGGESTIVE_CONTOUR, sc_layers);
|
|
if (sc_layers.empty())
|
|
return;
|
|
|
|
WXFaceLayer *sc_layer;
|
|
sc_layer = sc_layers[0];
|
|
|
|
// Compute the derivative value at each vertex of the face, and add it in a vector.
|
|
vector<real> kr_derivatives;
|
|
|
|
unsigned vertices_nb = iFace->numberOfVertices();
|
|
WXVertex *v, *opposite_vertex_a, *opposite_vertex_b;
|
|
WXFace *wxf;
|
|
WOEdge *opposite_edge;
|
|
Vec3r normal_vec, radial_normal_vec, er_vec, v_vec, inter, inter1, inter2, tmp_vec;
|
|
GeomUtils::intersection_test res;
|
|
real kr(0), kr1(0), kr2(0), t;
|
|
|
|
for (unsigned int i = 0; i < vertices_nb; ++i) {
|
|
v = (WXVertex *)(iFace->GetVertex(i));
|
|
|
|
// v is a singular vertex, skip it.
|
|
if (v->isBoundary()) {
|
|
kr_derivatives.push_back(0);
|
|
continue;
|
|
}
|
|
|
|
v_vec = v->GetVertex();
|
|
er_vec = v->curvatures()->er;
|
|
|
|
// For each vertex, iterate on its adjacent faces.
|
|
for (WVertex::face_iterator fit = v->faces_begin(), fitend = v->faces_end(); fit != fitend; ++fit) {
|
|
wxf = dynamic_cast<WXFace*>(*fit);
|
|
if (!wxf->getOppositeEdge(v, opposite_edge))
|
|
continue;
|
|
|
|
opposite_vertex_a = (WXVertex *)opposite_edge->GetaVertex();
|
|
opposite_vertex_b = (WXVertex *)opposite_edge->GetbVertex();
|
|
normal_vec = wxf->GetVertexNormal(v); // FIXME: what about e1 ^ e2 ?
|
|
radial_normal_vec = er_vec ^ normal_vec;
|
|
|
|
// Test wether the radial plan intersects with the edge at the opposite of v.
|
|
res = GeomUtils::intersectRayPlane(opposite_vertex_a->GetVertex(), opposite_edge->GetVec(),
|
|
radial_normal_vec, -(v_vec * radial_normal_vec),
|
|
t, 1.0e-06);
|
|
|
|
// If there is an intersection, compute the value of the derivative ath that point.
|
|
if ((res == GeomUtils::DO_INTERSECT) && (t >= 0) && (t <= 1)) {
|
|
kr = t * opposite_vertex_a->curvatures()->Kr + (1 - t) * opposite_vertex_b->curvatures()->Kr;
|
|
inter = opposite_vertex_a->GetVertex() + t * opposite_edge->GetVec();
|
|
tmp_vec = inter - v->GetVertex();
|
|
// Is it kr1 or kr2?
|
|
if (tmp_vec * er_vec > 0) {
|
|
kr2 = kr;
|
|
inter2 = inter;
|
|
}
|
|
else {
|
|
kr1 = kr;
|
|
inter1 = inter;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now we have kr1 and kr2 along the radial direction, for one vertex of iFace.
|
|
// We have to compute the derivative of kr for that vertex, equal to:
|
|
// (kr2 - kr1) / dist(inter1, inter2).
|
|
// Then we add it to the vector of derivatives.
|
|
v->curvatures()->dKr = (kr2 - kr1) / (inter2 - inter1).norm();
|
|
kr_derivatives.push_back(v->curvatures()->dKr);
|
|
}
|
|
|
|
// At that point, we have the derivatives for each vertex of iFace.
|
|
// All we have to do now is to use linear interpolation to compute the values at the extremities of the smooth edge.
|
|
WXSmoothEdge *sc_edge = sc_layer->getSmoothEdge();
|
|
WOEdge *sc_oedge = sc_edge->woea();
|
|
t = sc_edge->ta();
|
|
if (t * kr_derivatives[iFace->GetIndex(sc_oedge->GetaVertex())] +
|
|
(1 - t) * kr_derivatives[iFace->GetIndex(sc_oedge->GetbVertex())] < _kr_derivative_epsilon)
|
|
{
|
|
sc_layer->removeSmoothEdge();
|
|
return;
|
|
}
|
|
sc_oedge = sc_edge->woeb();
|
|
t = sc_edge->tb();
|
|
if (t * kr_derivatives[iFace->GetIndex(sc_oedge->GetaVertex())] +
|
|
(1 - t) * kr_derivatives[iFace->GetIndex(sc_oedge->GetbVertex())] < _kr_derivative_epsilon)
|
|
{
|
|
sc_layer->removeSmoothEdge();
|
|
}
|
|
}
|
|
|
|
// MATERIAL_BOUNDARY
|
|
////////////////////
|
|
void FEdgeXDetector::processMaterialBoundaryShape(WXShape *iWShape)
|
|
{
|
|
if (!_computeViewIndependant)
|
|
return;
|
|
// Make a pass on the edges to detect material boundaries
|
|
vector<WEdge*>::iterator we, weend;
|
|
vector<WEdge*> &wedges = iWShape->getEdgeList();
|
|
for (we = wedges.begin(), weend = wedges.end(); we != weend; ++we) {
|
|
ProcessMaterialBoundaryEdge((WXEdge *)(*we));
|
|
}
|
|
}
|
|
|
|
void FEdgeXDetector::ProcessMaterialBoundaryEdge(WXEdge *iEdge)
|
|
{
|
|
// check whether the edge is a material boundary?
|
|
WFace *aFace = iEdge->GetaFace();
|
|
WFace *bFace = iEdge->GetbFace();
|
|
if (aFace && bFace && aFace->frs_materialIndex() != bFace->frs_materialIndex()) {
|
|
iEdge->AddNature(Nature::MATERIAL_BOUNDARY);
|
|
}
|
|
}
|
|
|
|
// EDGE MARKS
|
|
/////////////
|
|
void FEdgeXDetector::processEdgeMarksShape(WXShape *iShape)
|
|
{
|
|
// Make a pass on the edges to detect material boundaries
|
|
vector<WEdge*>::iterator we, weend;
|
|
vector<WEdge*> &wedges = iShape->getEdgeList();
|
|
for (we = wedges.begin(), weend = wedges.end(); we != weend; ++we) {
|
|
ProcessEdgeMarks((WXEdge *)(*we));
|
|
}
|
|
}
|
|
|
|
void FEdgeXDetector::ProcessEdgeMarks(WXEdge *iEdge)
|
|
{
|
|
if (iEdge->GetMark()) {
|
|
iEdge->AddNature(Nature::EDGE_MARK);
|
|
}
|
|
}
|
|
|
|
// Build Smooth edges
|
|
/////////////////////
|
|
void FEdgeXDetector::buildSmoothEdges(WXShape *iShape)
|
|
{
|
|
bool hasSmoothEdges = false;
|
|
|
|
// Make a last pass to build smooth edges from the previous stored values:
|
|
//--------------------------------------------------------------------------
|
|
vector<WFace*>& wfaces = iShape->GetFaceList();
|
|
for (vector<WFace *>::iterator f = wfaces.begin(), fend = wfaces.end(); f != fend; ++f) {
|
|
vector<WXFaceLayer *>& faceLayers = ((WXFace *)(*f))->getSmoothLayers();
|
|
for (vector<WXFaceLayer *>::iterator wxfl = faceLayers.begin(), wxflend = faceLayers.end();
|
|
wxfl != wxflend;
|
|
++wxfl)
|
|
{
|
|
if ((*wxfl)->BuildSmoothEdge())
|
|
hasSmoothEdges = true;
|
|
}
|
|
}
|
|
|
|
if (hasSmoothEdges && !_computeRidgesAndValleys && !_computeSuggestiveContours) {
|
|
vector<WVertex *>& wvertices = iShape->getVertexList();
|
|
for (vector<WVertex*>::iterator wv = wvertices.begin(), wvend = wvertices.end(); wv != wvend; ++wv) {
|
|
// Compute curvatures
|
|
WXVertex *wxv = dynamic_cast<WXVertex *>(*wv);
|
|
computeCurvatures(wxv);
|
|
}
|
|
_meanK1 /= (real)(_nPoints);
|
|
_meanKr /= (real)(_nPoints);
|
|
}
|
|
}
|
|
|
|
} /* namespace Freestyle */
|