Mercurial > bus-service / file diff

--- a/geometry.py	Thu Mar 29 23:55:36 2018 +0300
+++ b/geometry.py	Fri Apr 13 17:32:40 2018 +0300
@@ -1,124 +1,124 @@
 from math import sqrt, hypot, radians, sin, cos, atan2
 
-class Sijainti:
-	def __init__(self, leveys, pituus):
-		self.leveys, self.pituus = leveys, pituus
-	def etäisyys(tämä, toinen):
+class Location:
+	def __init__(self, latitude, longitude):
+		self.latitude, self.longitude = latitude, longitude
+	def distance(self, other):
 		# https://stackoverflow.com/a/365853
-		a = sin(radians(tämä.leveys - toinen.leveys) / 2) ** 2
-		a += sin(radians(tämä.pituus - toinen.pituus) / 2) ** 2 * cos(radians(tämä.leveys)) * cos(radians(toinen.leveys))
+		a = sin(radians(self.latitude - other.latitude) / 2) ** 2
+		a += sin(radians(self.longitude - other.longitude) / 2) ** 2 * cos(radians(self.latitude)) * cos(radians(other.latitude))
 		return 6371 * 2 * atan2(sqrt(a), sqrt(1 - a))
 	def __repr__(self):
-		return '%s(%r, %r)' % (type(self).__name__, self.leveys, self.pituus)
+		return '%s(%r, %r)' % (type(self).__name__, self.latitude, self.longitude)
 	def __str__(self):
-		return '%.5f, %.5f' % (self.leveys, self.pituus)
+		return '%.5f, %.5f' % (self.latitude, self.longitude)
 	@property
 	def x(self):
-		return self.leveys
+		return self.latitude
 	@property
 	def y(self):
-		return self.pituus
+		return self.longitude
 	@property
 	def link_to_map(self):
-		return 'http://www.openstreetmap.org/#map=19/%f/%f' % (self.leveys, self.pituus)
+		return 'http://www.openstreetmap.org/#map=19/%f/%f' % (self.latitude, self.longitude)
 
-class Rengas:
-	def __init__(tämä, säiliö):
-		tämä.säiliö = säiliö
-	def __getitem__(tämä, indeksi):
-		while indeksi < 0:
-			indeksi += len(tämä.säiliö)
-		while indeksi >= len(tämä.säiliö):
-			indeksi -= len(tämä.säiliö)
-		return tämä.säiliö[indeksi]
-	def __iter__(tämä):
-		return iter(tämä.säiliö)
-	def __len__(tämä):
-		return len(tämä.säiliö)
+class Ring:
+	def __init__(self, container):
+		self.container = container
+	def __getitem__(self, i):
+		while i < 0:
+			i += len(self.container)
+		while i >= len(self.container):
+			i -= len(self.container)
+		return self.container[i]
+	def __iter__(self):
+		return iter(self.container)
+	def __len__(self):
+		return len(self.container)
 
-class Monikulmio:
-	def __init__(self, *pisteet):
-		self.pisteet = pisteet
+class Polygon:
+	def __init__(self, *points):
+		self.points = points
 	def __repr__(self):
-		return '%s(%s)' % (type(self).__name__, ', '.join(map(repr, self.pisteet)))
-	def pinta_ala(self):
-		rengas = Rengas(self.pisteet)
+		return '%s(%s)' % (type(self).__name__, ', '.join(map(repr, self.points)))
+	def area(self):
+		ring = Ring(self.points)
 		return sum(
-			rengas[i].x * rengas[i + 1].y - rengas[i + 1].x * rengas[i].y
-			for i in range(len(rengas))
+			ring[i].x * ring[i + 1].y - ring[i + 1].x * ring[i].y
+			for i in range(len(ring))
 		) / 2
-	def piiri(self):
-		rengas = Rengas(self.pisteet)
+	def circumference(self):
+		ring = Ring(self.points)
 		return sum(
-			sqrt((rengas[i + 1].x - rengas[i].x)**2 + (rengas[i + 1].y - rengas[i].y)**2)
-			for i in range(len(rengas))
+			sqrt((ring[i + 1].x - ring[i].x)**2 + (ring[i + 1].y - ring[i].y)**2)
+			for i in range(len(ring))
 		)
-	def painopiste(self):
-		rengas = Rengas(self.pisteet)
+	def centroid(self):
+		ring = Ring(self.points)
 		x = sum(
-			(rengas[i].x + rengas[i + 1].x) * (rengas[i].x * rengas[i + 1].y - rengas[i + 1].x * rengas[i].y)
-			for i in range(len(rengas))
-		) / 6 / self.pinta_ala()
+			(ring[i].x + ring[i + 1].x) * (ring[i].x * ring[i + 1].y - ring[i + 1].x * ring[i].y)
+			for i in range(len(ring))
+		) / 6 / self.area()
 		y = sum(
-			(rengas[i].y + rengas[i + 1].y) * (rengas[i].x * rengas[i + 1].y - rengas[i + 1].x * rengas[i].y)
-			for i in range(len(rengas))
-		) / 6 / self.pinta_ala()
-		return self.pistetyyppi()(x, y)
-	def pistetyyppi(self):
-		if len(self.pisteet):
-			return type(self.pisteet[0])
+			(ring[i].y + ring[i + 1].y) * (ring[i].x * ring[i + 1].y - ring[i + 1].x * ring[i].y)
+			for i in range(len(ring))
+		) / 6 / self.area()
+		return self.point_type()(x, y)
+	def point_type(self):
+		if len(self.points):
+			return type(self.points[0])
 		else:
-			return Piste
-	def piiri_janat(self):
-		rengas = Rengas(self.pisteet)
-		for i in range(len(rengas)):
-			yield Jana(rengas[i], rengas[i + 1])
-	def sisältää_pisteen(self, piste):
-		ulkopiste = self.pistetyyppi()(
-			min(piste.x for piste in self.pisteet) - 1,
-			min(piste.y for piste in self.pisteet) - 1
+			return Point
+	def segments(self):
+		ring = Ring(self.points)
+		for i in range(len(ring)):
+			yield LineSegment(ring[i], ring[i + 1])
+	def contains_point(self, point):
+		outer_point = self.point_type()(
+			min(point.x for point in self.points) - 1,
+			min(point.y for point in self.points) - 1
 		)
-		ulkojana = Jana(piste, ulkopiste)
-		leikkauksia = 0
-		for jana in self.piiri_janat():
-			if jana.leikkauspiste(ulkojana) is not None:
-				leikkauksia += 1
-		return bool(leikkauksia & 1)
+		outer_segment = LineSegment(point, outer_point)
+		intersections = 0
+		for segment in self.segments():
+			if segment.intersection(outer_segment) is not None:
+				intersections += 1
+		return bool(intersections & 1)
 
-class Jana:
-	def __init__(self, alkupiste, päätepiste):
-		self.alkupiste, self.päätepiste = alkupiste, päätepiste
+class LineSegment:
+	def __init__(self, p1, p2):
+		self.p1, self.p2 = p1, p2
 	def __repr__(self):
-		return 'Jana(%r, %r)' % (self.alkupiste, self.päätepiste)
-	def pituus(self):
-		return hypot(self.alkupiste.x - self.päätepiste.x, self.alkupiste.y - self.päätepiste.y)
-	def leikkauspiste(tämä, toinen):
-		pistetyyppi = type(tämä.alkupiste)
-		x = (tämä.alkupiste.x, tämä.päätepiste.x, toinen.alkupiste.x, toinen.päätepiste.x)
-		y = (tämä.alkupiste.y, tämä.päätepiste.y, toinen.alkupiste.y, toinen.päätepiste.y)
+		return 'LineSegment(%r, %r)' % (self.p1, self.p2)
+	def length(self):
+		return hypot(self.p1.x - self.p2.x, self.p1.y - self.p2.y)
+	def intersection(self, other):
+		point_type = type(self.p1)
+		x = (self.p1.x, self.p2.x, other.p1.x, other.p2.x)
+		y = (self.p1.y, self.p2.y, other.p1.y, other.p2.y)
 		try:
-			jakaja = (x[0] - x[1]) * (y[2] - y[3]) - (y[0] - y[1]) * (x[2] - x[3])
-			Px = ((x[0] * y[1] - y[0] * x[1]) * (x[2] - x[3]) - (x[0] - x[1]) * (x[2] * y[3] - y[2] * x[3])) / jakaja
-			Py = ((x[0] * y[1] - y[0] * x[1]) * (y[2] - y[3]) - (y[0] - y[1]) * (x[2] * y[3] - y[2] * x[3])) / jakaja
-			etäisyys = lambda n: (Px - x[n]) ** 2 + (Py - y[n]) ** 2
-			if max(etäisyys(0), etäisyys(1)) <= tämä.pituus() ** 2 and max(etäisyys(2), etäisyys(3)) <= toinen.pituus() ** 2:
-				return pistetyyppi(Px, Py)
+			denominator = (x[0] - x[1]) * (y[2] - y[3]) - (y[0] - y[1]) * (x[2] - x[3])
+			Px = ((x[0] * y[1] - y[0] * x[1]) * (x[2] - x[3]) - (x[0] - x[1]) * (x[2] * y[3] - y[2] * x[3])) / denominator
+			Py = ((x[0] * y[1] - y[0] * x[1]) * (y[2] - y[3]) - (y[0] - y[1]) * (x[2] * y[3] - y[2] * x[3])) / denominator
+			distance = lambda n: hypot(Px - x[n], Py - y[n])
+			if max(distance(0), distance(1)) <= self.length() and max(distance(2), distance(3)) <= other.length():
+				return point_type(Px, Py)
 			else:
 				return None
 		except ZeroDivisionError:
 			return None
 
-class Piste:
+class Point:
 	def __init__(self, x, y):
 		self.x, self.y = x, y
 	def __repr__(self):
-		return 'Piste(%r, %r)' % (self.x, self.y)
+		return 'Point(%r, %r)' % (self.x, self.y)
 
-A = Monikulmio(
-	Piste(2,3),
-	Piste(1,1),
-	Piste(4,0),
-	Piste(6,2),
-	Piste(4,4))
-L1 = Jana(Piste(1, 1), Piste(-1, 5))
-L2 = Jana(Piste(1, 5), Piste(5, 1))
+A = Polygon(
+	Point(2,3),
+	Point(1,1),
+	Point(4,0),
+	Point(6,2),
+	Point(4,4))
+L1 = LineSegment(Point(1, 1), Point(-1, 5))
+L2 = LineSegment(Point(1, 5), Point(5, 1))