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 Please add newer entries at the top, list the date and your name with
email address. 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> 2010-Oct-20 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================ ================================================================================
++richio: ++richio:

18
eeschema/hotkeys.cpp
View File

@ -111,7 +111,7 @@ static Ki_HotkeyInfo HkMirrorXComponent( wxT( "Mirror X Component" ),
HK_MIRROR_X_COMPONENT, 'X' ); HK_MIRROR_X_COMPONENT, 'X' );
static Ki_HotkeyInfo HkOrientNormalComponent( wxT( "Orient Normal Component" ), static Ki_HotkeyInfo HkOrientNormalComponent( wxT( "Orient Normal Component" ),
HK_ORIENT_NORMAL_COMPONENT, 'N' ); HK_ORIENT_NORMAL_COMPONENT, 'N' );
static Ki_HotkeyInfo HkRotate( wxT( "Rotate Schematic Item" ), static Ki_HotkeyInfo HkRotate( wxT( "Rotate Item" ),
HK_ROTATE, 'R' ); HK_ROTATE, 'R' );
static Ki_HotkeyInfo HkEdit( wxT( "Edit Schematic Item" ), static Ki_HotkeyInfo HkEdit( wxT( "Edit Schematic Item" ),
HK_EDIT, 'E' ); HK_EDIT, 'E' );
@ -120,7 +120,7 @@ static Ki_HotkeyInfo HkEditComponentValue( wxT( "Edit Component Value" ),
static Ki_HotkeyInfo HkEditComponentFootprint( wxT( "Edit Component Footprint" ), static Ki_HotkeyInfo HkEditComponentFootprint( wxT( "Edit Component Footprint" ),
HK_EDIT_COMPONENT_FOOTPRINT, HK_EDIT_COMPONENT_FOOTPRINT,
'F' ); 'F' );
static Ki_HotkeyInfo HkMove( wxT( "Move Schematic Item" ), static Ki_HotkeyInfo HkMove( wxT( "Move Item" ),
HK_MOVE_COMPONENT_OR_ITEM, 'M', HK_MOVE_COMPONENT_OR_ITEM, 'M',
ID_POPUP_SCH_MOVE_CMP_REQUEST ); 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: // Special keys for library editor:
static Ki_HotkeyInfo HkCreatePin( wxT( "Create Pin" ), HK_LIBEDIT_CREATE_PIN, 'P' ); 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 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 // List of common hotkey descriptors
@ -193,7 +193,7 @@ Ki_HotkeyInfo* s_LibEdit_Hotkey_List[] =
&HkCreatePin, &HkCreatePin,
&HkInsertPin, &HkInsertPin,
&HkEdit, &HkEdit,
&HkMovePin, &HkMoveLibItem,
&HkDelete, &HkDelete,
&HkRotate, &HkRotate,
&HkDrag, &HkDrag,
@ -816,6 +816,11 @@ void WinEDA_LibeditFrame::OnHotKey( wxDC* DC, int hotkey, EDA_BaseStruct* DrawSt
GetEventHandler()->ProcessEvent( cmd ); GetEventHandler()->ProcessEvent( cmd );
break; break;
case COMPONENT_FIELD_DRAW_TYPE:
cmd.SetId( ID_POPUP_LIBEDIT_FIELD_EDIT_ITEM );
GetEventHandler()->ProcessEvent( cmd );
break;
default: default:
break; break;
} }
@ -839,6 +844,11 @@ void WinEDA_LibeditFrame::OnHotKey( wxDC* DC, int hotkey, EDA_BaseStruct* DrawSt
GetEventHandler()->ProcessEvent( cmd ); GetEventHandler()->ProcessEvent( cmd );
break; break;
case COMPONENT_FIELD_DRAW_TYPE:
cmd.SetId( ID_POPUP_LIBEDIT_FIELD_ROTATE_ITEM );
GetEventHandler()->ProcessEvent( cmd );
break;
default: default:
break; 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, ADD_MENUITEM( PopMenu, ID_POPUP_LIBEDIT_MOVE_ITEM_REQUEST,
msg, move_field_xpm ); msg, move_field_xpm );
} }
msg = AddHotkeyName( _( "Field Rotate" ), s_Libedit_Hokeys_Descr,
HK_ROTATE );
ADD_MENUITEM( PopMenu, ID_POPUP_LIBEDIT_FIELD_ROTATE_ITEM, 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, ADD_MENUITEM( PopMenu, ID_POPUP_LIBEDIT_FIELD_EDIT_ITEM,
_( "Field Edit" ), edit_text_xpm ); msg, edit_text_xpm );
break; break;

11
eeschema/pinedit.cpp
View File

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

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

@ -445,7 +445,7 @@ namespace boost { namespace polygon{
}; };
template <typename S45V> template <typename S45V>
static inline void sortScan45Vector(S45V& vec) { 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> 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); Interval rectIvl = nodep->rect.get(orient);
leadingEdges.push_back(EdgeAssociation(std::pair<Unit, Interval>(leading, rectIvl), nodep)); 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(); typename std::vector<EdgeAssociation>::iterator leadingBegin = leadingEdges.begin();
iT trailingBegin = beginNode; iT trailingBegin = beginNode;
while(leadingBegin != leadingEdges.end()) { 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, 0), 2, -1));
data.push_back(Vertex45(Point(10, 10), 2, 1)); data.push_back(Vertex45(Point(10, 10), 2, 1));
data.push_back(Vertex45(Point(10, 10), 0, 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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, 10), 2, -1));
data.push_back(Vertex45(Point(10, 20), 2, 1)); data.push_back(Vertex45(Point(10, 20), 2, 1));
data.push_back(Vertex45(Point(10, 20), 1, 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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(10, 10), 0, -1));
data.push_back(Vertex45(Point(20, 10), 1, -1)); data.push_back(Vertex45(Point(20, 10), 1, -1));
data.push_back(Vertex45(Point(20, 10), 0, 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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)); data.push_back(Vertex45(Point(12, 8), 1, -1));
// result == 12 8 -1 1 // result == 12 8 -1 1
data.push_back(Vertex45(Point(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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1051,7 +1051,7 @@ namespace boost { namespace polygon{
stdcout << "scanning\n"; stdcout << "scanning\n";
scan45.scan(result, vertices.begin(), vertices.end()); 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()); pf.scan(polys, result.begin(), result.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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));
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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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));
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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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), 2, -1));
data.push_back(Vertex45(Point(10, 22), 0, -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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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, 0), 2, -1));
data.push_back(Vertex45(Point(10, 10), 2, 1)); data.push_back(Vertex45(Point(10, 10), 2, 1));
data.push_back(Vertex45(Point(10, 10), 0, 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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, 10), 2, -1));
data.push_back(Vertex45(Point(10, 20), 2, 1)); data.push_back(Vertex45(Point(10, 20), 2, 1));
data.push_back(Vertex45(Point(10, 20), 1, 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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(10, 10), 0, -1));
data.push_back(Vertex45(Point(20, 10), 1, -1)); data.push_back(Vertex45(Point(20, 10), 1, -1));
data.push_back(Vertex45(Point(20, 10), 0, 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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(10, 10), 0, 1));
data.push_back(Vertex45(Point(20, 20), 1, 1)); data.push_back(Vertex45(Point(20, 20), 1, 1));
data.push_back(Vertex45(Point(20, 20), 2, 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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), 0, 1));
data.push_back(Vertex45(Point(20, -10), -1, -1)); data.push_back(Vertex45(Point(20, -10), -1, -1));
data.push_back(Vertex45(Point(20, -10), 2, -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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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(2, 2), 0, 1));
data.push_back(Vertex45(Point(3, 2), 1, 1)); data.push_back(Vertex45(Point(3, 2), 1, 1));
data.push_back(Vertex45(Point(3, 2), 0, -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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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), 2, -1));
data.push_back(Vertex45(Point(2, 2), 0, -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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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)); data.push_back(Vertex45(Point(12, 8), 1, -1));
// result == 12 8 -1 1 // result == 12 8 -1 1
data.push_back(Vertex45(Point(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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { for(std::size_t i = 0; i < polys.size(); ++i) {
@ -1933,7 +1933,7 @@ namespace boost { namespace polygon{
stdcout << "scanning\n"; stdcout << "scanning\n";
scan45.scan(result, vertices.begin(), vertices.end()); 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()); pf.scan(polys, result.begin(), result.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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));
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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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));
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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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), 2, -1));
data.push_back(Vertex45(Point(10, 22), 0, -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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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; // orient_ = orient;
// output_.clear(); // output_.clear();
// output_.insert(output_.end(), input_begin, input_end); // 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> template <typename graph_type>
static void performTouch(graph_type& graph, TouchSetData& tsd) { 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; typedef std::vector<std::pair<Point, typename boolean_op_45<Unit>::template Scan45CountT<CountTouch> > > TSD;
TSD tsd_; TSD tsd_;
tsd_.reserve(tsd.size()); 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); 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> template <typename value_type, typename ltype, typename rtype, typename op_type>
struct compute_90_set_value { struct compute_90_set_value {
static static
void value(value_type& output_, const ltype& lvalue_, const rtype& rvalue_, orientation_2d orient_) { void value(value_type& output_, const ltype& lvalue_, const rtype& rvalue_, orientation_2d orient_) {
value_type linput_(orient_); value_type linput_(orient_);
value_type rinput_(orient_); value_type rinput_(orient_);
insert_into_view_arg(linput_, lvalue_, orient_); orientation_2d orient_l = polygon_90_set_traits<ltype>::orient(lvalue_);
insert_into_view_arg(rinput_, rvalue_, orient_); orientation_2d orient_r = polygon_90_set_traits<rtype>::orient(rvalue_);
output_.applyBooleanBinaryOp(linput_.begin(), linput_.end(), //std::cout << "compute_90_set_value-0 orientations (left, right, out):\t" << orient_l.to_int()
rinput_.begin(), rinput_.end(), boolean_op::BinaryCount<op_type>()); // << "," << 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> 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> { struct compute_90_set_value<value_type, polygon_90_set_data<lcoord>, polygon_90_set_data<rcoord>, op_type> {
static static
void value(value_type& output_, const polygon_90_set_data<lcoord>& lvalue_, void value(value_type& output_, const polygon_90_set_data<lcoord>& lvalue_,
const polygon_90_set_data<rcoord>& rvalue_, orientation_2d) { const polygon_90_set_data<rcoord>& rvalue_, orientation_2d orient_) {
lvalue_.sort(); orientation_2d orient_l = lvalue_.orient();
rvalue_.sort(); orientation_2d orient_r = rvalue_.orient();
output_.applyBooleanBinaryOp(lvalue_.begin(), lvalue_.end(), value_type linput_(orient_);
rvalue_.begin(), rvalue_.end(), boolean_op::BinaryCount<op_type>()); 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> 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> { struct compute_90_set_value<value_type, polygon_90_set_data<lcoord>, rtype, op_type> {
static static
void value(value_type& output_, const polygon_90_set_data<lcoord>& lvalue_, void value(value_type& output_, const polygon_90_set_data<lcoord>& lvalue_,
const rtype& rvalue_, orientation_2d orient_) { const rtype& rvalue_, orientation_2d orient_) {
value_type rinput_(orient_); value_type rinput_(orient_);
lvalue_.sort(); lvalue_.sort();
insert_into_view_arg(rinput_, rvalue_, orient_); orientation_2d orient_r = polygon_90_set_traits<rtype>::orient(rvalue_);
output_.applyBooleanBinaryOp(lvalue_.begin(), lvalue_.end(), //std::cout << "compute_90_set_value-2 orientations (right, out):\t" << orient_r.to_int()
rinput_.begin(), rinput_.end(), boolean_op::BinaryCount<op_type>()); // << "," << 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> 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> { struct compute_90_set_value<value_type, ltype, polygon_90_set_data<rcoord>, op_type> {
static static
void value(value_type& output_, const ltype& lvalue_, void value(value_type& output_, const ltype& lvalue_,
const polygon_90_set_data<rcoord>& rvalue_, orientation_2d orient_) { const polygon_90_set_data<rcoord>& rvalue_, orientation_2d orient_) {
value_type linput_(orient_); value_type linput_(orient_);
insert_into_view_arg(linput_, lvalue_, orient_); orientation_2d orient_l = polygon_90_set_traits<ltype>::orient(lvalue_);
rvalue_.sort(); insert_into_view_arg(linput_, lvalue_, orient_l);
output_.applyBooleanBinaryOp(linput_.begin(), linput_.end(), rvalue_.sort();
rvalue_.begin(), rvalue_.end(), boolean_op::BinaryCount<op_type>()); //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> template <typename ltype, typename rtype, typename op_type>
class polygon_90_set_view { class polygon_90_set_view {
@ -129,7 +164,7 @@ namespace boost { namespace polygon{
// orient_ = orient; // orient_ = orient;
// output_.clear(); // output_.clear();
// output_.insert(output_.end(), input_begin, input_end); // 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 void sort() const {} //is always sorted
}; };
@ -206,23 +241,34 @@ namespace boost { namespace polygon{
typedef type_1 type; typedef type_1 type;
}; };
template <typename geometry_type_1, typename geometry_type_2, typename op_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_) { geometry_type_1& self_assignment_boolean_op(geometry_type_1& lvalue_, const geometry_type_2& rvalue_) {
typedef geometry_type_1 ltype; typedef geometry_type_1 ltype;
typedef geometry_type_2 rtype; typedef geometry_type_2 rtype;
typedef typename polygon_90_set_traits<ltype>::coordinate_type coordinate_type; typedef typename polygon_90_set_traits<ltype>::coordinate_type coordinate_type;
typedef polygon_90_set_data<coordinate_type> value_type; typedef polygon_90_set_data<coordinate_type> value_type;
orientation_2d orient_ = polygon_90_set_traits<ltype>::orient(lvalue_); orientation_2d orient_ = polygon_90_set_traits<ltype>::orient(lvalue_);
value_type linput_(orient_); //BM: rvalue_ data set may have its own orientation for scanline
value_type rinput_(orient_); orientation_2d orient_r = polygon_90_set_traits<rtype>::orient(rvalue_);
value_type output_(orient_); //std::cout << "self-assignment boolean-op (left, right, out):\t" << orient_.to_int()
insert_into_view_arg(linput_, lvalue_, orient_); // << "," << orient_r.to_int() << "," << orient_.to_int() << std::endl;
insert_into_view_arg(rinput_, rvalue_, orient_); value_type linput_(orient_);
output_.applyBooleanBinaryOp(linput_.begin(), linput_.end(), // BM: the rinput_ set's (that stores the rvalue_ dataset polygons) scanline orientation is *forced*
rinput_.begin(), rinput_.end(), boolean_op::BinaryCount<op_type>()); // to be same as linput
polygon_90_set_mutable_traits<geometry_type_1>::set(lvalue_, output_.begin(), output_.end(), orient_); value_type rinput_(orient_);
return lvalue_; //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 { namespace operators {
struct y_ps90_b : gtl_yes {}; 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) { static inline void sort_vertex_arbitrary_count(vertex_arbitrary_count& count, const Point& pt) {
less_half_edge_count lfec(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; 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) { static inline void sort_incoming_count(incoming_count& count, const Point& pt) {
less_incoming_count lfec(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) { 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, 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(10, 0), 1));
data.push_back(vertex_half_edge(Point(10, 10), Point(0, 10), 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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, 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(10, 10), 1));
data.push_back(vertex_half_edge(Point(10, 20), Point(0, 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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, 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, 2), 1));
data.push_back(vertex_half_edge(Point(2, 4), Point(2, -4), 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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(10, 12), -1));
data.push_back(vertex_half_edge(Point(10, 22), Point(2, 22), -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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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, 5), -1));
data.push_back(vertex_half_edge(Point(7, 2), Point(5, 2), 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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(5, 5), -1));
data.push_back(vertex_half_edge(Point(7, 2), Point(4, 1), 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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(5, 5), -1));
data.push_back(vertex_half_edge(Point(7, 2), Point(4, 1), 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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(-1, 4), Point(0, 2), -1));
data.push_back(vertex_half_edge(Point(0, 2), Point(-1, 4), 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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, 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(10, 0), 1));
data.push_back(vertex_half_edge(Point(10, 10), Point(0, 10), 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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, 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(10, 10), 1));
data.push_back(vertex_half_edge(Point(10, 20), Point(0, 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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, 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, 2), 1));
data.push_back(vertex_half_edge(Point(2, 4), Point(2, -4), 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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(10, 12), -1));
data.push_back(vertex_half_edge(Point(10, 22), Point(2, 22), -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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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, 5), -1));
data.push_back(vertex_half_edge(Point(7, 2), Point(5, 2), 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()); pf.scan(polys, data.begin(), data.end());
stdcout << "result size: " << polys.size() << std::endl; stdcout << "result size: " << polys.size() << std::endl;
for(std::size_t i = 0; i < polys.size(); ++i) { 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) { inline void perform_merge(result_type& result, property_merge_data& data) {
if(data.empty()) return; if(data.empty()) return;
//sort //sort
std::sort(data.begin(), data.end(), less_vertex_data<vertex_property>()); gtlsort(data.begin(), data.end(), less_vertex_data<vertex_property>());
//scanline //scanline
bool firstIteration = true; bool firstIteration = true;
scanlinePosition = scanline.end(); scanlinePosition = scanline.end();
@ -156,7 +156,7 @@ private:
class less_vertex_data { class less_vertex_data {
public: public:
less_vertex_data() {} 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 true;
if(lvalue.first.x() > rvalue.first.x()) return false; if(lvalue.first.x() > rvalue.first.x()) return false;
if(lvalue.first.y() < rvalue.first.y()) return true; if(lvalue.first.y() < rvalue.first.y()) return true;
@ -442,7 +442,7 @@ private:
inline void performExtract(T& result, property_merge_data& data) { inline void performExtract(T& result, property_merge_data& data) {
if(data.empty()) return; if(data.empty()) return;
//sort //sort
std::sort(data.begin(), data.end(), less_vertex_data<vertex_property>()); gtlsort(data.begin(), data.end(), less_vertex_data<vertex_property>());
//scanline //scanline
bool firstIteration = true; 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> template <typename output_type>
static void performMerge(output_type& result, MergeSetData& tsd) { 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; typedef std::vector<std::pair<Point, typename boolean_op_45<Unit>::template Scan45CountT<CountMerge> > > TSD;
TSD tsd_; TSD tsd_;
tsd_.reserve(tsd.size()); tsd_.reserve(tsd.size());

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

@ -10,6 +10,7 @@
#ifdef BOOST_POLYGON_DEBUG_FILE #ifdef BOOST_POLYGON_DEBUG_FILE
#include <fstream> #include <fstream>
#endif #endif
#include "polygon_sort_adaptor.hpp"
namespace boost { namespace polygon{ namespace boost { namespace polygon{
template <typename Unit> 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.first.y(), count));
ends.push_back(std::make_pair((*itr).first.second.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.reserve(ends.size());
histogram.push_back(std::make_pair(ends.front().first, std::make_pair(0, 0))); 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) { 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_; typename scanline_base<Unit>::compute_intersection_pack pack_;
std::sort(data.begin(), data.end()); gtlsort(data.begin(), data.end());
//find all intersection points //find all intersection points
for(typename std::vector<std::pair<half_edge, segment_id> >::iterator outer = data.begin(); for(typename std::vector<std::pair<half_edge, segment_id> >::iterator outer = data.begin();
outer != data.end(); ++outer) { 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 newend = std::unique(pts.begin(), pts.end());
typename std::vector<Point>::iterator lfinger = pts.begin(); typename std::vector<Point>::iterator lfinger = pts.begin();
//find all segments that interact with intersection points //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::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(); for(typename std::vector<std::pair<half_edge, segment_id> >::iterator outer = data.begin();
outer != data.end(); ++outer) { outer != data.end(); ++outer) {
const half_edge& he1 = (*outer).first; const half_edge& he1 = (*outer).first;
@ -356,7 +357,7 @@ namespace boost { namespace polygon{
tmpPts.reserve(pts.size()); tmpPts.reserve(pts.size());
tmpPts.insert(tmpPts.end(), pts.begin(), pts.end()); tmpPts.insert(tmpPts.end(), pts.begin(), pts.end());
less_point_down_slope lpds; 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()); segment_edge(output_segments, he, id, tmpPts.begin(), tmpPts.end());
} else { } else {
segment_edge(output_segments, he, id, pts.begin(), pts.end()); segment_edge(output_segments, he, id, pts.begin(), pts.end());
@ -498,7 +499,7 @@ namespace boost { namespace polygon{
// } // }
// //merge sloping element data // //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::map<Unit, std::set<iterator> > sloping_elements;
// std::set<iterator> merge_elements; // std::set<iterator> merge_elements;
// for(typename std::vector<std::pair<Unit, iterator> >::iterator slop_iter = sloping_ends.begin(); // 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.first, he.second, count));
output.push_back(vertex_half_edge(he.second, he.first, -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 { class test_functor {
@ -1514,7 +1515,7 @@ namespace boost { namespace polygon{
public: public:
less_vertex_data() : pack_() {} less_vertex_data() : pack_() {}
less_vertex_data(typename scanline_base<Unit>::evalAtXforYPack* pack) : pack_(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; less_point lp;
if(lp(lvalue.first.first, rvalue.first.first)) return true; if(lp(lvalue.first.first, rvalue.first.first)) return true;
if(lp(rvalue.first.first, lvalue.first.first)) return false; if(lp(rvalue.first.first, lvalue.first.first)) return false;
@ -1528,7 +1529,7 @@ namespace boost { namespace polygon{
inline void sort_property_merge_data() { inline void sort_property_merge_data() {
less_vertex_data<vertex_property> lvd(&evalAtXforYPack_); less_vertex_data<vertex_property> lvd(&evalAtXforYPack_);
std::sort(pmd.begin(), pmd.end(), lvd); gtlsort(pmd.begin(), pmd.end(), lvd);
} }
public: public:
inline property_merge_data& get_property_merge_data() { return pmd; } 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.first);
pts.push_back(lines[i].first.second); 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) { for(std::size_t i = 0; i < pts.size(); i+=2) {
if(pts[i] != pts[i+1]) { if(pts[i] != pts[i+1]) {
//stdcout << "Non-closed figures after line intersection!\n"; //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) { static inline void sort_vertex_half_edges(vertex_data& vertex) {
less_half_edge_pair lessF(vertex.first); 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 { 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.first);
outpts.push_back((*itr).first.second); 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) { for(std::size_t i = 0; i < outpts.size(); i+=2) {
if(outpts[i] != outpts[i+1]) { if(outpts[i] != outpts[i+1]) {
stdcout << "Polygon set not a closed figure\n"; 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: public:
less_vertex_data() : pack_() {} less_vertex_data() : pack_() {}
less_vertex_data(typename scanline_base<Unit>::evalAtXforYPack* pack) : pack_(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; less_point lp;
if(lp(lvalue.first.first, rvalue.first.first)) return true; if(lp(lvalue.first.first, rvalue.first.first)) return true;
if(lp(rvalue.first.first, lvalue.first.first)) return false; 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() { inline void sort_property_merge_data() {
less_vertex_data<vertex_property> lvd(&evalAtXforYPack_); less_vertex_data<vertex_property> lvd(&evalAtXforYPack_);
std::sort(pmd.begin(), pmd.end(), lvd); gtlsort(pmd.begin(), pmd.end(), lvd);
} }
public: public:
inline arbitrary_boolean_op() : pmd(), evalAtXforYPack_() {} inline arbitrary_boolean_op() : pmd(), evalAtXforYPack_() {}
@ -2732,7 +2733,7 @@ pts.push_back(Point(12344171, 6695983 )); pts.push_back(Point(12287208, 6672388
public: public:
less_vertex_data() : pack_() {} less_vertex_data() : pack_() {}
less_vertex_data(typename scanline_base<Unit>::evalAtXforYPack* pack) : pack_(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; less_point lp;
if(lp(lvalue.first.first, rvalue.first.first)) return true; if(lp(lvalue.first.first, rvalue.first.first)) return true;
if(lp(rvalue.first.first, lvalue.first.first)) return false; 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() { inline void sort_property_merge_data() {
less_vertex_data<vertex_property> lvd(&evalAtXforYPack_); less_vertex_data<vertex_property> lvd(&evalAtXforYPack_);
std::sort(pmd.begin(), pmd.end(), lvd); gtlsort(pmd.begin(), pmd.end(), lvd);
} }
public: public:
inline arbitrary_connectivity_extraction() : pmd(), evalAtXforYPack_() {} 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; typedef typename interval_traits<interval_type>::coordinate_type Unit;
Unit coords[4] = {low(interval), high(interval), low(b), high(b)}; Unit coords[4] = {low(interval), high(interval), low(b), high(b)};
//consider implementing faster sorting of small fixed length range //consider implementing faster sorting of small fixed length range
std::sort(coords, coords+4); gtlsort(coords, coords+4);
low(interval, coords[1]); low(interval, coords[1]);
high(interval, coords[2]); high(interval, coords[2]);
return interval; return interval;

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

@ -7,6 +7,7 @@
*/ */
#ifndef BOOST_POLYGON_POLYGON_HPP #ifndef BOOST_POLYGON_POLYGON_HPP
#define BOOST_POLYGON_POLYGON_HPP #define BOOST_POLYGON_POLYGON_HPP
#define BOOST_POLYGON_VERSION 014401
#include "isotropy.hpp" #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{ void sort() const{
if(unsorted_) { if(unsorted_) {
std::sort(data_.begin(), data_.end()); gtlsort(data_.begin(), data_.end());
unsorted_ = false; unsorted_ = false;
} }
} }
@ -1262,7 +1262,7 @@ namespace boost { namespace polygon{
//std::cout << "SCAN " << currentX << "\n"; //std::cout << "SCAN " << currentX << "\n";
//scan event //scan event
scan45.scan(eventOut, eventIn.begin(), eventIn.end()); scan45.scan(eventOut, eventIn.begin(), eventIn.end());
std::sort(eventOut.begin(), eventOut.end()); gtlsort(eventOut.begin(), eventOut.end());
std::size_t ptCount = 0; std::size_t ptCount = 0;
for(std::size_t i = 0; i < eventOut.size(); ++i) { for(std::size_t i = 0; i < eventOut.size(); ++i) {
if(!result_data.empty() && if(!result_data.empty() &&
@ -1333,7 +1333,7 @@ namespace boost { namespace polygon{
} }
} }
scan45.scan(eventOut, eventIn.begin(), eventIn.end()); scan45.scan(eventOut, eventIn.begin(), eventIn.end());
std::sort(eventOut.begin(), eventOut.end()); gtlsort(eventOut.begin(), eventOut.end());
std::size_t ptCount = 0; std::size_t ptCount = 0;
for(std::size_t i = 0; i < eventOut.size(); ++i) { for(std::size_t i = 0; i < eventOut.size(); ++i) {
@ -1385,7 +1385,7 @@ namespace boost { namespace polygon{
//std::cout << "SCAN " << currentX << "\n"; //std::cout << "SCAN " << currentX << "\n";
//scan event //scan event
scan45.scan(eventOut, eventIn.begin(), eventIn.end()); scan45.scan(eventOut, eventIn.begin(), eventIn.end());
std::sort(eventOut.begin(), eventOut.end()); gtlsort(eventOut.begin(), eventOut.end());
std::size_t ptCount = 0; std::size_t ptCount = 0;
for(std::size_t i = 0; i < eventOut.size(); ++i) { for(std::size_t i = 0; i < eventOut.size(); ++i) {
if(!result_data.empty() && if(!result_data.empty() &&
@ -1422,7 +1422,7 @@ namespace boost { namespace polygon{
++iter1; ++iter1;
} }
scan45.scan(eventOut, eventIn.begin(), eventIn.end()); scan45.scan(eventOut, eventIn.begin(), eventIn.end());
std::sort(eventOut.begin(), eventOut.end()); gtlsort(eventOut.begin(), eventOut.end());
std::size_t ptCount = 0; std::size_t ptCount = 0;
for(std::size_t i = 0; i < eventOut.size(); ++i) { for(std::size_t i = 0; i < eventOut.size(); ++i) {
@ -1639,7 +1639,7 @@ namespace boost { namespace polygon{
result.error_data_.push_back(ci); result.error_data_.push_back(ci);
} }
Data2 new_result_data; 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 applyUnary45OpOnVectors<Unit2, 0>(new_result_data, result_data); //OR operation
result_data.swap(new_result_data); result_data.swap(new_result_data);
} }
@ -1749,7 +1749,7 @@ namespace boost { namespace polygon{
result.error_data_.push_back(ci); result.error_data_.push_back(ci);
} }
Data2 new_result_data; 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 applyUnary45OpOnVectors<Unit2, 0>(new_result_data, result_data); //OR operation
result_data.swap(new_result_data); 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{ void sort() const{
if(unsorted_) { if(unsorted_) {
std::sort(data_.begin(), data_.end()); gtlsort(data_.begin(), data_.end());
unsorted_ = false; 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.first, (*itr).first.second, (*itr).second));
data.push_back(vertex_half_edge((*itr).first.second, (*itr).first.first, -1 * (*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()); pf.scan(container, data.begin(), data.end());
//std::cout << "DONE FORMING POLYGONS\n"; //std::cout << "DONE FORMING POLYGONS\n";
} }
@ -321,7 +321,7 @@ namespace boost { namespace polygon {
void sort() const{ void sort() const{
if(unsorted_) { if(unsorted_) {
std::sort(data_.begin(), data_.end()); gtlsort(data_.begin(), data_.end());
unsorted_ = false; unsorted_ = false;
} }
} }
@ -364,7 +364,7 @@ namespace boost { namespace polygon {
if(resizing < 0) if(resizing < 0)
return shrink(-resizing); return shrink(-resizing);
if(resizing > 0) if(resizing > 0)
return bloat(-resizing); return bloat(resizing);
return *this; return *this;
} }
if(resizing == 0) 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.first, (*itr).first.second, (*itr).second));
data.push_back(vertex_half_edge((*itr).first.second, (*itr).first.first, -1 * (*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()); pf.scan(container, data.begin(), data.end());
} }
}; };