pns_log_viewer.cpp File Reference

#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"

Go to the source code of this file.

Classes
class	PNS_LOG_VIEWER_FRAME
class	WX_SHAPE_TREE_ITEM_DATA

Macros
#define	ID_LIST_COPY   10001
#define	ID_LIST_SHOW_ALL   10002
#define	ID_LIST_SHOW_NONE   10003

Functions
static const COLOR4D	assignColor (int aStyle)
static BOARD *	loadBoard (const std::string &filename)
static void	expandAllChildren (wxTreeListCtrl *tree, const wxTreeListItem &item)
static bool	commonParallelProjection (SEG p, SEG n, SEG &pClip, SEG &nClip)
int	replay_main_func (int argc, char *argv[])
template<typename T1 , typename T2 >
std::map< T1, T2 >::iterator	findClosestKey (std::map< T1, T2 > &data, T1 key)
void	extractDiffPair (BOARD *aBoard, int net_p, int net_n)
static int	matchDpSuffix (const wxString &aNetName, wxString &aComplementNet, wxString &aBaseDpName)
static int	dpCoupledNet (BOARD *aBoard, int aNet)
void	extractAllDiffPairs (BOARD *aBoard)
bool	segmentCrossesHullBoundary (const SHAPE_LINE_CHAIN &hull, const SEG &seg)
bool	walkaround2 (SHAPE_LINE_CHAIN &aLine, SHAPE_LINE_CHAIN aObstacle, SHAPE_LINE_CHAIN &aPre, SHAPE_LINE_CHAIN &aWalk, SHAPE_LINE_CHAIN &aPost, bool aCw)
int	test2_main_func (int argc, char *argv[])

Variables
static bool	registered2
static std::shared_ptr< KIGFX::VIEW_OVERLAY >	overlay
static bool	registered4

Macro Definition Documentation

ID_LIST_COPY

#define ID_LIST_COPY   10001

Definition at line 45 of file pns_log_viewer.cpp.

ID_LIST_SHOW_ALL

#define ID_LIST_SHOW_ALL   10002

Definition at line 46 of file pns_log_viewer.cpp.

ID_LIST_SHOW_NONE

#define ID_LIST_SHOW_NONE   10003

Definition at line 47 of file pns_log_viewer.cpp.

Function Documentation

assignColor()

static const COLOR4D assignColor ( int  aStyle )

static

Definition at line 137 of file pns_log_viewer.cpp.

{
    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;
}

References color.

Referenced by PNS_LOG_VIEWER_FRAME::drawLoggedItems().

commonParallelProjection()

bool commonParallelProjection ( SEG  p, SEG  n, SEG &  pClip, SEG &  nClip  )

static

Definition at line 618 of file pns_log_viewer.cpp.

{
    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;
}

References SEG::A, SEG::B, SEG::LineProject(), rescale(), SEG::SquaredLength(), SEG::TCoef(), VECTOR2< T >::x, and VECTOR2< T >::y.

dpCoupledNet()

static int dpCoupledNet ( BOARD *  aBoard, int  aNet  )

static

Definition at line 1040 of file pns_log_viewer.cpp.

{
    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;
}

References dummy(), BOARD::FindNet(), NETINFO_ITEM::GetNetCode(), NETINFO_ITEM::GetNetname(), and matchDpSuffix().

Referenced by extractAllDiffPairs().

expandAllChildren()

static void expandAllChildren ( wxTreeListCtrl *  tree, const wxTreeListItem &  item  )

static

Definition at line 564 of file pns_log_viewer.cpp.

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

extractAllDiffPairs()

void extractAllDiffPairs

(

BOARD *

aBoard

)

Definition at line 1059 of file pns_log_viewer.cpp.

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

References dpCoupledNet(), extractDiffPair(), BOARD::FindNet(), NETINFO_LIST::GetNetCount(), BOARD::GetNetInfo(), and NETINFO_ITEM::GetNetname().

extractDiffPair()

void extractDiffPair	(	BOARD *	aBoard,
		int	net_p,
		int	net_n
	)

Definition at line 931 of file pns_log_viewer.cpp.

{
    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 );

                                    }
            }
        }

}

References PNS::commonParallelProjection(), PCB_ARC_T, PCB_TRACE_T, and BOARD::Tracks().

Referenced by extractAllDiffPairs().

findClosestKey()

template<typename T1 , typename T2 >

std::map<T1, T2>::iterator findClosestKey	(	std::map< T1, T2 > &	data,
		T1	key
	)

Definition at line 907 of file pns_log_viewer.cpp.

{
    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;
}

loadBoard()

static BOARD* loadBoard ( const std::string &  filename )

static

Definition at line 289 of file pns_log_viewer.cpp.

{
    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;
}

References _, Format(), NULL, and IO_ERROR::Problem().

matchDpSuffix()

static int matchDpSuffix ( const wxString &  aNetName, wxString &  aComplementNet, wxString &  aBaseDpName  )

static

Definition at line 981 of file pns_log_viewer.cpp.

{
    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;
}

Referenced by dpCoupledNet().

replay_main_func()

int replay_main_func	(	int	argc,
		char *	argv[]
	)

Definition at line 864 of file pns_log_viewer.cpp.

{
    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;
}

References PNS_LOG_FILE::Load().

segmentCrossesHullBoundary()

bool segmentCrossesHullBoundary	(	const SHAPE_LINE_CHAIN &	hull,
		const SEG &	seg
	)

Definition at line 1121 of file pns_log_viewer.cpp.

{
        for( int j = 0; j < hull.SegmentCount(); j++ )
        {
            auto sr = hull.CSegment(j);
        }
    

}

References SHAPE_LINE_CHAIN::CSegment(), and SHAPE_LINE_CHAIN::SegmentCount().

test2_main_func()

int test2_main_func	(	int	argc,
		char *	argv[]
	)

Definition at line 1361 of file pns_log_viewer.cpp.

{
    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;
}

References BLUE, overlay, path, Pgm(), RED, PNS::LINE::SetShape(), PNS::LINE::Walkaround(), and WHITE.

walkaround2()

bool walkaround2	(	SHAPE_LINE_CHAIN &	aLine,
		SHAPE_LINE_CHAIN	aObstacle,
		SHAPE_LINE_CHAIN &	aPre,
		SHAPE_LINE_CHAIN &	aWalk,
		SHAPE_LINE_CHAIN &	aPost,
		bool	aCw
	)

Definition at line 1131 of file pns_log_viewer.cpp.

{
    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;
}

References SHAPE_LINE_CHAIN::Append(), SHAPE_LINE_CHAIN::CPoint(), SHAPE_LINE_CHAIN::Find(), findVertex(), Format(), SHAPE_LINE_CHAIN::Intersect(), OUTSIDE, overlay, SHAPE_LINE_CHAIN::PointCount(), SHAPE_LINE_CHAIN_BASE::PointInside(), SHAPE_LINE_CHAIN_BASE::PointOnEdge(), RED, SHAPE_LINE_CHAIN::Reverse(), SHAPE_LINE_CHAIN::SegmentCount(), SHAPE_LINE_CHAIN::Split(), and WHITE.

Variable Documentation

overlay

std::shared_ptr<KIGFX::VIEW_OVERLAY> overlay

static

Definition at line 1119 of file pns_log_viewer.cpp.

Referenced by AUTOPLACE_TOOL::autoplace(), KIGFX::VIEW::MakeOverlay(), test::DRC_TEST_PROVIDER_DIFF_PAIR_COUPLING::Run(), test2_main_func(), and walkaround2().

registered2

bool registered2

static

Initial value:

= UTILITY_REGISTRY::Register( {
        "replay",
        "PNS Log Player",
        replay_main_func,
} )

Definition at line 894 of file pns_log_viewer.cpp.

registered4

bool registered4

static

Initial value:

= UTILITY_REGISTRY::Register( {
        "test2",
        "Test2",
        test2_main_func,
} )

Definition at line 1432 of file pns_log_viewer.cpp.