Replace array_view.size with an external helper

QuLogic · QuLogic · commit 343fa1312f3e · 2023-10-14T01:11:09.000-04:00
This currently checks if any dimension is 0, and returns the first
dimension or 0. However, `pybind11::array_t.size()` returns the product
of the shapes, so we want to be explicit when we need the former.

I also checked the remaining `size` calls, and those will be fine with
either interpretation, so I did not change them.
diff --git a/src/_backend_agg.h b/src/_backend_agg.h
@@ -918,15 +918,15 @@ inline void RendererAgg::_draw_path_collection_generic(GCAgg &gc,
     typedef agg::conv_curve<clipped_t> curve_t;
 
     size_t Npaths = path_generator.num_paths();
-    size_t Noffsets = offsets.size();
+    size_t Noffsets = safe_first_shape(offsets);
     size_t N = std::max(Npaths, Noffsets);
 
-    size_t Ntransforms = transforms.size();
-    size_t Nfacecolors = facecolors.size();
-    size_t Nedgecolors = edgecolors.size();
-    size_t Nlinewidths = linewidths.size();
+    size_t Ntransforms = safe_first_shape(transforms);
+    size_t Nfacecolors = safe_first_shape(facecolors);
+    size_t Nedgecolors = safe_first_shape(edgecolors);
+    size_t Nlinewidths = safe_first_shape(linewidths);
     size_t Nlinestyles = std::min(linestyles.size(), N);
-    size_t Naa = antialiaseds.size();
+    size_t Naa = safe_first_shape(antialiaseds);
 
     if ((Nfacecolors == 0 && Nedgecolors == 0) || Npaths == 0) {
         return;
diff --git a/src/_path.h b/src/_path.h
@@ -113,7 +113,7 @@ void point_in_path_impl(PointArray &points, PathIterator &path, ResultArray &ins
     size_t i;
     bool all_done;
 
-    size_t n = points.size();
+    size_t n = safe_first_shape(points);
 
     std::vector<uint8_t> yflag0(n);
     std::vector<uint8_t> subpath_flag(n);
@@ -247,7 +247,7 @@ inline void points_in_path(PointArray &points,
     typedef agg::conv_contour<curve_t> contour_t;
 
     size_t i;
-    for (i = 0; i < points.size(); ++i) {
+    for (i = 0; i < safe_first_shape(points); ++i) {
         result[i] = false;
     }
 
@@ -384,9 +384,9 @@ void get_path_collection_extents(agg::trans_affine &master_transform,
     }
 
     size_t Npaths = paths.size();
-    size_t Noffsets = offsets.size();
+    size_t Noffsets = safe_first_shape(offsets);
     size_t N = std::max(Npaths, Noffsets);
-    size_t Ntransforms = std::min(transforms.size(), N);
+    size_t Ntransforms = std::min(safe_first_shape(transforms), N);
     size_t i;
 
     agg::trans_affine trans;
@@ -436,9 +436,9 @@ void point_in_path_collection(double x,
         return;
     }
 
-    size_t Noffsets = offsets.size();
+    size_t Noffsets = safe_first_shape(offsets);
     size_t N = std::max(Npaths, Noffsets);
-    size_t Ntransforms = std::min(transforms.size(), N);
+    size_t Ntransforms = std::min(safe_first_shape(transforms), N);
     size_t i;
 
     agg::trans_affine trans;
@@ -776,7 +776,7 @@ int count_bboxes_overlapping_bbox(agg::rect_d &a, BBoxArray &bboxes)
         std::swap(a.y1, a.y2);
     }
 
-    size_t num_bboxes = bboxes.size();
+    size_t num_bboxes = safe_first_shape(bboxes);
     for (size_t i = 0; i < num_bboxes; ++i) {
         b = agg::rect_d(bboxes(i, 0, 0), bboxes(i, 0, 1), bboxes(i, 1, 0), bboxes(i, 1, 1));
 
diff --git a/src/array.h b/src/array.h
@@ -40,6 +40,13 @@ class scalar
     }
 };
 
+template <typename T, int ND>
+size_t
+safe_first_shape(scalar<T, ND>)
+{
+    return 1;
+}
+
 template <typename T>
 class empty
 {
@@ -75,6 +82,12 @@ class empty
         return 0;
     }
 };
+
+template <typename T>
+size_t safe_first_shape(empty<T>)
+{
+    return 0;
+}
 }
 
 #endif
diff --git a/src/numpy_cpp.h b/src/numpy_cpp.h
@@ -500,24 +500,7 @@ class array_view : public detail::array_view_accessors<array_view, T, ND>
         return m_shape[i];
     }
 
-    /*
-       In most cases, code should use size() instead of dim(0), since
-       size() == 0 when any dimension is 0.
-    */
-    size_t size() const
-    {
-        bool empty = (ND == 0);
-        for (size_t i = 0; i < ND; i++) {
-            if (m_shape[i] == 0) {
-                empty = true;
-            }
-        }
-        if (empty) {
-            return 0;
-        } else {
-            return (size_t)shape(0);
-        }
-    }
+    size_t size() const;
 
     // Do not use this for array_view<bool, ND>.  See comment near top of file.
     const T *data() const
@@ -567,6 +550,32 @@ class array_view : public detail::array_view_accessors<array_view, T, ND>
     }
 };
 
+/* In most cases, code should use safe_first_shape(obj) instead of obj.shape(0), since
+   safe_first_shape(obj) == 0 when any dimension is 0. */
+template <typename T, int ND>
+size_t
+safe_first_shape(const array_view<T, ND> &a)
+{
+    bool empty = (ND == 0);
+    for (size_t i = 0; i < ND; i++) {
+        if (a.shape(i) == 0) {
+            empty = true;
+        }
+    }
+    if (empty) {
+        return 0;
+    } else {
+        return (size_t)a.shape(0);
+    }
+}
+
+template <typename T, int ND>
+size_t
+array_view<T, ND>::size() const
+{
+    return safe_first_shape<T, ND>(*this);
+}
+
 } // namespace numpy
 
 

Original file line number	Diff line number	Diff line change
`@@ -40,6 +40,13 @@ class scalar`
`40`	`40`	`}`
`41`	`41`	`};`
`42`	`42`
	`43`	`+template <typename T, int ND>`
	`44`	`+size_t`
	`45`	`+safe_first_shape(scalar<T, ND>)`
	`46`	`+{`
	`47`	`+ return 1;`
	`48`	`+}`
	`49`	`+`
`43`	`50`	`template <typename T>`
`44`	`51`	`class empty`
`45`	`52`	`{`
`@@ -75,6 +82,12 @@ class empty`
`75`	`82`	`return 0;`
`76`	`83`	`}`
`77`	`84`	`};`
	`85`	`+`
	`86`	`+template <typename T>`
	`87`	`+size_t safe_first_shape(empty<T>)`
	`88`	`+{`
	`89`	`+ return 0;`
	`90`	`+}`
`78`	`91`	`}`
`79`	`92`
`80`	`93`	`#endif`