#usage "en:<b>export 3d-data from board to IDF-FileFormat</b><p>"
       "More info can be found here: .../eagle.../doc/generate_3d_data_eng.pdf<br>"
       "<author>Original author: Uploaded by Neubacher Andreas from Commend International GmbHh<br>"
       "co-Author: alf@cadsoft.de</author><p>"
       ,
       "de:<b>export 3d-data from board to IDF-FileFormat</b><p>"
       "Im Layer 50 mu&szlig; eine Kopie der Boardkontour des Layer 20 angelegt werden. Die Wirebreite in Micron "
       "ergibt die Boarddicke in mm.<br>"
       "Die Bordkontour kann entweder im Board lebst oder in einem Package angelegt werden, es muß nur die "
       "obenstehende Bedingung eingehalten werden.<br>"
       "Um in einem Board einen Durchbruch zu erzeugen, kann man entweder im Board selbst oder in einem Package "
       "eine Kontur mit der Wirebreite von 0 im Layer 50 anlegen.<br>"
       "<author>Original author: Uploaded by Neubacher Andreas from Commend International GmbHh<br>"
       "co-Author: alf@cadsoft.de</author><p>"

#require 6.0600
string UlpVersion = "1.9";

string Docuemantpath = "Weiter Infos finden sie im Dokumentenordner unter " + path_doc[0] + "/generate_3d_data_eng.pdf<br>";


//############################################################################
// Author: Andy Neubacher
// Version |     Date   |  log
//---------+------------+-----------------------------------------------------
// v1.9    | 2014-04-08 |  - Now can change the filedirectory an filename
//                           select Top and or Bottom side of parts to export
// v1.8    | 2014-04-01 |  - Cutout und Koordinaten berichtigt (nur beim ersten Wire, Anfang und Endkoordinate ausgeben)
//                           dann immer nur die 2. Koordinate bis die erste Koordinate wieder erreicht ist.
//                         - LoopCounter für geschlossene Konturen (Durchbruch/Cutout) wieder berichtigt.
//
// v1.7    | 2014-01-20 |  - draw also pad-holes
// v1.6    | 2013-12-19 |  - LoopCounter für geschlossene Konturen (Durchbruch/Cutout).
//                           Die Bedingung für die Erkennung der einzelnen Konturen ist:
//                           1. Die allererste Kontour im Layer 50 ist die Boardkontur,
//                              was bedeutet, diese Kontour muss als allererste Kontur gezeichnet werden.
//                           2. Jede weitere Kontur wird als Cutout betrachtet, und es wird keine Überprüfung
//                              vorgenommen, ob diese Kontur innerhalb oder ausserhalb der Board-Dimension ist.
//                           3. Jede Kontur muss durchgehend gezeichnet und geschlossen sein.
//                              Das bedeutet, man darf innerhalb einer Kontur nicht an beliebigen Punkten
//                              das (WIRE) zeichnen unterbrechen, und an einer anderen Stelle wieder beginnen,
//                              also dem vorher unterbrochenen *Ende* entgegen zeichnen.
//
// v1.5    | 2013-12-18 |  - file renamed and now without version, for use in Text-Menu
//         |            |  - draw board cutout
//         |            |  - ++CutoutNumSegments change to CutoutNumSegments++
//                           alf@cadsoft.de
// v1.4    | 2013-12-11 |  - correct Board outline Curve
//         |            |  - correct Pre- to Post-Increment in all Functions
//         |            |  - fixed by Angelo.Cuccato@bogen-electronic.com
// v1.3    | 2013-03-14 |  - correct using ARC coorinates
// v1.2    | 2013-01-14 |  - Link in description to download page  - fixes by alf@cadsoft.de
// v1.1    | 2012-12-04 |  - korrect Loop Label for contours in layer Dimension - fixes by alf@cadsoft.de
// v1.0    | 2012-08-20 |  - more resolution %.6f of coordinates   - fixes by alf@cadsoft.de
// v0.9    | 2012-02-08 |  - used function u2mm() for Z-axis value - fixes by alf@cadsoft.de
//         |            |
// v0.8    | 2011-05-31 |  - changed characters that caused import problems
//         |            |  - changed output file extension to .emn and .emp
//         |            |  - fixes by morten@riftlabs.com
//         |            |
// v0.7    | 2006-10-24 |  - outline of board can also be drawn direct in brd-file
//         |            |  - any hole is taken from devices and board direct
//         |            |  - close open polygons on request
//         |            |  - drill vias on request
//         |            |  - bugfix : error if device contains more than one poly on top and bottom
//         |            |  - bugfix : sorting of points possible failed if polygon was open
//         |            |  - bugfix : partheights on bottomlayer were ignored
// v0.6    | 2006-08-31 |  now multiple partheights are possible
// v0.5    | 2006-08-25 |  modification to 'RIR-standard'
// v0.4    | 2005-11-09 |  1st export of a real board+parts successfull
// v0.3    | 2005-11-03 |  correct mirrors at top and bottom side
// v0.2    | 2005-10-21 |  1st working IDF-data
// v0.1    | 2005-09-30 |  start of project
//---------+------------+-----------------------------------------------------
//
// HOWTO:
// Create your board outline on layer 50.
// In your library, draw the component outlines on layer 57 (tCad) and use the line thickness to set component height.
// 1000 mic = 1 mm (e.g. if your grid is in mm, then a line thickness of 0.001 equals a component height of 1 mm).
// More info can be found here: ftp://ftp.cadsoft.de/eagle/userfiles/ulp/generate_3d_data_eng.pdf
//
//############################################################################


int    Layer3dBoardDimension = 50;
int    tLayer3Ddata = 57;
int    bLayer3Ddata = 58;
int    SelectSide[] = { 1, 1 };   // select Part output on side Top / Bottom
int    maxCutoutLineWidth = 0;    // -->> is linewidth 0.0 -> line is a cutout ??
string UlpName = filename(argv[0]);  // gets ulp name


// partoptions
int    NumParts;            // number of parts
string PartName[];        // name of part

// vars for polygon calculation
int   NumSegments = 0;      // number of points
int   PointX1[];            // start x
int   PointY1[];            // start y
int   PointX2[];            // end x
int   PointY2[];            // end y
int   SegmentType[];        // LINE, ARC, CIRCLE
real  SegmentCurve[];       // used by ARCs : - if drawn CCW,  + if drawn CW
int   SegmentWidth[];       // linewitdh = partheight

int   CutoutNumSegments = 0;
int   CutoutPointX1[];         // start x
int   CutoutPointY1[];         // start y
int   CutoutPointX2[];         // end x
int   CutoutPointY2[];         // end y
int   CutoutSegmentType[];     // LINE, ARC, CIRCLE
int   CutoutSegmentCurve[];    // used by ARCs : -180 if drawn CCW,  +180 if drawn CW
int   CutoutSegmentWidth[];    // linewitdh = partheight

int   LoopCounter = 0;         // 2015-04-02 für Boardoutline und Cutoutline


enum { LINE = 1, ARC = 2, CIRCLE = 3 };
enum { CUTOUT = 0, OUTLINE = -1 };
enum { false = 0, true = 1};
string Type[];
       Type[0]      =  "0";
       Type[LINE]   = "LINE";
       Type[ARC]    = "ARC";
       Type[CIRCLE] = "CIRCLE";

// vars for library
int    NumPacInLib = 0;               // number of pacs in library
int    PacIn_LIB_heights[];           // if 0 = only one partheight, if != 0 more than one height
real   PacIn_LIB_angle[];             // rotation of part in board
string PacIn_LIB_name[];              // names of pack's in library
int    PacIn_LIB_Device_mountside[];  // TOP, BOTTOM
string PacIn_LIB_SubPart_mountside[]; // mountside of subparts


int NumCutouts = 0;                   // number of holes in the pcb (drills, millings)
int OutlineInDeviceFound = false;     // is outline drawn in device symbol

int  CloseOpenPoly = false;           // close polygon if gap is smaller than ...mm
real MaxGapWidth = 0.1;               // value of maximum gap to close

int  DrillViaHoles = true;            // drill via-holes in pcb
real MinViaHoleDia = 0.254;           // diameter of drill


////////////////////////////////////////////////////
void CollectPartData(UL_BOARD brd) { //   read out all parts
  NumParts = 0;
  brd.elements(E) {
    PartName[NumParts] = E.name;
    PacIn_LIB_angle[NumParts] = -1;  // fill with invalid rotation and ...
    PacIn_LIB_Device_mountside[NumParts] = -1;   // fill with invalid mountside (mirror)   for "void IDF_LibaryElectrical(UL_BOARD BRD)" function
    PacIn_LIB_heights[NumParts] = 0; // part is only one package
    NumParts++;
  }
}

////////////////////////////////////////////////////
void IDF_Circle(int x1, int y1, int x2, int y2, int type) {       // output circle to file in IDF format
  int loopcount = 0;
  if(type == CUTOUT)  loopcount = NumCutouts; // 2013-12-19
  printf("%d %.6f %.6f 0\n", loopcount, u2mm(x1), u2mm(y1));
  printf("%d %.6f %.6f 360\n", loopcount, u2mm(x2), u2mm(y2));
  return;
}

////////////////////////////////////////////////////
void IDF_Arc(int x1, int y1, int x2, int y2, real angle, int type, int first) {   // output arc to file in IDF format
  int loopcount = 0;
  if(type == CUTOUT) loopcount = NumCutouts; // 2013-12-19
  if (first) printf("%d %.6f %.6f 0\n", loopcount, u2mm(x1), u2mm(y1));
  printf("%d %.6f %.6f %.1f\n", loopcount, u2mm(x2), u2mm(y2), angle);
  return;
}

////////////////////////////////////////////////////
void IDF_Line(int x1, int y1, int x2, int y2, int type, int first) {         // output line to file in IDF format
  int loopcount = 0;
  if(type == CUTOUT) loopcount = NumCutouts; // 2013-12-19
  if (first) printf("%d %.6f %.6f 0\n", loopcount, u2mm(x1), u2mm(y1));
  printf("%d %.6f %.6f 0\n", loopcount, u2mm(x2), u2mm(y2));
  return;
}

////////////////////////////////////////////////////
void OutputLines(int originx, int originy, int type) {       // write to file
  int first = 1;
  int i = 0;
  int startx = PointX1[i];
  int starty = PointY1[i];
  for(i = 0; i < NumSegments; i++) {
    NumCutouts = LoopCounter;
    switch(SegmentType[i]) {
      case LINE   : IDF_Line(PointX1[i]-originx, PointY1[i]-originy, PointX2[i]-originx, PointY2[i]-originy, type, first);
                    first = 0; // nur die erste Koordinate wird mit xy1 und xy2 ausgegeben, alles weiteren nur yx2,
                               // bis zum Ende sprich schliessen der Schleife
                    break;
      case ARC    : IDF_Arc(PointX1[i]-originx, PointY1[i]-originy, PointX2[i]-originx, PointY2[i]-originy, SegmentCurve[i], type, first);
                    first = 0; // nur die erste Koordinate wird mit xy1 und xy2 ausgegeben, alles weiteren nur yx2,
                               // bis zum Ende sprich schliessen der Schleife
                    break;
      case CIRCLE : IDF_Circle(PointX1[i]-originx, PointY1[i]-originy, PointX2[i]-originx, PointY2[i]-originy, type);
                    LoopCounter++;
                    NumCutouts = LoopCounter;
                    startx = PointX1[i+1];
                    starty = PointY1[i+1];
                    first = 1;
                    break;
      default     : string s;
                    sprintf(s, "Unknown type in Segment %d", i);
                    if (dlgMessageBox(s, "OK", "esc") != 0) exit(-182);
    }
    if (startx == PointX2[i] && starty == PointY2[i]) {
      first = 1;  // beim Anfang eine neuen Kontour wieder beie Koordinatenpaare ausgeben
      startx = PointX1[i+1];
      starty = PointY1[i+1];
      LoopCounter++; // die Schleife (Kontur) ist geschlossen. Bedingung siehe in oben.
    }
  }
  return;
}

////////////////////////////////////////////////////
void OutputBoardOutLines(int originx, int originy, int type) {  // write to file :: type ist hier irrelevant
  int first = 1;
  int i = 0;
  int startx = PointX1[i];
  int starty = PointY1[i];
  for(i = 0; i < NumSegments; i++) {
    NumCutouts = LoopCounter;
    switch(SegmentType[i]) { // 2013-12-18
      case LINE   : IDF_Line(PointX1[i]-originx, PointY1[i]-originy, PointX2[i]-originx, PointY2[i]-originy, CUTOUT, first);
                    first = 0; // nur die erste Koordinate wird mit xy1 und xy2 ausgegeben, alles weiteren nur yx2,
                               // bis zum Ende sprich schliessen der Schleife
                    break;
      case ARC    : IDF_Arc(PointX1[i]-originx, PointY1[i]-originy, PointX2[i]-originx, PointY2[i]-originy, SegmentCurve[i], CUTOUT, first);
                    first = 0; // nur die erste Koordinate wird mit xy1 und xy2 ausgegeben, alles weiteren nur yx2,
                               // bis zum Ende sprich schliessen der Schleife
                    break;
      case CIRCLE : IDF_Circle(PointX1[i]-originx, PointY1[i]-originy, PointX2[i]-originx, PointY2[i]-originy, CUTOUT);
                    LoopCounter++;
                    NumCutouts = LoopCounter;
                    startx = PointX1[i+1];
                    starty = PointY1[i+1];
                    first = 1;
                    break;
      default     : string s;
                    sprintf(s, "Unknown type in Segment %d", i);
    }
    if (startx == PointX2[i] && starty == PointY2[i]) {
      first = 1;  // beim Anfang eine neuen Kontour wieder beie Koordinatenpaare ausgeben
      startx = PointX1[i+1];
      starty = PointY1[i+1];
      LoopCounter++; // die Schleife (Kontur) ist geschlossen. Bedingung siehe in oben.
    }
  }
  return;
}

void OutputBoardCutOutLines(int originx, int originy, int type) {  // write to file :: type ist hier irrelevant
  int first = 1;
  int i = 0;
  int startx = CutoutPointX1[i];
  int starty = CutoutPointY1[i];
  for(i = 0; i < CutoutNumSegments; i++) {
    NumCutouts = LoopCounter;
    switch(CutoutSegmentType[i]) { // 2013-12-18
      case LINE   : IDF_Line(CutoutPointX1[i]-originx, CutoutPointY1[i]-originy, CutoutPointX2[i]-originx, CutoutPointY2[i]-originy, CUTOUT, first);
                    first = 0; // nur die erste Koordinate wird mit xy1 und xy2 ausgegeben, alles weiteren nur yx2,
                    // bis zum Ende sprich schliessen der Schleife
                    break;
      case ARC    : IDF_Arc(CutoutPointX1[i]-originx, CutoutPointY1[i]-originy, CutoutPointX2[i]-originx, CutoutPointY2[i]-originy, CutoutSegmentCurve[i], CUTOUT, first);
                    first = 0; // nur die erste Koordinate wird mit xy1 und xy2 ausgegeben, alles weiteren nur yx2,
                    // bis zum Ende sprich schliessen der Schleife
                    break;
      case CIRCLE : IDF_Circle(CutoutPointX1[i]-originx, CutoutPointY1[i]-originy, CutoutPointX2[i]-originx, CutoutPointY2[i]-originy, CUTOUT);
                    LoopCounter++;
                    NumCutouts = LoopCounter;
                    startx = CutoutPointX1[i+1];
                    starty = CutoutPointY1[i+1];
                    first = 1;
                    break;
      default     : string s;
                    sprintf(s, "Unknown type in Segment %d", i);
    }
    if (startx == CutoutPointX2[i] && starty == CutoutPointY2[i]) {
      first = 1;  // beim Anfang eine neuen Kontour wieder beie Koordinatenpaare ausgeben
      startx = CutoutPointX1[i+1];
      starty = CutoutPointY1[i+1];
      LoopCounter++; // die Schleife (Kontur) ist geschlossen. Bedingung siehe in oben.
    }
  }
  return;
}

////////////////////////////////////////////////////
int IsPointEqual (int x1, int y1, int x2, int y2) {  // really need a func-description ??
  if(x1 == x2 && y1 == y2) return true;
  return false;
}

////////////////////////////////////////////////////
real getPartHeight() {                     // returns maximum partlevel
  real ret = u2mm(SegmentWidth[0])*1000.0; // 2012-02-08
  return ret;
}

////////////////////////////////////////////////////
int IsPointInCircle(int target_x, int target_y, int circle_x, int circle_y, real radius) {
  real dist,a,b;
  a = abs(target_y-circle_y);
  b = abs(target_x-circle_x);
  // calculate distance
  dist = sqrt(a*a + b*b);
  if(dist <= radius) return true;
  return false;
}

////////////////////////////////////////////////////
//int GetArcOptions(UL_WIRE w) {                             // is arc drawn CW or CCW
//  if(IsPointEqual(w.x1, w.y1, w.x2, w.y2))  return (w.arc.angle1 - w.arc.angle2);
//  else  return (w.arc.angle2 - w.arc.angle1);
//}

////////////////////////////////////////////////////
int DataOnLayerPresent(UL_ELEMENT E, int layer) {
  E.package.circles(CIR) { // circle found
    if(CIR.layer == layer && CIR.width > maxCutoutLineWidth)  return true;
  }
  E.package.wires(W) {
    if(W.arc) {         // arc found
      if(W.layer == layer && W.width > maxCutoutLineWidth) return true;
    }
    else {             // straight line found
      if(W.layer == layer && W.width > maxCutoutLineWidth) return true;
    }
  }
  return false;    // no 3d-data on given layer found
}

////////////////////////////////////////////////////
void CollectRemainingPoints(int start, int nr) {
  int i;
  for(i = 0; i < nr; i++) {
    PointX1[i] = PointX1[i+start];
    PointY1[i] = PointY1[i+start];
    PointX2[i] = PointX2[i+start];
    PointY2[i] = PointY2[i+start];
    SegmentType[i] = SegmentType[i+start];
    SegmentCurve[i] = SegmentCurve[i+start];
    SegmentWidth[i] = SegmentWidth[i+start];
  }
  NumSegments = nr;
  return;
}

////////////////////////////////////////////////////
int SortPointsEx (void) {     // sort all points to a continous polygon
  int i;
  int ptfound;
  int ResultPointX1[];        // start x
  int ResultPointY1[];        // start y
  int ResultPointX2[];        // end x
  int ResultPointY2[];        // end y
  int ResultSegmentType[];    // SegmentType
  int ResultSegmentCurve[];   // options of segment (only used for ARCs)
  int ResultSegmentWidth[];   // width of line
  int PointUsed[];
  enum { NOT_FOUND = 0, FOUND = 1, ERROR = 2 };
  enum { NOT_USED = 0, USED = 1 };
  for(i = 0; i < NumSegments; i++)  PointUsed[i] = NOT_USED;

  ResultPointX1[0] = PointX1[0];  // startpoint
  ResultPointY1[0] = PointY1[0];
  ResultPointX2[0] = PointX2[0];
  ResultPointY2[0] = PointY2[0];
  ResultSegmentType[0] = SegmentType[0];
  ResultSegmentWidth[0] = SegmentWidth[0];
  ResultSegmentCurve[0] = SegmentCurve[0];
  PointUsed[0] = USED;

  for(int x=1; x<NumSegments; x++) {
    i = 1;
    ptfound = NOT_FOUND;
    do {
      if(!PointUsed[i]) {
        // search left point of segment in list
        if( IsPointEqual(PointX1[i], PointY1[i], ResultPointX2[x-1], ResultPointY2[x-1]) ) { // x1,y1 = startpoint  |  x2,y2 = endpoint
          ptfound = FOUND;
          PointUsed[i] = USED;
          ResultPointX1[x] = PointX1[i];
          ResultPointY1[x] = PointY1[i];
          ResultPointX2[x] = PointX2[i];
          ResultPointY2[x] = PointY2[i];
          ResultSegmentType[x] = SegmentType[i];
          ResultSegmentWidth[x] = SegmentWidth[i];
          ResultSegmentCurve[x] = SegmentCurve[i];
        }

        // search right point of segment in list
        if( IsPointEqual(PointX2[i], PointY2[i], ResultPointX2[x-1], ResultPointY2[x-1]) ) { // x2,y2 = startpoint  |  x1,y1 = endpoint
          ptfound = FOUND;
          PointUsed[i] = USED;
          ResultPointX1[x] = PointX2[i];
          ResultPointY1[x] = PointY2[i];
          ResultPointX2[x] = PointX1[i];
          ResultPointY2[x] = PointY1[i];
          ResultSegmentType[x] = SegmentType[i];
          ResultSegmentWidth[x] = SegmentWidth[i];
          ResultSegmentCurve[x] = SegmentCurve[i] * (-1);    // swap also drawing direction of ARC (clockwise, counter-clockwise)
        }
      }  // point used
      // checked full array ?
      if(i++ >= (NumSegments-1)) {
        if(ptfound != FOUND) ptfound = ERROR;
      }
    } while(ptfound == NOT_FOUND);
    // if point was not found -> end sorting of points
    if (ptfound == ERROR) break;
  }  // for NumSegments
  // count how many points are not used
  int n;
  int NumPointsUsed = 0;
  for(i=0; i < NumSegments; i++)  {
    if(PointUsed[i] == USED) NumPointsUsed++;
  }
  // copy not used points to end of ResultPoint[]
  for(i = NumSegments-1; i >= NumPointsUsed; i--) {
    for(n = 0; n < NumSegments; n++) {
      if(PointUsed[n] == NOT_USED) { // copy if point is not used
        PointUsed[n] = USED;
        ResultPointX1[i] = PointX1[n];
        ResultPointY1[i] = PointY1[n];
        ResultPointX2[i] = PointX2[n];
        ResultPointY2[i] = PointY2[n];
        ResultSegmentCurve[i] = SegmentCurve[n];
        ResultSegmentType[i] = SegmentType[n];
        ResultSegmentWidth[i] = SegmentWidth[n];
        break;
      }
    }
  }
  // copy back sorted list
  for(i=0; i<NumSegments;  i++) {
    PointX1[i] = ResultPointX1[i];
    PointY1[i] = ResultPointY1[i];
    PointX2[i] = ResultPointX2[i];
    PointY2[i] = ResultPointY2[i];
    SegmentType[i] = ResultSegmentType[i];
    SegmentCurve[i] = ResultSegmentCurve[i];
    SegmentWidth[i] = ResultSegmentWidth[i];
  }
  return NumSegments-NumPointsUsed;    // return number of pending points
} // SortPointsEx

////////////////////////////////////////////////////
void CloseOpenPolygon (void) {
  int i, LineAdded;
  int RemainingPoints, LastPoint;
  do  {
    LineAdded = false;
    RemainingPoints = SortPointsEx();
    LastPoint = NumSegments - RemainingPoints - 1;

    if(RemainingPoints) {   // only search for gaps if remainingpoints != 0
      for(i=LastPoint+1; i<NumSegments; i++) {   // start from last+1 poly-segment -> search for points within circle
        if(IsPointInCircle(PointX1[i], PointY1[i], PointX2[LastPoint], PointY2[LastPoint], mm2u(MaxGapWidth))) { // 2012-02-08
          PointX1[NumSegments] = PointX2[LastPoint];  // add new line with start at last-point
          PointY1[NumSegments] = PointY2[LastPoint];
          PointX2[NumSegments] = PointX1[i];
          PointY2[NumSegments] = PointY1[i];
          SegmentType[NumSegments] = LINE;
          SegmentWidth[NumSegments] = SegmentWidth[LastPoint];
          SegmentCurve[NumSegments++] = 0; // 2013-12-11
          LineAdded = true;
          break;    // point within circle found and added -> escape from "for"-loop
        }
        if(IsPointInCircle(PointX2[i], PointY2[i], PointX2[LastPoint], PointY2[LastPoint], mm2u(MaxGapWidth))) { // 2012-02-08
          PointX1[NumSegments] = PointX2[LastPoint];  // add new line with start at last-point
          PointY1[NumSegments] = PointY2[LastPoint];
          PointX2[NumSegments] = PointX2[i];
          PointY2[NumSegments] = PointY2[i];
          SegmentType[NumSegments] = LINE;
          SegmentWidth[NumSegments] = SegmentWidth[LastPoint];
          SegmentCurve[NumSegments++] = 0; // 2013-12-11
          LineAdded = true;
          break;    // point within circle found and added -> escape from "for"-loop
        }
      }
    }
  } while(LineAdded);    // resort points and close gaps  if new line added
  // finished correct -> but is polygon closed ?!? (firstpoint and lastpoint may no be the same coordinate !)
  if(IsPointEqual(PointX1[0], PointY1[0], PointX2[LastPoint], PointY2[LastPoint]) == false) { // poly closed ?
    if(IsPointInCircle(PointX1[0], PointY1[0], PointX2[LastPoint], PointY2[LastPoint], mm2u(MaxGapWidth))) { // 2012-02-08
      PointX1[NumSegments] = PointX2[LastPoint];  // add new line with start at last-point
      PointY1[NumSegments] = PointY2[LastPoint];
      PointX2[NumSegments] = PointX1[0];
      PointY2[NumSegments] = PointY1[0];
      SegmentType[NumSegments] = LINE;
      SegmentWidth[NumSegments] = SegmentWidth[LastPoint];
      SegmentCurve[NumSegments++] = 0; // 2013-12-11
    }
  }
  return;
}

////////////////////////////////////////////////////
int SortPoints(string ElementName) {    // sort all points to a continous polygon
  int LastPoint, RemainingPoints;
  // close open polygon
  if (CloseOpenPoly) CloseOpenPolygon();
  // do final sorting
  RemainingPoints = SortPointsEx();
  // check if polygon is closed
  LastPoint = NumSegments - RemainingPoints - 1;
  if (LastPoint < 0) {
    dlgMessageBox("!Negativ Index in function SortPoints().", "OK");
    exit(-472);
  }
  if(IsPointEqual(PointX1[0], PointY1[0], PointX2[LastPoint], PointY2[LastPoint]) == false) {
    if(SegmentType[0] != CIRCLE) {
      string x;
      int pt_x, pt_y;
      pt_x = PointX2[LastPoint];
      pt_y = PointY2[LastPoint];
      sprintf(x,"!%s contains an open polygon !\n\ncoordinate : X= %.6f[mm], Y= %.6f[mm]", ElementName, u2mm(pt_x), u2mm(pt_y));
      if (dlgMessageBox(x, "OK", "Show") != 0) {
        sprintf(x, "WIN (%.6fmm %.6fmm);\n", u2mm(pt_x), u2mm(pt_y));
        exit(x);
      }
    }
  }
  return RemainingPoints;
}

////////////////////////////////////////////////////
void IDF_LibaryHeader(UL_BOARD BRD) {              //->   create header of libary
  int t = time();
  string date;
  string sourceID;
  sprintf(date, "%d/%02d/%02d.%02d:%02d:%02d", t2year(t), t2month(t), t2day(t), t2hour(t), t2minute(t), t2second(t));
  sprintf(sourceID, "Commend International >%s %s %s<", UlpName, UlpVersion, EAGLE_SIGNATURE); // 2013-01-14
  printf(".HEADER\n");
  printf("LIBRARY_FILE 3.0 \"%s\" %s 1\n", sourceID, date);
  printf(".END_HEADER\n");
  return;
}

////////////////////////////////////////////////////
int CollectLibOutlineSegments(UL_ELEMENT E, int layer) {   // get all segments of elements on 3D-layer
  NumSegments=0;
  E.package.circles(CIR) {     // create circles
    if(CIR.layer == layer && CIR.width > maxCutoutLineWidth) {
      PointX1[NumSegments] = CIR.x;
      PointY1[NumSegments] = CIR.y;
      PointX2[NumSegments] = CIR.x + CIR.radius;
      PointY2[NumSegments] = CIR.y;
      SegmentType[NumSegments] = CIRCLE;
      SegmentWidth[NumSegments] = CIR.width;
      SegmentCurve[NumSegments++] = 0; // 2013-12-11
    }
  }
  E.package.wires(W) {
    if(W.curve) {      // create arcs
      if(W.layer == layer && W.width > maxCutoutLineWidth) {
        PointX1[NumSegments] = W.x1;  // 2013-03-14 use wire coordinate, not arc!
        PointY1[NumSegments] = W.y1;
        PointX2[NumSegments] = W.x2;
        PointY2[NumSegments] = W.y2;
        SegmentType[NumSegments] = ARC;
        SegmentWidth[NumSegments] = W.width;
        SegmentCurve[NumSegments++] = W.curve; //GetArcOptions(W);
      }
    }
    else {             // create straight lines
      if(W.layer == layer && W.width > maxCutoutLineWidth) {
        PointX1[NumSegments] = W.x1;
        PointY1[NumSegments] = W.y1;
        PointX2[NumSegments] = W.x2;
        PointY2[NumSegments] = W.y2;
        SegmentType[NumSegments] = LINE;
        SegmentWidth[NumSegments] = W.width;
        SegmentCurve[NumSegments++] = 0;  // 2013-12-11
      }
    }
  }
  if(NumSegments != 0) {    // show warningbox if element contains no 3d-data
    if(layer == bLayer3Ddata) {      // is given layer the bottom layer -> mirror
      for(int i=0; i<NumSegments; i++) {    // swap x-coordinate for bottom parts
        PointX1[i] = E.x - ((E.x - PointX1[i])*(-1));
        PointX2[i] = E.x - ((E.x - PointX2[i])*(-1));
      }
    }
  }
  return NumSegments;
}

////////////////////////////////////////////////////
void IDF_LibaryElectrical(UL_BOARD BRD) {   //->   create electrical parts (R, C, IC, ...)
  int i,x,inlib,NrOfPolygon;
  int RemainingPoints;
  string MountSide[] = {"TOP", "BOTTOM"};
  int layer[] = { tLayer3Ddata, bLayer3Ddata };

  for(i=0;i<NumParts;i++) {
    BRD.elements(E) {
      inlib = 0;
      for(x=0; x<NumPacInLib; x++) {   // check if new package
        if(PacIn_LIB_name[x] == E.package.name &&
           PacIn_LIB_angle[x] == E.angle &&
           PacIn_LIB_Device_mountside[x] == E.mirror
          ) inlib = 1;
      }
      if(E.name == PartName[i] && inlib == 0) {   // is package still in LIB-file
        NrOfPolygon = 0;
        if(DataOnLayerPresent(E, bLayer3Ddata))   NrOfPolygon=1; // if poly on bot-side found start from "1"
        for(int tb=0;tb<2;tb++){
          if(CollectLibOutlineSegments(E, layer[tb]) && SelectSide[tb]) { // only add package to lib if line-segments in layer found
            do {
              RemainingPoints = SortPoints(E.name);  // returns number of open/not_used points
              NumSegments -= RemainingPoints;        // calculate nr of correct/used points in poly
              // more than one outline in device present ?
              if((NrOfPolygon == 0) && (RemainingPoints != 0)) NrOfPolygon=1;
              printf(".ELECTRICAL\n");
              printf("%s_ANGLE%.1f_%s.%d CI_LIB MM %.6f\n", E.package.name, E.angle, MountSide[tb], NrOfPolygon, getPartHeight());
              OutputLines(E.x, E.y, OUTLINE);      // add package to libfile -> subract given offsets ->  E.x, E.y
              printf(".END_ELECTRICAL\n");
              CollectRemainingPoints(NumSegments, RemainingPoints);
              PacIn_LIB_heights[NumPacInLib] = NrOfPolygon;             // 0=package has only 1 poly; >0 package has more than one poly-outline
              PacIn_LIB_name[NumPacInLib] = E.package.name;             // mark that package is now in LIB-file
              PacIn_LIB_Device_mountside[NumPacInLib] = E.mirror;       // safe top- or bottom-side
              PacIn_LIB_SubPart_mountside[NumPacInLib] = MountSide[tb];  // safe mountside of subparts
              PacIn_LIB_angle[NumPacInLib++] = E.angle;                 // safe angle of partplacement
              if(RemainingPoints != 0 || NrOfPolygon != 0)  NrOfPolygon++;
            } while(RemainingPoints != 0);    // get multiple outline with multiple partheights
          }
        }
      }
    }
  }
  return;
}

////////////////////////////////////////////////////
void IDF_LibaryMechanical(UL_BOARD BRD) {             //->   create mechanical parts (drills, holes, ...)
  // not implemented yet
  return;
}

////////////////////////////////////////////////////
int CollectBoardOutlineSegments(UL_BOARD BRD) {             //++   get all segments of boardoutline
  NumSegments = 0;
  // first search board outline in board direct
  BRD.circles(CIR) {
    if(CIR.layer == Layer3dBoardDimension) {
      if (CIR.width > maxCutoutLineWidth) {
        PointX1[NumSegments] = CIR.x;
        PointY1[NumSegments] = CIR.y;
        PointX2[NumSegments] = CIR.x + CIR.radius;
        PointY2[NumSegments] = CIR.y;
        SegmentType[NumSegments] = CIRCLE;
        SegmentWidth[NumSegments] = CIR.width;
        SegmentCurve[NumSegments++] = 0;
      }
      else {
        CutoutPointX1[CutoutNumSegments] = CIR.x;
        CutoutPointY1[CutoutNumSegments] = CIR.y;
        CutoutPointX2[CutoutNumSegments] = CIR.x + CIR.radius;
        CutoutPointY2[CutoutNumSegments] = CIR.y;
        CutoutSegmentType[CutoutNumSegments]   = CIRCLE;
        CutoutSegmentWidth[CutoutNumSegments]  = CIR.width;
        CutoutSegmentCurve[CutoutNumSegments++] = 0;
      }
    }
  }
  BRD.wires(W) {
    if(W.layer == Layer3dBoardDimension) {
      if (W.width > maxCutoutLineWidth) {
        if(W.curve) {    // create arcs board-outline board
          PointX1[NumSegments] = W.x1; // 2013-03-14 use direct wire coordinate, not arc-coordinate
          PointY1[NumSegments] = W.y1;
          PointX2[NumSegments] = W.x2;
          PointY2[NumSegments] = W.y2;
          SegmentType[NumSegments] = ARC;
          SegmentWidth[NumSegments] = W.width;
          SegmentCurve[NumSegments] = W.curve; // GetArcOptions(W);
        }
        else {           // create straight lines board-outline board
          PointX1[NumSegments] = W.x1;
          PointY1[NumSegments] = W.y1;
          PointX2[NumSegments] = W.x2;
          PointY2[NumSegments] = W.y2;
          SegmentType[NumSegments] = LINE;
          SegmentWidth[NumSegments] = W.width;
          SegmentCurve[NumSegments] = 0;
        }
        NumSegments++;
      }
      else {
        if(W.curve) {    // create arcs board-outline board
          CutoutPointX1[CutoutNumSegments] = W.x1;
          CutoutPointY1[CutoutNumSegments] = W.y1;
          CutoutPointX2[CutoutNumSegments] = W.x2;
          CutoutPointY2[CutoutNumSegments] = W.y2;
          CutoutSegmentType[CutoutNumSegments] = ARC;
          CutoutSegmentWidth[CutoutNumSegments] = W.width;
          CutoutSegmentCurve[CutoutNumSegments] = W.curve; //GetArcOptions(W);
        }
        else {
          CutoutPointX1[CutoutNumSegments] = W.x1;
          CutoutPointY1[CutoutNumSegments] = W.y1;
          CutoutPointX2[CutoutNumSegments] = W.x2;
          CutoutPointY2[CutoutNumSegments] = W.y2;
          CutoutSegmentType[CutoutNumSegments] = LINE;
          CutoutSegmentWidth[CutoutNumSegments] = W.width;
          CutoutSegmentCurve[CutoutNumSegments] = 0;
        }
        CutoutNumSegments++;
      }
    }
  }
  // second search board outline in packages
  BRD.elements(E) {
    E.package.circles(CIR) {  // create board-outline of package-libary
      if(CIR.layer == Layer3dBoardDimension) {
        PointX1[NumSegments] = CIR.x;
        PointY1[NumSegments] = CIR.y;
        PointX2[NumSegments] = CIR.x + CIR.radius;
        PointY2[NumSegments] = CIR.y;
        SegmentType[NumSegments] = CIRCLE;
        SegmentWidth[NumSegments] = CIR.width;
        SegmentCurve[NumSegments++] = 0;
      }
    }
  }
  BRD.elements(E) {
    E.package.wires(W) {
      if(W.layer == Layer3dBoardDimension) {
        if (W.width > maxCutoutLineWidth) {
          if(W.curve) {  // create arcs board-outline of package-libary
            PointX1[NumSegments] = W.x1;
            PointY1[NumSegments] = W.y1;
            PointX2[NumSegments] = W.x2;
            PointY2[NumSegments] = W.y2;
            SegmentType[NumSegments] = ARC;
            SegmentWidth[NumSegments] = W.width;
            SegmentCurve[NumSegments] = W.curve; // GetArcOptions(W);
          }
          else {         // create straight lines board-outline of package-libary
            PointX1[NumSegments] = W.x1;
            PointY1[NumSegments] = W.y1;
            PointX2[NumSegments] = W.x2;
            PointY2[NumSegments] = W.y2;
            SegmentType[NumSegments] = LINE;
            SegmentWidth[NumSegments] = W.width;
            SegmentCurve[NumSegments] = 0;
          }
          NumSegments++;
        }
        else {
          if(W.curve) {  // create arcs board-cutout of package-libary
            CutoutPointX1[CutoutNumSegments] = W.x1;
            CutoutPointY1[CutoutNumSegments] = W.y1;
            CutoutPointX2[CutoutNumSegments] = W.x2;
            CutoutPointY2[CutoutNumSegments] = W.y2;
            CutoutSegmentType[CutoutNumSegments] = ARC;
            CutoutSegmentWidth[CutoutNumSegments] = W.width;
            CutoutSegmentCurve[CutoutNumSegments] = W.curve; //GetArcOptions(W);
          }
          else {         // create line board-cutout of package-libary
            CutoutPointX1[CutoutNumSegments] = W.x1;
            CutoutPointY1[CutoutNumSegments] = W.y1;
            CutoutPointX2[CutoutNumSegments] = W.x2;
            CutoutPointY2[CutoutNumSegments] = W.y2;
            CutoutSegmentType[CutoutNumSegments] = LINE;
            CutoutSegmentWidth[CutoutNumSegments] = W.width;
            CutoutSegmentCurve[CutoutNumSegments] = 0;
          }
          CutoutNumSegments++;
        }
      }
    }
  }

  if(NumSegments == 0) {
    string error;
    sprintf(error,"!No board-outline on layer %d found !", Layer3dBoardDimension);
    dlgMessageBox(error);
    exit(-771);
  }
  return NumSegments;
}


////////////////////////////////////////////////////
void IDF_BoardHeader(UL_BOARD BRD) {  //-##  create header of boardfile
  int t = time();
  string date;
  string sourceID;

  sprintf(date, "%d/%02d/%02d.%02d:%02d:%02d", t2year(t), t2month(t), t2day(t), t2hour(t), t2minute(t), t2second(t));
  sprintf(sourceID, "Commend International >%s %s %s<", UlpName, UlpVersion, EAGLE_SIGNATURE);
  printf(".HEADER\n");
  printf("BOARD_FILE 3.0 \"%s\" %s 1\n", sourceID, date);
  printf("\"%s\" MM\n", filename(BRD.name));
  printf(".END_HEADER\n");
  return;
}

////////////////////////////////////////////////////
void IDF_BoardOutline(UL_BOARD BRD) {  //-##   create outline of board
  // get outline
  CollectBoardOutlineSegments(BRD);
  SortPoints("Board-Outline");         // boardname
  // draw outline
  printf(".BOARD_OUTLINE UNOWNED\n");
  printf("%.6f\n", getPartHeight());
  OutputBoardOutLines(0, 0, OUTLINE);    // subract given offsets ->  E.x, E.y
  OutputBoardCutOutLines(0, 0, OUTLINE);
  printf(".END_BOARD_OUTLINE\n");
  LoopCounter = 0;
  return;
}

////////////////////////////////////////////////////
void IDF_BoardPlaceParts(UL_BOARD BRD) {   //-##   mount parts on board
  int i, inlib;
  string MountSide[] = {"TOP","BOTTOM"};
  printf(".PLACEMENT\n");
  BRD.elements(E) {
    inlib = 0;
    for(i=0; i<NumPacInLib; i++) {   // check if elements was found in libary
      if(PacIn_LIB_name[i] == E.package.name && PacIn_LIB_Device_mountside[i] == E.mirror && PacIn_LIB_angle[i] == E.angle) {
        inlib = 1;
        break;
      }
    }
    if(inlib) {   // only add part if part is in lib-file
      if(PacIn_LIB_heights[i] == 0) {     // part has only one height
        printf("%s_ANGLE%.1f_%s.0 CI_LIB %s.0\n", E.package.name, E.angle, PacIn_LIB_SubPart_mountside[i], E.name);
        printf("%.6f %.6f 0 0 %s PLACED\n", u2mm(E.x), u2mm(E.y), MountSide[E.mirror]);
      }
      else {     // part has multiple heights -> more than one part on same x/y position
        int lib_start = i;
        do {
          printf("%s_ANGLE%.1f_%s.%d CI_LIB %s.%d\n", E.package.name, E.angle, PacIn_LIB_SubPart_mountside[lib_start], PacIn_LIB_heights[lib_start], E.name, PacIn_LIB_heights[lib_start]);
          printf("%.6f %.6f 0 0 %s PLACED\n", u2mm(E.x), u2mm(E.y), PacIn_LIB_SubPart_mountside[lib_start]);
          lib_start++;
        }while(PacIn_LIB_heights[lib_start] > 1);
      }
    }
  }
  printf(".END_PLACEMENT\n");
  return;
}

////////////////////////////////////////////////////
void IDF_BoardHoles(UL_BOARD BRD) {             //-##   create holes in board (cutout, partholes, ...)
  printf(".DRILLED_HOLES\n");
  // drill holes from board direct
  BRD.holes(H)
    printf("%.6f %.6f %.6f NPTH BOARD Other UNOWNED\n", u2mm(H.drill), u2mm(H.x), u2mm(H.y));
  // drill holes from elements
  BRD.elements(E) {
    E.package.holes(H)
      printf("%.6f %.6f %.6f NPTH BOARD Other UNOWNED\n", u2mm(H.drill), u2mm(H.x), u2mm(H.y));
  }
  // drill pad(holes) from elements 2014-01-20
  BRD.elements(E) {
    E.package.contacts(C)
      if (C.pad)
        if (u2mm(C.pad.drill) > MinViaHoleDia)
          printf("%.6f %.6f %.2f PTH BOARD Other UNOWNED\n", u2mm(C.pad.drill), u2mm(C.pad.x), u2mm(C.pad.y));
  }
  // drill big via's
  BRD.signals(S) {
    S.vias(V) {
      if((DrillViaHoles == true) && (u2mm(V.drill) > MinViaHoleDia))    // drill via-hole
        printf("%.6f %.6f %.6f PTH BOARD VIA UNOWNED\n", u2mm(V.drill), u2mm(V.x), u2mm(V.y));
    }
  }
  printf(".END_DRILLED_HOLES\n");
  return;
}

////////////////////////////////////////////////////
void IDF_CreateLibaryFile(UL_BOARD BRD, string fname) { //  create libary for the IDF-board
  output(fname, "wt") {
    IDF_LibaryHeader(BRD);
    IDF_LibaryElectrical(BRD);
    IDF_LibaryMechanical(BRD);
  }
  return;
}

////////////////////////////////////////////////////
void IDF_CreateBoardFile(UL_BOARD BRD, string fname) {  //  create boardfile with parts of libary
  output(fname, "wt") {
    IDF_BoardHeader(BRD);
    IDF_BoardOutline(BRD);
    IDF_BoardHoles(BRD);
    IDF_BoardPlaceParts(BRD);
  }
  return;
}


////////////////////////////////////////////////////
void DisplayHelp(void) {    //  show helptext
  dlgDialog("Generate 3D IDF data")  {
    dlgLabel("Version " + UlpVersion);
    dlgHBoxLayout dlgSpacing(500);
    dlgHBoxLayout {
      dlgVBoxLayout dlgSpacing(200);
      dlgTextView(usage);
    }
    dlgLabel(Docuemantpath);
    dlgHBoxLayout {
      dlgStretch(1);
      dlgPushButton("-Back") dlgReject();
    }
  };
  return;
}

////////////////////////////////////////////////////
//   S T A R T   of   U L P
//
if (board) {
  int proceed = 0;
  string FileDirectoryName;
  string FilenamePanel;
  string FileNameIDB; // Board
  string FileNameIDL; // Library
  board(BRD) {
    FileDirectoryName = filedir(BRD.name);
    FileNameIDB = filesetext(filename(BRD.name), ".IDB");
    FileNameIDL = filesetext(filename(BRD.name), ".IDL");
  }
  dlgDialog("Generate 3D data format (IDF-file)") {
    dlgHBoxLayout {
      dlgGroup(" settings ") {
        dlgGridLayout {
          dlgCell(0,0) dlgCheckBox("close polygon if gap is smaller than   : ", CloseOpenPoly);
          dlgCell(0,1) dlgRealEdit(MaxGapWidth);
          dlgCell(0,2) dlgLabel(" mm");

          dlgCell(1,0) dlgCheckBox("drill via-holes if via is bigger than  : ", DrillViaHoles);
          dlgCell(1,1) dlgRealEdit(MinViaHoleDia);
          dlgCell(1,2) dlgLabel(" mm");

          dlgCell(2,0) dlgCheckBox("Export top parts",  SelectSide[0]);
          dlgCell(3,0) dlgCheckBox("Export bottom parts",  SelectSide[1]);
        }
      }
    }
    dlgGridLayout {
      dlgCell(1,0)  dlgLabel("Output Directory:");
      dlgCell(1,1)  dlgLabel(FileDirectoryName, 1);
      dlgCell(1,2)  {
                      dlgPushButton("Browse") {
                        string fdn = dlgDirectory("Save IDF file", FileDirectoryName);
                        if (fdn) {
                          int len = strlen(fdn);
                          if (fdn[len] != '/') fdn+="/"; // dlgDirectory gibt den Pfad ohne abschliessenden Slash zurück!
                          FileDirectoryName = fdn;
                        }
                      }
                    }
      dlgCell(2,0)  dlgLabel("Filename IDB (Board)");
      dlgCell(2,1)  dlgStringEdit(FileNameIDB);
      dlgCell(2,2)  {
                      dlgPushButton("Browse") {
                        string fdb = dlgFileSave("Save IDF file", FileDirectoryName, "IDF files (*.IDB)");
                        if (fdb) {
                          FileNameIDB = filename(fdb);
                          if(strchr(FileNameIDB, '.') < 0)    // add fileextension if missing
                            FileNameIDB += ".IDB";
                          FileNameIDL = filesetext(FileNameIDB, ".IDL");
                        }
                      }
                    }
      dlgCell(3,0)  dlgLabel("Filename IDL (Library)");
      dlgCell(3,1)  dlgStringEdit(FileNameIDL);
      dlgCell(3,2)  {
                      dlgPushButton("Browse") {
                        string fdl = dlgFileSave("Save IDF file", FileDirectoryName, "IDF files (*.IDL)");
                        if (fdl) {
                          FileNameIDL = filename(fdl);
                          if(strchr(FileNameIDL, '.') < 0)    // add fileextension if missing
                            FileNameIDL += ".IDL";
                          FileNameIDB = filesetext(FileNameIDL, ".IDB");
                        }
                      }
                    }
    }
    dlgHBoxLayout {
      dlgPushButton("OK") { proceed = 1; dlgAccept(); }
      dlgPushButton("Cancel") dlgReject();
      dlgStretch(1);
      dlgLabel("Version: " + UlpVersion);
      dlgPushButton("Help") DisplayHelp();
    }
  };
  if(proceed)  {
    project.board(BRD) {
      CollectPartData(BRD);    // read out data from BRD
      IDF_CreateLibaryFile(BRD, FileNameIDL);
      IDF_CreateBoardFile(BRD, FileNameIDB);
    }
  }
}
else {
  dlgMessageBox(usage + "<hr><b>ERROR: No board!</b><p>\nThis program can only work in the layout editor.");
  exit(0);
}