//----------------------------------------------------------------------- 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); } }