MeshGeometry PrimitiveGeometryBuilder::buildCylinderMesh(std::vector<tgt::vec3>& vertices, size_t numSides, tgt::vec3 color) { // Transform vec3 to vec4 tgt::vec4 color4(color[0], color[1], color[2], 1.f); // Build cylinder's sides MeshGeometry cyl; for (size_t i = 0; i < 2*numSides; i+=2) { FaceGeometry face; tgt::vec3 faceNormal = tgt::cross(vertices[i+1] - vertices[i], vertices[i+2] - vertices[i]); // Face vertices // TODO Replace faceNormal with vertex normals for smoother representation VertexGeometry fv1(vertices[i], tgt::vec3(0.f), color4, faceNormal); VertexGeometry fv2(vertices[i+1], tgt::vec3(0.f), color4, faceNormal); VertexGeometry fv3(vertices[i+3], tgt::vec3(0.f), color4, faceNormal); VertexGeometry fv4(vertices[i+2], tgt::vec3(0.f), color4, faceNormal); face.addVertex(fv1); face.addVertex(fv2); face.addVertex(fv3); face.addVertex(fv4); cyl.addFace(face); } return cyl; }
MeshListGeometry* ROICube::generateNormalizedMesh(tgt::plane pl) const { FaceGeometry planeFace = createQuad(pl, getColor()); vec4 xm(-1.0f, 0.0f, 0.0f, 1.0f); vec4 xp(1.0f, 0.0f, 0.0f, 1.0f); vec4 ym(0.0f, -1.0f, 0.0f, 1.0f); vec4 yp(0.0f, 1.0f, 0.0f, 1.0f); vec4 zm(0.0f, 0.0f, -1.0f, 1.0f); vec4 zp(0.0f, 0.0f, 1.0f, 1.0f); planeFace.clip(xm); planeFace.clip(xp); planeFace.clip(ym); planeFace.clip(yp); planeFace.clip(zm); planeFace.clip(zp); MeshGeometry mg; if(planeFace.getVertexCount() > 2) mg.addFace(planeFace); MeshListGeometry* mlg = new MeshListGeometry(); mlg->addMesh(mg); return mlg; }
FaceGeometry PrimitiveGeometryBuilder::createFace(std::vector<tgt::vec3>& vertices, tgt::vec4 color) { FaceGeometry face; tgt::vec3 faceNormal = tgt::cross(vertices[1] - vertices[0], vertices[2] - vertices[0]); // Face vertices // TODO Replace faceNormal with vertex normals for smoother representation for (size_t i = 0; i < vertices.size(); i++) { VertexGeometry fv(vertices[i], tgt::vec3(0.f), color, faceNormal); face.addVertex(fv); } return face; }
void Detection::doFacialComponentsExtractionSide(FaceGeometry& faceGeometry, const std::vector<ContourInfo>& componentContourInfo, const std::vector<ContourInfo>& faceContourInfo) { // we need at least 3 elements (left & right eye, mouth) if (componentContourInfo.size()<1 || faceContourInfo.size()<1) { throw std::exception("we need at least 1 region for classification as eye (side image)"); } const ContourInfo& eye = componentContourInfo[0]; const ContourInfo& face = faceContourInfo[0]; faceGeometry.setDetectedPoint(FaceGeometry::SideEye, cv::Point2d(eye.cogX, eye.cogY)); // find bounding polygon with at least 5 vertices std::vector<cv::Point> polygonPoints; double precission = 50.0; while (polygonPoints.size() < 5) { cv::approxPolyDP(face.contour, polygonPoints, precission, true); precission = precission / 2; } // nose tip is rightmost point (of this polygon) size_t noseIdx = 0; faceGeometry.setDetectedPoint(FaceGeometry::SideNoseTip, cv::Point2d(0, 0)); for (size_t i = 0; i < polygonPoints.size(); ++i) { if (polygonPoints[i].x > faceGeometry.getDetectedPoint(FaceGeometry::SideNoseTip).x) { faceGeometry.setDetectedPoint(FaceGeometry::SideNoseTip, polygonPoints[i]); noseIdx = i; } } // find chin: which direction must be searched for in the polygon? bool incIdx = false; const size_t numPolygonPoints = polygonPoints.size(); if (polygonPoints[(noseIdx + 1) % numPolygonPoints].y > faceGeometry.getDetectedPoint(FaceGeometry::SideNoseTip).y) { incIdx = true; } // search for the following pattern: find a convex and a neighboured concave polygon part under the nose faceGeometry.setDetectedPoint(FaceGeometry::SideChin, cv::Point2d(0, 0)); for (size_t i = noseIdx, j = 0; j<numPolygonPoints; incIdx ? ++i : --i, ++j) { // don't check the nose itself if (j==0) { continue; } // get prev, curr and next point cv::Point prevprev = polygonPoints[(incIdx ? (i - 2) : (i + 2)) % numPolygonPoints]; cv::Point prev = polygonPoints[(incIdx ? (i - 1) : (i + 1)) % numPolygonPoints]; cv::Point curr = polygonPoints[i % numPolygonPoints]; cv::Point next = polygonPoints[(incIdx ? (i + 1) : (i - 1)) % numPolygonPoints]; if (isConcave(prev, curr, next) && !isConcave(prevprev, prev, curr)) { faceGeometry.setDetectedPoint(FaceGeometry::SideChin, prev); break; } } // find back side of head const cv::Point chinPoint = faceGeometry.getDetectedPoint(FaceGeometry::SideChin); cv::Point backPoint; for (int x = 0; x<m_FaceExtracted[sideImgNr].cols; ++x) { if (m_FaceExtracted[sideImgNr].at<unsigned char>(cv::Point(x, chinPoint.y))!=0) { backPoint.x = x; backPoint.y = chinPoint.y; break; } } faceGeometry.setDetectedPoint(FaceGeometry::SideBack, backPoint); // create face mask cv::Mat mask(imgSize, imgSize, CV_8U); mask.setTo(0); cv::drawContours(mask, std::vector<std::vector<cv::Point> > {face.contour}, 0, 255, -1); m_FaceMask.push_back(mask); // show debug info cv::Mat tmp = getCopyOfOriginal(sideImgNr); cv::drawContours(tmp, std::vector<std::vector<cv::Point> > {eye.contour}, 0, cv::Scalar(255, 0, 0), -1); dbgShow(tmp, "doFacialComponentsExtractionSide"); // and the polygon cv::Mat tmpChin = cv::Mat::zeros(imgSize, imgSize, CV_8UC3); cv::drawContours(tmpChin, std::vector<std::vector<cv::Point> > {face.contour}, 0, cv::Scalar(100, 100, 100), -1); cv::RNG rng(0); for (size_t i = 0; i < numPolygonPoints; ++i) { std::cout << "Point: " << polygonPoints[i] << "\n"; cv::line(tmpChin, polygonPoints[i], polygonPoints[(i + 1) % numPolygonPoints], cv::Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255)), 5); } dbgShow(tmpChin, "doFacialComponentsExtractionSide"); }
void Detection::doFacialComponentsExtractionFront(FaceGeometry& faceGeometry, const std::vector<ContourInfo>& componentContourInfo, const std::vector<ContourInfo>& faceContourInfo) { // we need at least 3 elements (left & right eye, mouth) if (componentContourInfo.size()<3 || faceContourInfo.size()<1) { throw std::exception("we need at least 3 regions for classification as left & right eye, mouth (front image)"); } std::vector<ContourInfo> biggestThree(componentContourInfo.begin(), componentContourInfo.begin() + 3); ContourInfo mouth; std::vector<ContourInfo> eyes; for (size_t i = 0; i < biggestThree.size(); ++i) { if (biggestThree[i].cogY > faceContourInfo[0].cogY) { mouth = biggestThree[i]; } else { eyes.push_back(biggestThree[i]); } } // we need at least 3 elements (left & right eye, mouth) if (eyes.size()!=2) { throw std::exception("couldn't identify both eyes"); } // left / right eye ContourInfo leftEye = eyes[0].cogX < eyes[1].cogX ? eyes[0] : eyes[1]; ContourInfo rightEye = eyes[0].cogX > eyes[1].cogX ? eyes[0] : eyes[1]; faceGeometry.setDetectedPoint(FaceGeometry::FrontLeftEye, cv::Point2d(leftEye.cogX, leftEye.cogY)); faceGeometry.setDetectedPoint(FaceGeometry::FrontRightEye, cv::Point2d(rightEye.cogX, rightEye.cogY)); faceGeometry.setDetectedPoint(FaceGeometry::FrontMouth, cv::Point2d(mouth.cogX, mouth.cogY)); // find sides of face (xmin, xmax) const cv::Point eyePos = faceGeometry.getDetectedPoint(FaceGeometry::FrontLeftEye); cv::Point leftCheek, rightCheek; // left for (int x = 0; x<m_FaceExtracted[sideImgNr].cols; ++x) { if (m_FaceExtracted[frontImgNr].at<unsigned char>(cv::Point(x, eyePos.y)) != 0) { leftCheek.x = x; leftCheek.y = eyePos.y; break; } } // right for (int x = m_FaceExtracted[sideImgNr].cols-1; x>=0; --x) { if (m_FaceExtracted[frontImgNr].at<unsigned char>(cv::Point(x, eyePos.y)) != 0) { rightCheek.x = x; rightCheek.y = eyePos.y; break; } } faceGeometry.setDetectedPoint(FaceGeometry::FrontLeftCheek, leftCheek); faceGeometry.setDetectedPoint(FaceGeometry::FrontRightCheek, rightCheek); // create face mask cv::Mat mask(imgSize,imgSize,CV_8U); mask.setTo(0); cv::drawContours(mask, std::vector<std::vector<cv::Point> > {faceContourInfo[0].contour}, 0, 255, -1); m_FaceMask.push_back(mask); // show debug info cv::Mat tmp=getCopyOfOriginal(frontImgNr); cv::drawContours(tmp, std::vector<std::vector<cv::Point> > {leftEye.contour}, 0, cv::Scalar(255, 0, 0), -1); cv::drawContours(tmp, std::vector<std::vector<cv::Point> > {rightEye.contour}, 0, cv::Scalar(0, 255, 0), -1); cv::drawContours(tmp, std::vector<std::vector<cv::Point> > {mouth.contour}, 0, cv::Scalar(0, 0, 255), -1); dbgShow(tmp, "doFacialComponentsExtractionFront"); }
void MeshGeometry::createCubeFaces(FaceGeometry& topFace, FaceGeometry& frontFace, FaceGeometry& leftFace, FaceGeometry& backFace, FaceGeometry& rightFace, FaceGeometry& bottomFace, tgt::vec3 coordLlf, tgt::vec3 coordUrb, tgt::vec3 texLlf, tgt::vec3 texUrb, tgt::vec3 colorLlf, tgt::vec3 colorUrb, float alpha) { // expecting coordLlf < coordUrb if (coordLlf.x > coordUrb.x) { std::swap(coordLlf.x, coordUrb.x); std::swap(texLlf.x, texUrb.x); std::swap(colorLlf.x, colorUrb.x); } if (coordLlf.y > coordUrb.y) { std::swap(coordLlf.y, coordUrb.y); std::swap(texLlf.y, texUrb.y); std::swap(colorLlf.y, colorUrb.y); } if (coordLlf.z > coordUrb.z) { std::swap(coordLlf.z, coordUrb.z); std::swap(texLlf.z, texUrb.z); std::swap(colorLlf.z, colorUrb.z); } VertexGeometry llf(vec3(coordLlf.x, coordLlf.y, coordLlf.z), vec3(texLlf.x, texLlf.y, texLlf.z), vec4(colorLlf.x, colorLlf.y, colorLlf.z, alpha)); VertexGeometry lrf(vec3(coordUrb.x, coordLlf.y, coordLlf.z), vec3(texUrb.x, texLlf.y, texLlf.z), vec4(colorUrb.x, colorLlf.y, colorLlf.z, alpha)); VertexGeometry lrb(vec3(coordUrb.x, coordLlf.y, coordUrb.z), vec3(texUrb.x, texLlf.y, texUrb.z), vec4(colorUrb.x, colorLlf.y, colorUrb.z, alpha)); VertexGeometry llb(vec3(coordLlf.x, coordLlf.y, coordUrb.z), vec3(texLlf.x, texLlf.y, texUrb.z), vec4(colorLlf.x, colorLlf.y, colorUrb.z, alpha)); VertexGeometry ulb(vec3(coordLlf.x, coordUrb.y, coordUrb.z), vec3(texLlf.x, texUrb.y, texUrb.z), vec4(colorLlf.x, colorUrb.y, colorUrb.z, alpha)); VertexGeometry ulf(vec3(coordLlf.x, coordUrb.y, coordLlf.z), vec3(texLlf.x, texUrb.y, texLlf.z), vec4(colorLlf.x, colorUrb.y, colorLlf.z, alpha)); VertexGeometry urf(vec3(coordUrb.x, coordUrb.y, coordLlf.z), vec3(texUrb.x, texUrb.y, texLlf.z), vec4(colorUrb.x, colorUrb.y, colorLlf.z, alpha)); VertexGeometry urb(vec3(coordUrb.x, coordUrb.y, coordUrb.z), vec3(texUrb.x, texUrb.y, texUrb.z), vec4(colorUrb.x, colorUrb.y, colorUrb.z, alpha)); topFace.addVertex(urb); topFace.addVertex(urf); topFace.addVertex(ulf); topFace.addVertex(ulb); frontFace.addVertex(llf); frontFace.addVertex(ulf); frontFace.addVertex(urf); frontFace.addVertex(lrf); leftFace.addVertex(llf); leftFace.addVertex(llb); leftFace.addVertex(ulb); leftFace.addVertex(ulf); backFace.addVertex(urb); backFace.addVertex(ulb); backFace.addVertex(llb); backFace.addVertex(lrb); rightFace.addVertex(urb); rightFace.addVertex(lrb); rightFace.addVertex(lrf); rightFace.addVertex(urf); bottomFace.addVertex(llf); bottomFace.addVertex(lrf); bottomFace.addVertex(lrb); bottomFace.addVertex(llb); }
MeshGeometry MeshGeometry::clip(const vec4& clipplane, double epsilon) { // Clip all faces... for (iterator it = begin(); it != end(); ++it) it->clip(clipplane, epsilon); // Remove empty faces... for (size_t i = 0; i < faces_.size(); ++i) { // Is face empty? if (faces_.at(i).getVertexCount() < 3) faces_.erase(faces_.begin() + i--); } // Close convex polyhedron if necessary... typedef std::pair<VertexGeometry, VertexGeometry> EdgeType; typedef std::vector<EdgeType> EdgeListType; typedef std::vector<VertexGeometry> VertexListType; EdgeListType edgeList; FaceGeometry closingFace; // Search all face edges on the clipping plane... for (size_t i = 0; i < faces_.size(); ++i) { FaceGeometry face = faces_.at(i); VertexListType verticesOnClipplane; for (size_t j = 0; j < face.getVertexCount(); ++j) { if (face.getVertex(j).getDistanceToPlane(clipplane, epsilon) == 0) verticesOnClipplane.push_back(face.getVertex(j)); // Is face in the same plane as the clipping plane? if (verticesOnClipplane.size() > 2) break; } // Does one face edge corresponds with clipping plane? if (verticesOnClipplane.size() == 2) edgeList.push_back(std::make_pair(verticesOnClipplane[0], verticesOnClipplane[1])); } // Is closing necessary? if (edgeList.size() > 1) { // Sort edges to produce contiguous vertex order... bool reverseLastEdge = false; for (size_t i = 0; i < edgeList.size() - 1; ++i) { for (size_t j = i + 1; j < edgeList.size(); ++j) { VertexGeometry connectionVertex; if (reverseLastEdge) connectionVertex = edgeList.at(i).first; else connectionVertex = edgeList.at(i).second; if (edgeList.at(j).first.equals(connectionVertex, epsilon)) { std::swap(edgeList.at(i + 1), edgeList.at(j)); reverseLastEdge = false; break; } else if (edgeList.at(j).second.equals(connectionVertex, epsilon)) { std::swap(edgeList.at(i + 1), edgeList.at(j)); reverseLastEdge = true; break; } } } // Convert sorted edge list to sorted vertex list... VertexListType closingFaceVertices; for (size_t i = 0; i < edgeList.size(); ++i) { bool reverseEdge = i != 0 && !closingFaceVertices.at(closingFaceVertices.size() - 1).equals(edgeList.at(i).first); VertexGeometry first = (reverseEdge ? edgeList.at(i).second : edgeList.at(i).first); VertexGeometry second = (reverseEdge ? edgeList.at(i).first : edgeList.at(i).second); if (i == 0) closingFaceVertices.push_back(first); else closingFaceVertices.at(closingFaceVertices.size() - 1).combine(first); if (i < (edgeList.size() - 1)) closingFaceVertices.push_back(second); else closingFaceVertices[0].combine(second); } // Convert vertex order to counter clockwise if necessary... vec3 closingFaceNormal(0, 0, 0); for (size_t i = 0; i < closingFaceVertices.size(); ++i) closingFaceNormal += tgt::cross(closingFaceVertices[i].getCoords(), closingFaceVertices[(i + 1) % closingFaceVertices.size()].getCoords()); closingFaceNormal = tgt::normalize(closingFaceNormal); if (tgt::dot(clipplane.xyz(), closingFaceNormal) < 0) std::reverse(closingFaceVertices.begin(), closingFaceVertices.end()); // Close convex polyhedron... for (VertexListType::iterator it = closingFaceVertices.begin(); it != closingFaceVertices.end(); ++it) { // TODO(b_bolt01): Remove debug message... //std::cout << " cfv " << it->getCoords() << std::endl; closingFace.addVertex(*it); } addFace(closingFace); } // If there is only the clipplane left, erase it also... if (faces_.size() == 1) faces_.clear(); MeshGeometry closingMesh; if (closingFace.getVertexCount() > 0) closingMesh.addFace(closingFace); return closingMesh; }
FaceGeometry* FaceGeometry::clone() const { FaceGeometry* toReturn = new FaceGeometry(_vertices, _textureCoordinates, _colors, _normals); toReturn->setPickingInformation(_pickingInformation); return toReturn; }
void MultiPlanarProxyGeometry::process() { // input volume const VolumeBase* inputVolume = inport_.getData(); tgtAssert(inputVolume, "No input volume"); tgt::vec3 llf = inputVolume->getLLF(); tgt::vec3 urb = inputVolume->getURB(); tgt::vec3 texLlf = tgt::vec3(0.f); tgt::vec3 texUrb = tgt::vec3(1.f); // // x-face // const float slicePosX = llf.x + slicePosX_.get()*(urb.x - llf.x); const float sliceTexX = slicePosX_.get(); VertexGeometry xLL(tgt::vec3(slicePosX, llf.y, llf.z), tgt::vec3(sliceTexX, texLlf.y, texLlf.z)); VertexGeometry xLR(tgt::vec3(slicePosX, urb.y, llf.z), tgt::vec3(sliceTexX, texUrb.y, texLlf.z)); VertexGeometry xUR(tgt::vec3(slicePosX, urb.y, urb.z), tgt::vec3(sliceTexX, texUrb.y, texUrb.z)); VertexGeometry xUL(tgt::vec3(slicePosX, llf.y, urb.z), tgt::vec3(sliceTexX, texLlf.y, texUrb.z)); FaceGeometry xFace; xFace.addVertex(xLL); xFace.addVertex(xLR); xFace.addVertex(xUR); xFace.addVertex(xUL); // We need to double each of the three faces with antiparallel normal vectors, // in order to make sure that we have front and back faces. This is necessary, // because the MeshEntryExitPoints processor derives the exit points from back faces. // these offsets are added to the back faces' slice and tex coords for preventing // the ray direction (exitPoint - entryPoint) becoming the null vector. const float texCoordOffset = 0.001f; const float sliceCoordOffset = 0.00001f; const float slicePosXBack = slicePosX-sliceCoordOffset; const float sliceTexXBack = sliceTexX-texCoordOffset; VertexGeometry xLLBack(tgt::vec3(slicePosXBack, llf.y, llf.z), tgt::vec3(sliceTexXBack, texLlf.y, texLlf.z)); VertexGeometry xLRBack(tgt::vec3(slicePosXBack, urb.y, llf.z), tgt::vec3(sliceTexXBack, texUrb.y, texLlf.z)); VertexGeometry xURBack(tgt::vec3(slicePosXBack, urb.y, urb.z), tgt::vec3(sliceTexXBack, texUrb.y, texUrb.z)); VertexGeometry xULBack(tgt::vec3(slicePosXBack, llf.y, urb.z), tgt::vec3(sliceTexXBack, texLlf.y, texUrb.z)); FaceGeometry xFaceBack; //< reverse order of vertices for back face xFaceBack.addVertex(xLLBack); xFaceBack.addVertex(xULBack); xFaceBack.addVertex(xURBack); xFaceBack.addVertex(xLRBack); // // y-face // const float slicePosY = llf.y + slicePosY_.get()*(urb.y - llf.y); const float sliceTexY = slicePosY_.get(); VertexGeometry yLL(tgt::vec3(llf.x, slicePosY, llf.z), tgt::vec3(texLlf.x, sliceTexY, texLlf.z)); VertexGeometry yLR(tgt::vec3(urb.x, slicePosY, llf.z), tgt::vec3(texUrb.x, sliceTexY, texLlf.z)); VertexGeometry yUR(tgt::vec3(urb.x, slicePosY, urb.z), tgt::vec3(texUrb.x, sliceTexY, texUrb.z)); VertexGeometry yUL(tgt::vec3(llf.x, slicePosY, urb.z), tgt::vec3(texLlf.x, sliceTexY, texUrb.z)); FaceGeometry yFace; yFace.addVertex(yLL); yFace.addVertex(yUL); yFace.addVertex(yUR); yFace.addVertex(yLR); // y back face (see above) const float slicePosYBack = slicePosY-sliceCoordOffset; const float sliceTexYBack = sliceTexY-texCoordOffset; VertexGeometry yLLBack(tgt::vec3(llf.x, slicePosYBack, llf.z), tgt::vec3(texLlf.x, sliceTexYBack, texLlf.z)); VertexGeometry yLRBack(tgt::vec3(urb.x, slicePosYBack, llf.z), tgt::vec3(texUrb.x, sliceTexYBack, texLlf.z)); VertexGeometry yURBack(tgt::vec3(urb.x, slicePosYBack, urb.z), tgt::vec3(texUrb.x, sliceTexYBack, texUrb.z)); VertexGeometry yULBack(tgt::vec3(llf.x, slicePosYBack, urb.z), tgt::vec3(texLlf.x, sliceTexYBack, texUrb.z)); FaceGeometry yFaceBack; yFaceBack.addVertex(yLLBack); yFaceBack.addVertex(yLRBack); yFaceBack.addVertex(yURBack); yFaceBack.addVertex(yULBack); // // z-face // const float slicePosZ = llf.z + slicePosZ_.get()*(urb.z - llf.z); const float sliceTexZ = slicePosZ_.get(); VertexGeometry zLL(tgt::vec3(llf.x, llf.y, slicePosZ), tgt::vec3(texLlf.x, texLlf.y, sliceTexZ)); VertexGeometry zLR(tgt::vec3(urb.x, llf.y, slicePosZ), tgt::vec3(texUrb.x, texLlf.y, sliceTexZ)); VertexGeometry zUR(tgt::vec3(urb.x, urb.y, slicePosZ), tgt::vec3(texUrb.x, texUrb.y, sliceTexZ)); VertexGeometry zUL(tgt::vec3(llf.x, urb.y, slicePosZ), tgt::vec3(texLlf.x, texUrb.y, sliceTexZ)); FaceGeometry zFace; zFace.addVertex(zLL); zFace.addVertex(zLR); zFace.addVertex(zUR); zFace.addVertex(zUL); // z back face (see above) const float slicePosZBack = slicePosZ-sliceCoordOffset; const float sliceTexZBack = sliceTexZ-texCoordOffset; VertexGeometry zLLBack(tgt::vec3(llf.x, llf.y, slicePosZBack), tgt::vec3(texLlf.x, texLlf.y, sliceTexZBack)); VertexGeometry zLRBack(tgt::vec3(urb.x, llf.y, slicePosZBack), tgt::vec3(texUrb.x, texLlf.y, sliceTexZBack)); VertexGeometry zURBack(tgt::vec3(urb.x, urb.y, slicePosZBack), tgt::vec3(texUrb.x, texUrb.y, sliceTexZBack)); VertexGeometry zULBack(tgt::vec3(llf.x, urb.y, slicePosZBack), tgt::vec3(texLlf.x, texUrb.y, sliceTexZBack)); FaceGeometry zFaceBack; zFaceBack.addVertex(zLLBack); zFaceBack.addVertex(zULBack); zFaceBack.addVertex(zURBack); zFaceBack.addVertex(zLRBack); // construct output mesh from faces MeshGeometry* geometry = new MeshGeometry(); geometry->addFace(xFace); geometry->addFace(xFaceBack); geometry->addFace(yFace); geometry->addFace(yFaceBack); geometry->addFace(zFace); geometry->addFace(zFaceBack); // assign vertex tex coords as vertex colors so the mesh can be rendered directly (debugging, ...) for (size_t faceID=0; faceID<geometry->getFaceCount(); faceID++) { for (size_t vertexID=0; vertexID<geometry->getFace(faceID).getVertexCount(); vertexID++) { tgt::vec3 texCoords = geometry->getFace(faceID).getVertex(vertexID).getTexCoords(); geometry->getFace(faceID).getVertex(vertexID).setColor(texCoords); } } outport_.setData(geometry); }
boost::shared_ptr<hier::BoxOverlap> OuterfaceGeometry::doOverlap( const FaceGeometry& dst_geometry, const OuterfaceGeometry& src_geometry, const hier::Box& src_mask, const hier::Box& fill_box, const bool overwrite_interior, const hier::Transformation& transformation, const hier::BoxContainer& dst_restrict_boxes) { const tbox::Dimension& dim(src_mask.getDim()); std::vector<hier::BoxContainer> dst_boxes(dim.getValue()); // Perform a quick-and-dirty intersection to see if the boxes might overlap hier::Box src_box(src_geometry.d_box); src_box.grow(src_geometry.d_ghosts); src_box = src_box * src_mask; transformation.transform(src_box); hier::Box dst_ghost(dst_geometry.getBox()); dst_ghost.grow(dst_geometry.getGhosts()); // Compute the intersection (if any) for each of the face directions const hier::IntVector one_vector(dim, 1); const hier::Box quick_check( hier::Box::grow(src_box, one_vector) * hier::Box::grow(dst_ghost, one_vector)); if (!quick_check.empty()) { hier::Box mask_shift(src_mask); transformation.transform(mask_shift); for (tbox::Dimension::dir_t d = 0; d < dim.getValue(); ++d) { const hier::Box msk_face( FaceGeometry::toFaceBox(mask_shift, d)); const hier::Box dst_face( FaceGeometry::toFaceBox(dst_ghost, d)); const hier::Box src_face( FaceGeometry::toFaceBox(src_box, d)); const hier::Box fill_face( FaceGeometry::toFaceBox(fill_box, d)); const hier::Box together(dst_face * src_face * fill_face); if (!together.empty()) { // Add lower face intersection (if any) to the box list hier::Box low_face(src_face); low_face.setUpper(0, low_face.lower(0)); //+ghosts; hier::Box low_overlap(low_face * msk_face * dst_face); if (!low_overlap.empty()) { dst_boxes[d].pushBack(low_overlap); } // Add upper face intersection (if any) to the box list hier::Box hig_face(src_face); hig_face.setLower(0, hig_face.upper(0)); //-ghosts; hier::Box hig_overlap(hig_face * msk_face * dst_face); if (!hig_overlap.empty()) { dst_boxes[d].pushBack(hig_overlap); } // Take away the interior of over_write interior is not set if (!overwrite_interior) { dst_boxes[d].removeIntersections( FaceGeometry::toFaceBox(dst_geometry.getBox(), d)); } } // if (!together.empty()) if (!dst_restrict_boxes.empty() && !dst_boxes[d].empty()) { hier::BoxContainer face_restrict_boxes; for (hier::BoxContainer::const_iterator b = dst_restrict_boxes.begin(); b != dst_restrict_boxes.end(); ++b) { face_restrict_boxes.pushBack(FaceGeometry::toFaceBox(*b, d)); } dst_boxes[d].intersectBoxes(face_restrict_boxes); } } // loop over dim } // if (!quick_check.empty()) // Create the face overlap data object using the boxes and source shift return boost::make_shared<FaceOverlap>(dst_boxes, transformation); }
bool FaceGeometry::operator==(const FaceGeometry& rhs) const { return (this->getVertexCount() == rhs.getVertexCount()); }