songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Removed unused code

This commit is contained in:
Sebastian Morr 2014-06-30 17:14:03 +02:00
parent 8a15677d1c
commit 25793b7683
5 changed files with 18 additions and 390 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Minkowski_sum_2/include/CGAL/Minkowski_sum_2/new/Arr_SegmentData_traits.h
View File

@ -51,7 +51,6 @@ public:
typedef typename Base::Compare_y_at_x_2 Compare_y_at_x_2;
typedef typename Base::Compare_x_2 Compare_x_2;
typedef typename Base::Compare_endpoints_xy_2 Compare_endpoints_xy_2;
typedef typename Base::Compare_y_at_x_right_2 Compare_y_at_x_right_2;
typedef typename Base::Has_left_category Has_left_category;
typedef Tag_false Has_merge_category;
@ -493,10 +492,6 @@ public:
Compare_endpoints_xy_2 compare_endpoints_xy_2_object() const {
return (Compare_endpoints_xy_2(((Base *)this)->compare_endpoints_xy_2_object()));
}
Compare_y_at_x_right_2 compare_y_at_x_right_2_object() const {
return (Compare_y_at_x_right_2(((Base *)this)->compare_y_at_x_right_2_object()));
}
};
} // namespace internal

384
Minkowski_sum_2/include/CGAL/Minkowski_sum_2/new/Minkowski_sum_conv_lien_2.h
View File

@ -514,14 +514,6 @@ public:
return sum;
}
std::list<ConvSegment> &getLoopSegmentsList() {
if (!_loopsCreated) {
createLoopsSegmentsLists();
}
return _loopSegmentsList;
}
std::list<ConvSegment> &getNonLoopSegmentsList() {
if (!_loopsCreated) {
createLoopsSegmentsLists();
@ -567,15 +559,6 @@ public:
}
}
template <typename InputIterator> void removeRange_bak(InputIterator start, InputIterator end) {
std::vector<typename InputIterator::value_type> vec(start, end);
sort(vec.begin(), vec.end());
std::vector<typename InputIterator::value_type> *seg_set = new std::vector<typename InputIterator::value_type>();
set_difference(_edgesSet->begin(), _edgesSet->end(), vec.begin(), vec.end(), back_inserter(*seg_set));
delete _edgesSet;
_edgesSet = new std::set<ConvSegment>(seg_set->begin(), seg_set->end());
}
ConvSegment getEdge() {
return *(_edgesSet->begin());
}
@ -1022,29 +1005,6 @@ private:
return checkCollisionDetection(arr, mid_point, pgn1, pgn2);
}
void removeFaceLoop(Arrangement_history_2 &arr, Halfedge_handle &handle) const {
std::list<Halfedge_handle> remove_list;
Ccb_halfedge_circulator circ = handle->ccb();
remove_list.push_front(handle);
++circ;
while (circ != handle) {
remove_list.push_front(circ);
++circ;
}
for (typename std::list<Halfedge_handle>::iterator itr = remove_list.begin(); itr != remove_list.end(); ++itr) {
arr.remove_edge(*itr);
}
}
void constructOrientableLoops(Arrangement_history_2 &arr) const {
const Minkowski_sum_by_convolution_lien_2 *ptr = this;
ConvSegMapper mapper(&arr, const_cast <Minkowski_sum_by_convolution_lien_2 *>(ptr));
TraversalManager manager(&mapper);
manager.traverseLoops();
}
bool checkDegenerateEdgeOppositeSegments(Arrangement_history_2 &arr, Halfedge_handle he) const {
Originating_curve_iterator segment_itr;// = arr.originating_curves_begin ( *he);
@ -1180,150 +1140,6 @@ private:
return sign * ang;
}
Halfedge_handle traverseNextHalfedge() {
}
void traceOrientableLoops(Arrangement_history_2 &arr, Edges_set &edges_set) const {
int loop_counter = 0;
std::list<Halfedge_iterator> temp_segments;
double angles_sum = 0;
// get an edge that is surly on the outside border. we will start from the external loop.
Face_iterator startFace = arr.unbounded_face();
Halfedge_iterator perimiterFace = *(startFace -> holes_begin());
Halfedge_iterator curr_halfedge = perimiterFace;//(*edges_set.begin());
if (!checkTripSameDirWithSegment(arr, curr_halfedge)) {
curr_halfedge = curr_halfedge->twin();
}
Halfedge_iterator start_halfedge = curr_halfedge;
temp_segments.push_back(curr_halfedge);
setEdgeVisited(*curr_halfedge, true, loop_counter);
Halfedge_handle close_loop_handle;
Halfedge_handle before_close_loop_handle;
bool isOrientable = true;
bool close_loop_found = false;
bool tracing_holes = false;
while (isOrientable) {
// after first loop we are starting to trace the holes.
if (loop_counter > 0) {
tracing_holes = true;
}
/////////////////////////DEBUG
Point_2 p_source = curr_halfedge->source()->point();
Point_2 p_end = curr_halfedge->target()->point();
double x1 = CGAL::to_double(p_source.x());
double y1 = CGAL::to_double(p_source.y());
double x2 = CGAL::to_double(p_end.x());
double y2 = CGAL::to_double(p_end.y());
int size_edges_set = edges_set.size();
/////////////////////////DEBUG
Vertex_iterator v_target = curr_halfedge->target();
p_source = v_target->point();
double x = CGAL::to_double(p_source.x());
double y = CGAL::to_double(p_source.y());
Halfedge_around_vertex_circulator itr = v_target->incident_halfedges();
bool next_edge_found;
bool temp_close_loop_found = false;
Halfedge_iterator next_halfedge = getLargestExitingClockwiseEdge(arr, curr_halfedge, *v_target, next_edge_found, loop_counter, temp_close_loop_found, close_loop_handle);
if (!next_halfedge->visited && next_edge_found) {
setEdgeVisited(*next_halfedge, true, loop_counter);
}
// if any ending of loop was found remember it.
if (temp_close_loop_found) {
before_close_loop_handle = curr_halfedge;
close_loop_found = true;
}
// Check if we are stuck or we have met a visited edge which closes the loop:
if (!next_edge_found) {
Halfedge_handle temp_twin = next_halfedge->twin();
if ((next_halfedge->loopNumber == loop_counter) && (next_halfedge != curr_halfedge) && (temp_twin != curr_halfedge)) {
// a loop closes with part of the edges. we have to remove edges till next_halfedge from arrangment,
// and clear the list.
removeHalfEdgesArrPart(arr, edges_set, temp_segments, next_halfedge);
//removeHalfEdgesArrPart(arr,edges_set,temp_segments,curr_halfedge);
nextLoop(temp_segments, arr, edges_set, curr_halfedge, start_halfedge, isOrientable, loop_counter);
}
else {
if (close_loop_found) {
removeHalfEdgesArrPartEnd(arr, edges_set, temp_segments, close_loop_handle, before_close_loop_handle);
nextLoop(temp_segments, arr, edges_set, curr_halfedge, start_halfedge, isOrientable, loop_counter);
close_loop_found = false;
} else {
// we are stuck.
removeHalfEdgesArr(arr, edges_set, temp_segments);
nextLoop(temp_segments, arr, edges_set, curr_halfedge, start_halfedge, isOrientable, loop_counter);
}
}
} else {
if (close_loop_found) {
// We have closed the loop, attempted to expand it and got stuck so remove everything but the loop.
// THIS IS WRONG ??????????????????????????????????????????????????????????????????????????????????????????????
removeHalfEdgesArrPartEnd(arr, edges_set, temp_segments, close_loop_handle, before_close_loop_handle);
nextLoop(temp_segments, arr, edges_set, curr_halfedge, start_halfedge, isOrientable, loop_counter);
close_loop_found = false;
} else {
curr_halfedge = next_halfedge;
temp_segments.push_back(curr_halfedge);
int size_temp_segments = temp_segments.size();
// check if loop has closed (?)
if (next_halfedge == start_halfedge) {
removeHalfedgesSet(arr, edges_set, temp_segments);
nextLoop(temp_segments, arr, edges_set, curr_halfedge, start_halfedge, isOrientable, loop_counter);
}
}
}
}
}
void nextLoop(std::list<Halfedge_iterator> &temp_segments, Arrangement_history_2 &arr, Edges_set &edges_set, Halfedge_iterator &curr_halfedge, Halfedge_iterator &start_halfedge, bool &isOrientable, int &loop_counter) const {
temp_segments.clear();
if (edges_set.size() > 0) {
++loop_counter;
curr_halfedge = (*edges_set.begin());
while (curr_halfedge->visited && edges_set.size() > 0) {
typename Edges_set::iterator testItem = edges_set.find(curr_halfedge);
if (testItem == edges_set.end()) {
testItem = edges_set.find(((curr_halfedge)->twin()));
if (testItem != edges_set.end()) {
edges_set.erase(testItem);
}
} else {
edges_set.erase(testItem);
}
curr_halfedge = (*edges_set.begin());
}
if (!checkTripSameDirWithSegment(arr, curr_halfedge)) {
curr_halfedge = curr_halfedge->twin();
}
setEdgeVisited(*curr_halfedge, true, loop_counter);
temp_segments.push_back(curr_halfedge);
start_halfedge = curr_halfedge;
} else {
isOrientable = false;
}
}
void setEdgeVisited(Halfedge &he, bool value, int id) const {
he.visited = value;
he.twin()->visited = value;
@ -1336,190 +1152,6 @@ private:
he.twin()->isDegenerate = value;
}
bool getEdgeDegenerate(Halfedge_handle &he) const {
return he.isDegenerate;
}
bool getEdgeVisited(Halfedge_handle &he) const {
return he.visited;
}
// Removes the edges matching to halfedges from the set
void removeHalfedgesSet(Arrangement_history_2 &arr, Edges_set &edges_set, std::list<Halfedge_iterator> &temp_segments) const {
removeHalfEdgesInner(arr, edges_set, temp_segments, false, false, false, *(temp_segments.begin()), *(temp_segments.begin()));
}
// Removes the edges matching to halfedges from the set and arrangment
void removeHalfEdgesArr(Arrangement_history_2 &arr, Edges_set &edges_set, std::list<Halfedge_iterator> &temp_segments) const {
removeHalfEdgesInner(arr, edges_set, temp_segments, true, false, false, *(temp_segments.begin()), *(temp_segments.begin()));
}
// Remove edges before loop and keep loop
void removeHalfEdgesArrPart(Arrangement_history_2 &arr, Edges_set &edges_set, std::list<Halfedge_iterator> &temp_segments, Halfedge_handle &partition) const {
removeHalfEdgesInner(arr, edges_set, temp_segments, false, true, false, partition, *(temp_segments.begin()));
}
// Remove edges before loop and keep loop and remove edges after loop.
void removeHalfEdgesArrPartEnd(Arrangement_history_2 &arr, Edges_set &edges_set, std::list<Halfedge_iterator> &temp_segments, Halfedge_handle &partition, Halfedge_handle &end_partition) const {
removeHalfEdgesInner(arr, edges_set, temp_segments, false, true, true, partition, end_partition);
}
// remove half edges from set or set and arrangment.
void removeHalfEdgesInner(Arrangement_history_2 &arr, Edges_set &edges_set, std::list<Halfedge_iterator> &temp_segments, bool remove_arr, bool range, bool end_range, Halfedge_handle &partition_itr, Halfedge_handle &partition_end_itr) const {
bool part_reached = false;
typename Edges_set::iterator partItem = edges_set.find(partition_itr);
if (partItem == edges_set.end()) {
partItem = edges_set.find(((*partition_itr).twin()));
}
typename Edges_set::iterator part_item_end = edges_set.find(partition_end_itr);
if (part_item_end == edges_set.end()) {
part_item_end = edges_set.find(((*partition_end_itr).twin()));
}
Halfedge_handle h_e_start;
if (partItem != edges_set.end()) {
h_e_start = *partItem;
}
Halfedge_handle h_e_finish;
if (part_item_end != edges_set.end()) {
h_e_finish = *part_item_end;
}
bool mark_change_part = false;
for (typename std::list<Halfedge_iterator>::iterator itr = temp_segments.begin(); itr != temp_segments.end(); ++itr) {
if (range && !part_reached && ((*itr == h_e_start) || (*itr == h_e_start->twin()))) {
part_reached = true;
}
// If we have to close the loop check if range end has arrived
if (range && end_range && part_reached && (((*itr) == h_e_finish) || (*itr == h_e_finish->twin()))) {
mark_change_part = true;
}
typename Edges_set::iterator testItem = edges_set.find(*itr);
if (testItem == edges_set.end()) {
testItem = edges_set.find(((*itr)->twin()));
if (testItem != edges_set.end()) {
edges_set.erase(testItem);
if (remove_arr || (range && !part_reached)) {
arr.remove_edge(*itr);
}
}
} else {
edges_set.erase(testItem);
if (remove_arr || (range && !part_reached)) {
arr.remove_edge(*itr);
}
}
if (mark_change_part) {
part_reached = false;
}
}
}
Halfedge_handle getLargestExitingClockwiseEdge(Arrangement_history_2 &arr, Halfedge_iterator &curr_halfedge, Vertex &v_target, bool &next_edge_found, int loop_number, bool &close_loop_found, Halfedge_handle &handle_close_loop) const {
Point_2 p_source = v_target.point();
double x1 = CGAL::to_double(p_source.x());
double y1 = CGAL::to_double(p_source.y());
Halfedge_around_vertex_circulator itr = v_target.incident_halfedges();
Halfedge_around_vertex_circulator start = itr;
Halfedge_around_vertex_circulator tmp = itr;
++itr;
if (itr == tmp) {
next_edge_found = false;
return itr;
}
bool found = false;
Direction_2 entering_dir = f_direction((f_vector(curr_halfedge->source()->point(), curr_halfedge->target()->point())));
// find first edge which is valid in direction with respect to original edges.
//
int count = 0;
bool res;
while ((!(res = checkTripSameDirWithSegment(arr, ((itr->twin())))) || (curr_halfedge == itr) || (itr->visited)) && (itr != start)) {
++itr;
++ count;
}
Halfedge_handle maybe_visited;
if (count == 1) {
close_loop_found = false;
if (!checkOutgoingNotVisited(arr, v_target, maybe_visited, loop_number)) {
close_loop_found = true;
handle_close_loop = maybe_visited;
}
}
if (!res || itr->visited) {
next_edge_found = false;
return itr->twin();
}
if (count != 1) {
close_loop_found = false;
if (!checkOutgoingNotVisited(arr, v_target, maybe_visited, loop_number)) {
close_loop_found = true;
handle_close_loop = maybe_visited;
}
}
// Now we have the first edge, check if we can improve
Halfedge_around_vertex_circulator next_edge_itr = itr;
++next_edge_itr;
count = 0;
Direction_2 min_edge_dir = f_direction((f_vector(itr->twin()->source()->point(), itr->twin()->target()->point())));
while (next_edge_itr != itr) {
if (checkTripSameDirWithSegment(arr, ((next_edge_itr->twin())))) {
Direction_2 new_edge_dir = f_direction((f_vector(next_edge_itr->twin()->source()->point(), next_edge_itr->twin()->target()->point())));
// If the new edge improves the old one, ie it is larger and satisfies the improvment rule, which is under consideration.
// currently, being the anticlocwise most if we are in right halfplane of the entering direction, and then choose anti clockwise most from left plane.
if (isDirImproving(min_edge_dir, entering_dir, new_edge_dir) &&
(!next_edge_itr->visited)
) {
itr = next_edge_itr;
min_edge_dir = f_direction((f_vector(itr->twin()->source()->point(), itr->twin()->target()->point())));
}
}
++count;
++next_edge_itr;
}
if (close_loop_found) {
Direction_2 new_edge_dir = f_direction((f_vector(maybe_visited->twin()->source()->point(), maybe_visited->twin()->target()->point())));
if (isDirImproving(min_edge_dir, entering_dir, new_edge_dir)) {
next_edge_found = true;
return maybe_visited->twin();
}
}
next_edge_found = true;
return itr->twin();
}
bool isDirImproving(Direction_2 &min_edge_dir, Direction_2 &entering_dir, Direction_2 &new_edge_dir) const {
Direction_2 opp_enter = -entering_dir;
@ -1550,22 +1182,6 @@ private:
return true;
}
bool checkTripSameDirWithSegment_bak(Arrangement_history_2 &arr, Halfedge_handle he) const {
Originating_curve_iterator segment_itr;// = arr.originating_curves_begin ( *he);
Direction_2 start_he_dir = f_direction((f_vector(he->source()->point(), he->target()->point())));
for (segment_itr = arr.originating_curves_begin(he); segment_itr != arr.originating_curves_end(he); ++segment_itr) {
Segment_2 segment = *segment_itr;
Direction_2 start_seg_dir = f_direction(f_vector(segment.source(), segment.target()));
if (start_seg_dir == start_he_dir) {
return true;
}
}
return false;
}
bool checkTripSameDirWithSegment(Arrangement_history_2 &arr, Halfedge_handle he) const {
Originating_curve_iterator segment_itr;

13
Minkowski_sum_2/test/Minkowski_sum_2/read_polygon.h
View File

@ -36,4 +36,17 @@ bool read_polygon_with_holes (const char *filename, CGAL::Polygon_with_holes_2<K
return true;
}
template <class Kernel>
bool write_polygon_with_holes (const char *filename, CGAL::Polygon_with_holes_2<Kernel>& pgn)
{
std::cout << filename << std::endl;
std::ofstream ofile(filename);
if (ofile.is_open()) {
ofile << pgn;
} else {
exit(1);
}
return true;
}
#endif

1
Minkowski_sum_2/test/Minkowski_sum_2/test_Minkowski_sum.cmd
View File

@ -1,3 +1,4 @@
compare ./data/star_50_1.txt ./data/star_50_2.txt
compare ./data/rooms_part1.dat ./data/rooms_part2.dat
compare ./data/comb_part1.dat ./data/comb_part2.dat
compare ./data/knife_part1.dat ./data/knife_part2.dat

5
Minkowski_sum_2/test/Minkowski_sum_2/test_Minkowski_sum.cpp
View File

@ -19,6 +19,7 @@
#include <CGAL/Timer.h>
#include "read_polygon.h"
#include <cstring>
#include <libgen.h>
#include <list>
@ -198,7 +199,9 @@ int main (int argc, char **argv)
std::cout << "ERROR (different result)." << std::endl;
return 1;
}
write_polygon_with_holes((std::string("./results/") + basename(argv[i+1]) + "-and-" + basename(argv[i+2]) + ".dat").c_str(), sum_conv_new);
if (verify)
{
i += 4;