areas

src/data/Coordinates.java

@@ -80,6 +80,16 @@ public class Coordinates {
 		}
 		return false;
 	}
+	
+	/**
+	 * Cette methode renvoie une distance Mathématique, sans unitée de mesure et non une distance en KM comme le fait DistanceAvec.
+	 * @param p2
+	 * @return Une distance mathématique, sans unitée de mesure.
+	 */
+	
+	public double distanceWithPoint(Coordinates p2) {
+		return Math.sqrt(Math.pow(this.latitude-p2.latitude, 2) + Math.pow(this.longitude-p2.longitude, 2) );
+	}
 
 	/** (non-Javadoc)
 	 * @see java.lang.Object#toString()

src/data/PointInPoligonTest.java

@@ -1,10 +1,84 @@
 package data;
 
-public class PointInPoligonTest {
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
 
-	public static void main(String[] args) {
-		// TODO Auto-generated method stub
+public class PointInPoligonTest {
+	Coordinates a = new Coordinates(2,3);
+	Coordinates b = new Coordinates(3, -1);
+	Coordinates c = new Coordinates(-2, -2);
+	Coordinates d = new Coordinates(-3, 1);
+	Coordinates c1 = new Coordinates(2, 2);
+	Coordinates c2 = new Coordinates(2.5, 2);
+	Coordinates c3 = new Coordinates(-2.26, -0.82);
+	Coordinates c4 = new Coordinates(-2.77, 0.96);
+	Coordinates c5 = new Coordinates(-3.03, 0.82);
+	Coordinates c6 = new Coordinates(1.95, -0.79);
+	Coordinates c7 = new Coordinates(-0.36, 2.17);
+	Coordinates c8 = new Coordinates(3.31, -0.72);
+	Coordinates c9 = new Coordinates(-0.42, -1.74);
+	Coordinates c10 = new Coordinates(0.37, 3.75);
+	Coordinates c11 = new Coordinates(0, 0);
+	Coordinates c12 = new Coordinates(0, -1.36);
+	
 
+	@Test
+	public void testP1P() {
+		Polygon p = new Polygon();
+		p.add(a);
+		p.add(b);
+		p.add(c);
+		p.add(d);
+		
+		
+		
+		System.out.println("===== C1 ====="+true);
+		assertTrue(p.isInPolygon(c1));
+		System.out.println("===== C2 ====="+false);
+		assertFalse(p.isInPolygon(c2));
+		System.out.println("===== C3 ====="+true);
+		assertTrue(p.isInPolygon(c3));
+		System.out.println("===== C4 ====="+true);
+		assertTrue(p.isInPolygon(c4));
+		System.out.println("===== C5 ====="+false);
+		assertFalse(p.isInPolygon(c5));
+		System.out.println("===== C6 ====="+true);
+		assertTrue(p.isInPolygon(c6));
+		System.out.println("===== C7 ====="+false);
+		assertFalse(p.isInPolygon(c7));
+		System.out.println("===== C8 ====="+false);
+		assertFalse(p.isInPolygon(c8));
+		System.out.println("===== C9 ====="+false);
+		assertFalse(p.isInPolygon(c9));
+		System.out.println("===== C10 ====="+false);
+		assertFalse(p.isInPolygon(c10));
+		System.out.println("===== C11 ====="+true);
+		assertTrue(p.isInPolygon(c11));
+		System.out.println("===== C12 ====="+true);
+		assertTrue(p.isInPolygon(c12));
+	}
+	
+	@Test
+	public void distanceAvecTest() {
+		assertEquals(1.85, c3.distanceWithPoint(c4),0.1);
+		assertEquals(1.85, c4.distanceWithPoint(c3),0.1);
+		assertEquals(2.2, c11.distanceWithPoint(c7),0.1);
+		assertEquals(5.17, c5.distanceWithPoint(c1),0.1);
+		assertEquals(4.74, c9.distanceWithPoint(c2),0.1);
+		assertEquals(5.32, c8.distanceWithPoint(c10),0.1);
+		assertEquals(2.03,c12.distanceWithPoint(c6),0.1);
+		
+	}
+	
+	@Test
+	public void longitudeCorrespondingTotheLatTest() {
+		Segment s1 = new Segment(c, d);
+		assertEquals(-0.5, s1.getLongitudeCorrespondingToTheLatitude(-2.5), 0.1);
+		Segment s2 = new Segment(a, b);
+		assertEquals(2.5, s2.getLongitudeCorrespondingToTheLatitude(1),0.1);
 	}
 
 }

src/data/Polygon.java

@@ -19,8 +19,6 @@ public class Polygon {
 	public boolean addPoint(Coordinates point) {
 		return this.points.add(point);
 	}
-	
-	
 
 	public boolean isEmpty() {
 		return points.isEmpty();
@@ -65,19 +63,30 @@ public class Polygon {
 			Segment s = getSegment(i);
 			if(s.isLatitudeBeetweenTheTwoPoints(latitude)) {
 				res.add(s);
+				System.out.println("Segment: "+s+" crossing the lat");
+			}else {
+				System.out.println("Segment: "+s+" NOT crossing the lat");
 			}
 		}
 		return res;
 	}
 	
 	public boolean isInPolygon(Coordinates coordinates) {
-		List<Segment> segmentsInTheLatitude =  getAllSegmentsOfThePolygonForTheLatitude(coordinates.getLatitude());
+		List<Segment> segmentsInTheLatitude = getAllSegmentsOfThePolygonForTheLatitude(coordinates.getLatitude());
 		int segmentsCrossed = 0;
+		boolean res = false;
 		for(Segment s : segmentsInTheLatitude) {
 			double longitude = s.getLongitudeCorrespondingToTheLatitude(coordinates.getLatitude());
-			if(longitude<=coordinates.getLongitude()) segmentsCrossed++;
+			if(longitude<=coordinates.getLongitude()) {
+				segmentsCrossed++;
+				res = !res;
+				System.out.println(s+" a une longitude <= a celle demandée, on incrémente");
+			}else {
+				System.out.println(s+" a une longitude > a celle demandée");
+			}
+			System.out.println("On a croisé "+segmentsCrossed+" segments");
 		}
-		return (segmentsCrossed / 2) == 1;  //nombre impair de croisement de segments: on est dans le polygone.
+		return res;
 	}
 	
 	

src/data/Segment.java

@@ -37,21 +37,46 @@ public class Segment {
 	 * @param latitude latitude qui est censée se situer entre celle des deux points.
 	 * @return longitude correspondante a la latitude sur le segment.
 	 */
-	public double getLongitudeCorrespondingToTheLatitude(double latitude) {
-		Coordinates pointsTriangle;
+	public double getLongitudeCorrespondingToTheLatitude2(double latitude) {
+		Coordinates pointsTriangle,xlat;
+		
 		if(c1BiggestLat()) {
 			pointsTriangle = new Coordinates(c1.getLatitude(), c2.getLongitude());
+			double distPtC1= pointsTriangle.distanceWithPoint(c1);
+			double distPtC2=pointsTriangle.distanceWithPoint(c2);
+			xlat = new Coordinates(latitude,c1.getLongitude());
+			double rapport = xlat.distanceWithPoint(c1)/distPtC1;
+			return c1.getLatitude()+(rapport*(distPtC2));
 		}else {
 			pointsTriangle = new Coordinates(c2.getLatitude(), c1.getLongitude());
+			double distPtC1= pointsTriangle.distanceWithPoint(c1);
+			double distPtC2=pointsTriangle.distanceWithPoint(c2);
+			xlat = new Coordinates(latitude,c2.getLongitude());
+			double rapport = xlat.distanceWithPoint(c2)/distPtC2;
+			return c2.getLatitude()+(rapport*(distPtC1));
 		}
-		double distPtC1=pointsTriangle.distanceAvec(c1);
-		double distPtC2=pointsTriangle.distanceAvec(c2);
-		double rapport = new Coordinates(latitude,c2.getLongitude()).distanceAvec(c2)/distPtC2;
-		return c2.getLatitude()+(rapport*(distPtC1));
+		
 	}
 	
+	public double getLongitudeCorrespondingToTheLatitude(double latitude) {
+		double difflat = c1.getLatitude()-c2.getLatitude();
+		double difflon = c1.getLongitude()-c2.getLongitude();  //différence signée pour aller dans le bon sens
+		double difflatlat = c1.getLatitude()-latitude;
+		try {
+		return c1.getLongitude()+(difflatlat/difflon)*difflat;
+		}catch (Exception e) {
+			return c1.getLongitude();
+		}
+		
+	}
+
+	
 	public boolean c1BiggestLat() {
 		return c1.getLatitude()>=c2.getLatitude();
 	}
 
+	@Override 
+	public String toString() {
+		return "[("+c1.getLatitude()+","+c1.getLongitude()+"),("+c2.getLatitude()+","+c2.getLongitude()+")]";
+	}
 }