Merge pull request #343 from SymbiFlow/master+wip-hackerfoo

recent lookahead sampling changes

Author: litghost

libs/libvtrcapnproto/connection_map.capnp

@@ -13,8 +13,13 @@ struct VprVector2D {
     y @1 :Int64;
 }
 
+struct VprFloatEntry {
+    value @0 :Float32;
+}
+
 struct VprCostMap {
     costMap @0 :Matrix.Matrix((Matrix.Matrix(VprCostEntry)));
     offset @1 :Matrix.Matrix(VprVector2D);
     segmentMap @2 :List(Int64);
+    penalty @3 :Matrix.Matrix(VprFloatEntry);
 }

libs/libvtrutil/src/vtr_geometry.h

@@ -1,10 +1,12 @@
 #ifndef VTR_GEOMETRY_H
 #define VTR_GEOMETRY_H
 #include "vtr_range.h"
+#include "vtr_assert.h"
 
 #include <vector>
 #include <tuple>
 #include <limits>
+#include <type_traits>
 
 namespace vtr {
 
@@ -78,7 +80,13 @@ class Rect {
     Rect();
     Rect(T left_val, T bottom_val, T right_val, T top_val);
     Rect(Point<T> bottom_left_val, Point<T> top_right_val);
-    Rect(Point<T> bottom_left_val, T size);
+
+    //Constructs a rectangle that only contains the given point
+    //  Rect(p1).contains(p2) => p1 == p2
+    //It is only enabled for integral types, because making this work for floating point types would be difficult and brittle.
+    //The following line only enables the constructor if std::is_integral<T>::value == true
+    template<typename U = T, typename std::enable_if<std::is_integral<U>::value>::type...>
+    Rect(Point<U> point);
 
   public: //Accessors
     //Co-ordinates
@@ -103,28 +111,41 @@ class Rect {
     bool coincident(Point<T> point) const;
 
     //Returns true if no points are contained in the rectangle
+    //  rect.empty() => not exists p. rect.contains(p)
+    //  This also implies either the width or height is 0.
     bool empty() const;
 
     friend bool operator== <>(const Rect<T>& lhs, const Rect<T>& rhs);
     friend bool operator!= <>(const Rect<T>& lhs, const Rect<T>& rhs);
 
-    template<class U>
-    friend Rect<U> operator|(const Rect<U>& lhs, const Rect<U>& rhs);
-    template<class U>
-    friend Rect<U>& operator|=(Rect<U>& lhs, const Rect<U>& rhs);
-
   public: //Mutators
     //Co-ordinates
     void set_xmin(T xmin_val);
     void set_ymin(T ymin_val);
     void set_xmax(T xmax_val);
     void set_ymax(T ymax_val);
 
+    //Equivalent to `*this = bounding_box(*this, other)`
+    Rect<T>& expand_bounding_box(const Rect<T>& other);
+
   private:
     Point<T> bottom_left_;
     Point<T> top_right_;
 };
 
+//Return the smallest rectangle containing both given rectangles
+//Note that this isn't a union and the resulting rectangle may include points not in either given rectangle
+template<class T>
+Rect<T> bounding_box(const Rect<T>& lhs, const Rect<T>& rhs);
+
+//Sample on a uniformly spaced grid within a rectangle
+//  sample(vtr::Rect(l, h), 0, 0, M) == l
+//  sample(vtr::Rect(l, h), M, M, M) == h
+//To avoid the edges, use `sample(r, x+1, y+1, N+1) for x, y, in 0..N-1
+//Only defined for integral types
+template<typename T, typename std::enable_if<std::is_integral<T>::value>::type...>
+Point<T> sample(const vtr::Rect<T>& r, T x, T y, T d);
+
 //A 2D line
 template<class T>
 class Line {

libs/libvtrutil/src/vtr_geometry.tpp

@@ -80,11 +80,13 @@ Rect<T>::Rect(Point<T> bottom_left_val, Point<T> top_right_val)
     //pass
 }
 
+//Only defined for integral types
 template<class T>
-Rect<T>::Rect(Point<T> bottom_left_val, T size)
-    : bottom_left_(bottom_left_val)
-    , top_right_(bottom_left_val.x() + size,
-                 bottom_left_val.y() + size) {
+template<typename U, typename std::enable_if<std::is_integral<U>::value>::type...>
+Rect<T>::Rect(Point<U> point)
+    : bottom_left_(point)
+    , top_right_(point.x() + 1,
+                 point.y() + 1) {
     //pass
 }
 
@@ -165,6 +167,22 @@ bool operator!=(const Rect<T>& lhs, const Rect<T>& rhs) {
     return !(lhs == rhs);
 }
 
+template<class T>
+Rect<T> bounding_box(const Rect<T>& lhs, const Rect<T>& rhs) {
+    return Rect<T>(std::min(lhs.xmin(), rhs.xmin()),
+                   std::min(lhs.ymin(), rhs.ymin()),
+                   std::max(lhs.xmax(), rhs.xmax()),
+                   std::max(lhs.ymax(), rhs.ymax()));
+}
+
+//Only defined for integral types
+template<typename T, typename std::enable_if<std::is_integral<T>::value>::type...>
+Point<T> sample(const vtr::Rect<T>& r, T x, T y, T d) {
+    VTR_ASSERT(d > 0);
+    return Point<T>((r.xmin() * (d - x) + r.xmax() * x + d / 2) / d,
+                    (r.ymin() * (d - y) + r.ymax() * y + d / 2) / d);
+}
+
 template<class T>
 void Rect<T>::set_xmin(T xmin_val) {
     bottom_left_.set_x(xmin_val);
@@ -186,16 +204,9 @@ void Rect<T>::set_ymax(T ymax_val) {
 }
 
 template<class T>
-Rect<T> operator|(const Rect<T>& lhs, const Rect<T>& rhs) {
-    return Rect<T>(std::min(lhs.xmin(), rhs.xmin()),
-                   std::min(lhs.ymin(), rhs.ymin()),
-                   std::max(lhs.xmax(), rhs.xmax()),
-                   std::max(lhs.ymax(), rhs.ymax()));
-}
-
-template<class T>
-Rect<T>& operator|=(Rect<T>& lhs, const Rect<T>& rhs) {
-    return lhs = lhs | rhs;
+Rect<T>& Rect<T>::expand_bounding_box(const Rect<T>& other) {
+    *this = bounding_box(*this, other);
+    return *this;
 }
 
 /*

libs/libvtrutil/test/test_geometry.cpp

@@ -61,6 +61,7 @@ TEST_CASE("Rect", "[vtr_geometry/Rect]") {
             REQUIRE(r2.contains({6, 4}));
             REQUIRE_FALSE(r2.contains({100, 4}));
             REQUIRE_FALSE(r2.contains(pi_2));
+            REQUIRE(vtr::Rect<int>(pi_1).contains(pi_1));
         }
 
         SECTION("strictly_contains_int") {
@@ -78,7 +79,19 @@ TEST_CASE("Rect", "[vtr_geometry/Rect]") {
         }
 
         SECTION("bounds_int") {
-            REQUIRE(r1 == (r3 | r4));
+            REQUIRE(r1 == bounding_box(r3, r4));
+        }
+
+        SECTION("empty_int") {
+            REQUIRE(vtr::Rect<int>().empty());
+        }
+
+        SECTION("sample_int") {
+            auto r = vtr::Rect<int>(pi_1, pi_2);
+            REQUIRE(sample(r, 0, 0, 17) == pi_1);
+            REQUIRE(sample(r, 17, 17, 17) == pi_2);
+            auto inside = sample(r, 3, 11, 17);
+            REQUIRE(r.contains(inside));
         }
     }
 
@@ -92,6 +105,7 @@ TEST_CASE("Rect", "[vtr_geometry/Rect]") {
         vtr::Rect<float> r4(pf_1, pf_2);
         vtr::Rect<float> r5(pf_1, pf_3);
         vtr::Rect<float> r6(pf_3, pf_2);
+        // vtr::Rect<float> r7(pf_1); // <-- will fail to compile
 
         SECTION("equality_float") {
             REQUIRE(r3 == r4);
@@ -140,7 +154,11 @@ TEST_CASE("Rect", "[vtr_geometry/Rect]") {
         }
 
         SECTION("bounds_float") {
-            REQUIRE(r3 == (r5 | r6));
+            REQUIRE(r3 == bounding_box(r5, r6));
+        }
+
+        SECTION("empty_float") {
+            REQUIRE(vtr::Rect<float>().empty());
         }
     }
 }