1. 程式人生 > >PCB 線路銅皮面積(殘銅率)計算的實現方法

PCB 線路銅皮面積(殘銅率)計算的實現方法

     一個多月沒更新部落格園了,這裡繼續分享關於PCB工程相關一些知識,做過PCB工程都知道用使用genesis或incam是可以非常方便的計算得到銅皮面積這個引數【下圖】,但實際這個軟體是通過什麼演算法計算出銅面積的呢,這個我們不得而知,但接下來這裡介紹一種可以將【線路殘銅率(銅皮面積)】計算得出來的方法.

  一.計算銅皮面積----公式與引數

       1.銅面積公式

        公式=【銅面的多邊形面積】+【銅的多邊形周長*銅厚】-【孔的底面積】+【孔的圓柱面積】 

        注:看看計算公式是多麼簡單呀,是吧。下面重點講【銅面的多邊形面積】引數計算方法,因為其它引數過於簡單就不寫了

      2.銅面積引數

         1.表面銅面積【銅面的多邊形面積】

         2.表面橫截面積【銅的多邊形周長*銅厚】

         3.有銅孔孔徑面積【孔的底面積】  

         4.有銅孔孔壁面積保【孔的圓柱面積】

       

  二.【銅面的多邊形面積】--計算方法

       【銅面的多邊形面積】計算公式用 Shoelace公式 【鞋帶公式】,此公式可以計算任意凸凹多邊形,剛好是滿足計算需求的,但對於PCB 銅皮(Surface)來說,銅皮點節點存在弧節點,直接用此公式計算當然不行啦,需要改造一下才行的。接一來用兩種方法(丟失精度與精度)實現計算【銅面的多邊形面積】

         

     1.【丟失精度】計算銅面積

          將銅皮節點含有弧節點,全部轉為折線節點, 轉換後的弧長長度控制在0.1mm左右,當然弧長的長度值越小精度就越高,這樣一來計算量就上去了,經測試弧長控制0.1mm比較合適。銅面積計算不會丟失太多。

        

     2.【精度】計算銅面積

          將原有銅皮銅邊形分為2部份

          1.分解第1部份 折線多邊形鞋帶公式求解

          2.分解第2部份  圓弧多邊形扇形面積求解  (如何判斷,圓弧多邊形是刪除,還是增加呢,下面有說明)

      

      上面帶來一個新的問題? 圖形面積合併計算,如何判斷,哪些弧形多邊形是【加】還是【減】呢

     按下表的關係進行加減計算合併銅皮面積

    

三.【銅面的多邊形面積】--計算程式碼

      1.計算銅面積呼叫程式碼

            //獲取gtl 線路層(計算前轉為Surface銅皮屬性)
            gLayer workLayerInfo = g.getFEATURES("gtl");
            //1.【丟失精度】計算銅面積
            var areaLayer = calc2.s_area(workLayerInfo.Slist);
            //2. 【精度】計算銅面積
            var areaLayer2 = calc2.s_area2(workLayerInfo.Slist);
            //計算銅的多邊形周長 
            var copperLenght =  calc2.s_Length(workLayerInfo.Slist);

   2.計算銅面積函式

        /// <summary>
        /// 【丟失精度】計算銅面積
        /// </summary>
        /// <param name="gS_list"></param>
        /// <returns></returns>
        public double s_area(List<gS> gS_list)
        {
            double SurfaceArea = 0;
            foreach (var gS_item in gS_list)
            {
                foreach (var Polyline in gS_item.sur_group)
                {
                    var sur_list = s_2gSur_Point(Polyline.sur_list);
                    if (Polyline.is_hole)
                        SurfaceArea -= s_area(sur_list);
                    else
                        SurfaceArea += s_area(sur_list);
                }
            }
            return SurfaceArea;
        }
        /// <summary>
        /// 【丟失精度】計算銅面積
        /// </summary>
        /// <param name="gSur_Point_list"></param>
        /// <returns></returns>
        public double s_area(List<gSur_Point> gSur_Point_list)
        {
            int Point_Count = gSur_Point_list.Count() - 1;
            if (Point_Count < 2) return 0;
            double PolylineArea = 0;
            double ArcArea = 0;
            for (int i = 1; i <= Point_Count; i++)
            {
                PolylineArea += gSur_Point_list[i - 1].p.x * gSur_Point_list[i].p.y - gSur_Point_list[i - 1].p.y * gSur_Point_list[i].p.x;
            }
            PolylineArea = Math.Abs(PolylineArea * 0.5);
            return PolylineArea;
        }
        /// <summary>
        /// 【精度】計算銅面積
        /// </summary>
        /// <param name="gSur_Point_list"></param>
        /// <returns></returns>
        public double s_area2(List<gSur_Point> gSur_Point_list)
        {
            int Point_Count = gSur_Point_list.Count() - 1;
            if (Point_Count < 2) return 0;
            double PolylineArea = 0;
            double ArcArea = 0;
            bool isCCW = s_isCCW(gSur_Point_list);
            for (int i = 1; i <= Point_Count; i++)
            {
                if (gSur_Point_list[i].type_point > 0)
                {
                    double a_area = a_Area(gSur_Point_list[i - 1].p, gSur_Point_list[i].p, gSur_Point_list[i + 1].p, gSur_Point_list[i].type_point == 2);
                    if (isCCW)
                    {
                        if (gSur_Point_list[i].type_point == 2)
                            ArcArea += a_area;
                        else
                            ArcArea -= a_area;
                    }
                    else
                    {
                        if (gSur_Point_list[i].type_point == 2)
                            ArcArea -= a_area;
                        else
                            ArcArea += a_area;
                    }
                }
                PolylineArea += gSur_Point_list[i - 1].p.x * gSur_Point_list[i].p.y - gSur_Point_list[i - 1].p.y * gSur_Point_list[i].p.x;
            }
            PolylineArea = Math.Abs(PolylineArea * 0.5);
            PolylineArea += ArcArea;
            //var isCW = s_isCW(gSur_Point_list);
            //PolylineArea += (isCCW ? -ArcArea : ArcArea);
            return PolylineArea;
        }
        /// <summary>
        /// 求弧Arc 扇形面積
        /// </summary>
        /// <param name="a"></param>
        /// <returns></returns>
        public double a_Area(gPoint ps, gPoint pc, gPoint pe, bool ccw, bool islg180deg = false)
        {
            double r_ = p2p_di(pc, ps);
            return pi * r_ * r_ * a_Angle(ps, pc, pe, ccw, islg180deg) / 360;
        }
        /// <summary>
        /// 求弧Arc圓心角   3點    //後續改進  用叉積 與3P求角度求解  驗證哪個效率高
        /// </summary>
        /// <param name="ps"></param>
        /// <param name="pc"></param>
        /// <param name="pe"></param>
        /// <param name="ccw"></param>
        /// <returns></returns>
        public double a_Angle(gPoint ps, gPoint pc, gPoint pe, bool ccw, bool islg180deg = false)
        {
            double angle_s, angle_e, angle_sum;
            if (ccw)
            {
                angle_s = p_ang(pc, pe);
                angle_e = p_ang(pc, ps);
            }
            else
            {
                angle_s = p_ang(pc, ps);
                angle_e = p_ang(pc, pe);
            }
            if (angle_s == 360) { angle_s = 0; }
            if (angle_e >= angle_s)
            {
                angle_sum = 360 - (angle_e - angle_s);  //360 - Math.Abs(angle_s - angle_e);
            }
            else
            {
                angle_sum = angle_s - angle_e;//Math.Abs(angle_s - angle_e);
            }
            if (islg180deg && angle_sum > 180)
            {
                angle_sum = 360 - angle_sum;
            }
            return angle_sum;
        }
        /// <summary>
        /// 檢測 Surface是否逆時針   
        /// </summary>
        /// <param name="gSur_Point_list"></param>
        /// <returns></returns>
        public bool s_isCCW(List<gSur_Point> gSur_Point_list)
        {
            double d = 0;
            int n = gSur_Point_list.Count() - 1;
            for (int i = 0; i < n; i++)
            {
                if (gSur_Point_list[i].type_point > 0) continue;
                int NextI = i + 1 + (gSur_Point_list[i+ 1].type_point > 0 ? 1 : 0);
                d += -0.5 * (gSur_Point_list[NextI].p.y + gSur_Point_list[i].p.y) * (gSur_Point_list[NextI].p.x - gSur_Point_list[i].p.x);
            }
            return d > 0;
        }
        /// <summary>
        /// 將gSur_Point中含弧的節點轉為線
        /// </summary>
        /// <param name="gSur_Point_list"></param>
        /// <param name="val_">此數值表示:分段數值</param>
        /// <param name="type_">代表值數值型別 【0】弧長 【1】角度  【2】弦長 </param>
        /// <returns></returns>
        public List<gSur_Point> s_2gSur_Point(List<gSur_Point> gSur_Point_list, double val_ = 1d, int type_ = 1)
        {
            List<gSur_Point> resultList = new List<gSur_Point>();
            if (gSur_Point_list.Count > 2)
            {
                bool is_flag = false;
                resultList.Add(gSur_Point_list[0]);
                for (int j = 1; j < gSur_Point_list.Count; j++)
                {
                    if (is_flag)
                    {
                        is_flag = false;
                        continue;
                    }
                    if (gSur_Point_list[j].type_point > 0)
                    {
                        var aData = new gA(gSur_Point_list[j - 1].p, gSur_Point_list[j].p, gSur_Point_list[j + 1].p, 100, gSur_Point_list[j].type_point == 2 ? true : false);
                        var PlistData = a_2Plist(aData, val_, type_, true);
                        resultList.AddRange(PlistData.Select(tt => new gSur_Point(tt.p, 0)).ToList());
                        is_flag = true;
                    }
                    else
                    {
                        resultList.Add(gSur_Point_list[j]);
                    }
                }
            }
            return resultList;
        }
        /// <summary>
        /// 弧Arc 轉點P組集
        /// </summary>
        /// <param name="a"></param>
        /// <param name="val_">此數值表示:分段數值</param>
        /// <param name="type_">代表值數值型別 【0】弧長 【1】角度  【2】弦長 </param>
        /// <param name="is_avg">是否平均分佈 </param>
        /// <returns></returns>
        public List<gPP> a_2Plist(gA a, double val_ = 0.1d, int type_ = 0, bool is_avg = false)
        {
            List<gPP> list_point = new List<gPP>();
            gPP tempP;
            tempP.p = a.ps;
            tempP.symbols = a.symbols;
            tempP.width = a.width;
            list_point.Add(tempP);

            double avg_count;
            double angle_val = 0;
            double rad_ = p2p_di(a.pc, a.pe);
            double sum_alge = a_Angle(a);
            if (type_ == 1)  //    【1】角度  
            {
                angle_val = val_;
                avg_count = (int)(Math.Floor(sum_alge / angle_val));  //  總角度/單角度
            }
            else if (type_ == 2)  //【2】弦長
            {
                angle_val = Math.Asin(val_ / (rad_ * 2)) * 360 / pi;
                avg_count = (int)(Math.Ceiling(sum_alge / angle_val) + eps) - 1;  //  總角度/單絃長
            }
            else  //                【0】弧長 
            {
                angle_val = val_ * 180 / (pi * rad_);
                avg_count = (int)(Math.Ceiling(sum_alge / angle_val) + eps) - 1;  //  總角度/單角度
                //avg_count = (int)(Math.Ceiling(a_Lenght(a) / val_)) - 1;  //  或  總弧長/單弧長
            }
            if (is_avg)
                angle_val = sum_alge / avg_count;
            if (avg_count > 1)
            {
                gPP centerP = tempP;
                centerP.p = a.pc;
                double angle_s = p_ang(a.pc, a.ps);
                if (a.ccw) { angle_val = 0 - angle_val; }
                for (int i = 1; i < avg_count; i++)
                {
                    tempP = p_val_ang(centerP, rad_, angle_s - angle_val * i);
                    list_point.Add(tempP);
                }
            }
            // if (!(zero(a.ps.x - a.pe.x) && zero(a.ps.y - a.pe.y)))
            // {
            //     tempP.p = a.pe;
            //     list_point.Add(tempP);
            // }
            tempP.p = a.pe;
            list_point.Add(tempP);
            return list_point;
        }
        /// <summary>
        /// 返回兩點之間歐氏距離
        /// </summary>
        /// <param name="p1"></param>
        /// <param name="p2"></param>
        /// <returns></returns>
        public double p2p_di(gPoint p1, gPoint p2)
        {
            return Math.Sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
        }
        /// <summary>
        /// 求弧Arc圓心角       //後續改進  用叉積 與3P求角度求解  驗證哪個效率高
        /// </summary>
        /// <param name="a"></param>
        /// <returns></returns>
        public double a_Angle(gA a)
        {
            double angle_s, angle_e, angle_sum;
            if (a.ccw)
            {
                angle_s = p_ang(a.pc, a.pe);
                angle_e = p_ang(a.pc, a.ps);
            }
            else
            {
                angle_s = p_ang(a.pc, a.ps);
                angle_e = p_ang(a.pc, a.pe);
            }
            if (angle_s == 360) { angle_s = 0; }
            if (angle_e >= angle_s)
                angle_sum = 360 - Math.Abs(angle_s - angle_e);
            else
                angle_sum = Math.Abs(angle_s - angle_e);
            return angle_sum;
        }
        /// <summary>
        /// 求方位角
        /// </summary>
        /// <param name="ps"></param>
        /// <param name="pe"></param>
        /// <returns></returns>
        public double p_ang(gPoint ps, gPoint pe)
        {
            double a_ang = Math.Atan((pe.y - ps.y) / (pe.x - ps.x)) / Math.PI * 180;
            //象限角  轉方位角   計算所屬象限   並求得方位角
            if (pe.x >= ps.x && pe.y >= ps.y)  //↗    第一象限
            {
                return a_ang;
            }
            else if (!(pe.x >= ps.x) && pe.y >= ps.y)  // ↖   第二象限
            {
                return a_ang + 180;
            }
            else if (!(pe.x >= ps.x) && !(pe.y >= ps.y))  //↙   第三象限
            {
                return a_ang + 180;
            }
            else if (pe.x >= ps.x && !(pe.y >= ps.y))  // ↘   第四象限
            {
                return a_ang + 360;
            }
            else
            {
                return a_ang;
            }
        }
        /// <summary>
        /// 求增量座標
        /// </summary>
        /// <param name="ps">起點</param>
        /// <param name="val">增量值</param>
        /// <param name="ang_direction">角度</param>
        /// <returns></returns>
        public gPP p_val_ang(gPP ps, double val, double ang_direction)
        {
            gPP pe = ps;
            pe.p.x = ps.p.x + val * Math.Cos(ang_direction * Math.PI / 180);
            pe.p.y = ps.p.y + val * Math.Sin(ang_direction * Math.PI / 180);
            return pe;
        }
View Code

   3.計算銅的多邊形周長函式

        /// <summary>
        /// 求Surface  總周長
        /// </summary>
        /// <param name="gS_list"></param>
        /// <returns></returns>
        public double s_Length(List<gS> gS_list)
        {
            int Surface_Count = gS_list.Count();
            double SurfaceArea = 0;
            foreach (var gS_item in gS_list)
            {
                foreach (var Polyline in gS_item.sur_group)
                {
                    SurfaceArea += s_Length(Polyline.sur_list);
                }
            }
            return SurfaceArea;
        }
        /// <summary>
        /// 求Surface  總周長
        /// </summary>
        /// <param name="gSur_Point_list"></param>
        /// <returns></returns>
        public double s_Length(List<gSur_Point> gSur_Point_list)
        {
            double sum_lenght = 0;
            bool is_flag = false;
            bool ccw = false;
            for (int i = 1; i < gSur_Point_list.Count; i++)
            {
                if (is_flag)
                {
                    is_flag = false;
                    continue;
                }
                if (gSur_Point_list[i].type_point > 0)
                {
                    if (gSur_Point_list[i].type_point == 2)
                        ccw = true;
                    else
                        ccw = false;
                    sum_lenght += a_Length(gSur_Point_list[i - 1].p, gSur_Point_list[i].p, gSur_Point_list[i + 1].p, ccw);
                    is_flag = true;
                }
                else
                {
                    sum_lenght += l_Length(gSur_Point_list[i - 1].p, gSur_Point_list[i].p);
                }
            }
            return sum_lenght;
        }
        /// <summary>
        /// 求弧Arc長度  3點
        /// </summary>
        /// <param name="ps"></param>
        /// <param name="pc"></param>
        /// <param name="pe"></param>
        /// <returns></returns>
        public double a_Length(gPoint ps, gPoint pc, gPoint pe, bool ccw = false)
        {
            return pi / 180 * p2p_di(pc, ps) * a_Angle(ps, pc, pe, ccw);
        }
        /// <summary>
        /// 求線Line長度  2點
        /// </summary>
        /// <param name="ps"></param>
        /// <param name="pe"></param>
        /// <returns></returns>
        public double l_Length(gPoint ps, gPoint pe)
        {
            return Math.Sqrt((ps.x - pe.x) * (ps.x - pe.x) + (ps.y - pe.y) * (ps.y - pe.y));
        }
View Code

  4.資料結構

    /// <summary>
    /// Surface 座標泛型集類1
    /// </summary>
    public class gSur_Point
    {
        public gSur_Point()
        { }
        public gSur_Point(double x_val, double y_val, byte type_point_)
        {
            this.p.x = x_val;
            this.p.y = y_val;
            this.type_point = type_point_;
        }
        public gSur_Point(gPoint p, byte type_point_)
        {
            this.p = p;
            this.type_point = type_point_;
        }
        public gPoint p;
        /// <summary>
        /// 0為折點  1為順時針 2為逆時針  
        /// </summary>
        public byte type_point { get; set; } = 0;
        /// <summary>
        /// 值
        /// </summary>
        public double Value { get; set; } = 0;
    }
    /// <summary>
    /// Surface 座標泛型集類2
    /// </summary>
    public class gSur_list
    {
        public List<gSur_Point> sur_list = new List<gSur_Point>();
        /// <summary>
        /// 是否為空洞
        /// </summary>
        public bool is_hole { get; set; }
        /// <summary>
        /// 是否逆時針
        /// </summary>
        public bool is_ccw { get; set; }
    }
    /// <summary>
    /// Surface 座標泛型集類3
    /// </summary>
    public class gS
    {
        public List<gSur_list> sur_group = new List<gSur_list>();
        /// <summary>
        /// 是否為負  polarity-- P N
        /// </summary>
        public bool negative { get; set; }
        public string attribut { get; set; }
    }
    /// <summary>
    /// 點  資料型別 (XY)
    /// </summary>
    public struct gPoint
    {
        public gPoint(gPoint p_)
        {
            this.x = p_.x;
            this.y = p_.y;
        }
        public gPoint(double x_val, double y_val)
        {
            this.x = x_val;
            this.y = y_val;
        }
        public double x;
        public double y;
        public static gPoint operator +(gPoint p1, gPoint p2)
        {
            p1.x += p2.x;
            p1.y += p2.y;
            return p1;
        }
        public static gPoint operator -(gPoint p1, gPoint p2)
        {
            p1.x -= p2.x;
            p1.y -= p2.y;
            return p1;
        }
    }
    /// <summary>
    /// ARC 資料型別
    /// </summary>
    public struct gA
    {
        public gA(double ps_x, double ps_y, double pc_x, double pc_y, double pe_x, double pe_y, double width_, bool ccw_)
        {
            this.ps = new gPoint(ps_x, ps_y);
            this.pc = new gPoint(pc_x, pc_y);
            this.pe = new gPoint(pe_x, pe_y);
            this.negative = false;
            this.ccw = ccw_;
            this.symbols = "r" + width_.ToString();
            this.attribut = string.Empty;
            this.width = width_;
        }
        public gA(gPoint ps_, gPoint pc_, gPoint pe_, double width_, bool ccw_ = false)
        {
            this.ps = ps_;
            this.pc = pc_;
            this.pe = pe_;
            this.negative = false;
            this.ccw = ccw_;
            this.symbols = "r" + width_.ToString();
            this.attribut = string.Empty;
            this.width = width_;
        }
        public gPoint ps;
        public gPoint pe;
        public gPoint pc;
        public bool negative;//polarity-- positive  negative
        public bool ccw; //direction-- cw ccw
        public string symbols;
        public string attribut;
        public double width;
        public static gA operator +(gA arc1, gPoint move_p)
        {
            arc1.ps += move_p;
            arc1.pe += move_p;
            arc1.pc += move_p;
            return arc1;
        }
        public static gA operator +(gA arc1, gPP move_p)
        {
            arc1.ps += move_p.p;
            arc1.pe += move_p.p;
            arc1.pc += move_p.p;
            return arc1;
        }
        public static gA operator +(gA arc1, gP move_p)
        {
            arc1.ps += move_p.p;
            arc1.pe += move_p.p;
            arc1.pc += move_p.p;
            return arc1;
        }
        public static gA operator -(gA arc1, gPoint move_p)
        {
            arc1.ps -= move_p;
            arc1.pe -= move_p;
            arc1.pc -= move_p;
            return arc1;
        }
        public static gA operator -(gA arc1, gPP move_p)
        {
            arc1.ps -= move_p.p;
            arc1.pe -= move_p.p;
            arc1.pc -= move_p.p;
            return arc1;
        }
        public static gA operator -(gA arc1, gP move_p)
        {
            arc1.ps -= move_p.p;
            arc1.pe -= move_p.p;
            arc1.pc -= move_p.p;
            return arc1;
        }
    }
View Code

 

四.【銅面的多邊形面積】--實現效果

     經測試,發現程式計算出來銅面積與genesis銅面積計算存在少量的偏差(猜側奧寶為了達到越大規模銅面積計算,採用丟失精度計算銅面積達到快速計算銅面積的目的)

    小結: 採用程式計算在小規模銅面積計算,不管是計算速度還是銅面積計算精度已超過genesis.

 

 下例:genesis計算銅面積存一定偏差,實際PAD尺寸為4X3mm 面積為:12平方毫米  而genesis計算得到面積為12.004平方毫米

 

&n