// Class defintion header file for class Field and derived classes FieldSyn (Field_2.h)
// FieldSyn has additional private member arrays (X,Y)
// to be initialised via public arrays aY and aX
// Arrays are now initialised by passing appropriate pointer address and looping
// 

#include <iostream>
#include <cstdlib>


using namespace std;

class Field
{
protected:
    int LeafPairs;
    int LeafWidth;
    int GantryAngle;
    int CollimatorAngle;
    double MonitorUnits;
public:
    // constructor
Field(){
		LeafPairs=GantryAngle=CollimatorAngle=0;
		MonitorUnits=0.0;
	}
    virtual ~Field(){};// Virtual function dynamically determined at runtime (can be overwritten in derived class)
	//new constructor for dynamic memory allocation - must be parameterless
	

    //accessors/member functions
    void SetGantryAngle (int Gantry) { GantryAngle=Gantry;}
    void SetCollimatorAngle (int Colli) { CollimatorAngle=Colli;}
    void SetMonitorUnits (double MU) { MonitorUnits=MU;}
    int GetLeafPairs () const {return LeafPairs;}
    int GetLeafWidth () const {return LeafWidth;}
    int GetGantryAngle () const {return GantryAngle;}
    int GetCollimatorAngle () const {return CollimatorAngle;}
    double GetMonitorUnits () const {return MonitorUnits;}
};

class FieldSyn: public Field
{
private:
    int X[80], Y[41]; 
public:
    //constructor and destructor
    // constructor initialises values and arrays
	FieldSyn(){
		LeafPairs=40;
		LeafWidth=4;
		
    }
	int aX[80], aY[41]; // public arrays for Leaf position (aX) and Leaf boundary (aY)
    //destructor
    virtual ~FieldSyn(){};// Virtual function dynamically determined at runtime (can be overwritten in derived class)

	//accessors for arrays
	void SetYPosition (int *pY) {
		for (int i=0;i<LeafPairs+1;i++){
			aY[i]=*pY;
			pY++;//advance pointer
		}
	pY=pY-(LeafPairs+1);// reset pointer
	}
	void SetXPosition (int *pX) {
		for (int i=0;i<2*LeafPairs;i++){
			aX[i]=*pX;

			pX++;//advance pointer
		}
	pX=pX-(2*LeafPairs);// reset pointer
	}

	void GetYPosition () const {
		for(int i=0;i<LeafPairs+1;i++){
			cout << aY[i] << "\\";}
		cout <<endl;}

	void GetXPosition () const {
		for(int i=0;i<2*LeafPairs;i++){
			cout <<  aX[i] << "\\";}
		cout << endl;}

	
};

// Class defintion for simple derived class FieldSyn
// Derived from Field
// FieldSyn has additional private member arrays
// to be initialised
// Modified to "dynamically" create instances of Field objects at runtime
// In final program value of Beams will be read in from DICOM RT PLAN file
// 

#include <iostream>
#include <cstdlib>
#include"Field_2.h"

using namespace std;


int main()
{

	int *NumBeams=0, Beams=9;// max 9 for testing purposes
	int *NumSegm=0, Segments=3; // needed for 2D dynamic array
	
	// define static input arrays for Gantry-, Collimator angle and MUs (testing purposes ONLY)

	int GAngle[]={0,20,40,80,120,240,280,320,340}, *pGAngle=0; // pointer to array elements
	int CAngle[]={1,3,5,7,5,3,1,3,5}, *pCAngle=0; // pointer to array elements
	double MU[]={5.76,
				10.34,
				17.36,
				25.01,
				35.43,
				42.17,
				47.32,
	            49.27,
				55.00}, *pMU=0; 
	int YPos[] ={-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}, *pY=0; // Synergy MLC
	int XPos[] ={110,110,110,110,110,110,110,110,
	  110,110,110,110,110,110,110,110,
	  110,110,110,110,110,110,110,110,
	  50,50,50,50,50,50,50,50,
	  80,80,80,80,80,80,80,80,
	  90,90,90,90,90,90,90,90,
	  30,30,30,30,30,30,30,30,
	  110,110,110,110,110,110,110,110,
	  110,110,110,110,110,110,110,110,
	  110,110,110,110,110,110,110,110},*pX;//pointer to array elements Synergy

//  Initialise pointers
	pX=&XPos[0];
	pY=&YPos[0];
	pGAngle=&GAngle[0];
	pCAngle=&CAngle[0];
	pMU=&MU[0];
	NumBeams=&Beams;
	NumSegm=&Segments;// set ptr NumBeams to address of Beams variable


	FieldSyn **pBeam = new FieldSyn*[Beams]; // rows=Beams : dynamically allocate 2D array of FieldSyn objects
	for (int j=0;j<Beams;j++){
		pBeam[j]=new FieldSyn[Segments]; // column of Beam objects: Segments

/*	try{
		pBeam=new FieldSyn[*NumBeams];
	} catch (bad_alloc xa){
		cout << "Allocation failure\n";
		return 1;
	}
/*  Loop over all Beams to set gantry and collimator angle, MUs etc.
*/  cout << "\nBeam : " << j << endl;
    for(int i=0;i<Segments;i++){
	
	
	cout << "\nSegment: " << i << endl;

	pBeam[j]->SetGantryAngle(*pGAngle);
    cout << "Gantry Angle : " << pBeam[j]->GetGantryAngle() << endl;

    pBeam[j]->SetCollimatorAngle(*pCAngle);
    cout << "Collimator Angle : " << pBeam[j]->GetCollimatorAngle() << endl;

    pBeam[j]->SetMonitorUnits(*pMU);
    cout << "Monitor Units : " << pBeam[j]->GetMonitorUnits() << endl;

	cout << "Leaf width : " << pBeam[j]->GetLeafWidth() << endl;
	cout << "Leaf pairs: " << pBeam[j]->GetLeafPairs() << endl;

	pBeam[j]->SetYPosition(pY); // try to initialise values with accessor
	cout << "Leaf Y position: " << endl;
	pBeam[j]->GetYPosition(); // return Y positions
	
	pBeam[j]->SetXPosition(pX);
	cout << "Leaf X position: " << endl;
	pBeam[j]->GetXPosition();
//  Advance pointers
//	pGAngle++;
//	pCAngle++; 
	pMU++;
	
	}
	// reset pointers
	pGAngle++;
	pCAngle++;
//	pGAngle=pGAngle-Segments;
//	pCAngle=pCAngle-Segments;
	pMU=pMU-Segments;
	// advance pointer pBeam;
	pBeam++; }

	//pBeam=pBeam-Beams; // reset pBeam pointer

	cout<< endl;

    delete [] pBeam[j];
	delete [] pBeam;// calls FieldSyn destructor and releases memory (avoid memory "leak")
	return 0;

}

// Allocate the array of arrays
FieldSyn **pBeam = new FieldSyn*[Beams];

// Allocate each individual array
for (int j=0;j<Beams;j++) 
{
  pBeam[j]=new FieldSyn[Segments];
}





// Now, you have a 2D array of FieldSyn objects
// ....





// Delete each individual array
for (int j=0;j<Beams;j++) 
{
  delete[] pBeam[j];
}

// Delete the array of arrays
delete[] pBeam;

    FieldSyn **pBeam = new FieldSyn*[Beams];
    for (int j = 0; j < Beams; j++) {
.
.
.
    pBeam[j]->SetGantryAngle(*pGAngle);
.
.
.
    pBeam++;}