Ejemplo n.º 1
0
 Shapes* Shapes::clone()
 {
     Shapes *newShapes = new Shapes();
     newShapes->setMarkers(markers);
     newShapes->setHierarchy(hierarchy);
     newShapes->setContours(contours);
     return newShapes;
 }
Ejemplo n.º 2
0
int main()
{
   Shapes shapes;
   shapes.push_back(std::make_shared<Rectangle>(1,2));
   shapes.push_back(std::make_shared<Rectangle>(3,4));
   shapes.push_back(std::make_shared<Square>(2));
   shapes.push_back(std::make_shared<Square>(3));

   GeometricCalculator geometricCalculator(shapes);
   std::cout<<"summed area is equal: " << geometricCalculator.calculateSumArea() << std::endl;

}
Ejemplo n.º 3
0
int main(void)
{
  char* g_image_filename="images/lena.jpg";
  Mat src = imread( g_image_filename, 1 );
  if (src.empty()) {
    std::cout << "!!! Failed imread()\n ./colors <image filename>" << std::endl;
    return -1;
  }  

  DrawWindow WIPC = DrawWindow(src.cols,src.rows,"IPC countours"); // w,h
  Shapes SIPC;
  ImageParserContours IPC;
  if (1) {
    IPC.setMinContourLength(5);
    IPC.setCannyThreshold(50);
    IPC.parseImage(src);
    IPC.useRandomColors(1);
    //IPC.draw(); // 
    IPC.defineShapes(&SIPC);
    //IPC.printImageData(1);
    
    WIPC.clearWindow(230,230,230); // default background is white
    SIPC.drawAll(&WIPC);
    WIPC.show();
  }

  DrawWindow WIPK = DrawWindow(src.cols,src.rows,"IPK pixel regions"); // w,h
  Shapes SIPK;
  ImageParserKmeans IPK;
  if (1) {
    IPK.setMinPixelsInRegion(5);
    IPK.parseImage(src);
    IPK.useRandomColors(1);
    IPK.draw();
    IPK.defineShapes(&SIPK);
    //  IPC.printImageData(1);
    
    WIPK.clearWindow(230,230,230); // default background is white
    SIPK.drawAll(&WIPK);
    WIPK.show();
  }

  while (1) {
    int k = waitKey(33);
    if (k==27) { // Esc key to stop
      return(0);
    }
  }

   return 0;
}
Ejemplo n.º 4
0
//---------------------------------------------------------------------------- init
// OpenGL initialization
void
init()
{
    calcUVN(VPN, VUP);

    program = InitShader( "/home/GONZAGA/rdraper/Desktop/Ada/Lrdraperjhaddock2FinalProj/vshader53.glsl", "//home/GONZAGA/rdraper/Desktop/Ada/Lrdraperjhaddock2FinalProj/fshader53.glsl" );  // gouraud shading

    glUseProgram( program );

    // Uniform variables: color and viewing parameters
    model_color = glGetUniformLocation( program, "model_color" );
    model_view = glGetUniformLocation( program, "model_view" );
    projection = glGetUniformLocation( program, "projection" );

    lightSetUp();
    myBasketball.createVAO(program);
    shapes.createVAO(program);
    land.createVAO(program);

    glUniform4fv( model_color, 1,vec4(1,1,1,1) ); // set color to white initially

    glLineWidth(1);
    glEnable( GL_DEPTH_TEST );
    glClearColor( 0.5, 0.5, 0.5, 1.0 );
    printControls();
    cout << "Shooter Pause: On -- press middle mouse button to toggle off" << endl;
}
Ejemplo n.º 5
0
int main() {
	/*
	Square squ1;
	Triangle tri1;
	Shapes* ptr1 = &squ1;
	Shapes* ptr2 = &tri1;
	ptr1->set_values(2, 4);
	ptr2->set_values(5, 10);
	*/
	// Because of polymorphism every derived class can be made by pointers

	Shapes* rect = new Square(5, 4);
	Shapes* tria = new Triangle(5, 4);
	rect->printarea();
	tria->printarea();
	delete rect;
	delete tria;
	return 0;
}
Ejemplo n.º 6
0
BodyCreator::Shapes BodyCreator::m_ProcessConvex(const Shape& points)
{
	assert(points.size() > b2_maxPolygonVertices);
	Shapes output;
	const sf::Uint16 maxVerts = b2_maxPolygonVertices - 2u;
	const sf::Uint16 shapeCount = static_cast<sf::Uint16>(std::floor(points.size() / maxVerts));
	const sf::Uint16 s = points.size();

	for (auto i = 0u; i <= shapeCount; i++)
	{
		Shape shape;
		sf::Uint16 total = 0u;
		for (auto j = 0u; j < maxVerts; j++)
		{
			sf::Uint16 index = i * maxVerts + j;
			if (i) index--;
			if (index < s)
				shape.push_back(points[index]);
			else
				break;
		}
		output.push_back(shape);
	}


	//join ends
	Shape& shape = output[output.size() - 2];
	output.back().push_back(output.front().front());
	output.back().push_back(shape.back());

	return output;
}
int main(int argc, char **argv) {
    int diff, old_score, new_score;
    struct timeval start;
    gettimeofday(&start,NULL);
    Shapes s;
    s.readFile(argc, argv);
    s.buildConflictArray();
    Graphs g;
    g.buildConflictGraph(s.getShapes());
    s.findBoundingBox();
    Windows w;
    w.createWindow();
    w.countArea(s.getShapes(), g.getGraphs());
    g.countTotalColorDiff();

    Calculate c;
    //c.printResult(s.getShapes(), g.getGraphs(), w.getWindows(), argc, argv);
    //printf("real score : %.2f\n\n\n", c.real_score(w.getWindows()));

    //std::vector<Graph> &gg = g.getGraphs();
    //c.changeGraphColor(w.getWindows(), g.getGraphs()[0]);
    //c.changeGraphColor(w.getWindows(), g.getGraphs()[0]);
    //c.changeGraphColor(w.getWindows(), g.getGraphs()[2]);
    c.initial_total_color_diff(&g, g.getGraphs(), w.getWindows());
    //c.printResult(s.getShapes(), g.getGraphs(), w.getWindows(), argc, argv);
    //printf("real score : %.2f\n\n\n", c.real_score(w.getWindows()));

    for (int group_id = 0; group_id < c.group_size; group_id++) {
        c.iterative_sol(g.getGraphs(), w.getWindows(), group_id);
    }
    //printf("real score : %.2f\n\n\n", c.real_score(w.getWindows()));
    c.simulatedAnnealing(g.getGraphs(), w.getWindows(), start, argv[1]);

    for (int group_id = 0; group_id < c.group_size; group_id++) {
        c.iterative_sol(g.getGraphs(), w.getWindows(), group_id);
    }

    c.printResult(s.getShapes(), g.getGraphs(), w.getWindows(), argc, argv);
    printf("real score : %.2f\n\n\n", c.real_score(w.getWindows()));
    return 0;
}
Ejemplo n.º 8
0
void Scene::AddTexturedObject(const std::string fname, Material* material, Shapes &objects, const std::string textName, const Point &ofs) const
{
	size_t index = Shape::GetUniqueID();

	// —читывание меша из файла
	L3DS *l3ds = new L3DS(fname.c_str());
	if(!l3ds || !l3ds->GetMeshCount())
		throw Error("Error in loading extern files");

	for(int i = 0; i<l3ds->GetMeshCount(); i++) {
		LMesh *mesh = l3ds->GetMesh(i);

		Texture *texture = new Texture(textName.c_str());

		for(int j = 0; j<mesh->GetTriangleCount(); j++) {
			LTriangle tr = mesh->GetTriangle(j);

			Point a(mesh->GetVertex(tr.a).x, mesh->GetVertex(tr.a).y, mesh->GetVertex(tr.a).z);
			Point b(mesh->GetVertex(tr.b).x, mesh->GetVertex(tr.b).y, mesh->GetVertex(tr.b).z);
			Point c(mesh->GetVertex(tr.c).x, mesh->GetVertex(tr.c).y, mesh->GetVertex(tr.c).z);	

			TextureCoords tA(mesh->GetUV(tr.a).u, mesh->GetUV(tr.a).v);
			TextureCoords tB(mesh->GetUV(tr.b).u, mesh->GetUV(tr.b).v);
			TextureCoords tC(mesh->GetUV(tr.c).u, mesh->GetUV(tr.c).v);

			tA.InvertU();
			tB.InvertU();
			tC.InvertU();

			tA*=8;
			tB*=8;
			tC*=8;

			if (Triangle::IsValidTrangle(a,b,c))
				objects.push_back(new Triangle(a-ofs, b-ofs, c-ofs, material, index, texture, tA, tB, tC));
		}
	}
}
Ejemplo n.º 9
0
void Scene::AddObject(const std::string& fname,Material* material, Shapes &objects, const Point &ofs) const
{
	size_t index = Shape::GetUniqueID();

	// —читывание меша из файла
	L3DS *l3ds = new L3DS(fname.c_str());
	if(!l3ds || !l3ds->GetMeshCount())
		throw Error("Error in loading extern files");

	for(int i = 0; i<l3ds->GetMeshCount(); i++) {
		LMesh *mesh = l3ds->GetMesh(i);

		for(int j = 0; j<mesh->GetTriangleCount(); j++) {
			LTriangle tr = mesh->GetTriangle(j);

			Point a(mesh->GetVertex(tr.a).x, mesh->GetVertex(tr.a).y, mesh->GetVertex(tr.a).z);
			Point b(mesh->GetVertex(tr.b).x, mesh->GetVertex(tr.b).y, mesh->GetVertex(tr.b).z);
			Point c(mesh->GetVertex(tr.c).x, mesh->GetVertex(tr.c).y, mesh->GetVertex(tr.c).z);	

			if (Triangle::IsValidTrangle(a,b,c))
				objects.push_back(new Triangle(a-ofs, b-ofs, c-ofs, material, index));
		}
	}
}
Ejemplo n.º 10
0
 bool DetectPolygons::processFrameContainer(BaseFrameContainer *frm, BaseFrameSource *frameSource)
 {
     Shapes* shapes = frm->getShapes();
     std::vector<Point>  approxCurve;
     unsigned int size = 0;
     ///for each contour, analyze if it is a paralelepiped likely to be the marker
     for (unsigned int i=0;i<shapes->getContours().size();i++)
     {
         
         unsigned int contourSize = shapes->getContours()[i].size();
         //check it is a possible element by first checking is has enough points
         if (contourSize>(unsigned int)(frm->getFrame()->getMat().cols /15))
         {
             //approximate to a polygon - 1. limit slozitosti (pocet bodu krat cislo vs konstanta), 2. uzavreny
             
             double complexity = double(contourSize)*complexityKoef;
             complexity = complexity > maxComplexity ? maxComplexity : (complexity < minComplexity ? minComplexity : complexity);
             cv::approxPolyDP(  cv::Mat (shapes->getContours()[i]),approxCurve , complexity , onlyClosed);
             
             size = approxCurve.size();
             unsigned int one, two;
             
             if (approxCurve.size() >= 3) {
                 // remove inline points
                 for (unsigned int i = 0; i < size; i++) {
                     one = (i + 1)%size;
                     two = (i + 2)%size;
                     // rozdil smernic
                     double x1 = approxCurve[i].x, y1 =  approxCurve[i].y,
                            x2 = approxCurve[one].x, y2 =  approxCurve[one].y,
                            x3 = approxCurve[two].x, y3 =  approxCurve[two].y;
                     
                     float k = std::abs(((y2-y1)/(x2-x1)) - ((y3-y1)/(x3-x1)));
                     
                     float d1 = std::sqrt((float) (approxCurve[i].x-approxCurve[one].x)*(approxCurve[i].x-approxCurve[one].x) +
                                        (approxCurve[i].y-approxCurve[one].y)*(approxCurve[i].y-approxCurve[one].y));
                     
                     float d2 = std::sqrt((float) (approxCurve[i].x-approxCurve[two].x)*(approxCurve[i].x-approxCurve[two].x) +
                                          (approxCurve[i].y-approxCurve[two].y)*(approxCurve[i].y-approxCurve[two].y));
                         
                     // if angle is too small or points are too close
                     if (k < 0.2 || d1 < 0.04*d2) {
                         approxCurve.erase(approxCurve.begin()+one);
                         size--;
                     }
                 }
             }
             
             
             if (size >= minimalPolygonLines && size <= maximalPolygonLines)
             {
                 
                 //and is convex
                 if (!onlyConvex || cv::isContourConvex(Mat  (approxCurve)))
                 {
                     
                     float minDist=1e10;
                     if (minDistance > 0) {
                         for (int i=0;i<size;i++)
                         {
                             float d= std::sqrt((float) (approxCurve[i].x-approxCurve[(i+1)%size].x)*(approxCurve[i].x-approxCurve[(i+1)%size].x) +
                                                (approxCurve[i].y-approxCurve[(i+1)%size].y)*(approxCurve[i].y-approxCurve[(i+1)%size].y));
                             if (d<minDist) minDist=d;
                         }
                     }
                     if (minDist>=minDistance)
                     {
                         shapes->getMarkers().push_back(Marker());
                         for (unsigned int i=0;i<size;i++)
                         {
                             shapes->getMarkers().back().push_back( Point2f(approxCurve[i].x,approxCurve[i].y));
                         }
                     }
                 }
             }
         }
     }
     
     /// remove these elements whise corners are too close to each other
     //first detect candidates
     size = shapes->getMarkers().size();
     
     if (minimalPolygonLines==4 && maximalPolygonLines == 4) {
         for (unsigned int i=0;i<shapes->getMarkers().size();i++)
         {
             
             //trace a line between the first and second point.
             //if the thrid point is at the right side, then the points are anti-clockwise
             double dx1 = shapes->getMarkers()[i][1].x - shapes->getMarkers()[i][0].x;
             double dy1 =  shapes->getMarkers()[i][1].y - shapes->getMarkers()[i][0].y;
             double dx2 = shapes->getMarkers()[i][2].x - shapes->getMarkers()[i][0].x;
             double dy2 = shapes->getMarkers()[i][2].y - shapes->getMarkers()[i][0].y;
             double o = (dx1*dy2)-(dy1*dx2);
             
             if (o  < 0.0)		 //if the third point is in the left side, then sort in anti-clockwise order
             {
                 swap(shapes->getMarkers()[i][1],shapes->getMarkers()[i][3]);
             }
         }
     }
     
     
     vector<pair<int,int>  > TooNearCandidates;
     for (unsigned int i=0;i < size;i++)
     {
         // 	cout<<"Marker i="<<i<<MarkerCanditates[i]<<endl;
         //calculate the average distance of each corner to the nearest corner of the other marker candidate
         for (unsigned int j=i+1;j<size;j++)
         {
             unsigned int vertexCount = shapes->getMarkers()[i].size();
             if (vertexCount == shapes->getMarkers()[j].size()) {
                 float dist=0;
                 for (unsigned int c=0;c<vertexCount;c++)
                     dist+= std::sqrt(  (shapes->getMarkers()[i][c].x-shapes->getMarkers()[j][c].x)*(shapes->getMarkers()[i][c].x-shapes->getMarkers()[j][c].x)+(shapes->getMarkers()[i][c].y-shapes->getMarkers()[j][c].y)*(shapes->getMarkers()[i][c].y-shapes->getMarkers()[j][c].y));
                 dist/=vertexCount;
                 //if distance is too small
                 if (dist< 14) {
                     TooNearCandidates.push_back(pair<int,int>(i,j));
                 }
             }
         }
     }
     //mark for removal the element of  the pair with smaller perimeter
     vector<bool> toRemove (shapes->getMarkers().size(),false);
     for (unsigned int i=0;i<TooNearCandidates.size();i++) {
         if ( perimeter(shapes->getMarkers()[TooNearCandidates[i].first ])>perimeter(shapes->getMarkers()[ TooNearCandidates[i].second] ))
             toRemove[TooNearCandidates[i].second]=true;
         else toRemove[TooNearCandidates[i].first]=true;
     }
     
     //remove the invalid ones
     removeElements(shapes->getMarkers(),toRemove);
     
     return true;
 }
Ejemplo n.º 11
0
BodyCreator::Shapes BodyCreator::m_ProcessConcave(const Shape& points)
{
	ShapeQueue q;
	q.push(points);

	Shapes output;

	while (!q.empty())
	{
		const auto& shape = q.front();
		sf::Uint16 s = shape.size();
		bool convex = true;

		for (auto i = 0u; i < s; i++)
		{
			sf::Uint16 i1 = i;
			sf::Uint16 i2 = (i < s - 1u) ? i + 1u : i + 1u - s;
			sf::Uint16 i3 = (i < s - 2u) ? i + 2u : i + 2u - s;

			sf::Vector2f p1 = shape[i1];
			sf::Vector2f p2 = shape[i2];
			sf::Vector2f p3 = shape[i3];

			float direction = m_GetWinding(p1, p2, p3);
			if (direction < 0.f)
			{
				convex = false;
				float minLen = FLT_MAX;
				sf::Int16 j1 = 0;
				sf::Int16 j2 = 0;
				sf::Vector2f v1;
				sf::Vector2f v2;
				sf::Int16 h = 0;
				sf::Int16 k = 0;
				sf::Vector2f hitPoint;

				for (auto j = 0u; j < s; j++)
				{
					if (j != i1 && j != i2)
					{
						j1 = j;
						j2 = (j < s - 1u) ? j + 1u : 0;

						v1 = shape[j1];
						v2 = shape[j2];

						sf::Vector2f hp = m_HitPoint(p1, p2, v1, v2);
						bool b1 = m_OnSeg(p2, p1, hp);
						bool b2 = m_OnSeg(hp, v1, v2);

						if (b1 && b2)
						{
							sf::Vector2f dist = p2 - hp;

							float t = Helpers::Vectors::dot(dist, dist); //aka length squared

							if (t < minLen)
							{
								h = j1;
								k = j2;
								hitPoint = hp;
								minLen = t;
							}
						}
					}
				}

				assert(minLen != FLT_MAX);

				Shape shape1;
				Shape shape2;

				j1 = h;
				j2 = k;
				v1 = shape[j1];
				v2 = shape[j2];

				if (!m_PointsMatch(hitPoint, v2))
					shape1.push_back(hitPoint);

				if (!m_PointsMatch(hitPoint, v1))
					shape2.push_back(hitPoint);


				h = -1;
				k = i1;
				while (true)
				{
					if (k != j2)
					{
						shape1.push_back(shape[k]);
					}
					else
					{
						assert(h >= 0 && h < s);
						if (!m_OnSeg(v2, shape[h], p1))
						{
							shape1.push_back(shape[k]);
						}
						break;
					}

					h = k;
					if ((k - 1) < 0)
					{
						k = s - 1;
					}
					else
					{
						k--;
					}
				}

				std::reverse(shape1.begin(), shape1.end());

				h = -1;
				k = i2;
				while (true)
				{
					if (k != j1)
					{
						shape2.push_back(shape[k]);
					}
					else
					{
						assert(h >= 0 && h < s);
						if ((k == j1) && !m_OnSeg(v1, shape[h], p2))
						{
							shape2.push_back(shape[k]);
						}
						break;
					}

					h = k;
					if (k + 1 > s - 1)
					{
						k = 0;
					}
					else
					{
						k++;
					}
				}
				q.push(shape1);
				q.push(shape2);
				q.pop();

				break;
			}
		}

		if (convex)
		{
			output.push_back(q.front());
			q.pop();
		}
	}
	return output;
}
Ejemplo n.º 12
0
LRESULT CALLBACK EXPORT AWClientWndProc
  (
  HWND    hwnd,
  UINT    uMsg,
  WPARAM  wParam,
  LPARAM  lParam
  )

  {
  LRESULT lRet;
  BOOL    fHandled;
  Window* pWnd = (Window*)GetWindowLong(hwnd, I_GWL_WINDOW);
  Shapes* pShapes = (Shapes*)GetWindowLong(hwnd, I_GWL_SHAPES);

  switch (uMsg)
    {
    case WM_CREATE:
      pWnd = (Window*)(((CREATESTRUCT*)lParam)->lpCreateParams);
      pShapes = (pWnd->GetLayout())->Shapes();
      SetWindowLong(hwnd, I_GWL_WINDOW, (long)pWnd);
      SetWindowLong(hwnd, I_GWL_SHAPES, (long)pShapes);
      fHandled = TRUE;
      lRet = 0L;
      break;

    // the following messages are processed by the Shapes class
    case WM_MOUSEMOVE:
      pShapes->MouseMove(pWnd, hwnd, (int)wParam, (short)LOWORD(lParam), (short)HIWORD(lParam));
      fHandled = TRUE;
      lRet = 0L;
      break;

    case WM_LBUTTONDOWN:
      pShapes->MouseLButtonDown(pWnd, hwnd, (int)wParam, (short)LOWORD(lParam), (short)HIWORD(lParam));
      fHandled = TRUE;
      lRet = 0L;
      break;

    case WM_LBUTTONDBLCLK:
      pShapes->MouseLButtonDblClk(pWnd, hwnd, (int)wParam, (short)LOWORD(lParam), (short)HIWORD(lParam));
      fHandled = TRUE;
      lRet = 0L;
      break;

    case WM_LBUTTONUP:
      pShapes->MouseLButtonUp(pWnd, hwnd, (int)wParam, (short)LOWORD(lParam), (short)HIWORD(lParam));
      fHandled = TRUE;
      lRet = 0L;
      break;

    case WM_RBUTTONDOWN:
      pShapes->MouseRButtonDown(pWnd, hwnd, (int)wParam, (short)LOWORD(lParam), (short)HIWORD(lParam));
      fHandled = TRUE;
      lRet = 0L;
      break;

    case WM_KEYDOWN:
      pShapes->KeyDown(pWnd, hwnd, (int)wParam, lParam);
      fHandled = TRUE;
      lRet = 0L;
      break;

    case WM_KEYUP:
      pShapes->KeyUp(pWnd, hwnd, (int)wParam, lParam);
      fHandled = TRUE;
      lRet = 0L;
      break;


    // the following messages are handled by the Window class
    case WM_ERASEBKGND:
      pWnd->EraseBackground((HDC)wParam);
      fHandled = TRUE;
      lRet = 0L;
      break;

    case WM_PAINT:
      (pWnd->Items())->Paint();
      fHandled = TRUE;
      lRet = 0L;
      break;

    case WM_HSCROLL:
      HANDLE_WM_HSCROLL(hwnd, wParam, lParam, (pWnd->Items())->HScroll);
      fHandled = TRUE;
      lRet = 0L;
      break;

    case WM_VSCROLL:
      HANDLE_WM_VSCROLL(hwnd, wParam, lParam, (pWnd->Items())->VScroll);
      fHandled = TRUE;
      lRet = 0L;
      break;

    case WM_DELETEITEM:
    case WM_COMPAREITEM:
    case WM_MEASUREITEM:
    case WM_DRAWITEM:
    #if defined(__FLAT__)
    case WM_CTLCOLORBTN:
    case WM_CTLCOLORDLG:
    case WM_CTLCOLOREDIT:
    case WM_CTLCOLORLISTBOX:
    case WM_CTLCOLORSCROLLBAR:
    case WM_CTLCOLORSTATIC:
    #else
    case WM_CTLCOLOR:
    #endif
      lRet = (pWnd->Items())->ParentNotified(hwnd, uMsg, wParam, lParam);
      fHandled = TRUE;
      break;

    default:
      fHandled = FALSE;
      break;
    }

  return fHandled ? lRet : DefWindowProc(hwnd, uMsg, wParam, lParam);
  }
Ejemplo n.º 13
0
int main(int argc, char* argv[]){

   // declarations
   Fitter fitter;
   map<string, Dataset> datasets;
   vector<Event> eventvec_datamc;
   vector<Event> eventvec_train;
   vector<Event> eventvec_test;
   map< string, map<string, TH1D*> > hists_all_;
   map< string, map<string, TH1D*> > hists_train_;
   map< string, map<string, TH1D*> > hists_test_;

   // output fit results
   int run_number=-1;
   int fitstatus=-1;
   double mt=0, mt_err=0;
   double kmbl=0, kmbl_err=0;
   double k220=0, k220_err=0;
   double mcmass=0;
   double fitchi2=0;
   double tsig_mbl_chi2 [8] = {0};
   double tbkg_mbl_chi2 [8] = {0};
   
   TTree *tree = new TTree("FitResults", "FitResults");
   tree->Branch("runNumber", &run_number);
   tree->Branch("fitStatus", &fitstatus);
   tree->Branch("mt", &mt);
   tree->Branch("mt_err", &mt_err);
   tree->Branch("kmbl", &kmbl);
   tree->Branch("kbml_err", &kmbl_err);
   tree->Branch("k220", &k220);
   tree->Branch("k220_err", &k220_err);
   tree->Branch("mcmass", &mcmass);
   tree->Branch("fitchi2", &fitchi2);
   tree->Branch("tsig_mbl_chi2", tsig_mbl_chi2, "tsig_mbl_chi2[8]/D");
   tree->Branch("tbkg_mbl_chi2", tbkg_mbl_chi2, "tbkg_mbl_chi2[8]/D");


   // option flags
   int c;
   int do_fit = 0;
   int do_diagnostics = 0;
   int use_data = 0;
   float masspnt = 0;
   int do_bootstrap = 0;
   int do_templates = 0;
   int do_learnparams = 0;
   int do_mbl = 0;
   int do_mt2 = 0;
   double fracevts = -1;

   struct option longopts[] = {
      { "run_number",   required_argument,   0,                'n' },
      { "fit",          no_argument,         &do_fit,          'f' },
      { "diagnostics",  no_argument,         &do_diagnostics,  'd' },
      { "templates",    no_argument,         &do_templates,    'e' },
      { "learnparams",  no_argument,         &do_learnparams,  'x' },
      { "data",         no_argument,         &use_data,        'a' },
      { "profile",      no_argument,         0,                'p' },
      { "masspnt",      required_argument,   0,                'm' },
      { "bootstrap",    no_argument,         &do_bootstrap,    'o' },
      { "fracevts",     required_argument,   0,                'c' },
      // If the lmbl flag is not entered, lengthscale_mbl has default value -1.
      // This instructs the code to not use mbl in the fit.
      // The same goes for each other kinematic variable.
      { "mbl",          no_argument,         &do_mbl,          'b' },
      { "mt2",          no_argument,         &do_mt2,          't' },
      { "help",         no_argument,         NULL,             'h' },
      { 0, 0, 0, 0 }
   };

   while( (c = getopt_long(argc, argv, "fdexahponbtm:c:", longopts, NULL)) != -1 ) {
      switch(c)
      {
         case 'n' :
            run_number = atoi(optarg);
            break;

         case 'f' :
            do_fit = 1;
            break;

         case 'd' :
            do_diagnostics = 1;
            break;

         case 'e' :
            do_templates = 1;
            break;

         case 'x' :
            do_learnparams = 1;
            break;

         case 'a' :
            use_data = 1;
            break;

         case 'm' :
            masspnt = atof(optarg);
            break;

         case 'p' :
            fitter.compute_profile = true;
            break;

         case 'o' :
            do_bootstrap = 1;
            break;

         case 'c' :
            fracevts = atof(optarg);
            break;

         case 'b' :
            do_mbl = true;
            break;

         case 't' :
            do_mt2 = true;
            break;

         case 'h' :
            print_usage();
            return -1;
            break;

         case 0:     /* getopt_long() set a variable, just keep going */
            break;

         case ':':   /* missing option argument */
            fprintf(stderr, "%s: option `-%c' requires an argument\n",
                  argv[0], optopt);
            return -1;

         case '?':
         default:    /* invalid option */
            fprintf(stderr, "%s: option `-%c' is invalid: ignored\n",
                  argv[0], optopt);
            print_usage();
            return -1;

      }
   }

   fitter.dists["mbl"].activate = do_mbl;
   fitter.dists["mt2_220_nomatchmbl"].activate = do_mt2;

   // Check that at least one kinematic variable's lengthscale has been entered.
   // Any additional distributions need to be added here
   if (!(fitter.dists["mbl"].activate) and !(fitter.dists["mt2_220_nomatchmbl"].activate) and do_fit == 1){
      std::cout << "At least one variable needed to do fit.  Input at least one lengthscale." << std::endl;
      print_usage();
      return -1;
   }

   fitter.LoadDatasets( datasets );

   // for event counting
   map<string, int> datacount;

   // random number seed for bootstrapping (turns on when nonzero)
   int randseed = 0;
   if( do_bootstrap ) randseed = run_number+1+10E6;

   cout << "\nLoading datasets" << endl;
   for(map<string, Dataset>::iterator it = datasets.begin(); it != datasets.end(); it++){

      string name = it->first;
      Dataset *dat = &(it->second);

      datacount[name] = 0;

      TFile file( (dat->path+dat->file).c_str() );
      TTree *trees = (TTree*)file.Get("RealData");

      cout << setiosflags(ios::left);
      cout << "... " << setw(25) << name
         << ": " << trees->GetEntries() << " events" << endl;

      if( do_diagnostics or use_data ){
         fitter.ReadNtuple( dat->path+dat->file, name, dat->mc_xsec/dat->mc_nevts,
               "RealData", eventvec_datamc, 0, 0, -1 );
      }

      // events for training and testing
      if( name.compare("data") != 0 ){

         if( use_data ){ // train on full mc set
            fitter.ReadNtuple( dat->path+dat->file, name, dat->mc_xsec/dat->mc_nevts,
                  "RealData", eventvec_train, 0, randseed, -1 );
         }else{
            fitter.ReadNtuple( dat->path+dat->file, name, dat->mc_xsec/dat->mc_nevts,
                  "RealData", eventvec_train, 1, randseed, -1 );
            fitter.ReadNtuple( dat->path+dat->file, name, dat->mc_xsec/dat->mc_nevts,
                  "RealData", eventvec_test, 2, randseed, fracevts );
         }

      }

   }

   // data/mc plots, kinematic distributions
   fitter.GetVariables( eventvec_datamc );
   fitter.GetVariables( eventvec_train );
   fitter.GetVariables( eventvec_test );

   fitter.DeclareHists( hists_train_, "train" );
   fitter.FillHists( hists_train_, eventvec_train );

   fitter.DeclareHists( hists_test_, "test" );
   fitter.FillHists( hists_test_, eventvec_test );

   if( do_diagnostics ){ 
      fitter.DeclareHists( hists_all_, "all" );
      fitter.FillHists( hists_all_, eventvec_datamc );
      fitter.PrintHists( hists_all_ );
   }

   if( do_fit ){

      vector<Event> eventvec_fit;
      vector<Event> eventvec_fit_bkgcontrol;
      map< string, map<string, TH1D*> > hists_fit_;
      map< string, map<string, TH1D*> > hists_fit_bkgcontrol_;

      if( use_data ){ // added 220 distribution to the data fit too, but haven't tested it

         //
         // turn this feature off for now -- will need to clean up later.
         //

         /*
         cout << "REMINDER: EVENT WEIGHTS IN MC" << endl;
         for(vector<Event>::iterator ev = eventvec_datamc.begin(); ev < eventvec_datamc.end();ev++){
            if( ev->type.find("data") != string::npos ){
               if( ev->type.find("bkgcontrol") == string::npos ){
                  eventvec_fit.push_back(*ev);
               }else{
                  eventvec_fit_bkgcontrol.push_back(*ev);
               }
            }
         }

         // flag events to be fitted
         for( vector<Event>::iterator ev = eventvec_fit.begin(); ev < eventvec_fit.end(); ev++){
            ev->fit_event = true;
            for(map<string, int>::iterator it = datacount.begin(); it != datacount.end(); it++){
               if( ev->process.compare(it->first) == 0 ) datacount[it->first]+=1;
            }
         }
         for( vector<Event>::iterator ev = eventvec_fit_bkgcontrol.begin();
               ev < eventvec_fit_bkgcontrol.end(); ev++){
            ev->fit_event = true;
            for(map<string, int>::iterator it = datacount.begin(); it != datacount.end(); it++){
               if( ev->process.compare(it->first) == 0 ) datacount[it->first]+=1;
            }
         }
         cout << "Fit event count: " << endl;
         cout << setiosflags(ios::left);
         for(map<string, int>::iterator it = datacount.begin(); it != datacount.end(); it++){
            cout << "... " << setw(25) << it->first << ": " << it->second << " events" << endl;
         }

         fitter.DeclareHists( hists_fit_, "fit" );
         fitter.FillHists( hists_fit_, eventvec_fit, true );
         fitter.DeclareHists( hists_fit_bkgcontrol_, "fit_bkgcontrol" );
         fitter.FillHists( hists_fit_bkgcontrol_, eventvec_fit_bkgcontrol, true );

         double wgt=0;
         for(vector<Event>::iterator ev = eventvec_fit.begin(); ev < eventvec_fit.end(); ev++){
            wgt += ev->weight;
         }
         cout << "wgt = " << wgt << endl;

         // do GP training
         cout << "Training GP." << endl;

         // GP training for mbl
         if ( lengthscale_mbl != -1){
            Shapes * fptr = new Shapes( "mbl", fitter.gplength_mbl, fitter.gplength_mt_mbl,
                  fitter.lbnd, fitter.rbnd );
            fptr->TrainGP( hists_train_ );
            fitter.aGPsig.ResizeTo( fptr->aGPsig.GetNoElements() );
            fitter.aGPsig = fptr->aGPsig;
            fitter.aGPbkg.ResizeTo( fptr->aGPbkg.GetNoElements() );
            fitter.aGPbkg = fptr->aGPbkg;
         }

         // GP training for 220
         if ( lengthscale_220 != -1){
            Shapes * fptr220 = new Shapes( "mt2_220_nomatchmbl", fitter.gplength_220, fitter.gplength_mt_220,
                  fitter.lbnd, fitter.rbnd );
            fptr220->TrainGP( hists_train_ );
            fitter.aGPsig220.ResizeTo( fptr220->aGPsig.GetNoElements() );
            fitter.aGPsig220 = fptr220->aGPsig;
            fitter.aGPbkg220.ResizeTo( fptr220->aGPbkg.GetNoElements() );
            fitter.aGPbkg220 = fptr220->aGPbkg;
         }

         // events for fitting, hists for training
         fitter.RunMinimizer( eventvec_fit );
         fitter.PlotResults( hists_fit_ ); // plot fitted events

         // fill results tree
         mcmass = 0;
         fitstatus = fitter.gMinuit->Status();
         const double *par = fitter.gMinuit->X();
         const double *par_err = fitter.gMinuit->Errors();
         mt = par[0];
         kmbl = par[1];
         k220 = par[2];
         mt_err = par_err[0];
         kmbl_err = par_err[1];
         k220_err = par_err[2];
         fitchi2 = fitter.fitchi2;
         gplength_mbl = lengthscale_mbl;
         gplength_220 = lengthscale_220;
         gplength_mt_mbl = lengthscale_mt_mbl;
         gplength_mt_220 = lengthscale_mt_220;

         // TODO
         //tree->Fill();

         eventvec_fit.clear();
         eventvec_fit_bkgcontrol.clear();
         fitter.DeleteHists( hists_fit_ );
         fitter.DeleteHists( hists_fit_bkgcontrol_ );
         */

      }else{ // loop over mc masses

         double masspnts [] = {161.5,163.5,166.5,169.5,172.5,175.5,178.5,181.5};
         for(int i=0; i < 8; i++){

            double mass = masspnts[i];
            // masspoint from command line
            if( masspnt != 0 ){
               bool check = false;
               for(int j=0; j < 8; j++){
                  if( masspnts[j] == masspnt ) check = true;
               }
               if(check){
                  mass = masspnt;
                  i = 7;
               }else{
                  cout << "masspoint " << masspnt << " not found!" << endl;
                  return -1;
               }
            }

            cout << "############# Fitting Masspoint " << mass << " ###############" << endl;

            stringstream dstr;
            dstr << floor(mass);
            string dname = "ttbar"+dstr.str();

            // load events to be fitted
            for(vector<Event>::iterator ev = eventvec_test.begin(); ev < eventvec_test.end(); ev++){
               if( ev->type.find(dname) != string::npos or ev->type.find("other") != string::npos ){
                  if( ev->type.find("bkgcontrol") == string::npos ){
                        eventvec_fit.push_back(*ev);
                  }else{
                     eventvec_fit_bkgcontrol.push_back(*ev);
                  }
               }
            }

            fitter.ReweightMC( eventvec_fit, dname );

            // flag events to be fitted
            for( vector<Event>::iterator ev = eventvec_fit.begin(); ev < eventvec_fit.end(); ev++){
               ev->fit_event = true;
               for(map<string, int>::iterator it = datacount.begin(); it != datacount.end(); it++){
                  if( ev->process.compare(it->first) == 0 ) datacount[it->first]+=1;
               }
            }
            for( vector<Event>::iterator ev = eventvec_fit_bkgcontrol.begin();
                  ev < eventvec_fit_bkgcontrol.end(); ev++){
               ev->fit_event = true;
               for(map<string, int>::iterator it = datacount.begin(); it != datacount.end(); it++){
                  if( ev->process.compare(it->first) == 0 ) datacount[it->first]+=1;
               }
            }

            cout << "Fit event count: " << endl;
            cout << setiosflags(ios::left);
            for(map<string, int>::iterator it = datacount.begin(); it != datacount.end(); it++){
               cout << "... " << setw(25) << it->first << ": " << it->second << " events" << endl;
            }

            fitter.DeclareHists( hists_fit_, "fit" );
            fitter.FillHists( hists_fit_, eventvec_fit, true );
            fitter.DeclareHists( hists_fit_bkgcontrol_, "fit_bkgcontrol" );
            fitter.FillHists( hists_fit_bkgcontrol_, eventvec_fit_bkgcontrol, true );

            // do GP training
            for( map<string, Distribution>::iterator it = fitter.dists.begin(); it != fitter.dists.end(); it++ ){

               string name = it->first;
               Distribution *dist = &(it->second);

               double m2llsig, m2llbkg;

               if( dist->activate ){
                  Shapes * fptr = new Shapes( name, dist->glx, dist->glmt, dist->gnorm1, dist->gnorm2 );
                  fptr->TrainGP( hists_train_, m2llsig, m2llbkg );

                  dist->aGPsig.ResizeTo( fptr->aGPsig.GetNoElements() );
                  dist->aGPsig = fptr->aGPsig;
                  dist->aGPbkg.ResizeTo( fptr->aGPbkg.GetNoElements() );
                  dist->aGPbkg = fptr->aGPbkg;

                  delete fptr;

               }

            }

            typedef map<string, TH1D*> tmap;
            typedef map<string, tmap> hmap;
            for( hmap::iterator h = hists_train_.begin(); h != hists_train_.end(); h++){
               for( tmap::iterator t = h->second.begin(); t != h->second.end(); t++){
                  for(int n=1; n < t->second->GetNbinsX(); n++){
                     if( t->second->GetBinContent(n) == 0 )
                        t->second->SetBinError(n, 1.0/35000);
                  }
               }
            }

            // events for fitting, hists for training
            fitter.RunMinimizer( eventvec_fit );
            fitter.PlotResults( hists_fit_ ); // plot fitted events

            cout << "Fit Chi2 = " << fitter.fitchi2 << endl;


            // fill results tree
            // any additional variables need to be added here
            mcmass = mass;
            fitstatus = fitter.gMinuit->Status();
            const double *par = fitter.gMinuit->X();
            const double *par_err = fitter.gMinuit->Errors();
            mt = par[0];
            kmbl = par[1];
            mt_err = par_err[0];
            kmbl_err = par_err[1];
            k220 = par[2];
            k220_err = par_err[2];
            fitchi2 = fitter.fitchi2;

            tree->Fill();

            eventvec_fit.clear();
            eventvec_fit_bkgcontrol.clear();
            fitter.DeleteHists( hists_fit_ );
            fitter.DeleteHists( hists_fit_bkgcontrol_ );

         }

      }

   }

   if( do_templates ){

            // do GP training
            for( map<string, Distribution>::iterator it = fitter.dists.begin(); it != fitter.dists.end(); it++ ){

               string name = it->first;
               Distribution *dist = &(it->second);

               double m2llsig, m2llbkg;

               if( dist->activate ){
                  Shapes * fptr = new Shapes( name, dist->glx, dist->glmt, dist->gnorm1, dist->gnorm2 );
                  fptr->TrainGP( hists_train_, m2llsig, m2llbkg );

                  dist->aGPsig.ResizeTo( fptr->aGPsig.GetNoElements() );
                  dist->aGPsig = fptr->aGPsig;
                  dist->aGPbkg.ResizeTo( fptr->aGPbkg.GetNoElements() );
                  dist->aGPbkg = fptr->aGPbkg;

                  dist->Ainv_sig.ResizeTo( fptr->aGPsig.GetNoElements(), fptr->aGPsig.GetNoElements() );
                  dist->Ainv_sig = fptr->Ainv_sig;
                  dist->Ainv_bkg.ResizeTo( fptr->aGPbkg.GetNoElements(), fptr->aGPbkg.GetNoElements() );
                  dist->Ainv_bkg = fptr->Ainv_bkg;

                  delete fptr;
               }

            }

            fitter.PlotTemplates( hists_train_ );

            for(int j=0; j < 8; j++){
               tsig_mbl_chi2[j] = fitter.tsig_mbl_chi2[j];
               tbkg_mbl_chi2[j] = fitter.tbkg_mbl_chi2[j];
            }

   }

   if( do_learnparams ){
      string name = "mbl";
      Distribution *dist = &(fitter.dists[name]);
      Shapes * fptr = new Shapes( name, dist->glx, dist->glmt, dist->gnorm1, dist->gnorm2 );
      fptr->LearnGPparams( hists_train_ );
      delete fptr;
   }

   if( do_fit or do_templates ){
      tree->Fill();
   }


   //
   // write fit results
   //
   if( do_fit or do_templates ){
      // set up output file path
      std::string pathstr;
      char* path = std::getenv("WORKING_DIR");
      if (path==NULL) {
         pathstr = "./results";
      }else {
         pathstr = path;
      }

      TFile *file = new TFile((pathstr+"/fitresults.root").c_str(), "RECREATE");
      file->cd();
      tree->Write();
      file->Write();
      file->Close();
   }

   return 0;
}
Ejemplo n.º 14
0
Vector RayCast(Ray r, int Depth)
{
  Vector result = Vector();
  Shapes o = Shapes();
  int ShapeNum = 0;
  bool Intersect = false;
  //Find nearest intersection between r and objects		
  float Dist = -1.0f;
  for (int i = 0; i < ShapeList.size(); i++)
  {
    // Find Closest intersecting shape
    // - Find t for each shape
    // - if t > 0 for that shape find dst
    // - Smallest Dst is the object		
    ShapeList[i].setT(-1.0f);
    auto t = ShapeList[i].Intersect(r);

    if (t > 0.0f)
    {
      ShapeList[i].setT(t);
      Intersect = true;
      Shapes Place = ShapeList[i];
      if (Dist < 0.0f)
      {
        Dist = ShapeList[i].getT();
      }
      if (ShapeList[i].getT() <= Dist)
      {
        o = ShapeList[i];
        ShapeNum = i;
        Dist = o.getT();
      }
    }
  }
  if (!Intersect)
  {
    return result;
  }
  Vector p = r.Source + (r.Direction * o.getT());
  Vector n = o.Normal(p);
  Vector v = ViewCamera.Position() - p;
  LightConstants MaterialP = o.getLightConstants();
  if (o.Has_Texture())
  {
    Vector Material = o.getMaterialColour(p);
    MaterialP.Diffuse = Material;
  }
  result = aLight.CalculateLightModel(p, n, v, MaterialP, ShapeList, ShapeNum);

  if (Depth == 0)
  {
    return result;
  }
  LightConstants P = o.getLightConstants();
  Vector ZERO = Vector(0.0f, 0.0f, 0.0f);
  if ((P.Reflective.x != ZERO.x) || (P.Reflective.y != ZERO.y) || (P.Reflective.z != ZERO.z))
  {
    // Reflection Vector = u - 2(u . n)n
    float temp = 2.0f * DotProduct(r.Direction.Normalize(), n.Normalize());
    Vector R = r.Direction.Normalize() - (n.Normalize() * temp);
    Vector ReflectColour = RayCast(Ray(p, R.Normalize()), Depth - 1);
    result = result + Vector(P.Reflective.x * ReflectColour.x, P.Reflective.y * ReflectColour.y, P.Reflective.z * ReflectColour.z);
  }

  if ((P.Transmission.x != ZERO.x) || (P.Transmission.y != ZERO.y) || (P.Transmission.z != ZERO.z))
  {
    Vector u = r.Direction;
    u = u.Normalize() * -1.0f;
    Vector t = aLight.CalcTransmissionDirection((u), n.Normalize(), 1.5f);
    if ((t.x != ZERO.x) && (t.y != ZERO.y) && (t.z != ZERO.z))
    {
      Vector T = RayCast(Ray(p, t), Depth - 1);
      result = result + Vector(P.Transmission.x * T.x, P.Transmission.y * T.y, P.Transmission.z * T.z);
    }
  }
  //if ! Transparent
  return result;
}
Ejemplo n.º 15
0
int main()
{
  cout << "RayTracer starting...\n";
  bitmap image1;
  image1.create(256, 256);
  cout << "Image Created...\n";
  // Camera is a ray as well, Source would be the position that the camera exists and
  // Direction would be where it is looking.	
  Vector CameraCenter = Vector(0.0f, 0.0f, 0.0f);
  ViewCamera = Camera(CameraCenter, Vector(0.0f, 0.0f, 1.0f), Vector(0.0f, 1.0f, 0.0f), image1.getwidth(), image1.getheight());
  ViewCamera.CalculatePlaneNormals();

  Shapes a = Shapes();
  LightConstants Material = LightConstants(Vector(0.0f, 0.9f, 0.0f), Vector(0.1f, 0.1f, 0.1f), Vector(0.1f, 0.1f, 0.1f), Vector(), Vector(), Vector(), 8.0f);
  a.setPlane(Vector(0.0f, 1.0f, 0.0f, 1.0f), Material);
  ShapeList.push_back(a);

  Material = LightConstants(Vector(1.0f, 0.0f, 0.0f), Vector(0.1f, 0.1f, 0.1f), Vector(0.0f, 0.0f, 0.0f), Vector(), Vector(), Vector(), 8.0f);
  a.setPlane(Vector(0.0f, -1.0f, 0.0f, 1.0f), Material);
  ShapeList.push_back(a);

  Material = LightConstants(Vector(0.9f, 0.9f, 0.0f), Vector(0.1f, 0.1f, 0.1f), Vector(0.0f, 0.0f, 0.0f), Vector(), Vector(), Vector(), 8.0f);
  a.setPlane(Vector(1.0f, 0.0f, 0.0f, 1.0f), Material);
  ShapeList.push_back(a);

  Material = LightConstants(Vector(0.9f, 0.9f, 0.9f), Vector(0.1f, 0.1f, 0.1f), Vector(0.0f, 0.0f, 0.0f), Vector(), Vector(), Vector(), 8.0f);
  a.setPlane(Vector(-1.0f, 0.0f, 0.0f, 1.0f), Material);
  ShapeList.push_back(a);

  Shapes b = Shapes();
  Material = LightConstants(Vector(0.0f, 0.0f, 0.7f), Vector(0.3f, 0.3f, 0.3f), Vector(), Vector(), Vector(0.1f, 0.1f, 0.1f), Vector(), 4.0f);
  b.setSphere(0.5f, Material, false);
  b.Translatef(Vector(0.0f, 1.0f, 0.0f));
  ShapeList.push_back(b);

  Material = LightConstants(Vector(0.7f, 0.0f, 0.0f), Vector(0.3f, 0.3f, 0.3f), Vector(), Vector(), Vector(0.5f, 0.5f, 0.5f), Vector(), 16.0f);
  b.setSphere(0.5f, Material, false);
  b.Translatef(Vector(-1.0f, 0.0f, 0.0f));
  ShapeList.push_back(b);

  Material = LightConstants(Vector(0.1f, 0.1f, 0.1f), Vector(0.9f, 0.9f, 0.9f), Vector(), Vector(), Vector(0.5f, 0.5f, 0.5f), Vector(), 16.0f);
  b.setSphere(0.5f, Material, false);
  b.Translatef(Vector(1.0f, 0.0f, 0.0f));
  ShapeList.push_back(b);

  Material = LightConstants(Vector(0.0f, 0.7f, 0.0f), Vector(0.3f, 0.3f, 0.3f), Vector(), Vector(), Vector(0.5f, 0.5f, 0.5f), Vector(), 16.0f);
  b.setSphere(0.5f, Material, false);
  b.Translatef(Vector(0.0f, -1.0f, 0.0f));
  ShapeList.push_back(b);

  Material = LightConstants(Vector(0.5f, 0.5f, 0.5f), Vector(0.5f, 0.5f, 0.5f), Vector(), Vector(), Vector(), Vector(0.9f, 0.9f, 0.9f), 16.0f);
  b.setTriangle(Vector(0.5f, 0.0f, 0.0f), Vector(0.0f, 0.5f, 0.0f), Vector(-0.5f, 0.0f, 0.0f), Material);
  b.Translatef(Vector(0.0f, 0.0f, -0.5f));
  //b.Rotatef(3.0f, Vector(0.0f, 1.0f, 0.0f));
  ShapeList.push_back(b);

  LightConstants LightValue = LightConstants(Vector(0.7f, 0.7f, 0.7f), Vector(0.3f, 0.3f, 0.3f), Vector(1.0f, 1.0f, 1.0f));
  aLight = Light(Ray(Vector(0.5f, 0.5f, -1.0f), Vector(0.0f, 0.0f, 0.0f)), LightValue);
  LightValue = LightConstants(Vector(0.7f, 0.7f, 0.7f), Vector(0.3f, 0.3f, 0.3f), Vector(0.5f, 0.5f, 0.5f));
  aLight.addLight(Ray(Vector(-0.5f, 0.5f, -1.0f), Vector(0.0f, 0.0f, 0.0f)), LightValue);
  cout << "Casting Rays...\n";
  BYTE Red, Green, Blue;

  for (int i = 1; i < image1.getwidth(); i++)
  {
    cout << i;
    float w = image1.getwidth();
    float t = i / w;
    Vector Left = Parametric(ViewCamera.P3(), ViewCamera.P0(), t);
    Vector Right = Parametric(ViewCamera.P2(), ViewCamera.P1(), t);
    for (int j = 1; j < image1.getheight(); j++)
    {
      float h = image1.getheight();
      t = j / h;
      Vector RayDir = Parametric(Left, Right, t);
      Matrix4Operations Translate;
      Matrix4Operations TranslateC;
      Translate.SetTranslate(RayDir);
      RayDir = Translate.Translate(Vector(0.0f, 0.0f, -3.0f));
      Vector C = ViewCamera.Position();
      TranslateC.SetTranslate(C);
      C = TranslateC.Translate(Vector(0.0f, 0.0f, -3.0f));
      RayDir = C - RayDir;
      Ray casted = Ray(C, RayDir.Normalize());
      Vector Colour = RayCast(casted, 5);
      Red = Limit255(Colour.x * 255);
      Green = Limit255(Colour.y * 255);
      Blue = Limit255(Colour.z * 255);
      image1.setcolor(255 - i, 255 - j, Red, Green, Blue);
    }
  }
  cout << "Saving Image...\n";
  image1.save("image1.bmp");
  //system("PAUSE");
  return 0;
}