Patch main for auto positioning

Author: TolyaTalamanov

include/raytracer/datatypes.hpp

@@ -63,7 +63,7 @@ inline Vec3f operator-(Vec3f rhs, double val) {
 };
 
 inline std::ostream& operator<<(std::ostream& os, Vec3f vec) {
-    os << "[ " << vec.x << " " << vec.y << " " << vec.z << " ]" << std::endl;
+    os << "[ " << vec.x << " " << vec.y << " " << vec.z << " ]";
     return os;
 }
 

include/raytracer/geometry.hpp

@@ -157,10 +157,12 @@ class Triangle : public Object {
 
 class Scene {
 public:
-    Scene(Objects&&                     eobjects,
+    Scene(Objects&&                      objects,
           Lights&&                       lights,
           std::vector<GeometricVertex>&& geom_vertices);
 
+    void AddLight(Light &&);
+
     const Objects&                      GetObjects()           const;
     const Lights&                       GetLights()            const;
     const std::vector<GeometricVertex>& GetGeometricVertices() const;

main.cpp

@@ -3,37 +3,95 @@
 
 #include <raytracer/raytracer.hpp>
 
-static Vec3f GetCenter(const Scene& scene) {
-    Vec3f c{0, 0, 0};
-    for (auto&& v : scene.GetGeometricVertices()) {
-        c = c + Vec3f{v.x, v.y, v.z};
+class BBox {
+public:
+    BBox(const std::vector<GeometricVertex> &vertices) {
+        const auto &v = vertices.front();
+
+        Vec3f min = Vec3f{v.x, v.y, v.z};
+        Vec3f max = Vec3f{v.x, v.y, v.z};
+
+        for (auto&& v : vertices) {
+            min.x = std::min(min.x, v.x);
+            min.y = std::min(min.y, v.y);
+            min.z = std::min(min.z, v.z);
+
+            max.x = std::max(max.x, v.x);
+            max.y = std::max(max.y, v.y);
+            max.z = std::max(max.z, v.z);
+        }
+
+        _coords[0] = Vec3f{min.x, min.y, min.z};
+        _coords[1] = Vec3f{max.x, min.y, min.z};
+        _coords[2] = Vec3f{min.x, max.y, min.z};
+        _coords[3] = Vec3f{max.x, max.y, min.z};
+        _coords[4] = Vec3f{min.x, min.y, max.z};
+        _coords[5] = Vec3f{max.x, min.y, max.z};
+        _coords[6] = Vec3f{min.x, max.y, max.z};
+        _coords[7] = Vec3f{max.x, max.y, max.z};
     }
-    return c / scene.GetGeometricVertices().size();
-}
+
+    Vec3f GetCenter() const {
+        return { (_coords[0].x + _coords[7].x) / 2,
+                 (_coords[0].y + _coords[7].y) / 2,
+                 (_coords[0].z + _coords[7].z) / 2 };
+    }
+
+    double GetDiag() const {
+        return (_coords[0] - _coords[6]).norm();
+    }
+
+private:
+    std::array<Vec3f, 8> _coords;
+};
 
 int main(int argc, const char** argv) {
     CameraOptions camera_opts(500, 500);
     RenderOptions render_opts{3};
 
+    if (argc < 2) {
+        throw std::logic_error("Provide path to texture file (*.obj)");
+    }
+
+    double zoom = 1.0;
+    if (argc == 3) {
+        zoom = std::stod(argv[2]);
+    }
+
     const std::string obj_filename = argv[1];
-    const auto scene  = Parse(obj_filename);
-    const auto center = GetCenter(scene);
+    auto scene  = Parse(obj_filename);
+    BBox bbox(scene.GetGeometricVertices());
+    auto c = bbox.GetCenter();
+    auto d = bbox.GetDiag();
+    Vec3f look = {c.x + d * zoom,
+                  c.y + d * zoom,
+                  c.z + d * zoom};
+
+    std::cout << "[INFO] Zoom is equal to " << zoom << std::endl;
+    std::cout << "[INFO] Object center is: " << c << std::endl;
+    std::cout << "[INFO] Diag: " << d << std::endl;
 
-    std::cout << "Object center is: " << center << std::endl;
+    if (scene.GetLights().empty()) {
+        std::cout << "[WARNING] Scene doesn't contain any light object." << std::endl;
+        // NB: Put some light by default.
+        scene.AddLight(Light{look, {1, 1, 1}});
+    }
+
+    std::cout << "[INFO] Number of objects on scene: " << scene.GetObjects().size() << std::endl;
 
-    camera_opts.look_from = std::array<double, 3>{std::stod(argv[2]),
-                                                  std::stod(argv[3]),
-                                                  std::stod(argv[4])};
-    camera_opts.look_to   = std::array<double, 3>{center.x, center.y, center.z};
+    camera_opts.look_from = std::array<double, 3>{look.x, look.y, look.z};
+    camera_opts.look_to   = std::array<double, 3>{c.x, c.y, c.z};
 
     using namespace std::chrono;
     auto start   = high_resolution_clock::now();
-    auto image   = Render(obj_filename, camera_opts, render_opts);
+    auto image   = Render(scene, camera_opts, render_opts);
     auto end     = high_resolution_clock::now();
     auto elapsed = duration_cast<milliseconds>(end-start).count();
-    image.Write("output.png");
 
-    std::cout << "Elapsed time: " << elapsed  << " ms" << std::endl;
+    std::cout << "[INFO] Rendering time: " << elapsed  << " ms" << std::endl;
+
+    image.Write("output.png");
+    std::cout << "[INFO] Dump result to output.png" << std::endl;
 
     return 0;
 }

src/geometry.cpp

@@ -20,6 +20,10 @@ const std::vector<GeometricVertex>& Scene::GetGeometricVertices() const {
     return _geom_vertices;
 }
 
+void Scene::AddLight(Light &&light) {
+    _lights.push_back(std::move(light));
+}
+
 Vec3f Ray::at(double t) const {
     return orig + dir * t;
 }