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