odb_feature.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 * Author: SYSUEric <[email protected]>.
 *
 * 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 3 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, see <https://www.gnu.org/licenses/>.
 */
 
#include "odb_feature.h"
 
#include <sstream>
#include <map>
 
#include <wx/log.h>
 
#include "footprint.h"
#include "pad.h"
#include "pcb_shape.h"
#include "odb_defines.h"
#include "pcb_track.h"
#include "pcb_textbox.h"
#include "pcb_table.h"
#include "pcb_barcode.h"
#include "pcb_dimension.h"
#include "zone.h"
#include "board.h"
#include "board_design_settings.h"
#include "geometry/eda_angle.h"
#include "geometry/shape_circle.h"
#include "geometry/shape_ellipse.h"
#include "geometry/shape_line_chain.h"
#include "geometry/shape_segment.h"
#include "geometry/shape_poly_set.h"
#include "odb_eda_data.h"
#include "pcb_io_odbpp.h"
#include <callback_gal.h>
#include <string_utils.h>
#include <trace_helpers.h>
 
 
void FEATURES_MANAGER::AddFeatureLine( const VECTOR2I& aStart, const VECTOR2I& aEnd,
                                       uint64_t aWidth )
{
    AddFeature<ODB_LINE>( ODB::AddXY( aStart ), ODB::AddXY( aEnd ),
                          AddCircleSymbol( ODB::SymDouble2String( aWidth ) ) );
}
 
 
void FEATURES_MANAGER::AddFeatureArc( const VECTOR2I& aStart, const VECTOR2I& aEnd,
                                      const VECTOR2I& aCenter, uint64_t aWidth,
                                      ODB_DIRECTION aDirection )
{
    AddFeature<ODB_ARC>( ODB::AddXY( aStart ), ODB::AddXY( aEnd ), ODB::AddXY( aCenter ),
                         AddCircleSymbol( ODB::SymDouble2String( aWidth ) ), aDirection );
}
 
 
void FEATURES_MANAGER::AddPadCircle( const VECTOR2I& aCenter, uint64_t aDiameter,
                                     const EDA_ANGLE& aAngle, bool aMirror,
                                     double aResize /*= 1.0 */ )
{
    AddFeature<ODB_PAD>( ODB::AddXY( aCenter ),
                         AddCircleSymbol( ODB::SymDouble2String( aDiameter ) ), aAngle, aMirror,
                         aResize );
}
 
 
bool FEATURES_MANAGER::AddContour( const SHAPE_POLY_SET& aPolySet, int aOutline /*= 0*/,
                                   FILL_T aFillType /*= FILL_T::FILLED_SHAPE*/ )
{
    // todo: args modify aPolySet.Polygon( aOutline ) instead of aPolySet
 
    if( aPolySet.OutlineCount() < ( aOutline + 1 ) )
        return false;
 
    AddFeatureSurface( aPolySet.Polygon( aOutline ), aFillType );
 
    return true;
}
 
 
void FEATURES_MANAGER::AddShape( const PCB_SHAPE& aShape, PCB_LAYER_ID aLayer )
{
    int stroke_width = aShape.GetWidth();
 
    switch( aShape.GetShape() )
    {
    case SHAPE_T::CIRCLE:
    {
        // GetRadius() can reach INT_MAX / 2 rounded up, which overflows a signed int when doubled
        int64_t  diameter = static_cast<int64_t>( aShape.GetRadius() ) * 2;
        VECTOR2I center = ODB::GetShapePosition( aShape );
 
        // The stroke straddles the radius, so in diameter terms the whole width comes off the
        // inner edge and goes onto the outer
        int64_t  innerDiameter = diameter - stroke_width;
        wxString outerDim = ODB::SymDouble2String( diameter + stroke_width );
 
        // donut_r has no spelling for a hole closed by its own stroke
        if( aShape.IsSolidFill() || innerDiameter <= 0 )
        {
            AddFeature<ODB_PAD>( ODB::AddXY( center ), AddCircleSymbol( outerDim ) );
        }
        else
        {
            AddFeature<ODB_PAD>( ODB::AddXY( center ),
                                 AddRoundDonutSymbol( outerDim,
                                                      ODB::SymDouble2String( innerDiameter ) ) );
        }
 
        break;
    }
 
    case SHAPE_T::RECTANGLE:
    {
        // ODB++ donut_rc symbols degenerate when the corner radius is smaller than half the
        // line width, and some viewers drop the feature entirely.  Emit the rectangle as a
        // filled pad for the fill (if any) plus four line segments for the stroke, matching
        // how a rectangle drawn with the line tool is exported.
        if( aShape.IsSolidFill() )
        {
            int      width = std::abs( aShape.GetRectangleWidth() );
            int      height = std::abs( aShape.GetRectangleHeight() );
            VECTOR2I center = ODB::GetShapePosition( aShape );
 
            AddFeature<ODB_PAD>( ODB::AddXY( center ),
                                 AddRectSymbol( ODB::SymDouble2String( width ),
                                                ODB::SymDouble2String( height ) ) );
        }
 
        if( stroke_width > 0 )
        {
            std::vector<VECTOR2I> corners = aShape.GetRectCorners();
 
            for( size_t ii = 0; ii < corners.size(); ++ii )
                AddFeatureLine( corners[ii], corners[( ii + 1 ) % corners.size()], stroke_width );
        }
 
        break;
    }
 
    case SHAPE_T::POLY:
    {
        int soldermask_min_thickness = 0;
 
        // TODO: check if soldermask_min_thickness should be Stroke width
 
        if( aLayer != UNDEFINED_LAYER && LSET( { F_Mask, B_Mask } ).Contains( aLayer ) )
            soldermask_min_thickness = stroke_width;
 
        int            maxError = m_board->GetDesignSettings().m_MaxError;
        SHAPE_POLY_SET poly_set;
 
        if( soldermask_min_thickness == 0 )
        {
            poly_set = aShape.GetPolyShape().CloneDropTriangulation();
            poly_set.Fracture();
        }
        else
        {
            SHAPE_POLY_SET initialPolys;
 
            // add shapes inflated by aMinThickness/2 in areas
            aShape.TransformShapeToPolygon( initialPolys, aLayer, 0, maxError, ERROR_OUTSIDE );
            aShape.TransformShapeToPolygon( poly_set, aLayer, soldermask_min_thickness / 2 - 1,
                                            maxError, ERROR_OUTSIDE );
 
            poly_set.Simplify();
            poly_set.Deflate( soldermask_min_thickness / 2 - 1,
                              CORNER_STRATEGY::CHAMFER_ALL_CORNERS, maxError );
            poly_set.BooleanAdd( initialPolys );
            poly_set.Fracture();
        }
 
        // ODB++ surface features can only represent closed polygons.  We add a surface for
        // the fill of the shape, if present, and add line segments for the outline, if present.
        if( aShape.IsSolidFill() )
        {
            for( int ii = 0; ii < poly_set.OutlineCount(); ++ii )
            {
                AddContour( poly_set, ii, FILL_T::FILLED_SHAPE );
 
                if( stroke_width != 0 )
                {
                    for( int jj = 0; jj < poly_set.COutline( ii ).SegmentCount(); ++jj )
                    {
                        const SEG& seg = poly_set.COutline( ii ).CSegment( jj );
                        AddFeatureLine( seg.A, seg.B, stroke_width );
                    }
                }
            }
        }
        else
        {
            for( int ii = 0; ii < poly_set.OutlineCount(); ++ii )
            {
                for( int jj = 0; jj < poly_set.COutline( ii ).SegmentCount(); ++jj )
                {
                    const SEG& seg = poly_set.COutline( ii ).CSegment( jj );
                    AddFeatureLine( seg.A, seg.B, stroke_width );
                }
            }
        }
 
        break;
    }
 
    case SHAPE_T::ARC:
    {
        ODB_DIRECTION dir = !aShape.IsClockwiseArc() ? ODB_DIRECTION::CW : ODB_DIRECTION::CCW;
 
        AddFeatureArc( aShape.GetStart(), aShape.GetEnd(), aShape.GetCenter(), stroke_width, dir );
        break;
    }
 
    case SHAPE_T::BEZIER:
    {
        const std::vector<VECTOR2I>& points = aShape.GetBezierPoints();
 
        for( size_t i = 0; i < points.size() - 1; i++ )
            AddFeatureLine( points[i], points[i + 1], stroke_width );
 
        break;
    }
 
    case SHAPE_T::SEGMENT:
        AddFeatureLine( aShape.GetStart(), aShape.GetEnd(), stroke_width );
        break;
 
    case SHAPE_T::ELLIPSE:
    {
        int maxError = m_board->GetDesignSettings().m_MaxError;
 
        SHAPE_ELLIPSE e( aShape.GetEllipseCenter(), aShape.GetEllipseMajorRadius(), aShape.GetEllipseMinorRadius(),
                         aShape.GetEllipseRotation() );
 
        SHAPE_LINE_CHAIN chain = e.ConvertToPolyline( maxError );
        chain.SetClosed( true );
 
        if( aShape.IsSolidFill() )
        {
            SHAPE_POLY_SET poly_set;
            poly_set.AddOutline( chain );
            poly_set.Fracture();
 
            for( int ii = 0; ii < poly_set.OutlineCount(); ++ii )
                AddContour( poly_set, ii, FILL_T::FILLED_SHAPE );
        }
 
        if( stroke_width > 0 )
        {
            for( int ii = 0; ii < chain.SegmentCount(); ++ii )
            {
                const SEG& seg = chain.CSegment( ii );
                AddFeatureLine( seg.A, seg.B, stroke_width );
            }
        }
 
        break;
    }
 
    case SHAPE_T::ELLIPSE_ARC:
    {
        int maxError = m_board->GetDesignSettings().m_MaxError;
 
        SHAPE_ELLIPSE e( aShape.GetEllipseCenter(), aShape.GetEllipseMajorRadius(), aShape.GetEllipseMinorRadius(),
                         aShape.GetEllipseRotation(), aShape.GetEllipseStartAngle(), aShape.GetEllipseEndAngle() );
 
        SHAPE_LINE_CHAIN chain = e.ConvertToPolyline( maxError );
 
        for( int ii = 0; ii < chain.SegmentCount(); ++ii )
        {
            const SEG& seg = chain.CSegment( ii );
            AddFeatureLine( seg.A, seg.B, stroke_width );
        }
 
        break;
    }
 
    default:
        wxLogTrace( traceOdbppIo, wxT( "Unknown shape when adding ODB++ layer feature" ) );
        break;
    }
 
    if( aShape.IsHatchedFill() )
    {
        for( int ii = 0; ii < aShape.GetHatching().OutlineCount(); ++ii )
            AddContour( aShape.GetHatching(), ii, FILL_T::FILLED_SHAPE );
    }
}
 
 
void FEATURES_MANAGER::AddFeatureSurface( const SHAPE_POLY_SET::POLYGON& aPolygon,
                                          FILL_T aFillType /*= FILL_T::FILLED_SHAPE */ )
{
    AddFeature<ODB_SURFACE>( aPolygon, aFillType );
}
 
 
void FEATURES_MANAGER::AddPadShape( const PAD& aPad, PCB_LAYER_ID aLayer )
{
    FOOTPRINT* fp = aPad.GetParentFootprint();
    bool       mirror = false;
 
    if( aPad.GetOrientation() != ANGLE_0 )
    {
        if( fp && fp->IsFlipped() )
            mirror = true;
    }
 
    int maxError = m_board->GetDesignSettings().m_MaxError;
 
    VECTOR2I expansion{ 0, 0 };
 
    if( aLayer != UNDEFINED_LAYER && LSET( { F_Mask, B_Mask } ).Contains( aLayer ) )
        expansion.x = expansion.y = aPad.GetSolderMaskExpansion( aLayer );
 
    if( aLayer != UNDEFINED_LAYER && LSET( { F_Paste, B_Paste } ).Contains( aLayer ) )
        expansion = aPad.GetSolderPasteMargin( aLayer );
 
    int mask_clearance = expansion.x;
 
    VECTOR2I plotSize = aPad.GetSize( aLayer ) + 2 * expansion;
 
    VECTOR2I center = aPad.ShapePos( aLayer );
 
    wxString width = ODB::SymDouble2String( std::abs( plotSize.x ) );
    wxString height = ODB::SymDouble2String( std::abs( plotSize.y ) );
 
    switch( aPad.GetShape( aLayer ) )
    {
    case PAD_SHAPE::CIRCLE:
    {
        wxString diam = ODB::SymDouble2String( plotSize.x );
 
        AddFeature<ODB_PAD>( ODB::AddXY( center ), AddCircleSymbol( diam ), aPad.GetOrientation(),
                             mirror );
 
        break;
    }
    case PAD_SHAPE::RECTANGLE:
    {
        if( mask_clearance > 0 )
        {
            wxString rad = ODB::SymDouble2String( mask_clearance );
 
            AddFeature<ODB_PAD>( ODB::AddXY( center ), AddRoundRectSymbol( width, height, rad ),
                                 aPad.GetOrientation(), mirror );
        }
        else
        {
            AddFeature<ODB_PAD>( ODB::AddXY( center ), AddRectSymbol( width, height ),
                                 aPad.GetOrientation(), mirror );
        }
 
        break;
    }
    case PAD_SHAPE::OVAL:
    {
        AddFeature<ODB_PAD>( ODB::AddXY( center ), AddOvalSymbol( width, height ),
                             aPad.GetOrientation(), mirror );
        break;
    }
    case PAD_SHAPE::ROUNDRECT:
    {
        wxString rad = ODB::SymDouble2String( aPad.GetRoundRectCornerRadius( aLayer ) );
 
        AddFeature<ODB_PAD>( ODB::AddXY( center ), AddRoundRectSymbol( width, height, rad ),
                             aPad.GetOrientation(), mirror );
 
        break;
    }
    case PAD_SHAPE::CHAMFERED_RECT:
    {
        int shorterSide = std::min( plotSize.x, plotSize.y );
        int chamfer = std::max(
                0, KiROUND( aPad.GetChamferRectRatio( aLayer ) * shorterSide ) );
        wxString rad = ODB::SymDouble2String( chamfer );
        int      positions = aPad.GetChamferPositions( aLayer );
 
        AddFeature<ODB_PAD>( ODB::AddXY( center ),
                             AddChamferRectSymbol( width, height, rad, positions ),
                             aPad.GetOrientation(), mirror );
 
        break;
    }
    case PAD_SHAPE::TRAPEZOID:
    {
        SHAPE_POLY_SET outline;
 
        aPad.TransformShapeToPolygon( outline, aLayer, 0, maxError, ERROR_INSIDE );
 
        // Shape polygon can have holes so use InflateWithLinkedHoles(), not Inflate()
        // which can create bad shapes if margin.x is < 0
 
        if( mask_clearance )
        {
            outline.InflateWithLinkedHoles( expansion.x, CORNER_STRATEGY::ROUND_ALL_CORNERS,
                                            maxError );
        }
 
        for( int ii = 0; ii < outline.OutlineCount(); ++ii )
            AddContour( outline, ii );
 
        break;
    }
    case PAD_SHAPE::CUSTOM:
    {
        SHAPE_POLY_SET shape;
        aPad.MergePrimitivesAsPolygon( aLayer, &shape );
 
        // as for custome shape, odb++ don't rotate the polygon,
        // so we rotate the polygon in kicad anticlockwise
 
        shape.Rotate( aPad.GetOrientation() );
        shape.Move( center );
 
        if( expansion != VECTOR2I( 0, 0 ) )
        {
            shape.InflateWithLinkedHoles( std::max( expansion.x, expansion.y ),
                                          CORNER_STRATEGY::ROUND_ALL_CORNERS, maxError );
        }
 
        for( int ii = 0; ii < shape.OutlineCount(); ++ii )
            AddContour( shape, ii );
 
        break;
    }
    default: wxLogTrace( traceOdbppIo, wxT( "Unknown pad type" ) ); break;
    }
}
 
 
void FEATURES_MANAGER::AddTrack( PCB_LAYER_ID aLayer, PCB_TRACK* track )
{
    auto iter = GetODBPlugin()->GetViaTraceSubnetMap().find( track );
 
    if( iter == GetODBPlugin()->GetViaTraceSubnetMap().end() )
    {
        wxLogTrace( traceOdbppIo, wxT( "Failed to get subnet track data" ) );
        return;
    }
 
    auto subnet = iter->second;
 
    if( track->Type() == PCB_TRACE_T )
    {
        PCB_SHAPE shape( nullptr, SHAPE_T::SEGMENT );
        shape.SetStart( track->GetStart() );
        shape.SetEnd( track->GetEnd() );
        shape.SetWidth( track->GetWidth() );
 
        AddShape( shape );
        subnet->AddFeatureID( EDA_DATA::FEATURE_ID::TYPE::COPPER, m_layerName, m_featuresList.size() - 1 );
    }
    else if( track->Type() == PCB_ARC_T )
    {
        const PCB_ARC* arc = static_cast<const PCB_ARC*>( track );
 
        // Too small arcs cannot be really handled: arc center (and arc radius)
        // cannot be safely computed
        if( !arc->IsDegenerated( 10 /* in IU */ ) )
        {
            PCB_SHAPE shape( nullptr, SHAPE_T::ARC );
            shape.SetArcGeometry( arc->GetStart(), arc->GetMid(), arc->GetEnd() );
            shape.SetWidth( arc->GetWidth() );
 
            AddShape( shape );
        }
        else
        {
            // Approximate this very small arc by a segment.
            AddFeatureLine( track->GetStart(), track->GetEnd(), track->GetWidth() );
        }
 
        subnet->AddFeatureID( EDA_DATA::FEATURE_ID::TYPE::COPPER, m_layerName, m_featuresList.size() - 1 );
    }
    else
    {
        // add via
        PCB_VIA* via = static_cast<PCB_VIA*>( track );
 
        bool hole = false;
 
        if( aLayer != PCB_LAYER_ID::UNDEFINED_LAYER )
        {
            hole = m_layerName.Contains( "plugging" );
        }
        else
        {
            hole = m_layerName.Contains( "drill" )
                   || m_layerName.Contains( "filling" )
                   || m_layerName.Contains( "capping" );
        }
 
        if( hole )
        {
            AddViaDrillHole( via, aLayer );
            subnet->AddFeatureID( EDA_DATA::FEATURE_ID::TYPE::HOLE, m_layerName, m_featuresList.size() - 1 );
 
            // TODO: confirm TOOLING_HOLE
            // AddSystemAttribute( *m_featuresList.back(), ODB_ATTR::PAD_USAGE::TOOLING_HOLE );
 
            if( !m_featuresList.empty() )
            {
                AddSystemAttribute( *m_featuresList.back(), ODB_ATTR::DRILL::VIA );
                AddSystemAttribute( *m_featuresList.back(),
                                    ODB_ATTR::GEOMETRY{ "VIA_RoundD" + std::to_string( via->GetWidth( aLayer ) ) } );
            }
        }
        else
        {
            // to draw via copper shape on copper layer
            AddVia( via, aLayer );
            subnet->AddFeatureID( EDA_DATA::FEATURE_ID::TYPE::COPPER, m_layerName, m_featuresList.size() - 1 );
 
            if( !m_featuresList.empty() )
            {
                AddSystemAttribute( *m_featuresList.back(), ODB_ATTR::PAD_USAGE::VIA );
                AddSystemAttribute( *m_featuresList.back(),
                                    ODB_ATTR::GEOMETRY{ "VIA_RoundD" + std::to_string( via->GetWidth( aLayer ) ) } );
            }
        }
    }
}
 
 
void FEATURES_MANAGER::AddZone( PCB_LAYER_ID aLayer, ZONE* zone )
{
    SHAPE_POLY_SET zone_shape = zone->GetFilledPolysList( aLayer )->CloneDropTriangulation();
 
    for( int ii = 0; ii < zone_shape.OutlineCount(); ++ii )
    {
        AddContour( zone_shape, ii );
 
        auto iter = GetODBPlugin()->GetPlaneSubnetMap().find( std::make_pair( aLayer, zone ) );
 
        if( iter == GetODBPlugin()->GetPlaneSubnetMap().end() )
        {
            wxLogTrace( traceOdbppIo, wxT( "Failed to get subnet plane data" ) );
            return;
        }
 
        iter->second->AddFeatureID( EDA_DATA::FEATURE_ID::TYPE::COPPER, m_layerName, m_featuresList.size() - 1 );
 
        if( zone->IsTeardropArea() && !m_featuresList.empty() )
            AddSystemAttribute( *m_featuresList.back(), ODB_ATTR::TEAR_DROP{ true } );
    }
};
 
 
void FEATURES_MANAGER::AddText( PCB_LAYER_ID aLayer, BOARD_ITEM* item, RESOLUTION_CONTEXT aContext )
{
    EDA_TEXT* text_item = nullptr;
 
    if( PCB_TEXT* tmp_text = dynamic_cast<PCB_TEXT*>( item ) )
        text_item = static_cast<EDA_TEXT*>( tmp_text );
    else if( PCB_TEXTBOX* tmp_textbox = dynamic_cast<PCB_TEXTBOX*>( item ) )
        text_item = static_cast<EDA_TEXT*>( tmp_textbox );
 
    if( !text_item || !text_item->IsVisible() )
        return;
 
    wxString shownText = text_item->GetShownText( aContext );
 
    if( shownText.empty() )
        return;
 
    auto plot_text =
            [&]( const VECTOR2I& aPos, const wxString& aTextString, const TEXT_ATTRIBUTES& aAttributes,
                 KIFONT::FONT* aFont, const KIFONT::METRICS& aFontMetrics )
            {
                KIGFX::GAL_DISPLAY_OPTIONS empty_opts;
 
                TEXT_ATTRIBUTES attributes = aAttributes;
                int             penWidth = attributes.m_StrokeWidth;
 
                if( penWidth == 0 && attributes.m_Bold ) // Use default values if aPenWidth == 0
                    penWidth = GetPenSizeForBold( std::min( attributes.m_Size.x, attributes.m_Size.y ) );
 
                if( penWidth < 0 )
                    penWidth = -penWidth;
 
                attributes.m_StrokeWidth = penWidth;
 
                std::list<VECTOR2I> pts;
 
                auto push_pts =
                        [&]()
                        {
                            if( pts.size() < 2 )
                                return;
 
                            // Polylines are only allowed for more than 3 points.
                            // Otherwise, we have to use a line
 
                            if( pts.size() < 3 )
                            {
                                PCB_SHAPE shape( nullptr, SHAPE_T::SEGMENT );
                                shape.SetStart( pts.front() );
                                shape.SetEnd( pts.back() );
                                shape.SetWidth( attributes.m_StrokeWidth );
 
                                AddShape( shape );
                                AddSystemAttribute( *m_featuresList.back(),
                                                    ODB_ATTR::STRING{ aTextString.ToStdString() } );
                            }
                            else
                            {
                                for( auto it = pts.begin(); std::next( it ) != pts.end(); ++it )
                                {
                                    auto      it2 = std::next( it );
                                    PCB_SHAPE shape( nullptr, SHAPE_T::SEGMENT );
                                    shape.SetStart( *it );
                                    shape.SetEnd( *it2 );
                                    shape.SetWidth( attributes.m_StrokeWidth );
                                    AddShape( shape );
 
                                    if( !m_featuresList.empty() )
                                    {
                                        AddSystemAttribute( *m_featuresList.back(),
                                                            ODB_ATTR::STRING{ aTextString.ToStdString() } );
                                    }
                                }
                            }
 
                            pts.clear();
                        };
 
                CALLBACK_GAL callback_gal(
                        empty_opts,
                        // Stroke callback
                        [&]( const VECTOR2I& aPt1, const VECTOR2I& aPt2 )
                        {
                            if( !pts.empty() )
                            {
                                if( aPt1 == pts.back() )
                                    pts.push_back( aPt2 );
                                else if( aPt2 == pts.front() )
                                    pts.push_front( aPt1 );
                                else if( aPt1 == pts.front() )
                                    pts.push_front( aPt2 );
                                else if( aPt2 == pts.back() )
                                    pts.push_back( aPt1 );
                                else
                                {
                                    push_pts();
                                    pts.push_back( aPt1 );
                                    pts.push_back( aPt2 );
                                }
                            }
                            else
                            {
                                pts.push_back( aPt1 );
                                pts.push_back( aPt2 );
                            }
                        },
                        // Polygon callback
                        [&]( const SHAPE_LINE_CHAIN& aPoly )
                        {
                            if( aPoly.PointCount() < 3 )
                                return;
 
                            SHAPE_POLY_SET poly_set;
                            poly_set.AddOutline( aPoly );
 
                            for( int ii = 0; ii < poly_set.OutlineCount(); ++ii )
                            {
                                AddContour( poly_set, ii, FILL_T::FILLED_SHAPE );
 
                                if( !m_featuresList.empty() )
                                {
                                    AddSystemAttribute( *m_featuresList.back(),
                                                        ODB_ATTR::STRING{ aTextString.ToStdString() } );
                                }
                            }
                        } );
 
                aFont->Draw( &callback_gal, aTextString, aPos, aAttributes, aFontMetrics );
 
                if( !pts.empty() )
                    push_pts();
            };
 
    PCB_TEXT*    text = nullptr;
    PCB_TEXTBOX* textbox = nullptr;
    bool         isKnockout = false;
 
    if( item->Type() == PCB_TEXT_T || item->Type() == PCB_FIELD_T )
    {
        text = static_cast<PCB_TEXT*>( item );
        isKnockout = text->IsKnockout();
    }
    else if( item->Type() == PCB_TEXTBOX_T )
    {
        textbox = static_cast<PCB_TEXTBOX*>( item );
        isKnockout = textbox->IsKnockout();
    }
 
    const KIFONT::METRICS& fontMetrics = item->GetFontMetrics();
    KIFONT::FONT*          font = text_item->GetDrawFont( nullptr );
 
    VECTOR2I pos = text_item->GetTextPos();
 
    TEXT_ATTRIBUTES attrs = text_item->GetAttributes();
    attrs.m_StrokeWidth = text_item->GetEffectiveTextPenWidth();
    attrs.m_Angle = text_item->GetDrawRotation();
    attrs.m_Multiline = false;
 
    if( isKnockout )
    {
        SHAPE_POLY_SET finalpolyset;
        int            maxError = m_board->GetDesignSettings().m_MaxError;
 
        if( text )
            text->TransformTextToPolySet( finalpolyset, 0, maxError, ERROR_INSIDE );
        else if( textbox )
            textbox->TransformTextToPolySet( finalpolyset, 0, maxError, ERROR_INSIDE );
 
        finalpolyset.Fracture();
 
        for( int ii = 0; ii < finalpolyset.OutlineCount(); ++ii )
        {
            AddContour( finalpolyset, ii, FILL_T::FILLED_SHAPE );
 
            if( !m_featuresList.empty() )
                AddSystemAttribute( *m_featuresList.back(), ODB_ATTR::STRING{ shownText.ToStdString() } );
        }
    }
    else if( text_item->IsMultilineAllowed() )
    {
        std::vector<VECTOR2I> positions;
        wxArrayString         strings_list;
        wxStringSplit( shownText, strings_list, '\n' );
        positions.reserve( strings_list.Count() );
 
        text_item->GetLinePositions( nullptr, positions, strings_list.Count() );
 
        for( unsigned ii = 0; ii < strings_list.Count(); ii++ )
        {
            wxString& txt = strings_list.Item( ii );
            plot_text( positions[ii], txt, attrs, font, fontMetrics );
        }
    }
    else
    {
        plot_text( pos, shownText, attrs, font, fontMetrics );
    }
};
 
 
void FEATURES_MANAGER::AddShape( PCB_LAYER_ID aLayer, PCB_SHAPE* shape )
{
    // FOOTPRINT* fp = shape->GetParentFootprint();
    AddShape( *shape, aLayer );
};
 
 
void FEATURES_MANAGER::AddDimension( PCB_LAYER_ID aLayer, PCB_DIMENSION_BASE* dimension )
{
    // A dimension is a PCB_TEXT subclass, so the value text is plotted via add_text.
 
    AddText( aLayer, dimension, FOR_CANVAS );
 
    PCB_SHAPE temp_shape;
    temp_shape.SetStroke( STROKE_PARAMS( dimension->GetLineThickness(), LINE_STYLE::SOLID ) );
    temp_shape.SetLayer( dimension->GetLayer() );
 
    for( const std::shared_ptr<SHAPE>& shape : dimension->GetShapes() )
    {
        switch( shape->Type() )
        {
        case SH_SEGMENT:
        {
            const SEG& seg = static_cast<const SHAPE_SEGMENT*>( shape.get() )->GetSeg();
 
            temp_shape.SetShape( SHAPE_T::SEGMENT );
            temp_shape.SetStart( seg.A );
            temp_shape.SetEnd( seg.B );
 
            AddShape( aLayer, &temp_shape );
            break;
        }
 
        case SH_CIRCLE:
        {
            VECTOR2I center( shape->Centre() );
            int      radius = static_cast<const SHAPE_CIRCLE*>( shape.get() )->GetRadius();
 
            temp_shape.SetShape( SHAPE_T::CIRCLE );
            temp_shape.SetFilled( false );
            temp_shape.SetStart( center );
            temp_shape.SetEnd( VECTOR2I( center.x + radius, center.y ) );
 
            AddShape( aLayer, &temp_shape );
            break;
        }
 
        default:
            break;
        }
    }
};
 
 
void FEATURES_MANAGER::AddPad( PCB_LAYER_ID aLayer, PAD* pad )
{
    auto iter = GetODBPlugin()->GetPadSubnetMap().find( pad );
 
    if( iter == GetODBPlugin()->GetPadSubnetMap().end() )
    {
        wxLogTrace( traceOdbppIo, wxT( "Failed to get subnet top data" ) );
        return;
    }
 
    if( aLayer != PCB_LAYER_ID::UNDEFINED_LAYER )
    {
        // FOOTPRINT* fp = pad->GetParentFootprint();
 
        AddPadShape( *pad, aLayer );
 
        iter->second->AddFeatureID( EDA_DATA::FEATURE_ID::TYPE::COPPER, m_layerName, m_featuresList.size() - 1 );
 
        if( !m_featuresList.empty() )
            AddSystemAttribute( *m_featuresList.back(), ODB_ATTR::PAD_USAGE::TOEPRINT );
 
        if( !pad->HasHole() && !m_featuresList.empty() )
            AddSystemAttribute( *m_featuresList.back(), ODB_ATTR::SMD{ true } );
    }
    else
    {
        // drill layer round hole or slot hole
        if( m_layerName.Contains( "drill" ) )
        {
            // here we exchange round hole or slot hole into pad to draw in drill layer
            PAD dummy( *pad );
            dummy.Padstack().SetMode( PADSTACK::MODE::NORMAL );
 
            if( pad->GetDrillSizeX() == pad->GetDrillSizeY() )
                dummy.SetShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::CIRCLE ); // round hole shape
            else
                dummy.SetShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::OVAL );   // slot hole shape
 
            dummy.SetOffset( PADSTACK::ALL_LAYERS,  VECTOR2I( 0, 0 ) );    // use hole position not pad position
            dummy.SetSize( PADSTACK::ALL_LAYERS, pad->GetDrillSize() );
 
            AddPadShape( dummy, aLayer );
 
            if( pad->GetAttribute() == PAD_ATTRIB::PTH )
            {
                // only plated holes link to subnet
                iter->second->AddFeatureID( EDA_DATA::FEATURE_ID::TYPE::HOLE, m_layerName,
                                            m_featuresList.size() - 1 );
 
                if( !m_featuresList.empty() )
                    AddSystemAttribute( *m_featuresList.back(), ODB_ATTR::DRILL::PLATED );
            }
            else
            {
                if( !m_featuresList.empty() )
                    AddSystemAttribute( *m_featuresList.back(), ODB_ATTR::DRILL::NON_PLATED );
            }
        }
    }
    // AddSystemAttribute( *m_featuresList.back(),
    //         ODB_ATTR::GEOMETRY{ "PAD_xxxx" } );
};
 
void FEATURES_MANAGER::InitFeatureList( PCB_LAYER_ID aLayer, std::vector<BOARD_ITEM*>& aItems )
{
    for( BOARD_ITEM* item : aItems )
    {
        switch( item->Type() )
        {
        case PCB_TRACE_T:
        case PCB_ARC_T:
        case PCB_VIA_T:
            AddTrack( aLayer, static_cast<PCB_TRACK*>( item ) );
            break;
 
        case PCB_ZONE_T:
            AddZone( aLayer, static_cast<ZONE*>( item ) );
            break;
 
        case PCB_PAD_T:
            AddPad( aLayer, static_cast<PAD*>( item ) );
            break;
 
        case PCB_SHAPE_T:
            AddShape( aLayer, static_cast<PCB_SHAPE*>( item ) );
            break;
 
        case PCB_TEXT_T:
        case PCB_FIELD_T:
            AddText( aLayer, item, FOR_CANVAS );
            break;
 
        case PCB_TEXTBOX_T:
            AddText( aLayer, item, FOR_CANVAS );
 
            if( static_cast<PCB_TEXTBOX*>( item )->IsBorderEnabled() )
                AddShape( aLayer, static_cast<PCB_TEXTBOX*>( item ) );
 
            break;
 
        case PCB_TABLE_T:
        case PCB_DRILL_CHART_T:
        {
            PCB_TABLE* table = static_cast<PCB_TABLE*>( item );
 
            for( PCB_TABLECELL* cell : table->GetCells() )
                AddText( aLayer, cell, FOR_CANVAS );
 
            table->DrawBorders(
                    [&]( const VECTOR2I& aPt1, const VECTOR2I& aPt2, const STROKE_PARAMS& aStroke )
                    {
                        int lineWidth = aStroke.GetWidth();
 
                        if( lineWidth > 0 )
                            AddFeatureLine( aPt1, aPt2, lineWidth );
                    } );
 
            break;
        }
 
        case PCB_DIM_ALIGNED_T:
        case PCB_DIM_LEADER_T:
        case PCB_DIM_CENTER_T:
        case PCB_DIM_RADIAL_T:
        case PCB_DIM_ORTHOGONAL_T:
            AddDimension( aLayer, static_cast<PCB_DIMENSION_BASE*>( item ) );
            break;
 
        case PCB_TARGET_T:
            //TODO: Add support for targets
            break;
 
        case PCB_BARCODE_T:
        {
            const PCB_BARCODE* barcode = static_cast<const PCB_BARCODE*>( item );
            SHAPE_POLY_SET     poly_set;
 
            barcode->TransformShapeToPolygon( poly_set, aLayer, 0, m_board->GetDesignSettings().m_MaxError,
                                              ERROR_INSIDE );
            poly_set.Fracture();
 
            for( int ii = 0; ii < poly_set.OutlineCount(); ++ii )
                AddContour( poly_set, ii, FILL_T::FILLED_SHAPE );
 
            break;
        }
 
        default:
            break;
        }
    }
}
 
 
void FEATURES_MANAGER::AddVia( const PCB_VIA* aVia, PCB_LAYER_ID aLayer )
{
    if( !aVia->FlashLayer( aLayer ) )
        return;
 
    PAD dummy( nullptr ); // default pad shape is circle
    dummy.SetPadstack( aVia->Padstack() );
    dummy.SetPosition( aVia->GetStart() );
 
    AddPadShape( dummy, aLayer );
}
 
 
void FEATURES_MANAGER::AddViaDrillHole( const PCB_VIA* aVia, PCB_LAYER_ID aLayer )
{
    PAD dummy( nullptr );
    dummy.SetPadstackMode( PADSTACK::MODE::NORMAL );
    dummy.SetShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::CIRCLE );
    dummy.SetPosition( aVia->GetStart() );
    dummy.SetSize( PADSTACK::ALL_LAYERS, VECTOR2I( aVia->GetDrillValue(), aVia->GetDrillValue() ) );
 
    AddPadShape( dummy, aLayer );
}
 
 
void FEATURES_MANAGER::GenerateProfileFeatures( std::ostream& ost ) const
{
    ost << "UNITS=" << PCB_IO_ODBPP::m_unitsStr << std::endl;
    ost << "#\n#Num Features\n#" << std::endl;
    ost << "F " << m_featuresList.size() << std::endl;
 
    if( m_featuresList.empty() )
        return;
 
    ost << "#\n#Layer features\n#" << std::endl;
 
    for( const auto& feat : m_featuresList )
    {
        feat->WriteFeatures( ost );
    }
}
 
 
void FEATURES_MANAGER::GenerateFeatureFile( std::ostream& ost ) const
{
    ost << "UNITS=" << PCB_IO_ODBPP::m_unitsStr << std::endl;
    ost << "#\n#Num Features\n#" << std::endl;
    ost << "F " << m_featuresList.size() << std::endl << std::endl;
 
    if( m_featuresList.empty() )
        return;
 
    ost << "#\n#Feature symbol names\n#" << std::endl;
 
    for( const auto& [n, name] : m_allSymMap )
    {
        ost << "$" << n << " " << name << std::endl;
    }
 
    WriteAttributes( ost );
 
    ost << "#\n#Layer features\n#" << std::endl;
 
    for( const auto& feat : m_featuresList )
    {
        feat->WriteFeatures( ost );
    }
}
 
 
void ODB_FEATURE::WriteFeatures( std::ostream& ost )
{
    switch( GetFeatureType() )
    {
    case FEATURE_TYPE::LINE: ost << "L "; break;
 
    case FEATURE_TYPE::ARC: ost << "A "; break;
 
    case FEATURE_TYPE::PAD: ost << "P "; break;
 
    case FEATURE_TYPE::SURFACE: ost << "S "; break;
    default: return;
    }
 
    WriteRecordContent( ost );
    ost << std::endl;
}
 
 
void ODB_LINE::WriteRecordContent( std::ostream& ost )
{
    ost << m_start.first << " " << m_start.second << " " << m_end.first << " " << m_end.second
        << " " << m_symIndex << " P 0";
 
    WriteAttributes( ost );
}
 
 
void ODB_ARC::WriteRecordContent( std::ostream& ost )
{
    ost << m_start.first << " " << m_start.second << " " << m_end.first << " " << m_end.second
        << " " << m_center.first << " " << m_center.second << " " << m_symIndex << " P 0 "
        << ( m_direction == ODB_DIRECTION::CW ? "Y" : "N" );
 
    WriteAttributes( ost );
}
 
 
void ODB_PAD::WriteRecordContent( std::ostream& ost )
{
    ost << m_center.first << " " << m_center.second << " ";
 
    // TODO: support resize symbol
    // ost << "-1" << " " << m_symIndex << " "
    //     << m_resize << " P 0 ";
 
    ost << m_symIndex << " P 0 ";
 
    if( m_mirror )
        ost << "9 " << ODB::Double2String( m_angle.Normalize().AsDegrees() );
    else
        ost << "8 " << ODB::Double2String( ( ANGLE_360 - m_angle ).Normalize().AsDegrees() );
 
    WriteAttributes( ost );
}
 
 
ODB_SURFACE::ODB_SURFACE( uint32_t aIndex, const SHAPE_POLY_SET::POLYGON& aPolygon,
                          FILL_T aFillType /*= FILL_T::FILLED_SHAPE*/ ) : ODB_FEATURE( aIndex )
{
    if( !aPolygon.empty() && aPolygon[0].PointCount() >= 3 )
    {
        m_surfaces = std::make_unique<ODB_SURFACE_DATA>( aPolygon );
        if( aFillType != FILL_T::NO_FILL )
        {
            m_surfaces->AddPolygonHoles( aPolygon );
        }
    }
    else
    {
        delete this;
    }
}
 
 
void ODB_SURFACE::WriteRecordContent( std::ostream& ost )
{
    ost << "P 0";
    WriteAttributes( ost );
    ost << std::endl;
    m_surfaces->WriteData( ost );
    ost << "SE";
}
 
 
ODB_SURFACE_DATA::ODB_SURFACE_DATA( const SHAPE_POLY_SET::POLYGON& aPolygon )
{
    const std::vector<VECTOR2I>& pts = aPolygon[0].CPoints();
    if( !pts.empty() )
    {
        if( m_polygons.empty() )
        {
            m_polygons.resize( 1 );
        }
 
        m_polygons.at( 0 ).reserve( pts.size() );
        m_polygons.at( 0 ).emplace_back( pts.back() );
 
        for( size_t jj = 0; jj < pts.size(); ++jj )
        {
            m_polygons.at( 0 ).emplace_back( pts.at( jj ) );
        }
    }
}
 
 
void ODB_SURFACE_DATA::AddPolygonHoles( const SHAPE_POLY_SET::POLYGON& aPolygon )
{
    for( size_t ii = 1; ii < aPolygon.size(); ++ii )
    {
        wxCHECK2( aPolygon[ii].PointCount() >= 3, continue );
 
        const std::vector<VECTOR2I>& hole = aPolygon[ii].CPoints();
 
        if( hole.empty() )
            continue;
 
        if( m_polygons.size() <= ii )
        {
            m_polygons.resize( ii + 1 );
 
            m_polygons[ii].reserve( hole.size() );
        }
 
        m_polygons.at( ii ).emplace_back( hole.back() );
 
        for( size_t jj = 0; jj < hole.size(); ++jj )
        {
            m_polygons.at( ii ).emplace_back( hole[jj] );
        }
    }
}
 
 
void ODB_SURFACE_DATA::WriteData( std::ostream& ost ) const
{
    ODB::CHECK_ONCE is_island;
 
    for( const auto& contour : m_polygons )
    {
        if( contour.empty() )
            continue;
 
        ost << "OB " << ODB::AddXY( contour.back().m_end ).first << " "
            << ODB::AddXY( contour.back().m_end ).second << " ";
 
        if( is_island() )
            ost << "I";
        else
            ost << "H";
        ost << std::endl;
 
        for( const auto& line : contour )
        {
            if( SURFACE_LINE::LINE_TYPE::SEGMENT == line.m_type )
                ost << "OS " << ODB::AddXY( line.m_end ).first << " "
                    << ODB::AddXY( line.m_end ).second << std::endl;
            else
                ost << "OC " << ODB::AddXY( line.m_end ).first << " "
                    << ODB::AddXY( line.m_end ).second << " " << ODB::AddXY( line.m_center ).first
                    << " " << ODB::AddXY( line.m_center ).second << " "
                    << ( line.m_direction == ODB_DIRECTION::CW ? "Y" : "N" ) << std::endl;
        }
        ost << "OE" << std::endl;
    }
}