Member Avatar for bobsta
bobsta 0 Newbie Poster

I am trying to render multiple scenes in different window. I am confident that the data is correctly read in from the .txt file and used to initialise the Beam and Segment objects (each Beam object comprises >=1 Segment)

However when I attempt to render the scenes the program tries to render segment 2 i.e. a third segment (0,1,...n) which results in a Segmentation fault (crash) g++ (SUSE Linux) 4.3.2 [gcc-4_3-branch revision 141291]

for (segmentsRendered=1;segmentsRendered<1+(pBeam->segments);segmentsRendered++){
	    window[segmentsRendered]=0;
	    sprintf(title,"Segment %d BEV",segmentsRendered);
	    std::cout << "Window title " << segmentsRendered << " is \" " << title << " \"\n";
	    window[segmentsRendered]=glutCreateWindow(title);
	    
	    std::cout << "\nSegment " << segmentsRendered << "\n";
	   
	    glutDisplayFunc(renderScene);
	   //Set handler functions
	    glutKeyboardFunc(handleKeypress);
	    glutReshapeFunc(handleResize);
	  }

void renderScene(){
  
    std::cout << "\nStart rendering scene now with pointer: "<< pBeam << "... ";
      pBeam->renderMLC(segmentsRendered-1);
     
  	glutSwapBuffers();
}

I have tried to localise the problem by printing stuff to the screen.

Found 40 leaf pairs for Beam 0x8054e90

Leaf boundaries : -80 0x8055340 -76 -72 -68 -64 -60 -56 -52 -48 -44 -40 -36 -32 -28 -24 -20 -16 -12 -8 -4 0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80

Parked position : 110

Found 2 segments for this beam

Reading in segment 1 of beam

Leaf positions : 110 110 110 110 110 110 110 110 110 110 110 -4 -15 -18 -17 -15 -19 -16 -24 -23 -22 -20 -20 -22 -23 -24 -27 -29 -28 -29 -27 110 110 110 110 110 110 110 110 110 110 110 110 110 110 110 110 110 110 110 110 27 31 26 15 22 27 29 32 34 33 29 43 44 48 48 51 54 57 13 10 110 110 110 110 110 110 110 110 110

Finished writing segment!
Reading in segment 2 of beam

Leaf positions : 110 110 110 110 110 110 110 110 110 110 110 -4 -3 -15 -17 -15 -12 -16 -16 -24 -22 -17 -14 -21 -23 -24 -27 -28 -28 -29 -27 110 110 110 110 110 110 110 110 110 110 110 110 110 110 110 110 110 110 110 110 8 9 18 9 9 10 8 4 3 4 8 10 10 13 17 15 14 13 13 24 110 110 110 110 110 110 110 110 110

Finished writing segment!
Closing file now !

Will try to render 2 segment(s)
Window title 1 is " Segment 1 BEV "

Segment 1
Window title 2 is " Segment 2 BEV "

Segment 2

Start rendering scene now with pointer: 0x8054e90...
[B]Starting to render BEV for segment 2
[/B]
[3]+  Segmentation fault      ./transform MLC2Seg.txt

I am probably making a fundamental mistake (since I am new to GLUT and OpenGL) but would very much appreciate some assistance.

Thanks

Mark

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cstdlib>
#include <GL/glut.h>
#include "Beam.h"
#include "Segment.h"
Beam::Beam():leafPairs(0),parkedPosition(0),segments(0){
  leafBoundary=leafPosition=NULL;
  //  pSegment=NULL;
  }

Beam::Beam(char *file){
  FILE * pFile;
  char sBuff[32678];
  int i,j;
  //  float pPos;

  pFile = fopen (file , "r");
   if (pFile == NULL) perror ("Error opening file");
   for (i=0;i<4;i++){

  // read in first line of file into sBuff string
  fgets(sBuff,32678,pFile);

  // return number of pairs from sBuff string
  if (i==0) this->setLeafPairs(sBuff);
  
  // now set tokenise leafBoundary string using sBuff and # pairs
  if (i==1) this->setLeafBoundaries(sBuff,leafPairs);
  
  // now read in parked position
  if(i==2)this->setParkedPosition(sBuff);

  // now read in number of segments for this beam
 
  if (i==3) {
    this->setSegments(sBuff);


    pSegment =new Segment*[this->segments];
     for (j=0;j<this->segments;j++){
       std::cout << "\nReading in segment " << j+1 << " of beam\n";
       fgets(sBuff,32678,pFile);
       pSegment[j]=new Segment(this,sBuff);
     }
   }

   }
  std::cout << "\nClosing file now !\n";
  fclose(pFile);
}

Beam::~Beam(){
  if(leafBoundary != NULL) {
		delete [] leafBoundary;
		leafBoundary = NULL;
  }
  if(leafPosition != NULL) {
		delete [] leafPosition;
		leafPosition = NULL;
  }
}
 void Beam::setLeafBoundaries(char *lBoundary, int leafPairs){
  int j;
  
  this->leafBoundary =new float[leafPairs+1];
  for (j=0;j<1+leafPairs;j++){
    leafBoundary[j]=0.0;
   
  }
  std::cout << "\nLeaf boundaries : ";
  this->leafBoundary[0]=atof(strtok(lBoundary,"\\"));
  std::cout << leafBoundary[0] << " " << &leafBoundary[0] << " ";
  for (j=1;j<1+leafPairs;j++){
    this->leafBoundary[j]=atof(strtok(NULL,"\\"));
    std::cout << this->leafBoundary[j] << " ";
 }
  std::cout << "\n";
}

 void Beam::setLeafPositions(char *lPos, int leafPairs){
  
  this->leafPosition=new float[2*leafPairs];
  int k;
  
  this->leafPosition[0]=atof(strtok(lPos,"\\"));
  std::cout << "\nLeaf positions : " << leafPosition[0] << " ";
    for (k=1;k<2*leafPairs;k++){
      this->leafPosition[k]=atof(strtok(NULL,"\\"));
      std::cout << this->leafPosition[k] << " ";
    }
    std::cout<< "\n";
  }

 void Beam::setLeafPairs(char *lPairs){
  this->leafPairs=atoi(strtok(lPairs,"\\"));
  std::cout << "\nFound " << this->leafPairs << " leaf pairs for Beam " << this << "\n";
}

 void Beam::setParkedPosition(char *PP){
  this->parkedPosition=atof(strtok(PP,"\\"));
  std::cout<< "\nParked position : " << this->parkedPosition << "\n";
}
 
void Beam::setSegments(char *seg){
  this->segments=atoi(strtok(seg,"\\"));
  std::cout << "\nFound " << this->segments << " segments for this beam\n";
}

void Beam::renderMLC(){
  int j;//,lP;
  float temp;
  // lP=40;
  GLfloat colours [][3]={
	  {0.0,0.0,0.0}, // black   [0]
	  {1.0,0.0,0.0}, // red     [1]
	  {1.0,1.0,0.0}, // yellow  [2]
	  {1.0,0.0,1.0}, // magenta [3]
	  {0.0,1.0,0.0}, // green   [4]
	  {0.0,1.0,1.0}, // cyan    [5]
	  {1.0,1.0,1.0}, // white   [6]
	  {0.5,0.5,0.5}  // grey    [7]
	  };
  glColor3fv(colours[4]); // set cross-hair colour to green
  //this->renderCrossHair();
  // renderCrossHair();

  glColor3fv(colours[7]); // set leaf colour to grey
  //  std::cout << "\nBeam pointer = " << this;
  for (j=0;j<this->leafPairs;j++){
    temp=0.0;
    //  std::cout << "\nLeafBoundary " << j+1 << ": " << this->leafBoundary[j] << "mm :" << &this->leafBoundary[j];/*
    // }
     // start with the B leaves
    glBegin(GL_LINE_LOOP);
    // glBegin(GL_LINE_LOOP);
    // render anti-clockwise: bottom-left, bottom-right, top-right, top-left
    if (this->leafPosition[j]!=this->parkedPosition) temp=this->leafPosition[j];
    //   else temp=this->leafPosition[j];
    glVertex3f(-400,this->leafBoundary[j],-1000);
    /*    std::cout << "\nRendering B leaf " << j+1 << " : bottom left (-400," << this->leafBoundary[j]<<
              ")->bottom right (" << temp << "," << this->leafBoundary[j] << 
              ")->top right (" << temp << "," << this->leafBoundary[j+1] << 
              ")->top left (-400," << this->leafBoundary[j+1]<< ")\n";*/
    glVertex3f(temp,this->leafBoundary[j],-1000);
    //    cout << "\nLeaf " <<i+j << " = " << leafB[i+j] << "\n"; 
    glVertex3f(temp,this->leafBoundary[j+1],-1000);
    glVertex3f(-400,this->leafBoundary[j+1],-1000);
    glEnd();

    // Now do the A leaves
    glBegin(GL_LINE_LOOP);
    //glBegin(GL_LINE_LOOP);
    // render clockwise : bottom-right, bottom-left, top-left, top-right
    glVertex3f(400,this->leafBoundary[j],-1000);
    if (this->leafPosition[j+this->leafPairs]!=this->parkedPosition) temp=this->leafPosition[j+this->leafPairs];
    
    //glVertex3f(this->leafPosition[j+this->leafPairs],this->leafBoundary[j],-1000); // x-coordinate comes from MLC leaf position array
    //glVertex3f(this->leafPosition[j+this->leafPairs],this->leafBoundary[j+1],-1000);
    glVertex3f(temp,this->leafBoundary[j],-1000); // x-coordinate comes from MLC leaf position array
    glVertex3f(temp,this->leafBoundary[j+1],-1000);
    
    glVertex3f(400,this->leafBoundary[j+1],-1000);
    glEnd();
    }

  	glutSwapBuffers();
}

void Beam::renderMLC(int segNum){
  int j;
  float temp;
  
  GLfloat colours [][3]={
	  {0.0,0.0,0.0}, // black   [0]
	  {1.0,0.0,0.0}, // red     [1]
	  {1.0,1.0,0.0}, // yellow  [2]
	  {1.0,0.0,1.0}, // magenta [3]
	  {0.0,1.0,0.0}, // green   [4]
	  {0.0,1.0,1.0}, // cyan    [5]
	  {1.0,1.0,1.0}, // white   [6]
	  {0.5,0.5,0.5}  // grey    [7]
	  };
  std::cout << "\nStarting to render BEV for segment " << segNum << "\n";
  glColor3fv(colours[4]); // set cross-hair colour to green
  this->renderCrossHair();
  // renderCrossHair();

  glColor3fv(colours[7]); // set leaf colour to grey
  //  std::cout << "\nBeam pointer = " << this;
  for (j=0;j<this->leafPairs;j++){
    temp=0.0;
    //  std::cout << "\nLeafBoundary " << j+1 << ": " << this->leafBoundary[j] << "mm :" << &this->leafBoundary[j];/*
    // }
     // start with the B leaves
    glBegin(GL_LINE_LOOP);
    // glBegin(GL_LINE_LOOP);
    // render anti-clockwise: bottom-left, bottom-right, top-right, top-left
    if (this->pSegment[segNum]->leafPosition[j]!=this->parkedPosition) temp=this->pSegment[segNum]->leafPosition[j];
    //   else temp=this->leafPosition[j];
    glVertex3f(-400,this->leafBoundary[j],-1000);
    /*    std::cout << "\nRendering B leaf " << j+1 << " : bottom left (-400," << this->leafBoundary[j]<<
              ")->bottom right (" << temp << "," << this->leafBoundary[j] << 
              ")->top right (" << temp << "," << this->leafBoundary[j+1] << 
              ")->top left (-400," << this->leafBoundary[j+1]<< ")\n";*/
    glVertex3f(temp,this->leafBoundary[j],-1000);
    //    cout << "\nLeaf " <<i+j << " = " << leafB[i+j] << "\n"; 
    glVertex3f(temp,this->leafBoundary[j+1],-1000);
    glVertex3f(-400,this->leafBoundary[j+1],-1000);
    glEnd();

    // Now do the A leaves
    glBegin(GL_LINE_LOOP);
    //glBegin(GL_LINE_LOOP);
    // render clockwise : bottom-right, bottom-left, top-left, top-right
    glVertex3f(400,this->leafBoundary[j],-1000);
    if (this->pSegment[segNum]->leafPosition[j+this->leafPairs]!=this->parkedPosition) temp=this->pSegment[segNum]->leafPosition[j+this->leafPairs];
    
    //glVertex3f(this->leafPosition[j+this->leafPairs],this->leafBoundary[j],-1000); // x-coordinate comes from MLC leaf position array
    //glVertex3f(this->leafPosition[j+this->leafPairs],this->leafBoundary[j+1],-1000);
    glVertex3f(temp,this->leafBoundary[j],-1000); // x-coordinate comes from MLC leaf position array
    glVertex3f(temp,this->leafBoundary[j+1],-1000);
    
    glVertex3f(400,this->leafBoundary[j+1],-1000);
    glEnd();
    }

  	glutSwapBuffers();
}

void Beam::renderCrossHair(){
glBegin(GL_LINES);
//  int tickLines;
  
  float tickLength=2.5;

  int columns, rows,majorXTicks,minorXTicks, majorYTicks,minorYTicks,i;
  columns=400;
  rows=400;
  majorXTicks=majorYTicks=50;
  minorXTicks=minorYTicks=5;

    /* Vertical tick lines. */
  glVertex3f(0,-0.5*rows,-1000);
  glVertex3f(0,0.5*rows,-1000);
  for (i=-columns*0.5; i<=0.5*columns-1; i++) {
    if (i%majorXTicks==0) { tickLength=5.0;
      
      glVertex3f(i, -tickLength,-1000);
      glVertex3f(i, tickLength,-1000);
    }

    else if(i%minorXTicks==0){ 
      tickLength=2.5;
      glVertex3f(i,-tickLength,-1000);
      glVertex3f(i,tickLength,-1000);
    }
      //     std::cout << i << " ";
  }
    //    std::cout <<"\n";
    /* Horizontal lines. */
  
  glVertex3f(-0.5*columns,0,-1000);
  glVertex3f(0.5*columns,0,-1000);
  for (i=-0.5*rows; i<=0.5*rows-1; i++) {
    if (i%majorYTicks==0) {
      tickLength=5.0;
      glVertex3f(-tickLength,i,-1000);
      glVertex3f(tickLength,i,-1000);
    }
    else if (i%minorYTicks==0){
      tickLength=2.5;
      glVertex3f(-tickLength,i,-1000);
      glVertex3f(tickLength,i,-1000);
    }
      //     std::cout << i << " ";
  }
    //   std::cout << "\n";
  glEnd();
}
#ifndef BEAM_H_
#define BEAM_H_
class Segment;
class Beam{
public:
  float *leafBoundary,*leafPosition,parkedPosition;
  int leafPairs,segments;
  Segment **pSegment;
  Beam();
  Beam(char *file);
  void setLeafBoundaries(char *lBoundary, int pairs);
  void setLeafPositions(char *lPos, int pairs);
  void setLeafPairs(char *lPairs);
  void setParkedPosition(char *PP);
  void setSegments(char *seg);
  void renderCrossHair();
  void renderMLC();
  void renderMLC(int segNum);
  
  ~Beam();
};

#endif /* BEAM_H_ */
#include <cstdlib>
#include <GL/glut.h>
#include <iostream>
#include<cstdio>
#include <ctype.h>
#include <cmath>
#include <ctime>
#include <cstring>
#include <fstream>
#include <cassert>
#include "Beam.h"

#define PI=3.141592653 
#define INV_PI=0.31830988618 
using namespace std;
int segmentsRendered, window[10];
// Global definitions: colours and Beam objects
Beam *pBeam;
	// Define a colour array for ease of specification
	GLfloat colours [][3]={
	  {0.0,0.0,0.0}, // black   [0]
	  {1.0,0.0,0.0}, // red     [1]
	  {1.0,1.0,0.0}, // yellow  [2]
	  {1.0,0.0,1.0}, // magenta [3]
	  {0.0,1.0,0.0}, // green   [4]
	  {0.0,1.0,1.0}, // cyan    [5]
	  {1.0,1.0,1.0}, // white   [6]
	  {0.5,0.5,0.5}  // grey    [7]
	};

// Prototypes
int main(int argc, char * argv[]);
void init();
void handleKeypress(unsigned char key, int x, int y);
void initRendering();
void handleResize(int w, int h);
void renderScene();
void renderSceneAll();

//Called when a key is pressed
void handleKeypress(unsigned char key, int x, int y) {
	switch (key) {
		case 27: //Escape key
			exit(0);
	}
}

//Initializes 3D rendering
void initRendering() {
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_COLOR_MATERIAL);

}

//Called when the window is resized
void handleResize(int w, int h) {
  float height;//,param;
  //  param=0.0005*h;
  height=9.148;
  //height=22.61986; 
  //height=360*INV_PI;
	glViewport(0, 0, w, h);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(height, (double)w / (double)h, 800.0, 1500.0);
}

void init(){
  glClearColor(0.0,0.0,0.0,1.0);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	
	glMatrixMode(GL_MODELVIEW); //Switch to the drawing perspective
		glLoadIdentity(); //Reset the drawing perspective
		/*		glTranslatef(0.0f, 0.0f, -1000); //Move forward Z (mm) units
	glRotatef(0.0, 0.0f, 0.0f, 1.0f); //Rotate "camera" about the z-axis (collimator)
	glRotatef(-100.0, 0.0f, 1.0f, 0.0f); //Rotate the "camera" by camera_angle about y-axis (gantry)
	glRotatef (90.0f,1.0f,0.0f,0.0f); // rotate "camera" by 90 degrees about x-axis
	glTranslatef(-11.0f,189.0f,51.0f); //re-define origin of world coordinates to be (11,-189,-51) - applied to all polygon vertices
	glLoadIdentity();*/

}



void renderScene(){
  
    std::cout << "\nStart rendering scene now with pointer: "<< pBeam << "... ";
      pBeam->renderMLC(segmentsRendered-1);
     
  	glutSwapBuffers();
}
void renderSceneAll(){
  
  std::cout << "Segment " << segmentsRendered << " will now be rendered with renderMLC(" << segmentsRendered <<")\n";
     pBeam->renderMLC(segmentsRendered);
     
  	glutSwapBuffers();
}

int main(int argc, char * argv[]){
  //  int j;
  pBeam=NULL;
  char title[50];
  //  int window[10];// hard code maximum of 10 windows
  
  
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
	glutInitWindowSize(400, 400); // 210 x 160 for Syn

	
	pBeam=new Beam(argv[1]);
	
	
	initRendering();
	init();
	
	
	std::cout << "\nWill try to render " << pBeam->segments << " segment(s) \n";

	for (segmentsRendered=1;segmentsRendered<1+(pBeam->segments);segmentsRendered++){
	    window[segmentsRendered]=0;
	    sprintf(title,"Segment %d BEV",segmentsRendered);
	    std::cout << "Window title " << segmentsRendered << " is \" " << title << " \"\n";
	    window[segmentsRendered]=glutCreateWindow(title);
	    
	    std::cout << "\nSegment " << segmentsRendered << "\n";
	   
	    glutDisplayFunc(renderScene);
	   //Set handler functions
	    glutKeyboardFunc(handleKeypress);
	    glutReshapeFunc(handleResize);
	  }
	 

	glutMainLoop();

	std::cout << " done!";
	delete pBeam;
	std::cout << "\nBeam object destructuted!\n";
	return 0;

}
40
-80\-76\-72\-68\-64\-60\-56\-52\-48\-44\-40\-36\-32\-28\-24\-20\-16\-12\-8\-4\0\4\8\12\16\20\24\28\32\36\40\44\48\52\56\60\64\68\72\76\80
110
2
110\110\110\110\110\110\110\110\110\110\110\-4\-15\-18\-17\-15\-19\-16\-24\-23\-22\-20\-20\-22\-23\-24\-27\-29\-28\-29\-27\110\110\110\110\110\110\110\110\110\110\110\110\110\110\110\110\110\110\110\110\27\31\26\15\22\27\29\32\34\33\29\43\44\48\48\51\54\57\13\10\110\110\110\110\110\110\110\110\110
110\110\110\110\110\110\110\110\110\110\110\-4\-3\-15\-17\-15\-12\-16\-16\-24\-22\-17\-14\-21\-23\-24\-27\-28\-28\-29\-27\110\110\110\110\110\110\110\110\110\110\110\110\110\110\110\110\110\110\110\110\8\9\18\9\9\10\8\4\3\4\8\10\10\13\17\15\14\13\13\24\110\110\110\110\110\110\110\110\110]
#include "Segment.h"
#include<cstdio>
#include<cstring>
#include<iostream>
#include<cstdlib>
#include <GL/glut.h>
#include "Beam.h"
Segment::Segment(){
  this->leafPosition=NULL;
}

Segment::Segment(Beam *b, char *lPos):parentBeam(b){
   // float *leafPosition;
  this->leafPosition=new float[2*parentBeam->leafPairs];
  int k;
  
  this->leafPosition[0]=atof(strtok(lPos,"\\"));
  std::cout << "\nLeaf positions : " << leafPosition[0] << " ";
    for (k=1;k<2*parentBeam->leafPairs;k++){
      this->leafPosition[k]=atof(strtok(NULL,"\\"));
      std::cout << this->leafPosition[k] << " ";
    }
    std::cout<< "\n";
    std::cout << "\nFinished writing segment!";
  }
  
Segment::~Segment(){
 if(leafPosition != NULL) {
		delete [] leafPosition;
		leafPosition = NULL;
  }
}
#ifndef SEGMENT_H_
#define SEGMENT_H_

class Beam;
class Segment{
public:
  float *leafPosition;
  Beam *parentBeam;
  Segment();
  Segment(Beam *b, char *lPos);
  /*  void setLeafBoundaries(char *lBoundary, int pairs);
  void setLeafPositions(char *lPos, int pairs);
  void setLeafPairs(char *lPairs);
  void setParkedPosition(char *PP);
  void setSegments(char *seg);
  void renderCrossHair();*/
  
  void renderMLC();
  
  ~Segment();
};

#endif /* SEGMENT_H_ */
  • 1 Contributor
  • 0 Replies
  • 72 Views
Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.