Objects in instance-variable list not being retained? Pointer issues? - c++

Question

I have a global variable vector<BezierPatch*> listOfBezierPatches that I populate from a command line parsing function. I then have a series of methods that populates two instance variable lists of a BezierPatch:
// final list of subdivided triangles, ready to feed to OpenGL display system
std::vector<Triangle*> listOfTriangles;
// list of differential geometries (i.e. points) that we are evaluating the given patch at
std::vector<DifferentialGeometry*> listOfDifferentialGeometries;
main.cpp:
void parseBezierFile(string filename) {
...
BezierPatch* currentBezierPatch = new BezierPatch();
while (getline(file, str)) {
...
vector<Eigen::Vector3f> bezierCurve;
bezierCurve.push_back(vector_from_command_line);
...
currentBezierPatch->addCurve(bezierCurve);
...
listOfBezierPatches.push_back(currentBezierPatch);
}
perform_subdivision();
}
void perform_subdivision() {
// Iterate through each of the Bezier patches...
for (std::vector<BezierPatch*>::size_type i = 0; i < listOfBezierPatches.size(); i++) {
BezierPatch currentBezierPatch = *(listOfBezierPatches[i]);
currentBezierPatch.performUniformSubdivision(subdivisionParameter);
}
}
BezierPatch.h:
void performUniformSubdivision(float stepSize) {
int numberOfSteps = 1.0 / stepSize;
for (int u = 0; u < numberOfSteps; u++) {
for (int v = 0; v < numberOfSteps; v++) {
listOfDifferentialGeometries.push_back(evaluateDifferentialGeometry(u * stepSize, v * stepSize));
}
}
// Iterate through all of our differential geometries, but do NOT touch the right-most column and the bottom-most row
for (int u = 0; u < (numberOfSteps - 1); u++) {
for (int v = 0; v < (numberOfSteps - 1); v++) {
// (u, v) represents the index in the above grid that we're triangulating
// This index represents the TOP LEFT corner of the 4-point rectangle that is described above
// Index of listOfDifferentialGeometries that corresponds with position (u, v)
int differentialGeometrixIndex = (u * numberOfSteps) + v;
// Construct tri-1
listOfTriangles.push_back(new Triangle(
*listOfDifferentialGeometries[differentialGeometrixIndex], // top left
*listOfDifferentialGeometries[differentialGeometrixIndex + numberOfSteps], // move one unit right
*listOfDifferentialGeometries[differentialGeometrixIndex + 1])); // move one unit down from top left
// Construct tri-2
listOfTriangles.push_back(new Triangle(
*listOfDifferentialGeometries[differentialGeometrixIndex + numberOfSteps], // top right
*listOfDifferentialGeometries[differentialGeometrixIndex + 1], // bottom left
*listOfDifferentialGeometries[differentialGeometrixIndex + numberOfSteps + 1])); // bottom right
}
}
// We should have (numberOfSteps - 1) * (numberOfSteps - 1) * 2 triangles
}
DifferentialGeometry* evaluateDifferentialGeometry(float u, float v) {
...
return new DifferentialGeometry(finalVCurve.point, normal, Eigen::Vector2f(u, v));
}
The problem:
After all of the above code has been run, if I iterate through the BezierPatches in listOfBezierPatches, the listOfTriangles and listOfDifferentialGeometries are both empty. I know this is obviously something to do with local pointers/variables, but I can't seem to figure it out. Here's a detailed look at the perform_subdivision method, where the problem occurs:
void perform_subdivision(bool adaptive_subdivision) {
// Iterate through each of the Bezier patches...
for (std::vector<BezierPatch*>::size_type i = 0; i < listOfBezierPatches.size(); i++) {
BezierPatch currentBezierPatch = *(listOfBezierPatches[i]);
currentBezierPatch.performUniformSubdivision(subdivisionParameter);
// ***** TESTING: This successfully prints out our differential geometries ***** //
// Iterate through Triangles in the current Bezier patch
for (std::vector<DifferentialGeometry>::size_type j = 0; j < currentBezierPatch.listOfDifferentialGeometries.size(); j++) {
DifferentialGeometry* currentDifferentialGeometry = currentBezierPatch.listOfDifferentialGeometries[j];
cout << " DifferentialGeometry " << (j + 1) << ":\n";
Eigen::Vector3f currentPosition = currentDifferentialGeometry->position;
cout << " (" << currentPosition.x() << " , " << currentPosition.y() << " , " << currentPosition.z() << ")\n";
}
// This does NOT successfully print out our differential geometries...
printDifferentialGeometriesInBezierPatches();
}
}
}
where printDifferentialGeometriesInBezierPatches() is defined as:
//****************************************************
// function that prints all differential geometries in every Bezier Patch
//***************************************************
void printDifferentialGeometriesInBezierPatches() {
if (debug) {
// Iterate through Bezier Patches
for (std::vector<BezierPatch*>::size_type i = 0; i < listOfBezierPatches.size(); i++) {
cout << " Bezier patch " << (i + 1) << ":\n\n";
// Iterate through Triangles in the current Bezier patch
for (std::vector<DifferentialGeometry>::size_type j = 0; i < listOfBezierPatches[i]->listOfDifferentialGeometries.size(); j++) {
DifferentialGeometry* currentDifferentialGeometry = listOfBezierPatches[i]->listOfDifferentialGeometries[j];
cout << " DifferentialGeometry " << (j + 1) << ":\n";
Eigen::Vector3f currentPosition = currentDifferentialGeometry->position;
cout << " (" << currentPosition.x() << " , " << currentPosition.y() << " , " << currentPosition.z() << ")\n";
}
}
}
}
Any suggestions would be greatly appreciated. Thanks!

Answer 1

Maybe your problem in the next line in perform_subdivision
BezierPatch currentBezierPatch = *(listOfBezierPatches[i]);
For each element you create a copy which removed in the end of the loop
void perform_subdivision() {
// Iterate through each of the Bezier patches...
for (std::vector<BezierPatch*>::size_type i = 0; i < listOfBezierPatches.size(); i++) {
// ! Here you create a copy of i-th element
BezierPatch currentBezierPatch = *(listOfBezierPatches[i]);
// populate its memebers
currentBezierPatch.performUniformSubdivision(subdivisionParameter);
}
}
I guess this would be correct
void perform_subdivision() {
// Iterate through each of the Bezier patches...
for (std::vector<BezierPatch*>::size_type i = 0; i < listOfBezierPatches.size(); i++) {
BezierPatch* currentBezierPatch = listOfBezierPatches[i];
currentBezierPatch->performUniformSubdivision(subdivisionParameter);
}
}