예제 #1
0
파일: Light.py 프로젝트: hanton/pyTracer
class EnvironmentLight(Light):
    def __init__(self, material, sampler, cast_shadow):
        self.material    = material
        self.sampler     = sampler
        self.cast_shadow = cast_shadow
        
        self.sampler.map_samples_to_hemisphere(1)
        self.u, self.v, self.w = Vector(0.0, 0.0, 0.0), Vector(0.0, 0.0, 0.0), Vector(0.0, 0.0, 0.0)
        self.wi = Vector(0.0, 0.0, 0.0)

    def get_direction(self, shading_point):
        self.w = shading_point.normal
        up     = Vector(0.003, 1.0, 0.007)
        self.v = up.cross(self.w)
        self.v = self.v.normalize()
        self.u = self.v.cross(self.w)
        sp = self.sampler.sample_hemisphere()
        self.wi = self.u.scalar(sp.x) + self.v.scalar(sp.y) + self.w.scalar(sp.z)
        return self.wi.scalar(-1.0)

    def in_shadow(self, ray, shading_point):
        for shape in shading_point.scene.shapes:
            if shape.shadow_hit(ray):
                return True

        return False

    def L(self):
        return self.material.Le()

    def G(self, shading_point):
        return 1.0

    def pdf(self, shading_point):
        return shading_point.normal.dot(self.wi) / math.pi
예제 #2
0
파일: Light.py 프로젝트: hanton/pyTracer
    def __init__(self, shape, cast_shadow):
        self.shape       = shape
        self.cast_shadow = cast_shadow

        self.sample       = Vector(0.0, 0.0, 0.0)
        self.light_normal = Vector(0.0, 0.0, 0.0)
        self.wi           = Vector(0.0, 0.0, 0.0)
예제 #3
0
파일: Light.py 프로젝트: hanton/pyTracer
 def __init__(self, material, sampler, cast_shadow):
     self.material    = material
     self.sampler     = sampler
     self.cast_shadow = cast_shadow
     
     self.sampler.map_samples_to_hemisphere(1)
     self.u, self.v, self.w = Vector(0.0, 0.0, 0.0), Vector(0.0, 0.0, 0.0), Vector(0.0, 0.0, 0.0)
     self.wi = Vector(0.0, 0.0, 0.0)
예제 #4
0
파일: Light.py 프로젝트: hanton/pyTracer
 def get_direction(self, shading_point):
     self.w = shading_point.normal
     up     = Vector(0.003, 1.0, 0.007)
     self.v = up.cross(self.w)
     self.v = self.v.normalize()
     self.u = self.v.cross(self.w)
     sp = self.sampler.sample_hemisphere()
     self.wi = self.u.scalar(sp.x) + self.v.scalar(sp.y) + self.w.scalar(sp.z)
     return self.wi.scalar(-1.0)
예제 #5
0
파일: Material.py 프로젝트: hanton/pyTracer
    def sample_f(self, shading_point):
        w = shading_point.normal
        # jitter the up vector
        v = Vector(0.0024, 1.0, 0.0081).cross(w)
        v = v.normalize()
        u = v.cross(w)

        sample_point = self.sampler.sample_hemisphere()
        wi = sample_point.x * u + sample_point.y * v + sample_point.z * w
        wi = wi.normalize()
        pdf = shading_point.normal * wi / math.pi
        color = self.surface.get_color(shading_point)
        return pdf, wi, (self.kd * color / math.pi)
예제 #6
0
    def _calculate_intersection(self, ray, frustum):
        # Calculate the positions of the camera and the ray relative to the quadric
        rCam = ray.origin - self._position
        rRay = ray.direction

        # Precalculate these values for our quadratic equation
        V1 = rRay * rRay
        V2 = Vector(rRay.x * rRay.y, rRay.y * rRay.z, rRay.z * rRay.x) * 2
        V3 = rCam * rRay
        V4 = Vector(rRay.x * rCam.y + rCam.x * rRay.y,
                    rCam.y * rRay.z + rRay.y * rCam.z,
                    rCam.x * rRay.z + rRay.x * rCam.z)
        V5 = rRay
        V6 = rCam * rCam
        V7 = Vector(rCam.x * rCam.y, rCam.y * rCam.z, rCam.z * rCam.x) * 2
        V8 = rCam * 2

        # Calculate the quadratic coefficients
        A = dot(self._ABC, V1) + dot(self._DEF, V2)
        B = dot(self._ABC, V3) + dot(self._DEF, V4) + dot(self._GHI, V5)
        C = dot(self._ABC, V6) + dot(self._DEF, V7) + dot(
            self._GHI, V8) + self._equation[9]

        # Calculate the squared value for our quadratic formula
        square = B**2 - A * C

        # No collision if the root is imaginary
        if square < 0:
            return None

        # Take its squareroot if it's real
        root = square**0.5

        # Calculate both intersections
        D1 = (-B - root) / A
        D2 = (-B + root) / A

        # Return closest intersection thats in the frustum
        if frustum.near <= D1 <= frustum.far:
            return D1
        elif frustum.near <= D2 <= frustum.far:
            return D2
        return None
예제 #7
0
파일: Light.py 프로젝트: hanton/pyTracer
class AreaLight(Light):
    def __init__(self, shape, cast_shadow):
        self.shape       = shape
        self.cast_shadow = cast_shadow

        self.sample       = Vector(0.0, 0.0, 0.0)
        self.light_normal = Vector(0.0, 0.0, 0.0)
        self.wi           = Vector(0.0, 0.0, 0.0)

    def get_direction(self, shading_point):
        self.sample = self.shape.sample()
        self.light_normal = self.shape.normal
        self.wi = self.sample - shading_point.hit_point
        self.wi = self.wi.normalize()
        return -1.0 * self.wi

    def in_shadow(self, ray, shading_point):
        ts = (self.sample - ray.origin) * ray.direction
        for shape in shading_point.scene.shapes:
            if shape.shadow_hit(ray) and shape.shadow_t < ts:
                return True

        return False

    def L(self):
        ndotd = -1.0 * self.wi * self.light_normal

        if ndotd > 0.0:
            return self.shape.material.Le()
        else:
            return Color(0.0, 0.0, 0.0)

    def G(self, shading_point):
        ndotd = -1.0 * self.light_normal * self.wi
        d2    = self.sample.distance(shading_point.hit_point)
        d2    = d2 * d2
        return ndotd / d2

    def pdf(self, shading_point):
        return self.shape.pdf()
예제 #8
0
 def _get_normal(self, point):
     relative = point - self._position
     # Compute the generic derivative of the equation at given point
     x = (2 * self._equation.A * relative.x +
          self._equation.E * relative.z + self._equation.F * relative.y +
          self._equation.G)
     y = (2 * self._equation.B * relative.y +
          self._equation.D * relative.z + self._equation.F * relative.x +
          self._equation.H)
     z = (2 * self._equation.C * relative.z +
          self._equation.D * relative.y + self._equation.E * relative.x +
          self._equation.I)
     return Vector(x, y, z).unit()