GdsObjectHelpers.h

Go to the documentation of this file.

 
#ifndef LIMBO_PARSERS_GDSII_GDSDB_GDSOBJECTHELPERS_H
#define LIMBO_PARSERS_GDSII_GDSDB_GDSOBJECTHELPERS_H
 
#include <cmath>
#include <boost/geometry/strategies/transform.hpp>
#include <limbo/parsers/gdsii/stream/GdsReader.h>
#include <limbo/parsers/gdsii/stream/GdsWriter.h>
#include <limbo/preprocessor/Msg.h>

namespace GdsParser 
{
namespace GdsDB 
{

struct GdsObjectHelpers
{
    template <typename ActionType>
    void operator()(::GdsParser::GdsRecords::EnumType type, GdsObject* object, ActionType action) const 
    {
        try
        {
            switch (type)
            {
                case ::GdsParser::GdsRecords::BOUNDARY:
                    {
                        GdsPolygon* ptr = dynamic_cast<GdsPolygon*>(object); 
                        action(type, ptr); 
                    }
                    break;
                case ::GdsParser::GdsRecords::PATH:
                    {
                        GdsPath* ptr = dynamic_cast<GdsPath*>(object); 
                        action(type, ptr); 
                    }
                    break;
                case ::GdsParser::GdsRecords::TEXT:
                    {
                        GdsText* ptr = dynamic_cast<GdsText*>(object); 
                        action(type, ptr); 
                    }
                    break;
                case ::GdsParser::GdsRecords::SREF:
                    {
                        GdsCellReference* ptr = dynamic_cast<GdsCellReference*>(object); 
                        action(type, ptr); 
                    }
                    break;
                case ::GdsParser::GdsRecords::AREF:
                    {
                        GdsCellArray* ptr = dynamic_cast<GdsCellArray*>(object); 
                        action(type, ptr); 
                    }
                    break;
                default:
                    limboAssertMsg(0, "unsupported type %d\n", type); 
            }
        }
        catch (std::exception& e)
        {
            limboPrint(limbo::kERROR, "exception in action %s: %s\n", action.message().c_str(), e.what()); 
            limboAssert(0);
        }
    }
};

struct CopyCellObjectAction
{
    std::pair< ::GdsParser::GdsRecords::EnumType, GdsObject*>& target; 

    CopyCellObjectAction(std::pair< ::GdsParser::GdsRecords::EnumType, GdsObject*>& t) : target(t) {}
    CopyCellObjectAction(CopyCellObjectAction const& rhs) : target(rhs.target) {}

    template <typename ObjectType>
    void operator()(::GdsParser::GdsRecords::EnumType type, ObjectType* object)
    {
        target.first = type;
        target.second = new ObjectType(*object); 
    }

    std::string message() const 
    {
        return "CopyCellObjectAction"; 
    }
}; 

struct DeleteCellObjectAction
{
    std::pair< ::GdsParser::GdsRecords::EnumType, GdsObject*>& target; 

    DeleteCellObjectAction(std::pair< ::GdsParser::GdsRecords::EnumType, GdsObject*>& t) : target(t) {}
    DeleteCellObjectAction(DeleteCellObjectAction const& rhs) : target(rhs.target) {}

    template <typename ObjectType>
    void operator()(::GdsParser::GdsRecords::EnumType /*type*/, ObjectType* object)
    {
        delete object; 
    }

    std::string message() const 
    {
        return "DeleteCellObjectAction"; 
    }
}; 

template <typename GdsWriterType>
struct WriteCellObjectAction
{
    GdsWriterType const& writer; 
    ::GdsParser::GdsWriter& gdsWriter; 
    std::pair< ::GdsParser::GdsRecords::EnumType, GdsObject*> const& target; 

    WriteCellObjectAction(GdsWriterType const& w, ::GdsParser::GdsWriter& gw, std::pair< ::GdsParser::GdsRecords::EnumType, GdsObject*> const& t) : writer(w), gdsWriter(gw), target(t) {}
    WriteCellObjectAction(WriteCellObjectAction const& rhs) : writer(rhs.writer), gdsWriter(rhs.gdsWriter), target(rhs.target) {}

    template <typename ObjectType>
    void operator()(::GdsParser::GdsRecords::EnumType /*type*/, ObjectType* object)
    {
        writer.write(gdsWriter, *object); 
    }

    std::string message() const 
    {
        return "WriteCellObjectAction"; 
    }
}; 

namespace ExtractCellObjectActionDetails 
{

template <typename ObjectType>
inline void extract(GdsDB const& /*gdsDB*/, GdsCell const& /*srcCell*/, GdsCell& targetCell, ::GdsParser::GdsRecords::EnumType type, ObjectType* object)
{
    ObjectType* ptr = new ObjectType (*object); 
    targetCell.objects().push_back(std::make_pair(type, ptr)); 
}

template <>
inline void extract<GdsCellReference>(GdsDB const& gdsDB, GdsCell const& srcCell, GdsCell& targetCell, ::GdsParser::GdsRecords::EnumType type, GdsCellReference* object)
{
    limboAssert(type == ::GdsParser::GdsRecords::SREF);
    limboAssertMsg(srcCell.name() != object->refCell(), "self reference of cell %s", srcCell.name().c_str());
    GdsCell const* refCell = gdsDB.getCell(object->refCell()); 
    limboAssertMsg(refCell, "failed to find reference cell %s", object->refCell().c_str());
    // generate a new cell from reference 
    GdsCell cell = object->extractCellRef(gdsDB, *refCell); 
    // directly append object pointers to target cell 
    targetCell.objects().insert(targetCell.objects().end(), cell.objects().begin(), cell.objects().end()); 
    // must clear the list, otherwise, the pointers are destroyed 
    cell.objects().clear(); 
}

template <>
inline void extract<GdsCellArray>(GdsDB const& /*gdsDB*/, GdsCell const& /*srcCell*/, GdsCell& /*targetCell*/, ::GdsParser::GdsRecords::EnumType type, GdsCellArray* /*object*/)
{
    limboAssert(type == ::GdsParser::GdsRecords::AREF);
    limboAssertMsg(0, "not implemented yet"); 
}
 
} // namespace ExtractCellObjectActionDetails

struct ExtractCellObjectAction
{
    GdsDB const& gdsDB; 
    GdsCell const& srcCell; 
    GdsCell& targetCell; 

    ExtractCellObjectAction(GdsDB const& db, GdsCell const& sc, GdsCell& tc) : gdsDB(db), srcCell(sc), targetCell(tc) {}
    ExtractCellObjectAction(ExtractCellObjectAction const& rhs) : gdsDB(rhs.gdsDB), srcCell(rhs.srcCell), targetCell(rhs.targetCell) {}

    template <typename ObjectType>
    void operator()(::GdsParser::GdsRecords::EnumType type, ObjectType* object)
    {
        ExtractCellObjectActionDetails::extract(gdsDB, srcCell, targetCell, type, object);
    }

    std::string message() const 
    {
        return "ExtractCellObjectAction"; 
    }
};

namespace ApplyCellReferenceActionDetails 
{

template<typename PointType>
struct Translate 
{
    PointType offset; 

    Translate(PointType const& o) : offset(o) {}

    void operator()(PointType& p) const 
    {
        p = gtl::construct<PointType>(p.x()+offset.x(), p.y()+offset.y());
    }
};

template<typename PointType>
struct Rotate 
{
    double angle; 
    double cosAngle; 
    double sinAngle; 

    Rotate(double a) : angle(a) 
    {
        cosAngle = cos(angle/180.0*M_PI);
        sinAngle = sin(angle/180.0*M_PI);
    }

    void operator()(PointType& p) const 
    {
        p = gtl::construct<PointType>(
                p.x()*cosAngle - p.y()*sinAngle, 
                p.x()*sinAngle + p.y()*cosAngle
                );
    }
};

template<typename PointType>
struct MagScale 
{
    double scaleX; 
    double scaleY; 

    MagScale(double sx, double sy) : scaleX(sx), scaleY(sy) {}

    void operator()(PointType& p) const 
    {
        p = gtl::construct<PointType>(p.x()*scaleX, p.y()*scaleY);
    }
};

template<typename PointType>
struct XReflection
{
    void operator()(PointType& p) const 
    {
        p = gtl::construct<PointType>(p.x(), -p.y());
    }
};

template <typename Iterator, typename TransformerType>
inline void transform(Iterator first, Iterator last, TransformerType transform)
{
    for (; first != last; ++first)
        transform(*first);
}

template <typename ObjectType>
inline void copyToArray(std::vector<GdsCellReference::point_type>& vPoint, ObjectType* object)
{
    vPoint.assign(object->begin(), object->end());
}

template <>
inline void copyToArray<GdsText>(std::vector<GdsCellReference::point_type>& vPoint, GdsText* object)
{
    vPoint.assign(1, object->position());
}

template <typename ObjectType>
inline void copyFromArray(std::vector<GdsCellReference::point_type> const& vPoint, ObjectType* object)
{
    object->set(vPoint.begin(), vPoint.end());
}

template <>
inline void copyFromArray<GdsText>(std::vector<GdsCellReference::point_type> const& vPoint, GdsText* object)
{
    object->setPosition(vPoint.front());
}

template <typename ObjectType>
inline void apply(GdsCellReference const& cellRef, ObjectType* object)
{
    std::vector<GdsCellReference::point_type> vPoint; 
    std::vector<GdsCellReference::float_point_type> vFloatPoint; 
    copyToArray(vPoint, object);
  // copy to temporary float point array 
  // use float point type to avoid numerical issues 
  vFloatPoint.reserve(vPoint.size());
  for (std::vector<GdsCellReference::point_type>::const_iterator it = vPoint.begin(); it != vPoint.end(); ++it)
  {
    vFloatPoint.push_back(gtl::construct<GdsCellReference::float_point_type>(it->x(), it->y())); 
  }
    // the order must be kept according to the manual 
    // strans
    if (cellRef.strans() != std::numeric_limits<int>::max() && (cellRef.strans() & 0x8000)) // apply x reflection 
    {
        transform(vFloatPoint.begin(), vFloatPoint.end(), XReflection<GdsCellReference::float_point_type>()); 
    }
    // magnification, magnification bit in strans must be set to 1 (KLayout does not honor this bit) 
    if (/*(cellRef.strans() & 0x4) &&*/ cellRef.magnification() != std::numeric_limits<double>::max())
    {
        transform(vFloatPoint.begin(), vFloatPoint.end(), MagScale<GdsCellReference::float_point_type>(cellRef.magnification(), cellRef.magnification())); 
    }
    // angle, angle bit in strans must be set to 1 (KLayout does not honor this bit)
    if (/*(cellRef.strans() & 0x2) &&*/ cellRef.angle() != std::numeric_limits<double>::max())
    {
        transform(vFloatPoint.begin(), vFloatPoint.end(), Rotate<GdsCellReference::float_point_type>(cellRef.angle())); 
    }
    // position offset 
    if (cellRef.position().x() != std::numeric_limits<int>::max() && cellRef.position().y() != std::numeric_limits<int>::max())
    {
        transform(vFloatPoint.begin(), vFloatPoint.end(), Translate<GdsCellReference::float_point_type>(cellRef.position())); 
    }
 
  // copy back 
  vPoint.clear();
  for (std::vector<GdsCellReference::float_point_type>::const_iterator it = vFloatPoint.begin(); it != vFloatPoint.end(); ++it)
  {
    vPoint.push_back(gtl::construct<GdsCellReference::point_type>(round(it->x()), round(it->y()))); 
  }
    copyFromArray(vPoint, object);
}

template <>
inline void apply<GdsCellReference>(GdsCellReference const& /*cellRef*/, GdsCellReference* /*object*/)
{
    limboAssertMsg(0, "should not arrive here"); 
}

template <>
inline void apply<GdsCellArray>(GdsCellReference const& /*cellRef*/, GdsCellArray* /*object*/)
{
    limboAssertMsg(0, "should not arrive here"); 
}
 
} // namespace ApplyCellReferenceActionDetails

struct ApplyCellReferenceAction
{
    GdsCellReference const& cellRef; 

    ApplyCellReferenceAction(GdsCellReference const& cr) : cellRef(cr) {}
    ApplyCellReferenceAction(ApplyCellReferenceAction const& rhs) : cellRef(rhs.cellRef) {}

    template <typename ObjectType>
    void operator()(::GdsParser::GdsRecords::EnumType /*type*/, ObjectType* object)
    {
        ApplyCellReferenceActionDetails::apply(cellRef, object);
    }

    std::string message() const 
    {
        return "ApplyCellReferenceAction"; 
    }
};
 
} // namespace GdsDB
} // namespace GdsParser
 
#endif