[ceph.git] / ceph / src / boost / libs / geometry / test / algorithms / set_operations / sym_difference / test_sym_difference_linear_linear.hpp

// Boost.Geometry (aka GGL, Generic Geometry Library)

// Copyright (c) 2014-2015, Oracle and/or its affiliates.

// Licensed under the Boost Software License version 1.0.
// http://www.boost.org/users/license.html

// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle

#ifndef BOOST_GEOMETRY_TEST_SYM_DIFFERENCE_LINEAR_LINEAR_HPP
#define BOOST_GEOMETRY_TEST_SYM_DIFFERENCE_LINEAR_LINEAR_HPP

#include <limits>

#include <boost/geometry/geometry.hpp>
#include "../test_set_ops_linear_linear.hpp"
#include <from_wkt.hpp>
#include <to_svg.hpp>


//==================================================================
//==================================================================
// symmetric difference of (linear) geometries
//==================================================================
//==================================================================

template
<
    typename Geometry1, typename Geometry2,
    typename MultiLineString
>
class test_sym_difference_of_geometries
{
private:
    static inline void base_test(Geometry1 const& geometry1,
                                 Geometry2 const& geometry2,
                                 MultiLineString const& mls_sym_diff,
                                 std::string const& case_id,
                                 double tolerance,
                                 bool test_vector_and_deque = false)
    {
        static bool vector_deque_already_tested = false;

        typedef typename boost::range_value<MultiLineString>::type LineString;
        typedef std::vector<LineString> linestring_vector;
        typedef std::deque<LineString> linestring_deque;

        MultiLineString mls_output;

        linestring_vector ls_vector_output;
        linestring_deque ls_deque_output;

        bg::sym_difference(geometry1, geometry2, mls_output);

        BOOST_CHECK_MESSAGE( equals::apply(mls_sym_diff, mls_output, tolerance),
                             "case id: " << case_id
                             << ", sym diff L/L: " << bg::wkt(geometry1)
                             << " " << bg::wkt(geometry2)
                             << " -> Expected: " << bg::wkt(mls_sym_diff)
                             << " computed: " << bg::wkt(mls_output) );


        set_operation_output("sym_difference", case_id,
                             geometry1, geometry2, mls_output);

#ifdef BOOST_GEOMETRY_TEST_DEBUG
        std::cout << "Geometry #1: " << bg::wkt(geometry1) << std::endl;
        std::cout << "Geometry #2: " << bg::wkt(geometry2) << std::endl;
        std::cout << "sym_difference : " << bg::wkt(mls_output) << std::endl;
        std::cout << "expected sym_difference : " << bg::wkt(mls_sym_diff)
                  << std::endl;
        std::cout << std::endl;
        std::cout << "************************************" << std::endl;
        std::cout << std::endl;
        std::cout << std::endl;
#endif

        if ( !vector_deque_already_tested && test_vector_and_deque )
        {
            vector_deque_already_tested = true;
#ifdef BOOST_GEOMETRY_TEST_DEBUG
            std::cout << std::endl;
            std::cout << "Testing with vector and deque as output container..."
                      << std::endl;
#endif
            bg::sym_difference(geometry1, geometry2, ls_vector_output);
            bg::sym_difference(geometry1, geometry2, ls_deque_output);

            BOOST_CHECK(multilinestring_equals
                        <
                            false
                        >::apply(mls_sym_diff, ls_vector_output, tolerance));

            BOOST_CHECK(multilinestring_equals
                        <
                            false
                        >::apply(mls_sym_diff, ls_deque_output, tolerance));

#ifdef BOOST_GEOMETRY_TEST_DEBUG
            std::cout << "Done!" << std::endl << std::endl;
#endif
        }

        // check the symmetric difference where the order of the two
        // geometries is reversed
        bg::clear(mls_output);
        bg::sym_difference(geometry2, geometry1, mls_output);

        BOOST_CHECK_MESSAGE( equals::apply(mls_sym_diff, mls_output, tolerance),
                             "case id: " << case_id
                             << ", sym diff L/L: " << bg::wkt(geometry2)
                             << " " << bg::wkt(geometry1)
                             << " -> Expected: " << bg::wkt(mls_sym_diff)
                             << " computed: " << bg::wkt(mls_output) );

#ifdef BOOST_GEOMETRY_TEST_DEBUG
        std::cout << "Geometry #1: " << bg::wkt(geometry2) << std::endl;
        std::cout << "Geometry #2: " << bg::wkt(geometry1) << std::endl;
        std::cout << "sym_difference : " << bg::wkt(mls_output) << std::endl;
        std::cout << "expected sym_difference : " << bg::wkt(mls_sym_diff)
                  << std::endl;
        std::cout << std::endl;
        std::cout << "************************************" << std::endl;
        std::cout << std::endl;
        std::cout << std::endl;
#endif
    }


public:
    static inline void apply(Geometry1 const& geometry1,
                             Geometry2 const& geometry2,
                             MultiLineString const& mls_sym_diff,
                             std::string const& case_id,
                             double tolerance
                                 = std::numeric_limits<double>::epsilon())
    {
#ifdef BOOST_GEOMETRY_TEST_DEBUG
        std::cout << "test case: " << case_id << std::endl;
        std::stringstream sstr;
        sstr << "svgs/" << case_id << ".svg";
#ifdef TEST_WITH_SVG
        to_svg(geometry1, geometry2, sstr.str());
#endif
#endif

        Geometry1 rg1(geometry1);
        bg::reverse<Geometry1>(rg1);

        Geometry2 rg2(geometry2);
        bg::reverse<Geometry2>(rg2);

        test_get_turns_ll_invariance<>::apply(geometry1, geometry2);
#ifdef BOOST_GEOMETRY_TEST_DEBUG
        std::cout << std::endl
                  << "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"
                  << std::endl << std::endl;
#endif
        test_get_turns_ll_invariance<>::apply(rg1, geometry2);

        base_test(geometry1, geometry2, mls_sym_diff, case_id, tolerance, true);
        //        base_test(geometry1, rg2, mls_sym_diff);
        //        base_test(rg1, geometry2, mls_sym_diff);
        base_test(rg1, rg2, mls_sym_diff, case_id, tolerance);

#ifdef BOOST_GEOMETRY_TEST_DEBUG
        std::cout << std::endl;
        std::cout << std::endl;
#endif
    }
};


#endif // BOOST_GEOMETRY_TEST_SYM_DIFFERENCE_LINEAR_LINEAR_HPP
Commit	Line	Data
7c673cae FG	1	// Boost.Geometry (aka GGL, Generic Geometry Library)
	2
	3	// Copyright (c) 2014-2015, Oracle and/or its affiliates.
	4
	5	// Licensed under the Boost Software License version 1.0.
	6	// http://www.boost.org/users/license.html
	7
	8	// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
	9
	10	#ifndef BOOST_GEOMETRY_TEST_SYM_DIFFERENCE_LINEAR_LINEAR_HPP
	11	#define BOOST_GEOMETRY_TEST_SYM_DIFFERENCE_LINEAR_LINEAR_HPP
	12
	13	#include <limits>
	14
	15	#include <boost/geometry/geometry.hpp>
	16	#include "../test_set_ops_linear_linear.hpp"
	17	#include <from_wkt.hpp>
	18	#include <to_svg.hpp>
	19
	20
	21	//==================================================================
	22	//==================================================================
	23	// symmetric difference of (linear) geometries
	24	//==================================================================
	25	//==================================================================
	26
	27	template
	28	<
	29	typename Geometry1, typename Geometry2,
	30	typename MultiLineString
	31	>
	32	class test_sym_difference_of_geometries
	33	{
	34	private:
	35	static inline void base_test(Geometry1 const& geometry1,
	36	Geometry2 const& geometry2,
	37	MultiLineString const& mls_sym_diff,
	38	std::string const& case_id,
	39	double tolerance,
	40	bool test_vector_and_deque = false)
	41	{
	42	static bool vector_deque_already_tested = false;
	43
	44	typedef typename boost::range_value<MultiLineString>::type LineString;
	45	typedef std::vector<LineString> linestring_vector;
	46	typedef std::deque<LineString> linestring_deque;
	47
	48	MultiLineString mls_output;
	49
	50	linestring_vector ls_vector_output;
	51	linestring_deque ls_deque_output;
	52
	53	bg::sym_difference(geometry1, geometry2, mls_output);
	54
	55	BOOST_CHECK_MESSAGE( equals::apply(mls_sym_diff, mls_output, tolerance),
	56	"case id: " << case_id
	57	<< ", sym diff L/L: " << bg::wkt(geometry1)
	58	<< " " << bg::wkt(geometry2)
	59	<< " -> Expected: " << bg::wkt(mls_sym_diff)
	60	<< " computed: " << bg::wkt(mls_output) );
	61
	62
	63	set_operation_output("sym_difference", case_id,
	64	geometry1, geometry2, mls_output);
65
66	#ifdef BOOST_GEOMETRY_TEST_DEBUG
67	std::cout << "Geometry #1: " << bg::wkt(geometry1) << std::endl;
68	std::cout << "Geometry #2: " << bg::wkt(geometry2) << std::endl;
69	std::cout << "sym_difference : " << bg::wkt(mls_output) << std::endl;
70	std::cout << "expected sym_difference : " << bg::wkt(mls_sym_diff)
71	<< std::endl;
72	std::cout << std::endl;
73	std::cout << "************************************" << std::endl;
74	std::cout << std::endl;
75	std::cout << std::endl;
76	#endif
77
78	if ( !vector_deque_already_tested && test_vector_and_deque )
79	{
80	vector_deque_already_tested = true;
81	#ifdef BOOST_GEOMETRY_TEST_DEBUG
82	std::cout << std::endl;
83	std::cout << "Testing with vector and deque as output container..."
84	<< std::endl;
85	#endif
86	bg::sym_difference(geometry1, geometry2, ls_vector_output);
87	bg::sym_difference(geometry1, geometry2, ls_deque_output);
88
89	BOOST_CHECK(multilinestring_equals
90	<
91	false
92	>::apply(mls_sym_diff, ls_vector_output, tolerance));
93
94	BOOST_CHECK(multilinestring_equals
95	<
96	false
97	>::apply(mls_sym_diff, ls_deque_output, tolerance));
98
99	#ifdef BOOST_GEOMETRY_TEST_DEBUG
100	std::cout << "Done!" << std::endl << std::endl;
101	#endif
102	}
103
104	// check the symmetric difference where the order of the two
105	// geometries is reversed
106	bg::clear(mls_output);
107	bg::sym_difference(geometry2, geometry1, mls_output);
108
109	BOOST_CHECK_MESSAGE( equals::apply(mls_sym_diff, mls_output, tolerance),
110	"case id: " << case_id
111	<< ", sym diff L/L: " << bg::wkt(geometry2)
112	<< " " << bg::wkt(geometry1)
113	<< " -> Expected: " << bg::wkt(mls_sym_diff)
114	<< " computed: " << bg::wkt(mls_output) );
115
116	#ifdef BOOST_GEOMETRY_TEST_DEBUG
117	std::cout << "Geometry #1: " << bg::wkt(geometry2) << std::endl;
118	std::cout << "Geometry #2: " << bg::wkt(geometry1) << std::endl;
119	std::cout << "sym_difference : " << bg::wkt(mls_output) << std::endl;
120	std::cout << "expected sym_difference : " << bg::wkt(mls_sym_diff)
121	<< std::endl;
122	std::cout << std::endl;
123	std::cout << "************************************" << std::endl;
124	std::cout << std::endl;
125	std::cout << std::endl;
126	#endif
127	}
128
129
130	public:
131	static inline void apply(Geometry1 const& geometry1,
132	Geometry2 const& geometry2,
133	MultiLineString const& mls_sym_diff,
134	std::string const& case_id,
135	double tolerance
136	= std::numeric_limits<double>::epsilon())
137	{
138	#ifdef BOOST_GEOMETRY_TEST_DEBUG
139	std::cout << "test case: " << case_id << std::endl;
140	std::stringstream sstr;
141	sstr << "svgs/" << case_id << ".svg";
142	#ifdef TEST_WITH_SVG
143	to_svg(geometry1, geometry2, sstr.str());
144	#endif
145	#endif
146
147	Geometry1 rg1(geometry1);
148	bg::reverse<Geometry1>(rg1);
149
150	Geometry2 rg2(geometry2);
151	bg::reverse<Geometry2>(rg2);
152
153	test_get_turns_ll_invariance<>::apply(geometry1, geometry2);
154	#ifdef BOOST_GEOMETRY_TEST_DEBUG
155	std::cout << std::endl
156	<< "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"
157	<< std::endl << std::endl;
158	#endif
159	test_get_turns_ll_invariance<>::apply(rg1, geometry2);
160
161	base_test(geometry1, geometry2, mls_sym_diff, case_id, tolerance, true);
162	// base_test(geometry1, rg2, mls_sym_diff);
163	// base_test(rg1, geometry2, mls_sym_diff);
164	base_test(rg1, rg2, mls_sym_diff, case_id, tolerance);
165
166	#ifdef BOOST_GEOMETRY_TEST_DEBUG
167	std::cout << std::endl;
168	std::cout << std::endl;
169	#endif
170	}
171	};
172
173
174	#endif // BOOST_GEOMETRY_TEST_SYM_DIFFERENCE_LINEAR_LINEAR_HPP