1439 lines
41 KiB
C++
1439 lines
41 KiB
C++
/*
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
*
|
|
* Copyright (C) 2020 KiCad Developers.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, you may find one here:
|
|
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|
* or you may search the http://www.gnu.org website for the version 2 license,
|
|
* or you may write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
|
|
// WARNING - this Tom's crappy PNS hack tool code. Please don't complain about its quality
|
|
// (unless you want to improve it).
|
|
|
|
#include <wx/clipbrd.h>
|
|
|
|
#include <pcb_painter.h>
|
|
#include <pcb_test_frame.h>
|
|
#include <qa_utils/utility_registry.h>
|
|
#include <pgm_base.h>
|
|
|
|
#include <profile.h>
|
|
|
|
#include <view/view_overlay.h>
|
|
|
|
#include "pns_log.h"
|
|
#include "router/pns_diff_pair.h"
|
|
#include "pns_log_viewer_frame_base.h"
|
|
|
|
#include "qa/drc_proto/drc_proto.h"
|
|
|
|
#define ID_LIST_COPY 10001
|
|
#define ID_LIST_SHOW_ALL 10002
|
|
#define ID_LIST_SHOW_NONE 10003
|
|
|
|
class PNS_LOG_VIEWER_FRAME : public PNS_LOG_VIEWER_FRAME_BASE, public PCB_TEST_FRAME_BASE
|
|
{
|
|
public:
|
|
PNS_LOG_VIEWER_FRAME( wxFrame* frame ) : PNS_LOG_VIEWER_FRAME_BASE( frame )
|
|
{
|
|
LoadSettings();
|
|
createView( this, PCB_DRAW_PANEL_GAL::GAL_TYPE_OPENGL );
|
|
|
|
m_viewSizer->Add( m_galPanel.get(), 1, wxEXPAND, 5 );
|
|
|
|
Layout();
|
|
|
|
Show( true );
|
|
Maximize();
|
|
Raise();
|
|
|
|
auto settings = static_cast<KIGFX::PCB_RENDER_SETTINGS*>(
|
|
m_galPanel->GetView()->GetPainter()->GetSettings() );
|
|
|
|
settings->SetZoneDisplayMode( ZONE_DISPLAY_MODE::SHOW_ZONE_OUTLINE );
|
|
|
|
m_listPopupMenu = new wxMenu(wxT(""));
|
|
m_listPopupMenu->Append(ID_LIST_COPY, wxT("Copy selected geometry"), wxT(""), wxITEM_NORMAL);
|
|
m_listPopupMenu->Append(ID_LIST_SHOW_ALL, wxT("Show all"), wxT (""), wxITEM_NORMAL);
|
|
m_listPopupMenu->Append(ID_LIST_SHOW_NONE, wxT("Show none"), wxT (""), wxITEM_NORMAL);
|
|
|
|
m_itemList->Connect(m_itemList->GetId(),wxEVT_TREELIST_ITEM_CONTEXT_MENU,wxMouseEventHandler(PNS_LOG_VIEWER_FRAME::onListRightClick),NULL,this);
|
|
//m_itemList->Connect(m_itemList->GetId(),wxEVT_LISTBOX,wxCommandEventHandler(PNS_LOG_VIEWER_FRAME::onListSelect),NULL,this);
|
|
m_itemList->Connect(m_itemList->GetId(),wxEVT_TREELIST_SELECTION_CHANGED,wxCommandEventHandler(PNS_LOG_VIEWER_FRAME::onListSelect),NULL,this);
|
|
m_itemList->Connect(m_itemList->GetId(),wxEVT_TREELIST_ITEM_CHECKED,wxCommandEventHandler(PNS_LOG_VIEWER_FRAME::onListChecked),NULL,this);
|
|
|
|
//Connect(ID_LIST_COPY,wxEVT_COMMAND_MENU_SELECTED,wxCommandEventHandler(PNS_LOG_VIEWER_FRAME::onListCopy),NULL,this);
|
|
//Connect(ID_LIST_SHOW_ALL,wxEVT_COMMAND_MENU_SELECTED,wxCommandEventHandler(PNS_LOG_VIEWER_FRAME::onListShowAll),NULL,this);
|
|
//Connect(ID_LIST_SHOW_NONE,wxEVT_COMMAND_MENU_SELECTED,wxCommandEventHandler(PNS_LOG_VIEWER_FRAME::onListShowNone),NULL,this);
|
|
m_itemList->AppendColumn ( "Type" );
|
|
m_itemList->AppendColumn ( "Value" );
|
|
}
|
|
|
|
virtual ~PNS_LOG_VIEWER_FRAME()
|
|
{
|
|
}
|
|
|
|
void SetLogFile( PNS_LOG_FILE* aLog );
|
|
|
|
private:
|
|
void drawLoggedItems( int iter );
|
|
void updateDumpPanel( int iter );
|
|
virtual void createUserTools() override;
|
|
void buildListTree( wxTreeListItem item, PNS_TEST_DEBUG_DECORATOR::DEBUG_ENT* ent );
|
|
void syncModel();
|
|
PNS_TEST_DEBUG_DECORATOR::STAGE* getCurrentStage();
|
|
|
|
virtual void onReload( wxCommandEvent& event ) override;
|
|
virtual void onExit( wxCommandEvent& event ) override;
|
|
virtual void onRewindScroll( wxScrollEvent& event ) override;
|
|
virtual void onRewindCountText( wxCommandEvent& event ) override;
|
|
virtual void onListRightClick(wxMouseEvent& event);
|
|
virtual void onListShowAll( wxCommandEvent& event );
|
|
virtual void onListShowNone( wxCommandEvent& event );
|
|
virtual void onListCopy( wxCommandEvent& event );
|
|
virtual void onListSelect( wxCommandEvent& event );
|
|
virtual void onBtnRewindLeft( wxCommandEvent& event ) override;
|
|
virtual void onBtnRewindRight( wxCommandEvent& event ) override;
|
|
virtual void onListChecked( wxCommandEvent& event );
|
|
|
|
std::shared_ptr<KIGFX::VIEW_OVERLAY> m_overlay;
|
|
std::shared_ptr<PNS_LOG_FILE> m_logFile;
|
|
std::shared_ptr<PNS_TEST_ENVIRONMENT> m_env;
|
|
int m_rewindIter;
|
|
wxMenu* m_listPopupMenu;
|
|
};
|
|
|
|
|
|
class WX_SHAPE_TREE_ITEM_DATA : public wxClientData
|
|
{
|
|
public:
|
|
WX_SHAPE_TREE_ITEM_DATA(PNS_TEST_DEBUG_DECORATOR::DEBUG_ENT *item ) :
|
|
m_item(item) {};
|
|
|
|
PNS_TEST_DEBUG_DECORATOR::DEBUG_ENT *m_item;
|
|
};
|
|
|
|
void PNS_LOG_VIEWER_FRAME::createUserTools()
|
|
{
|
|
|
|
}
|
|
|
|
|
|
static const COLOR4D assignColor( int aStyle )
|
|
{
|
|
COLOR4D color;
|
|
|
|
switch( aStyle )
|
|
{
|
|
case 0:
|
|
color = COLOR4D( 0, 1, 0, 1 );
|
|
break;
|
|
|
|
case 1:
|
|
color = COLOR4D( 1, 0, 0, 1 );
|
|
break;
|
|
|
|
case 2:
|
|
color = COLOR4D( 1, 1, 0, 1 );
|
|
break;
|
|
|
|
case 3:
|
|
color = COLOR4D( 0, 0, 1, 1 );
|
|
break;
|
|
|
|
case 4:
|
|
color = COLOR4D( 1, 1, 1, 1 );
|
|
break;
|
|
|
|
case 5:
|
|
color = COLOR4D( 1, 1, 0, 1 );
|
|
break;
|
|
|
|
case 6:
|
|
color = COLOR4D( 0, 1, 1, 1 );
|
|
break;
|
|
|
|
case 32:
|
|
color = COLOR4D( 0, 0, 1, 1 );
|
|
break;
|
|
|
|
default:
|
|
color = COLOR4D( 0.4, 0.4, 0.4, 1 );
|
|
break;
|
|
}
|
|
|
|
return color;
|
|
}
|
|
|
|
PNS_TEST_DEBUG_DECORATOR::STAGE* PNS_LOG_VIEWER_FRAME::getCurrentStage()
|
|
{
|
|
PNS_TEST_DEBUG_DECORATOR* dbgd = m_env->GetDebugDecorator();
|
|
int count = dbgd->GetStageCount();
|
|
|
|
int iter = m_rewindIter;
|
|
|
|
if( count <= 0 )
|
|
return nullptr;
|
|
|
|
if( iter < 0 )
|
|
iter = 0;
|
|
|
|
if( iter >= count )
|
|
iter = count - 1;
|
|
|
|
return dbgd->GetStage( iter );
|
|
}
|
|
|
|
void PNS_LOG_VIEWER_FRAME::drawLoggedItems( int iter )
|
|
{
|
|
if( !m_env )
|
|
return;
|
|
|
|
m_overlay = m_galPanel->DebugOverlay();
|
|
m_overlay->Clear();
|
|
|
|
PNS_TEST_DEBUG_DECORATOR::STAGE* st = getCurrentStage();
|
|
|
|
if( !st )
|
|
return;
|
|
|
|
auto drawShapes = [ & ] ( PNS_TEST_DEBUG_DECORATOR::DEBUG_ENT *ent ) -> bool
|
|
{
|
|
bool isEnabled = ent->IsVisible();
|
|
bool isSelected = false;
|
|
if (! isEnabled )
|
|
return true;
|
|
|
|
for( auto& sh : ent->m_shapes )
|
|
{
|
|
m_overlay->SetIsStroke( true );
|
|
m_overlay->SetIsFill( false );
|
|
m_overlay->SetStrokeColor( assignColor( ent->m_color ) );
|
|
m_overlay->SetLineWidth( ent->m_width );
|
|
|
|
switch( sh->Type() )
|
|
{
|
|
case SH_CIRCLE:
|
|
{
|
|
auto cir = static_cast<SHAPE_CIRCLE*>( sh );
|
|
m_overlay->Circle( cir->GetCenter(), cir->GetRadius() );
|
|
|
|
break;
|
|
}
|
|
case SH_RECT:
|
|
{
|
|
auto rect = static_cast<SHAPE_RECT*>( sh );
|
|
m_overlay->Rectangle( rect->GetPosition(), rect->GetPosition() + rect->GetSize() );
|
|
|
|
break;
|
|
}
|
|
case SH_LINE_CHAIN:
|
|
{
|
|
auto lc = static_cast<SHAPE_LINE_CHAIN*>( sh );
|
|
|
|
if( isSelected )
|
|
{
|
|
m_overlay->SetLineWidth( ent->m_width * 2 );
|
|
m_overlay->SetStrokeColor( COLOR4D(1.0, 1.0, 1.0, 1.0) );
|
|
}
|
|
|
|
for( int i = 0; i < lc->SegmentCount(); i++ )
|
|
{
|
|
auto s = lc->CSegment( i );
|
|
m_overlay->Line( s.A, s.B );
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
};
|
|
|
|
st->m_entries->IterateTree( drawShapes );
|
|
|
|
/* if ( !m_itemList->IsChecked(itemID) || !ent.m_shapes.size() )
|
|
{
|
|
if( itemID != m_selectedItem )
|
|
{
|
|
itemID++;
|
|
continue;
|
|
}
|
|
}*/
|
|
|
|
//m_galPanel->ForceRefresh();
|
|
|
|
m_galPanel->GetView()->MarkDirty();
|
|
m_galPanel->GetParent()->Refresh();
|
|
}
|
|
|
|
|
|
static BOARD* loadBoard( const std::string& filename )
|
|
{
|
|
PLUGIN::RELEASER pi( new PCB_IO );
|
|
BOARD* brd = nullptr;
|
|
|
|
try
|
|
{
|
|
brd = pi->Load( wxString( filename.c_str() ), NULL, NULL );
|
|
}
|
|
catch( const IO_ERROR& ioe )
|
|
{
|
|
wxString msg = wxString::Format( _( "Error loading board.\n%s" ),
|
|
ioe.Problem() );
|
|
|
|
printf( "Board Loading Error: '%s'\n", (const char*) msg.mb_str() );
|
|
return nullptr;
|
|
}
|
|
|
|
return brd;
|
|
}
|
|
|
|
|
|
void PNS_LOG_VIEWER_FRAME::SetLogFile( PNS_LOG_FILE* aLog )
|
|
{
|
|
m_logFile.reset( aLog );
|
|
|
|
SetBoard( m_logFile->GetBoard() );
|
|
|
|
m_env.reset( new PNS_TEST_ENVIRONMENT );
|
|
|
|
m_env->SetMode( PNS::PNS_MODE_ROUTE_SINGLE );
|
|
m_env->ReplayLog( m_logFile.get() );
|
|
|
|
auto dbgd = m_env->GetDebugDecorator();
|
|
int n_stages = dbgd->GetStageCount();
|
|
m_rewindSlider->SetMax( n_stages - 1 );
|
|
m_rewindSlider->SetValue( n_stages - 1 );
|
|
m_rewindIter = n_stages - 1;
|
|
|
|
auto extents = m_board->GetBoundingBox();
|
|
|
|
|
|
BOX2D bbd;
|
|
bbd.SetOrigin( extents.GetOrigin() );
|
|
bbd.SetWidth( extents.GetWidth() );
|
|
bbd.SetHeight( extents.GetHeight() );
|
|
bbd.Inflate( std::min( bbd.GetWidth(), bbd.GetHeight() )/ 5);
|
|
|
|
m_galPanel->GetView()->SetViewport( bbd );
|
|
|
|
drawLoggedItems( m_rewindIter );
|
|
updateDumpPanel( m_rewindIter );
|
|
}
|
|
|
|
void PNS_LOG_VIEWER_FRAME::onReload( wxCommandEvent& event )
|
|
{
|
|
event.Skip();
|
|
}
|
|
|
|
void PNS_LOG_VIEWER_FRAME::onExit( wxCommandEvent& event )
|
|
{
|
|
event.Skip();
|
|
}
|
|
|
|
void PNS_LOG_VIEWER_FRAME::onListChecked( wxCommandEvent& event )
|
|
{
|
|
printf("On-list-checked\n");
|
|
syncModel();
|
|
drawLoggedItems(m_rewindIter);
|
|
}
|
|
|
|
|
|
void PNS_LOG_VIEWER_FRAME::onRewindScroll( wxScrollEvent& event )
|
|
{
|
|
m_rewindIter = event.GetPosition();
|
|
drawLoggedItems(m_rewindIter);
|
|
updateDumpPanel(m_rewindIter);
|
|
char str[128];
|
|
sprintf(str,"%d",m_rewindIter);
|
|
m_rewindPos->SetValue( str );
|
|
event.Skip();
|
|
}
|
|
|
|
void PNS_LOG_VIEWER_FRAME::onBtnRewindLeft( wxCommandEvent& event )
|
|
{
|
|
if(m_rewindIter > 0)
|
|
{
|
|
m_rewindIter--;
|
|
drawLoggedItems(m_rewindIter);
|
|
updateDumpPanel(m_rewindIter);
|
|
char str[128];
|
|
sprintf(str,"%d",m_rewindIter);
|
|
m_rewindPos->SetValue( str );
|
|
}
|
|
}
|
|
|
|
void PNS_LOG_VIEWER_FRAME::onBtnRewindRight( wxCommandEvent& event )
|
|
{
|
|
auto dbgd = m_env->GetDebugDecorator();
|
|
int count = dbgd->GetStageCount();
|
|
|
|
if(m_rewindIter < count)
|
|
{
|
|
m_rewindIter++;
|
|
drawLoggedItems(m_rewindIter);
|
|
updateDumpPanel(m_rewindIter);
|
|
char str[128];
|
|
sprintf(str,"%d",m_rewindIter);
|
|
m_rewindPos->SetValue( str );
|
|
}
|
|
}
|
|
|
|
void PNS_LOG_VIEWER_FRAME::onRewindCountText( wxCommandEvent& event )
|
|
{
|
|
if( !m_env )
|
|
return;
|
|
|
|
int val = wxAtoi( m_rewindPos->GetValue() );
|
|
|
|
auto dbgd = m_env->GetDebugDecorator();
|
|
int count = dbgd->GetStageCount();
|
|
|
|
if( val < 0 )
|
|
val = 0;
|
|
|
|
if( val >= count )
|
|
val = count - 1;
|
|
|
|
m_rewindIter = val;
|
|
m_rewindSlider->SetValue( m_rewindIter );
|
|
drawLoggedItems( m_rewindIter );
|
|
updateDumpPanel( m_rewindIter );
|
|
|
|
event.Skip();
|
|
}
|
|
|
|
void PNS_LOG_VIEWER_FRAME::syncModel()
|
|
{
|
|
printf("SyncModel\n");
|
|
|
|
for( wxTreeListItem item = m_itemList->GetFirstItem();
|
|
item.IsOk();
|
|
item = m_itemList->GetNextItem( item )
|
|
)
|
|
{
|
|
WX_SHAPE_TREE_ITEM_DATA* idata = static_cast<WX_SHAPE_TREE_ITEM_DATA*> ( m_itemList->GetItemData( item ) );
|
|
printf("IDATA %p\n", idata);
|
|
if( idata )
|
|
{
|
|
idata->m_item->m_visible = m_itemList->GetCheckedState( item ) == wxCHK_CHECKED;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void PNS_LOG_VIEWER_FRAME::onListRightClick(wxMouseEvent& event)
|
|
{
|
|
fprintf(stderr,"OnListMenu\n");
|
|
//m_itemList->PopupMenu(m_listPopupMenu);
|
|
auto sel = m_itemList->GetPopupMenuSelectionFromUser( *m_listPopupMenu );
|
|
|
|
switch( sel )
|
|
{
|
|
case ID_LIST_SHOW_NONE:
|
|
m_itemList->CheckItemRecursively( m_itemList->GetRootItem(), wxCHK_UNCHECKED );
|
|
syncModel();
|
|
drawLoggedItems( m_rewindIter );
|
|
break;
|
|
case ID_LIST_SHOW_ALL:
|
|
m_itemList->CheckItemRecursively( m_itemList->GetRootItem(), wxCHK_CHECKED );
|
|
syncModel();
|
|
drawLoggedItems( m_rewindIter );
|
|
break;
|
|
}
|
|
}
|
|
|
|
void PNS_LOG_VIEWER_FRAME::onListShowAll( wxCommandEvent& event )
|
|
{
|
|
|
|
}
|
|
|
|
void PNS_LOG_VIEWER_FRAME::onListShowNone( wxCommandEvent& event )
|
|
{
|
|
m_itemList->CheckItemRecursively( m_itemList->GetRootItem(), wxCHK_UNCHECKED );
|
|
|
|
drawLoggedItems( m_rewindIter );
|
|
}
|
|
|
|
void PNS_LOG_VIEWER_FRAME::onListCopy( wxCommandEvent& event )
|
|
{
|
|
wxString s;
|
|
|
|
int sel = 0; //m_itemList->GetSelection();
|
|
auto dbgd = m_env->GetDebugDecorator();
|
|
int count = dbgd->GetStageCount();
|
|
|
|
if( count <= 0 )
|
|
return;
|
|
|
|
int iter = m_rewindIter;
|
|
|
|
if( iter < 0 )
|
|
iter = 0;
|
|
|
|
if( iter >= count )
|
|
iter = count - 1;
|
|
|
|
const PNS_TEST_DEBUG_DECORATOR::STAGE* st = dbgd->GetStage( iter );
|
|
|
|
// if ( st->m_entries.size() < sel )
|
|
// return;
|
|
|
|
const PNS_TEST_DEBUG_DECORATOR::DEBUG_ENT& ent = st->m_entries[sel];
|
|
|
|
for( auto& sh : ent.m_shapes )
|
|
{
|
|
s += sh->Format() + " ";
|
|
}
|
|
|
|
if (wxTheClipboard->Open())
|
|
{
|
|
// This data objects are held by the clipboard,
|
|
// so do not delete them in the app.
|
|
wxTheClipboard->SetData( new wxTextDataObject(s) );
|
|
wxTheClipboard->Close();
|
|
}
|
|
}
|
|
|
|
void PNS_LOG_VIEWER_FRAME::onListSelect( wxCommandEvent& event )
|
|
{
|
|
printf("OnListSelect!\n");
|
|
drawLoggedItems( m_rewindIter );
|
|
}
|
|
|
|
|
|
void PNS_LOG_VIEWER_FRAME::buildListTree( wxTreeListItem item, PNS_TEST_DEBUG_DECORATOR::DEBUG_ENT* ent )
|
|
{
|
|
printf("LOG append %p\n", ent );
|
|
|
|
wxTreeListItem ritem;
|
|
|
|
if( ent->m_children.size() )
|
|
ritem = m_itemList->AppendItem( item, "Child" );
|
|
else
|
|
ritem = item;
|
|
|
|
//ent->m_item = ritem;
|
|
|
|
if( ent->m_msg.length() )
|
|
{
|
|
m_itemList->SetItemText( ritem, 0, "Message" );
|
|
m_itemList->SetItemText( ritem, 1, ent->m_msg );
|
|
}
|
|
else
|
|
{
|
|
m_itemList->SetItemText( ritem, 0, "Shapes" );
|
|
m_itemList->SetItemText( ritem, 1, ent->m_name );
|
|
}
|
|
|
|
m_itemList->SetItemData( ritem, new WX_SHAPE_TREE_ITEM_DATA( ent ) );
|
|
|
|
for( auto child : ent->m_children )
|
|
{
|
|
auto citem = m_itemList->AppendItem( ritem, "" );
|
|
buildListTree( citem, child );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static void expandAllChildren( wxTreeListCtrl* tree, const wxTreeListItem& item)
|
|
{
|
|
tree->Freeze();
|
|
// expand this item first, this might result in its children being added on
|
|
// the fly
|
|
if ( item != tree->GetRootItem() )
|
|
tree->Expand(item);
|
|
//else: expanding hidden root item is unsupported and unnecessary
|
|
|
|
// then (recursively) expand all the children
|
|
for ( auto idCurr = tree->GetFirstChild(item);
|
|
idCurr.IsOk();
|
|
idCurr = tree->GetNextSibling(item) )
|
|
{
|
|
expandAllChildren(tree, idCurr);
|
|
}
|
|
tree->Thaw();
|
|
}
|
|
|
|
void PNS_LOG_VIEWER_FRAME::updateDumpPanel( int iter )
|
|
{
|
|
if ( !m_env )
|
|
return;
|
|
|
|
auto dbgd = m_env->GetDebugDecorator();
|
|
int count = dbgd->GetStageCount();
|
|
|
|
wxArrayString dumpStrings;
|
|
|
|
if( count <= 0 )
|
|
return;
|
|
|
|
if( iter < 0 )
|
|
iter = 0;
|
|
|
|
if( iter >= count )
|
|
iter = count - 1;
|
|
|
|
|
|
auto st = dbgd->GetStage( iter );
|
|
|
|
auto rootItem = m_itemList->GetRootItem();
|
|
|
|
printf("ItemList: %p\n", m_itemList );
|
|
|
|
m_itemList->DeleteAllItems();
|
|
buildListTree( rootItem, st->m_entries );
|
|
m_itemList->CheckItemRecursively ( rootItem, wxCHK_CHECKED );
|
|
//m_itemList->Expand( List->GetRootItem() );
|
|
|
|
//expandAllChildren( m_itemList, m_itemList->GetRootItem() );
|
|
m_itemList->Refresh();
|
|
}
|
|
|
|
static bool commonParallelProjection( SEG p, SEG n, SEG &pClip, SEG& nClip )
|
|
{
|
|
SEG n_proj_p( p.LineProject( n.A ), p.LineProject( n.B ) );
|
|
|
|
int64_t t_a = 0;
|
|
int64_t t_b = p.TCoef( p.B );
|
|
|
|
int64_t tproj_a = p.TCoef( n_proj_p.A );
|
|
int64_t tproj_b = p.TCoef( n_proj_p.B );
|
|
|
|
if( t_b < t_a )
|
|
std::swap( t_b, t_a );
|
|
|
|
if( tproj_b < tproj_a )
|
|
std::swap( tproj_b, tproj_a );
|
|
|
|
if( t_b <= tproj_a )
|
|
return false;
|
|
|
|
if( t_a >= tproj_b )
|
|
return false;
|
|
|
|
int64_t t[4] = { 0, p.TCoef( p.B ), p.TCoef( n_proj_p.A ), p.TCoef( n_proj_p.B ) };
|
|
std::vector<int64_t> tv( t, t + 4 );
|
|
std::sort( tv.begin(), tv.end() ); // fixme: awful and disgusting way of finding 2 midpoints
|
|
|
|
int64_t pLenSq = p.SquaredLength();
|
|
|
|
VECTOR2I dp = p.B - p.A;
|
|
pClip.A.x = p.A.x + rescale( (int64_t)dp.x, tv[1], pLenSq );
|
|
pClip.A.y = p.A.y + rescale( (int64_t)dp.y, tv[1], pLenSq );
|
|
|
|
pClip.B.x = p.A.x + rescale( (int64_t)dp.x, tv[2], pLenSq );
|
|
pClip.B.y = p.A.y + rescale( (int64_t)dp.y, tv[2], pLenSq );
|
|
|
|
nClip.A = n.LineProject( pClip.A );
|
|
nClip.B = n.LineProject( pClip.B );
|
|
|
|
return true;
|
|
}
|
|
|
|
#if 0
|
|
|
|
using namespace PNS;
|
|
|
|
|
|
|
|
template <typename T1, typename T2>
|
|
typename std::map<T1, T2>::iterator findClosestKey( std::map<T1, T2> & data, T1 key)
|
|
{
|
|
if (data.size() == 0) {
|
|
return data.end();
|
|
}
|
|
|
|
auto lower = data.lower_bound(key);
|
|
|
|
if (lower == data.end()) // If none found, return the last one.
|
|
return std::prev(lower);
|
|
|
|
if (lower == data.begin())
|
|
return lower;
|
|
|
|
// Check which one is closest.
|
|
auto previous = std::prev(lower);
|
|
if ((key - previous->first) < (lower->first - key))
|
|
return previous;
|
|
|
|
return lower;
|
|
}
|
|
|
|
void extractDiffPairItems ( PNS::NODE* node, int net_p, int net_n )
|
|
{
|
|
std::set<PNS::ITEM*> pendingItems, complementItems;
|
|
node->AllItemsInNet( net_p, pendingItems, PNS::ITEM::SEGMENT_T | PNS::ITEM::ARC_T );
|
|
node->AllItemsInNet( net_n, complementItems, PNS::ITEM::SEGMENT_T | PNS::ITEM::ARC_T );
|
|
|
|
while( pendingItems.size() )
|
|
{
|
|
PNS::LINE l = node->AssembleLine( static_cast<PNS::LINKED_ITEM*>( *pendingItems.begin() ) );
|
|
|
|
printf("l net %d segs %d layer %d\n", net_p, l.SegmentCount(), l.Layer() );
|
|
|
|
std::map<int, int> gapMap;
|
|
std::map<PNS::LINKED_ITEM*, int> coupledCandidates;
|
|
|
|
for( auto li : l.Links() )
|
|
{
|
|
pendingItems.erase( li );
|
|
auto sp = dyn_cast<PNS::SEGMENT*> ( li );
|
|
|
|
if(!sp)
|
|
continue;
|
|
|
|
for ( auto ci : complementItems )
|
|
{
|
|
auto sn = dyn_cast<PNS::SEGMENT*> ( ci );
|
|
|
|
if( !sn->Layers().Overlaps( sp->Layers() ))
|
|
continue;
|
|
|
|
|
|
auto ssp = sp->Seg();
|
|
auto ssn = sn->Seg();
|
|
|
|
if( ssp.ApproxParallel(ssn) )
|
|
{
|
|
SEG ca, cb;
|
|
bool coupled = commonParallelProjection( ssp, ssn, ca, cb );
|
|
|
|
if( coupled )
|
|
{
|
|
/* g_overlay->SetStrokeColor( KIGFX::COLOR4D( 1.0, 0.8, 0.8, 1.0 ) );
|
|
g_overlay->SetIsFill(false);
|
|
g_overlay->SetIsStroke(true );
|
|
g_overlay->SetLineWidth( 10000 );
|
|
g_overlay->Line( ca );
|
|
g_overlay->SetStrokeColor( KIGFX::COLOR4D( 0.8, 0.8, 1.0, 1.0 ) );
|
|
g_overlay->Line( cb );*/
|
|
|
|
int len = ca.Length();
|
|
int gap = (int)(ca.A - cb.A).EuclideanNorm() - (sp->Width()+sn->Width()) / 2;
|
|
|
|
auto closestGap = findClosestKey( gapMap, gap );
|
|
|
|
coupledCandidates[sn] = gap;
|
|
|
|
if( closestGap == gapMap.end() || std::abs(closestGap->first - gap) > 50 )
|
|
{
|
|
gapMap[gap] = len;
|
|
} else {
|
|
closestGap->second += len;
|
|
}
|
|
|
|
printf("Seg %p %p gap %d dist %d\n", sp, sn, gap, len );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int bestGap = -1;
|
|
int maxLength = 0;
|
|
for( auto i : gapMap )
|
|
{
|
|
if( i.second > maxLength )
|
|
{
|
|
maxLength = i.second;
|
|
bestGap = i.first;
|
|
}
|
|
}
|
|
|
|
printf("Best gap: %d\n", bestGap);
|
|
|
|
bool pendingCandidates = true;
|
|
|
|
while ( pendingCandidates )
|
|
{
|
|
pendingCandidates = false;
|
|
|
|
for ( auto c : coupledCandidates )
|
|
{
|
|
if( std::abs(c.second - bestGap ) < 50 )
|
|
{
|
|
PNS::LINE l_coupled = node->AssembleLine( c.first );
|
|
|
|
PNS::DIFF_PAIR pair(l, l_coupled, bestGap );
|
|
pair.SetNets( l.Net(), l_coupled.Net() );
|
|
|
|
/* g_overlay->SetStrokeColor( KIGFX::COLOR4D( 1.0, 0.8, 0.8, 1.0 ) );
|
|
g_overlay->SetIsFill(true);
|
|
g_overlay->SetIsStroke(true );
|
|
g_overlay->SetLineWidth( 10000 );
|
|
g_overlay->Polyline( l.CLine() );
|
|
g_overlay->SetStrokeColor( KIGFX::COLOR4D( 0.8, 0.8, 1.0, 1.0 ) );
|
|
g_overlay->Polyline( l_coupled.CLine() );
|
|
*/
|
|
for( auto li : l_coupled.Links() )
|
|
coupledCandidates.erase( li );
|
|
|
|
printf("Orig line : %d segs, coupled line: %d segs\n", l.SegmentCount(), l_coupled.SegmentCount() );
|
|
|
|
pendingCandidates = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
int pns1_main_func( int argc, char* argv[] )
|
|
{
|
|
auto frame = new PNS_LOG_VIEWER_FRAME(nullptr);
|
|
std::shared_ptr<BOARD> board;
|
|
|
|
board.reset( loadBoard ( argv[1] ) );
|
|
|
|
frame->SetBoard( board );
|
|
|
|
Pgm().App().SetTopWindow( frame ); // wxApp gets a face.
|
|
frame->Show();
|
|
|
|
PNS_KICAD_IFACE_BASE iface;
|
|
PNS::NODE *world = new PNS::NODE;
|
|
|
|
iface.SetBoard( board.get() );
|
|
iface.SyncWorld( world );
|
|
|
|
#if 0
|
|
std::map<int, int> diffPairs;
|
|
|
|
// FIXMe: GetNetInfo copies f***ing pointers...
|
|
const auto& netinfo = board->GetNetInfo();
|
|
|
|
int n_nets = netinfo.GetNetCount();
|
|
|
|
for (int net = 0 ; net < n_nets; net++ )
|
|
{
|
|
int coupled = iface.GetRuleResolver()->DpCoupledNet( net );
|
|
if( coupled > 0 && diffPairs.find( coupled ) == diffPairs.end() )
|
|
{
|
|
printf("net %d coupled %d\n", net, coupled );
|
|
diffPairs[net] = coupled;
|
|
}
|
|
}
|
|
|
|
for( auto p : diffPairs )
|
|
{
|
|
extractDiffPairItems ( world, p.first, p.second );
|
|
}
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
static bool registered = UTILITY_REGISTRY::Register( {
|
|
"pns1",
|
|
"PNS Dumb Test (Tom's hacks)",
|
|
pns1_main_func,
|
|
} );
|
|
|
|
#endif
|
|
|
|
//extern "C" void drcCreateTestsProviderClearance();
|
|
//extern "C" void drcCreateTestsProviderEdgeClearance();
|
|
|
|
int replay_main_func( int argc, char* argv[] )
|
|
{
|
|
auto frame = new PNS_LOG_VIEWER_FRAME(nullptr);
|
|
|
|
// drcCreateTestsProviderClearance();
|
|
// drcCreateTestsProviderEdgeClearance();
|
|
|
|
|
|
if( argc >= 2 && std::string(argv[1]) == "-h")
|
|
{
|
|
printf("PNS Log (Re)player. Allows to step through the log written by the ROUTER_TOOL in debug Kicad builds. ");
|
|
printf("Requires a board file with UUIDs and a matching log file. Both are written to /tmp when you press '0' during routing.");
|
|
return 0;
|
|
}
|
|
|
|
if(argc < 3)
|
|
{
|
|
printf("Expected parameters: log_file.log board_file.dump\n");
|
|
return 0;
|
|
}
|
|
|
|
PNS_LOG_FILE* logFile = new PNS_LOG_FILE;
|
|
logFile->Load( argv[1], argv[2] );
|
|
|
|
frame->SetLogFile( logFile );
|
|
//SetTopFrame( frame ); // wxApp gets a face.
|
|
|
|
return 0;
|
|
}
|
|
|
|
static bool registered2 = UTILITY_REGISTRY::Register( {
|
|
"replay",
|
|
"PNS Log Player",
|
|
replay_main_func,
|
|
} );
|
|
|
|
|
|
|
|
|
|
bool commonParallelProjection( SEG p, SEG n, SEG &pClip, SEG& nClip );
|
|
|
|
|
|
template <typename T1, typename T2>
|
|
typename std::map<T1, T2>::iterator findClosestKey( std::map<T1, T2> & data, T1 key)
|
|
{
|
|
if (data.size() == 0) {
|
|
return data.end();
|
|
}
|
|
|
|
auto lower = data.lower_bound(key);
|
|
|
|
if (lower == data.end()) // If none found, return the last one.
|
|
return std::prev(lower);
|
|
|
|
if (lower == data.begin())
|
|
return lower;
|
|
|
|
// Check which one is closest.
|
|
auto previous = std::prev(lower);
|
|
if ((key - previous->first) < (lower->first - key))
|
|
return previous;
|
|
|
|
return lower;
|
|
}
|
|
|
|
|
|
|
|
void extractDiffPair( BOARD* aBoard, int net_p, int net_n )
|
|
{
|
|
std::set<TRACK*> pendingItems, complementItems;
|
|
|
|
struct DP_COUPLED_SEGMENTS
|
|
{
|
|
TRACK* itemP, *itemN;
|
|
};
|
|
|
|
for( auto trk: aBoard->Tracks() )
|
|
{
|
|
if( trk->Type() == PCB_TRACE_T || trk->Type() == PCB_ARC_T )
|
|
{
|
|
if( trk->GetNetCode() == net_p )
|
|
pendingItems.insert( trk );
|
|
else if( trk->GetNetCode() == net_n )
|
|
complementItems.insert( trk );
|
|
}
|
|
}
|
|
|
|
while( pendingItems.size() )
|
|
{
|
|
auto li = *pendingItems.begin();
|
|
pendingItems.erase( li );
|
|
auto sp = dyn_cast<TRACK*>(li);
|
|
|
|
if(!sp)
|
|
continue;
|
|
|
|
for ( auto ci : complementItems )
|
|
{
|
|
auto sn = dyn_cast<TRACK*> ( ci );
|
|
|
|
if( ( sn->GetLayerSet() & sp->GetLayerSet() ).none() )
|
|
continue;
|
|
|
|
SEG ssp ( sp->GetStart(), sp->GetEnd() );
|
|
SEG ssn ( sn->GetStart(), sn->GetEnd() );
|
|
|
|
if( ssp.ApproxParallel(ssn) )
|
|
{
|
|
SEG ca, cb;
|
|
bool coupled = commonParallelProjection( ssp, ssn, ca, cb );
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
static int matchDpSuffix( const wxString& aNetName, wxString& aComplementNet,
|
|
wxString& aBaseDpName )
|
|
{
|
|
int rv = 0;
|
|
|
|
if( aNetName.EndsWith( "+" ) )
|
|
{
|
|
aComplementNet = "-";
|
|
rv = 1;
|
|
}
|
|
else if( aNetName.EndsWith( "P" ) )
|
|
{
|
|
aComplementNet = "N";
|
|
rv = 1;
|
|
}
|
|
else if( aNetName.EndsWith( "-" ) )
|
|
{
|
|
aComplementNet = "+";
|
|
rv = -1;
|
|
}
|
|
else if( aNetName.EndsWith( "N" ) )
|
|
{
|
|
aComplementNet = "P";
|
|
rv = -1;
|
|
}
|
|
// Match P followed by 2 digits
|
|
else if( aNetName.Right( 2 ).IsNumber() && aNetName.Right( 3 ).Left( 1 ) == "P" )
|
|
{
|
|
aComplementNet = "N" + aNetName.Right( 2 );
|
|
rv = 1;
|
|
}
|
|
// Match P followed by 1 digit
|
|
else if( aNetName.Right( 1 ).IsNumber() && aNetName.Right( 2 ).Left( 1 ) == "P" )
|
|
{
|
|
aComplementNet = "N" + aNetName.Right( 1 );
|
|
rv = 1;
|
|
}
|
|
// Match N followed by 2 digits
|
|
else if( aNetName.Right( 2 ).IsNumber() && aNetName.Right( 3 ).Left( 1 ) == "N" )
|
|
{
|
|
aComplementNet = "P" + aNetName.Right( 2 );
|
|
rv = -1;
|
|
}
|
|
// Match N followed by 1 digit
|
|
else if( aNetName.Right( 1 ).IsNumber() && aNetName.Right( 2 ).Left( 1 ) == "N" )
|
|
{
|
|
aComplementNet = "P" + aNetName.Right( 1 );
|
|
rv = -1;
|
|
}
|
|
if( rv != 0 )
|
|
{
|
|
aBaseDpName = aNetName.Left( aNetName.Length() - aComplementNet.Length() );
|
|
aComplementNet = aBaseDpName + aComplementNet;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
|
|
static int dpCoupledNet( BOARD* aBoard, int aNet )
|
|
{
|
|
wxString refName = aBoard->FindNet( aNet )->GetNetname();
|
|
wxString dummy, coupledNetName;
|
|
|
|
if( matchDpSuffix( refName, coupledNetName, dummy ) )
|
|
{
|
|
NETINFO_ITEM* net = aBoard->FindNet( coupledNetName );
|
|
|
|
if( !net )
|
|
return -1;
|
|
|
|
return net->GetNetCode();
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
void extractAllDiffPairs( BOARD* aBoard )
|
|
{
|
|
std::map<int, int> diffPairs;
|
|
|
|
// FIXMe: GetNetInfo copies f***ing pointers...
|
|
const auto& netinfo = aBoard->GetNetInfo();
|
|
|
|
int n_nets = netinfo.GetNetCount();
|
|
|
|
for (int net = 0 ; net < n_nets; net++ )
|
|
{
|
|
int coupled = dpCoupledNet(aBoard, net );
|
|
|
|
if( coupled > 0 && diffPairs.find( coupled ) == diffPairs.end() )
|
|
{
|
|
diffPairs[net] = coupled;
|
|
}
|
|
}
|
|
|
|
for( auto p : diffPairs )
|
|
{
|
|
printf("Extract DP: %s/%s\n", (const char*) aBoard->FindNet( p.first )->GetNetname(),
|
|
(const char*) aBoard->FindNet( p.second )->GetNetname() );
|
|
|
|
extractDiffPair ( aBoard, p.first, p.second );
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
int test1_main_func( int argc, char* argv[] )
|
|
{
|
|
auto frame = new PNS_LOG_VIEWER_FRAME(nullptr);
|
|
|
|
PROJECT_CONTEXT project = loadKicadProject( argv[1], OPT<wxString>() );
|
|
|
|
frame->SetBoard( project.board);
|
|
|
|
Pgm().App().SetTopWindow( frame ); // wxApp gets a face.
|
|
frame->Show();
|
|
|
|
auto view = frame->GetPanel()->GetView();
|
|
//auto settings = static_cast<KIGFX::PCB_RENDER_SETTINGS*>( view->GetPainter()->GetSettings() );
|
|
//settings->SetZoneDisplayMode( ZONE_DISPLAY_MODE:: );
|
|
|
|
/* view->SetLayerVisible( LAYER_TRACKS, false );
|
|
view->SetLayerVisible( LAYER_PADS, false );
|
|
view->SetLayerVisible( LAYER_MOD_TEXT_BK, false );
|
|
view->SetLayerVisible( LAYER_MOD_TEXT_FR, false );
|
|
view->SetLayerVisible( LAYER_MOD_REFERENCES, false );
|
|
view->SetLayerVisible( LAYER_MOD_VALUES, false );
|
|
view->SetLayerVisible( LAYER_MOD_BK, false );
|
|
view->SetLayerVisible( LAYER_MOD_FR, false );*/
|
|
|
|
runDRCProto( project, frame->GetPanel()->DebugOverlay() );
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
//std::shared_ptr<KIGFX::VIEW_OVERLAY> g_overlay;
|
|
static std::shared_ptr<KIGFX::VIEW_OVERLAY> overlay;
|
|
|
|
bool segmentCrossesHullBoundary( const SHAPE_LINE_CHAIN& hull, const SEG& seg)
|
|
{
|
|
for( int j = 0; j < hull.SegmentCount(); j++ )
|
|
{
|
|
auto sr = hull.CSegment(j);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
bool walkaround2( SHAPE_LINE_CHAIN& aLine, SHAPE_LINE_CHAIN aObstacle, SHAPE_LINE_CHAIN& aPre,
|
|
SHAPE_LINE_CHAIN& aWalk, SHAPE_LINE_CHAIN& aPost, bool aCw )
|
|
{
|
|
const SHAPE_LINE_CHAIN& line( aLine );
|
|
|
|
if( line.SegmentCount() < 1 )
|
|
return false;
|
|
|
|
const auto pFirst = line.CPoint(0);
|
|
const auto pLast = line.CPoint(-1);
|
|
|
|
bool inFirst = aObstacle.PointInside( pFirst ) && !aObstacle.PointOnEdge( pFirst );
|
|
bool inLast = aObstacle.PointInside( pLast ) && !aObstacle.PointOnEdge( pLast );
|
|
|
|
if( inFirst || inLast )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
enum VERTEX_TYPE { INSIDE = 0, OUTSIDE, ON_EDGE };
|
|
|
|
struct VERTEX
|
|
{
|
|
VERTEX_TYPE type;
|
|
bool isHull;
|
|
VECTOR2I pos;
|
|
std::vector<VERTEX*> neighbours;
|
|
int indexp, indexh;
|
|
bool visited = false;
|
|
};
|
|
|
|
SHAPE_LINE_CHAIN::INTERSECTIONS ips;
|
|
|
|
line.Intersect( aObstacle, ips );
|
|
|
|
SHAPE_LINE_CHAIN pnew(aLine), hnew(aObstacle);
|
|
|
|
std::vector<VERTEX> vts;
|
|
|
|
auto findVertex = [&]( VECTOR2I pos) -> VERTEX*
|
|
{
|
|
for(auto& v : vts)
|
|
if(v.pos == pos )
|
|
return &v;
|
|
|
|
return nullptr;
|
|
};
|
|
|
|
for( auto ip : ips )
|
|
{
|
|
bool isNewP, isNewH;
|
|
|
|
if( pnew.Find( ip.p ) < 0 )
|
|
{
|
|
pnew.Split(ip.p);
|
|
//overlay->SetStrokeColor( YELLOW );
|
|
//overlay->Circle( ip.p, 200000 );
|
|
}
|
|
|
|
if( hnew.Find( ip.p ) < 0 )
|
|
{
|
|
hnew.Split(ip.p);
|
|
//overlay->SetStrokeColor( CYAN );
|
|
//overlay->Circle( ip.p, 250000 );
|
|
}
|
|
}
|
|
|
|
if ( !aCw )
|
|
hnew = hnew.Reverse();
|
|
|
|
for( int i = 0; i < pnew.PointCount(); i++ )
|
|
{
|
|
auto p = pnew.CPoint(i);
|
|
VERTEX v;
|
|
v.indexp = i;
|
|
v.isHull = false;
|
|
v.pos = p;
|
|
v.type = hnew.PointInside( p ) && !hnew.PointOnEdge( p ) ? INSIDE : hnew.PointOnEdge( p ) ? ON_EDGE : OUTSIDE;
|
|
vts.push_back(v);
|
|
overlay->SetStrokeColor( WHITE );
|
|
overlay->SetFillColor( WHITE );
|
|
overlay->SetGlyphSize( VECTOR2D( 200000, 200000 ));
|
|
overlay->BitmapText( wxString::Format("%d", i), v.pos, 0 );
|
|
}
|
|
|
|
for( int i = 0; i < pnew.PointCount() - 1; i++ )
|
|
{
|
|
vts[i].neighbours.push_back(&vts[i+1]);
|
|
}
|
|
|
|
for( int i = 0; i < hnew.PointCount(); i++ )
|
|
{
|
|
auto hp = hnew.CPoint(i);
|
|
bool found = false;
|
|
auto vn = findVertex( hp );
|
|
|
|
if( vn )
|
|
{
|
|
vn->isHull = true;
|
|
vn->indexh = i;
|
|
} else {
|
|
VERTEX v;
|
|
v.pos = hp;
|
|
v.type = ON_EDGE;
|
|
v.indexh = i;
|
|
v.isHull = true;
|
|
vts.push_back( v );
|
|
}
|
|
|
|
overlay->SetStrokeColor( WHITE );
|
|
overlay->SetFillColor( WHITE );
|
|
overlay->SetGlyphSize( VECTOR2D( 200000, 200000 ));
|
|
// overlay->BitmapText( wxString::Format("%d", i), hp, 0 );
|
|
}
|
|
|
|
|
|
for( int i = 0; i < hnew.PointCount(); i++ )
|
|
{
|
|
auto vc = findVertex( hnew.CPoint(i ) );
|
|
auto vnext = findVertex( hnew.CPoint(i+1) );
|
|
|
|
|
|
|
|
if(vc && vnext)
|
|
vc->neighbours.push_back(vnext);
|
|
}
|
|
|
|
for( auto& v : vts )
|
|
{
|
|
printf(" ip %d ih %d t %d ishull %d\n", v.indexp, v.indexh, v.type, v.isHull?1:0);
|
|
}
|
|
|
|
|
|
VERTEX* v = &vts[0];
|
|
|
|
SHAPE_LINE_CHAIN out;
|
|
|
|
int n = 0;
|
|
while (v->indexp != pnew.PointCount() )
|
|
{
|
|
printf("SCAN ip %d ih %d t %d ishull %d\n", v->indexp, v->indexh, v->type, v->isHull?1:0);
|
|
|
|
out.Append( v->pos );
|
|
if(v->visited)
|
|
break;
|
|
|
|
overlay->SetStrokeColor( v->isHull ? RED : WHITE );
|
|
overlay->SetFillColor( v->isHull ? RED : WHITE );
|
|
overlay->SetGlyphSize( VECTOR2D( 200000, 200000 ));
|
|
//overlay->BitmapText( wxString::Format("%d", v->isHull ? v->indexh : v->indexp), v->pos, 0 );
|
|
|
|
|
|
v->visited = true;
|
|
|
|
if ( (n++) == 2000 ) // sanity check
|
|
break;
|
|
|
|
for( auto vn : v->neighbours )
|
|
{
|
|
printf(" ---> next ip %d ih %d t %d ishull %d\n",vn->indexp, vn->indexh, vn->type, vn->isHull?1:0);
|
|
}
|
|
|
|
|
|
if (v->type == OUTSIDE)
|
|
{
|
|
out.Append(v->pos);
|
|
for( auto vn : v->neighbours )
|
|
if( (vn->indexp > v->indexp) && vn->type != INSIDE )
|
|
{
|
|
v = vn;
|
|
break;
|
|
}
|
|
}
|
|
else if (v->type == ON_EDGE)
|
|
{
|
|
VERTEX* v_next = nullptr;
|
|
int best_dist = INT_MAX;
|
|
|
|
for( auto vn: v->neighbours)
|
|
{
|
|
if( vn->type == ON_EDGE && (vn->indexp == (v->indexp + 1) ) )
|
|
{
|
|
v_next = vn;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( !v_next )
|
|
{
|
|
for( auto vn: v->neighbours)
|
|
{
|
|
if( vn->type == OUTSIDE )
|
|
{
|
|
v_next = vn;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( !v_next )
|
|
{
|
|
for( auto vn: v->neighbours)
|
|
{
|
|
if ( v->type == ON_EDGE )
|
|
{
|
|
if( vn->indexh == ( (v->indexh + 1) % hnew.PointCount() ) )
|
|
{
|
|
v_next = vn;
|
|
//printf("E2\n");
|
|
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
v = v_next;
|
|
|
|
|
|
}
|
|
}
|
|
|
|
out.Append( v->pos );
|
|
|
|
aWalk = out;
|
|
|
|
return true;
|
|
}
|
|
|
|
int test2_main_func( int argc, char* argv[] )
|
|
{
|
|
auto frame = new PNS_LOG_VIEWER_FRAME(nullptr);
|
|
Pgm().App().SetTopWindow( frame ); // wxApp gets a face.
|
|
frame->Show();
|
|
|
|
overlay = frame->GetPanel()->DebugOverlay();
|
|
|
|
|
|
overlay->SetIsFill(false);
|
|
overlay->SetLineWidth(10000);
|
|
|
|
// auto hull = SHAPE_LINE_CHAIN( { VECTOR2I( 155977520, 128439216), VECTOR2I( 155639216, 128777520), VECTOR2I( 155160784, 128777520), VECTOR2I( 154822480, 128439216), VECTOR2I( 154822480, 97960784), VECTOR2I( 155160784, 97622480), VECTOR2I( 155639216, 97622480), VECTOR2I( 155977520, 97960784)}, true );
|
|
//auto path = SHAPE_LINE_CHAIN( { VECTOR2I( 148981200, 102320000), VECTOR2I( 154822480, 102320000), VECTOR2I( 154822480, 98777520), VECTOR2I( 60977520, 98777520), VECTOR2I( 60977520, 127622480), VECTOR2I( 155639216, 127622480), VECTOR2I( 155977520, 127960784), VECTOR2I( 155977520, 128439216), VECTOR2I( 155639216, 128777520), VECTOR2I( 60160784, 128777520), VECTOR2I( 59822480, 128439216), VECTOR2I( 59822480, 97960784), VECTOR2I( 60160784, 97622480), VECTOR2I( 155639216, 97622480), VECTOR2I( 155977520, 97960784), VECTOR2I( 155977520, 102320000), VECTOR2I( 160208000, 102320000), VECTOR2I( 160462000, 102574000)}, false );
|
|
|
|
//auto path = SHAPE_LINE_CHAIN( { VECTOR2I( 112456000, 102726400), VECTOR2I( 112456000, 98560800), VECTOR2I( 112456000, 98827020)}, false );
|
|
//auto hull = SHAPE_LINE_CHAIN( { VECTOR2I( 155659720, 97572980), VECTOR2I( 156027020, 97940280), VECTOR2I( 156027020, 98459720), VECTOR2I( 155659720, 98827020), VECTOR2I( 60140280, 98827020), VECTOR2I( 59772980, 98459720), VECTOR2I( 59772980, 97940280), VECTOR2I( 60140280, 97572980)}, true );
|
|
|
|
//auto path = SHAPE_LINE_CHAIN( { VECTOR2I( 119364800, 100288000), VECTOR2I( 119364800, 97697200), VECTOR2I( 119364800, 97572980)}, false );
|
|
//auto hull = SHAPE_LINE_CHAIN( { VECTOR2I( 155659720, 97572980), VECTOR2I( 156027020, 97940280), VECTOR2I( 156027020, 98459720), VECTOR2I( 155659720, 98827020), VECTOR2I( 60140280, 98827020), VECTOR2I( 59772980, 98459720), VECTOR2I( 59772980, 97940280), VECTOR2I( 60140280, 97572980)}, true );
|
|
|
|
//auto path = SHAPE_LINE_CHAIN( { VECTOR2I( 119263200, 101253200), VECTOR2I( 119263200, 98827020), VECTOR2I( 61027020, 98827020), VECTOR2I( 61027020, 127572980), VECTOR2I( 154772980, 127572980), VECTOR2I( 154772980, 97940280), VECTOR2I( 155140280, 97572980), VECTOR2I( 155659720, 97572980), VECTOR2I( 156027020, 97940280), VECTOR2I( 156027020, 128459720), VECTOR2I( 155659720, 128827020), VECTOR2I( 60140280, 128827020), VECTOR2I( 59772980, 128459720), VECTOR2I( 59772980, 97940280), VECTOR2I( 60140280, 97572980), VECTOR2I( 119641420, 97572980), VECTOR2I( 121650800, 95563600)}, false );
|
|
//auto hull = SHAPE_LINE_CHAIN( { VECTOR2I( 155659720, 97572980), VECTOR2I( 156027020, 97940280), VECTOR2I( 156027020, 98459720), VECTOR2I( 155659720, 98827020), VECTOR2I( 60140280, 98827020), VECTOR2I( 59772980, 98459720), VECTOR2I( 59772980, 97940280), VECTOR2I( 60140280, 97572980)}, true );
|
|
|
|
// auto hull = SHAPE_LINE_CHAIN( { VECTOR2I( 96722489, 117694794), VECTOR2I( 97594794, 116822489), VECTOR2I( 99205206, 116822489), VECTOR2I( 100077511, 117694794), VECTOR2I( 100077511, 119305206), VECTOR2I( 99205206, 120177511), VECTOR2I( 97594794, 120177511), VECTOR2I( 96722489, 119305206)}, true );
|
|
// auto path = SHAPE_LINE_CHAIN( { VECTOR2I( 103400000, 118500000), VECTOR2I( 93400000, 118500000)}, false );
|
|
|
|
auto hull = SHAPE_LINE_CHAIN( { VECTOR2I( 66280505, 107710033), VECTOR2I( 65914967, 107344495), VECTOR2I( 65914967, 106827549), VECTOR2I( 66280505, 106462011), VECTOR2I( 74810033, 106462009), VECTOR2I( 75175571, 106827547), VECTOR2I( 75175571, 107344493), VECTOR2I( 74810033, 107710031)}, true );
|
|
auto path = SHAPE_LINE_CHAIN( { /*VECTOR2I( 143928480, 109445996), VECTOR2I( 111066480, 109445996), VECTOR2I( 106254391, 104633907), VECTOR2I( 105909001, 104633907), VECTOR2I( 105775094, 104500000),*/ VECTOR2I( 76250000, 104500000), VECTOR2I( 74287991, 106462009), VECTOR2I( 66280505, 106462011), VECTOR2I( 66012989, 106462011)}, false );
|
|
|
|
|
|
BOX2D bb ( path.BBox().GetPosition(), path.BBox().GetSize() );
|
|
|
|
frame->GetPanel()->GetView()->SetViewport(bb);
|
|
|
|
PNS::LINE l;
|
|
SHAPE_LINE_CHAIN path_pre, path_walk, path_post;
|
|
l.SetShape( path );
|
|
|
|
auto status = l.Walkaround( hull, path_walk, false );
|
|
printf("Stat: %d\n", status );
|
|
|
|
//printf("status: %d\n", walkaround2( path, hull, path_pre, path_walk,
|
|
// path_post, false ) );
|
|
|
|
overlay->SetLineWidth(200000.0);
|
|
overlay->SetStrokeColor( BLUE );
|
|
//overlay->Polyline( path_pre );
|
|
overlay->Polyline( path_walk );
|
|
//overlay->Polyline( path_post );
|
|
|
|
overlay->SetStrokeColor( WHITE );
|
|
overlay->SetLineWidth( 100000.0 );
|
|
overlay->Polyline( path );
|
|
|
|
overlay->SetStrokeColor( RED );
|
|
overlay->Polyline( hull );
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
#if 0
|
|
static bool registered3 = UTILITY_REGISTRY::Register( {
|
|
"test1",
|
|
"Test1",
|
|
test1_main_func,
|
|
} );
|
|
|
|
#endif
|
|
|
|
static bool registered4 = UTILITY_REGISTRY::Register( {
|
|
"test2",
|
|
"Test2",
|
|
test2_main_func,
|
|
} );
|
|
|
|
|