gendrill_writer_base.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 1992-2017 Jean_Pierre Charras <jp.charras at wanadoo.fr>
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#ifndef GENDRILL_WRITER_BASE_H
#define GENDRILL_WRITER_BASE_H
 
// holes can have an attribute in Excellon drill files, similar to attributes
// in Gerber X2 format
// They are only comments for a better identification of holes (vias, pads...)
// Set to 1 to add these comments and 0 to not use these comments
#define USE_ATTRIB_FOR_HOLES 1
 
#include <optional>
#include <string>
#include <vector>
 
#include <layer_ids.h>
#include <plotters/plotter.h>
#include <padstack.h>
 
 
class BOARD;
class BOARD_ITEM;
class OUTPUTFORMATTER;
class PAGE_INFO;
class REPORTER;
 
// hole attribute, mainly to identify vias and pads and add this info as comment
// in NC drill files
enum class HOLE_ATTRIBUTE
{
    HOLE_UNKNOWN,           // uninitialized type
    HOLE_VIA_THROUGH,       // a via hole (always plated) from top to bottom
    HOLE_VIA_BURIED,        // a via hole (always plated) not through hole
    HOLE_VIA_BACKDRILL,     // a via hole created by a backdrill operation
    HOLE_PAD,               // a plated or not plated pad hole
    HOLE_PAD_CASTELLATED,   // a plated castelleted pad hole
    HOLE_PAD_PRESSFIT,      // a plated press-fit pad hole
    HOLE_MECHANICAL         // a mechanical pad (provided, not used)
};
 
// Via Protection features according to IPC-4761.
enum class IPC4761_FEATURES : int
{
    FILLED,
    CAPPED,
    PLUGGED_FRONT,
    PLUGGED_BACK,
    COVERED_FRONT,
    COVERED_BACK,
    TENTED_FRONT,
    TENTED_BACK
};
 
// the DRILL_TOOL class  handles tools used in the excellon drill file:
class DRILL_TOOL
{
public:
    int m_Diameter;                 // the diameter of the used tool
                                    // (for oblong, the smaller size)
    int m_TotalCount;               // how many times it is used (round and oblong)
    int m_OvalCount;                // oblong count
    bool m_Hole_NotPlated;          // Is the hole plated or not plated
    HOLE_ATTRIBUTE m_HoleAttribute; // Attribute (used in Excellon drill file)
    bool m_IsBackdrill;             // True when drilling a backdrill span
    bool m_HasPostMachining;        // True if any hole for this tool has post-machining
    std::optional<int> m_MinStubLength; // Minimum stub length for this tool (IU)
    std::optional<int> m_MaxStubLength; // Maximum stub length for this tool (IU)
 
public:
    DRILL_TOOL( int aDiameter, bool a_NotPlated )
    {
        m_TotalCount     = 0;
        m_OvalCount      = 0;
        m_Diameter       = aDiameter;
        m_Hole_NotPlated = a_NotPlated;
        m_HoleAttribute  = HOLE_ATTRIBUTE::HOLE_UNKNOWN;
        m_IsBackdrill    = false;
        m_HasPostMachining = false;
    }
};
 

class HOLE_INFO
{
public:
    HOLE_INFO()
    {
        m_ItemParent = nullptr;
        m_Hole_NotPlated = false;
        m_Hole_Diameter = 0;
        m_Tool_Reference = 0;
        m_Hole_Orient = ANGLE_0;
        m_Hole_Shape = 0;
        m_Hole_Bottom_Layer = B_Cu;
        m_Hole_Top_Layer = F_Cu;
        m_HoleAttribute = HOLE_ATTRIBUTE::HOLE_UNKNOWN;
        m_Hole_Filled = false;
        m_Hole_Capped = false;
        m_Hole_Top_Covered = false;
        m_Hole_Bot_Covered = false;
        m_Hole_Top_Plugged = false;
        m_Hole_Bot_Plugged = false;
        m_Hole_Top_Tented = false;
        m_Hole_Bot_Tented = false;
        m_IsBackdrill = false;
        m_FrontPostMachining = PAD_DRILL_POST_MACHINING_MODE::UNKNOWN;
        m_FrontPostMachiningSize = 0;
        m_FrontPostMachiningDepth = 0;
        m_FrontPostMachiningAngle = 0;
        m_BackPostMachining = PAD_DRILL_POST_MACHINING_MODE::UNKNOWN;
        m_BackPostMachiningSize = 0;
        m_BackPostMachiningDepth = 0;
        m_BackPostMachiningAngle = 0;
        m_DrillStart = UNDEFINED_LAYER;
        m_DrillEnd = UNDEFINED_LAYER;
    }
 
public:
    BOARD_ITEM*  m_ItemParent;           // The pad or via parent of this hole
    int          m_Hole_Diameter;        // hole value, and for oblong: min(hole size x, hole
                                         // size y).
    int          m_Tool_Reference;       // Tool reference for this hole = 1 ... n (values <=0
                                         // must not be used).
    VECTOR2I     m_Hole_Size;            // hole size for oblong holes
    EDA_ANGLE    m_Hole_Orient;          // Hole rotation (= pad rotation) for oblong holes
    int          m_Hole_Shape;           // hole shape: round (0) or oval (1)
    VECTOR2I     m_Hole_Pos;             // hole position
    PCB_LAYER_ID m_Hole_Bottom_Layer;    // physically lowest layer reached by the hole
    PCB_LAYER_ID m_Hole_Top_Layer;       // physically highest layer reached by the hole
    bool         m_Hole_NotPlated;       // hole not plated. Must be in a specific drill file or
                                         // section.
    HOLE_ATTRIBUTE m_HoleAttribute;      // Attribute, used in Excellon drill file and to sort holes
                                         // by type.
    bool         m_Hole_Filled;          // True if the hole is filled
    bool         m_Hole_Capped;          // True if the hole is capped
    bool         m_Hole_Top_Covered;     // True if the hole is covered on the top layer
    bool         m_Hole_Bot_Covered;     // True if the hole is covered on the bottom layer
    bool         m_Hole_Top_Plugged;     // True if the hole is plugged on the top layer
    bool         m_Hole_Bot_Plugged;     // True if the hole is plugged on the bottom layer
    bool         m_Hole_Top_Tented;      // True if the hole is tented on the top layer
    bool         m_Hole_Bot_Tented;      // True if the hole is tented on the bottom layer
    bool         m_IsBackdrill;          // True if the hole is a backdrill
    PAD_DRILL_POST_MACHINING_MODE m_FrontPostMachining; // Post-machining mode
    int          m_FrontPostMachiningSize;    // Post-machining size
    int          m_FrontPostMachiningDepth;   // Post-machining depth
    int          m_FrontPostMachiningAngle;   // Post-machining angle
    PAD_DRILL_POST_MACHINING_MODE m_BackPostMachining; // Post-machining mode
    int          m_BackPostMachiningSize;    // Post-machining size
    int          m_BackPostMachiningDepth;   // Post-machining depth
    int          m_BackPostMachiningAngle;   // Post-machining angle
    PCB_LAYER_ID m_DrillStart;           // Start layer for backdrills
    PCB_LAYER_ID m_DrillEnd;             // End layer for backdrills
    std::optional<int> m_StubLength;     // Stub length for backdrills
 
 
};
 
 
typedef std::pair<PCB_LAYER_ID, PCB_LAYER_ID>   DRILL_LAYER_PAIR;
 
 
struct DRILL_SPAN
{
    DRILL_SPAN()
    {
        m_StartLayer = F_Cu;
        m_EndLayer = B_Cu;
        m_IsBackdrill = false;
        m_IsNonPlatedFile = false;
    }
 
    DRILL_SPAN( PCB_LAYER_ID aStartLayer, PCB_LAYER_ID aEndLayer, bool aIsBackdrill,
                bool aIsNonPlated )
    {
        m_StartLayer = aStartLayer;
        m_EndLayer = aEndLayer;
        m_IsBackdrill = aIsBackdrill;
        m_IsNonPlatedFile = aIsNonPlated;
    }
 
    PCB_LAYER_ID TopLayer() const
    {
        // B_Cu (id=2) is numerically less than inner layers (id>=4), but is physically
        // at the bottom of the stack. Use IsCopperLayerLowerThan for correct ordering.
        return IsCopperLayerLowerThan( m_StartLayer, m_EndLayer ) ? m_EndLayer : m_StartLayer;
    }
 
    PCB_LAYER_ID BottomLayer() const
    {
        return IsCopperLayerLowerThan( m_StartLayer, m_EndLayer ) ? m_StartLayer : m_EndLayer;
    }
 
    PCB_LAYER_ID DrillStartLayer() const
    {
        return m_StartLayer;
    }
 
    PCB_LAYER_ID DrillEndLayer() const
    {
        return m_EndLayer;
    }
 
    DRILL_LAYER_PAIR Pair() const
    {
        return DRILL_LAYER_PAIR( TopLayer(), BottomLayer() );
    }
 
    bool operator<( const DRILL_SPAN& aOther ) const
    {
        if( TopLayer() != aOther.TopLayer() )
            return TopLayer() < aOther.TopLayer();
 
        if( BottomLayer() != aOther.BottomLayer() )
            return BottomLayer() < aOther.BottomLayer();
 
        if( m_IsBackdrill != aOther.m_IsBackdrill )
            return m_IsBackdrill && !aOther.m_IsBackdrill;
 
        if( m_IsNonPlatedFile != aOther.m_IsNonPlatedFile )
            return m_IsNonPlatedFile && !aOther.m_IsNonPlatedFile;
 
        if( m_StartLayer != aOther.m_StartLayer )
            return m_StartLayer < aOther.m_StartLayer;
 
        return m_EndLayer < aOther.m_EndLayer;
    }
 
    PCB_LAYER_ID m_StartLayer;
    PCB_LAYER_ID m_EndLayer;
    bool         m_IsBackdrill;
    bool         m_IsNonPlatedFile;
};
 

class DRILL_PRECISION
{
public:
    DRILL_PRECISION( int l = 2, int r = 4 )
    {
        m_Lhs = l; m_Rhs = r;
    }
 
 
    wxString GetPrecisionString()
    {
        wxString text;
 
        text << m_Lhs << wxT( ":" ) << m_Rhs;
        return text;
    }
 
    int m_Lhs;      // Left digit number (integer value of coordinates)
    int m_Rhs;      // Right digit number (decimal value of coordinates)
};
 

class GENDRILL_WRITER_BASE
{
public:
    enum ZEROS_FMT {            // Zero format in coordinates
        DECIMAL_FORMAT,         // Floating point coordinates
        SUPPRESS_LEADING,       // Suppress leading zeros
        SUPPRESS_TRAILING,      // Suppress trailing zeros
        KEEP_ZEROS              // keep zeros
    };
 
    enum TYPE_FILE {            // type of holes in file: PTH, NPTH, mixed
        PTH_FILE,               // PTH only, this is the default also for blind/buried holes
        NPTH_FILE,              // NPTH only
        MIXED_FILE              // PHT+NPTH (mixed)
    };
 
    virtual ~GENDRILL_WRITER_BASE()
    {
    }

    void SetMergeOption( bool aMerge ) { m_merge_PTH_NPTH = aMerge; }

    VECTOR2I GetOffset() { return m_offset; }

    void SetPageInfo( const PAGE_INFO* aPageInfo ) { m_pageInfo = aPageInfo; }

    void SetMapFileFormat( PLOT_FORMAT aMapFmt )
    {
        m_mapFileFmt = aMapFmt;
    }

    bool CreateMapFilesSet( const wxString& aPlotDirectory, REPORTER* aReporter = nullptr );

    bool GenDrillReportFile( const wxString& aFullFileName, REPORTER* aReporter = nullptr );

    wxString GetDrillFileExt() const { return m_drillFileExtension; }
 
protected:
    bool genDrillMapFile( const wxString& aFullFileName, PLOT_FORMAT aFormat );

    void buildHolesList( const DRILL_SPAN& aSpan, bool aGenerateNPTH_list );
 
    int  getHolesCount() const { return m_holeListBuffer.size(); }

    bool plotDrillMarks( PLOTTER* aPlotter );

    std::vector<DRILL_SPAN> getUniqueLayerPairs() const;

    enum class TOOL_SUMMARY
    {
        PLATED,     
        UNPLATED,   
        BACKDRILL   
    };

    unsigned printToolSummary( FILE* out, TOOL_SUMMARY aSummary ) const;

    const std::string layerPairName( DRILL_LAYER_PAIR aPair ) const;

    const std::string layerName( PCB_LAYER_ID aLayer ) const;

    virtual const wxString getDrillFileName( const DRILL_SPAN& aSpan, bool aNPTH,
                                             bool aMerge_PTH_NPTH ) const;
 

    virtual const wxString getProtectionFileName( const DRILL_SPAN& aSpan,
                                                  IPC4761_FEATURES aFeature ) const;
 

    const wxString BuildFileFunctionAttributeString( const DRILL_SPAN& aSpan,
                                                     TYPE_FILE aHoleType,
                                                     bool aCompatNCdrill = false ) const;
 
 
protected:
    // Use derived classes to build a fully initialized GENDRILL_WRITER_BASE class.
    GENDRILL_WRITER_BASE( BOARD* aPcb )
    {
        m_pcb             = aPcb;
        m_conversionUnits = 1.0;
        m_unitsMetric     = true;
        m_mapFileFmt      = PLOT_FORMAT::PDF;
        m_pageInfo        = nullptr;
        m_merge_PTH_NPTH  = false;
        m_zeroFormat      = DECIMAL_FORMAT;
    }
 
    BOARD*                   m_pcb;
    wxString                 m_drillFileExtension;      // .drl or .gbr, depending on format
    bool                     m_unitsMetric;             // true = mm, false = inches
    ZEROS_FMT                m_zeroFormat;              // the zero format option for output file
    DRILL_PRECISION          m_precision;               // The current coordinate precision (not
                                                        // used in decimal format).
    double                   m_conversionUnits;         // scaling factor to convert the board
                                                        // unites to Excellon/Gerber units (i.e
                                                        // inches or mm)
    VECTOR2I                 m_offset;                  // Drill offset coordinates
    bool                     m_merge_PTH_NPTH;          // True to generate only one drill file
    std::vector<HOLE_INFO>   m_holeListBuffer;          // Buffer containing holes
    std::vector<DRILL_TOOL>  m_toolListBuffer;          // Buffer containing tools
 
    PLOT_FORMAT m_mapFileFmt;                           // the format of the map drill file,
                                                        // if this map is needed
    const PAGE_INFO*         m_pageInfo;                // the page info used to plot drill maps
                                                        // If NULL, use a A4 page format
};
 
#endif      // #define GENDRILL_FILE_WRITER_BASE_H