void test_one_lp(std::string const& caseid,
std::string const& wkt1, std::string const& wkt2,
std::size_t expected_count,
int expected_point_count,
double expected_length)
{
G1 g1;
bg::read_wkt(wkt1, g1);
G2 g2;
bg::read_wkt(wkt2, g2);
bg::correct(g1);
bg::correct(g2);
typedef typename setop_output_type<OutputType>::type result_type;
result_type pieces;
bg::difference(g1, g2, pieces);
typename bg::default_length_result<G1>::type length = 0;
std::size_t n = 0;
std::size_t piece_count = 0;
for (typename result_type::iterator it = pieces.begin();
it != pieces.end();
++it)
{
if (expected_point_count >= 0)
{
n += bg::num_points(*it);
}
piece_count++;
length += bg::length(*it);
}
BOOST_CHECK_MESSAGE(piece_count == expected_count,
"difference: " << caseid
<< " #outputs expected: " << expected_count
<< " detected: " << pieces.size()
);
if (expected_point_count >= 0)
{
BOOST_CHECK_MESSAGE(n == std::size_t(expected_point_count),
"difference: " << caseid
<< " #points expected: " << std::size_t(expected_point_count)
<< " detected: " << n
<< " type: " << (type_for_assert_message<G1, G2>())
);
}
BOOST_CHECK_CLOSE(length, expected_length, 0.001);
std::string lp = "lp_";
difference_output(lp + caseid, g1, g2, pieces);
}
std::string test_difference(std::string const& caseid, G1 const& g1, G2 const& g2,
int expected_count, int expected_rings_count, int expected_point_count,
double expected_area,
bool sym,
ut_settings const& settings)
{
typedef typename bg::coordinate_type<G1>::type coordinate_type;
boost::ignore_unused<coordinate_type>();
bg::model::multi_polygon<OutputType> result;
if (sym)
{
bg::sym_difference(g1, g2, result);
}
else
{
bg::difference(g1, g2, result);
}
if (settings.remove_spikes)
{
bg::remove_spikes(result);
}
#if ! defined(BOOST_GEOMETRY_TEST_ONLY_ONE_TYPE)
{
bg::model::multi_polygon<OutputType> result_s;
typedef typename bg::strategy::relate::services::default_strategy
<
G1, G2
>::type strategy_type;
if (sym)
{
bg::sym_difference(g1, g2, result_s, strategy_type());
}
else
{
bg::difference(g1, g2, result_s, strategy_type());
}
if (settings.remove_spikes)
{
bg::remove_spikes(result_s);
}
BOOST_CHECK_EQUAL(bg::num_points(result), bg::num_points(result_s));
}
#endif
std::ostringstream return_string;
return_string << bg::wkt(result);
typename bg::default_area_result<G1>::type const area = bg::area(result);
std::size_t const n = expected_point_count >= 0
? bg::num_points(result) : 0;
#if ! defined(BOOST_GEOMETRY_NO_BOOST_TEST)
if (settings.test_validity)
{
// std::cout << bg::dsv(result) << std::endl;
std::string message;
bool const valid = bg::is_valid(result, message);
BOOST_CHECK_MESSAGE(valid,
"difference: " << caseid << " not valid " << message
<< " type: " << (type_for_assert_message<G1, G2>()));
}
#endif
difference_output(caseid, g1, g2, result);
#if ! (defined(BOOST_GEOMETRY_TEST_ONLY_ONE_TYPE) \
|| defined(BOOST_GEOMETRY_DEBUG_ASSEMBLE))
{
// Test inserter functionality
// Test if inserter returns output-iterator (using Boost.Range copy)
typedef typename bg::point_type<G1>::type point_type;
typedef typename bg::rescale_policy_type<point_type>::type
rescale_policy_type;
rescale_policy_type rescale_policy
= bg::get_rescale_policy<rescale_policy_type>(g1, g2);
typename setop_output_type<OutputType>::type
inserted, array_with_one_empty_geometry;
array_with_one_empty_geometry.push_back(OutputType());
if (sym)
{
boost::copy(array_with_one_empty_geometry,
bg::detail::sym_difference::sym_difference_insert<OutputType>
(g1, g2, rescale_policy, std::back_inserter(inserted)));
}
else
{
boost::copy(array_with_one_empty_geometry,
bg::detail::difference::difference_insert<OutputType>(
g1, g2, rescale_policy, std::back_inserter(inserted)));
}
BOOST_CHECK_EQUAL(boost::size(result), boost::size(inserted) - 1);
}
#endif
#if ! defined(BOOST_GEOMETRY_NO_BOOST_TEST)
if (expected_point_count >= 0)
{
BOOST_CHECK_MESSAGE(bg::math::abs(int(n) - expected_point_count) < 3,
"difference: " << caseid
<< " #points expected: " << expected_point_count
<< " detected: " << n
<< " type: " << (type_for_assert_message<G1, G2>())
);
}
if (expected_count >= 0)
{
BOOST_CHECK_MESSAGE(int(boost::size(result)) == expected_count,
"difference: " << caseid
<< " #outputs expected: " << expected_count
<< " detected: " << result.size()
<< " type: " << (type_for_assert_message<G1, G2>())
);
}
if (expected_rings_count >= 0)
{
int nrings = int(boost::size(result) + bg::num_interior_rings(result));
BOOST_CHECK_MESSAGE(nrings == expected_rings_count,
"difference: " << caseid
<< " #rings expected: " << expected_rings_count
<< " detected: " << nrings
<< " type: " << (type_for_assert_message<G1, G2>())
);
}
BOOST_CHECK_CLOSE(area, expected_area, settings.percentage);
#endif
return return_string.str();
}
void test_difference(std::string const& caseid, G1 const& g1, G2 const& g2,
int expected_count, int expected_point_count,
double expected_area,
double percentage = 0.0001,
bool sym = false)
{
typedef typename bg::coordinate_type<G1>::type coordinate_type;
boost::ignore_unused<coordinate_type>();
std::vector<OutputType> clip;
if (sym)
{
bg::sym_difference(g1, g2, clip);
}
else
{
bg::difference(g1, g2, clip);
}
typename bg::default_area_result<G1>::type area = 0;
int n = 0;
for (typename std::vector<OutputType>::iterator it = clip.begin();
it != clip.end();
++it)
{
if (expected_point_count >= 0)
{
n += bg::num_points(*it);
}
area += bg::area(*it);
}
difference_output(caseid, g1, g2, clip);
#ifndef BOOST_GEOMETRY_DEBUG_ASSEMBLE
{
// Test inserter functionality
// Test if inserter returns output-iterator (using Boost.Range copy)
typedef typename bg::point_type<G1>::type point_type;
typedef typename bg::rescale_policy_type<point_type>::type
rescale_policy_type;
rescale_policy_type rescale_policy
= bg::get_rescale_policy<rescale_policy_type>(g1, g2);
std::vector<OutputType> inserted, array_with_one_empty_geometry;
array_with_one_empty_geometry.push_back(OutputType());
if (sym)
{
boost::copy(array_with_one_empty_geometry,
bg::detail::sym_difference::sym_difference_insert<OutputType>
(g1, g2, rescale_policy, std::back_inserter(inserted)));
}
else
{
boost::copy(array_with_one_empty_geometry,
bg::detail::difference::difference_insert<OutputType>(
g1, g2, rescale_policy, std::back_inserter(inserted)));
}
BOOST_CHECK_EQUAL(boost::size(clip), boost::size(inserted) - 1);
}
#endif
#if ! defined(BOOST_GEOMETRY_NO_BOOST_TEST)
if (expected_point_count >= 0)
{
BOOST_CHECK_MESSAGE(bg::math::abs(n - expected_point_count) < 3,
"difference: " << caseid
<< " #points expected: " << expected_point_count
<< " detected: " << n
<< " type: " << (type_for_assert_message<G1, G2>())
);
}
if (expected_count >= 0)
{
BOOST_CHECK_MESSAGE(int(clip.size()) == expected_count,
"difference: " << caseid
<< " #outputs expected: " << expected_count
<< " detected: " << clip.size()
<< " type: " << (type_for_assert_message<G1, G2>())
);
}
BOOST_CHECK_CLOSE(area, expected_area, percentage);
#endif
}