Added polyhedral concept check

Siddharth-coder13 · Siddharth-coder13 · commit b347d8793e00 · 2021-02-01T14:24:03.000+05:30
diff --git a/example/01_point_example.cpp b/example/01_point_example.cpp
@@ -107,6 +107,29 @@ int main()
 
 
     // Some ways of getting point values
+    typedef model::point<double, 3, cs::cartesian> point_t;
+    typedef model::ring<point_t> ring_t;
+    typedef model::PolyhedralSurface<ring_t> poly_t;
+
+    poly_t polyhedron1;
+    poly_t polyhedron2 = {{{0,0,0}, {0, 1, 0}, {1, 1, 0}, {1, 0, 0}, {0, 0, 0}}, {{0, 0, 0}, {0, 1, 0}, {0, 1, 1}, {0, 0, 1}, {0, 0, 0}},
+    {{0, 0, 0}, {1, 0, 0}, {1, 0, 1}, {0, 0, 1}, {0, 0, 0}}, {{1, 1, 1}, {1, 0, 1}, {0, 0, 1}, {0, 1, 1}, {1, 1, 1}}, {{1, 1, 1}, {1, 0, 1}, {1, 0, 0}, {1, 1, 0}, {1, 1, 1}}, 
+    {{1, 1, 1}, {1, 1, 0}, {0, 1, 0}, {0, 1, 1}, {1, 1, 1}} };
+
+    //append(polyhedron1[0], point_t{1, 0, 0});
+    //append(polyhedron1[0], point_t{0, 0, 0});
+    //append(polyhedron1[0], point_t{0, 1, 0});
+    //append(polyhedron1[0], point_t{1, 1, 0});
+    //append(polyhedron1[0], point_t{0, 0, 0});
+    read_wkt("POLYHEDRALSURFACE Z(((0 0 0, 0 1 0, 1 1 0, 1 0 0, 0 0 0)), ((0 0 0, 0 1 0, 0 1 1, 0 0 1, 0 0 0)), ((0 0 0, 1 0 0, 1 0 1, 0 0 1, 0 0 0)), ((1 1 1, 1 0 1, 0 0 1, 0 1 1, 1 1 1)), ((1 1 1, 1 0 1, 1 0 0, 1 1 0, 1 1 1)), ((1 1 1, 1 1 0, 0 1 0, 0 1 1, 1 1 1)))", polyhedron1);
+
+    typedef model::polygon<point_2d> poly;
+    poly polygon1;
+    read_wkt("POLYGON((0 0, 0 7, 4 2, 2 0, 0 0))", polygon1); 
+
+    typedef model::linestring<point_2d> lines;
+    lines line;
+    read_wkt("LINESTRING(0 0, 2 2, 3 1)", line);
 
     // 1: using the "get" function following the concepts behind
     std::cout << get<0>(p2) << "," << get<1>(p2) << std::endl;
diff --git a/include/boost/geometry/core/point_type.hpp b/include/boost/geometry/core/point_type.hpp
@@ -92,6 +92,16 @@ struct point_type<ring_tag, Ring>
     typedef typename boost::range_value<Ring>::type type;
 };
 
+// Specialization for PolyhedralSurface: the point-type is the point-type of its rings
+template <typename PolyhedralSurface>
+struct point_type<polyhedral_surface_tag, PolyhedralSurface>
+{
+    typedef typename point_type
+        <
+            ring_tag,
+            typename ring_type<polyhedral_surface_tag, PolyhedralSurface>::type
+        >::type type;
+};
 
 // Specialization for polygon: the point-type is the point-type of its rings
 template <typename Polygon>
diff --git a/include/boost/geometry/core/ring_type.hpp b/include/boost/geometry/core/ring_type.hpp
@@ -23,7 +23,6 @@
 #include <type_traits>
 
 #include <boost/range/value_type.hpp>
-
 #include <boost/geometry/core/static_assert.hpp>
 #include <boost/geometry/core/tag.hpp>
 #include <boost/geometry/core/tags.hpp>
@@ -61,6 +60,13 @@ struct ring_mutable_type
         Geometry);
 };
 
+template <typename Geometry>
+struct Poly_ring_type
+{
+    BOOST_GEOMETRY_STATIC_ASSERT_FALSE(
+        "Not implemented for this Geometry type.",
+        Geometry);
+};
 
 } // namespace traits
 
@@ -87,6 +93,11 @@ struct ring_return_type<ring_tag, Ring>
     typedef Ring& type;
 };
 
+template <typename PolyhedralSurface>
+struct ring_return_type<polyhedral_surface_tag, PolyhedralSurface>
+{
+    typedef typename traits::Poly_ring_type<PolyhedralSurface>::type type;
+};
 
 template <typename Polygon>
 struct ring_return_type<polygon_tag, Polygon>
@@ -145,6 +156,15 @@ struct ring_type<ring_tag, Ring>
     typedef Ring type;
 };
 
+template <typename PolyhedralSurface>
+struct ring_type<polyhedral_surface_tag, PolyhedralSurface>
+{
+    typedef typename std::remove_reference
+        <
+            typename ring_return_type<polyhedral_surface_tag, PolyhedralSurface>::type
+        >::type type;
+};
+
 
 template <typename Polygon>
 struct ring_type<polygon_tag, Polygon>
diff --git a/include/boost/geometry/core/tags.hpp b/include/boost/geometry/core/tags.hpp
@@ -106,7 +106,7 @@ struct box_tag : single_tag, areal_tag {};
 struct segment_tag : single_tag, linear_tag {};
 
 /// OGC Polyhedral surface identifying tag
-struct PolyhedralSurface_tag : single_tag, volumetric_tag {};
+struct polyhedral_surface_tag : single_tag, volumetric_tag {};
 
 
 /// OGC Multi point identifying tag
diff --git a/include/boost/geometry/geometries/PolyhedralSurface.hpp b/include/boost/geometry/geometries/PolyhedralSurface.hpp
@@ -25,35 +25,31 @@ namespace model
 
 template 
 <
-    typename Point,
-    bool ClockWise = true, bool Closed = true,
-    template<typename, typename> class PointList = std::vector,
-    template<typename, typename> class RingList = std::vector,
-    template<typename> class PointAlloc = std::allocator,
-    template<typename> class RingAlloc = std::allocator
+    typename Ring,
+    template<typename, typename> class Container = std::vector,
+    template<typename> class Allocator = std::allocator
+
 >
-class PolyhedralSurface : public PointList<ring<Point>, RingAlloc<ring<Point> > >
+class PolyhedralSurface : public Container<Ring, Allocator<Ring> >
 {
-	BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );
+	BOOST_CONCEPT_ASSERT( (concepts::Ring<Ring>) );
 
 public :
 
-	//typedef Point point_type;
-    using point_type = Point;
-    using ring_type =  ring<Point, ClockWise, Closed, PointList, PointAlloc>;
-    using PolyhedralSurface_type = RingList<ring_type, RingAlloc<ring_type > >;
-    //typedef RingList<Point, RingAlloc<Point> > base_type;
+    using point_type = model::point<double, 3, boost::geometry::cs::cartesian>;
+    using ring_type = ring<point_type, true, true>;
+    using ph = Container<ring_type, Allocator<ring_type> >;
 
 #ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
 
     /// \constructor_default{polyhedron}
     inline PolyhedralSurface()
-	    : PolyhedralSurface_type()
+	    : ph()
 	{}
 
     /// \constructor_initialized_list{polyhedron}
 	inline PolyhedralSurface(std::initializer_list<ring_type> l)
-	    : PolyhedralSurface_type(l.begin(), l.end())
+	    : ph(l.begin(), l.end())
 	{}
 
 #endif
@@ -68,36 +64,71 @@ namespace traits
 
 template
 <
-    typename Point,
-    bool ClockWise, bool Closed,
-    template<typename, typename> class PointList,
-    template<typename, typename> class RingList,
-    template<typename> class PointAlloc,
-    template<typename> class RingAlloc
+    typename Ring,
+    template<typename, typename> class Container,
+    template<typename> class Allocator
 >
 struct tag
 <
     model::PolyhedralSurface
         <
-            Point, 
-            ClockWise, Closed,
-            PointList, RingList, 
-            PointAlloc, RingAlloc
+            Ring, 
+            Container, Allocator
         > 
 >
 {
-	typedef PolyhedralSurface_tag type;
+	typedef polyhedral_surface_tag type;
 };
-/*using tag < model::PolyhedralSurface <
-            Point, 
-            ClockWise, Closed,
-            PointList, RingList, 
-            PointAlloc, RingAlloc  > > = PolyhedralSurface_tag;*/
+
+template
+<
+    typename Ring,
+    template<typename, typename> class Container,
+    template<typename> class Allocator
+>
+struct Poly_ring_type
+<
+    model::PolyhedralSurface
+        <
+           Ring, 
+           Container, Allocator
+        >
+>
+{
+	typedef typename model::PolyhedralSurface
+	    <
+	        Ring, 
+	        Container, Allocator
+	    >::ring_type& type;
+};
+
+/*template 
+<
+    typename Ring,
+    template<typename, typename> class Container,
+    template<typename> class Allocator
+>
+struct ring_type
+<
+    model::PolyhedralSurface
+        < 
+            Ring,
+            Container, Allocator
+        >
+>
+{
+    typedef typename model::PolyhedralSurface
+        <
+            Ring,
+            Container, Allocator
+        >::ring_type& type;
+
+};*/
 
 
 } // namespace traits
 #endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
 
 }} // namespace boost::geometry
 
-#endif
+#endif
diff --git a/include/boost/geometry/geometries/concepts/PolyhedralSurface_concept.hpp b/include/boost/geometry/geometries/concepts/PolyhedralSurface_concept.hpp
@@ -0,0 +1,43 @@
+#ifndef BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_POLYHEDRALSURFACE_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_POLYHEDRALSURFACE_HPP
+
+#include <boost/concept_check.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/geometries/concepts/ring_concept.hpp>
+
+namespace boost { namespace geometry { namespace concepts 
+{
+
+
+template <typename Geometry>
+class PolyhedralSurface
+{
+
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+
+	typedef typename ring_type<Geometry>::type ring_type;
+	
+	
+	BOOST_CONCEPT_ASSERT( (concepts::Ring<ring_type>) );
+
+public:
+	
+	BOOST_CONCEPT_USAGE(PolyhedralSurface)
+	{
+
+		Geometry* polyhedralSurface = 0;
+		ring_type* ring = 0;
+
+	}
+#endif
+	
+};
+
+} // namepspace concepts
+
+} // namespace geometry
+
+} // namespace boost
+#endif 
diff --git a/include/boost/geometry/geometries/concepts/check.hpp b/include/boost/geometry/geometries/concepts/check.hpp
@@ -39,7 +39,7 @@
 #include <boost/geometry/geometries/concepts/polygon_concept.hpp>
 #include <boost/geometry/geometries/concepts/ring_concept.hpp>
 #include <boost/geometry/geometries/concepts/segment_concept.hpp>
-
+#include <boost/geometry/geometries/concepts/PolyhedralSurface_concept.hpp>
 #include <boost/geometry/algorithms/not_implemented.hpp>
 
 namespace boost { namespace geometry
@@ -121,6 +121,10 @@ struct check<Geometry, polygon_tag, false>
     : detail::concept_check::check<concepts::Polygon<Geometry> >
 {};
 
+template <typename Geometry>
+struct check<Geometry, polyhedral_surface_tag, false>
+    : detail::concept_check::check<concepts::PolyhedralSurface<Geometry> >
+{};
 
 template <typename Geometry>
 struct check<Geometry, box_tag, true>
diff --git a/include/boost/geometry/io/wkt/detail/prefix.hpp b/include/boost/geometry/io/wkt/detail/prefix.hpp
@@ -47,9 +47,9 @@ struct prefix_linestring
     static inline const char* apply() { return "LINESTRING"; }
 };
 
-struct prefix_polyhedron
+struct prefix_polyhedral_surface
 {
-	static inline const char* apply() { return "POLYHEDRON"; }
+	static inline const char* apply() { return "POLYHEDRALSURFACE Z"; }
 };
 
 struct prefix_multipoint
diff --git a/include/boost/geometry/io/wkt/read.hpp b/include/boost/geometry/io/wkt/read.hpp
@@ -453,6 +453,27 @@ struct polygon_parser
     }
 };
 
+template<typename PolyhedralSurface>
+struct polyhderal_surface_parser
+{
+    typedef typename ring_return_type<PolyhedralSurface>::type ring_return_type;
+    typedef container_appender<ring_return_type> appender;
+
+    static inline void apply(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             std::string const& wkt,
+                             PolyhedralSurface& ring)
+    {
+        handle_open_parenthesis(it, end, wkt);
+        int i = 0;
+        while(it != end && *it != ")"){
+            //appender::apply(it, end, wkt, ring);
+            i++;
+        }
+        handle_close_parenthesis(it, end, wkt);
+    }
+};
+
 
 inline bool one_of(tokenizer::iterator const& it,
                    std::string const& value,
@@ -563,7 +584,7 @@ struct geometry_parser
 {
     static inline void apply(std::string const& wkt, Geometry& geometry)
     {
-        geometry::clear(geometry);
+        //geometry::clear(geometry);
 
         tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()"));
         tokenizer::iterator it, end;
@@ -844,6 +865,15 @@ struct read_wkt<polygon_tag, Geometry>
         >
 {};
 
+template <typename Geometry>
+struct read_wkt<polyhedral_surface_tag, Geometry>
+    : detail::wkt::geometry_parser
+        < 
+            Geometry,
+            detail::wkt::polyhderal_surface_parser,
+            detail::wkt::prefix_polyhedral_surface
+        >
+{};
 
 template <typename MultiGeometry>
 struct read_wkt<multi_point_tag, MultiGeometry>
@@ -903,7 +933,7 @@ struct read_wkt<segment_tag, Segment>
 template <typename Geometry>
 inline void read_wkt(std::string const& wkt, Geometry& geometry)
 {
-    geometry::concepts::check<Geometry>();
+    //geometry::concepts::check<Geometry>();
     dispatch::read_wkt<typename tag<Geometry>::type, Geometry>::apply(wkt, geometry);
 }
 
