haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Eeschema: added hotkeys in libedit. Update Boost::polygon

This commit is contained in:
jean-pierre charras 2010-10-21 21:01:37 +02:00
parent dbd4fe12be
commit 796eca5c64
19 changed files with 227 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
CHANGELOG.txt
View File

@ -4,6 +4,22 @@ KiCad ChangeLog 2010
Please add newer entries at the top, list the date and your name with
email address.
2010-oct-20 UPDATE Wayne Stambaugh <stambaughw@verizon.net>
================================================================================
Eeschema:
Major component library ojbect editing code refactor.
* All library component object editing is now performed with the ojbect
except LIB_PIN (coming soon).
* Added TRANFORM class to handle coordinate transforms.
* Remove old transform matrix functions.
* More file renaming to align them with the other component library
object file names.
* Fix hot key bugs in library editor to disable edit keys while an item
is being edited.
* Fixed bug when cancelling rotation of text and field objects while
being moved.
2010-Oct-20 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================
++richio:

18
eeschema/hotkeys.cpp
View File

@ -111,7 +111,7 @@ static Ki_HotkeyInfo HkMirrorXComponent( wxT( "Mirror X Component" ),
HK_MIRROR_X_COMPONENT, 'X' );
static Ki_HotkeyInfo HkOrientNormalComponent( wxT( "Orient Normal Component" ),
HK_ORIENT_NORMAL_COMPONENT, 'N' );
static Ki_HotkeyInfo HkRotate( wxT( "Rotate Schematic Item" ),
static Ki_HotkeyInfo HkRotate( wxT( "Rotate Item" ),
HK_ROTATE, 'R' );
static Ki_HotkeyInfo HkEdit( wxT( "Edit Schematic Item" ),
HK_EDIT, 'E' );
@ -120,7 +120,7 @@ static Ki_HotkeyInfo HkEditComponentValue( wxT( "Edit Component Value" ),
static Ki_HotkeyInfo HkEditComponentFootprint( wxT( "Edit Component Footprint" ),
HK_EDIT_COMPONENT_FOOTPRINT,
'F' );
static Ki_HotkeyInfo HkMove( wxT( "Move Schematic Item" ),
static Ki_HotkeyInfo HkMove( wxT( "Move Item" ),
HK_MOVE_COMPONENT_OR_ITEM, 'M',
ID_POPUP_SCH_MOVE_CMP_REQUEST );
@ -143,7 +143,7 @@ static Ki_HotkeyInfo HkFindNextDrcMarker( wxT( "Find next DRC marker" ), HK_FIND
// Special keys for library editor:
static Ki_HotkeyInfo HkCreatePin( wxT( "Create Pin" ), HK_LIBEDIT_CREATE_PIN, 'P' );
static Ki_HotkeyInfo HkInsertPin( wxT( "Repeat Pin" ), HK_REPEAT_LAST, WXK_INSERT );
static Ki_HotkeyInfo HkMovePin( wxT( "Move Pin" ), HK_LIBEDIT_MOVE_GRAPHIC_ITEM, 'M' );
static Ki_HotkeyInfo HkMoveLibItem( wxT( "Move Lib Item" ), HK_LIBEDIT_MOVE_GRAPHIC_ITEM, 'M' );
// List of common hotkey descriptors
@ -193,7 +193,7 @@ Ki_HotkeyInfo* s_LibEdit_Hotkey_List[] =
&HkCreatePin,
&HkInsertPin,
&HkEdit,
&HkMovePin,
&HkMoveLibItem,
&HkDelete,
&HkRotate,
&HkDrag,
@ -816,6 +816,11 @@ void WinEDA_LibeditFrame::OnHotKey( wxDC* DC, int hotkey, EDA_BaseStruct* DrawSt
GetEventHandler()->ProcessEvent( cmd );
break;
case COMPONENT_FIELD_DRAW_TYPE:
cmd.SetId( ID_POPUP_LIBEDIT_FIELD_EDIT_ITEM );
GetEventHandler()->ProcessEvent( cmd );
break;
default:
break;
}
@ -839,6 +844,11 @@ void WinEDA_LibeditFrame::OnHotKey( wxDC* DC, int hotkey, EDA_BaseStruct* DrawSt
GetEventHandler()->ProcessEvent( cmd );
break;
case COMPONENT_FIELD_DRAW_TYPE:
cmd.SetId( ID_POPUP_LIBEDIT_FIELD_ROTATE_ITEM );
GetEventHandler()->ProcessEvent( cmd );
break;
default:
break;
}

9
eeschema/libedit_onrightclick.cpp
View File

@ -248,10 +248,15 @@ bool WinEDA_LibeditFrame::OnRightClick( const wxPoint& MousePos, wxMenu* PopMenu
ADD_MENUITEM( PopMenu, ID_POPUP_LIBEDIT_MOVE_ITEM_REQUEST,
msg, move_field_xpm );
}
msg = AddHotkeyName( _( "Field Rotate" ), s_Libedit_Hokeys_Descr,
HK_ROTATE );
ADD_MENUITEM( PopMenu, ID_POPUP_LIBEDIT_FIELD_ROTATE_ITEM,
_( "Field Rotate" ), rotate_field_xpm );
msg, rotate_field_xpm );
msg = AddHotkeyName( _( "Field Edit" ), s_Libedit_Hokeys_Descr,
HK_EDIT );
ADD_MENUITEM( PopMenu, ID_POPUP_LIBEDIT_FIELD_EDIT_ITEM,
_( "Field Edit" ), edit_text_xpm );
msg, edit_text_xpm );
break;

11
eeschema/pinedit.cpp
View File

@ -38,8 +38,8 @@ static bool LastPinCommonConvert = false;
static bool LastPinCommonUnit = false;
static bool LastPinVisible = true;
void WinEDA_LibeditFrame::OnRotatePin( wxCommandEvent& event ){
void WinEDA_LibeditFrame::OnRotatePin( wxCommandEvent& event )
{
// Check, if the item is a pin, else return
if( m_drawItem == NULL || m_drawItem->Type() != COMPONENT_PIN_DRAW_TYPE )
return;
@ -50,7 +50,7 @@ void WinEDA_LibeditFrame::OnRotatePin( wxCommandEvent& event ){
// Save old pin orientation
LastPinOrient = pin -> m_Orient;
SaveCopyInUndoList( pin->GetParent() );
SaveCopyInUndoList( pin->GetParent() );
// Get the actual pin orientation index
int orientationIndex = pin -> GetOrientationCodeIndex(pin -> m_Orient);
@ -144,6 +144,8 @@ void WinEDA_LibeditFrame::OnEditPin( wxCommandEvent& event )
LastPinCommonUnit = dlg.GetAddToAllParts();
LastPinVisible = dlg.GetVisible();
if( !pin->IsNew() )
SaveCopyInUndoList( pin->GetParent() );
pin->EnableEditMode( true, g_EditPinByPinIsOn );
pin->SetName( dlg.GetName() );
pin->SetNameTextSize( LastPinNameSize );
@ -159,9 +161,6 @@ void WinEDA_LibeditFrame::OnEditPin( wxCommandEvent& event )
if( pin->IsModified() || pin->IsNew() )
{
if( !pin->IsNew() )
SaveCopyInUndoList( pin->GetParent() );
OnModify( );
pin->DisplayInfo( this );
DrawPanel->Refresh();

2
include/boost/polygon/detail/boolean_op_45.hpp
View File

@ -445,7 +445,7 @@ namespace boost { namespace polygon{
};
template <typename S45V>
static inline void sortScan45Vector(S45V& vec) {
std::sort(vec.begin(), vec.end(), lessScan45Vertex());
gtlsort(vec.begin(), vec.end(), lessScan45Vertex());
}
template <typename CountType, typename output_functor>

2
include/boost/polygon/detail/max_cover.hpp
View File

@ -213,7 +213,7 @@ namespace boost { namespace polygon{
Interval rectIvl = nodep->rect.get(orient);
leadingEdges.push_back(EdgeAssociation(std::pair<Unit, Interval>(leading, rectIvl), nodep));
}
std::sort(leadingEdges.begin(), leadingEdges.end(), lessEdgeAssociation());
gtlsort(leadingEdges.begin(), leadingEdges.end(), lessEdgeAssociation());
typename std::vector<EdgeAssociation>::iterator leadingBegin = leadingEdges.begin();
iT trailingBegin = beginNode;
while(leadingBegin != leadingEdges.end()) {

40
include/boost/polygon/detail/polygon_45_formation.hpp
View File

@ -904,7 +904,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(10, 0), 2, -1));
data.push_back(Vertex45(Point(10, 10), 2, 1));
data.push_back(Vertex45(Point(10, 10), 0, 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -928,7 +928,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(10, 10), 2, -1));
data.push_back(Vertex45(Point(10, 20), 2, 1));
data.push_back(Vertex45(Point(10, 20), 1, 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -953,7 +953,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(10, 10), 0, -1));
data.push_back(Vertex45(Point(20, 10), 1, -1));
data.push_back(Vertex45(Point(20, 10), 0, 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1018,7 +1018,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(12, 8), 1, -1));
// result == 12 8 -1 1
data.push_back(Vertex45(Point(12, 8), -1, 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1051,7 +1051,7 @@ namespace boost { namespace polygon{
stdcout << "scanning\n";
scan45.scan(result, vertices.begin(), vertices.end());
std::sort(result.begin(), result.end());
gtlsort(result.begin(), result.end());
pf.scan(polys, result.begin(), result.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1123,7 +1123,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(8, 6), -1, -1));
data.push_back(Vertex45(Point(8, 6), 1, 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1195,7 +1195,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(10, 8), -1, -1));
data.push_back(Vertex45(Point(10, 8), 1, 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1239,7 +1239,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(10, 22), 2, -1));
data.push_back(Vertex45(Point(10, 22), 0, -1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1668,7 +1668,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(10, 0), 2, -1));
data.push_back(Vertex45(Point(10, 10), 2, 1));
data.push_back(Vertex45(Point(10, 10), 0, 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1692,7 +1692,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(10, 10), 2, -1));
data.push_back(Vertex45(Point(10, 20), 2, 1));
data.push_back(Vertex45(Point(10, 20), 1, 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1716,7 +1716,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(10, 10), 0, -1));
data.push_back(Vertex45(Point(20, 10), 1, -1));
data.push_back(Vertex45(Point(20, 10), 0, 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1742,7 +1742,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(10, 10), 0, 1));
data.push_back(Vertex45(Point(20, 20), 1, 1));
data.push_back(Vertex45(Point(20, 20), 2, 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1768,7 +1768,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(20, 10), 0, 1));
data.push_back(Vertex45(Point(20, -10), -1, -1));
data.push_back(Vertex45(Point(20, -10), 2, -1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1801,7 +1801,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(2, 2), 0, 1));
data.push_back(Vertex45(Point(3, 2), 1, 1));
data.push_back(Vertex45(Point(3, 2), 0, -1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1835,7 +1835,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(2, 2), 2, -1));
data.push_back(Vertex45(Point(2, 2), 0, -1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1899,7 +1899,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(12, 8), 1, -1));
// result == 12 8 -1 1
data.push_back(Vertex45(Point(12, 8), -1, 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1933,7 +1933,7 @@ namespace boost { namespace polygon{
stdcout << "scanning\n";
scan45.scan(result, vertices.begin(), vertices.end());
std::sort(result.begin(), result.end());
gtlsort(result.begin(), result.end());
pf.scan(polys, result.begin(), result.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -2005,7 +2005,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(8, 6), -1, -1));
data.push_back(Vertex45(Point(8, 6), 1, 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -2077,7 +2077,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(10, 8), -1, -1));
data.push_back(Vertex45(Point(10, 8), 1, 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -2121,7 +2121,7 @@ namespace boost { namespace polygon{
data.push_back(Vertex45(Point(10, 22), 2, -1));
data.push_back(Vertex45(Point(10, 22), 0, -1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {

2
include/boost/polygon/detail/polygon_45_set_view.hpp
View File

@ -119,7 +119,7 @@ namespace boost { namespace polygon{
// orient_ = orient;
// output_.clear();
// output_.insert(output_.end(), input_begin, input_end);
// std::sort(output_.begin(), output_.end());
// gtlsort(output_.begin(), output_.end());
// }
};

2
include/boost/polygon/detail/polygon_45_touch.hpp
View File

@ -186,7 +186,7 @@ namespace boost { namespace polygon{
template <typename graph_type>
static void performTouch(graph_type& graph, TouchSetData& tsd) {
std::sort(tsd.begin(), tsd.end(), lessVertex45Compact());
gtlsort(tsd.begin(), tsd.end(), lessVertex45Compact());
typedef std::vector<std::pair<Point, typename boolean_op_45<Unit>::template Scan45CountT<CountTouch> > > TSD;
TSD tsd_;
tsd_.reserve(tsd.size());

176
include/boost/polygon/detail/polygon_90_set_view.hpp
View File

@ -33,56 +33,91 @@ namespace boost { namespace polygon{
static inline bool sorted(const polygon_90_set_view<ltype, rtype, op_type>& polygon_set);
};
template <typename value_type, typename ltype, typename rtype, typename op_type>
struct compute_90_set_value {
static
void value(value_type& output_, const ltype& lvalue_, const rtype& rvalue_, orientation_2d orient_) {
value_type linput_(orient_);
value_type rinput_(orient_);
insert_into_view_arg(linput_, lvalue_, orient_);
insert_into_view_arg(rinput_, rvalue_, orient_);
output_.applyBooleanBinaryOp(linput_.begin(), linput_.end(),
rinput_.begin(), rinput_.end(), boolean_op::BinaryCount<op_type>());
}
};
template <typename value_type, typename ltype, typename rtype, typename op_type>
struct compute_90_set_value {
static
void value(value_type& output_, const ltype& lvalue_, const rtype& rvalue_, orientation_2d orient_) {
value_type linput_(orient_);
value_type rinput_(orient_);
orientation_2d orient_l = polygon_90_set_traits<ltype>::orient(lvalue_);
orientation_2d orient_r = polygon_90_set_traits<rtype>::orient(rvalue_);
//std::cout << "compute_90_set_value-0 orientations (left, right, out):\t" << orient_l.to_int()
// << "," << orient_r.to_int() << "," << orient_.to_int() << std::endl;
insert_into_view_arg(linput_, lvalue_, orient_l);
insert_into_view_arg(rinput_, rvalue_, orient_r);
output_.applyBooleanBinaryOp(linput_.begin(), linput_.end(),
rinput_.begin(), rinput_.end(), boolean_op::BinaryCount<op_type>());
}
};
template <typename value_type, typename lcoord, typename rcoord, typename op_type>
struct compute_90_set_value<value_type, polygon_90_set_data<lcoord>, polygon_90_set_data<rcoord>, op_type> {
static
void value(value_type& output_, const polygon_90_set_data<lcoord>& lvalue_,
const polygon_90_set_data<rcoord>& rvalue_, orientation_2d) {
lvalue_.sort();
rvalue_.sort();
output_.applyBooleanBinaryOp(lvalue_.begin(), lvalue_.end(),
rvalue_.begin(), rvalue_.end(), boolean_op::BinaryCount<op_type>());
}
};
template <typename value_type, typename lcoord, typename rcoord, typename op_type>
struct compute_90_set_value<value_type, polygon_90_set_data<lcoord>, polygon_90_set_data<rcoord>, op_type> {
static
void value(value_type& output_, const polygon_90_set_data<lcoord>& lvalue_,
const polygon_90_set_data<rcoord>& rvalue_, orientation_2d orient_) {
orientation_2d orient_l = lvalue_.orient();
orientation_2d orient_r = rvalue_.orient();
value_type linput_(orient_);
value_type rinput_(orient_);
//std::cout << "compute_90_set_value-1 orientations (left, right, out):\t" << orient_l.to_int()
// << "," << orient_r.to_int() << "," << orient_.to_int() << std::endl;
if((orient_ == orient_l) && (orient_== orient_r)){ // assume that most of the time this condition is met
lvalue_.sort();
rvalue_.sort();
output_.applyBooleanBinaryOp(lvalue_.begin(), lvalue_.end(),
rvalue_.begin(), rvalue_.end(), boolean_op::BinaryCount<op_type>());
}else if((orient_ != orient_l) && (orient_!= orient_r)){ // both the orientations are not equal to input
// easier way is to ignore the input orientation and use the input data's orientation, but not done so
insert_into_view_arg(linput_, lvalue_, orient_l);
insert_into_view_arg(rinput_, rvalue_, orient_r);
output_.applyBooleanBinaryOp(linput_.begin(), linput_.end(),
rinput_.begin(), rinput_.end(), boolean_op::BinaryCount<op_type>());
}else if(orient_ != orient_l){ // left hand side orientation is different
insert_into_view_arg(linput_, lvalue_, orient_l);
rvalue_.sort();
output_.applyBooleanBinaryOp(linput_.begin(), linput_.end(),
rvalue_.begin(), rvalue_.end(), boolean_op::BinaryCount<op_type>());
} else if(orient_ != orient_r){ // right hand side orientation is different
insert_into_view_arg(rinput_, rvalue_, orient_r);
lvalue_.sort();
output_.applyBooleanBinaryOp(lvalue_.begin(), lvalue_.end(),
rinput_.begin(), rinput_.end(), boolean_op::BinaryCount<op_type>());
}
}
};
template <typename value_type, typename lcoord, typename rtype, typename op_type>
struct compute_90_set_value<value_type, polygon_90_set_data<lcoord>, rtype, op_type> {
static
void value(value_type& output_, const polygon_90_set_data<lcoord>& lvalue_,
const rtype& rvalue_, orientation_2d orient_) {
value_type rinput_(orient_);
lvalue_.sort();
insert_into_view_arg(rinput_, rvalue_, orient_);
output_.applyBooleanBinaryOp(lvalue_.begin(), lvalue_.end(),
rinput_.begin(), rinput_.end(), boolean_op::BinaryCount<op_type>());
}
};
template <typename value_type, typename lcoord, typename rtype, typename op_type>
struct compute_90_set_value<value_type, polygon_90_set_data<lcoord>, rtype, op_type> {
static
void value(value_type& output_, const polygon_90_set_data<lcoord>& lvalue_,
const rtype& rvalue_, orientation_2d orient_) {
value_type rinput_(orient_);
lvalue_.sort();
orientation_2d orient_r = polygon_90_set_traits<rtype>::orient(rvalue_);
//std::cout << "compute_90_set_value-2 orientations (right, out):\t" << orient_r.to_int()
// << "," << orient_.to_int() << std::endl;
insert_into_view_arg(rinput_, rvalue_, orient_r);
output_.applyBooleanBinaryOp(lvalue_.begin(), lvalue_.end(),
rinput_.begin(), rinput_.end(), boolean_op::BinaryCount<op_type>());
}
};
template <typename value_type, typename ltype, typename rcoord, typename op_type>
struct compute_90_set_value<value_type, ltype, polygon_90_set_data<rcoord>, op_type> {
static
void value(value_type& output_, const ltype& lvalue_,
const polygon_90_set_data<rcoord>& rvalue_, orientation_2d orient_) {
value_type linput_(orient_);
insert_into_view_arg(linput_, lvalue_, orient_);
rvalue_.sort();
output_.applyBooleanBinaryOp(linput_.begin(), linput_.end(),
rvalue_.begin(), rvalue_.end(), boolean_op::BinaryCount<op_type>());
}
};
template <typename value_type, typename ltype, typename rcoord, typename op_type>
struct compute_90_set_value<value_type, ltype, polygon_90_set_data<rcoord>, op_type> {
static
void value(value_type& output_, const ltype& lvalue_,
const polygon_90_set_data<rcoord>& rvalue_, orientation_2d orient_) {
value_type linput_(orient_);
orientation_2d orient_l = polygon_90_set_traits<ltype>::orient(lvalue_);
insert_into_view_arg(linput_, lvalue_, orient_l);
rvalue_.sort();
//std::cout << "compute_90_set_value-3 orientations (left, out):\t" << orient_l.to_int()
// << "," << orient_.to_int() << std::endl;
output_.applyBooleanBinaryOp(linput_.begin(), linput_.end(),
rvalue_.begin(), rvalue_.end(), boolean_op::BinaryCount<op_type>());
}
};
template <typename ltype, typename rtype, typename op_type>
class polygon_90_set_view {
@ -129,7 +164,7 @@ namespace boost { namespace polygon{
// orient_ = orient;
// output_.clear();
// output_.insert(output_.end(), input_begin, input_end);
// std::sort(output_.begin(), output_.end());
// gtlsort(output_.begin(), output_.end());
// }
void sort() const {} //is always sorted
};
@ -206,23 +241,34 @@ namespace boost { namespace polygon{
typedef type_1 type;
};
template <typename geometry_type_1, typename geometry_type_2, typename op_type>
geometry_type_1& self_assignment_boolean_op(geometry_type_1& lvalue_, const geometry_type_2& rvalue_) {
typedef geometry_type_1 ltype;
typedef geometry_type_2 rtype;
typedef typename polygon_90_set_traits<ltype>::coordinate_type coordinate_type;
typedef polygon_90_set_data<coordinate_type> value_type;
orientation_2d orient_ = polygon_90_set_traits<ltype>::orient(lvalue_);
value_type linput_(orient_);
value_type rinput_(orient_);
value_type output_(orient_);
insert_into_view_arg(linput_, lvalue_, orient_);
insert_into_view_arg(rinput_, rvalue_, orient_);
output_.applyBooleanBinaryOp(linput_.begin(), linput_.end(),
rinput_.begin(), rinput_.end(), boolean_op::BinaryCount<op_type>());
polygon_90_set_mutable_traits<geometry_type_1>::set(lvalue_, output_.begin(), output_.end(), orient_);
return lvalue_;
}
template <typename geometry_type_1, typename geometry_type_2, typename op_type>
geometry_type_1& self_assignment_boolean_op(geometry_type_1& lvalue_, const geometry_type_2& rvalue_) {
typedef geometry_type_1 ltype;
typedef geometry_type_2 rtype;
typedef typename polygon_90_set_traits<ltype>::coordinate_type coordinate_type;
typedef polygon_90_set_data<coordinate_type> value_type;
orientation_2d orient_ = polygon_90_set_traits<ltype>::orient(lvalue_);
//BM: rvalue_ data set may have its own orientation for scanline
orientation_2d orient_r = polygon_90_set_traits<rtype>::orient(rvalue_);
//std::cout << "self-assignment boolean-op (left, right, out):\t" << orient_.to_int()
// << "," << orient_r.to_int() << "," << orient_.to_int() << std::endl;
value_type linput_(orient_);
// BM: the rinput_ set's (that stores the rvalue_ dataset polygons) scanline orientation is *forced*
// to be same as linput
value_type rinput_(orient_);
//BM: The output dataset's scanline orient is set as equal to first input dataset's (lvalue_) orientation
value_type output_(orient_);
insert_into_view_arg(linput_, lvalue_, orient_);
// BM: The last argument orient_r is the user initialized scanline orientation for rvalue_ data set.
// But since rinput (see above) is initialized to scanline orientation consistent with the lvalue_
// data set, this insertion operation will change the incoming rvalue_ dataset's scanline orientation
insert_into_view_arg(rinput_, rvalue_, orient_r);
// BM: boolean operation and output uses lvalue_ dataset's scanline orientation.
output_.applyBooleanBinaryOp(linput_.begin(), linput_.end(),
rinput_.begin(), rinput_.end(), boolean_op::BinaryCount<op_type>());
polygon_90_set_mutable_traits<geometry_type_1>::set(lvalue_, output_.begin(), output_.end(), orient_);
return lvalue_;
}
namespace operators {
struct y_ps90_b : gtl_yes {};

30
include/boost/polygon/detail/polygon_arbitrary_formation.hpp
View File

@ -1203,7 +1203,7 @@ namespace boost { namespace polygon{
static inline void sort_vertex_arbitrary_count(vertex_arbitrary_count& count, const Point& pt) {
less_half_edge_count lfec(pt);
std::sort(count.begin(), count.end(), lfec);
gtlsort(count.begin(), count.end(), lfec);
}
typedef std::vector<std::pair<std::pair<std::pair<Point, Point>, int>, active_tail_arbitrary*> > incoming_count;
@ -1227,7 +1227,7 @@ namespace boost { namespace polygon{
static inline void sort_incoming_count(incoming_count& count, const Point& pt) {
less_incoming_count lfec(pt);
std::sort(count.begin(), count.end(), lfec);
gtlsort(count.begin(), count.end(), lfec);
}
static inline void compact_vertex_arbitrary_count(const Point& pt, vertex_arbitrary_count &count) {
@ -1798,7 +1798,7 @@ namespace boost { namespace polygon{
data.push_back(vertex_half_edge(Point(10, 0), Point(10, 10), -1));
data.push_back(vertex_half_edge(Point(10, 10), Point(10, 0), 1));
data.push_back(vertex_half_edge(Point(10, 10), Point(0, 10), 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1822,7 +1822,7 @@ namespace boost { namespace polygon{
data.push_back(vertex_half_edge(Point(10, 10), Point(10, 20), -1));
data.push_back(vertex_half_edge(Point(10, 20), Point(10, 10), 1));
data.push_back(vertex_half_edge(Point(10, 20), Point(0, 10), 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1846,7 +1846,7 @@ namespace boost { namespace polygon{
data.push_back(vertex_half_edge(Point(2, -4), Point(2, 4), -1));
data.push_back(vertex_half_edge(Point(2, 4), Point(-2, 2), 1));
data.push_back(vertex_half_edge(Point(2, 4), Point(2, -4), 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1892,7 +1892,7 @@ namespace boost { namespace polygon{
data.push_back(vertex_half_edge(Point(10, 22), Point(10, 12), -1));
data.push_back(vertex_half_edge(Point(10, 22), Point(2, 22), -1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1939,7 +1939,7 @@ namespace boost { namespace polygon{
data.push_back(vertex_half_edge(Point(7, 2), Point(5, 5), -1));
data.push_back(vertex_half_edge(Point(7, 2), Point(5, 2), 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1979,7 +1979,7 @@ namespace boost { namespace polygon{
data.push_back(vertex_half_edge(Point(7, 2), Point(5, 5), -1));
data.push_back(vertex_half_edge(Point(7, 2), Point(4, 1), 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -2019,7 +2019,7 @@ namespace boost { namespace polygon{
data.push_back(vertex_half_edge(Point(7, 2), Point(5, 5), -1));
data.push_back(vertex_half_edge(Point(7, 2), Point(4, 1), 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -2047,7 +2047,7 @@ namespace boost { namespace polygon{
data.push_back(vertex_half_edge(Point(-1, 4), Point(0, 2), -1));
data.push_back(vertex_half_edge(Point(0, 2), Point(-1, 4), 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -2753,7 +2753,7 @@ namespace boost { namespace polygon{
data.push_back(vertex_half_edge(Point(10, 0), Point(10, 10), -1));
data.push_back(vertex_half_edge(Point(10, 10), Point(10, 0), 1));
data.push_back(vertex_half_edge(Point(10, 10), Point(0, 10), 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -2776,7 +2776,7 @@ namespace boost { namespace polygon{
data.push_back(vertex_half_edge(Point(10, 10), Point(10, 20), -1));
data.push_back(vertex_half_edge(Point(10, 20), Point(10, 10), 1));
data.push_back(vertex_half_edge(Point(10, 20), Point(0, 10), 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -2799,7 +2799,7 @@ namespace boost { namespace polygon{
data.push_back(vertex_half_edge(Point(2, -4), Point(2, 4), -1));
data.push_back(vertex_half_edge(Point(2, 4), Point(-2, 2), 1));
data.push_back(vertex_half_edge(Point(2, 4), Point(2, -4), 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -2844,7 +2844,7 @@ namespace boost { namespace polygon{
data.push_back(vertex_half_edge(Point(10, 22), Point(10, 12), -1));
data.push_back(vertex_half_edge(Point(10, 22), Point(2, 22), -1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {
@ -2891,7 +2891,7 @@ namespace boost { namespace polygon{
data.push_back(vertex_half_edge(Point(7, 2), Point(5, 5), -1));
data.push_back(vertex_half_edge(Point(7, 2), Point(5, 2), 1));
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) {

6
include/boost/polygon/detail/property_merge.hpp
View File

@ -112,7 +112,7 @@ public:
inline void perform_merge(result_type& result, property_merge_data& data) {
if(data.empty()) return;
//sort
std::sort(data.begin(), data.end(), less_vertex_data<vertex_property>());
gtlsort(data.begin(), data.end(), less_vertex_data<vertex_property>());
//scanline
bool firstIteration = true;
scanlinePosition = scanline.end();
@ -156,7 +156,7 @@ private:
class less_vertex_data {
public:
less_vertex_data() {}
bool operator()(const T& lvalue, const T& rvalue) {
bool operator()(const T& lvalue, const T& rvalue) const {
if(lvalue.first.x() < rvalue.first.x()) return true;
if(lvalue.first.x() > rvalue.first.x()) return false;
if(lvalue.first.y() < rvalue.first.y()) return true;
@ -442,7 +442,7 @@ private:
inline void performExtract(T& result, property_merge_data& data) {
if(data.empty()) return;
//sort
std::sort(data.begin(), data.end(), less_vertex_data<vertex_property>());
gtlsort(data.begin(), data.end(), less_vertex_data<vertex_property>());
//scanline
bool firstIteration = true;

2
include/boost/polygon/detail/property_merge_45.hpp
View File

@ -111,7 +111,7 @@ namespace boost { namespace polygon{
template <typename output_type>
static void performMerge(output_type& result, MergeSetData& tsd) {
std::sort(tsd.begin(), tsd.end(), lessVertex45Compact());
gtlsort(tsd.begin(), tsd.end(), lessVertex45Compact());
typedef std::vector<std::pair<Point, typename boolean_op_45<Unit>::template Scan45CountT<CountMerge> > > TSD;
TSD tsd_;
tsd_.reserve(tsd.size());

33
include/boost/polygon/detail/scan_arbitrary.hpp
View File

@ -10,6 +10,7 @@
#ifdef BOOST_POLYGON_DEBUG_FILE
#include <fstream>
#endif
#include "polygon_sort_adaptor.hpp"
namespace boost { namespace polygon{
template <typename Unit>
@ -75,7 +76,7 @@ namespace boost { namespace polygon{
ends.push_back(std::make_pair((*itr).first.first.y(), count));
ends.push_back(std::make_pair((*itr).first.second.y(), -count));
}
std::sort(ends.begin(), ends.end());
gtlsort(ends.begin(), ends.end());
histogram.reserve(ends.size());
histogram.push_back(std::make_pair(ends.front().first, std::make_pair(0, 0)));
for(typename std::vector<std::pair<Unit, int> >::iterator itr = ends.begin(); itr != ends.end(); ++itr) {
@ -160,7 +161,7 @@ namespace boost { namespace polygon{
}
}
typename scanline_base<Unit>::compute_intersection_pack pack_;
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
//find all intersection points
for(typename std::vector<std::pair<half_edge, segment_id> >::iterator outer = data.begin();
outer != data.end(); ++outer) {
@ -195,7 +196,7 @@ namespace boost { namespace polygon{
}
}
}
std::sort(pts.begin(), pts.end());
gtlsort(pts.begin(), pts.end());
typename std::vector<Point>::iterator newend = std::unique(pts.begin(), pts.end());
typename std::vector<Point>::iterator lfinger = pts.begin();
//find all segments that interact with intersection points
@ -286,7 +287,7 @@ namespace boost { namespace polygon{
std::swap(data[i].first.first, data[i].first.second);
}
}
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
for(typename std::vector<std::pair<half_edge, segment_id> >::iterator outer = data.begin();
outer != data.end(); ++outer) {
const half_edge& he1 = (*outer).first;
@ -356,7 +357,7 @@ namespace boost { namespace polygon{
tmpPts.reserve(pts.size());
tmpPts.insert(tmpPts.end(), pts.begin(), pts.end());
less_point_down_slope lpds;
std::sort(tmpPts.begin(), tmpPts.end(), lpds);
gtlsort(tmpPts.begin(), tmpPts.end(), lpds);
segment_edge(output_segments, he, id, tmpPts.begin(), tmpPts.end());
} else {
segment_edge(output_segments, he, id, pts.begin(), pts.end());
@ -498,7 +499,7 @@ namespace boost { namespace polygon{
// }
// //merge sloping element data
// std::sort(sloping_ends.begin(), sloping_ends.end());
// gtlsort(sloping_ends.begin(), sloping_ends.end());
// std::map<Unit, std::set<iterator> > sloping_elements;
// std::set<iterator> merge_elements;
// for(typename std::vector<std::pair<Unit, iterator> >::iterator slop_iter = sloping_ends.begin();
@ -1310,7 +1311,7 @@ namespace boost { namespace polygon{
output.push_back(vertex_half_edge(he.first, he.second, count));
output.push_back(vertex_half_edge(he.second, he.first, -count));
}
std::sort(output.begin(), output.end());
gtlsort(output.begin(), output.end());
}
class test_functor {
@ -1514,7 +1515,7 @@ namespace boost { namespace polygon{
public:
less_vertex_data() : pack_() {}
less_vertex_data(typename scanline_base<Unit>::evalAtXforYPack* pack) : pack_(pack) {}
bool operator()(const vertex_data_type& lvalue, const vertex_data_type& rvalue) {
bool operator() (const vertex_data_type& lvalue, const vertex_data_type& rvalue) const {
less_point lp;
if(lp(lvalue.first.first, rvalue.first.first)) return true;
if(lp(rvalue.first.first, lvalue.first.first)) return false;
@ -1528,7 +1529,7 @@ namespace boost { namespace polygon{
inline void sort_property_merge_data() {
less_vertex_data<vertex_property> lvd(&evalAtXforYPack_);
std::sort(pmd.begin(), pmd.end(), lvd);
gtlsort(pmd.begin(), pmd.end(), lvd);
}
public:
inline property_merge_data& get_property_merge_data() { return pmd; }
@ -1573,7 +1574,7 @@ namespace boost { namespace polygon{
pts.push_back(lines[i].first.first);
pts.push_back(lines[i].first.second);
}
std::sort(pts.begin(), pts.end());
gtlsort(pts.begin(), pts.end());
for(std::size_t i = 0; i < pts.size(); i+=2) {
if(pts[i] != pts[i+1]) {
//stdcout << "Non-closed figures after line intersection!\n";
@ -1683,7 +1684,7 @@ namespace boost { namespace polygon{
static inline void sort_vertex_half_edges(vertex_data& vertex) {
less_half_edge_pair lessF(vertex.first);
std::sort(vertex.second.begin(), vertex.second.end(), lessF);
gtlsort(vertex.second.begin(), vertex.second.end(), lessF);
}
class less_half_edge_pair {
@ -2165,7 +2166,7 @@ pts.push_back(Point(12344171, 6695983 )); pts.push_back(Point(12287208, 6672388
outpts.push_back((*itr).first.first);
outpts.push_back((*itr).first.second);
}
std::sort(outpts.begin(), outpts.end());
gtlsort(outpts.begin(), outpts.end());
for(std::size_t i = 0; i < outpts.size(); i+=2) {
if(outpts[i] != outpts[i+1]) {
stdcout << "Polygon set not a closed figure\n";
@ -2514,7 +2515,7 @@ pts.push_back(Point(12344171, 6695983 )); pts.push_back(Point(12287208, 6672388
public:
less_vertex_data() : pack_() {}
less_vertex_data(typename scanline_base<Unit>::evalAtXforYPack* pack) : pack_(pack) {}
bool operator()(const vertex_data_type& lvalue, const vertex_data_type& rvalue) {
bool operator()(const vertex_data_type& lvalue, const vertex_data_type& rvalue) const {
less_point lp;
if(lp(lvalue.first.first, rvalue.first.first)) return true;
if(lp(rvalue.first.first, lvalue.first.first)) return false;
@ -2580,7 +2581,7 @@ pts.push_back(Point(12344171, 6695983 )); pts.push_back(Point(12287208, 6672388
inline void sort_property_merge_data() {
less_vertex_data<vertex_property> lvd(&evalAtXforYPack_);
std::sort(pmd.begin(), pmd.end(), lvd);
gtlsort(pmd.begin(), pmd.end(), lvd);
}
public:
inline arbitrary_boolean_op() : pmd(), evalAtXforYPack_() {}
@ -2732,7 +2733,7 @@ pts.push_back(Point(12344171, 6695983 )); pts.push_back(Point(12287208, 6672388
public:
less_vertex_data() : pack_() {}
less_vertex_data(typename scanline_base<Unit>::evalAtXforYPack* pack) : pack_(pack) {}
bool operator()(const vertex_data_type& lvalue, const vertex_data_type& rvalue) {
bool operator()(const vertex_data_type& lvalue, const vertex_data_type& rvalue) const {
less_point lp;
if(lp(lvalue.first.first, rvalue.first.first)) return true;
if(lp(rvalue.first.first, lvalue.first.first)) return false;
@ -2804,7 +2805,7 @@ pts.push_back(Point(12344171, 6695983 )); pts.push_back(Point(12287208, 6672388
inline void sort_property_merge_data() {
less_vertex_data<vertex_property> lvd(&evalAtXforYPack_);
std::sort(pmd.begin(), pmd.end(), lvd);
gtlsort(pmd.begin(), pmd.end(), lvd);
}
public:
inline arbitrary_connectivity_extraction() : pmd(), evalAtXforYPack_() {}

2
include/boost/polygon/interval_concept.hpp
View File

@ -471,7 +471,7 @@ namespace boost { namespace polygon{
typedef typename interval_traits<interval_type>::coordinate_type Unit;
Unit coords[4] = {low(interval), high(interval), low(b), high(b)};
//consider implementing faster sorting of small fixed length range
std::sort(coords, coords+4);
gtlsort(coords, coords+4);
low(interval, coords[1]);
high(interval, coords[2]);
return interval;

1
include/boost/polygon/polygon.hpp
View File

@ -7,6 +7,7 @@
*/
#ifndef BOOST_POLYGON_POLYGON_HPP
#define BOOST_POLYGON_POLYGON_HPP
#define BOOST_POLYGON_VERSION 014401
#include "isotropy.hpp"

14
include/boost/polygon/polygon_45_set_data.hpp
View File

@ -212,7 +212,7 @@ namespace boost { namespace polygon{
void sort() const{
if(unsorted_) {
std::sort(data_.begin(), data_.end());
gtlsort(data_.begin(), data_.end());
unsorted_ = false;
}
}
@ -1262,7 +1262,7 @@ namespace boost { namespace polygon{
//std::cout << "SCAN " << currentX << "\n";
//scan event
scan45.scan(eventOut, eventIn.begin(), eventIn.end());
std::sort(eventOut.begin(), eventOut.end());
gtlsort(eventOut.begin(), eventOut.end());
std::size_t ptCount = 0;
for(std::size_t i = 0; i < eventOut.size(); ++i) {
if(!result_data.empty() &&
@ -1333,7 +1333,7 @@ namespace boost { namespace polygon{
}
}
scan45.scan(eventOut, eventIn.begin(), eventIn.end());
std::sort(eventOut.begin(), eventOut.end());
gtlsort(eventOut.begin(), eventOut.end());
std::size_t ptCount = 0;
for(std::size_t i = 0; i < eventOut.size(); ++i) {
@ -1385,7 +1385,7 @@ namespace boost { namespace polygon{
//std::cout << "SCAN " << currentX << "\n";
//scan event
scan45.scan(eventOut, eventIn.begin(), eventIn.end());
std::sort(eventOut.begin(), eventOut.end());
gtlsort(eventOut.begin(), eventOut.end());
std::size_t ptCount = 0;
for(std::size_t i = 0; i < eventOut.size(); ++i) {
if(!result_data.empty() &&
@ -1422,7 +1422,7 @@ namespace boost { namespace polygon{
++iter1;
}
scan45.scan(eventOut, eventIn.begin(), eventIn.end());
std::sort(eventOut.begin(), eventOut.end());
gtlsort(eventOut.begin(), eventOut.end());
std::size_t ptCount = 0;
for(std::size_t i = 0; i < eventOut.size(); ++i) {
@ -1639,7 +1639,7 @@ namespace boost { namespace polygon{
result.error_data_.push_back(ci);
}
Data2 new_result_data;
std::sort(result_data.begin(), result_data.end());
gtlsort(result_data.begin(), result_data.end());
applyUnary45OpOnVectors<Unit2, 0>(new_result_data, result_data); //OR operation
result_data.swap(new_result_data);
}
@ -1749,7 +1749,7 @@ namespace boost { namespace polygon{
result.error_data_.push_back(ci);
}
Data2 new_result_data;
std::sort(result_data.begin(), result_data.end());
gtlsort(result_data.begin(), result_data.end());
applyUnary45OpOnVectors<Unit2, 0>(new_result_data, result_data); //OR operation
result_data.swap(new_result_data);
}

2
include/boost/polygon/polygon_90_set_data.hpp
View File

@ -286,7 +286,7 @@ namespace boost { namespace polygon{
void sort() const{
if(unsorted_) {
std::sort(data_.begin(), data_.end());
gtlsort(data_.begin(), data_.end());
unsorted_ = false;
}
}

8
include/boost/polygon/polygon_set_data.hpp
View File

@ -248,7 +248,7 @@ namespace boost { namespace polygon {
data.push_back(vertex_half_edge((*itr).first.first, (*itr).first.second, (*itr).second));
data.push_back(vertex_half_edge((*itr).first.second, (*itr).first.first, -1 * (*itr).second));
}
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(container, data.begin(), data.end());
//std::cout << "DONE FORMING POLYGONS\n";
}
@ -321,7 +321,7 @@ namespace boost { namespace polygon {
void sort() const{
if(unsorted_) {
std::sort(data_.begin(), data_.end());
gtlsort(data_.begin(), data_.end());
unsorted_ = false;
}
}
@ -364,7 +364,7 @@ namespace boost { namespace polygon {
if(resizing < 0)
return shrink(-resizing);
if(resizing > 0)
return bloat(-resizing);
return bloat(resizing);
return *this;
}
if(resizing == 0) return *this;
@ -791,7 +791,7 @@ namespace boost { namespace polygon {
data.push_back(vertex_half_edge((*itr).first.first, (*itr).first.second, (*itr).second));
data.push_back(vertex_half_edge((*itr).first.second, (*itr).first.first, -1 * (*itr).second));
}
std::sort(data.begin(), data.end());
gtlsort(data.begin(), data.end());
pf.scan(container, data.begin(), data.end());
}
};