def __init__(self, points): assert len(points) >= 3 assert reduce(operator.and_, [isinstance(p, euclid.Point3) for p in points]) self.plane = euclid.Plane(points[0], points[1], points[2]) n = self.plane.n self.edge_planes = [ \ euclid.Plane(p1, (p2 - p1).cross(n)) \ for p1, p2 in map(None, points[:], points[1:] + [points[0]]) if (p2 - p1).cross(n)] # Filter out edges that are colinear with # normal (non-planar polygon) self.point = points[0] # An arbitrary point on this polygon # Axis aligned bounding box p1 = points[0].copy() p2 = points[0].copy() for p in points[1:]: if p.x < p1.x: p1.x = p.x if p.y < p1.y: p1.y = p.y if p.z < p1.z: p1.z = p.z if p.x > p2.x: p2.x = p.x if p.y > p2.y: p2.y = p.y if p.z > p2.z: p2.z = p.z self.aabbox = p1, p2
def __init__(self,i1,i2,i3,p1,p2,p3): self.vertex_indices=[i1,i2,i3]; self.vertices=[p1,p2,p3]; #list of vertices self.plane=euclid.Plane(self.vertices[0],self.vertices[1],self.vertices[2]); self.plane.n.normalize(); self.v1=self.vertices[1]-self.vertices[0]; self.v2=self.vertices[2]-self.vertices[0];
def __init__(self, origin=euclid.Point3(0., 0., 0.), squaresize=4, normal=euclid.Vector3(0., 0., 1.), roughness=1.0, transparency=0.0, refractionIndex=1.0): super().__init__(color=(255, 255, 255), roughness=roughness, transparency=transparency, refractionIndex=refractionIndex) self.shape = euclid.Plane(origin, normal) normal = normal.normalized() self.squaresize = squaresize # let's find the unit vectors ux = euclid.Vector3(0., 1., 0.) uy = euclid.Vector3(0., 0., 1.) un = euclid.Vector3(1., 0., 0.) # 'original' normal # rotation axis axis = un.cross(normal) # cos(angle) between normal and unit normal angle = normal.dot(un) angle = math.acos(angle) rotation = euclid.Quaternion.new_rotate_axis(angle, axis) self.unitx = rotation * ux self.unity = rotation * uy
def calculateRepr(self): # first, reset to default values Ly = -self.zoom * math.tan(self.LRAngle / 2) Ry = -Ly self.L = P3(0, Ly, 0) - self.focus # to leftmost point on mid row of screen self.R = P3(0, Ry, 0) - self.focus # to rightmost "" "" self.D = V3(-1, 0, 0) * self.zoom # line from camera to screen. # figure out up angle # first get x distance x = Ry * 2 y = 1.0 / self.aspectRatio * x # next use trig to figure out up angle self.TBAngle = math.atan(y / 2 / self.zoom) * 2 Tz = self.zoom * math.tan(self.TBAngle / 2) Bz = -self.zoom * math.tan(self.TBAngle / 2) self.T = V3( 0, 0, Tz) - self.focus # to topmost point on mid column of screen self.B = V3(0, 0, Bz) - self.focus # to bottommost "" "" # screen's plane self.screenPlane = euclid.Plane(P3( 0, 0, 0), self.D) # the normal is the line from cam to screen. # Next, rotate all vectors accordingly. for i in xrange(3): if self.rotation[i] != 0: t = self.rotation[i] axis = V3(1 if i == 0 else 0, 1 if i == 1 else 0, 1 if i == 2 else 0) self.L = rotateGeneric(self.L, axis, t) self.R = rotateGeneric(self.R, axis, t) self.D = rotateGeneric(self.D, axis, t) self.T = rotateGeneric(self.T, axis, t) self.B = rotateGeneric(self.B, axis, t) self.focus = rotateGeneric(self.focus, axis, t) # Figure out the basic vectors for the screen. self.basic_horizontal = self.R - self.L self.basic_vertical = self.B - self.T # Topleft corner finding. self.topleft = self.focus + self.L + self.basic_vertical * .5
def rotateGeneric(shape, k, t): if type(shape) == V3: return rotate(shape, k, t) if type(shape) == P3: v = rotate(shape, k, t) return P3(v.x, v.y, v.z) if type(shape) == R3: v, p = R3.v, R3.p out = R3(p, v) out.v = rotate(v, k, t) out.p = rotate(p, k, t) return out if type(shape) == euclid.Plane: n, k = shape.n, shape.k out = euclid.Plane(n, k) out.n = rotate(n, k, t) return out if type(shape) == euclid.Sphere: c, r = shape.c, shape.r out = euclid.Sphere(c, r) out.c = rotate(c, k, t) return out raise TypeError("Argument type for shape(" + type(shape) + ") is unknown.")