export_gencad.cpp File Reference

Export GenCAD 1.4 format. More...

#include <build_version.h>
#include <board.h>
#include <fp_shape.h>
#include <footprint.h>
#include <track.h>
#include <confirm.h>
#include <core/arraydim.h>
#include <dialogs/dialog_gencad_export_options.h>
#include <locale_io.h>
#include <macros.h>
#include <hash_eda.h>
#include <pcb_edit_frame.h>
#include <pcbnew_settings.h>
#include <pgm_base.h>
#include <project/project_file.h>
#include <wx/app.h>

Go to the source code of this file.

Functions
static bool	CreateHeaderInfoData (FILE *aFile, PCB_EDIT_FRAME *frame)
static void	CreateArtworksSection (FILE *aFile)
static void	CreateTracksInfoData (FILE *aFile, BOARD *aPcb)
static void	CreateBoardSection (FILE *aFile, BOARD *aPcb)
static void	CreateComponentsSection (FILE *aFile, BOARD *aPcb)
static void	CreateDevicesSection (FILE *aFile, BOARD *aPcb)
static void	CreateRoutesSection (FILE *aFile, BOARD *aPcb)
static void	CreateSignalsSection (FILE *aFile, BOARD *aPcb)
static void	CreateShapesSection (FILE *aFile, BOARD *aPcb)
static void	CreatePadsShapesSection (FILE *aFile, BOARD *aPcb)
static void	FootprintWriteShape (FILE *File, FOOTPRINT *aFootprint, const wxString &aShapeName)
static std::string	GenCADLayerName (int aCuCount, PCB_LAYER_ID aId)
static std::string	GenCADLayerNameFlipped (int aCuCount, PCB_LAYER_ID aId)
static wxString	escapeString (const wxString &aString)
static std::string	fmt_mask (LSET aSet)
static const wxString	getShapeName (FOOTPRINT *aFootprint)
static double	MapXTo (int aX)
static double	MapYTo (int aY)
static bool	ViaSort (const VIA *aPadref, const VIA *aPadcmp)
static size_t	hashFootprint (const FOOTPRINT *aFootprint)
	Compute hashes for footprints without taking into account their position, rotation or layer. More...

Variables
static const PCB_LAYER_ID	gc_seq []
static bool	flipBottomPads
static bool	uniquePins
static bool	individualShapes
static bool	storeOriginCoords
static int	GencadOffsetX
static int	GencadOffsetY
static std::map< FOOTPRINT *, int >	componentShapes
static std::map< int, wxString >	shapeNames
static const double	SCALE_FACTOR = 1000.0 * IU_PER_MILS

Detailed Description

Export GenCAD 1.4 format.

Definition in file export_gencad.cpp.

Function Documentation

CreateArtworksSection()

static void CreateArtworksSection ( FILE *  aFile )

static

Definition at line 349 of file export_gencad.cpp.

{
    /* The artworks section is empty */
    fputs( "$ARTWORKS\n", aFile );
    fputs( "$ENDARTWORKS\n\n", aFile );
}

Referenced by PCB_EDIT_FRAME::ExportToGenCAD().

CreateBoardSection()

static void CreateBoardSection ( FILE *  aFile, BOARD *  aPcb  )

static

Definition at line 1089 of file export_gencad.cpp.

{
    fputs( "$BOARD\n", aFile );

    // Extract the board edges
    for( BOARD_ITEM* drawing : aPcb->Drawings() )
    {
        if( drawing->Type() == PCB_SHAPE_T )
        {
            PCB_SHAPE* drawseg = static_cast<PCB_SHAPE*>( drawing );

            if( drawseg->GetLayer() == Edge_Cuts )
            {
                // XXX GenCAD supports arc boundaries but I've seen nothing that reads them
                fprintf( aFile, "LINE %g %g %g %g\n",
                         MapXTo( drawseg->GetStart().x ), MapYTo( drawseg->GetStart().y ),
                         MapXTo( drawseg->GetEnd().x ), MapYTo( drawseg->GetEnd().y ) );
            }
        }
    }

    fputs( "$ENDBOARD\n\n", aFile );
}

References BOARD::Drawings(), Edge_Cuts, PCB_SHAPE::GetEnd(), BOARD_ITEM::GetLayer(), PCB_SHAPE::GetStart(), MapXTo(), MapYTo(), and PCB_SHAPE_T.

Referenced by PCB_EDIT_FRAME::ExportToGenCAD().

CreateComponentsSection()

static void CreateComponentsSection ( FILE *  aFile, BOARD *  aPcb  )

static

Definition at line 807 of file export_gencad.cpp.

{
    fputs( "$COMPONENTS\n", aFile );

    int cu_count = aPcb->GetCopperLayerCount();

    for( FOOTPRINT* footprint : aPcb->Footprints() )
    {
        const char*   mirror;
        const char*   flip;
        double        fp_orient = footprint->GetOrientation();

        if( footprint->GetFlag() )
        {
            mirror = "MIRRORX";
            flip   = "FLIP";
            NEGATE_AND_NORMALIZE_ANGLE_POS( fp_orient );
        }
        else
        {
            mirror = "0";
            flip   = "0";
        }

        fprintf( aFile, "\nCOMPONENT \"%s\"\n",
                 TO_UTF8( escapeString( footprint->GetReference() ) ) );
        fprintf( aFile, "DEVICE \"DEV_%s\"\n",
                 TO_UTF8( escapeString( getShapeName( footprint ) ) ) );
        fprintf( aFile, "PLACE %g %g\n",
                 MapXTo( footprint->GetPosition().x ),
                 MapYTo( footprint->GetPosition().y ) );
        fprintf( aFile, "LAYER %s\n",
                 footprint->GetFlag() ? "BOTTOM" : "TOP" );
        fprintf( aFile, "ROTATION %g\n",
                 fp_orient / 10.0 );
        fprintf( aFile, "SHAPE \"%s\" %s %s\n",
                 TO_UTF8( escapeString( getShapeName( footprint ) ) ),
                 mirror, flip );

        // Text on silk layer: RefDes and value (are they actually useful?)
        for( FP_TEXT* textItem : { &footprint->Reference(), &footprint->Value() } )
        {
            double txt_orient = textItem->GetTextAngle();
            std::string layer = GenCADLayerName( cu_count, footprint->GetFlag() ? B_SilkS : F_SilkS );

            fprintf( aFile, "TEXT %g %g %g %g %s %s \"%s\"",
                     textItem->GetPos0().x / SCALE_FACTOR,
                    -textItem->GetPos0().y / SCALE_FACTOR,
                     textItem->GetTextWidth() / SCALE_FACTOR,
                     txt_orient / 10.0,
                     mirror,
                     layer.c_str(),
                     TO_UTF8( escapeString( textItem->GetText() ) ) );

            // Please note, the width is approx
            fprintf( aFile, " 0 0 %g %g\n",
                     ( textItem->GetTextWidth() * textItem->GetLength() ) / SCALE_FACTOR,
                     textItem->GetTextHeight() / SCALE_FACTOR );
        }

        // The SHEET is a 'generic description' for referencing the component
        fprintf( aFile, "SHEET \"RefDes: %s, Value: %s\"\n",
                 TO_UTF8( footprint->GetReference() ),
                 TO_UTF8( footprint->GetValue() ) );
    }

    fputs( "$ENDCOMPONENTS\n\n", aFile );
}

References B_SilkS, escapeString(), F_SilkS, BOARD::Footprints(), GenCADLayerName(), BOARD::GetCopperLayerCount(), getShapeName(), MapXTo(), MapYTo(), NEGATE_AND_NORMALIZE_ANGLE_POS(), SCALE_FACTOR, and TO_UTF8.

Referenced by PCB_EDIT_FRAME::ExportToGenCAD().

CreateDevicesSection()

static void CreateDevicesSection ( FILE *  aFile, BOARD *  aPcb  )

static

Definition at line 1057 of file export_gencad.cpp.

{
    std::set<wxString> emitted;
    fputs( "$DEVICES\n", aFile );

    for( const auto& componentShape : componentShapes )
    {
        const wxString& shapeName = shapeNames[componentShape.second];
        bool newDevice;
        std::tie( std::ignore, newDevice ) = emitted.insert( shapeName );

        if( !newDevice )        // do not repeat device definitions
            continue;

        const FOOTPRINT* footprint = componentShape.first;

        fprintf( aFile, "\nDEVICE \"DEV_%s\"\n", TO_UTF8( escapeString( shapeName ) ) );

        fprintf( aFile, "PART \"%s\"\n",
                 TO_UTF8( escapeString( footprint->GetValue() ) ) );

        fprintf( aFile, "PACKAGE \"%s\"\n",
                 TO_UTF8( escapeString( footprint->GetFPID().Format() ) ) );
    }

    fputs( "$ENDDEVICES\n\n", aFile );
}

References componentShapes, escapeString(), LIB_ID::Format(), FOOTPRINT::GetFPID(), FOOTPRINT::GetValue(), shapeNames, and TO_UTF8.

Referenced by PCB_EDIT_FRAME::ExportToGenCAD().

CreateHeaderInfoData()

static bool CreateHeaderInfoData ( FILE *  aFile, PCB_EDIT_FRAME *  frame  )

static

Definition at line 926 of file export_gencad.cpp.

{
    wxString msg;
    BOARD*   board = aFrame->GetBoard();

    fputs( "$HEADER\n", aFile );
    fputs( "GENCAD 1.4\n", aFile );

    // Please note: GenCAD syntax requires quoted strings if they can contain spaces
    msg.Printf( wxT( "USER \"%s %s\"\n" ),
                Pgm().App().GetAppName(),
                GetBuildVersion() );
    fputs( TO_UTF8( msg ), aFile );

    msg = wxT( "DRAWING \"" ) + board->GetFileName() + wxT( "\"\n" );
    fputs( TO_UTF8( msg ), aFile );

    const TITLE_BLOCK&  tb = aFrame->GetTitleBlock();

    msg = wxT( "REVISION \"" ) + tb.GetRevision() + wxT( " " ) + tb.GetDate() + wxT( "\"\n" );

    fputs( TO_UTF8( msg ), aFile );
    fputs( "UNITS INCH\n", aFile );

    // giving 0 as the argument to Map{X,Y}To returns the scaled origin point
    msg.Printf( wxT( "ORIGIN %g %g\n" ),
                storeOriginCoords ? MapXTo( 0 ) : 0,
                storeOriginCoords ? MapYTo( 0 ) : 0 );
    fputs( TO_UTF8( msg ), aFile );

    fputs( "INTERTRACK 0\n", aFile );
    fputs( "$ENDHEADER\n\n", aFile );

    return true;
}

References PCB_BASE_FRAME::GetBoard(), GetBuildVersion(), TITLE_BLOCK::GetDate(), BOARD::GetFileName(), TITLE_BLOCK::GetRevision(), PCB_BASE_FRAME::GetTitleBlock(), MapXTo(), MapYTo(), Pgm(), storeOriginCoords, and TO_UTF8.

Referenced by PCB_EDIT_FRAME::ExportToGenCAD().

CreatePadsShapesSection()

static void CreatePadsShapesSection ( FILE *  aFile, BOARD *  aPcb  )

static

Definition at line 359 of file export_gencad.cpp.

{
    std::vector<PAD*> padstacks;
    std::vector<VIA*> vias;
    std::vector<VIA*> viastacks;

    padstacks.resize( 1 ); // We count pads from 1

    // The master layermask (i.e. the enabled layers) for padstack generation
    LSET    master_layermask = aPcb->GetDesignSettings().GetEnabledLayers();
    int     cu_count = aPcb->GetCopperLayerCount();

    fputs( "$PADS\n", aFile );

    // Enumerate and sort the pads

    std::vector<PAD*> pads = aPcb->GetPads();
    std::sort( pads.begin(), pads.end(), []( const PAD* a, const PAD* b )
                                         {
                                             return PAD::Compare( a, b ) < 0;
                                         } );


    // The same for vias
    for( TRACK* track : aPcb->Tracks() )
    {
        if( VIA* via = dyn_cast<VIA*>( track ) )
            vias.push_back( via );
    }

    std::sort( vias.begin(), vias.end(), ViaSort );
    vias.erase( std::unique( vias.begin(), vias.end(), []( const VIA* a, const VIA* b )
                                                       {
                                                           return ViaSort( a, b ) == false;
                                                       } ),
            vias.end() );

    // Emit vias pads

    for( VIA* via : vias )
    {
        viastacks.push_back( via );
        fprintf( aFile, "PAD V%d.%d.%s ROUND %g\nCIRCLE 0 0 %g\n",
                 via->GetWidth(), via->GetDrillValue(),
                 fmt_mask( via->GetLayerSet() & master_layermask ).c_str(),
                 via->GetDrillValue() / SCALE_FACTOR,
                 via->GetWidth() / (SCALE_FACTOR * 2) );
    }

    // Emit component pads
    PAD* old_pad = 0;
    int  pad_name_number = 0;

    for( unsigned i = 0; i<pads.size(); ++i )
    {
        PAD* pad = pads[i];
        const wxPoint& off = pad->GetOffset();

        pad->SetSubRatsnest( pad_name_number );

        if( old_pad && 0 == PAD::Compare( old_pad, pad ) )
            continue;  // already created

        old_pad = pad;

        pad_name_number++;
        pad->SetSubRatsnest( pad_name_number );

        fprintf( aFile, "PAD P%d", pad->GetSubRatsnest() );

        padstacks.push_back( pad ); // Will have its own padstack later
        int dx = pad->GetSize().x / 2;
        int dy = pad->GetSize().y / 2;

        switch( pad->GetShape() )
        {
        default:
            wxASSERT_MSG( false, "Pad type not implemented" );
            KI_FALLTHROUGH;

        case PAD_SHAPE_CIRCLE:
            fprintf( aFile, " ROUND %g\n",
                     pad->GetDrillSize().x / SCALE_FACTOR );
            /* Circle is center, radius */
            fprintf( aFile, "CIRCLE %g %g %g\n",
                     off.x / SCALE_FACTOR,
                     -off.y / SCALE_FACTOR,
                     pad->GetSize().x / (SCALE_FACTOR * 2) );
            break;

        case PAD_SHAPE_RECT:
            fprintf( aFile, " RECTANGULAR %g\n",
                     pad->GetDrillSize().x / SCALE_FACTOR );

            // Rectangle is begin, size *not* begin, end!
            fprintf( aFile, "RECTANGLE %g %g %g %g\n",
                     (-dx + off.x ) / SCALE_FACTOR,
                     (-dy - off.y ) / SCALE_FACTOR,
                     dx / (SCALE_FACTOR / 2), dy / (SCALE_FACTOR / 2) );
            break;

        case PAD_SHAPE_ROUNDRECT:
        case PAD_SHAPE_OVAL:
            {
                const wxSize& size = pad->GetSize();
                int radius;

                if( pad->GetShape() == PAD_SHAPE_ROUNDRECT )
                    radius = pad->GetRoundRectCornerRadius();
                else
                    radius = std::min( size.x, size.y ) / 2;

                int lineX = size.x / 2 - radius;
                int lineY = size.y / 2 - radius;

                fprintf( aFile, " POLYGON %g\n", pad->GetDrillSize().x / SCALE_FACTOR );

                // bottom left arc
                fprintf( aFile, "ARC %g %g %g %g %g %g\n",
                        ( off.x - lineX - radius ) / SCALE_FACTOR,
                        ( -off.y - lineY ) / SCALE_FACTOR, ( off.x - lineX ) / SCALE_FACTOR,
                        ( -off.y - lineY - radius ) / SCALE_FACTOR,
                        ( off.x - lineX ) / SCALE_FACTOR, ( -off.y - lineY ) / SCALE_FACTOR );

                // bottom line
                if( lineX > 0 )
                {
                    fprintf( aFile, "LINE %g %g %g %g\n",
                            ( off.x - lineX ) / SCALE_FACTOR,
                            ( -off.y - lineY - radius ) / SCALE_FACTOR,
                            ( off.x + lineX ) / SCALE_FACTOR,
                            ( -off.y - lineY - radius ) / SCALE_FACTOR );
                }

                // bottom right arc
                fprintf( aFile, "ARC %g %g %g %g %g %g\n",
                        ( off.x + lineX ) / SCALE_FACTOR,
                        ( -off.y - lineY - radius ) / SCALE_FACTOR,
                        ( off.x + lineX + radius ) / SCALE_FACTOR,
                        ( -off.y - lineY ) / SCALE_FACTOR, ( off.x + lineX ) / SCALE_FACTOR,
                        ( -off.y - lineY ) / SCALE_FACTOR );

                // right line
                if( lineY > 0 )
                {
                    fprintf( aFile, "LINE %g %g %g %g\n",
                            ( off.x + lineX + radius ) / SCALE_FACTOR,
                            ( -off.y + lineY ) / SCALE_FACTOR,
                            ( off.x + lineX + radius ) / SCALE_FACTOR,
                            ( -off.y - lineY ) / SCALE_FACTOR );
                }

                // top right arc
                fprintf( aFile, "ARC %g %g %g %g %g %g\n",
                        ( off.x + lineX + radius ) / SCALE_FACTOR,
                        ( -off.y + lineY ) / SCALE_FACTOR, ( off.x + lineX ) / SCALE_FACTOR,
                        ( -off.y + lineY + radius ) / SCALE_FACTOR,
                        ( off.x + lineX ) / SCALE_FACTOR, ( -off.y + lineY ) / SCALE_FACTOR );

                // top line
                if( lineX > 0 )
                {
                    fprintf( aFile, "LINE %g %g %g %g\n"
                            , ( off.x - lineX ) / SCALE_FACTOR,
                            ( -off.y + lineY + radius ) / SCALE_FACTOR,
                            ( off.x + lineX ) / SCALE_FACTOR,
                            ( -off.y + lineY + radius ) / SCALE_FACTOR );
                }

                // top left arc
                fprintf( aFile, "ARC %g %g %g %g %g %g\n",
                        ( off.x - lineX ) / SCALE_FACTOR,
                        ( -off.y + lineY + radius ) / SCALE_FACTOR,
                        ( off.x - lineX - radius ) / SCALE_FACTOR,
                        ( -off.y + lineY ) / SCALE_FACTOR, ( off.x - lineX ) / SCALE_FACTOR,
                        ( -off.y + lineY ) / SCALE_FACTOR );

                // left line
                if( lineY > 0 )
                {
                    fprintf( aFile, "LINE %g %g %g %g\n",
                            ( off.x - lineX - radius ) / SCALE_FACTOR,
                            ( -off.y - lineY ) / SCALE_FACTOR,
                            ( off.x - lineX - radius ) / SCALE_FACTOR,
                            ( -off.y + lineY ) / SCALE_FACTOR );
                }
            }
            break;

        case PAD_SHAPE_TRAPEZOID:
            {
                fprintf( aFile, " POLYGON %g\n", pad->GetDrillSize().x / SCALE_FACTOR );

                int  ddx = pad->GetDelta().x / 2;
                int  ddy = pad->GetDelta().y / 2;

                wxPoint poly[4];
                poly[0] = wxPoint( -dx + ddy,  dy + ddx );
                poly[1] = wxPoint(  dx - ddy,  dy - ddx );
                poly[2] = wxPoint(  dx + ddy, -dy + ddx );
                poly[3] = wxPoint( -dx - ddy, -dy - ddx );

                for( int cur = 0; cur < 4; ++cur )
                {
                    int next = ( cur + 1 ) % 4;
                    fprintf( aFile, "LINE %g %g %g %g\n",
                            ( off.x + poly[cur].x ) / SCALE_FACTOR,
                            ( -off.y - poly[cur].y ) / SCALE_FACTOR,
                            ( off.x + poly[next].x ) / SCALE_FACTOR,
                            ( -off.y - poly[next].y ) / SCALE_FACTOR );
                }
            }
            break;

        case PAD_SHAPE_CUSTOM:
            {
                fprintf( aFile, " POLYGON %g\n", pad->GetDrillSize().x / SCALE_FACTOR );

                SHAPE_POLY_SET outline;
                pad->MergePrimitivesAsPolygon( &outline, UNDEFINED_LAYER );

                for( int jj = 0; jj < outline.OutlineCount(); ++jj )
                {
                    const SHAPE_LINE_CHAIN& poly = outline.COutline( jj );
                    int pointCount = poly.PointCount();

                    for( int ii = 0; ii < pointCount; ii++ )
                    {
                        int next = ( ii + 1 ) % pointCount;
                        fprintf( aFile, "LINE %g %g %g %g\n",
                                ( off.x + poly.CPoint( ii ).x ) / SCALE_FACTOR,
                                ( -off.y - poly.CPoint( ii ).y ) / SCALE_FACTOR,
                                ( off.x + poly.CPoint( next ).x ) / SCALE_FACTOR,
                                ( -off.y - poly.CPoint( next ).y ) / SCALE_FACTOR );
                    }
                }
            }
            break;
        }
    }

    fputs( "\n$ENDPADS\n\n", aFile );

    // Now emit the padstacks definitions, using the combined layer masks
    fputs( "$PADSTACKS\n", aFile );

    // Via padstacks
    for( unsigned i = 0; i < viastacks.size(); i++ )
    {
        VIA* via = viastacks[i];

        LSET mask = via->GetLayerSet() & master_layermask;

        fprintf( aFile, "PADSTACK VIA%d.%d.%s %g\n",
                 via->GetWidth(), via->GetDrillValue(),
                 fmt_mask( mask ).c_str(),
                 via->GetDrillValue() / SCALE_FACTOR );

        for( LSEQ seq = mask.Seq( gc_seq, arrayDim( gc_seq ) );  seq;  ++seq )
        {
            PCB_LAYER_ID layer = *seq;

            fprintf( aFile, "PAD V%d.%d.%s %s 0 0\n",
                    via->GetWidth(), via->GetDrillValue(),
                    fmt_mask( mask ).c_str(),
                    GenCADLayerName( cu_count, layer ).c_str()
                    );
        }
    }

    /* Component padstacks
     *  Older versions of CAM350 don't apply correctly the FLIP semantics for
     *  padstacks, i.e. doesn't swap the top and bottom layers... so I need to
     *  define the shape as MIRRORX and define a separate 'flipped' padstack...
     *  until it appears yet another noncompliant importer */
    for( unsigned i = 1; i < padstacks.size(); i++ )
    {
        PAD* pad = padstacks[i];

        // Straight padstack
        fprintf( aFile, "PADSTACK PAD%u %g\n", i, pad->GetDrillSize().x / SCALE_FACTOR );

        LSET pad_set = pad->GetLayerSet() & master_layermask;

        // the special gc_seq
        for( LSEQ seq = pad_set.Seq( gc_seq, arrayDim( gc_seq ) );  seq;  ++seq )
        {
            PCB_LAYER_ID layer = *seq;

            fprintf( aFile, "PAD P%u %s 0 0\n", i, GenCADLayerName( cu_count, layer ).c_str() );
        }

        // Flipped padstack
        if( flipBottomPads )
        {
            fprintf( aFile, "PADSTACK PAD%uF %g\n", i, pad->GetDrillSize().x / SCALE_FACTOR );

            // the normal PCB_LAYER_ID sequence is inverted from gc_seq[]
            for( LSEQ seq = pad_set.Seq();  seq;  ++seq )
            {
                PCB_LAYER_ID layer = *seq;

                fprintf( aFile, "PAD P%u %s 0 0\n", i, GenCADLayerNameFlipped( cu_count, layer ).c_str() );
            }
        }
    }

    fputs( "$ENDPADSTACKS\n\n", aFile );
}

References arrayDim(), PAD::Compare(), SHAPE_LINE_CHAIN::CPoint(), flipBottomPads, fmt_mask(), gc_seq, GenCADLayerName(), GenCADLayerNameFlipped(), BOARD::GetCopperLayerCount(), BOARD::GetDesignSettings(), BOARD_DESIGN_SETTINGS::GetEnabledLayers(), BOARD::GetPads(), KI_FALLTHROUGH, next(), pad, PAD_SHAPE_CIRCLE, PAD_SHAPE_CUSTOM, PAD_SHAPE_OVAL, PAD_SHAPE_RECT, PAD_SHAPE_ROUNDRECT, PAD_SHAPE_TRAPEZOID, SHAPE_LINE_CHAIN::PointCount(), SCALE_FACTOR, LSET::Seq(), BOARD::Tracks(), UNDEFINED_LAYER, via, ViaSort(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by PCB_EDIT_FRAME::ExportToGenCAD().

CreateRoutesSection()

static void CreateRoutesSection ( FILE *  aFile, BOARD *  aPcb  )

static

Definition at line 972 of file export_gencad.cpp.

{
    int     vianum = 1;
    int     old_netcode, old_width, old_layer;
    LSET    master_layermask = aPcb->GetDesignSettings().GetEnabledLayers();

    int     cu_count = aPcb->GetCopperLayerCount();

    TRACKS tracks( aPcb->Tracks() );
    std::sort( tracks.begin(), tracks.end(),
            []( const TRACK* a, const TRACK* b )
            {
                if( a->GetNetCode() == b->GetNetCode() )
                {
                    if( a->GetWidth() == b->GetWidth() )
                        return ( a->GetLayer() < b->GetLayer() );

                    return ( a->GetWidth() < b->GetWidth() );
                }

                return ( a->GetNetCode() < b->GetNetCode() );
            } );

    fputs( "$ROUTES\n", aFile );

    old_netcode = -1; old_width = -1; old_layer = -1;

    for( TRACK* track : tracks )
    {
        if( old_netcode != track->GetNetCode() )
        {
            old_netcode = track->GetNetCode();
            NETINFO_ITEM* net = track->GetNet();
            wxString      netname;

            if( net && (net->GetNetname() != wxEmptyString) )
                netname = net->GetNetname();
            else
                netname = wxT( "_noname_" );

            fprintf( aFile, "ROUTE \"%s\"\n", TO_UTF8( escapeString( netname ) ) );
        }

        if( old_width != track->GetWidth() )
        {
            old_width = track->GetWidth();
            fprintf( aFile, "TRACK TRACK%d\n", track->GetWidth() );
        }

        if( track->Type() == PCB_TRACE_T )
        {
            if( old_layer != track->GetLayer() )
            {
                old_layer = track->GetLayer();
                fprintf( aFile, "LAYER %s\n",
                        GenCADLayerName( cu_count, track->GetLayer() ).c_str() );
            }

            fprintf( aFile, "LINE %g %g %g %g\n",
                    MapXTo( track->GetStart().x ), MapYTo( track->GetStart().y ),
                    MapXTo( track->GetEnd().x ), MapYTo( track->GetEnd().y ) );
        }

        if( track->Type() == PCB_VIA_T )
        {
            const VIA* via = static_cast<const VIA*>(track);

            LSET vset = via->GetLayerSet() & master_layermask;

            fprintf( aFile, "VIA VIA%d.%d.%s %g %g ALL %g via%d\n",
                     via->GetWidth(), via->GetDrillValue(),
                     fmt_mask( vset ).c_str(),
                     MapXTo( via->GetStart().x ), MapYTo( via->GetStart().y ),
                     via->GetDrillValue() / SCALE_FACTOR, vianum++ );
        }
    }

    fputs( "$ENDROUTES\n\n", aFile );
}

References escapeString(), fmt_mask(), GenCADLayerName(), BOARD::GetCopperLayerCount(), BOARD::GetDesignSettings(), BOARD_DESIGN_SETTINGS::GetEnabledLayers(), BOARD_ITEM::GetLayer(), BOARD_CONNECTED_ITEM::GetNetCode(), NETINFO_ITEM::GetNetname(), TRACK::GetWidth(), MapXTo(), MapYTo(), PCB_TRACE_T, PCB_VIA_T, SCALE_FACTOR, TO_UTF8, BOARD::Tracks(), via, and vset().

Referenced by PCB_EDIT_FRAME::ExportToGenCAD().

CreateShapesSection()

static void CreateShapesSection ( FILE *  aFile, BOARD *  aPcb  )

static

Definition at line 691 of file export_gencad.cpp.

{
    const char* layer;
    wxString    pinname;
    const char* mirror = "0";
    std::map<wxString, size_t> shapes;

    fputs( "$SHAPES\n", aFile );

    for( FOOTPRINT* footprint : aPcb->Footprints() )
    {
        if( !individualShapes )
        {
            // Check if such shape has been already generated, and if so - reuse it
            // It is necessary to compute hash (i.e. check all children objects) as
            // certain components instances might have been modified on the board.
            // In such case the shape will be different despite the same LIB_ID.
            wxString shapeName = footprint->GetFPID().Format();

            auto shapeIt = shapes.find( shapeName );
            size_t modHash = hashFootprint( footprint );

            if( shapeIt != shapes.end() )
            {
                if( modHash != shapeIt->second )
                {
                    // there is an entry for this footprint, but it has a modified shape,
                    // so we need to create a new entry
                    wxString newShapeName;
                    int suffix = 0;

                    // find an unused name or matching entry
                    do
                    {
                        newShapeName = wxString::Format( "%s_%d", shapeName, suffix );
                        shapeIt = shapes.find( newShapeName );
                        ++suffix;
                    }
                    while( shapeIt != shapes.end() && shapeIt->second != modHash );

                    shapeName = newShapeName;
                }

                if( shapeIt != shapes.end() && modHash == shapeIt->second )
                {
                    // shape found, so reuse it
                    componentShapes[footprint] = modHash;
                    continue;
                }
            }

            // new shape
            componentShapes[footprint] = modHash;
            shapeNames[modHash] = shapeName;
            shapes[shapeName] = modHash;
            FootprintWriteShape( aFile, footprint, shapeName );
        }
        else // individual shape for each component
        {
            FootprintWriteShape( aFile, footprint, footprint->GetReference() );
        }

        // set of already emitted pins to check for duplicates
        std::set<wxString> pins;

        for( PAD* pad : footprint->Pads() )
        {
            /* Padstacks are defined using the correct layers for the pads, therefore to
             * all pads need to be marked as TOP to use the padstack information correctly.
             */
            layer = "TOP";
            pinname = pad->GetName();

            if( pinname.IsEmpty() )
                pinname = wxT( "none" );

            if( uniquePins )
            {
                int suffix = 0;
                wxString origPinname( pinname );

                auto it = pins.find( pinname );

                while( it != pins.end() )
                {
                    pinname = wxString::Format( "%s_%d", origPinname, suffix );
                    ++suffix;
                    it = pins.find( pinname );
                }

                pins.insert( pinname );
            }

            double orient = pad->GetOrientation() - footprint->GetOrientation();
            NORMALIZE_ANGLE_POS( orient );

            // Bottom side footprints use the flipped padstack
            fprintf( aFile, ( flipBottomPads && footprint->GetFlag() ) ?
                     "PIN \"%s\" PAD%dF %g %g %s %g %s\n" :
                     "PIN \"%s\" PAD%d %g %g %s %g %s\n",
                     TO_UTF8( escapeString( pinname ) ), pad->GetSubRatsnest(),
                     pad->GetPos0().x / SCALE_FACTOR,
                     -pad->GetPos0().y / SCALE_FACTOR,
                     layer, orient / 10.0, mirror );
        }
    }

    fputs( "$ENDSHAPES\n\n", aFile );
}

References componentShapes, escapeString(), flipBottomPads, BOARD::Footprints(), FootprintWriteShape(), Format(), hashFootprint(), individualShapes, NORMALIZE_ANGLE_POS(), pad, SCALE_FACTOR, shapeNames, TO_UTF8, and uniquePins.

Referenced by PCB_EDIT_FRAME::ExportToGenCAD().

CreateSignalsSection()

static void CreateSignalsSection ( FILE *  aFile, BOARD *  aPcb  )

static

Definition at line 879 of file export_gencad.cpp.

{
    wxString      msg;
    NETINFO_ITEM* net;
    int           NbNoConn = 1;

    fputs( "$SIGNALS\n", aFile );

    for( unsigned ii = 0; ii < aPcb->GetNetCount(); ii++ )
    {
        net = aPcb->FindNet( ii );

        if( net->GetNetname() == wxEmptyString ) // dummy netlist (no connection)
        {
            msg.Printf( "NoConnection%d", NbNoConn++ );
        }

        if( net->GetNetCode() <= 0 )  // dummy netlist (no connection)
            continue;

        msg = wxT( "SIGNAL \"" ) + escapeString( net->GetNetname() ) + "\"";

        fputs( TO_UTF8( msg ), aFile );
        fputs( "\n", aFile );

        for( FOOTPRINT* footprint : aPcb->Footprints() )
        {
            for( PAD* pad : footprint->Pads() )
            {
                if( pad->GetNetCode() != net->GetNetCode() )
                    continue;

                msg.Printf( wxT( "NODE \"%s\" \"%s\"" ),
                            escapeString( footprint->GetReference() ),
                            escapeString( pad->GetName() ) );

                fputs( TO_UTF8( msg ), aFile );
                fputs( "\n", aFile );
            }
        }
    }

    fputs( "$ENDSIGNALS\n\n", aFile );
}

References escapeString(), BOARD::FindNet(), BOARD::Footprints(), NETINFO_ITEM::GetNetCode(), BOARD::GetNetCount(), NETINFO_ITEM::GetNetname(), pad, and TO_UTF8.

Referenced by PCB_EDIT_FRAME::ExportToGenCAD().

CreateTracksInfoData()

static void CreateTracksInfoData ( FILE *  aFile, BOARD *  aPcb  )

static

Definition at line 1124 of file export_gencad.cpp.

{
    // Find thickness used for traces

    std::set<int> trackinfo;

    for( TRACK* track : aPcb->Tracks() )
        trackinfo.insert( track->GetWidth() );

    // Write data
    fputs( "$TRACKS\n", aFile );

    for( int size : trackinfo )
        fprintf( aFile, "TRACK TRACK%d %g\n", size, size / SCALE_FACTOR );

    fputs( "$ENDTRACKS\n\n", aFile );
}

References SCALE_FACTOR, and BOARD::Tracks().

Referenced by PCB_EDIT_FRAME::ExportToGenCAD().

escapeString()

static wxString escapeString ( const wxString &  aString )

static

Definition at line 165 of file export_gencad.cpp.

{
    wxString copy( aString );
    copy.Replace( "\"", "\\\"" );
    return copy;
}

References copy.

Referenced by CreateComponentsSection(), CreateDevicesSection(), CreateRoutesSection(), CreateShapesSection(), CreateSignalsSection(), and FootprintWriteShape().

fmt_mask()

static std::string fmt_mask ( LSET  aSet )

static

Definition at line 173 of file export_gencad.cpp.

{
    return StrPrintf( "%08x", (unsigned) ( aSet & LSET::AllCuMask() ).to_ulong() );
}

References LSET::AllCuMask(), and StrPrintf().

Referenced by CreatePadsShapesSection(), and CreateRoutesSection().

FootprintWriteShape()

static void FootprintWriteShape ( FILE *  File, FOOTPRINT *  aFootprint, const wxString &  aShapeName  )

static

Definition at line 1148 of file export_gencad.cpp.

{
    FP_SHAPE* shape;

    /* creates header: */
    fprintf( aFile, "\nSHAPE \"%s\"\n", TO_UTF8( escapeString( aShapeName ) ) );

    if( aFootprint->GetAttributes() & FP_THROUGH_HOLE )
        fprintf( aFile, "INSERT TH\n" );
    else
        fprintf( aFile, "INSERT SMD\n" );

    // Silk outline; wildly interpreted by various importers:
    // CAM350 read it right but only closed shapes
    // ProntoPlace double-flip it (at least the pads are correct)
    // GerberTool usually get it right...
    for( BOARD_ITEM* PtStruct : aFootprint->GraphicalItems() )
    {
        switch( PtStruct->Type() )
        {
        case PCB_FP_TEXT_T:

            // If we wanted to export text, this is not the correct section
            break;

        case PCB_FP_SHAPE_T:
            shape = (FP_SHAPE*) PtStruct;
            if( shape->GetLayer() == F_SilkS || shape->GetLayer() == B_SilkS )
            {
                switch( shape->GetShape() )
                {
                case S_SEGMENT:
                    fprintf( aFile, "LINE %g %g %g %g\n",
                             shape->m_Start0.x / SCALE_FACTOR,
                             -shape->m_Start0.y / SCALE_FACTOR,
                             shape->m_End0.x / SCALE_FACTOR,
                             -shape->m_End0.y / SCALE_FACTOR );
                    break;

                case S_RECT:
                {
                    fprintf( aFile, "LINE %g %g %g %g\n",
                             shape->m_Start0.x / SCALE_FACTOR,
                             -shape->m_Start0.y / SCALE_FACTOR,
                             shape->m_End0.x / SCALE_FACTOR,
                             -shape->m_Start0.y / SCALE_FACTOR );
                    fprintf( aFile, "LINE %g %g %g %g\n",
                             shape->m_End0.x / SCALE_FACTOR,
                             -shape->m_Start0.y / SCALE_FACTOR,
                             shape->m_End0.x / SCALE_FACTOR,
                             -shape->m_End0.y / SCALE_FACTOR );
                    fprintf( aFile, "LINE %g %g %g %g\n",
                             shape->m_End0.x / SCALE_FACTOR,
                             -shape->m_End0.y / SCALE_FACTOR,
                             shape->m_Start0.x / SCALE_FACTOR,
                             -shape->m_End0.y / SCALE_FACTOR );
                    fprintf( aFile, "LINE %g %g %g %g\n",
                             shape->m_Start0.x / SCALE_FACTOR,
                             -shape->m_End0.y / SCALE_FACTOR,
                             shape->m_Start0.x / SCALE_FACTOR,
                             -shape->m_Start0.y / SCALE_FACTOR );
                }
                    break;

                case S_CIRCLE:
                {
                    int radius = KiROUND( GetLineLength( shape->m_End0, shape->m_Start0 ) );
                    fprintf( aFile, "CIRCLE %g %g %g\n",
                             shape->m_Start0.x / SCALE_FACTOR,
                             -shape->m_Start0.y / SCALE_FACTOR,
                             radius / SCALE_FACTOR );
                    break;
                }

                case S_ARC:
                {
                    int arcendx, arcendy;
                    arcendx = shape->m_End0.x - shape->m_Start0.x;
                    arcendy = shape->m_End0.y - shape->m_Start0.y;
                    RotatePoint( &arcendx, &arcendy, -shape->GetAngle() );
                    arcendx += shape->GetStart0().x;
                    arcendy += shape->GetStart0().y;

                    fprintf( aFile, "ARC %g %g %g %g %g %g\n",
                             shape->m_End0.x / SCALE_FACTOR,
                             -shape->GetEnd0().y / SCALE_FACTOR,
                             arcendx / SCALE_FACTOR,
                             -arcendy / SCALE_FACTOR,
                             shape->GetStart0().x / SCALE_FACTOR,
                             -shape->GetStart0().y / SCALE_FACTOR );
                    break;
                }

                case S_POLYGON:
                    // Not exported (TODO)
                    break;

                default:
                    wxFAIL_MSG( wxString::Format( "Type Edge Module %d invalid.",
                                                  PtStruct->Type() ) );
                    break;
                }
            }
            break;

        default:
            break;
        }
    }
}

References B_SilkS, escapeString(), F_SilkS, Format(), FP_THROUGH_HOLE, PCB_SHAPE::GetAngle(), FOOTPRINT::GetAttributes(), FP_SHAPE::GetEnd0(), BOARD_ITEM::GetLayer(), GetLineLength(), PCB_SHAPE::GetShape(), FP_SHAPE::GetStart0(), FOOTPRINT::GraphicalItems(), KiROUND(), FP_SHAPE::m_End0, FP_SHAPE::m_Start0, PCB_FP_SHAPE_T, PCB_FP_TEXT_T, RotatePoint(), S_ARC, S_CIRCLE, S_POLYGON, S_RECT, S_SEGMENT, SCALE_FACTOR, and TO_UTF8.

Referenced by CreateShapesSection().

GenCADLayerName()

static std::string GenCADLayerName ( int  aCuCount, PCB_LAYER_ID  aId  )

static

Definition at line 64 of file export_gencad.cpp.

{
    if( IsCopperLayer( aId ) )
    {
        if( aId == F_Cu )
            return "TOP";
        else if( aId == B_Cu )
            return "BOTTOM";
        else if( aId <= 14 )
            return StrPrintf( "INNER%d", aCuCount - aId - 1 );
        else
            return StrPrintf( "LAYER%d", aId );
    }

    else
    {
        const char* txt;

        // using a switch to clearly show mapping & catch out of bounds index.
        switch( aId )
        {
        // Technicals
        case B_Adhes:   txt = "B.Adhes";                break;
        case F_Adhes:   txt = "F.Adhes";                break;
        case B_Paste:   txt = "SOLDERPASTE_BOTTOM";     break;
        case F_Paste:   txt = "SOLDERPASTE_TOP";        break;
        case B_SilkS:   txt = "SILKSCREEN_BOTTOM";      break;
        case F_SilkS:   txt = "SILKSCREEN_TOP";         break;
        case B_Mask:    txt = "SOLDERMASK_BOTTOM";      break;
        case F_Mask:    txt = "SOLDERMASK_TOP";         break;

        // Users
        case Dwgs_User: txt = "Dwgs.User";              break;
        case Cmts_User: txt = "Cmts.User";              break;
        case Eco1_User: txt = "Eco1.User";              break;
        case Eco2_User: txt = "Eco2.User";              break;
        case Edge_Cuts: txt = "Edge.Cuts";              break;
        case Margin:    txt = "Margin";                 break;

        // Footprint
        case F_CrtYd:   txt = "F_CrtYd";                break;
        case B_CrtYd:   txt = "B_CrtYd";                break;
        case F_Fab:     txt = "F_Fab";                  break;
        case B_Fab:     txt = "B_Fab";                  break;

        default:
            wxASSERT_MSG( 0, wxT( "aId UNEXPECTED" ) );
                        txt = "BAD-INDEX!";             break;
        }

        return txt;
    }
}

References B_Adhes, B_CrtYd, B_Cu, B_Fab, B_Mask, B_Paste, B_SilkS, Cmts_User, Dwgs_User, Eco1_User, Eco2_User, Edge_Cuts, F_Adhes, F_CrtYd, F_Cu, F_Fab, F_Mask, F_Paste, F_SilkS, IsCopperLayer(), Margin, and StrPrintf().

Referenced by CreateComponentsSection(), CreatePadsShapesSection(), CreateRoutesSection(), and GenCADLayerNameFlipped().

GenCADLayerNameFlipped()

static std::string GenCADLayerNameFlipped ( int  aCuCount, PCB_LAYER_ID  aId  )

static

Definition at line 156 of file export_gencad.cpp.

{
    if( 1<= aId && aId <= 14 )
        return StrPrintf(  "INNER%d", 14 - aId );

    return GenCADLayerName( aCuCount, aId );
}

References GenCADLayerName(), and StrPrintf().

Referenced by CreatePadsShapesSection().

getShapeName()

static const wxString getShapeName ( FOOTPRINT *  aFootprint )

static

Definition at line 191 of file export_gencad.cpp.

{
    static const wxString invalid( "invalid" );

    if( individualShapes )
        return aFootprint->GetReference();

    auto itShape = componentShapes.find( aFootprint );
    wxCHECK( itShape != componentShapes.end(), invalid );

    auto itName = shapeNames.find( itShape->second );
    wxCHECK( itName != shapeNames.end(), invalid );

    return itName->second;
}

References componentShapes, FOOTPRINT::GetReference(), individualShapes, and shapeNames.

Referenced by CreateComponentsSection().

hashFootprint()

static size_t hashFootprint ( const FOOTPRINT *  aFootprint )

static

Compute hashes for footprints without taking into account their position, rotation or layer.

Definition at line 671 of file export_gencad.cpp.

{
    size_t    ret = 0x11223344;
    constexpr int flags = HASH_FLAGS::HASH_POS | HASH_FLAGS::REL_COORD
                            | HASH_FLAGS::HASH_ROT | HASH_FLAGS::HASH_LAYER;

    for( BOARD_ITEM* i : aFootprint->GraphicalItems() )
        ret += hash_fp_item( i, flags );

    for( PAD* i : aFootprint->Pads() )
        ret += hash_fp_item( i, flags );

    return ret;
}

References FOOTPRINT::GraphicalItems(), hash_fp_item(), HASH_LAYER, HASH_POS, HASH_ROT, FOOTPRINT::Pads(), and REL_COORD.

Referenced by CreateShapesSection().

MapXTo()

static double MapXTo ( int  aX )

static

Definition at line 213 of file export_gencad.cpp.

{
    return (aX - GencadOffsetX) / SCALE_FACTOR;
}

References GencadOffsetX, and SCALE_FACTOR.

Referenced by CreateBoardSection(), CreateComponentsSection(), CreateHeaderInfoData(), and CreateRoutesSection().

MapYTo()

static double MapYTo ( int  aY )

static

Definition at line 219 of file export_gencad.cpp.

{
    return (GencadOffsetY - aY) / SCALE_FACTOR;
}

References GencadOffsetY, and SCALE_FACTOR.

Referenced by CreateBoardSection(), CreateComponentsSection(), CreateHeaderInfoData(), and CreateRoutesSection().

ViaSort()

static bool ViaSort ( const VIA *  aPadref, const VIA *  aPadcmp  )

static

Definition at line 333 of file export_gencad.cpp.

{
    if( aPadref->GetWidth() != aPadcmp->GetWidth() )
        return aPadref->GetWidth() < aPadcmp->GetWidth();

    if( aPadref->GetDrillValue() != aPadcmp->GetDrillValue() )
        return aPadref->GetDrillValue() < aPadcmp->GetDrillValue();

    if( aPadref->GetLayerSet() != aPadcmp->GetLayerSet() )
        return aPadref->GetLayerSet().FmtBin().compare( aPadcmp->GetLayerSet().FmtBin() ) < 0;

    return false;
}

References LSET::FmtBin(), VIA::GetDrillValue(), VIA::GetLayerSet(), and TRACK::GetWidth().

Referenced by CreatePadsShapesSection().

Variable Documentation

componentShapes

std::map<FOOTPRINT*, int> componentShapes

static

Definition at line 188 of file export_gencad.cpp.

Referenced by CreateDevicesSection(), CreateShapesSection(), PCB_EDIT_FRAME::ExportToGenCAD(), and getShapeName().

flipBottomPads

bool flipBottomPads

static

Definition at line 179 of file export_gencad.cpp.

Referenced by CreatePadsShapesSection(), CreateShapesSection(), and PCB_EDIT_FRAME::ExportToGenCAD().

gc_seq

const PCB_LAYER_ID gc_seq[]

static

Definition at line 119 of file export_gencad.cpp.

Referenced by CreatePadsShapesSection().

GencadOffsetX

int GencadOffsetX

static

Definition at line 185 of file export_gencad.cpp.

Referenced by PCB_EDIT_FRAME::ExportToGenCAD(), and MapXTo().

GencadOffsetY

int GencadOffsetY

static

Definition at line 185 of file export_gencad.cpp.

Referenced by PCB_EDIT_FRAME::ExportToGenCAD(), and MapYTo().

individualShapes

bool individualShapes

static

Definition at line 181 of file export_gencad.cpp.

Referenced by CreateShapesSection(), PCB_EDIT_FRAME::ExportToGenCAD(), and getShapeName().

SCALE_FACTOR

const double SCALE_FACTOR = 1000.0 * IU_PER_MILS

static

Definition at line 208 of file export_gencad.cpp.

Referenced by CreateComponentsSection(), CreatePadsShapesSection(), CreateRoutesSection(), CreateShapesSection(), CreateTracksInfoData(), FootprintWriteShape(), MapXTo(), and MapYTo().

shapeNames

std::map<int, wxString> shapeNames

static

Definition at line 189 of file export_gencad.cpp.

Referenced by CreateDevicesSection(), CreateShapesSection(), DIALOG_LIB_EDIT_PIN_TABLE::DIALOG_LIB_EDIT_PIN_TABLE(), PCB_EDIT_FRAME::ExportToGenCAD(), and getShapeName().

storeOriginCoords

bool storeOriginCoords

static

Definition at line 182 of file export_gencad.cpp.

Referenced by CreateHeaderInfoData(), and PCB_EDIT_FRAME::ExportToGenCAD().

uniquePins

bool uniquePins

static

Definition at line 180 of file export_gencad.cpp.

Referenced by CreateShapesSection(), and PCB_EDIT_FRAME::ExportToGenCAD().