raytracegroundup_v1.8_TriangleMesh_20170306

// Copyright (C) Kevin Suffern 2000-2007. // This C++ code is for non-commercial purposes only. // This C++ code is licensed under the GNU General Public License Version 2. // See the file COPYING.txt for the full license. // This file contains the definition of the Grid class #include <iostream> #include <vector> #include <math.h> #include "Constants.h" #include "Vector3D.h" #include "Point3D.h" #include "Grid.h" //#include "MeshTriangle.h" //#include "FlatMeshTriangle.h" //#include "SmoothMeshTriangle.h" //#include "FlatUVMeshTriangle.h" //#include "SmoothUVMeshTriangle.h" #include "Triangle.h" #include "SmoothTriangle.h" //#include "ply.h" typedef enum { flat, smooth } TriangleType; // ---------------------------------------------------------------- default constructor Grid::Grid(void) : Compound(), nx(0), ny(0), nz(0) // mesh_ptr(new Mesh), // reverse_normal(false) { // The cells array will be empty } // ---------------------------------------------------------------- constructor // for rendering triangle meshes Grid::Grid(Mesh* _mesh_ptr) : Compound(), nx(0), ny(0), nz(0) // mesh_ptr(_mesh_ptr), // reverse_normal(false) { // The cells array will be empty } // ---------------------------------------------------------------- clone Grid* Grid::clone(void) const { return (new Grid (*this)); } // ---------------------------------------------------------------- copy constructor // not implemented Grid::Grid(const Grid& grid) {} // ---------------------------------------------------------------- assignment operator // not implemented Grid& Grid::operator= (const Grid& rhs) { return (*this); } // ---------------------------------------------------------------- destructor // not implemented Grid::~Grid(void) {} BBox Grid::get_bounding_box(void) { return (bbox); } //------------------------------------------------------------------ setup_cells void Grid::setup_cells(void) { // find the minimum and maximum coordinates of the grid Point3D p0 = find_min_bounds(); Point3D p1 = find_max_bounds(); bbox.x0 = p0.x; bbox.y0 = p0.y; bbox.z0 = p0.z; bbox.x1 = p1.x; bbox.y1 = p1.y; bbox.z1 = p1.z; // compute the number of grid cells in the x, y, and z directions int num_objects = objects.size(); // dimensions of the grid in the x, y, and z directions double wx = p1.x - p0.x; double wy = p1.y - p0.y; double wz = p1.z - p0.z; double multiplier = 2.0; // multiplyer scales the number of grid cells relative to the number of objects double s = pow(wx * wy * wz / num_objects, 0.3333333); nx = multiplier * wx / s + 1; ny = multiplier * wy / s + 1; nz = multiplier * wz / s + 1; // set up the array of grid cells with null pointers int num_cells = nx * ny * nz; cells.reserve(num_objects); for (int j = 0; j < num_cells; j++) cells.push_back(NULL); // set up a temporary array to hold the number of objects stored in each cell vector<int> counts; counts.reserve(num_cells); for (int j = 0; j < num_cells; j++) counts.push_back(0); // put the objects into the cells BBox obj_bBox; // object's bounding box int index; // cell's array index for (int j = 0; j < num_objects; j++) { obj_bBox = objects[j]->get_bounding_box(); // compute the cell indices at the corners of the bounding box of the object int ixmin = clamp((obj_bBox.x0 - p0.x) * nx / (p1.x - p0.x), 0, nx - 1); int iymin = clamp((obj_bBox.y0 - p0.y) * ny / (p1.y - p0.y), 0, ny - 1); int izmin = clamp((obj_bBox.z0 - p0.z) * nz / (p1.z - p0.z), 0, nz - 1); int ixmax = clamp((obj_bBox.x1 - p0.x) * nx / (p1.x - p0.x), 0, nx - 1); int iymax = clamp((obj_bBox.y1 - p0.y) * ny / (p1.y - p0.y), 0, ny - 1); int izmax = clamp((obj_bBox.z1 - p0.z) * nz / (p1.z - p0.z), 0, nz - 1); // add the object to the cells for (int iz = izmin; iz <= izmax; iz++) // cells in z direction for (int iy = iymin; iy <= iymax; iy++) // cells in y direction for (int ix = ixmin; ix <= ixmax; ix++) { // cells in x direction index = ix + nx * iy + nx * ny * iz; if (counts[index] == 0) { cells[index] = objects[j]; counts[index] += 1; // now = 1 } else { if (counts[index] == 1) { Compound* compound_ptr = new Compound; // construct a compound object compound_ptr->add_object(cells[index]); // add object already in cell compound_ptr->add_object(objects[j]); // add the new object cells[index] = compound_ptr; // store compound in current cell counts[index] += 1; // now = 2 } else { // counts[index] > 1 cells[index]->add_object(objects[j]); // just add current object counts[index] += 1; // for statistics only } } } } // end of for (int j = 0; j < num_objects; j++) // erase the Compound::vector that stores the object pointers, but don't delete the objects objects.erase (objects.begin(), objects.end()); // display some statistics on counts // this is useful for finding out how many cells have no objects, one object, etc // comment this out if you don't want to use it int num_zeroes = 0; int num_ones = 0; int num_twos = 0; int num_threes = 0; int num_greater = 0; for (int j = 0; j < num_cells; j++) { if (counts[j] == 0) num_zeroes += 1; if (counts[j] == 1) num_ones += 1; if (counts[j] == 2) num_twos += 1; if (counts[j] == 3) num_threes += 1; if (counts[j] > 3) num_greater += 1; } cout << "num_cells =" << num_cells << endl; cout << "numZeroes = " << num_zeroes << " numOnes = " << num_ones << " numTwos = " << num_twos << endl; cout << "numThrees = " << num_threes << " numGreater = " << num_greater << endl; // erase the temporary counts vector counts.erase (counts.begin(), counts.end()); } //------------------------------------------------------------------ find_min_bounds // find the minimum grid coordinates, based on the bounding boxes of all the objects Point3D Grid::find_min_bounds(void) { BBox object_box; Point3D p0(kHugeValue); int num_objects = objects.size(); for (int j = 0; j < num_objects; j++) { object_box = objects[j]->get_bounding_box(); if (object_box.x0 < p0.x) p0.x = object_box.x0; if (object_box.y0 < p0.y) p0.y = object_box.y0; if (object_box.z0 < p0.z) p0.z = object_box.z0; } p0.x -= kEpsilon; p0.y -= kEpsilon; p0.z -= kEpsilon; return (p0); } //------------------------------------------------------------------ find_max_bounds // find the maximum grid coordinates, based on the bounding boxes of the objects Point3D Grid::find_max_bounds(void) { BBox object_box; Point3D p1(-kHugeValue); int num_objects = objects.size(); for (int j = 0; j < num_objects; j++) { object_box = objects[j]->get_bounding_box(); if (object_box.x1 > p1.x) p1.x = object_box.x1; if (object_box.y1 > p1.y) p1.y = object_box.y1; if (object_box.z1 > p1.z) p1.z = object_box.z1; } p1.x += kEpsilon; p1.y += kEpsilon; p1.z += kEpsilon; return (p1); } #if 0 // The following functions read a file in PLY format, and construct mesh triangles where the data is stored // in the mesh object // They are just small wrapper functions that call the functions read_ply_file or read_uv_ply_file that // do the actual reading // These use the PLY code by Greg Turk to read the PLY file // ----------------------------------------------------------------------------- read_flat_triangles void Grid::read_flat_triangles(char* file_name) { read_ply_file(file_name, flat); } // ----------------------------------------------------------------------------- read_smooth_triangles void Grid::rea