idf_common.h

Go to the documentation of this file.

 
/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2013-2017  Cirilo Bernardo
 * 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 IDF_COMMON_H
#define IDF_COMMON_H
 
#include <list>
#include <fstream>
#include <exception>
#include <string>
#include <cmath>
 
// differences in angle smaller than MIN_ANG are considered equal
#define MIN_ANG     (0.01)
 
class IDF_POINT;
class IDF_SEGMENT;
class IDF_DRILL_DATA;
class IDF_OUTLINE;
class IDF_LIB;
 
 
struct IDF_ERROR : std::exception
{
    std::string message;
 
    IDF_ERROR( const char* aSourceFile, const char* aSourceMethod, int aSourceLine,
               const std::string& aMessage ) noexcept;
 
    virtual ~IDF_ERROR() noexcept;
 
    virtual const char* what() const noexcept override;
};
 
 
namespace IDF3 {

enum class FILE_STATE
{
    FILE_START = 0, // no data has been read; expecting .HEADER
    FILE_HEADER,    // header has been read; expecting  .BOARD_OUTLINE
    FILE_OUTLINE,   // board outline has been read; most sections can be accepted
    FILE_PLACEMENT, // placement has been read; no further sections can be accepted
    FILE_INVALID,   // file is invalid
    FILE_ERROR      // other errors while processing the file
};

enum class IDF_VERSION
{
    IDF_V2 = 0, // version 2 has read support only; files written as IDFv3
    IDF_V3      // version 3 has full read/write support
};

enum class KEY_OWNER
{
    UNOWNED = 0, //< either MCAD or ECAD may modify a feature
    MCAD,        //< only MCAD may modify a feature
    ECAD         //< only ECAD may modify a feature
};

enum class KEY_HOLETYPE
{
    PIN = 0, //< drill hole is for a pin
    VIA,     //< drill hole is for a via
    MTG,     //< drill hole is for mounting
    TOOL,    //< drill hole is for tooling
    OTHER    //< user has specified a custom type
};

enum class KEY_PLATING
{
    PTH = 0, //< Plate-Through Hole
    NPTH     //< Non-Plate-Through Hole
};

enum class KEY_REFDES
{
    BOARD = 0, //< feature is associated with the board
    NOREFDES,  //< feature is associated with a component with no RefDes
    PANEL,     //< feature is associated with an IDF panel
    REFDES     //< reference designator as assigned by the CAD software
};

enum class CAD_TYPE
{
    CAD_ELEC = 0, //< An Electrical CAD is opening/modifying the file
    CAD_MECH,     //< A Mechanical CAD is opening/modifying the file
    CAD_INVALID
};

enum class IDF_LAYER
{
    LYR_TOP = 0,
    LYR_BOTTOM,
    LYR_BOTH,
    LYR_INNER,
    LYR_ALL,
    LYR_INVALID
};

enum class OUTLINE_TYPE
{
    OTLN_BOARD = 0,
    OTLN_OTHER,
    OTLN_PLACE,
    OTLN_ROUTE,
    OTLN_PLACE_KEEPOUT,
    OTLN_ROUTE_KEEPOUT,
    OTLN_VIA_KEEPOUT,
    OTLN_GROUP_PLACE,
    OTLN_COMPONENT,
    OTLN_INVALID
};

enum class COMP_TYPE
{
    COMP_ELEC = 0, //< Component library object is an electrical part
    COMP_MECH,     //< Component library object is a mechanical part
    COMP_INVALID
};

enum class IDF_UNIT
{
    UNIT_MM = 0, //< Units in the file are in millimeters
    UNIT_THOU,   //< Units in the file are in mils (aka thou)
    UNIT_TNM,    //< Deprecated Ten Nanometer Units from IDFv2
    UNIT_INVALID
};

enum class IDF_PLACEMENT
{
    PS_UNPLACED = 0, //< component location on the board has not been specified
    PS_PLACED,       //< component location has been specified and may be modified by ECAD or MCAD
    PS_MCAD,         //< component location has been specified and may only be modified by MCAD
    PS_ECAD,         //< component location has been specified and may only be modified by ECAD
    PS_INVALID
};

double CalcAngleRad( const IDF_POINT& aStartPoint, const IDF_POINT& aEndPoint );

double CalcAngleDeg( const IDF_POINT& aStartPoint, const IDF_POINT& aEndPoint );

void GetOutline( std::list<IDF_SEGMENT*>& aLines, IDF_OUTLINE& aOutline );
 
#ifdef DEBUG_IDF
    // prints out segment information for debug purposes
    void PrintSeg( IDF_SEGMENT* aSegment );
#endif
}
 

class IDF_NOTE
{
public:
    IDF_NOTE();

    void SetText( const std::string& aText );

    void SetPosition( double aXpos, double aYpos );

    void SetSize( double aHeight, double aLength );

    const std::string& GetText();

    void GetPosition( double& aXpos, double& aYpos );

    void GetSize( double& aHeight, double& aLength );
 
private:
    friend class IDF3_BOARD;

    bool readNote( std::istream& aBoardFile, IDF3::FILE_STATE& aBoardState,
                   IDF3::IDF_UNIT aBoardUnit );

    bool writeNote( std::ostream& aBoardFile, IDF3::IDF_UNIT aBoardUnit );
 
    std::string text;   // note text as per IDFv3
    double xpos;        // text X position as per IDFv3
    double ypos;        // text Y position as per IDFv3
    double height;      // text height as per IDFv3
    double length;      // text length as per IDFv3
};
 

class IDF_DRILL_DATA
{
public:
    IDF_DRILL_DATA();

    IDF_DRILL_DATA( double aDrillDia, double aPosX, double aPosY,
                    IDF3::KEY_PLATING aPlating,
                    const std::string& aRefDes,
                    const std::string& aHoleType,
                    IDF3::KEY_OWNER aOwner );

    bool Matches( double aDrillDia, double aPosX, double aPosY ) const;

    double GetDrillDia() const;

    double GetDrillXPos() const;

    double GetDrillYPos() const;

    IDF3::KEY_PLATING GetDrillPlating();

    const std::string& GetDrillRefDes();

    const std::string& GetDrillHoleType();
 
    IDF3::KEY_OWNER GetDrillOwner() const
    {
        return owner;
    }
 
private:
    friend class IDF3_BOARD;
    friend class IDF3_COMPONENT;

    bool read( std::istream& aBoardFile, IDF3::IDF_UNIT aBoardUnit, IDF3::FILE_STATE aBoardState,
               IDF3::IDF_VERSION aIdfVersion );

    void write( std::ostream& aBoardFile, IDF3::IDF_UNIT aBoardUnit );
 
    double dia;
    double x;
    double y;
    IDF3::KEY_PLATING plating;
    IDF3::KEY_REFDES kref;
    IDF3::KEY_HOLETYPE khole;
    std::string refdes;
    std::string holetype;
    IDF3::KEY_OWNER owner;
};
 

class IDF_POINT
{
public:
    IDF_POINT()
    {
        x = 0.0;
        y = 0.0;
    }
 
    IDF_POINT( double aX, double aY )
    {
        x = aX;
        y = aY;
    }

    bool Matches( const IDF_POINT& aPoint, double aRadius = 1e-5 ) const;

    double  CalcDistance( const IDF_POINT& aPoint ) const;
 
    double x;   // < X coordinate
    double y;   // < Y coordinate
};
 

class IDF_SEGMENT
{
public:
    IDF_SEGMENT();

    IDF_SEGMENT( const IDF_POINT& aStartPoint, const IDF_POINT& aEndPoint );

    IDF_SEGMENT( const IDF_POINT& aStartPoint, const IDF_POINT& aEndPoint, double aAngle,
                 bool aFromKicad );

    bool MatchesStart( const IDF_POINT& aPoint, double aRadius = 1e-3 );

    bool MatchesEnd( const IDF_POINT& aPoint, double aRadius = 1e-3 );

    bool IsCircle();

    double GetMinX();

    void SwapEnds();
 
private:
    void CalcCenterAndRadius();
 
public:
    IDF_POINT startPoint;   
    IDF_POINT endPoint;     

    IDF_POINT center;
    double    angle;        
    double    offsetAngle;  
    double    radius;       
};
 

class IDF_OUTLINE
{
public:
    IDF_OUTLINE() { dir = 0.0; }
    ~IDF_OUTLINE() { Clear(); }

    bool IsCCW();

    bool IsCircle();

    void Clear()
    {
        dir = 0.0;
 
        while( !outline.empty() )
        {
            delete outline.front();
            outline.pop_front();
        }
    }

    size_t size()
    {
        return outline.size();
    }

    bool empty()
    {
        return outline.empty();
    }

    IDF_SEGMENT*& front()
    {
        return outline.front();
    }

    IDF_SEGMENT*& back()
    {
        return outline.back();
    }

    std::list<IDF_SEGMENT*>::iterator begin()
    {
        return outline.begin();
    }

    std::list<IDF_SEGMENT*>::iterator end()
    {
        return outline.end();
    }

    bool push( IDF_SEGMENT* item );
 
private:
    double dir;                         // accumulator to help determine winding direction
    std::list<IDF_SEGMENT*> outline;    // sequential segments comprising an outline
};
 
#endif  // IDF_COMMON_H