Add MapRender for quads

cgogn/core/container/chunk_array.h

@@ -347,10 +347,10 @@ class ChunkArray : public ChunkArrayGen<CHUNK_SIZE>
 		}
 	}
 
-	void import_element(uint32 idx, std::istream& in) override
-	{
-		serialization::parse(in, this->operator [](idx));
-	}
+//	void import_element(uint32 idx, std::istream& in) override
+//	{
+//		serialization::parse(in, this->operator [](idx));
+//	}
 
 	const void* element_ptr(uint32 idx) const override
 	{
@@ -701,14 +701,14 @@ class ChunkArrayBool : public ChunkArrayGen<CHUNK_SIZE>
 		serialization::ostream_writer(o, this->operator[](idx),binary, little_endian);
 	}
 
-	void import_element(uint32 idx, std::istream& in) override
-	{
-		std::string val;
-		in >> val;
-		val = to_lower(val);
-		const bool b = (val == "true") || (std::stoi(val) != 0);
-		set_value(idx,b);
-	}
+//	void import_element(uint32 idx, std::istream& in) override
+//	{
+//		std::string val;
+//		in >> val;
+//		val = to_lower(val);
+//		const bool b = (val == "true") || (std::stoi(val) != 0);
+//		set_value(idx,b);
+//	}
 
 	const void* element_ptr(uint32) const override
 	{

cgogn/core/container/chunk_array_container.h

@@ -222,7 +222,9 @@ class ChunkArrayContainer
 		// first check if attribute already exists
 		const uint32 index = array_index(name);
 		if (index == UNKNOWN)
+		{
 			return nullptr;
+		}
 		return dynamic_cast<ChunkArray<T>*>(table_arrays_[index]);
 	}
 
@@ -238,7 +240,6 @@ class ChunkArrayContainer
 		const uint32 index = array_index(name);
 		if (index == UNKNOWN)
 		{
-			cgogn_log_warning("get_chunk_array") << "Chunk array of name \"" << name << "\" not found.";
 			return nullptr;
 		}
 

cgogn/core/container/chunk_array_gen.h

@@ -217,7 +217,7 @@ class ChunkArrayGen
 	 * @param idx
 	 * @param i
 	 */
-	virtual void import_element(uint32 idx, std::istream& in) = 0;
+//	virtual void import_element(uint32 idx, std::istream& in) = 0;
 	/**
 	 * @brief element_ptr
 	 * @return a generic pointer to the element of index idx.

cgogn/geometry/CMakeLists.txt

@@ -8,6 +8,7 @@ set(HEADER_ALGOS
 	algos/area.h
 	algos/centroid.h
 	algos/curvature.h
+	algos/convexity.h
 	algos/normal.h
 	algos/ear_triangulation.h
 	algos/picking.h

cgogn/geometry/algos/convexity.h

@@ -0,0 +1,141 @@
+/*******************************************************************************
+* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps  *
+* Copyright (C) 2015, IGG Group, ICube, University of Strasbourg, France       *
+*                                                                              *
+* This library is free software; you can redistribute it and/or modify it      *
+* under the terms of the GNU Lesser General Public License as published by the *
+* Free Software Foundation; either version 2.1 of the License, or (at your     *
+* option) any later version.                                                   *
+*                                                                              *
+* This library is distributed in the hope that it will be useful, but WITHOUT  *
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or        *
+* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License  *
+* for more details.                                                            *
+*                                                                              *
+* You should have received a copy of the GNU Lesser General Public License     *
+* along with this library; if not, write to the Free Software Foundation,      *
+* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.           *
+*                                                                              *
+* Web site: http://cgogn.unistra.fr/                                           *
+* Contact information: cgogn@unistra.fr                                        *
+*                                                                              *
+*******************************************************************************/
+
+#ifndef CGOGN_GEOMETRY_ALGOS_CONVEXITY_H
+#define CGOGN_GEOMETRY_ALGOS_CONVEXITY_H
+
+#include <cgogn/geometry/types/geometry_traits.h>
+#include <cgogn/geometry/algos/length.h>
+
+#include <cgogn/core/cmap/attribute.h>
+
+namespace cgogn
+{
+
+namespace geometry
+{
+
+/**
+ * @brief is_planar verifies if a face is planar: defined by the fact that all coordinates other than the first two (x and y) are constant (up to epsilon)
+ * @param map the map
+ * @param f the face
+ * @param position container of vertex positions
+ * @param epsilon maximum deviation of each component
+ * @return true iff planar
+ */
+template <typename VEC, typename MAP>
+inline bool is_planar(
+	const MAP& map,
+	const typename MAP::Face f,
+	const typename MAP::template VertexAttribute<VEC>& position,
+	typename vector_traits<VEC>::Scalar epsilon = Eigen::NumTraits<typename vector_traits<VEC>::Scalar>::dummy_precision()
+)
+{
+	using Scalar = typename vector_traits<VEC>::Scalar;
+	using Vertex = typename MAP::Vertex;
+
+	if (vector_traits<VEC>::SIZE < 3)
+		return true ;
+
+	using VecN_2 = Eigen::Matrix<Scalar,vector_traits<VEC>::SIZE - 2,1> ;
+	// Init with first vertex
+	VecN_2 depth0 ;
+	for (uint i = 0 ; i < vector_traits<VEC>::SIZE - 2 ; ++i)
+		depth0[i] = position[Vertex(f.dart)][i+2] ;
+
+	// verify that other vertices do not deviate in coordinates 3 (z) and higher.
+	bool planar = true ;
+	map.foreach_incident_vertex(f, [&] (Vertex v) -> bool
+	{
+		VecN_2 depth ;
+		for (uint i = 0 ; i < vector_traits<VEC>::SIZE - 2 ; ++i)
+		{
+			depth[i] = position[v][i+2] ;
+			if (!depth.isApprox(depth0,epsilon))
+			{
+				planar = false ;
+			}
+		}
+		return planar ;
+	});
+
+	return planar ;
+}
+
+/**
+ * @brief is_convex verifies if a given face is convex (in the plane, not in 3D).
+ * @param map the map
+ * @param f the face
+ * @param position the geometric embedding of the vertices
+ * @note if the face is not planar (see #is_planar), false is returned.
+ * @return true iff the face is convex.
+ */
+template <typename VEC, typename MAP>
+inline bool is_convex(
+	const MAP& map,
+	const typename MAP::Face f,
+	const typename MAP::template VertexAttribute<VEC>& position
+)
+{
+	if (!is_planar<VEC,MAP>(map,f,position))
+	{
+		cgogn_log_error("Trying to assess convexity of a face while it's not planar. This is ill-defined") ;
+		return false ;
+	}
+
+	using Scalar = typename vector_traits<VEC>::Scalar;
+	using Vertex = typename MAP::Vertex;
+	//using Dart = typename MAP::Dart;
+
+	bool convex = true ;
+	if (map.codegree(f) >= 3) // true otherwise
+	{
+		// Take all two consecutive darts and compute cross products.
+		// The face is convex iff the z components of all products have the same sign.
+		bool sign ;
+		bool first = true ;
+		map.foreach_dart_of_orbit(f, [&] (Dart d)
+		{
+			const VEC d1 = vector_from<VEC>(map,d,position) ;
+			const VEC d2 = vector_from<VEC>(map,map.phi1(d),position) ;
+			const Scalar zcross = d1[0]*d2[1] - d1[1]*d2[0] ;
+			if (first)
+			{
+				sign = (zcross > Scalar(0)) ;
+				first = false ;
+			}
+			else
+			{
+				if (sign != (zcross > Scalar(0)))
+					convex = false ;
+			}
+		});
+	}
+	return convex ;
+}
+
+} // Geometry
+
+} // CGoGN
+
+#endif // CGOGN_GEOMETRY_ALGOS_CONVEXITY_H

cgogn/geometry/functions/area.h

@@ -35,13 +35,28 @@ namespace geometry
 /**
  * area of the triangle formed by 3 points in 3D
  */
-template <typename VEC3>
-inline typename vector_traits<VEC3>::Scalar area(const VEC3& p1, const VEC3& p2, const VEC3& p3)
+template <typename VEC>
+inline auto area(const VEC& p1, const VEC& p2, const VEC& p3)
+	-> typename std::enable_if<vector_traits<VEC>::SIZE == 3, typename vector_traits<VEC>::Scalar>::type
 {
-	using Scalar = typename vector_traits<VEC3>::Scalar;
+	using Scalar = typename vector_traits<VEC>::Scalar;
 	return (Scalar(0.5) * ((p2 - p1).cross(p3 - p1)).norm());
 }
 
+/**
+ * area of the triangle formed by 3 points in 2D
+ */
+template <typename VEC>
+inline auto area(const VEC& p1, const VEC& p2, const VEC& p3)
+	-> typename std::enable_if<vector_traits<VEC>::SIZE == 2, typename vector_traits<VEC>::Scalar>::type
+{
+	using Scalar = typename vector_traits<VEC>::Scalar;
+	VEC v1 = p2 - p1;
+	VEC v2 = p3 - p1;
+	return (Scalar(0.5) * (v1[0] * v2[1] - v1[1] * v2[0]));
+}
+
+
 } // namespace geometry
 
 } // namespace cgogn

cgogn/geometry/types/aabb.h

@@ -274,8 +274,9 @@ class AABB
 
 	/// \brief Test if a ray intersectes an axis-aligned box
 	/// \tparam VEC3 the domain of the box. Has to be of dimension 3
+	template <bool B = true>
 	auto ray_intersect(const Vec& P, const Vec& V) const
-	  -> typename std::enable_if<nb_components_traits<Vec>::value == 3, bool>::type
+	  -> typename std::enable_if<B && nb_components_traits<Vec>::value == 3, bool>::type
 	{
 		if (!cgogn::almost_equal_relative(V[2], Scalar(0)))
 		{

cgogn/modeling/CMakeLists.txt

@@ -20,6 +20,7 @@ set(HEADER_TILING
 	tiling/square_grid.h
 	tiling/square_cylinder.h
 	tiling/square_tore.h
+	tiling/parallelogram_grid.h
 )
 set(HEADER_DECIMATION
 	decimation/edge_approximator.h
@@ -50,6 +51,7 @@ set(SOURCE_TILING
 	tiling/square_cylinder.cpp
 	tiling/square_tore.cpp
 #	tiling/square_cube.h
+	tiling/parallelogram_grid.cpp
 )
 set(SOURCE_FILES ${SOURCE_ALGOS} ${SOURCE_TILING})
 

cgogn/modeling/tiling/parallelogram_grid.cpp

@@ -0,0 +1,38 @@
+/*******************************************************************************
+* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps  *
+* Copyright (C) 2015, IGG Group, ICube, University of Strasbourg, France       *
+*                                                                              *
+* This library is free software; you can redistribute it and/or modify it      *
+* under the terms of the GNU Lesser General Public License as published by the *
+* Free Software Foundation; either version 2.1 of the License, or (at your     *
+* option) any later version.                                                   *
+*                                                                              *
+* This library is distributed in the hope that it will be useful, but WITHOUT  *
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or        *
+* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License  *
+* for more details.                                                            *
+*                                                                              *
+* You should have received a copy of the GNU Lesser General Public License     *
+* along with this library; if not, write to the Free Software Foundation,      *
+* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.           *
+*                                                                              *
+* Web site: http://cgogn.unistra.fr/                                           *
+* Contact information: cgogn@unistra.fr                                        *
+*                                                                              *
+*******************************************************************************/
+
+#define CGOGN_MODELING_TILING_PARALLELOGRAM_GRID_CPP_
+
+#include <cgogn/modeling/tiling/parallelogram_grid.h>
+
+namespace cgogn
+{
+
+namespace modeling
+{
+
+//template class CGOGN_MODELING_API ParallelogramGrid<CMap2,Eigen::Vector2d>;
+
+} // namespace modeling
+
+} // namespace cgogn