Add MotionBlurCamera

.gitignore

@@ -4,6 +4,7 @@ target/
 !**/src/test/**/target/
 
 image.ppm
+image.png
 
 ### IntelliJ IDEA ###
 .idea/

src/main/java/Main.java

@@ -1,15 +1,20 @@
+import camera.BlurCamera;
+import camera.MotionBlurCamera;
+import math.Color;
 import math.Point;
 import math.Ray;
 import math.Vector;
-import util.camera.BlurCamera;
-import util.camera.Camera;
-import util.camera.ClearCamera;
+import camera.Camera;
+import camera.ClearCamera;
+import objects.MovingSphere;
 import util.collections.*;
 import util.*;
-import util.material.Dielectric;
-import util.material.Lambertian;
-import util.material.Material;
-import util.material.Metal;
+import material.Dielectric;
+import material.Lambertian;
+import material.Material;
+import material.Metal;
+import objects.Hittable;
+import objects.Sphere;
 
 import java.io.BufferedWriter;
 import java.io.IOException;
@@ -31,6 +36,7 @@ public static void main(String[] args) throws Exception{
             new Main(writer);
             System.out.println("Processing time: " + (((double)(System.currentTimeMillis() - start))/1000));
         }
+        Convertor.main(args);
     }
 
     public Main(BufferedWriter writer) throws IOException {
@@ -55,7 +61,8 @@ public Main(BufferedWriter writer) throws IOException {
         world.add(new Sphere(new Point(0, -1000, 0), 1000, ground));
 
         world.add(new Sphere(new Point(-2, 1, 0), 1, left));
-        world.add(new Sphere(new Point(0, 1, 0), 1, center));
+//        world.add(new Sphere(new Point(0, 1, 0), 1, center));
+        world.add(new MovingSphere(new Point(0, 1, 0), new Point(0, 2, 0), 1, 0, 1, center));
         world.add(new Sphere(new Point(2, 1, 0), 1, right));
 //        Util.fillScene(world);
         //Camera
@@ -66,8 +73,10 @@ public Main(BufferedWriter writer) throws IOException {
         double aperture = 0.1;
         double focusDist = new Vector(lookAt, lookFrom).length();
 
-        Camera camera = new ClearCamera(lookFrom, lookAt, worldNormal, fov, aspectRatio);
-//        Camera camera = new BlurCamera(lookFrom, lookAt, worldNormal, fov, aspectRatio, aperture, focusDist);
+        Camera cameraClear = new ClearCamera(lookFrom, lookAt, worldNormal, fov, aspectRatio);
+        Camera cameraBlur = new BlurCamera(lookFrom, lookAt, worldNormal, fov, aspectRatio, aperture, focusDist);
+
+        Camera camera = new MotionBlurCamera(cameraClear, 0, 0.5);
 
         Random random = new Random();
         //Rendering

src/main/java/util/camera/BlurCamera.java → src/main/java/camera/BlurCamera.java

@@ -1,10 +1,9 @@
-package util.camera;
+package camera;
 
 import math.Point;
 import math.Ray;
 import math.Vector;
 import math.Vectors;
-import util.camera.Camera;
 
 public class BlurCamera implements Camera {
     private final Point origin;

src/main/java/util/camera/Camera.java → src/main/java/camera/Camera.java

@@ -1,4 +1,4 @@
-package util.camera;
+package camera;
 
 import math.Ray;
 

src/main/java/util/camera/ClearCamera.java → src/main/java/camera/ClearCamera.java

@@ -1,4 +1,4 @@
-package util.camera;
+package camera;
 
 import math.Point;
 import math.Ray;

src/main/java/camera/MotionBlurCamera.java

@@ -0,0 +1,24 @@
+package camera;
+
+import math.Ray;
+
+public class MotionBlurCamera implements Camera{
+    private final Camera camera;
+    private final double shutterOpeningMoment;
+    private final double shutterClosingMoment;
+
+    public MotionBlurCamera(Camera camera, double shutterOpeningMoment, double shutterClosingMoment) {
+        if(shutterClosingMoment < shutterOpeningMoment){
+            throw new IllegalArgumentException("shutterClosingMoment can`t be less then shutterOpeningMoment");
+        }
+        this.camera = camera;
+        this.shutterOpeningMoment = shutterOpeningMoment;
+        this.shutterClosingMoment = shutterClosingMoment;
+    }
+
+    @Override
+    public Ray getRay(double s, double t) {
+        double shutterOpenMoment = (Math.random() * (shutterClosingMoment - shutterOpeningMoment)) + shutterOpeningMoment;
+        return camera.getRay(s, t).setTimeMoment(shutterOpenMoment);
+    }
+}

src/main/java/util/material/Dielectric.java → src/main/java/material/Dielectric.java

@@ -1,9 +1,9 @@
-package util.material;
+package material;
 
 import math.Ray;
 import math.Vector;
 import math.Vectors;
-import util.Color;
+import math.Color;
 import util.HitRecord;
 
 public class Dielectric implements Material{
@@ -37,8 +37,7 @@ public boolean scatter(Ray rayIn, HitRecord record, Color attenuation, Ray scatt
         }else{
             direction = Vectors.refract(unitDirection, record.getNormal(), refractionRatio);
         }
-        scattered.setOrigin(record.getPoint());
-        scattered.setDirection(direction);
+        scattered.setOrigin(record.getPoint()).setDirection(direction).setTimeMoment(rayIn.getTimeMoment());
         return true;
     }
 

src/main/java/util/material/Lambertian.java → src/main/java/material/Lambertian.java

@@ -1,9 +1,9 @@
-package util.material;
+package material;
 
 import math.Ray;
 import math.Vector;
 import math.Vectors;
-import util.Color;
+import math.Color;
 import util.HitRecord;
 
 /**
@@ -22,8 +22,7 @@ public boolean scatter(Ray rayIn, HitRecord record, Color attenuation, Ray scatt
         if(scatteredDirection.nearZero()){
             scatteredDirection = record.getNormal();
         }
-        scattered.setDirection(scatteredDirection);
-        scattered.setOrigin(record.getPoint());
+        scattered.setDirection(scatteredDirection).setOrigin(record.getPoint()).setTimeMoment(rayIn.getTimeMoment());
         attenuation.set(albedo);
         return true;
     }

src/main/java/util/material/Material.java → src/main/java/material/Material.java

@@ -1,7 +1,7 @@
-package util.material;
+package material;
 
 import math.Ray;
-import util.Color;
+import math.Color;
 import util.HitRecord;
 
 public interface Material {

src/main/java/util/material/Metal.java → src/main/java/material/Metal.java

@@ -1,9 +1,9 @@
-package util.material;
+package material;
 
 import math.Ray;
 import math.Vector;
 import math.Vectors;
-import util.Color;
+import math.Color;
 import util.HitRecord;
 
 public class Metal implements Material{
@@ -24,8 +24,9 @@ public Metal(Color albedo, double fuzz) {
     @Override
     public boolean scatter(Ray rayIn, HitRecord record, Color attenuation, Ray scattered) {
         Vector reflected = Vectors.reflect(rayIn.getDirection().unit(), record.getNormal());
-        scattered.setOrigin(record.getPoint());
-        scattered.setDirection(reflected.add(Vectors.randomInUnitSphere().multiply(fuzz)));
+        scattered.setOrigin(record.getPoint())
+                .setDirection(reflected.add(Vectors.randomInUnitSphere().multiply(fuzz)))
+                .setTimeMoment(rayIn.getTimeMoment());
         attenuation.set(albedo);
         return Vectors.dot(scattered.getDirection(), record.getNormal()) > 0;
     }

src/main/java/util/Color.java → src/main/java/math/Color.java

@@ -1,4 +1,4 @@
-package util;
+package math;
 
 import java.util.Objects;
 

src/main/java/math/Ray.java

@@ -3,7 +3,7 @@
 public class Ray {
     private Point origin = new Point();
     private Vector direction = new Vector();
-
+    private double timeMoment = 0;
     public Ray() {
     }
 
@@ -12,6 +12,11 @@ public Ray(Point origin, Vector direction) {
         this.direction = direction;
     }
 
+    public Ray(Point origin, Vector direction, double timeMoment) {
+        this(origin, direction);
+        this.timeMoment = timeMoment;
+    }
+
     public Point at(double t){
         return origin.move(direction.multiply(t));
     }
@@ -20,15 +25,26 @@ public Point getOrigin() {
         return origin;
     }
 
-    public void setOrigin(Point origin) {
+    public Ray setOrigin(Point origin) {
         this.origin = origin;
+        return this;
     }
 
     public Vector getDirection() {
         return direction;
     }
 
-    public void setDirection(Vector direction) {
+    public Ray setDirection(Vector direction) {
         this.direction = direction;
+        return this;
+    }
+
+    public double getTimeMoment() {
+        return timeMoment;
+    }
+
+    public Ray setTimeMoment(double timeMoment) {
+        this.timeMoment = timeMoment;
+        return this;
     }
 }

src/main/java/util/Hittable.java → src/main/java/objects/Hittable.java

@@ -1,6 +1,7 @@
-package util;
+package objects;
 
 import math.Ray;
+import util.HitRecord;
 
 public interface Hittable {
     boolean hit(Ray r, double tMin, double tMax, HitRecord rec);

src/main/java/objects/MovingSphere.java

@@ -0,0 +1,60 @@
+package objects;
+
+import math.Point;
+import math.Ray;
+import math.Vector;
+import math.Vectors;
+import util.HitRecord;
+import material.Material;
+
+public class MovingSphere implements Hittable{
+    private final Point centerStart;
+    private final Point centerFinish;
+    private final double timeStart;
+    private final double timeFinish;
+    private final double radius;
+    private final Material material;
+
+    public MovingSphere(Point centerStart, Point centerFinish, double radius, double timeStart, double timeFinish,  Material material) {
+        this.centerStart = centerStart;
+        this.centerFinish = centerFinish;
+        this.timeStart = timeStart;
+        this.timeFinish = timeFinish;
+        this.radius = radius;
+        this.material = material;
+    }
+
+    @Override
+    public boolean hit(Ray r, double tMin, double tMax, HitRecord rec) {
+        Vector oc = new Vector(center(r.getTimeMoment()), r.getOrigin());
+        double A = r.getDirection().lengthSquared();
+        double halfB = Vectors.dot(oc, r.getDirection());
+        double C = oc.lengthSquared() - radius*radius;
+        double discriminant = halfB*halfB - A*C;
+        if(discriminant < 0d){
+            return false;
+        }
+        double sqrtd = Math.sqrt(discriminant);
+        double root = (-halfB - sqrtd) / A;
+        if (root < tMin || tMax < root) {
+            root = (-halfB + sqrtd) / A;
+            if (root < tMin || tMax < root)
+                return false;
+        }
+
+        rec.setT(root);
+        rec.setPoint(r.at(rec.getT()));
+        Vector outwardNormal = new Vector(center(r.getTimeMoment()), rec.getPoint()).divide(radius);
+        rec.setFaceNormal(r, outwardNormal);
+        rec.setMaterial(this.material);
+        return true;
+    }
+
+    private Point center(double time){
+        if(Math.abs(timeFinish - timeStart) <= 1e-10){
+            return centerStart;
+        }
+        return centerStart.move(new Vector(centerStart, centerFinish).multiply((time - timeStart)/(timeFinish - timeStart)));
+    }
+
+}

src/main/java/util/Sphere.java → src/main/java/objects/Sphere.java

@@ -1,10 +1,11 @@
-package util;
+package objects;
 
 import math.Point;
 import math.Ray;
 import math.Vector;
 import math.Vectors;
-import util.material.Material;
+import util.HitRecord;
+import material.Material;
 
 public class Sphere implements Hittable {
     private Point center;

src/main/java/util/HitRecord.java

@@ -4,7 +4,7 @@
 import math.Ray;
 import math.Vector;
 import math.Vectors;
-import util.material.Material;
+import material.Material;
 
 public class HitRecord{
     private Point point = new Point();

src/main/java/util/Util.java

@@ -1,13 +1,16 @@
 package util;
 
+import math.Color;
 import math.Point;
 import math.Ray;
 import math.Vector;
 import util.collections.HittableList;
-import util.material.Dielectric;
-import util.material.Lambertian;
-import util.material.Material;
-import util.material.Metal;
+import material.Dielectric;
+import material.Lambertian;
+import material.Material;
+import material.Metal;
+import objects.Hittable;
+import objects.Sphere;
 
 import static java.lang.Math.*;
 
@@ -36,8 +39,8 @@ public static Color normalColor(Ray r, Hittable world) {
     }
 
     public static void fillScene(HittableList world) {
-        for (int x = -20; x < 20; x++) {
-            for (int z = -20; z < 20; z++) {
+        for (int x = -11; x < 11; x++) {
+            for (int z = -11; z < 11; z++) {
                 Point location = new Point(x + random() * 0.9, 0.2, z + random() * 0.9);
                 if (new Vector(new Point(0, 0.2, 0), location).length() > 3) {
                     double rand = random();

src/main/java/util/collections/AbstractHittableList.java

@@ -1,7 +1,6 @@
 package util.collections;
 
-import util.collections.HittableList;
-import util.Hittable;
+import objects.Hittable;
 
 import java.util.Collection;
 import java.util.Iterator;

src/main/java/util/collections/HittableArrayList.java

@@ -1,7 +1,7 @@
 package util.collections;
 
 import util.HitRecord;
-import util.Hittable;
+import objects.Hittable;
 import math.Ray;
 
 import java.util.ArrayList;