Slicer::Slicer(OptimizedVolume* ov, int32_t initial, int32_t thickness, bool keepNoneClosed, bool extensiveStitching)
{
modelSize = ov->model->modelSize;
modelMin = ov->model->vMin;
int layerCount = (modelSize.z - initial) / thickness + 1;
fprintf(stdout, "Layer count: %i\n", layerCount);
layers.resize(layerCount);
for(unsigned int i=0; i<ov->faces.size(); i++)
{
Point3 p0 = ov->points[ov->faces[i].index[0]].p;
Point3 p1 = ov->points[ov->faces[i].index[1]].p;
Point3 p2 = ov->points[ov->faces[i].index[2]].p;
int32_t minZ = p0.z;
int32_t maxZ = p0.z;
if (p1.z < minZ) minZ = p1.z;
if (p2.z < minZ) minZ = p2.z;
if (p1.z > maxZ) maxZ = p1.z;
if (p2.z > maxZ) maxZ = p2.z;
for(int32_t layerNr = (minZ - initial) / thickness; layerNr <= (maxZ - initial) / thickness; layerNr++)
{
int32_t z = layerNr * thickness + initial;
if (z < minZ) continue;
if (layerNr < 0) continue;
SlicerSegment s;
if (p0.z < z && p1.z >= z && p2.z >= z)
s = project2D(p0, p2, p1, z);
else if (p0.z > z && p1.z < z && p2.z < z)
s = project2D(p0, p1, p2, z);
else if (p1.z < z && p0.z >= z && p2.z >= z)
s = project2D(p1, p0, p2, z);
else if (p1.z > z && p0.z < z && p2.z < z)
s = project2D(p1, p2, p0, z);
else if (p2.z < z && p1.z >= z && p0.z >= z)
s = project2D(p2, p1, p0, z);
else if (p2.z > z && p1.z < z && p0.z < z)
s = project2D(p2, p0, p1, z);
else
{
//Not all cases create a segment, because a point of a face could create just a dot, and two touching faces
// on the slice would create two segments
continue;
}
layers[layerNr].faceToSegmentIndex[i] = layers[layerNr].segmentList.size();
s.faceIndex = i;
s.addedToPolygon = false;
layers[layerNr].segmentList.push_back(s);
}
}
for(unsigned int layerNr=0; layerNr<layers.size(); layerNr++)
{
layers[layerNr].makePolygons(ov, keepNoneClosed, extensiveStitching);
}
}
Slicer::Slicer(Mesh* mesh, int initial, int thickness, int layer_count, bool keep_none_closed, bool extensive_stitching)
{
assert(layer_count > 0);
layers.resize(layer_count);
for(int32_t layer_nr = 0; layer_nr < layer_count; layer_nr++)
{
layers[layer_nr].z = initial + thickness * layer_nr;
}
for(unsigned int mesh_idx = 0; mesh_idx < mesh->faces.size(); mesh_idx++)
{
MeshFace& face = mesh->faces[mesh_idx];
Point3 p0 = mesh->vertices[face.vertex_index[0]].p;
Point3 p1 = mesh->vertices[face.vertex_index[1]].p;
Point3 p2 = mesh->vertices[face.vertex_index[2]].p;
int32_t minZ = p0.z;
int32_t maxZ = p0.z;
if (p1.z < minZ) minZ = p1.z;
if (p2.z < minZ) minZ = p2.z;
if (p1.z > maxZ) maxZ = p1.z;
if (p2.z > maxZ) maxZ = p2.z;
int32_t layer_max = (maxZ - initial) / thickness;
for(int32_t layer_nr = (minZ - initial) / thickness; layer_nr <= layer_max; layer_nr++)
{
int32_t z = layer_nr * thickness + initial;
if (z < minZ) continue;
if (layer_nr < 0) continue;
SlicerSegment s;
if (p0.z < z && p1.z >= z && p2.z >= z)
s = project2D(p0, p2, p1, z);
else if (p0.z > z && p1.z < z && p2.z < z)
s = project2D(p0, p1, p2, z);
else if (p1.z < z && p0.z >= z && p2.z >= z)
s = project2D(p1, p0, p2, z);
else if (p1.z > z && p0.z < z && p2.z < z)
s = project2D(p1, p2, p0, z);
else if (p2.z < z && p1.z >= z && p0.z >= z)
s = project2D(p2, p1, p0, z);
else if (p2.z > z && p1.z < z && p0.z < z)
s = project2D(p2, p0, p1, z);
else
{
//Not all cases create a segment, because a point of a face could create just a dot, and two touching faces
// on the slice would create two segments
continue;
}
layers[layer_nr].face_idx_to_segment_index.insert(std::make_pair(mesh_idx, layers[layer_nr].segmentList.size()));
s.faceIndex = mesh_idx;
s.addedToPolygon = false;
layers[layer_nr].segmentList.push_back(s);
}
}
for(unsigned int layer_nr=0; layer_nr<layers.size(); layer_nr++)
{
layers[layer_nr].makePolygons(mesh, keep_none_closed, extensive_stitching);
}
}
int main(int argc, char** argv) {
std::cout << "**************************************************\n"
<< "*** Introduction to Visual Computing, SS 2015 ***\n"
<< "*** Exercise 03: OpenCV Stub ***\n"
<< "**************************************************\n"
<< "*** Author: Dipl.-Inf. Sven Sickert ***\n"
<< "**************************************************\n\n";
// create a new window
cv::namedWindow("My Image Window", CV_WINDOW_AUTOSIZE || CV_WINDOW_KEEPRATIO);
//cv::Mat img(480, 640, CV_8UC3);
cv::Mat * img = genMatrix();
Object3DListType objects3D;
create3DObject(objects3D);
//Lade Ausgangs-Parameter
std::vector<double> position;
position.push_back(posZ);
position.push_back(posY);
position.push_back(posX);
std::vector<double> direction;
direction.push_back(vZ);
direction.push_back(vY);
direction.push_back(vX);
double focalDistance = FOCAL_DISTANCE;
char key;
bool quit;
//Verschiebe Objekte in einen sichtbaren Bereich
for (Object3DListType::iterator objIt = objects3D.begin(); objIt != objects3D.end(); objIt++) {
for (Point3DListType::iterator pointIt = (*objIt).first.begin(); pointIt != (*objIt).first.end(); pointIt++) {
(*pointIt)[0] += 30;
(*pointIt)[1] += 30;
(*pointIt)[2] += 30;
}
}
do {
key = (char) cv::waitKey();
delete img;
//std::cout << key << " " << std::endl;
std::cout << "--------Position--------" << std::endl;
std::cout << "posX = " << position[0] << std::endl;
std::cout << "posY = " << position[1] << std::endl;
std::cout << "posZ = " << position[2] << std::endl;
std::cout << "vX = " << direction[0] << std::endl;
std::cout << "vY = " << direction[1] << std::endl;
std::cout << "vZ = " << direction[2] << std::endl;
switch (key) {
case 'q':
quit = true;
break;
//--------Position
case 'w':
position[1]++;
break;
case 's':
position[1]--;
break;
case 'a':
position[0]--;
break;
case 'd':
position[0]++;
break;
case 'x':
position[2]++;
break;
case 'y':
position[2]--;
break;
//--------Blickvector
case 'R':
direction[0]++;
break;
case 'Q':
direction[1]--;
break;
case 'T':
direction[0]--;
break;
case 'S':
direction[1]++;
break;
case ',':
direction[2]--;
break;
case '.':
direction[2]++;
break;
}
img = genMatrix();
Object2DListType objects2D = project2D(objects3D, position, direction, focalDistance);
draw2DObjects(*img, objects2D);
cv::imshow("My Image Window", *img);
} while (!quit);
return 0;
}
