//-----------------------------------------------------------------------
const Triangle::PositionAndNormal MeshInfo::getRandomPositionAndNormal (const size_t triangleIndex)
{
Triangle triangle = getTriangle(triangleIndex);
Triangle::PositionAndNormal pAndN;
pAndN.position = Vector3::ZERO;
pAndN.normal = Vector3::ZERO;
if (mDistribution == MSD_HOMOGENEOUS || mDistribution == MSD_HETEROGENEOUS_1 || mDistribution == MSD_HETEROGENEOUS_2)
{
pAndN.position = triangle.getRandomTrianglePosition();
pAndN.normal = triangle.surfaceNormal;
}
else
{
if (mDistribution == MSD_VERTEX)
{
pAndN = triangle.getRandomVertexAndNormal();
}
else
{
if (mDistribution == MSD_EDGE)
{
pAndN = triangle.getRandomEdgePositionAndNormal();
}
}
}
return pAndN;
}
bool Terrain::getNormal( const QPointF & position, QVector3D & normal ) const
{
Triangle t;
if( !getTriangle( toMapF(position), t ) )
return false;
normal = t.normal();
return true;
}
void WPrimitive::drawPrimitive(bool showNormal,bool fillMode)
{
WTriangle t;
for(unsigned int i=0;i<nFaces;i++)
{
getTriangle(i,t);
t.draw(showNormal,fillMode);
}
}
static void getTriangle(const Gu::TriangleMesh& mesh, PxU32 i, PxVec3* wp, const PxVec3* vertices, const void* indices, const Cm::Matrix34& absPose, bool has16BitIndices)
{
PxVec3 localVerts[3];
getTriangle(mesh, i, localVerts, vertices, indices, has16BitIndices);
wp[0] = absPose.transform(localVerts[0]);
wp[1] = absPose.transform(localVerts[1]);
wp[2] = absPose.transform(localVerts[2]);
}
bool Terrain::getHeight( const QPointF & position, float & height ) const
{
Triangle t;
if( !getTriangle( toMapF(position), t ) )
return false;
QVector3D normal = t.normal();
height = ( (normal.x()*(position.x()-t.p().x())) + (normal.z()*(position.y()-t.p().z())) ) / ( -normal.y() ) + t.p().y();
return true;
}
vector<Triangle> getTriangles(p2t::CDT &cdt, double z)
{
vector<p2t::Triangle*> ptriangles = cdt.GetTriangles();
vector<Triangle> triangles(ptriangles.size());
for (guint i=0; i < ptriangles.size(); i++) {
triangles[i] = getTriangle(ptriangles[i], z);
}
return triangles;
}
std::vector< std::vector <int> > cMesh::getRegions()
{
int defVal = cTriangle::getDefTextureImgIndex();
std::set < int > triangleIdxSet;
std::vector< std::vector <int> > regions;
for (int aK=0; aK < getFacesNumber();++aK)
{
std::vector <int> myList;
myList.push_back(aK);
for (unsigned int bK=0; bK < myList.size();++bK)
{
cTriangle * Tri = getTriangle(myList[bK]);
int imgIdx = Tri->getTextureImgIndex();
if (imgIdx != defVal)
{
triangleIdxSet.insert(Tri->getIdx());
vector <cTriangle *> neighb = Tri->getNeighbours();
for (unsigned int cK=0; cK < neighb.size();++cK)
{
int triIdx = neighb[cK]->getIdx();
if (triangleIdxSet.find(triIdx)== triangleIdxSet.end() &&
(neighb[cK]->getTextureImgIndex() == imgIdx))
{
myList.push_back(triIdx);
triangleIdxSet.insert(triIdx);
}
}
}
}
//cout << "myList.size() = " << myList.size() << endl;
if (myList.size() > 1) //TODO: à retirer si on veut texturer les triangles isolés
regions.push_back(myList);
}
/*cout << "****************** Resultat *********************" << endl;
cout << endl;
for (unsigned int aK=0; aK < regions.size() ; ++aK)
{
//first triangle of region aK:
int triIdx = regions[aK][0];
cTriangle * Tri = getTriangle(triIdx);
cout << "one region with " << regions[aK].size() << " triangles, for image " << Tri->getTextureImgIndex() << endl;
}*/
return regions;
}
int main(int argc, char *argv[]) {
// initialize resources, if needed
// Q_INIT_RESOURCE(resfile);
QApplication app(argc, argv);
#ifndef DEBUG_OUTPUT
QStringList args = app.arguments();
MainWindow w;
w.show();
return app.exec();
#else
QStringList args = app.arguments();
if (args.length() == 1) {
MainWindow w;
w.show();
return app.exec();
}
QString optTriangle = args[1];
QString optViewpoint = args[2];
QString optFrequency = args[3];
QString optAmplitude = args[4];
Triangle globalTriangle;
MVector globalViewpoint;
mdouble frequency;
mdouble amplitude;
try {
globalTriangle = getTriangle(optTriangle);
globalViewpoint = getViewpoint(optViewpoint);
frequency = optFrequency.toDouble();
amplitude = optAmplitude.toDouble();
}
catch (const QString error) {
qDebug()<<"Виникла помилка:"<<error;
return 0;
}
mdouble wavelength = Processor::LIGHTSPEED / (frequency * pow(10, 9));
if (!Processor::isTriangleVisible(globalTriangle, QList<Triangle>(), globalViewpoint)) {
std::cout<<"Triangle is invisible from this viewpoint, exiting..."<<std::endl;
return 0;
}
QList<Triangle> model;
model.push_back(globalTriangle);
std::complex<mdouble> e = Processor::getE(globalViewpoint, model, wavelength, amplitude);
#endif
}
Triangle getTriangle(QPointF *points, quint32 size, quint32 layers, quint32 number,
QPointF *centerPtr) {
quint32 layer = 0;
quint32 layerStart = 0;
while (number >= layerStart + (layer * 2 + 1) * size) {
layerStart += (layer * 2 + 1) * size;
++layer;
}
quint32 trianglesInSector = layer * 2 + 1;
quint32 sector = (number - layerStart) / trianglesInSector;
quint32 index = (number - layerStart) % trianglesInSector;
return getTriangle(points, size, layers, layer, sector, index, centerPtr);
}
void WorldPainter::paint(QPainter &p, Turtle &turtle, int xt, int yt) {
auto oldPen = p.pen();
auto oldBrush = p.brush();
p.setPen(pen(turtle.getColor()));
p.setBrush(brush(turtle.getColor()));
auto triangle = getTriangle();
auto position = turtle.getPosition();
paint(p, triangle, position.getValue(0) + xt, position.getValue(1) + yt, turtle.getAngle(), 5.0);
p.setPen(oldPen);
p.setBrush(oldBrush);
}
/**
* Solid angle only considers triangle facing sample. Back faces do NOT
* contribute.
*
* This is tantamount to defining an object that is opaque to neutrons. Note
* that it is still possible to define a facing surface which is obscured by
* another. In that case there would still be a solid angle contribution as
* there is no way of detecting the shadowing.
*
* @param observer
* @return
*/
double MeshObject2D::solidAngle(const Kernel::V3D &observer) const {
double solidAngleSum(0);
Kernel::V3D vertex1, vertex2, vertex3;
for (size_t i = 0;
getTriangle(i, m_triangles, m_vertices, vertex1, vertex2, vertex3);
++i) {
double sa = MeshObjectCommon::getTriangleSolidAngle(vertex1, vertex2,
vertex3, observer);
if (sa > 0) {
solidAngleSum += sa;
}
}
return solidAngleSum;
}
//Calcule et stocke l'angle entre Dir et Triangle (appartenant a TriIdx)
void cMesh::setTrianglesAttribute(int img_idx, Pt3dr Dir, vector <unsigned int> const &aTriIdx)
{
for (unsigned int aK=0; aK < aTriIdx.size(); aK++)
{
cTriangle *aTri = getTriangle(aTriIdx[aK]);
Pt3dr aNormale = aTri->getNormale(true);
double cosAngle = scal(Dir, aNormale) / euclid(Dir);
vector <double> vAttr;
vAttr.push_back(cosAngle);
aTri->setAttributes(img_idx, vAttr);
}
}
char BaseMesh::selectComponent(IntersectionContext * ctx) const
{
Vector3F threeCorners[3];
unsigned fvi[3];
const unsigned nf = getNumTriangles();
for(unsigned i = 0; i < nf; i++) {
getTriangle(i, fvi);
threeCorners[0] = _vertices[fvi[0]];
threeCorners[1] = _vertices[fvi[1]];
threeCorners[2] = _vertices[fvi[2]];
if(triangleIntersect(threeCorners, ctx)) {
ctx->m_componentIdx = BaseMesh::closestVertex(i, ctx->m_hitP);;
return 1;
}
}
return 0;
}
/**
* Get intersection points and their in out directions on the given ray
* @param start :: Start point of ray
* @param direction :: Direction of ray
* @param intersectionPoints :: Intersection points (not sorted)
* @param entryExitFlags :: +1 ray enters -1 ray exits at corresponding point
*/
void MeshObject::getIntersections(
const Kernel::V3D &start, const Kernel::V3D &direction,
std::vector<Kernel::V3D> &intersectionPoints,
std::vector<TrackDirection> &entryExitFlags) const {
Kernel::V3D vertex1, vertex2, vertex3, intersection;
TrackDirection entryExit;
for (size_t i = 0; getTriangle(i, vertex1, vertex2, vertex3); ++i) {
if (MeshObjectCommon::rayIntersectsTriangle(start, direction, vertex1,
vertex2, vertex3, intersection,
entryExit)) {
intersectionPoints.push_back(intersection);
entryExitFlags.push_back(entryExit);
}
}
// still need to deal with edge cases
}
int main(void)
{
int seed, n;
Triangle tri[100];
printf("乱数 seed : ");
scanf("%d", &seed);
srand(seed);
printf("3角形の個数 : ");
scanf("%d", &n);
getTriangle(n, tri);
calcArea(n, tri);
sortTriangle(n, tri);
prtTriangle(n, tri);
return 0;
}
/** Interpolates the normal at the given position for the triangle with
* a given index. The position must be inside of the given triangle.
* \param index Index of the triangle to use.
* \param position The position for which to interpolate the normal.
*/
btVector3 TriangleMesh::getInterpolatedNormal(unsigned int index,
const btVector3 &position) const
{
btVector3 p1, p2, p3;
getTriangle(index, &p1, &p2, &p3);
btVector3 n1, n2, n3;
getNormals(index, &n1, &n2, &n3);
// Compute the Barycentric coordinates of position inside triangle
// p1, p2, p3.
btVector3 edge1 = p2 - p1;
btVector3 edge2 = p3 - p1;
// Area of triangle ABC
btScalar p1p2p3 = edge1.cross(edge2).length2();
// Area of BCP
btScalar p2p3p = (p3 - p2).cross(position - p2).length2();
// Area of CAP
btScalar p3p1p = edge2.cross(position - p3).length2();
btScalar s = btSqrt(p2p3p / p1p2p3);
btScalar t = btSqrt(p3p1p / p1p2p3);
btScalar w = 1.0f - s - t;
#ifdef NORMAL_DEBUGGING
btVector3 regen_position = s * p1 + t * p2 + w * p3;
if((regen_position - position).length2() >= 0.0001f)
{
printf("bary:\n");
printf("new: %f %f %f\n", regen_position.getX(),regen_position.getY(),regen_position.getZ());
printf("old: %f %f %f\n", position.getX(), position.getY(),position.getZ());
printf("stw: %f %f %f\n", s, t, w);
printf("p1: %f %f %f\n", p1.getX(),p1.getY(),p1.getZ());
printf("p2: %f %f %f\n", p2.getX(),p2.getY(),p2.getZ());
printf("p3: %f %f %f\n", p3.getX(),p3.getY(),p3.getZ());
printf("pos: %f %f %f\n", position.getX(),position.getY(),position.getZ());
}
#endif
return s*n1 + t*n2 + w*n3;
} // getInterpolatedNormal
PathNode* CollisionManager::findNearestPathNode(TriangleNode* triangle, FloorMesh* floor, const Vector3& finalTarget) {
// this is overkill TODO: find something faster
PathGraph* graph = floor->getPathGraph();
if (graph == NULL)
return NULL;
Vector<PathNode*>* pathNodes = graph->getPathNodes();
PathNode* returnNode = NULL;
float distance = 16000;
Vector3 trianglePos(triangle->getBarycenter());
//trianglePos.set(trianglePos.getX(), trianglePos.getY(), trianglePos.getZ());*/
for (int i = 0; i < pathNodes->size(); ++i) {
PathNode* node = pathNodes->get(i);
TriangleNode* triangleOfPathNode = getTriangle(node->getPosition(), floor);
Vector<Triangle*>* path = TriangulationAStarAlgorithm::search(trianglePos, triangleOfPathNode->getBarycenter(), triangle, triangleOfPathNode);
if (path == NULL)
continue;
else {
delete path;
float sqrDistance = node->getPosition().squaredDistanceTo(finalTarget);
if (sqrDistance < distance) {
distance = sqrDistance;
returnNode = node;
}
}
}
return returnNode;
}
bool Features::findGoodTriangles(const CvSeq* objectKeypoints, const CvSeq* imageKeypoints, vector<int> ptpairs, vector<int> objSize, vector<int> &objTri, vector<int> &imgTri)
{
bool goodTriangle = false;
int index = 0;
//Se buscan triángulos que resulten convenientes para realizar la transformación.
while(!goodTriangle){
objTri = getTriangle(objectKeypoints, ptpairs);
imgTri = getMatchingTriangle(objectKeypoints, objTri, ptpairs);
goodTriangle = checkTriangles(objTri, imgTri, ptpairs);
//if(!goodTriangle) qDebug() << "Bad triangle.";
//goodTriangle = checkTriangles(objTri, imgTri, objectKeypoints, imageKeypoints, objSize, index);
//goodTriangle = true;
//if(!goodTriangle)
// removeMatch(objectKeypoints, ptpairs, objTri[index]);
//cout << ptpairs.size() << endl;
if(ptpairs.size()/2 < MINPAIRS)
return false;
}
if(goodTriangle && VERBOSE){
cout << "Descriptores del triangulo de la imagen 1: <" << objTri[0] << ", " << objTri[1] << ", " << objTri[2] << ">" << endl;
cout << "Descriptores del triangulo de la imagen 2: <" << imgTri[0] << ", " << imgTri[1] << ", " << imgTri[2] << ">" << endl << endl;
}
return goodTriangle;
}
/**
* Calculate volume.
* @return The volume.
*/
double MeshObject::volume() const {
// Select centre of bounding box as centre point.
// For each triangle calculate the signed volume of
// the tetrahedron formed by the triangle and the
// centre point. Then add to total.
BoundingBox bb = getBoundingBox();
double cX = 0.5 * (bb.xMax() + bb.xMin());
double cY = 0.5 * (bb.yMax() + bb.yMin());
double cZ = 0.5 * (bb.zMax() + bb.zMin());
Kernel::V3D centre(cX, cY, cZ);
double volumeTimesSix(0.0);
Kernel::V3D vertex1, vertex2, vertex3;
for (size_t i = 0; getTriangle(i, vertex1, vertex2, vertex3); ++i) {
Kernel::V3D a = vertex1 - centre;
Kernel::V3D b = vertex2 - centre;
Kernel::V3D c = vertex3 - centre;
volumeTimesSix += a.scalar_prod(b.cross_prod(c));
}
return volumeTimesSix / 6.0;
}
void Mesh::computeNormals(){
_normals.clear();
for(int i = 0; i < points().size(); i++){
_normals.push_back(geometry::Vector3D(0, 0, 0));
}
for(int i = 0; i < triangleIndexes().size(); i++){
IndexedTriangle t = triangleIndexes()[i];
math::Vector normal = getTriangle(t).getNormal().asVector();
math::Vector temp = _normals[t.idA].asVector() + normal;
_normals[t.idA] = geometry::Vector3D(temp(0), temp(1), temp(2));
temp = _normals[t.idB].asVector() + normal;
_normals[t.idB] = geometry::Vector3D(temp(0), temp(1), temp(2));
temp = _normals[t.idC].asVector() + normal;
_normals[t.idC] = geometry::Vector3D(temp(0), temp(1), temp(2));
}
for(int i = 0; i < points().size(); i++){
_normals[i] = _normals[i].normalized();
}
}
float Terrain::getHeight( const QPointF & position ) const
{
Triangle t = getTriangle( toMapF(position) );
QVector3D normal = t.normal();
return ( (normal.x()*(position.x()-t.p().x())) + (normal.z()*(position.y()-t.p().z())) ) / ( -normal.y() ) + t.p().y();
}
plane3df CTriangleAttribute::getPlane()
{
return getTriangle().getPlane();
}
void Gu::TriangleMesh::debugVisualize(
Cm::RenderOutput& out, const PxTransform& pose, const PxMeshScale& scaling, const PxBounds3& cullbox,
const PxU64 mask, const PxReal fscale, const PxU32 numMaterials) const
{
PX_UNUSED(numMaterials);
//bool cscale = !!(mask & ((PxU64)1 << PxVisualizationParameter::eCULL_BOX));
const PxU64 cullBoxMask = PxU64(1) << PxVisualizationParameter::eCULL_BOX;
bool cscale = ((mask & cullBoxMask) == cullBoxMask);
const PxMat44 midt(PxIdentity);
const Cm::Matrix34 absPose(PxMat33(pose.q) * scaling.toMat33(), pose.p);
PxU32 nbTriangles = getNbTrianglesFast();
const PxU32 nbVertices = getNbVerticesFast();
const PxVec3* vertices = getVerticesFast();
const void* indices = getTrianglesFast();
const PxDebugColor::Enum colors[] =
{
PxDebugColor::eARGB_BLACK,
PxDebugColor::eARGB_RED,
PxDebugColor::eARGB_GREEN,
PxDebugColor::eARGB_BLUE,
PxDebugColor::eARGB_YELLOW,
PxDebugColor::eARGB_MAGENTA,
PxDebugColor::eARGB_CYAN,
PxDebugColor::eARGB_WHITE,
PxDebugColor::eARGB_GREY,
PxDebugColor::eARGB_DARKRED,
PxDebugColor::eARGB_DARKGREEN,
PxDebugColor::eARGB_DARKBLUE,
};
const PxU32 colorCount = sizeof(colors)/sizeof(PxDebugColor::Enum);
if(cscale)
{
const Gu::Box worldBox(
(cullbox.maximum + cullbox.minimum)*0.5f,
(cullbox.maximum - cullbox.minimum)*0.5f,
PxMat33(PxIdentity));
// PT: TODO: use the callback version here to avoid allocating this huge array
PxU32* results = reinterpret_cast<PxU32*>(PX_ALLOC_TEMP(sizeof(PxU32)*nbTriangles, "tmp triangle indices"));
LimitedResults limitedResults(results, nbTriangles, 0);
Midphase::intersectBoxVsMesh(worldBox, *this, pose, scaling, &limitedResults);
nbTriangles = limitedResults.mNbResults;
if (fscale)
{
const PxU32 fcolor = PxU32(PxDebugColor::eARGB_DARKRED);
for (PxU32 i=0; i<nbTriangles; i++)
{
const PxU32 index = results[i];
PxVec3 wp[3];
getTriangle(*this, index, wp, vertices, indices, absPose, has16BitIndices());
const PxVec3 center = (wp[0] + wp[1] + wp[2]) / 3.0f;
PxVec3 normal = (wp[0] - wp[1]).cross(wp[0] - wp[2]);
PX_ASSERT(!normal.isZero());
normal = normal.getNormalized();
out << midt << fcolor <<
Cm::DebugArrow(center, normal * fscale);
}
}
if (mask & (PxU64(1) << PxVisualizationParameter::eCOLLISION_SHAPES))
{
const PxU32 scolor = PxU32(PxDebugColor::eARGB_MAGENTA);
out << midt << scolor; // PT: no need to output this for each segment!
PxDebugLine* segments = out.reserveSegments(nbTriangles*3);
for(PxU32 i=0; i<nbTriangles; i++)
{
const PxU32 index = results[i];
PxVec3 wp[3];
getTriangle(*this, index, wp, vertices, indices, absPose, has16BitIndices());
segments[0] = PxDebugLine(wp[0], wp[1], scolor);
segments[1] = PxDebugLine(wp[1], wp[2], scolor);
segments[2] = PxDebugLine(wp[2], wp[0], scolor);
segments+=3;
}
}
if ((mask & (PxU64(1) << PxVisualizationParameter::eCOLLISION_EDGES)) && mExtraTrigData)
visualizeActiveEdges(out, *this, nbTriangles, results, absPose, midt);
PX_FREE(results);
}
else
{
if (fscale)
{
const PxU32 fcolor = PxU32(PxDebugColor::eARGB_DARKRED);
for (PxU32 i=0; i<nbTriangles; i++)
{
PxVec3 wp[3];
getTriangle(*this, i, wp, vertices, indices, absPose, has16BitIndices());
const PxVec3 center = (wp[0] + wp[1] + wp[2]) / 3.0f;
PxVec3 normal = (wp[0] - wp[1]).cross(wp[0] - wp[2]);
PX_ASSERT(!normal.isZero());
normal = normal.getNormalized();
out << midt << fcolor <<
Cm::DebugArrow(center, normal * fscale);
}
}
if (mask & (PxU64(1) << PxVisualizationParameter::eCOLLISION_SHAPES))
{
PxU32 scolor = PxU32(PxDebugColor::eARGB_MAGENTA);
out << midt << scolor; // PT: no need to output this for each segment!
PxVec3* transformed = reinterpret_cast<PxVec3*>(PX_ALLOC(sizeof(PxVec3)*nbVertices, "PxVec3"));
for(PxU32 i=0;i<nbVertices;i++)
transformed[i] = absPose.transform(vertices[i]);
PxDebugLine* segments = out.reserveSegments(nbTriangles*3);
for (PxU32 i=0; i<nbTriangles; i++)
{
PxVec3 wp[3];
getTriangle(*this, i, wp, transformed, indices, has16BitIndices());
const PxU32 localMaterialIndex = getTriangleMaterialIndex(i);
scolor = colors[localMaterialIndex % colorCount];
segments[0] = PxDebugLine(wp[0], wp[1], scolor);
segments[1] = PxDebugLine(wp[1], wp[2], scolor);
segments[2] = PxDebugLine(wp[2], wp[0], scolor);
segments+=3;
}
PX_FREE(transformed);
}
if ((mask & (PxU64(1) << PxVisualizationParameter::eCOLLISION_EDGES)) && mExtraTrigData)
visualizeActiveEdges(out, *this, nbTriangles, NULL, absPose, midt);
}
}
inline Triangle Terrain::getTriangle( const QVector3D & position ) const
{
return getTriangle( QPointF(position.x(),position.z()) );
}
inline bool Terrain::getTriangle( const QVector3D & position, Triangle & t ) const
{
return getTriangle( QPointF(position.x(),position.z()), t );
}
void cMesh::setGraph(int img_idx, RGraph &aGraph, vector <int> &aTriInGraph, vector <unsigned int> const &aVisTriIdx)
{
int id1, id2, pos1, pos2;
float E0, E1, E2;
//parcours des aretes du graphe d'adjacence
for (unsigned int aK=0; aK < mEdges.size(); aK++)
{
id1 = mEdges[aK].n1();
id2 = mEdges[aK].n2();
//on recherche id1 et id2 parmi les triangles visibles
if ((find(aVisTriIdx.begin(), aVisTriIdx.end(), id1)!=aVisTriIdx.end()) &&
(find(aVisTriIdx.begin(), aVisTriIdx.end(), id2)!=aVisTriIdx.end()))
{
//on ajoute seulement les triangles qui ne sont pas encore presents dans le graphe
if (find(aTriInGraph.begin(), aTriInGraph.end(), id1) == aTriInGraph.end())
{
aTriInGraph.push_back(id1);
aGraph.add_node();
}
if (find(aTriInGraph.begin(), aTriInGraph.end(), id2) == aTriInGraph.end())
{
aTriInGraph.push_back(id2);
aGraph.add_node();
}
}
}
cEdge elEdge;
//creation des aretes et calcul de leur energie
for (unsigned int aK=0; aK < mEdges.size(); aK++)
{
elEdge = mEdges[aK];
id1 = elEdge.n1();
id2 = elEdge.n2();
vector<int>::iterator it1 = find(aTriInGraph.begin(), aTriInGraph.end(), id1);
vector<int>::iterator it2 = find(aTriInGraph.begin(), aTriInGraph.end(), id2);
if ( (it1 != aTriInGraph.end()) && (it2 != aTriInGraph.end()) )
{
//pos1 = (int) (it1 - aTriInGraph.begin());
//pos2 = (int) (it2 - aTriInGraph.begin());
pos1 = (int) distance(aTriInGraph.begin(), it1);
pos2 = (int) distance(aTriInGraph.begin(), it2);
//energies de l'arete triangle-source et de l'arete triangle-puit
cTriangle *Tri1 = getTriangle(id1);
cTriangle *Tri2 = getTriangle(id2);
E1 = (float)Tri1->computeEnergy(img_idx);
E2 = (float)Tri2->computeEnergy(img_idx);
//if (E1 == 0.f)
// aGraph.add_tweights( pos1, 0.f, 1.f );
//else
//{
aGraph.add_tweights( pos1, (float)(mLambda*E1), 0.f );
//}
//if (E2 == 0.f)
// aGraph.add_tweights( pos2, 0.f, 1.f );
//else
//{
aGraph.add_tweights( pos2, (float)(mLambda*E2), 0.f );
//}
//energie de l'arete inter-triangles
//longueur^2 de l'arete coupee par elEdge
E0 = (float)square_euclid( getVertex( elEdge.v1() ), getVertex( elEdge.v2() ) );
aGraph.add_edge(pos1, pos2, E0, E0);
//aGraph.add_edge(pos1, pos2, 1, 1);
}
}
#ifdef oldoldold
for (unsigned int aK=0; aK < aTriInGraph.size(); aK++)
{
cTriangle *Tri = getTriangle(aTriInGraph[aK]);
E = Tri->computeEnergy(img_idx);
if (E == 0.f)
aGraph.add_tweights( aK, 1.f, 0.f );
else
{
aGraph.add_tweights( aK, mLambda*E, 0.f );
//aGraph.add_tweights( aK, 1.f, 0.f );
/*if (Tri->isInside())
aGraph.add_tweights( aK, 0.f, 1.f );
else
aGraph.add_tweights( aK, 1.f, 0.f );*/
}
}
#endif
}
QVector3D Terrain::getNormal( const QPointF & position ) const
{
Triangle t = getTriangle( toMapF(position) );
return t.normal();
}
//------------------------------
MeshAccessor::TriangleType MeshAccessor::getNextTriangle() const
{
mCurrentTriangleIndex++;
const COLLADAFW::MeshPrimitive* meshPrimitive = mMesh->getMeshPrimitives()[mCurrentPrimitiveIndex];
const COLLADAFW::UIntValuesArray& positionsIndices = meshPrimitive->getPositionIndices();
COLLADAFW::MaterialId materialId = meshPrimitive->getMaterialId();
switch ( meshPrimitive->getPrimitiveType() )
{
case COLLADAFW::MeshPrimitive::TRIANGLES:
{
size_t triangleCount = positionsIndices.getCount()/3;
if ( (mCurrentTriangleInTriStripFanIndex + 1) < triangleCount )
{
// use next in same triangle
mCurrentTriangleInTriStripFanIndex++;
size_t firstIndex = mCurrentTriangleInTriStripFanIndex * 3;
TriangleType triangle(positionsIndices[firstIndex], positionsIndices[firstIndex+1],positionsIndices[firstIndex+2], materialId);
return triangle;
}
else
{
return getTriangle( mCurrentTriangleIndex );
}
}
case COLLADAFW::MeshPrimitive::TRIANGLE_STRIPS:
{
const COLLADAFW::Tristrips* tristrips = (const COLLADAFW::Tristrips*)meshPrimitive;
const COLLADAFW::UIntValuesArray& faceVertexCountArray = tristrips->getGroupedVerticesVertexCountArray();
size_t triangleCount = faceVertexCountArray[mCurrentStripFanIndex] - 2;
if ( (mCurrentTriangleInTriStripFanIndex + 1) < triangleCount )
{
// use next in same triangle
mCurrentTriangleInTriStripFanIndex++;
size_t firstIndex = mCurrentTrianglePositionsArrayIndex + mCurrentTriangleInTriStripFanIndex;
if ( mCurrentTriangleInTriStripFanIndex % 2 == 0 )
{
return TriangleType(positionsIndices[firstIndex], positionsIndices[firstIndex+1],positionsIndices[firstIndex+2], materialId);
}
else
{
return TriangleType(positionsIndices[firstIndex], positionsIndices[firstIndex+2],positionsIndices[firstIndex+1], materialId);
}
}
else
{
if ( (mCurrentStripFanIndex + 1) < faceVertexCountArray.getCount() )
{
// take the next strip
mCurrentTrianglePositionsArrayIndex += faceVertexCountArray[mCurrentStripFanIndex];
mCurrentStripFanIndex++;
mCurrentTriangleInTriStripFanIndex = 0;
size_t firstIndex = mCurrentTrianglePositionsArrayIndex;
return TriangleType (positionsIndices[firstIndex], positionsIndices[firstIndex+1],positionsIndices[firstIndex+2], materialId);
}
else
{
return getTriangle( mCurrentTriangleIndex );
}
}
}
case COLLADAFW::MeshPrimitive::TRIANGLE_FANS:
{
const COLLADAFW::Trifans* trifans = (const COLLADAFW::Trifans*)meshPrimitive;
const COLLADAFW::UIntValuesArray& faceVertexCountArray = trifans->getGroupedVerticesVertexCountArray();
size_t triangleCount = faceVertexCountArray[mCurrentStripFanIndex] - 2;
if ( (mCurrentTriangleInTriStripFanIndex + 1) < triangleCount )
{
// use next in same triangle
mCurrentTriangleInTriStripFanIndex++;
size_t firstIndex = mCurrentTrianglePositionsArrayIndex + mCurrentTriangleInTriStripFanIndex;
TriangleType triangle(positionsIndices[mCurrentTrianglePositionsArrayIndex], positionsIndices[firstIndex+1],positionsIndices[firstIndex+2], materialId);
return triangle;
}
else
{
if ( (mCurrentStripFanIndex + 1) < faceVertexCountArray.getCount() )
{
// take the next strip
mCurrentTrianglePositionsArrayIndex += faceVertexCountArray[mCurrentStripFanIndex];
mCurrentStripFanIndex++;
mCurrentTriangleInTriStripFanIndex = 0;
size_t firstIndex = mCurrentTrianglePositionsArrayIndex;
TriangleType triangle(positionsIndices[mCurrentTrianglePositionsArrayIndex], positionsIndices[firstIndex+1],positionsIndices[firstIndex+2], materialId);
return triangle;
}
else
{
return getTriangle( mCurrentTriangleIndex );
}
}
}
default:
assert(false);
return TriangleType(0, 0, 0, 0);
}
}
