Пример #1
0
 def get_frame(self, scene, image):
     raytracer = RayTracer(scene)
     aspect = float(image.height) / float(image.width)
     for y in range(image.height):
         for x in range(image.width):
             x_coefficient = ((x + random()) * 2.0 / image.width) - 1.0
             y_coefficient = ((y + random()) * 2.0 / image.height) - 1.0
             offset = self.right * x_coefficient + self.up * (y_coefficient * aspect)
             sample_direction = (self.view_direction + (offset * tan(self.view_angle * 0.5))).unitize()
             radiance = raytracer.get_radiance(self.view_position, sample_direction)
             image.add_to_pixel(x, y, radiance)
Пример #2
0
 def get_frame(self, scene, image):
     raytracer = RayTracer(scene)
     aspect = float(image.height) / float(image.width)
     for y in range(image.height):
         for x in range(image.width):
             x_coefficient = ((x + random()) * 2.0 / image.width) - 1.0
             y_coefficient = ((y + random()) * 2.0 / image.height) - 1.0
             offset = self.right * x_coefficient + self.up * (y_coefficient * aspect)
             sample_direction = (self.view_direction + (offset * tan(self.view_angle * 0.5))).unitize()
             radiance = raytracer.get_radiance(self.view_position, sample_direction)
             image.add_to_pixel(x, y, radiance)
Пример #3
0
 def get_frame(self, scene, image, frame_type='depth'):
     raytracer = RayTracer(scene)
     aspect = float(image.height) / float(image.width)
     for y in range(image.height):
         for x in range(image.width):
             x_coefficient = ((x + random()) * 2.0 / image.width) - 1.0
             y_coefficient = ((y + random()) * 2.0 / image.height) - 1.0
             offset = self.right * x_coefficient + self.up * (y_coefficient * aspect)
             sample_direction = (self.view_direction + (offset * tan(self.view_angle * 0.5))).unitize()
             if frame_type == 'depth':
                 distance = raytracer.get_distance_to_first_hit(self.view_position, sample_direction)
                 image.add_to_pixel(x, y, distance)
             elif frame_type == 'reverse_depth':
                 distance = raytracer.get_distance_to_last_hit(self.view_position, sample_direction)
                 image.add_to_pixel(x, y, distance)
             else:
                 radiance = raytracer.get_radiance(self.view_position, sample_direction)
                 image.add_to_pixel(x, y, radiance)
Пример #4
0
 def get_frame(self, scene, image):
     
     raytracer = RayTracer(scene)
     aspect = float(image.height) / float(image.width)
     
     for y in range(image.height):
         for x in range(image.width):
             
             ## convert x, y into sample_direction
             
             x_coefficient = ((x + random()) * 2.0 / image.width) - 1.0
             y_coefficient = ((y + random()) * 2.0 / image.height) - 1.0
             
             offset = self.right * x_coefficient + self.up * (y_coefficient * aspect)
             sample_direction = (self.view_direction + (offset * tan(self.view_angle * 0.5))).unitize()
             
             # calculate radiance from that direction
             
             radiance = raytracer.get_radiance(self.view_position, sample_direction)
             
             # and add to image
             
             image.add_radiance(x, y, radiance)
Пример #5
0
    def pixel_accumulated_radiance(self, scene, random, width, height, x, y,
                                   aspect, num_samples):
        raytracer = RayTracer(scene)
        acc_radiance = [0.0, 0.0, 0.0]

        for i in range(num_samples):
            x_coefficient = ((x + random.real64()) * 2.0 / width) - 1.0
            y_coefficient = ((y + random.real64()) * 2.0 / height) - 1.0

            offset = self.right * x_coefficient + self.up * (y_coefficient *
                                                             aspect)

            sample_direction = (
                self.view_direction +
                (offset * tan(self.view_angle * 0.5))).unitize()

            radiance = raytracer.get_radiance(self.view_position,
                                              sample_direction, random)

            acc_radiance[0] += radiance[0]
            acc_radiance[1] += radiance[1]
            acc_radiance[2] += radiance[2]

        return Vector3f(acc_radiance[0], acc_radiance[1], acc_radiance[2])
Пример #6
0
class RenderWorker:
    @classmethod
    def createWorker(cls, renderTask):

        if not renderTask.isValid():
            return None

        return RenderWorker(renderTask)

    def __init__(self, task):
        if not isinstance(task, RenderTask):
            raise TypeError(
                "Incorrect task type: {}. Should be RenderTask".format(
                    type(task)))

        self.task = task

        self.random = Random()
        self.raytracer = RayTracer(task.getScene())
        self.progress = 0.0

    def get_progress(self):
        return self.progress

    def sample_radiance(self, x, y, w, h, aspect, camera, scene, num_samples):
        acc_radiance = [0.0, 0.0, 0.0]

        for i in range(num_samples):
            x_coefficient = ((x + self.random.real64()) * 2.0 / w) - 1.0
            y_coefficient = ((y + self.random.real64()) * 2.0 / h) - 1.0

            offset = camera.right * x_coefficient + camera.up * (
                y_coefficient * aspect)

            sample_direction = (
                camera.view_direction +
                (offset * tan(camera.view_angle * 0.5))).unitize()

            radiance = self.raytracer.get_radiance(camera.view_position,
                                                   sample_direction,
                                                   self.random)

            acc_radiance[0] += radiance[0]
            acc_radiance[1] += radiance[1]
            acc_radiance[2] += radiance[2]

        return Vector3f(acc_radiance[0], acc_radiance[1], acc_radiance[2])

    def getXY(self, idx, w):
        return idx % w, idx // w

    def renderingFinished(self, pixels):
        result = RenderTaskResult.createRenderTaskResult(
            self.task.getDesc(), pixels)

        if result:
            if self.task.callback:
                self.task.callback(result)
        else:
            print "Failed to acquire result"

        return result

    def render(self):
        desc = self.task.getDesc()

        x, y, w, h = desc.getX(), desc.getY(), desc.getW(), desc.getH()
        num_pixels, num_samples = desc.getNumPixels(), desc.getNumSamples()
        aspect = float(h) / float(w)
        offset = y * w + x
        id = desc.getID()

        pixels = [0.0] * 3 * num_pixels

        cam = self.task.getCamera()
        scn = self.task.getScene()

        for k in range(num_pixels):
            x, y = self.getXY(k + offset, w)

            radiance = self.sample_radiance(x, y, w, h, aspect, cam, scn,
                                            num_samples)

            pixels[3 * k + 0] = radiance[0]
            pixels[3 * k + 1] = radiance[1]
            pixels[3 * k + 2] = radiance[2]

            progress = float(k + 1) / float(num_pixels)

        return self.renderingFinished(pixels)