haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
kicad/qa/pns/pns_log_viewer.cpp

1439 lines
41 KiB
C++
Raw Normal View History

qa: router debug/hack tool. Adds Tom's internal P&S debugging tool. This is a work in progress and the code is quite messy for the moment, but I can't keep it in private branches forever and waste time rebasing it. Note: experimental and *very unclean* code. Use at your own risk.
2021-01-20 18:36:05 +00:00
/*
* 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,
} );