Merge pull request #2 from FOSSEE/develop

Develop

1 files changed, 811 insertions, 0 deletions

diff --git a/gerbview/class_aperture_macro.cpp b/gerbview/class_aperture_macro.cpp
new file mode 100644
index 0000000..0c48a5b
--- /dev/null
+++ b/gerbview/class_aperture_macro.cpp
@@ -0,0 +1,811 @@
+/**
+ * @file class_aperture_macro.cpp
+ */
+
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 1992-2010 Jean-Pierre Charras <jean-pierre.charras@gipsa-lab.inpg.fr>
+ * Copyright (C) 2010 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
+ * Copyright (C) 1992-2010 KiCad Developers, see change_log.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, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <fctsys.h>
+#include <common.h>
+#include <macros.h>
+#include <trigo.h>
+#include <gr_basic.h>
+
+#include <gerbview.h>
+#include <class_GERBER.h>
+
+
+
+/**
+ * Function scaletoIU
+ * converts a distance given in floating point to our internal units
+ */
+extern int scaletoIU( double aCoord, bool isMetric );       // defined it rs274d_read_XY_and_IJ_coordiantes.cpp
+
+/**
+ * Function mapPt
+ * translates a point from the aperture macro coordinate system to our
+ * deci-mils coordinate system.
+ * @return wxPoint - The GerbView coordinate system vector.
+ */
+static wxPoint mapPt( double x, double y, bool isMetric )
+{
+    wxPoint ret( scaletoIU( x, isMetric ), scaletoIU( y, isMetric ) );
+
+    return ret;
+}
+
+/**
+ * Function mapExposure
+ * translates the first parameter from an aperture macro into a current
+ * exposure setting.
+ * @param aParent = a GERBER_DRAW_ITEM that handle:
+ *    ** m_Exposure A dynamic setting which can change throughout the
+ *          reading of the gerber file, and it indicates whether the current tool
+ *          is lit or not.
+ *    ** m_ImageNegative A dynamic setting which can change throughout the reading
+ *          of the gerber file, and it indicates whether the current D codes are to
+ *          be interpreted as erasures or not.
+ * @return true to draw with current color, false to draw with alt color (erase)
+ */
+bool AM_PRIMITIVE::mapExposure( GERBER_DRAW_ITEM* aParent )
+{
+    bool exposure;
+    switch( primitive_id )
+    {
+    case AMP_CIRCLE:
+    case AMP_LINE2:
+    case AMP_LINE20:
+    case AMP_LINE_CENTER:
+    case AMP_LINE_LOWER_LEFT:
+    case AMP_OUTLINE:
+    case AMP_THERMAL:
+    case AMP_POLYGON:
+        // All have an exposure parameter and can return true or false
+        switch( GetExposure(aParent) )
+        {
+        case 0:     // exposure always OFF
+            exposure = false;
+            break;
+
+        default:
+        case 1:     // exposure always OON
+            exposure = true;
+            break;
+
+        case 2:     // reverse exposure
+            exposure = !aParent->GetLayerPolarity();
+        }
+        break;
+
+    case AMP_MOIRE:
+    case AMP_EOF:
+    case AMP_UNKNOWN:
+    default:
+        return true;    // All have no exposure parameter and must return true (no change for exposure)
+        break;
+    }
+
+    return exposure ^ aParent->m_imageParams->m_ImageNegative;
+}
+
+
+/**
+ * Function GetExposure
+ * returns the first parameter in integer form.  Some but not all primitives
+ * use the first parameter as an exposure control.
+ */
+int AM_PRIMITIVE::GetExposure(GERBER_DRAW_ITEM* aParent) const
+{
+    // No D_CODE* for GetValue()
+    wxASSERT( params.size() && params[0].IsImmediate() );
+    return (int) params[0].GetValue( aParent->GetDcodeDescr() );
+}
+
+/**
+ * Function DrawBasicShape
+ * Draw the primitive shape for flashed items.
+ */
+void AM_PRIMITIVE::DrawBasicShape( GERBER_DRAW_ITEM* aParent,
+                                   EDA_RECT* aClipBox,
+                                   wxDC* aDC,
+                                   EDA_COLOR_T aColor, EDA_COLOR_T aAltColor,
+                                   wxPoint aShapePos,
+                                   bool aFilledShape )
+{
+    static std::vector<wxPoint> polybuffer;     // create a static buffer to avoid a lot of memory reallocation
+    polybuffer.clear();
+
+    wxPoint curPos = aShapePos;
+    D_CODE* tool   = aParent->GetDcodeDescr();
+    double rotation;
+    if( mapExposure( aParent ) == false )
+    {
+        std::swap( aColor, aAltColor );
+    }
+
+    switch( primitive_id )
+    {
+    case AMP_CIRCLE:        // Circle, given diameter and position
+    {
+        /* Generated by an aperture macro declaration like:
+         * "1,1,0.3,0.5, 1.0*"
+         * type (1), exposure, diameter, pos.x, pos.y
+         * type is not stored in parameters list, so the first parameter is exposure
+         */
+        curPos += mapPt( params[2].GetValue( tool ), params[3].GetValue( tool ), m_GerbMetric );
+        curPos = aParent->GetABPosition( curPos );
+        int radius = scaletoIU( params[1].GetValue( tool ), m_GerbMetric ) / 2;
+        if( !aFilledShape )
+            GRCircle( aClipBox, aDC, curPos, radius, 0, aColor );
+        else
+            GRFilledCircle( aClipBox, aDC, curPos, radius, aColor );
+    }
+    break;
+
+    case AMP_LINE2:
+    case AMP_LINE20:        // Line with rectangle ends. (Width, start and end pos + rotation)
+    {
+        /* Generated by an aperture macro declaration like:
+         * "2,1,0.3,0,0, 0.5, 1.0,-135*"
+         * type (2), exposure, width, start.x, start.y, end.x, end.y, rotation
+         * type is not stored in parameters list, so the first parameter is exposure
+         */
+        ConvertShapeToPolygon( aParent, polybuffer );
+
+        // shape rotation:
+        rotation = params[6].GetValue( tool ) * 10.0;
+        if( rotation != 0)
+        {
+            for( unsigned ii = 0; ii < polybuffer.size(); ii++ )
+                RotatePoint( &polybuffer[ii], -rotation );
+        }
+
+        // Move to current position:
+        for( unsigned ii = 0; ii < polybuffer.size(); ii++ )
+        {
+            polybuffer[ii] += curPos;
+            polybuffer[ii] = aParent->GetABPosition( polybuffer[ii] );
+        }
+
+        GRClosedPoly( aClipBox, aDC,
+                      polybuffer.size(), &polybuffer[0], aFilledShape, aColor, aColor );
+    }
+    break;
+
+    case AMP_LINE_CENTER:
+    {
+        /* Generated by an aperture macro declaration like:
+         * "21,1,0.3,0.03,0,0,-135*"
+         * type (21), exposure, ,width, height, center pos.x, center pos.y, rotation
+         * type is not stored in parameters list, so the first parameter is exposure
+         */
+        ConvertShapeToPolygon( aParent, polybuffer );
+
+        // shape rotation:
+        rotation = params[5].GetValue( tool ) * 10.0;
+        if( rotation != 0 )
+        {
+            for( unsigned ii = 0; ii < polybuffer.size(); ii++ )
+                RotatePoint( &polybuffer[ii], -rotation );
+        }
+
+        // Move to current position:
+        for( unsigned ii = 0; ii < polybuffer.size(); ii++ )
+        {
+            polybuffer[ii] += curPos;
+            polybuffer[ii] = aParent->GetABPosition( polybuffer[ii] );
+        }
+
+        GRClosedPoly( aClipBox, aDC,
+                      polybuffer.size(), &polybuffer[0], aFilledShape, aColor, aColor );
+    }
+    break;
+
+    case AMP_LINE_LOWER_LEFT:
+    {
+        /* Generated by an aperture macro declaration like:
+         * "22,1,0.3,0.03,0,0,-135*"
+         * type (22), exposure, ,width, height, corner pos.x, corner pos.y, rotation
+         * type is not stored in parameters list, so the first parameter is exposure
+         */
+        ConvertShapeToPolygon( aParent, polybuffer );
+
+        // shape rotation:
+        rotation = params[5].GetValue( tool ) * 10.0;
+        if( rotation != 0)
+        {
+            for( unsigned ii = 0; ii < polybuffer.size(); ii++ )
+                RotatePoint( &polybuffer[ii], -rotation );
+        }
+
+        // Move to current position:
+        for( unsigned ii = 0; ii < polybuffer.size(); ii++ )
+        {
+            polybuffer[ii] += curPos;
+            polybuffer[ii] = aParent->GetABPosition( polybuffer[ii] );
+        }
+
+        GRClosedPoly( aClipBox, aDC,
+                      polybuffer.size(), &polybuffer[0], aFilledShape, aColor, aColor );
+    }
+    break;
+
+    case AMP_THERMAL:
+    {
+        /* Generated by an aperture macro declaration like:
+         * "7, 0,0,1.0,0.3,0.01,-13*"
+         * type (7), center.x , center.y, outside diam, inside diam, crosshair thickness, rotation
+         * type is not stored in parameters list, so the first parameter is center.x
+         */
+        curPos += mapPt( params[0].GetValue( tool ), params[1].GetValue( tool ), m_GerbMetric );
+        ConvertShapeToPolygon( aParent, polybuffer );
+
+        // shape rotation:
+        rotation = params[5].GetValue( tool ) * 10.0;
+
+        // Because a thermal shape has 4 identical sub-shapes, only one is created in polybuffer.
+        // We must draw 4 sub-shapes rotated by 90 deg
+        std::vector<wxPoint> subshape_poly;
+        for( int ii = 0; ii < 4; ii++ )
+        {
+            subshape_poly = polybuffer;
+            double sub_rotation = rotation + 900 * ii;
+            for( unsigned jj = 0; jj < subshape_poly.size(); jj++ )
+                RotatePoint( &subshape_poly[jj], -sub_rotation );
+
+            // Move to current position:
+            for( unsigned jj = 0; jj < subshape_poly.size(); jj++ )
+            {
+                subshape_poly[jj] += curPos;
+                subshape_poly[jj] = aParent->GetABPosition( subshape_poly[jj] );
+            }
+
+            GRClosedPoly( aClipBox, aDC,
+                          subshape_poly.size(), &subshape_poly[0], true, aAltColor,
+                          aAltColor );
+        }
+    }
+    break;
+
+    case AMP_MOIRE:     // A cross hair with n concentric circles
+    {
+        curPos += mapPt( params[0].GetValue( tool ), params[1].GetValue( tool ),
+                         m_GerbMetric );
+
+        /* Generated by an aperture macro declaration like:
+         * "6,0,0,0.125,.01,0.01,3,0.003,0.150,0"
+         * type(6), pos.x, pos.y, diam, penwidth, gap, circlecount, crosshair thickness, crosshaire len, rotation
+         * type is not stored in parameters list, so the first parameter is pos.x
+         */
+        int outerDiam    = scaletoIU( params[2].GetValue( tool ), m_GerbMetric );
+        int penThickness = scaletoIU( params[3].GetValue( tool ), m_GerbMetric );
+        int gap = scaletoIU( params[4].GetValue( tool ), m_GerbMetric );
+        int numCircles = KiROUND( params[5].GetValue( tool ) );
+
+        // Draw circles:
+        wxPoint center = aParent->GetABPosition( curPos );
+        // adjust outerDiam by this on each nested circle
+        int diamAdjust = (gap + penThickness); //*2;     //Should we use * 2 ?
+        for( int i = 0; i < numCircles; ++i, outerDiam -= diamAdjust )
+        {
+            if( outerDiam <= 0 )
+                break;
+            if( !aFilledShape )
+            {
+                // draw the border of the pen's path using two circles, each as narrow as possible
+                GRCircle( aClipBox, aDC, center, outerDiam / 2, 0, aColor );
+                GRCircle( aClipBox, aDC, center, outerDiam / 2 - penThickness, 0, aColor );
+            }
+            else    // Filled mode
+            {
+                GRCircle( aClipBox, aDC, center,
+                          (outerDiam - penThickness) / 2, penThickness, aColor );
+            }
+        }
+
+        // Draw the cross:
+        ConvertShapeToPolygon( aParent, polybuffer );
+
+        rotation = params[8].GetValue( tool ) * 10.0;
+        for( unsigned ii = 0; ii < polybuffer.size(); ii++ )
+        {
+            // shape rotation:
+            RotatePoint( &polybuffer[ii], -rotation );
+            // Move to current position:
+            polybuffer[ii] += curPos;
+            polybuffer[ii] = aParent->GetABPosition( polybuffer[ii] );
+        }
+
+        GRClosedPoly( aClipBox, aDC,
+                      polybuffer.size(), &polybuffer[0], aFilledShape, aColor, aColor );
+    }
+    break;
+
+    case AMP_OUTLINE:
+    {
+        /* Generated by an aperture macro declaration like:
+         * "4,1,3,0.0,0.0,0.0,0.5,0.5,0.5,0.5,0.0,-25"
+         * type(4), exposure, corners count, corner1.x, corner.1y, ..., rotation
+         * type is not stored in parameters list, so the first parameter is exposure
+         */
+        int numPoints = (int) params[1].GetValue( tool );
+        rotation  = params[numPoints * 2 + 4].GetValue( tool ) * 10.0;
+        wxPoint pos;
+        // Read points. numPoints does not include the starting point, so add 1.
+        for( int i = 0; i<numPoints + 1; ++i )
+        {
+            int jj = i * 2 + 2;
+            pos.x = scaletoIU( params[jj].GetValue( tool ), m_GerbMetric );
+            pos.y = scaletoIU( params[jj + 1].GetValue( tool ), m_GerbMetric );
+            polybuffer.push_back(pos);
+        }
+        // rotate polygon and move it to the actual position
+        // shape rotation:
+        for( unsigned ii = 0; ii < polybuffer.size(); ii++ )
+        {
+            RotatePoint( &polybuffer[ii], -rotation );
+       }
+
+        // Move to current position:
+        for( unsigned ii = 0; ii < polybuffer.size(); ii++ )
+        {
+            polybuffer[ii] += curPos;
+            polybuffer[ii] = aParent->GetABPosition( polybuffer[ii] );
+        }
+
+        GRClosedPoly( aClipBox, aDC,
+                      polybuffer.size(), &polybuffer[0], aFilledShape, aColor, aColor );
+    }
+    break;
+
+    case AMP_POLYGON:   // Is a regular polygon
+        /* Generated by an aperture macro declaration like:
+         * "5,1,0.6,0,0,0.5,25"
+         * type(5), exposure, vertices count, pox.x, pos.y, diameter, rotation
+         * type is not stored in parameters list, so the first parameter is exposure
+         */
+        curPos += mapPt( params[2].GetValue( tool ), params[3].GetValue( tool ), m_GerbMetric );
+        // Creates the shape:
+        ConvertShapeToPolygon( aParent, polybuffer );
+
+        // rotate polygon and move it to the actual position
+        rotation  = params[5].GetValue( tool ) * 10.0;
+        for( unsigned ii = 0; ii < polybuffer.size(); ii++ )
+        {
+            RotatePoint( &polybuffer[ii], -rotation );
+            polybuffer[ii] += curPos;
+            polybuffer[ii] = aParent->GetABPosition( polybuffer[ii] );
+        }
+        GRClosedPoly( aClipBox, aDC,
+                      polybuffer.size(), &polybuffer[0], aFilledShape, aColor, aColor );
+        break;
+
+    case AMP_EOF:
+        // not yet supported, waiting for you.
+        break;
+
+    case AMP_UNKNOWN:
+    default:
+        DBG( printf( "AM_PRIMITIVE::DrawBasicShape() err: unknown prim id %d\n",primitive_id) );
+        break;
+    }
+}
+
+
+/**
+ * Function ConvertShapeToPolygon (virtual)
+ * convert a shape to an equivalent polygon.
+ * Arcs and circles are approximated by segments
+ * Useful when a shape is not a graphic primitive (shape with hole,
+ * rotated shape ... ) and cannot be easily drawn.
+ * note for some schapes conbining circles and solid lines (rectangles), only rectangles are converted
+ * because circles are very easy to draw (no rotation problem) so convert them in polygons,
+ * and draw them as polygons is not a good idea.
+ */
+void AM_PRIMITIVE::ConvertShapeToPolygon( GERBER_DRAW_ITEM*     aParent,
+                                          std::vector<wxPoint>& aBuffer )
+{
+    D_CODE* tool = aParent->GetDcodeDescr();
+
+    switch( primitive_id )
+    {
+    case AMP_CIRCLE:        // Circle, currently convertion not needed
+        break;
+
+    case AMP_LINE2:
+    case AMP_LINE20:        // Line with rectangle ends. (Width, start and end pos + rotation)
+    {
+        int     width = scaletoIU( params[1].GetValue( tool ), m_GerbMetric );
+        wxPoint start = mapPt( params[2].GetValue( tool ),
+                               params[3].GetValue( tool ), m_GerbMetric );
+        wxPoint end = mapPt( params[4].GetValue( tool ),
+                             params[5].GetValue( tool ), m_GerbMetric );
+        wxPoint delta = end - start;
+        int     len   = KiROUND( EuclideanNorm( delta ) );
+
+        // To build the polygon, we must create a horizonta polygon starting to "start"
+        // and rotate it to have it end point to "end"
+        wxPoint currpt;
+        currpt.y += width / 2;          // Upper left
+        aBuffer.push_back( currpt );
+        currpt.x = len;                 // Upper right
+        aBuffer.push_back( currpt );
+        currpt.y -= width;              // lower right
+        aBuffer.push_back( currpt );
+        currpt.x = 0;                   // Upper left
+        aBuffer.push_back( currpt );
+
+        // Rotate rectangle and move it to the actual start point
+        double angle = ArcTangente( delta.y, delta.x );
+
+        for( unsigned ii = 0; ii < 4; ii++ )
+        {
+            RotatePoint( &aBuffer[ii], -angle );
+            aBuffer[ii] += start;
+        }
+    }
+    break;
+
+    case AMP_LINE_CENTER:
+    {
+        wxPoint size = mapPt( params[1].GetValue( tool ), params[2].GetValue( tool ), m_GerbMetric );
+        wxPoint pos  = mapPt( params[3].GetValue( tool ), params[4].GetValue( tool ), m_GerbMetric );
+
+        // Build poly:
+        pos.x -= size.x / 2;
+        pos.y -= size.y / 2;        // Lower left
+        aBuffer.push_back( pos );
+        pos.y += size.y;            // Upper left
+        aBuffer.push_back( pos );
+        pos.x += size.x;            // Upper right
+        aBuffer.push_back( pos );
+        pos.y -= size.y;            // lower right
+        aBuffer.push_back( pos );
+    }
+    break;
+
+    case AMP_LINE_LOWER_LEFT:
+    {
+        wxPoint size = mapPt( params[1].GetValue( tool ), params[2].GetValue( tool ), m_GerbMetric );
+        wxPoint lowerLeft = mapPt( params[3].GetValue( tool ), params[4].GetValue(
+                                       tool ), m_GerbMetric );
+
+        // Build poly:
+        aBuffer.push_back( lowerLeft );
+        lowerLeft.y += size.y;          // Upper left
+        aBuffer.push_back( lowerLeft );
+        lowerLeft.x += size.x;          // Upper right
+        aBuffer.push_back( lowerLeft );
+        lowerLeft.y -= size.y;          // lower right
+        aBuffer.push_back( lowerLeft );
+    }
+    break;
+
+    case AMP_THERMAL:
+    {
+        // Only 1/4 of the full shape is built, because the other 3 shapes will be draw from this first
+        // rotated by 90, 180 and 270 deg.
+        // params = center.x (unused here), center.y (unused here), outside diam, inside diam, crosshair thickness
+        int outerRadius   = scaletoIU( params[2].GetValue( tool ), m_GerbMetric ) / 2;
+        int innerRadius   = scaletoIU( params[3].GetValue( tool ), m_GerbMetric ) / 2;
+        int halfthickness = scaletoIU( params[4].GetValue( tool ), m_GerbMetric ) / 2;
+        double angle_start = RAD2DECIDEG( asin( (double) halfthickness / innerRadius ) );
+
+        // Draw shape in the first cadrant (X and Y > 0)
+        wxPoint pos, startpos;
+
+        // Inner arc
+        startpos.x = innerRadius;
+        double angle_end = 900 - angle_start;
+        for( double angle = angle_start; angle < angle_end; angle += 100 )
+        {
+            pos = startpos;
+            RotatePoint( &pos, angle );
+            aBuffer.push_back( pos );
+        }
+
+        // Last point
+        pos = startpos;
+        RotatePoint( &pos, angle_end );
+        aBuffer.push_back( pos );
+
+        // outer arc
+        startpos.x  = outerRadius;
+        startpos.y  = 0;
+        angle_start = RAD2DECIDEG( asin( (double) halfthickness / outerRadius ) );
+        angle_end   = 900 - angle_start;
+
+        // First point, near Y axis, outer arc
+        for( double angle = angle_end; angle > angle_start; angle -= 100 )
+        {
+            pos = startpos;
+            RotatePoint( &pos, angle );
+            aBuffer.push_back( pos );
+        }
+
+        // last point
+        pos = startpos;
+        RotatePoint( &pos, angle_start );
+        aBuffer.push_back( pos );
+
+        aBuffer.push_back( aBuffer[0] );  // Close poly
+    }
+    break;
+
+    case AMP_MOIRE:     // A cross hair with n concentric circles. Only the cros is build as polygon
+                        // because circles can be drawn easily
+    {
+        int crossHairThickness = scaletoIU( params[6].GetValue( tool ), m_GerbMetric );
+        int crossHairLength    = scaletoIU( params[7].GetValue( tool ), m_GerbMetric );
+
+        // Create cross. First create 1/4 of the shape.
+        // Others point are the same, totated by 90, 180 and 270 deg
+        wxPoint pos( crossHairThickness / 2, crossHairLength / 2 );
+        aBuffer.push_back( pos );
+        pos.y = crossHairThickness / 2;
+        aBuffer.push_back( pos );
+        pos.x = -crossHairLength / 2;
+        aBuffer.push_back( pos );
+        pos.y = -crossHairThickness / 2;
+        aBuffer.push_back( pos );
+
+        // Copy the 4 shape, rotated by 90, 180 and 270 deg
+        for( int jj = 1; jj <= 3; jj ++ )
+        {
+            for( int ii = 0; ii < 4; ii++ )
+            {
+                pos = aBuffer[ii];
+                RotatePoint( &pos, jj*900 );
+                aBuffer.push_back( pos );
+            }
+        }
+    }
+    break;
+
+    case AMP_OUTLINE:
+        // already is a polygon. Do nothing
+        break;
+
+    case AMP_POLYGON:   // Creates a regular polygon
+    {
+        int vertexcount = KiROUND( params[1].GetValue( tool ) );
+        int radius    = scaletoIU( params[4].GetValue( tool ), m_GerbMetric ) / 2;
+        // rs274x said: vertex count = 3 ... 10, and the first corner is on the X axis
+        if( vertexcount < 3 )
+            vertexcount = 3;
+        if( vertexcount > 10 )
+            vertexcount = 10;
+        for( int ii = 0; ii <= vertexcount; ii++ )
+        {
+            wxPoint pos( radius, 0);
+            RotatePoint( &pos, ii * 3600 / vertexcount );
+            aBuffer.push_back( pos );
+        }
+    }
+        break;
+
+    case AMP_COMMENT:
+    case AMP_UNKNOWN:
+    case AMP_EOF:
+        break;
+    }
+}
+
+/** GetShapeDim
+ * Calculate a value that can be used to evaluate the size of text
+ * when displaying the D-Code of an item
+ * due to the complexity of the shape of some primitives
+ * one cannot calculate the "size" of a shape (only abounding box)
+ * but here, the "dimension" of the shape is the diameter of the primitive
+ * or for lines the width of the line
+ * @param aParent = the parent GERBER_DRAW_ITEM which is actually drawn
+ * @return a dimension, or -1 if no dim to calculate
+  */
+int AM_PRIMITIVE::GetShapeDim( GERBER_DRAW_ITEM* aParent )
+{
+    int dim = -1;
+    D_CODE* tool = aParent->GetDcodeDescr();
+
+    switch( primitive_id )
+    {
+    case AMP_CIRCLE:
+        // params = exposure, diameter, pos.x, pos.y
+        dim = scaletoIU( params[1].GetValue( tool ), m_GerbMetric );     // Diameter
+        break;
+
+    case AMP_LINE2:
+    case AMP_LINE20:        // Line with rectangle ends. (Width, start and end pos + rotation)
+        dim  = scaletoIU( params[1].GetValue( tool ), m_GerbMetric );   // linne width
+    break;
+
+    case AMP_LINE_CENTER:
+    {
+        wxPoint size = mapPt( params[1].GetValue( tool ), params[2].GetValue( tool ), m_GerbMetric );
+        dim = std::min(size.x, size.y);
+    }
+    break;
+
+    case AMP_LINE_LOWER_LEFT:
+    {
+        wxPoint size = mapPt( params[1].GetValue( tool ), params[2].GetValue( tool ), m_GerbMetric );
+        dim = std::min(size.x, size.y);
+    }
+    break;
+
+    case AMP_THERMAL:
+    {
+        // Only 1/4 of the full shape is built, because the other 3 shapes will be draw from this first
+        // rotated by 90, 180 and 270 deg.
+        // params = center.x (unused here), center.y (unused here), outside diam, inside diam, crosshair thickness
+        dim   = scaletoIU( params[2].GetValue( tool ), m_GerbMetric ) / 2;  // Outer diam
+    }
+    break;
+
+    case AMP_MOIRE:     // A cross hair with n concentric circles.
+        dim = scaletoIU( params[7].GetValue( tool ), m_GerbMetric );    // = cross hair len
+        break;
+
+    case AMP_OUTLINE:   // a free polygon :
+    // dim = min side of the bounding box (this is a poor criteria, but what is a good criteria b?)
+    {
+        // exposure, corners count, corner1.x, corner.1y, ..., rotation
+        int numPoints = (int) params[1].GetValue( tool );
+        // Read points. numPoints does not include the starting point, so add 1.
+        // and calculate the bounding box;
+        wxSize pos_min, pos_max, pos;
+        for( int i = 0; i<numPoints + 1; ++i )
+        {
+            int jj = i * 2 + 2;
+            pos.x = scaletoIU( params[jj].GetValue( tool ), m_GerbMetric );
+            pos.y = scaletoIU( params[jj + 1].GetValue( tool ), m_GerbMetric );
+            if( i == 0 )
+                pos_min = pos_max = pos;
+            else
+            {
+                // upper right corner:
+                if( pos_min.x > pos.x )
+                    pos_min.x = pos.x;
+                if( pos_min.y > pos.y )
+                    pos_min.y = pos.y;
+                // lower left corner:
+                if( pos_max.x < pos.x )
+                    pos_max.x = pos.x;
+                if( pos_max.y < pos.y )
+                    pos_max.y = pos.y;
+            }
+        }
+        // calculate dim
+        wxSize size;
+        size.x = pos_max.x - pos_min.x;
+        size.y = pos_max.y - pos_min.y;
+        dim = std::min( size.x, size.y );
+    }
+        break;
+
+    case AMP_POLYGON:   // Regular polygon
+        dim = scaletoIU( params[4].GetValue( tool ), m_GerbMetric ) / 2;      // Radius
+        break;
+
+    case AMP_COMMENT:
+    case AMP_UNKNOWN:
+    case AMP_EOF:
+        break;
+    }
+    return dim;
+}
+
+
+/**
+ * Function DrawApertureMacroShape
+ * Draw the primitive shape for flashed items.
+ * When an item is flashed, this is the shape of the item
+ */
+void APERTURE_MACRO::DrawApertureMacroShape( GERBER_DRAW_ITEM* aParent,
+                                             EDA_RECT* aClipBox, wxDC* aDC,
+                                             EDA_COLOR_T aColor, EDA_COLOR_T aAltColor,
+                                             wxPoint aShapePos, bool aFilledShape )
+{
+    for( AM_PRIMITIVES::iterator prim_macro = primitives.begin();
+         prim_macro != primitives.end(); ++prim_macro )
+    {
+        prim_macro->DrawBasicShape( aParent, aClipBox, aDC,
+                                    aColor, aAltColor,
+                                    aShapePos,
+                                    aFilledShape );
+    }
+}
+
+/* Function HasNegativeItems
+ * return true if this macro has at least one aperture primitives
+ * that must be drawn in background color
+ * used to optimize screen refresh
+ */
+bool APERTURE_MACRO::HasNegativeItems( GERBER_DRAW_ITEM* aParent )
+{
+    for( AM_PRIMITIVES::iterator prim_macro = primitives.begin();
+         prim_macro != primitives.end(); ++prim_macro )
+    {
+        if( prim_macro->mapExposure( aParent ) == false )   // = is negative
+            return true;
+    }
+
+    return false;
+}
+
+
+/** GetShapeDim
+ * Calculate a value that can be used to evaluate the size of text
+ * when displaying the D-Code of an item
+ * due to the complexity of a shape using many primitives
+ * one cannot calculate the "size" of a shape (only abounding box)
+ * but most of aperture macro are using one or few primitives
+ * and the "dimension" of the shape is the diameter of the primitive
+ * (or the max diameter of primitives)
+ * @return a dimension, or -1 if no dim to calculate
+ */
+int APERTURE_MACRO::GetShapeDim( GERBER_DRAW_ITEM* aParent )
+{
+    int dim = -1;
+    for( AM_PRIMITIVES::iterator prim_macro = primitives.begin();
+         prim_macro != primitives.end(); ++prim_macro )
+    {
+        int pdim = prim_macro->GetShapeDim( aParent );
+        if( dim < pdim )
+            dim = pdim;
+    }
+
+    return dim;
+}
+
+
+/**
+ * function GetLocalParam
+ * Usually, parameters are defined inside the aperture primitive
+ * using immediate mode or defered mode.
+ * in defered mode the value is defined in a DCODE that want to use the aperture macro.
+ * But some parameters are defined outside the aperture primitive
+ * and are local to the aperture macro
+ * @return the value of a defered parameter defined inside the aperture macro
+ * @param aParamId = the param id (defined by $3 or $5 ..) to evaluate
+ */
+double APERTURE_MACRO::GetLocalParam( const D_CODE* aDcode, unsigned aParamId ) const
+{
+    // find parameter descr.
+    const AM_PARAM * param = NULL;
+    for( unsigned ii = 0; ii < m_localparamStack.size(); ii ++ )
+    {
+        if( m_localparamStack[ii].GetIndex() == aParamId )
+        {
+            param = &m_localparamStack[ii];
+            break;
+        }
+    }
+    if ( param == NULL )    // not found
+        return 0.0;
+    // Evaluate parameter
+    double value = param->GetValue( aDcode );
+    return value;
+}