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

Libedit: minor enhancements. Update Boost::Polygon

This commit is contained in:
jean-pierre charras 2010-10-23 12:09:23 +02:00
parent b6eb58c547
commit 0c24113dc0
22 changed files with 1637 additions and 1526 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
CHANGELOG.txt
View File

@ -4,6 +4,26 @@ KiCad ChangeLog 2010
Please add newer entries at the top, list the date and your name with
email address.
2010-oct-22 UPDATE Wayne Stambaugh <stambaughw@verizon.net>
================================================================================
Component library editor bug fixes and other minor fixes.
* Fix bug that prevented component from being replaced in library when
the component root name was changed.
* Fix drawing bug when changing text or field item string while move in
progress.
* Fix drawing bug when rotating text item while move in progress.
* Prevent undo or redo when editing a component draw item.
* Fix assert bug when replacing component in library when the component
root name was changed.
* Fix bug in field editor caused by new root alias implementation that
prevented any field from being changed.
* Fix minor spacing issues with EESchema find dialog.
* Deprecate remaining internal linked list code from component library
objects.
* Rename pin object files to match new library object file naming
scheme.
* Move LIB_TEXT object definition into it's own header file.
2010-Oct-20 UPDATE Dick Hollenbeck <dick@softplc.com>
================================================================================
++richio:

1626
eeschema/dialog_edit_libentry_fields_in_lib_base.fbp
View File

File diff suppressed because it is too large Load Diff

23
eeschema/hotkeys.cpp
View File

@ -111,15 +111,12 @@ 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" ),
HK_ROTATE, 'R' );
static Ki_HotkeyInfo HkEdit( wxT( "Edit Schematic Item" ),
HK_EDIT, 'E' );
static Ki_HotkeyInfo HkRotate( wxT( "Rotate Item" ), HK_ROTATE, 'R' );
static Ki_HotkeyInfo HkEdit( wxT( "Edit Schematic Item" ), HK_EDIT, 'E' );
static Ki_HotkeyInfo HkEditComponentValue( wxT( "Edit Component Value" ),
HK_EDIT_COMPONENT_VALUE, 'V' );
static Ki_HotkeyInfo HkEditComponentFootprint( wxT( "Edit Component Footprint" ),
HK_EDIT_COMPONENT_FOOTPRINT,
'F' );
HK_EDIT_COMPONENT_FOOTPRINT, 'F' );
static Ki_HotkeyInfo HkMove( wxT( "Move Schematic Item" ),
HK_MOVE_COMPONENT_OR_ITEM, 'M',
ID_POPUP_SCH_MOVE_CMP_REQUEST );
@ -143,7 +140,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 +190,7 @@ Ki_HotkeyInfo* s_LibEdit_Hotkey_List[] =
&HkCreatePin,
&HkInsertPin,
&HkEdit,
&HkMovePin,
&HkMoveLibItem,
&HkDelete,
&HkRotate,
&HkDrag,
@ -816,6 +813,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 +841,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;
}

34
eeschema/libedit_onrightclick.cpp
View File

@ -80,7 +80,7 @@ bool WinEDA_LibeditFrame::OnRightClick( const wxPoint& MousePos, wxMenu* PopMenu
case COMPONENT_ARC_DRAW_TYPE:
if( DrawEntry->m_Flags == 0 )
{
msg = AddHotkeyName( _( "Move Arc " ), s_Libedit_Hokeys_Descr,
msg = AddHotkeyName( _( "Move Arc" ), s_Libedit_Hokeys_Descr,
HK_LIBEDIT_MOVE_GRAPHIC_ITEM );
ADD_MENUITEM( PopMenu, ID_POPUP_LIBEDIT_MOVE_ITEM_REQUEST,
msg, move_arc_xpm );
@ -97,7 +97,7 @@ bool WinEDA_LibeditFrame::OnRightClick( const wxPoint& MousePos, wxMenu* PopMenu
if( DrawEntry->m_Flags == 0 )
{
msg = AddHotkeyName( _( "Delete Arc " ), s_Libedit_Hokeys_Descr,
msg = AddHotkeyName( _( "Delete Arc" ), s_Libedit_Hokeys_Descr,
HK_DELETE );
ADD_MENUITEM( PopMenu, ID_POPUP_LIBEDIT_DELETE_ITEM,
msg, delete_arc_xpm );
@ -107,7 +107,7 @@ bool WinEDA_LibeditFrame::OnRightClick( const wxPoint& MousePos, wxMenu* PopMenu
case COMPONENT_CIRCLE_DRAW_TYPE:
if( DrawEntry->m_Flags == 0 )
{
msg = AddHotkeyName( _( "Move Circle " ), s_Libedit_Hokeys_Descr,
msg = AddHotkeyName( _( "Move Circle" ), s_Libedit_Hokeys_Descr,
HK_LIBEDIT_MOVE_GRAPHIC_ITEM );
ADD_MENUITEM( PopMenu, ID_POPUP_LIBEDIT_MOVE_ITEM_REQUEST,
msg, move_circle_xpm );
@ -128,7 +128,7 @@ bool WinEDA_LibeditFrame::OnRightClick( const wxPoint& MousePos, wxMenu* PopMenu
if( DrawEntry->m_Flags == 0 )
{
msg = AddHotkeyName( _( "Delete Circle " ),
msg = AddHotkeyName( _( "Delete Circle" ),
s_Libedit_Hokeys_Descr, HK_DELETE );
ADD_MENUITEM( PopMenu, ID_POPUP_LIBEDIT_DELETE_ITEM,
msg, delete_circle_xpm );
@ -138,7 +138,7 @@ bool WinEDA_LibeditFrame::OnRightClick( const wxPoint& MousePos, wxMenu* PopMenu
case COMPONENT_RECT_DRAW_TYPE:
if( DrawEntry->m_Flags == 0 )
{
msg = AddHotkeyName( _( "Move Rectangle " ), s_Libedit_Hokeys_Descr,
msg = AddHotkeyName( _( "Move Rectangle" ), s_Libedit_Hokeys_Descr,
HK_LIBEDIT_MOVE_GRAPHIC_ITEM );
ADD_MENUITEM( PopMenu, ID_POPUP_LIBEDIT_MOVE_ITEM_REQUEST,
msg, move_rectangle_xpm );
@ -159,7 +159,7 @@ bool WinEDA_LibeditFrame::OnRightClick( const wxPoint& MousePos, wxMenu* PopMenu
if( DrawEntry->m_Flags == 0 )
{
msg = AddHotkeyName( _( "Delete Rectangle " ), s_Libedit_Hokeys_Descr,
msg = AddHotkeyName( _( "Delete Rectangle" ), s_Libedit_Hokeys_Descr,
HK_DELETE );
ADD_MENUITEM( PopMenu, ID_POPUP_LIBEDIT_DELETE_ITEM,
msg, delete_rectangle_xpm );
@ -170,25 +170,25 @@ bool WinEDA_LibeditFrame::OnRightClick( const wxPoint& MousePos, wxMenu* PopMenu
case COMPONENT_GRAPHIC_TEXT_DRAW_TYPE:
if( DrawEntry->m_Flags == 0 )
{
msg = AddHotkeyName( _( "Move Text " ), s_Libedit_Hokeys_Descr,
msg = AddHotkeyName( _( "Move Text" ), s_Libedit_Hokeys_Descr,
HK_LIBEDIT_MOVE_GRAPHIC_ITEM );
ADD_MENUITEM( PopMenu, ID_POPUP_LIBEDIT_MOVE_ITEM_REQUEST,
msg, move_text_xpm );
}
msg = AddHotkeyName( _( "Edit Text " ), s_Libedit_Hokeys_Descr,
msg = AddHotkeyName( _( "Edit Text" ), s_Libedit_Hokeys_Descr,
HK_EDIT );
ADD_MENUITEM( PopMenu, ID_POPUP_LIBEDIT_BODY_EDIT_ITEM,
msg, edit_text_xpm );
msg = AddHotkeyName( _( "Rotate Text " ), s_Libedit_Hokeys_Descr,
msg = AddHotkeyName( _( "Rotate Text" ), s_Libedit_Hokeys_Descr,
HK_ROTATE );
ADD_MENUITEM( PopMenu, ID_POPUP_LIBEDIT_ROTATE_GRAPHIC_TEXT,
msg, edit_text_xpm );
if( DrawEntry->m_Flags == 0 )
{
msg = AddHotkeyName( _( "Delete Text " ), s_Libedit_Hokeys_Descr,
msg = AddHotkeyName( _( "Delete Text" ), s_Libedit_Hokeys_Descr,
HK_DELETE );
ADD_MENUITEM( PopMenu, ID_POPUP_LIBEDIT_DELETE_ITEM,
msg, delete_text_xpm );
@ -198,7 +198,7 @@ bool WinEDA_LibeditFrame::OnRightClick( const wxPoint& MousePos, wxMenu* PopMenu
case COMPONENT_POLYLINE_DRAW_TYPE:
if( DrawEntry->m_Flags == 0 )
{
msg = AddHotkeyName( _( "Move Line " ), s_Libedit_Hokeys_Descr,
msg = AddHotkeyName( _( "Move Line" ), s_Libedit_Hokeys_Descr,
HK_LIBEDIT_MOVE_GRAPHIC_ITEM );
ADD_MENUITEM( PopMenu, ID_POPUP_LIBEDIT_MOVE_ITEM_REQUEST,
msg, move_line_xpm );
@ -230,7 +230,7 @@ bool WinEDA_LibeditFrame::OnRightClick( const wxPoint& MousePos, wxMenu* PopMenu
{
if( ( (LIB_POLYLINE*) DrawEntry )->GetCornerCount() > 2 )
{
msg = AddHotkeyName( _( "Delete Segment " ),
msg = AddHotkeyName( _( "Delete Segment" ),
s_Libedit_Hokeys_Descr, HK_DELETE );
ADD_MENUITEM( PopMenu,
ID_POPUP_LIBEDIT_DELETE_CURRENT_POLY_SEGMENT,
@ -243,15 +243,19 @@ bool WinEDA_LibeditFrame::OnRightClick( const wxPoint& MousePos, wxMenu* PopMenu
case COMPONENT_FIELD_DRAW_TYPE:
if( DrawEntry->m_Flags == 0 )
{
msg = AddHotkeyName( _( "Move Field " ), s_Libedit_Hokeys_Descr,
msg = AddHotkeyName( _( "Move Field" ), s_Libedit_Hokeys_Descr,
HK_LIBEDIT_MOVE_GRAPHIC_ITEM );
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;

32
eeschema/libeditframe.cpp
View File

@ -165,7 +165,7 @@ WinEDA_LibeditFrame::WinEDA_LibeditFrame( WinEDA_SchematicFrame* aParent,
SetShowDeMorgan( false );
m_drawSpecificConvert = true;
m_drawSpecificUnit = false;
m_savedComponent = NULL;
m_tempCopyComponent = NULL;
m_HotkeysZoomAndGridList = s_Libedit_Hokeys_Descr;
// Give an icon
@ -238,6 +238,9 @@ WinEDA_LibeditFrame::~WinEDA_LibeditFrame()
frame->m_LibeditFrame = NULL;
m_drawItem = m_lastDrawItem = NULL;
if ( m_tempCopyComponent )
delete m_tempCopyComponent;
m_tempCopyComponent = NULL;
}
@ -969,11 +972,26 @@ void WinEDA_LibeditFrame::SetLanguage( wxCommandEvent& event )
}
void WinEDA_LibeditFrame::DeleteSavedComponent()
/** Function TempCopyComponent
* create a temporary copy of the current edited component
* Used to prepare an Undo ant/or abort command before editing the component
*/
void WinEDA_LibeditFrame::TempCopyComponent()
{
if( m_savedComponent )
{
delete m_savedComponent;
m_savedComponent = NULL;
}
if( m_tempCopyComponent )
delete m_tempCopyComponent;
if( m_component )
m_tempCopyComponent = new LIB_COMPONENT( *m_component );
}
/** Function RestoreComponent
* Restore the current edited component from its temporary copy.
* Used to abort a command
*/
void WinEDA_LibeditFrame::RestoreComponent()
{
if( m_component )
delete m_component;
m_component = m_tempCopyComponent;
m_tempCopyComponent = NULL;
}

25
eeschema/libeditframe.h
View File

@ -23,10 +23,10 @@ class Dialog_BodyGraphicText_Properties;
*/
class WinEDA_LibeditFrame : public WinEDA_DrawFrame
{
LIB_COMPONENT* m_savedComponent; ///< Temporary copy of current component during edit.
wxString m_oldRootName; ///< The actual pointer of the component loaded from
///< a library. Do not do anything with this pointer.
///< It is to be used for reference purposes only.
LIB_COMPONENT* m_tempCopyComponent; ///< Temporary copy of current component during edit.
wxString m_oldRootName; ///< The actual pointer of the component loaded from
///< a library. Do not do anything with this pointer.
///< It is to be used for reference purposes only.
public:
WinEDAChoiceBox* m_SelpartBox; // a Box to select a part to edit (if any)
@ -171,7 +171,22 @@ public:
FILL_T GetFillStyle( void ) { return m_drawFillStyle; }
void DeleteSavedComponent();
/** Function TempCopyComponent
* create a temporary copy of the current edited component
* Used to prepare an Undo ant/or abort command before editing the component
*/
void TempCopyComponent();
/** Function RestoreComponent
* Restore the current edited component from its temporary copy.
* Used to abort a command
*/
void RestoreComponent();
/** Function GetTempCopyComponent
* @return the temporary copy of the current component.
*/
LIB_COMPONENT* GetTempCopyComponent() { return m_tempCopyComponent; }
bool IsEditingDrawItem() { return m_drawItem && m_drawItem->InEditMode(); }

29
eeschema/symbdraw.cpp
View File

@ -11,6 +11,7 @@
#include "eeschema_id.h"
#include "program.h"
#include "general.h"
#include "libeditframe.h"
#include "class_libentry.h"
#include "dialog_lib_edit_draw_item.h"
@ -61,14 +62,14 @@ void WinEDA_LibeditFrame::EditGraphicSymbol( wxDC* DC, LIB_DRAW_ITEM* DrawItem )
/* TODO: see if m_drawFillStyle must retain the last fill option or not.
* if the last is Filled, having next new graphic items created
* with filled body is often bad.
* currently m_drawFillStyle is left with the defualt value (not filled)
* currently m_drawFillStyle is left with the default value (not filled)
*/
if( DrawItem->IsFillable() )
m_drawFillStyle = (FILL_T) dialog.GetFillStyle();
#endif
// Save copy for undo is done before place.
if( !( DrawItem->m_Flags & IS_NEW ) )
// Save copy for undo if not in edit (edit command already handle the save copy)
if( DrawItem->m_Flags == 0 )
SaveCopyInUndoList( DrawItem->GetParent() );
if( m_drawSpecificUnit )
@ -106,19 +107,17 @@ static void AbortSymbolTraceOn( WinEDA_DrawPanel* Panel, wxDC* DC )
Panel->ManageCurseur = NULL;
Panel->ForceCloseManageCurseur = NULL;
bool deleteItem = item->IsNew();
bool newItem = item->IsNew();
item->EndEdit( parent->GetScreen()->GetCursorDrawPosition(), true );
// This draw is required to restore the item to it's last state.
item->Draw( Panel, DC, wxPoint( 0, 0 ), -1, g_XorMode, NULL, DefaultTransform );
if( deleteItem )
if( newItem )
{
SAFE_DELETE( item );
delete item;
parent->SetDrawItem( NULL );
}
else
parent->RestoreComponent();
parent->DeleteSavedComponent();
Panel->Refresh();
}
@ -187,7 +186,7 @@ LIB_DRAW_ITEM* WinEDA_LibeditFrame::CreateGraphicItem( LIB_COMPONENT* LibEntry,
if( m_drawSpecificConvert )
m_drawItem->m_Convert = m_convert;
m_savedComponent = new LIB_COMPONENT( *m_component );
TempCopyComponent();
}
else
{
@ -236,6 +235,7 @@ static void RedrawWhileMovingCursor( WinEDA_DrawPanel* panel, wxDC* DC, bool era
BASE_SCREEN* Screen = panel->GetScreen();
item->SetEraseLastDrawItem( erase );
item->Draw( panel, DC, Screen->GetCursorDrawPosition(), -1, g_XorMode, NULL,
DefaultTransform );
}
@ -251,7 +251,7 @@ void WinEDA_LibeditFrame::StartMoveDrawSymbol( wxDC* DC )
if( m_drawItem->m_Unit != m_unit )
m_drawItem->m_Unit = m_unit;
m_savedComponent = new LIB_COMPONENT( *m_component );
TempCopyComponent();
m_drawItem->BeginEdit( IS_MOVED, GetScreen()->GetCursorDrawPosition() );
DrawPanel->ManageCurseur = RedrawWhileMovingCursor;
DrawPanel->ForceCloseManageCurseur = AbortSymbolTraceOn;
@ -265,7 +265,7 @@ void WinEDA_LibeditFrame::StartModifyDrawSymbol( wxDC* DC )
if( m_drawItem == NULL )
return;
m_savedComponent = new LIB_COMPONENT( *m_component );
TempCopyComponent();
m_drawItem->BeginEdit( IS_RESIZED, GetScreen()->GetCursorDrawPosition() );
DrawPanel->ManageCurseur = SymbolDisplayDraw;
DrawPanel->ForceCloseManageCurseur = AbortSymbolTraceOn;
@ -300,8 +300,7 @@ void WinEDA_LibeditFrame::EndDrawGraphicItem( wxDC* DC )
else
SetCursor( wxCURSOR_ARROW );
SaveCopyInUndoList( m_savedComponent );
DeleteSavedComponent();
SaveCopyInUndoList( GetTempCopyComponent() );
if( m_drawItem->IsNew() )
m_component->AddDrawItem( m_drawItem );

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());
}
};