statistic-brd.ulp

老外的PCB设计软件,是免费的.可以上网更新.

          cPadRestringBOT[cntPringBOT]++;
        }

        // Inner-Restring *************************
        int Irestring = (C.pad.diameter[2] - C.pad.drill) / 2;
        for ( n = 0; n <= cntPringI; n++) {
          if (PadRestringI[n] == Irestring) {
            cPadRestringI[n]++;
            break;
          }
        }
        if (n > cntPringI) {
          cntPringI++;
          PadRestringI[cntPringI] = Irestring;
          cPadRestringI[cntPringI]++;
        }
        int schape    = C.pad.shape[LAYER_TOP];
        schape    = C.pad.shape[LAYER_BOTTOM];
        schape    = C.pad.shape[2];
      }
    }
    // Texte in Package [copper]
    E.package.texts(T) {
      if (T.layer < 19) {
        T.wires(W) {
          for (int n = 0; n <= cntTextWidth; n++) {
            if (TextWidth[n] == W.width) {
              cTextWidth[n]++;
              break;
            }
          }
          if (n > cntTextWidth) {
            cntTextWidth++;
            TextWidth[cntTextWidth] = W.width;
            cTextWidth[cntTextWidth]++;
          }
          break;
        }
      }
    }

    // Wires in Package [copper]
    E.package.wires(W) {
      if (W.layer < 19) {
        for (n = 0; n <= cntWire; n++) {
          if (WireWidth[n] == W.width) {
            cWireWidth[n]++;
            break;
          }
        }
        if (n > cntWire) {
          cntWire++;
          WireWidth[cntWire] = W.width;
          cWireWidth[cntWire]++;
        }
      }
    }

    // Polygon wires in Package [copper]
    E.package.polygons(P) {
      if (P.layer < 19) {
        for (n = 0; n <= cntPolyW; n++) {
          if (PolygonWidth[n] == P.width) {
            cPolygonWidth[n]++;
            break;
          }
        }
        if (n > cntPolyW) {
          cntPolyW++;
          PolygonWidth[cntPolyW] = P.width;
          cPolygonWidth[cntPolyW]++;
        }
        // Polygon isolate *********
        for (n = 0; n <= cntPolyIso; n++) {
          if (PolygonIsolate[n] == P.isolate) {
            cPolygonIsolate[n]++;
            break;
          }
        }
        if (n > cntPolyIso) {
          cntPolyIso++;
          PolygonIsolate[cntPolyIso] = P.isolate;
          cPolygonIsolate[cntPolyIso]++;
        }
      }
    }

    // Rectangles in Package [copper]
    E.package.rectangles(R) {
      if (R.layer < 19) {
        int r_x = R.x2 - R.x1;
        int r_y = R.y2 - R.y1;
        for (int n = 0; n <= cntRECT; n++) {
          if ( RECTx[n] == r_x && RECTy[n] == r_y ) {
            cRECT[n]++;
            break;
          }
        }
        if (n > cntRECT ) {
          cntRECT++;
          RECTx[cntRECT] = r_x;
          RECTy[cntRECT] = r_y;
          cRECT[cntRECT]++;
        }
      }
    }

    // Element Libraries *********
    for (n = 0; n <= cntLbr; n++) {
      if (Lbr[n] == E.package.library) {
        cLbr[n]++;
        break;
      }
    }
    if (n > cntLbr) {
      cntLbr++;
      Lbr[cntLbr] = E.package.library;
      cLbr[cntLbr]++;
    }
    // Element Package *********
    for (n = 0; n <= cntPacName; n++) {
      if (PacName[n] == E.package.name) {
        cPacName[n]++;
        break;
      }
    }
    if (n > cntPacName) {
      cntPacName++;
      PacName[cntPacName] = E.package.name;
      cPacName[cntPacName]++;
    }

    // Element Value *********
    string Ev = E.value;
    for (n = 0; n <= cntEValue; n++) {
      if (Ev == "") {
        Ev = empty + E.name;
        emptyValue++;
      }
      if (EValue[n] == Ev) {
        cEValue[n]++;
        break;
      }
    }
    if (n > cntEValue) {
      cntEValue++;
      EValue[cntEValue] = Ev;
      cEValue[cntEValue]++;
    }
  }

  int x = 0;
  // Statistic tabels
  // Net Class ********************
  statisticCLASS[x] = "# - Name\tmin. Width\tClearance\tmin. Drill\tUsed";
  for (n = 0; n <= 7; n++) {
    if (NetClassName[n]) {
      if(minClearance > NetClassClear[n]) minClearance = NetClassClear[n];
        x++;
        sprintf(statisticCLASS[x], "%1d - %s\t%s\t%s\t%s\t%-4d",
                    NetClassNr[n],
                    NetClassName[n],
                    value(NetClassWidth[n], ""),
                    value(NetClassClear[n], ""),
                    value(NetClassDrill[n], ""),
                    cNetClass[n]
               );
      }
    }

    // ************* Wire statistic *****************
    x = 0;
    statisticWirew[x] = "WIRE\tQuant.";
    for (n = 0; n <= cntWire; n++) {
      if (cWireWidth[n]) {
        sumWires += cWireWidth[n];
        if(minWires > WireWidth[n]) minWires = WireWidth[n];
        x++;
        sprintf(statisticWirew[x], "%s\t%-4d", value(WireWidth[n], ""), cWireWidth[n] );
      }
    }

    x = 0;
    statisticARCw[x] = "ARC\tQuant.";
    for ( n = 0; n <= cntArc; n++) {
      if (cArcWidth[n]) {
        sumARCw += cArcWidth[n];
        if(minARCw > ArcWidth[n]) minARCw = ArcWidth[n];
        x++;
        sprintf(statisticARCw[x], "%s\t%-4d", value(ArcWidth[n], ""), cArcWidth[n] );
      }
    }

    x = 0;
    statisticCIRw[x] = "CIRCLE\tQuant.";
    for ( n = 0; n <= cntCircl; n++) {
      if (cCirclWidth[n]) {
        sumCIRCw += cCirclWidth[n];
        if(minCIRCw > CirclWidth[n]) minCIRCw = CirclWidth[n];
        x++;
        sprintf(statisticCIRw[x], "%s\t%-4d", value(CirclWidth[n], ""), cCirclWidth[n] );
      }
    }

    x = 0;
    statisticPolyw[x] = "POLYGON\tQuant.";
    for ( n = 0; n <= cntPolyW; n++) {
      if (cPolygonWidth[n]) {
        sumPOLYw += cPolygonWidth[n];
        if(minPOLYw > PolygonWidth[n]) minPOLYw = PolygonWidth[n];
        x++;
        sprintf(statisticPolyw[x], "%s\t%-4d", value(PolygonWidth[n], ""), cPolygonWidth[n]);
        // ATTENTION : Width saved in .2 Micron
      }
    }

    x = 0;
    statisticPoliso[x] = "Isolate\tQuant.";
    for ( n = 0; n <= cntPolyIso; n++) {
      if (cPolygonIsolate[n]) {
        sumISOL += cPolygonIsolate[n];
        if(minISOL > PolygonIsolate[n]) minISOL = PolygonIsolate[n];
        x++;
        sprintf(statisticPoliso[x], "%s\t%-4d", value(PolygonIsolate[n], ""), cPolygonIsolate[n]);
      }
    }

    x = 0;
    statisticRECT[x] = "RECT x\tRECT y\tQuant.";
    for ( n = 0; n <= cntRECT; n++) {
      if (cRECT[n]) {
        sumRECT += cRECT[n];
        if(minRECTx > RECTx[n]) minRECTx = RECTx[n];
        if(minRECTy > RECTy[n]) minRECTy = RECTy[n];
        x++;
        sprintf(statisticRECT[x], "%s\t%s\t%-4d", value(RECTx[n], ""), value(RECTy[n], ""), cRECT[n]);
      }
    }

    x = 0;
    statisticSMD[x] = "SMD x\tSMD y\tQuant.";
    for ( n = 0; n <= cntSMD; n++) {
      if (cSMD[n]) {
        sumSMD += cSMD[n];
        if(minSMDx > SMDx[n]) minSMDx = SMDx[n];
        if(minSMDy > SMDy[n]) minSMDy = SMDy[n];
        x++;
        sprintf(statisticSMD[x], "%s\t%s\t%-4d", value(SMDx[n], ""), value(SMDy[n], ""), cSMD[n]);
      }
    }

    x = 0;
    statisticPADdril[x] = "PAD drill\tQuant.";
    for (n = 0; n <= cntPDril; n++) {
      if (cPadDrill[n]) {
        sumPADdril += cPadDrill[n];
        if(minPADdril > PadDrill[n]) minPADdril = PadDrill[n];
        x++;
        sprintf(statisticPADdril[x], "%s\t%-4d", value(PadDrill[n], ""), cPadDrill[n]);
      }
    }

    x = 0;
    statisticPADdiaTOP[x] = "PAD tDiameter\tQuant.";
    for ( n = 0; n <= cntPDiamTOP; n++) {
      if (cPadDiameterTOP[n]) {
        sumPADdia += cPadDiameterTOP[n];
        if(minPADdia > PadDiameterTOP[n]) minPADdia = PadDiameterTOP[n];
        x++;
        sprintf(statisticPADdiaTOP[x], "%s\t%-4d", value(PadDiameterTOP[n], ""), cPadDiameterTOP[n]);
      }
    }

    x = 0;
    statisticPADdiaBOT[x] = "PAD bDiameter\tQuant.";
    for ( n = 0; n <= cntPDiamBOT; n++) {
      if (cPadDiameterBOT[n]) {
        sumPADdia += cPadDiameterBOT[n];
        if(minPADdia > PadDiameterBOT[n]) minPADdia = PadDiameterBOT[n];
        x++;
        sprintf(statisticPADdiaBOT[x], "%s\t%-4d", value(PadDiameterBOT[n], ""), cPadDiameterBOT[n]);
      }
    }

    x = 0;
    statisticPADdiaI[x] = "PAD iDiameter\tQuant.";
    for ( n = 0; n <= cntiPDiam; n++) {
      if (ciPadDiameter[n]) {
        sumPADdiaI += ciPadDiameter[n];
        if(minPADdiaI > iPadDiameter[n]) minPADdiaI = iPadDiameter[n];
        x++;
        sprintf(statisticPADdiaI[x], "%s\t%-4d", value(iPadDiameter[n], ""), ciPadDiameter[n]);
      }
    }

    x = 0;
    statisticPADrestTOP[x] = "tRestring\tQuant.";
    for ( n = 0; n <= cntPringTOP; n++) {
      if (cPadRestringTOP[n]) {
        sumPADrest += cPadRestringTOP[n];
        if(minPADrest > PadRestringTOP[n]) minPADrest = PadRestringTOP[n];
        x++;
        sprintf(statisticPADrestTOP[x], "%s\t%-4d", value(PadRestringTOP[n], ""), cPadRestringTOP[n]);
      }
    }

    x = 0;
    statisticPADrestBOT[x] = "bRestring\tQuant.";
    for ( n = 0; n <= cntPringBOT; n++) {
      if (cPadRestringBOT[n]) {
        sumPADrest += cPadRestringBOT[n];
        if(minPADrest > PadRestringBOT[n]) minPADrest = PadRestringBOT[n];
        x++;
        sprintf(statisticPADrestBOT[x], "%s\t%-4d", value(PadRestringBOT[n], ""), cPadRestringBOT[n]);
      }
    }

    x = 0;
    statisticPADrestI[x] = "iRestring\tQuant.";
    for ( n = 0; n <= cntPringI; n++) {
      if (cPadRestringI[n]) {
        sumPADrestI += cPadRestringI[n];
        if(minPADrestI > PadRestringI[n]) minPADrestI = PadRestringI[n];
        x++;
        sprintf(statisticPADrestI[x], "%s\t%-4d", value(PadRestringI[n], ""), cPadRestringI[n]);
      }
    }

    x = 0;
    statisticVIAdril[x] = "VIA drill\tQuant.";
    for ( n = 0; n <= cntVDril; n++) {
      if (cViaDrill[n]) {
        sumVIAdril += cViaDrill[n];
        if(minVIAdril > ViaDrill[n]) minVIAdril = ViaDrill[n];
        x++;
        sprintf(statisticVIAdril[x], "%s\t%-4d", value(ViaDrill[n], ""), cViaDrill[n] );
      }
    }

    x = 0;
    statisticVIAdia[x] = "Outer-Diameter\tQuant.";
    for ( n = 0; n <= cntVDiam; n++) {
      if (cViaDiameter[n]) {
        sumVIAdiam += cViaDiameter[n];
        if(minVIAdiam > ViaDiameter[n]) minVIAdiam = ViaDiameter[n];
        x++;
        sprintf(statisticVIAdia[x], "%s\t%-4d", value(ViaDiameter[n], ""), cViaDiameter[n] );
      }
    }

    x = 0;
    statisticVIAdiaI[x] = "Inner-Diam.\tQuant.";
    for ( n = 0; n <= cntVDiamI; n++) {
      if (cViaDiameterI[n]) {
        sumVIAdiamI += cViaDiameterI[n];
        if(minVIAdiamI > ViaDiameterI[n]) minVIAdiamI = ViaDiameterI[n];
        x++;
        sprintf(statisticVIAdiaI[x], "%s\t%-4d", value(ViaDiameterI[n], ""), cViaDiameterI[n] );
      }
    }

    x = 0;
    statisticVIArest[x] = "Outer-Restring \tQuant.";
    for ( n = 0; n <= cntVringO; n++) {
      if (cViaRestringO[n]) {
        sumVIArest += cViaRestringO[n];
        if(minVIArest > ViaRestringO[n]) minVIArest = ViaRestringO[n];
        x++;
        sprintf(statisticVIArest[x], "%s\t%-4d", value(ViaRestringO[n], ""), cViaRestringO[n]);
      }
    }

    x = 0;
    statisticVIArestI[x] = "Inner-Re.\tQuant.";
    for ( n = 0; n <= cntVringI; n++) {
      if (cViaRestringI[n]) {
        sumVIArestI += cViaRestringI[n];
        if(minVIArestI > ViaRestringI[n]) minVIArestI = ViaRestringI[n];
        x++;
        sprintf(statisticVIArestI[x], "%s\t%-4d", value(ViaRestringI[n], ""), cViaRestringI[n]);
      }
    }

    x = 0;
    statisticVIAstack[x] = "Stack\tQuant.";
    for ( n = 0; n < cntStack; n++) {
      x++;
      sprintf(statisticVIAstack[x], "%s\t%-4d", ViaStack[n], ViaStackCnt[n]);
    }

    x = 0;
    statisticHOLE[x] = "HOLE drill\tQuant.";
    for ( n = 0; n <= cntHole; n++) {
      if (cHole[n]) {
        sumHOLE += cHole[n];
        if(minHOLE > Hole[n]) minHOLE = Hole[n];
        x++;
        sprintf(statisticHOLE[x], "%s\t%-4d", value(Hole[n], ""), cHole[n]);
      }
    }

    x = 0;
    statisticTEXTw[x] = "TEXT wire\tQuant.";
    for ( n = 0; n <= cntTextWidth; n++) {
      if (cTextWidth[n]) {
        sumTEXTw += cTextWidth[n];
        if(minTEXTw > TextWidth[n]) minTEXTw = TextWidth[n];
        x++;
        sprintf(statisticTEXTw[x], "%s\t%-4d",  value(TextWidth[n], ""),cTextWidth[n] );
      }
    }

    x = 0;
    statisticTEXTsize[x] = "TEXT size\tQuant.";
    for ( n = 0; n <= cntTextSize; n++) {
      if (cTextSize[n]) {
        x++;
        sprintf(statisticTEXTsize[x], "%s\t%-4d",  value(TextSize[n], ""),cTextSize[n] );
      }
    }

    x = 0;
    statisticLBR[x] = "LIBRARY\tQuant.";
    for ( n = 0; n <= cntLbr; n++) {
      if (cLbr[n]) {
        x++;
        sprintf(statisticLBR[x], "%s\t%-4d",  Lbr[n], cLbr[n] );
      }
    }

    x = 0;
    statisticPAC[x] = "PACKAGE\tQuant.";
    for ( n = 0; n <= cntPacName; n++) {
      if (cPacName[n]) {
        x++;
        sprintf(statisticPAC[x], "%s\t%-4d",  PacName[n], cPacName[n] );
      }
    }

    x = 0;
    statisticVALUE[x] = "VALUE\tQuant.";
    for ( n = 0; n <= cntEValue; n++) {
      if (cEValue[n]) {
        x++;
        sprintf(statisticVALUE[x], "%s\t%-4d",  EValue[n], cEValue[n] );
      }
    }

    x = 0;
    // Drill Rack statistic
    B.holes(H) AddDrilling(H.drill);
    B.signals(S) S.vias(V) AddDrilling(V.drill);
    B.elements(E) {
      E.package.contacts(C) {
        if (C.pad)
          AddDrilling(C.pad.drill);
      }
      E.package.holes(H) AddDrilling(H.drill);
    }
    sort(imax, Drilling);

    drillRack[0] = "RACK";
    for (int i = 0; i < imax; ++i) {
      string s;
      sprintf(s, "T%02d %5.*f", i + 1, unitPrec[uval], Drilling[i]);
      drillRack[i + 1] = s;
    }

    if (SignalUnrouted) {
      sprintf(displayUnrouted, "<nobr>%d &nbsp;&nbsp; <font color=red> unroutet (airwire)</font></nobr>", SignalUnrouted );
      sprintf(Unrouted, "%d", SignalUnrouted);
    }

    // summary ******************
    string Tsummary_area;
    sprintf(Tsummary_area, "~ %.2f mm