GdsObjects.h

Go to the documentation of this file.

#ifndef LIMBO_PARSERS_GDSII_GDSDB_GDSOBJECTS_H
#define LIMBO_PARSERS_GDSII_GDSDB_GDSOBJECTS_H

#include <boost/geometry.hpp>
// use adapted boost.polygon in boost.geometry, which is compatible to rtree
#include <boost/geometry/geometries/adapted/boost_polygon.hpp>
#include <boost/geometry/geometries/geometries.hpp>
#include <limbo/parsers/gdsii/stream/GdsReader.h>

namespace GdsParser 
{
namespace GdsDB 
{

// some shortcuts for namespace 
namespace gtl = boost::polygon;
namespace bg = boost::geometry;

// forward declaration 
class GdsCell; 
class GdsDB; 

class GdsObject 
{
    public:
        typedef int coordinate_type;
        typedef gtl::point_data<coordinate_type> point_type;
        typedef gtl::interval_data<coordinate_type> interval_type; 
        typedef gtl::rectangle_data<coordinate_type> rectangle_type;
        typedef gtl::polygon_data<coordinate_type> polygon_type;
        typedef gtl::polygon_90_set_data<coordinate_type> polygon_set_type;

        GdsObject();
        GdsObject(GdsObject const& rhs);
        GdsObject& operator=(GdsObject const& rhs);
        virtual ~GdsObject(); 
};

class GdsShape : public GdsObject
{
    public:
        typedef GdsObject base_type;

        GdsShape();
        GdsShape(GdsShape const& rhs); 
        GdsShape& operator=(GdsShape const& rhs); 
        ~GdsShape(); 

        // accessors
        int layer() const {return m_layer;}
        void setLayer(int l) {m_layer = l;}

        int datatype() const {return m_datatype;}
        void setDatatype(int d) {m_datatype = d;}
    protected:
        int m_layer; 
        int m_datatype; 
};

class GdsRectangle : public GdsShape, public gtl::rectangle_data<int>
{
    public:
        typedef GdsShape base_type; 
        typedef gtl::rectangle_data<int> base_ext_type; 

        GdsRectangle(); 
        GdsRectangle(GdsRectangle const& rhs); 
        GdsRectangle& operator=(GdsRectangle const& rhs);
        ~GdsRectangle(); 
};

class GdsPolygon : public GdsShape, public gtl::polygon_data<GdsShape::coordinate_type>
{
    public:
        typedef GdsShape base_type; 
        typedef gtl::polygon_data<GdsShape::coordinate_type> base_ext_type; 
        typedef base_type::coordinate_type coordinate_type; 
        typedef base_type::point_type point_type; 

        GdsPolygon(); 
        GdsPolygon(GdsPolygon const& rhs); 
        GdsPolygon& operator=(GdsPolygon const& rhs);
        ~GdsPolygon(); 
};

class GdsPath : public GdsShape, public bg::model::linestring<GdsShape::point_type>
{
    public:
        typedef GdsShape base_type; 
        typedef bg::model::linestring<GdsShape::point_type> base_ext_type; 

        GdsPath(); 
        GdsPath(GdsPath const& rhs); 
        GdsPath& operator=(GdsPath const& rhs);
        ~GdsPath(); 

        // accessors 
        int pathtype() const {return m_pathtype;}
        void setPathtype(int p) {m_pathtype = p;}

        coordinate_type width() const {return m_width;}
        void setWidth(coordinate_type w) {m_width = w;}

        template <typename Iterator>
        void set(Iterator first, Iterator last) {this->assign(first, last);}

        GdsPolygon toPolygon() const; 
    protected:
        int m_pathtype; 
        coordinate_type m_width; 
};

class GdsText : public GdsShape
{
    public:
        typedef GdsShape base_type; 

        GdsText(); 
        GdsText(GdsText const& rhs); 
        GdsText& operator=(GdsText const& rhs);
        ~GdsText(); 

        // accessors 
        int texttype() const {return m_texttype;}
        void setTexttype(int t) {m_texttype = t;}

        std::string const& text() const {return m_text;}
        void setText(std::string const& t) {m_text = t;}

        int width() const {return m_width;}
        void setWidth(int w) {m_width = w;}

        point_type const& position() const {return m_position;}
        void setPosition(point_type const& p) {m_position = p;}

        int presentation() const {return m_presentation;}
        void setPresentation(int p) {m_presentation = p;}

        double angle() const {return m_angle;}
        void setAngle(double a) {m_angle = a;}

        double magnification() const {return m_magnification;}
        void setMagnification(double m) {m_magnification = m;}

        int strans() const {return m_strans;}
        void setStrans(int s) {m_strans = s;}
    protected:
        int m_texttype; 
        std::string m_text; 
        point_type m_position; 
        int m_width; 
        int m_presentation; 
        double m_angle; 
        double m_magnification; 
        int m_strans; 
};

class GdsCellReference : public GdsObject
{
    public:
        typedef GdsObject base_type; 

        GdsCellReference(); 
        GdsCellReference(GdsCellReference const& rhs); 
        GdsCellReference& operator=(GdsCellReference const& rhs);
        ~GdsCellReference(); 

        // accessors 
        std::string const& refCell() const {return m_refCell;}
        void setRefCell(std::string const& r) {m_refCell = r;}

        point_type const& position() const {return m_position;}
        void setPosition(point_type const& p) {m_position = p;}

        double angle() const {return m_angle;}
        void setAngle(double a) {m_angle = a;}

        double magnification() const {return m_magnification;}
        void setMagnification(double m) {m_magnification = m;}

        int strans() const {return m_strans;}
        void setStrans(int s) {m_strans = s;}

        GdsCell extractCellRef(GdsDB const& gdsDB, GdsCell const& srcCell) const; 
    protected:
        std::string m_refCell; 
        point_type m_position; 
        double m_angle; 
        double m_magnification; 
        int m_strans; 
};

class GdsCellArray : public GdsObject
{
    public:
        typedef GdsObject base_type; 

        GdsCellArray(); 
        GdsCellArray(GdsCellArray const& rhs); 
        GdsCellArray& operator=(GdsCellArray const& rhs);
        ~GdsCellArray(); 

        // accessors 
        std::string const& refCell() const {return m_refCell;}
        void setRefCell(std::string const& r) {m_refCell = r;}

        int columns() const {return m_columns;}
        void setColumns(int c) {m_columns = c;}

        int rows() const {return m_rows;}
        void setRows(int r) {m_rows = r;}

        coordinate_type spacing(unsigned int idx) const {return m_spacing[idx];}
        void setSpacing(unsigned int idx, coordinate_type s) {m_spacing[idx] = s;}

        std::vector<point_type> const& positions() const {return m_vPosition;}
        std::vector<point_type>& positions() {return m_vPosition;}

        double angle() const {return m_angle;}
        void setAngle(double a) {m_angle = a;}

        double magnification() const {return m_magnification;}
        void setMagnification(double m) {m_magnification = m;}

        int strans() const {return m_strans;}
        void setStrans(int s) {m_strans = s;}
    protected:
        std::string m_refCell; 
        int m_columns; 
        int m_rows; 
        coordinate_type m_spacing[2]; 
        std::vector<point_type> m_vPosition; 
        double m_angle; 
        double m_magnification; 
        int m_strans; 
};

class GdsCell : public GdsObject
{
    public:
        typedef GdsObject base_type; 
        typedef std::pair< ::GdsParser::GdsRecords::EnumType, GdsObject*> object_entry_type; 

        GdsCell(); 
        GdsCell(GdsCell const& rhs); 
        GdsCell& operator=(GdsCell const& rhs);
        ~GdsCell(); 

        void addPolygon(int layer, int datatype, std::vector<point_type> const& vPoint); 
        void addPath(int layer, int datatype, int pathtype, int width, std::vector<point_type> const& vPoint);
        void addText(int layer, int datatype, int texttype, std::string const& str, point_type const& position, int width, int presentation, double angle, double magnification, int strans); 
        void addCellReference(std::string const& sname, point_type const& position, double angle, double magnification, int strans); 
        void addCellArray(std::string const& sname, int columns, int rows, int spacing[2], std::vector<point_type> const& vPosition, double angle, double magnification, int strans); 

        // accessors 
        std::string const& name() const {return m_name;}
        void setName(std::string const& n) {m_name = n;}

        std::vector<std::pair< ::GdsParser::GdsRecords::EnumType, GdsObject*> > const& objects() const {return m_vObject;}
        std::vector<std::pair< ::GdsParser::GdsRecords::EnumType, GdsObject*> >& objects() {return m_vObject;}
    protected:
        void copy(GdsCell const& rhs); 
        void destroy(); 

        std::string m_name; 
        std::vector<object_entry_type> m_vObject; 
};

class GdsDB : public GdsObject
{
    public:
        typedef GdsObject base_type; 

        GdsDB();
        GdsDB(GdsDB const& rhs);
        GdsDB& operator=(GdsDB const& rhs);
        ~GdsDB();

        GdsCell& addCell(std::string const& name = ""); 
        GdsCell& addCell(GdsCell const& cell); 

        // accessors 
        std::string const& header() const {return m_header;}
        void setHeader(std::string const& h) {m_header = h;}
        void setHeader(int h); 

        std::string const& libname() const {return m_libname;}
        void setLibname(std::string const& n) {m_libname = n;}

        double unit() const {return m_unit;}
        void setUnit(double u) {m_unit = u;}

        double precision() const {return m_precision;}
        void setPrecision(double p) {m_precision = p;}

        std::vector<GdsCell> const& cells() const {return m_vCell;}
        std::vector<GdsCell>& cells() {return m_vCell;}

        GdsCell const* getCell(std::string const& cellName) const; 
        GdsCell* getCell(std::string const& cellName); 

        GdsCell extractCell(std::string const& cellName) const; 
    protected:
        std::string m_header; 
        std::string m_libname; 
        double m_unit; 
        double m_precision; 
        std::vector<GdsCell> m_vCell; 
        std::map<std::string, unsigned int> m_mCellName2Idx; 
};

} // namespace GdsDB 
} // namespace GdsParser


namespace boost { namespace geometry { namespace traits {


template <>
struct tag<GdsParser::GdsDB::GdsRectangle > : public tag<GdsParser::GdsDB::GdsRectangle::base_ext_type>
{
};
template <>
struct point_type<GdsParser::GdsDB::GdsRectangle >
{
    typedef GdsParser::GdsDB::GdsRectangle::point_type type;
};


template <>
struct tag<GdsParser::GdsDB::GdsPolygon > : public tag<GdsParser::GdsDB::GdsPolygon::base_ext_type>
{
};
template <>
struct point_type<GdsParser::GdsDB::GdsPolygon >
{
    typedef GdsParser::GdsDB::GdsObject::point_type type;
};

}}} // namespace boost // namespace geometry // namespace traits

namespace boost { namespace polygon {

template <>
struct geometry_concept<GdsParser::GdsDB::GdsRectangle> 
{
    typedef rectangle_concept type;
};

template <>
struct geometry_concept<GdsParser::GdsDB::GdsPolygon> 
{
    typedef polygon_concept type;
};

}} // namespace boost // namespace polygon

#endif