Added planes

geometry.py

@@ -10,15 +10,15 @@ def __init__(self, slope, start):
         self.start = start
 
     @staticmethod
-    def throughPoints(point0, point1):
+    def through_points(point0, point1):
         """
         Creates a line that passes in two given points 
         """
         x1, y1, z1 = point1
         x0, y0, z0 = point0
         return Line((x1 - x0, y1 - y0, z1 - z0), (x0, y0, z0))
 
-    def distanceToPoint(self, point):
+    def distance_to_point(self, point):
         """
         Returns the distance between a line and a point
         """
@@ -29,6 +29,25 @@ def distanceToPoint(self, point):
         proj = vec.project(v)
         return (proj.subtract(vec)).norm()
 
+    def point_after_t(self, num):
+        p = Vector(self.start)
+        q = Vector(self.slope)
+        return p.add(q.mul_by_number(num))
+
+class HorizontalPlane():
+    def __init__(self, cte, color):
+        self.cte = cte
+        self.color = color
+
+    def intersect(self, line):
+        return line.slope[2] != 0
+
+    def intersection_value(self, line):
+return float(self.cte -  line.start[2])/line.slope[2]
+
+    def color_at_point(self, p):
+        return (0, 200, 0) if int(p[0]) % 2 == int(p[1]) % 2 else (0, 0, 200)
+
 class Sphere():
     def __init__(self, center, radius, color):
         """
@@ -41,7 +60,7 @@ def __init__(self, center, radius, color):
         self.color = color
 
     def intersect(self, line):
-        return line.distanceToPoint(self.center) <= self.radius
+        return line.distance_to_point(self.center) <= self.radius
 
     def intersection_value(self, line):
         v = Vector(line.slope)
@@ -52,6 +71,9 @@ def intersection_value(self, line):
         B = sum(-2*x*y for (x, y) in zip(v.coords, q.coords))
         C = sum(y*y for y in q.coords) - self.radius**2
         return solve_quadradic((A, B, C))
+
+    def color_at_point(self, p):
+        return self.color
 
 class Vector():
     def __init__(self, coords):
@@ -63,6 +85,9 @@ def scalar_product(self, v2):
     def subtract(self, v2):
         return Vector([self.coords[0] - v2.coords[0], self.coords[1] - v2.coords[1], self.coords[2] - v2.coords[2]])
 
+    def add(self, v2):
+        return Vector([self.coords[0] + v2.coords[0], self.coords[1] + v2.coords[1], self.coords[2] + v2.coords[2]])
+
     def norm(self):
         return sqrt(sum(x**2 for x in self.coords))
 

render.py

@@ -12,27 +12,33 @@ def coordinates(num, sz = size):
     """
     return 4.0*num/(sz - 1) - 2.0
 
-# Creating the world
-S1 = Sphere((1, 0, 0), 0.5, (10, 220, 0))
-S2 = Sphere((0.6, 0, 0), 0.5, (200, 10, 200))
+def create_world():
+    S1 = Sphere((0, 0, 0), 0.5, (100, 220, 0))
+    S2 = Sphere((0, 0, 0), 1, (200, 10, 200))
+    S3 = Sphere((1, 1, -3), 0.4, (100, 100, 200))
+    P = HorizontalPlane(0, (200, 200, 200))
+    return [S1, S2, S3, P]
+
+world = create_world()
 camera = (0, 0, -8)
-world = [S1, S2]
+light = (0, 10, 0)
 
 # Colouring each pixel
 for i in range(size):
     x0 = coordinates(i)
     for j in range(size):
         y0 = coordinates(j)
-        l = Line.throughPoints(camera, (x0, y0, -5))
+        l = Line.through_points(camera, (x0, y0, -5))
         ans = []
         for S in world: 
             if S.intersect(l):
-                ans.append((S.intersection_value(l), S))
+                t = S.intersection_value(l)
+                p = l.point_after_t(t)
+                ans.append((t, S, p.coords))
         if not ans:
             rays[i, j] = (255, 255, 255)
         else:
             ans.sort()
-            rays[i, j] = ans[0][1].color
+            rays[i, j] = ans[0][1].color_at_point(ans[0][2])
 
-
 tmp.save(path)