#------------------------------------------------------------------------------#
#------------------------------------------------------------------------------#
import unittest;
from geometry2d import *;
#------------------------------------------------------------------------------#

# Beachte: Ich habe nur soweit getestet,
# wie ich es fuer meine angepeilten Zwecke brauchte!

class TestVectors(unittest.TestCase):
    def test_str(self):
        vc1=Vectors(1,2);
        self.assertTrue(str(vc1)=='1, 2');

    def test_eq(self):
        vc1=Vectors(1,2);
        self.assertEqual(vc1,Vectors(1,2));
        self.assertEqual(vc1,Vectors(1.0,2.001));
        self.assertNotEqual(vc1,Vectors(1.0,2.01));
        self.assertNotEqual(vc1,Vectors(1,3));

    def test_toUnitVector(self):
        vc1=Vectors(1,2);
        vc2=Vectors(1/sqrt(5),2/sqrt(5));
        vc3=vc1.toUnitVector();
        self.assertEqual(vc2,vc3);

    def test_lengthOf(self):
        vc1=Vectors(1,2);
        vc3=vc1.toUnitVector();
        self.assertNotEqual(vc3.lengthOf(),1);
        self.assertTrue(abs(vc3.lengthOf()-1) <epsilon);

    def test_add(self):
        vc1=Vectors(1,2); vc2=Vectors(2,4);
        self.assertEqual(vc1+vc1,vc2);

    def test_sub(self):
        vc1=Vectors(1,2); vc2=Vectors(2,4);
        vc3=Vectors(1-2,2-4);
        self.assertEqual(vc1-vc2,vc3);

    def test_mul(self):
        vc1=Vectors(1,2);
        self.assertEqual(vc1*2,Vectors(2,4));
        self.assertEqual(2*vc1,Vectors(2,4));

    def test_smul(self):
        vc1=Vectors(1,2); vc2=Vectors(2,4);
        vc1.smul(2);
        self.assertEqual(vc1,vc2);

    def test_rmul(self):
        vc1=Vectors(1.0,2.0); vc2=Vectors(2,4);
        vc3=vc1*2;  # Uses __mul__
        self.assertEqual(vc3,vc2);

    def test_truediv(self):
        vc1=Vectors(1,2); vc2=Vectors(2.0,4.0);
        vc3=vc2/2;  # Uses __truediv__
                    # PyCharm warning ???
        ok=(vc3==vc1);
        self.assertTrue(ok);

    def test_sdiv(self):
        vc1=Vectors(1,2); vc2=Vectors(2,4);
        vc2.sdiv(2);
        self.assertEqual(vc2,vc1);

    def test_dotOp(self):
        vc1=Vectors(1,2);
        self.assertEqual(Vectors.dotOp(vc1,vc1),5);
        self.assertEqual(Vectors.dotOp(Vectors(1,1),Vectors(-1,1)),0);

    def Test_crossOp(self):
        vc1=Vectors(1,2);
        self.assertEqual(Vectors.crossOp(vc1,vc1),0);
        self.assertEqual(Vectors.crossOp(vc1,Vectors(1,3)),1);

    def test_dirAngleOf(self):
        vc4=Vectors(1,1);
        self.assertEqual(vc4.dirAngleOf()*r2d,45);
        vc4=Vectors(-1,1);
        self.assertEqual(vc4.dirAngleOf()*r2d,135);
        vc4=Vectors(-1,-1);
        self.assertEqual(vc4.dirAngleOf()*r2d,225);

    def test_sameDirectionOf(self):
        vc1=Vectors(1,2);
        self.assertTrue(vc1.sameDirectionOf(vc1));
        self.assertTrue(vc1.sameDirectionOf(Vectors(1.0,2.000001)));
        self.assertFalse(vc1.sameDirectionOf(Vectors(1.0,2.00001)));
# end  TestVectors
#------------------------------------------------------------------------------#

class TestPoints(unittest.TestCase):
    def test_eq(self):
        pt1=Points(1,2); pt2=Points(3,2);
        self.assertEqual(pt1,pt1);
        self.assertNotEqual(pt1,pt2);

    def test_str(self):
        pt1=Points(1,2);
        self.assertEqual(str(pt1),'1, 2');

    def test_distanceOf(self):
        pt1=Points(1,2); pt2=Points(3,2);
        self.assertEqual(pt1.distanceOf(pt1),0.0);
        self.assertEqual(pt1.distanceOf(pt2),2.0);
        self.assertEqual(pt2.distanceOf(pt1),2.0);

    def test_sub(self):
        pt1=Points(1,2); pt2=Points(3,2);
        self.assertEqual((pt2-pt1),Vectors(2,0));

    def test_add(self):
        pt1=Points(1,2); vc1=Vectors(1,1);
        self.assertEqual((pt1+vc1),Points(2,3));

    def test_areaOf(self):
        pt3=Points(0,0); pt4=Points(2,0);
        pt5=Points(1,1);
        self.assertEqual(pt3.areaOf(pt4,pt5),1.0);
        self.assertEqual(pt3.areaOf(pt5,pt4),-1.0);
# end TestPoints
#------------------------------------------------------------------------------#

class TestLines(unittest.TestCase):
    def test_eq(self):
        pt1=Points(0,0); pt2=Points(2,2);
        pt3=Points(0,2); pt4=Points(2,0);
        pt5=Points(-2.0,-2.0); pt6=Points(3,3);
        L12=Lines.toLine(pt1,pt2);
        L34=Lines.toLine(pt3,pt4);
        L56=Lines.toLine(pt6,pt5);
        self.assertEqual(L12,L12);
        self.assertEqual(L12,L56);
        self.assertNotEqual(L12,L34);

    def test_intersectionOf(self):
        pt1=Points(0,0); pt2=Points(2,2);
        pt3=Points(0,2); pt4=Points(2,0);
        L12=Lines.toLine(pt1,pt2);
        L34=Lines.toLine(pt3,pt4);
        ipt=Lines.intersectionOf(L12,L34);
        pt5=Points(1,1);
        self.assertEqual(ipt,pt5);
        with self.assertRaises(InfinityPoints):
            Lines.intersectionOf(L12,L12);
        pt7=Points(1,0); pt8=Points(3,2);
        L78=Lines.toLine(pt7,pt8);
        with self.assertRaises(NoPoint):
            Lines.intersectionOf(L12,L78);

    def test_nearestPointOf(self):
        pt1=Points(0,0); pt2=Points(2,2);
        L12=Lines.toLine(pt1,pt2);
        pt5=Points(1,1);
        self.assertEqual(L12.nearestPointOf(pt5),pt5);
        self.assertEqual(L12.nearestPointOf(Points(0,2)),pt5);

    def test_isPointInside(self):
        pt1=Points(0,0); pt2=Points(2,2);
        L12=Lines.toLine(pt1,pt2);
        pt3=Points(0,2); pt6=Points(3,3);
        self.assertTrue(L12.isPointInside(pt6));
        self.assertFalse(L12.isPointInside(pt3));

    def test_distanceOf(self):
        pt1=Points(0,0); pt2=Points(2,2);
        L12=Lines.toLine(pt1,pt2);
        pt3=Points(0,2);
        self.assertTrue(abs(abs(L12.distanceOf(pt3))-sqrt(2))<epsilon);
        self.assertTrue(abs(L12.distanceOf(pt3)-sqrt(2))<epsilon);
        pt4=Points(1,1);
        self.assertTrue(abs(L12.distanceOf(pt4))<epsilon);

    def test_areParallel(self):
        pt1=Points(0,0); pt2=Points(2,2);
        L12=Lines.toLine(pt1,pt2);
        self.assertFalse(Lines.areParallel(L12,L12));
        pt7=Points(1,0); pt8=Points(3,2);
        L78=Lines.toLine(pt7,pt8);
        self.assertTrue(Lines.areParallel(L12,L78));
        pt1a=Points(1,1); pt2a=Points(3,3);
        L12a=Lines.toLine(pt1a,pt2a);
        self.assertFalse(Lines.areParallel(L12,L12a));
        self.assertEqual(L12,L12a);

    def test_getGradientVector(self):
        pt1=Points(0,0); pt2=Points(2,2);
        L12=Lines.toLine(pt1,pt2);
        gv=L12.getNormalVector();
        self.assertTrue(str(gv),'0.7071067811865475, -0.7071067811865475');
        self.assertTrue(gv.isOrthogonalTo(L12.DV));
    # end test_getGradientVector

    def test_getParallelLine(self)->'Lines':
        pt1=Points(0,0); pt2=Points(2,2);
        L12=Lines.toLine(pt1,pt2);
        dist=sqrt(2);
        Lp=L12.getParallelLine(dist);
        pt3=Points(1,1); pt4=Points(3,3);
        L34=Lines.toLine(pt3,pt4);
        self.assertTrue(L34.areParallel(Lp));
        dist1=L12.distanceOf(pt3);
        self.assertTrue((abs(dist1)-dist)<epsilon);
    # end test_getParallelLine
# end TestLines
#------------------------------------------------------------------------------#

class TestRays(unittest.TestCase):
    def test_eq(self):
        sp1=Points(1,1); dir1=Vectors(1,1);
        ray1=Rays(sp1,dir1);
        self.assertEqual(ray1,ray1);

    def test_str(self):
        sp1=Points(1,1); dir1=Vectors(1,1);
        ray1=Rays(sp1,dir1);
        self.assertEqual(str(ray1),'SP: 1, 1 | DV: 0.7071067811865475, 0.7071067811865475');

    def test_toLine(self):
        sp1=Points(1,1); dir1=Vectors(1,1);
        ray1=Rays(sp1,dir1);
        ln1=ray1.toLine();
        ln2=Lines(0.707106781186545,-0.7071067811865475,0.0);
        self.assertEqual(ln1,ln2);

    def test_intersectionOf(self):
        sp1=Points(1,1); dir1=Vectors(1,1);
        ray1=Rays(sp1,dir1);
        sp2=Points(3,1); dir2=Vectors(-1,1);
        ray2=Rays(sp2,dir2);
        ip12=Rays.intersectionOf(ray1,ray2);
        self.assertEqual(ip12,Points(2,2));
        sp3=Points(1,1); dir3=Vectors(-1,1);
        ray3=Rays(sp3,dir3);
        with self.assertRaises(NoPoint):
            Rays.intersectionOf(ray1,ray3);
        with self.assertRaises(InfinityPoints):
            Rays.intersectionOf(ray1,ray1);
        sp4=Points(1,1); dir4=Vectors(-1,-1);
        ray4=Rays(sp4,dir4);
        with self.assertRaises(NoPoint):
            Rays.intersectionOf(ray4,ray1);
        pt1a=Points(3,3); pt1b=Points(5,4);
        ry1a=Rays.toRay(pt1a,pt1b);
        pt2a=Points(1,1); pt2b=Points(3,2);
        ry2a=Rays.toRay(pt2a,pt2b);
        ry2b=Rays.toRay(pt2b,pt2a);
        with self.assertRaises(NoPoint):
            Rays.intersectionOf(ry1a,ry2a);
        with self.assertRaises(NoPoint):
            Rays.intersectionOf(ry1a,ry2b);
        ry3a=Rays.toRay(pt1b,pt1a);
        with self.assertRaises(NoPoint):
            Rays.intersectionOf(ry3a,ry2a);
        with self.assertRaises(NoPoint):
            Rays.intersectionOf(ry3a,ry2b);
# end TestRays
#------------------------------------------------------------------------------#

class TestSectors(unittest.TestCase):
    def test_eq(self):
        sp1=Points(2,0);
        dv1=Vectors(-0.7071067811865475,0.7071067811865475);
        dv3=Vectors(-0.7071067811865476,0.7071067811865476);
        dv2=Vectors(0.4472135954999579, 0.8944271909999159);
        dv4=Vectors(0.447213595499958,  0.894427190999916);
        sc1=Sectors(sp1,dv1,dv2);
        sc2=Sectors(sp1,dv3,dv4);
        self.assertTrue( sc1==sc2);
        sc3=Sectors(sp1,dv1,dv2);
        sc4=Sectors(sp1,dv4,dv3);
        self.assertTrue( sc3==sc4);

    def test_toSector(self):
        pt0=Points(0,0);
        pt1=Points(1,1); pt2=Points(-1,1);
        pt3=Points(2,2); pt4=Points(-2,2)
        sc1=Sectors.toSector(pt0,pt1,pt2);
        sc2=Sectors.toSector(pt0,pt3,pt4);
        self.assertEqual(sc1,sc2);
# end TestSectors
#------------------------------------------------------------------------------#

class TestSegments(unittest.TestCase):
    def test_eq(self):
        pt1=Points(1,1); pt2=Points(2,1);
        sgm=Segments(pt1,pt2);
        self.assertEqual(sgm,sgm);

    def test_str(self):
        pt1=Points(1,1); pt2=Points(2,1);
        sgm=Segments(pt1,pt2);
        self.assertEqual(str(sgm),'1, 1 | 2, 1');

    def test_intersectionOf_withRay(self):
        sp1=Points(2.5,0); dir1=Vectors(-1,1);
        ray1=Rays(sp1,dir1);
        pt1=Points(1,1); pt2=Points(2,1);
        sgm=Segments(pt1,pt2);
        ip1=sgm.intersectionOf_withRay(ray1);
        self.assertEqual(ip1,Points(1.5,1.0));
        self.assertEqual(sgm.distanceOf(pt2),0.0);
        pt0=Points(0,0); dir0=Vectors(1,1);
        ray0=Rays(pt0,dir0);
        with self.assertRaises(NoPoint):
            sgm.intersectionOf_withRay(ray0);
        pt3=Points(1.5,2);
        self.assertEqual(sgm.distanceOf(pt3),1.0);
        pt3=Points(1.5,0);
        self.assertEqual(sgm.distanceOf(pt3),-1.0);
        pt1a=Points(1.4,0);
        pt2a=Points(1.4,2);
        sgma=Segments(pt1a,pt2a);
        ipa=sgm.intersectionOf(sgma);
        self.assertEqual(ipa,Points(1.4,1));
        pt1a=Points(1.3,0);
        pt2b=Points(4,3);
        sgmb=Segments(pt1a,pt2b);
        with self.assertRaises(NoPoint):
            sgm.intersectionOf(sgmb);
        pt4a=Points(1,1);
        pt4b=Points(2,2);
        sgm4=Segments(pt4a,pt4b);
        pt5a=Points(1.5,1.5);
        pt5b=Points(2.5,2.5);
        sgm5=Segments(pt5a,pt5b);
        with self.assertRaises(InfinityPoints):
            sgm4.intersectionOf(sgm5);

    def test_distanceOf(self):
        pt1=Points(1,1); pt2=Points(3,1);
        sgm=Segments(pt1,pt2);
        pta=Points(2,2);
        self.assertEqual(1,sgm.distanceOf(pta));
        pta=Points(2,0);
        self.assertEqual(-1,sgm.distanceOf(pta));
        pta=Points(0,1);
        self.assertEqual(1,sgm.distanceOf(pta));
        pta=Points(0,0);
        self.assertEqual(-sqrt(2),sgm.distanceOf(pta));
        pta=Points(0,2);
        self.assertEqual(sqrt(2),sgm.distanceOf(pta));
        pta=Points(4,0);
        self.assertEqual(-sqrt(2),sgm.distanceOf(pta));
        pta=Points(4,2);
        self.assertEqual(sqrt(2),sgm.distanceOf(pta));
# end TestSegments
#------------------------------------------------------------------------------#

class TestSectorWithSegments(unittest.TestCase):
    def test_getMinimalDistanceSegment(self):
        sp0=Points(0,0);
        dva=Vectors(1,0); dvb=Vectors(0,1);
        secwsgm=SectorWithSegments(sp0,dva,dvb);
        sgm1=Segments(Points(5,0),Points(0,4));
        sgm2=Segments(Points(4,0),Points(0,4));
        sgm3=Segments(Points(4,0),Points(0,5));
        sgms=[sgm1,sgm2,sgm3];
        for sgm in sgms:
            ok=secwsgm.add(sgm);
            if  not ok: raise InvalidDataError('Test data not ok!');
        self.assertEqual(str(secwsgm),"SP: 0, 0 | DV1: 1.0, 0.0 | DV2: 0.0, 1.0 || 5, 0 | 0, 4 | 4, 0 | 0, 4 | 4, 0 | 0, 5 | ")
        minsgm=secwsgm.getMinimalDistanceSegment();
        self.assertEqual(str(minsgm),'4, 0 | 0, 4');
# end SectorWithSegments
#------------------------------------------------------------------------------#

class TestPolygons(unittest.TestCase):
    def test_areaOf(self):
        pt1=Points(1,0); pt2=Points(2,1); pt3=Points(0,1);
        pts1=[pt1,pt2,pt3];
        pg1=Polygons(pts1);
        self.assertTrue(pg1.areaOf()==1.0);
        pts2=[pt1,pt3,pt2];
        pg2=Polygons(pts2);
        self.assertEqual(pg2.areaOf(),-1.0);

    def test_distanceOf(self):
        pt1=Points(1,0); pt2=Points(2,1); pt3=Points(0,1);
        pts1=[pt1,pt2,pt3];
        pg1=Polygons(pts1);
        pt4=Points(2,2);
        self.assertEqual(pg1.distanceOf(pt4),-1.0);

    def test_isPointOnside(self):
        pt1=Points(1,1); pt2=Points(1,2);
        pt3=Points(2,2); pt4=Points(2,1);
        ptL1=[pt1,pt2,pt3,pt4];
        pg1=Polygons(ptL1);
        ptT1=Points(1.75,1.75);
        self.assertTrue(pg1.isPointOnside(ptT1));
        ptT2=Points(2.5,2.5);
        self.assertFalse(pg1.isPointOnside(ptT2));
        pt5=Points(1.25,2.0); pt6=Points(1.5,1.25); pt7=Points(1.75,2.0);
        ptL2=[pt1,pt2,pt5,pt6,pt7,pt3,pt4];
        pg2=Polygons(ptL2);
        self.assertFalse(pg2.isPointOnside(ptT1));
        self.assertTrue(pg2.isPointOnside(pt1));
# end TestPolygons
#------------------------------------------------------------------------------#

class TestTriangles(unittest.TestCase):
    def test_areaOf(self):
        pt1=Points(1,0); pt2=Points(2,1); pt3=Points(0,1);
        tri=Triangles(pt1,pt2,pt3);
        self.assertEqual(tri.areaOf(),1.0);

    def test_isPointInside(self):
        pt1=Points(1,0); pt2=Points(2,1); pt3=Points(0,1);
        tri=Triangles(pt1,pt2,pt3);
        p4=Points(3,3);
        self.assertFalse(tri.isPointInside(p4));
        p4a=Points(1,2);
        self.assertFalse(tri.isPointInside(p4a));
        p4b=Points(0,0);
        self.assertFalse(tri.isPointInside(p4b));
        p4c=Points(2,-1);
        self.assertFalse(tri.isPointInside(p4c));
        p4d=Points(1.0,-0.01);
        self.assertFalse(tri.isPointInside(p4d));
        p5=Points(1.0,0.5);
        self.assertTrue(tri.isPointInside(p5));
# end TestTriangles
#------------------------------------------------------------------------------#

class TestCircles(unittest.TestCase):
    def test_isPointInside(self):
        pt1=Points(2,2);
        cc1=Circles(pt1,1);
        self.assertFalse(cc1.isPointInside(Points(1,1)));
        self.assertTrue(cc1.isPointInside(Points(1.5,2)));

    def test_str(self):
        pt1=Points(2.0,1.0);
        cc1=Circles(pt1,1.0);
        self.assertEqual(str(cc1),'2.0, 1.0 | 1.0');

    def test_toCircle(self):
        pt2=Points(1,1); pt3=Points(2,0); pt4=Points(2,2);
        cc2=Circles.toCircle(pt2,pt3,pt4);
        self.assertEqual(str(cc2),'2.0, 1.0 | 1.0');
        pt5=Points(1,1); pt6=Points(2,1); pt7=Points(3,1);
        with self.assertRaises(Circles.NoCircle):
            Circles.toCircle(pt5,pt6,pt7);
# end TestCircles
#------------------------------------------------------------------------------#

class TestPolygonTrains(unittest.TestCase):
    def test_init(self):
        pt1=Points(1,0); pt2=Points(2,1); pt3=Points(3,0);
        ptList=[pt1,pt2,pt3];
        polyT=PolygonTrains(ptList);
        sgms=polyT.getSegments();
        self.assertEqual(sgms[0],Segments(pt1,pt2));
        self.assertEqual(sgms[1],Segments(pt2,pt3));
# end TestPolygonTrains
#------------------------------------------------------------------------------#
#------------------------------------------------------------------------------#

if __name__ == '__main__':
    unittest.main();

#------------------------------------------------------------------------------#
#------------------------------------------------------------------------------#