diff -r f1006de05c54 -r 7d67be709091 geometry.cpp
--- a/geometry.cpp	Mon Sep 07 15:36:57 2009 +0000
+++ b/geometry.cpp	Tue Sep 08 12:15:39 2009 +0000
@@ -3,6 +3,8 @@
 #include <math.h>
 #include "misc.h"
 
+#include <QString>
+
 #include <iostream>
 using namespace std;
 
@@ -46,6 +48,48 @@
     return false;	
 }
 
+Vector::Vector ():QPointF ()
+{
+}
+
+Vector::Vector (const QPointF &p):QPointF (p)
+{
+}
+
+Vector::Vector (qreal x, qreal y):QPointF (x,y)
+{
+}
+
+//! Normalize vector
+void Vector::normalize ()
+{
+	if (x()==0 && y()==0) return;
+	qreal l=sqrt ( x()*x() + y()*y() );
+	setX (x()/l);
+	setY (y()/l);
+}
+
+//! Dot product of two vectors
+qreal Vector::dotProduct (const QPointF &b)
+{
+	return x()*b.x() + y()*b.y();
+}
+
+
+void Vector::scale (const qreal &f)
+{
+	setX (x()*f);
+	setY (y()*f);
+}
+
+void Vector::invert ()
+{
+	setX (-x());
+	setY (-y());
+}
+
+/*! Calculate the projection of a polygon on an axis
+    and returns it as a [min, max] interval  */
 ConvexPolygon::ConvexPolygon ()
 {
 }
@@ -89,45 +133,43 @@
 	return _area;
 }
 
-//! Normalize vector
-QPointF normalize (const QPointF &p)
+std::string ConvexPolygon::toStdString()
 {
-	if (p==QPointF(0,0)) return p;
-	qreal l=sqrt ( p.x()*p.x() + p.y()*p.y() );
-	return QPointF (p.x()/l,p.y()/l);
+	QString s ("(");
+	for (int i=0;i<size();++i)
+	{
+		s+=QString("(%1,%2)").arg(at(i).x()).arg(at(i).y());
+		if (i<size()-1) s+=",";
+	}
+	s+=")";	
+	return s.toStdString();
 }
 
-//! Dot product of two vectors
-qreal dotProduct (const QPointF &a, const QPointF &b)
+Vector ConvexPolygon::at(const int &i) const
 {
-	return a.x()*b.x() + a.y()*b.y();
+	return Vector (QPolygonF::at(i).x(),QPolygonF::at(i).y());
 }
 
+void ConvexPolygon::translate ( const Vector & offset )
+{ translate (offset.x(),offset.y());}
 
-QPointF scale (const QPointF &v,const qreal &f)
+void ConvexPolygon::translate ( qreal dx, qreal dy )
 {
-	return QPointF (v.x()*f,v.y()*f);
+	QPolygonF::translate (dx,dy);
+	_centroid=_centroid+QPointF (dx,dy);
 }
 
-QPointF invert (const QPointF &v)
-{
-	return QPointF (-v.x(),-v.y());
-}
-
-/*! Calculate the projection of a polygon on an axis
-    and returns it as a [min, max] interval  */
-
-void projectPolygon(QPointF axis, QPolygonF polygon, qreal &min, qreal &max) 
+void projectPolygon(Vector axis, ConvexPolygon polygon, qreal &min, qreal &max) 
 {
     // To project a point on an axis use the dot product
 
 	//cout << "Projecting on "<< axis<<endl;
-    qreal d = dotProduct(axis,polygon.at(0));
+    qreal d = axis.dotProduct(polygon.at(0));
     min = d;
     max = d;
     for (int i = 0; i < polygon.size(); i++) 
 	{
-        d= dotProduct (polygon.at(i),axis);
+        d= polygon.at(i).dotProduct (axis);
         if (d < min) 
             min = d;
         else 
@@ -153,8 +195,8 @@
  of the polygons (i.e. velocityA - velocityB)
 */
 
-PolygonCollisionResult polygonCollision(QPolygonF polygonA, 
-                              QPolygonF polygonB, QPointF velocity) 
+PolygonCollisionResult polygonCollision(ConvexPolygon polygonA, 
+                              ConvexPolygon polygonB, Vector velocity) 
 {
     PolygonCollisionResult result;
     result.intersect = true;
@@ -207,8 +249,8 @@
 
         // Find the axis perpendicular to the current edge
 
-        QPointF axis (-edge.y(), edge.x());
-        axis=normalize(axis);
+        Vector axis (-edge.y(), edge.x());
+        axis.normalize();
 
         // Find the projection of the polygon on the current axis
 
@@ -226,7 +268,7 @@
 
         // Project the velocity on the current axis
 
-        qreal velocityProjection = dotProduct(axis,velocity);
+        qreal velocityProjection = axis.dotProduct(velocity);
 
         // Get the projection of polygon A during the movement