精华内容
下载资源
问答
  • 城市设计资料-城市设计总平面cad参考
  • 现场总平面管理制度

    2020-12-18 10:04:09
    这一款整理收录发布的现场总平面管理制度,可用于学习、参考、借鉴现场总平面管理制度相关内容...该文档为现场总平面管理制度,是一份很不错的参考资料,具有较高参考价值,感兴趣的可以下载看看
  • 别墅规划总平面

    2020-12-19 20:59:59
    以下是《别墅规划总平面图》简单预览,如果需要完整的CAD图纸学习参考,请点击下载。...……………………该文档为别墅规划总平面图,是一份很不错的参考资料,具有较高参考价值,感兴趣的可以下载看看
  • 以下是《小区景观规划总平面图》简单预览,如果需要完整的CAD图纸学习参考,请点击下载。...……………………该文档为小区景观规划总平面图,是一份很不错的参考资料,具有较高参考价值,感兴趣的可以下载看看
  • 某别墅规划总平面

    2020-12-19 18:48:20
    以下是《某别墅规划总平面图》简单预览,如果需要完整的CAD图纸学习参考,请点击下载。...……………………该文档为某别墅规划总平面图,是一份很不错的参考资料,具有较高参考价值,感兴趣的可以下载看看
  • 合理的总平面规划可以为矿井文明生产创造良好的条件,使场区管理井然有序,交通秩序安全顺畅。文章结合几种不同地区、不同类型的大型矿井工业场地总平面布置实例,归纳...对矿井工业场地总平面规划设计有一定的参考作用。
  • 办公楼总平面

    2015-03-18 11:04:59
    办公楼的cad总平面 施工图 方案 填色的教程参考文件非常全
  • 以下是《体育馆人行天桥总平面图》简单预览,如果需要完整的CAD图纸学习参考,请点击下载。...……………………该文档为体育馆人行天桥总平面图,是一份很不错的参考资料,具有较高参考价值,感兴趣的可以下载看看
  • 以下是《某别墅区总平面CAD图纸》简单预览,如果需要完整的CAD图纸学习参考,请点击下载。...……………………该文档为某别墅区总平面CAD图纸,是一份很不错的参考资料,具有较高参考价值,感兴趣的可以下载看看
  • 以下是《钢板桩码头总平面布置图》简单预览,如果需要完整的CAD图纸学习参考,请点击下载。...……………………该文档为钢板桩码头总平面布置图,是一份很不错的参考资料,具有较高参考价值,感兴趣的可以下载看看
  • 以下是《怡景中学人行天桥工程总平面图》简单预览,如果需要完整的CAD图纸学习参考,请点击下载。...该文档为怡景中学人行天桥工程总平面图,是一份很不错的参考资料,具有较高参考价值,感兴趣的可以下载看看
  • 文章论述了小保当矿井作为"一矿两井"模式的选址原则,对矿井工业场地的总平面布置进行了设计,介绍了不同分区的功能特点,分析了不同厂区的优缺点,对规划"一矿两井"模式的总平面设计具有一定的参考作用。
  • 但在实际系统中,并不存在这样一个实体平面。比如,—个参考平面可能被分配给多个电源网络,那么,实心板就被撕裂成几个小的部分。在类似这种参考平面受到破坏的情况下,如果邻近信号层上的信号路径跨越分割实体的...
  • 总平面布置论文

    2014-11-13 09:05:28
    可以作为很好的参考资料的论文,大家可以学习一下,收获多多
  • 但在实际系统中,并不存在这样一个实体平面。比如,—个参考平面可能被分配给多个电源网络,那么,实心板就被撕裂成几个小的部分。在类似这种参考平面受到破坏的情况下,如果邻近信号层上的信号路径跨越分割实体的...

    理想的参考平面应该为其邻近信号层上的信号路径提供完美的返回路径,理想的参考平面应该是一个完整的实体平面。但在实际系统中,并不总存在这样一个实体平面。比如,—个参考平面可能被分配给多个电源网络,那么,实心板就被撕裂成几个小的部分。在类似这种参考平面受到破坏的情况下,如果邻近信号层上的信号路径跨越分割实体的缝隙,则返回路径就会绕过参考平面上的缝隙,将带来很多问题。

    如图1所示,信号走线跨越了参考平面上的缝隙,其返回电流将会绕过缝隙,形成一个大的电流环路,电路的抗干扰性降低,也容易产生RF辐射。此外,此缝隙会造成信号走线的阻抗突变,引起反射。解决这个问题的一个方法就是采用差分对布线,后面将会详细介绍。

    ˉˉˉˉ理想返回路径 ˉˉˉˉ实际返回路径

    图1返回路径上存在缝隙

    电路中不可避免会用到一些直插式的元件,如BGA封装,必然会在PCB上形成许多贯穿整个电路板的通孔。过多、过密的通孔会在参考平面上形成砂孔区,使参考平面的敷铜区减少,甚至形成大面积的不连续的槽,形成如上面缝隙一样的效果,如图2所示。

    图2 信号走线经过砂孔区

    欢迎转载,信息来源维库电子市场网(www.dzsc.com)

    展开全文
  • 但在实际系统中,并不存在这样一个实体平面。比如,—个参考平面可能被分配给多个电源网络,那么,实心板就被撕裂成几个小的部分。在类似这种参考平面受到破坏的情况下,如果邻近信号层上的信号路径跨越分割实体的...
  • 华清学院的CAD总平面仅供学习参考,内部含有基本的建筑体量关系,以及结构,内容详细。
  • 这是整理发布的一款《复习平面图形的周长和面积》课件PPT,PPT主要以初中数学课程为主,适合.....该文档为《复习平面图形的周长和面积》PPT课件1,是一份很不错的参考资料,具有较高参考价值,感兴趣的可以下载看看
  • 解决问题描述:二维平面有很多三角形错落,可能会相互叠加落在一起,也可能互相远离。目标求出这些三角形的占地面积。 我最开始想的解决方案是用面积-重叠面积 =占地面积。后来实现起来发现当面临多次重叠...

    解决问题描述:二维平面有很多三角形错落,可能会相互叠加落在一起,也可能互相远离。目标求出这些三角形的总占地面积。

    我最开始想的解决方案是用总面积-总重叠面积 = 总占地面积。后来实现起来发现当面临多次重叠时,这样算是错误的。

    后来参考了一些文献,得出结论:这个问题抽象出来就是求n个集合的并集问题。公式如下:

    A1∪A2∪......∪An =
    
    A1 + A2 + ......+ An ﹣(A1∩A2 + A1∩A3 + ......+ A[n-1]∩An) +
    
      (A1∩A2∩A3 + A1∩A2∩A4 + ......+ A[n-2]∩A[n-1]∩An) + ......+
    
    [(-1)^(n-1)]A1∩A2∩......∩An

    第二个需要解决的问题是如何判断两个三角形关系并求两个三角形的重叠面积

    思路如下:

    第一步:两个三角形各边分别求交点,交点放入集合a中

    第二步:两个三角形分别求一个点是否在另一个三角形内部,内点放入集合a中

    第三步:集合a去重

    第四部:如果a中元素数量>=3,则两三角形相交,重叠部分面积为a中点集所构成的凸多边形的面积。如果a中元素数量<3,则两三角形不相交。

    这两个问题解决,问题就迎刃而解了,中间还涉及了很多小函数,整体代码如下:

    type Vector2 struct {
        X float64                `json:"x"`
        Y float64                `json:"y"`
    }
    
    type Triangle struct {
        A Vector2
        B Vector2
        C Vector2
    }
    
    type Line struct {
        X Vector2
        Y Vector2
    }
    //全局变量
    var triangleArea = float64(0)    //所有三角片面积
    var n_getAcreage = 0
    func GetAcreage(triangles []Triangle) float64 {
        triangleArea = 0
        n_getAcreage = len(triangles)
        for i:=0;i<n_getAcreage-1 ;i++  {
            for j:=i+1;j< n_getAcreage;j++  {
                triangleA:=triangles[i]
                triangleB:=triangles[j]
                if QuickCross(TriangleToList(triangleA),TriangleToList(triangleB)) {        //快速判断,不准确,后面还需再次判断
                    GetShadow(TriangleToList(triangleA),TriangleToList(triangleB),triangles,1,j+1)
                }
            }
        }
        
    }
    
    func GetShadow(list1 []Vector2,list2 []Vector2,trangles []Triangle,sign float64,index int){
        //两个多边形求遮挡多边形和遮挡面积
        var list []Vector2           //相交点集
        list1 = ClockwiseSortPoints(list1)
        list2 = ClockwiseSortPoints(list2)
        //求相交点
        for i:=0;i< len(list1);i++  {
            for j:=0;j<len(list2);j++  {
                var line1,line2 Line
                if i==len(list1)-1 {
                    line1.X = list1[0]
                    line1.Y = list1[i]
                }else {
                    line1.X = list1[i]
                    line1.Y = list1[i+1]
                }
                if j==len(list2)-1 {
                    line2.X = list2[0]
                    line2.Y = list2[j]
                }else {
                    line2.X = list2[j]
                    line2.Y = list2[j+1]
                }
                point := CrossPoint(line1.X,line1.Y,line2.X,line2.Y)
                if point[0].X!=-1000 && point[0].Y!=-1000{
                    list = append(list, point...)
                }
            }
        }
        //求内部点
        for _,v1 := range list1{
            if IsInNedge(list2,v1) {
                list = append(list, v1)
            }
        }
        for _,v2 := range list2{
            if IsInNedge(list1,v2) {
                list = append(list, v2)
            }
        }
        //去重
        list = DeduplicationVec2(list)
        if len(list)<3 {
            return
        }
    
        shadow := GetNedgeArea(ClockwiseSortPoints(list))
        triangleArea = triangleArea+math.Pow(-1,sign)*shadow
        for k:=index;k<n_getAcreage ;k++  {
            if QuickCross(list,TriangleToList(trangles[k])){
                GetShadow(list,TriangleToList(trangles[k]),trangles,sign+1,k+1)
            }
        }
        return
    }
    
    func (this *Vector2)Set(x, y float64) {
        this.X = x
        this.Y = y
    }
    
    func (this *Vector2)Equal(x Vector2) bool {
        if math.Abs(this.X - x.X)<0.1 && math.Abs(this.Y - x.Y)<0.1{
            return true
        } else {
            return false
        }
    }
    
    
    func TriangleToList(triangle Triangle) []Vector2 {
        var res []Vector2
        var a Vector2
        a.Set(triangle.A.X,triangle.A.Y)
        res = append(res, a)
    
        a.Set(triangle.B.X,triangle.B.Y)
        res = append(res, a)
    
        a.Set(triangle.C.X,triangle.C.Y)
        res = append(res, a)
        return res
    }
    
    func QuickCross(list1,list2 []Vector2) bool {
        //判断两多边形是否相交
        var maxx1,maxy1,minx1,miny1,maxx2,maxy2,minx2,miny2 float64
        for _,v1 :=range list1{
            if v1.X>=maxx1 {
                maxx1 = v1.X
            }
            if v1.X<=minx1 {
                minx1 = v1.X
            }
            if v1.Y>=maxy1 {
                maxy1 = v1.Y
            }
            if v1.Y<=miny1 {
                miny1 = v1.Y
            }
        }
        for _,v2 :=range list2{
            if v2.X>=maxx2 {
                maxx2 = v2.X
            }
            if v2.X<=minx2 {
                minx2 = v2.X
            }
            if v2.Y>=maxy2 {
                maxy2 = v2.Y
            }
            if v2.Y<=miny2 {
                miny2 = v2.Y
            }
        }
        Lx := math.Abs((minx1+maxx1)/2-(minx2+maxx2)/2)
        Ly := math.Abs((miny1+maxy1)/2-(miny2+maxy2)/2)
        if Lx<math.Abs(maxx1-minx1)+math.Abs(maxx2-minx2) && Ly<math.Abs(maxy1-miny1)+math.Abs(maxy2-miny2) {
            return true
        }else {
            return false
        }
    }
    
    func GetNedgeArea(list []Vector2) float64 {
        //得到任意N边型面积 前提是点的排列方向为顺时针或逆时针
        var x,y float64
        for _,v := range list{
            x+=v.X
            y+=v.Y
        }
        var point Vector2
        point.Set(x/ float64(len(list)),y/ float64(len(list)))
        res := float64(0)
        for q:=0;q< len(list);q++  {
            if q==len(list)-1 {
                res+= GetTriangleAreaByVector(point,list[q],list[0])
            }else {
                res+= GetTriangleAreaByVector(point,list[q],list[q+1])
            }
        }
        return res
    }
    
    func ClockwiseSortPoints(list []Vector2) []Vector2 {
        //多边形点集排序--针对凸多边形,按逆时针方向进行排序
        var res []Vector2
        var center Vector2
        var a Vector2
        var first []Vector2
        var second []Vector2
        var third []Vector2
        var four []Vector2
        a.Set(1,0)
        x := float64(0)
        y := float64(0)
        for i:=0;i < len(list);i++{
            x += list[i].X
            y += list[i].Y
        }
        center.X = x/ float64(len(list))
        center.Y = y/ float64(len(list))
        for _,v := range list{
            var b Vector2
            b.Set(v.X-center.X,v.Y-center.Y)
            if b.X>=0 && b.Y>0 {
                first = append(first, b)
            }
            if b.X<0 && b.Y>=0 {
                second = append(second, b)
            }
            if b.X<=0 && b.Y<0 {
                third = append(third, b)
            }
            if b.X>0 && b.Y<=0 {
                four = append(four, b)
            }
        }
        if first!=nil {
            sort1(first)
            for _,v := range first{
                v.X = v.X+center.X
                v.Y = v.Y+center.Y
                res = append(res, v)
            }
        }
        if second!=nil {
            sort1(second)
            for _,v := range second{
                v.X = v.X+center.X
                v.Y = v.Y+center.Y
                res = append(res, v)
            }
        }
        if third!=nil {
            sort2(third)
            for _,v := range third{
                v.X = v.X+center.X
                v.Y = v.Y+center.Y
                res = append(res, v)
            }
        }
        if four!=nil {
            sort2(four)
            for _,v := range four{
                v.X = v.X+center.X
                v.Y = v.Y+center.Y
                res = append(res, v)
            }
        }
        return res
    }
    
    func sort1(buf[]Vector2)  {
        //从小到大排序
        var a Vector2
        a.Set(1,0)
        for i := 0; i < len(buf)-1; i++ {
            flag := false
            for j := 1; j < len(buf)-i; j++ {
                if GetAngelByVector2(buf[j-1],a) > GetAngelByVector2(buf[j],a) {
                    tmp := buf[j-1]
                    buf[j-1] = buf[j]
                    buf[j] = tmp
                    flag = true
                }
            }
            if !flag {
                break
            }
        }
    }
    
    func sort2(buf[]Vector2)  {
        //从大到小排序
        var a Vector2
        a.Set(1,0)
        for i := 0; i < len(buf)-1; i++ {
            flag := false
            for j := 1; j < len(buf)-i; j++ {
                if GetAngelByVector2(buf[j-1],a) < GetAngelByVector2(buf[j],a) {
                    tmp := buf[j-1]
                    buf[j-1] = buf[j]
                    buf[j] = tmp
                    flag = true
                }
            }
            if !flag {
                break
            }
        }
    }
    
    func GetAngelByVector2(a,b  Vector2) float64 {
        //二维得到两向量夹角
        a_sqrt := math.Sqrt(a.X*a.X + a.Y*a.Y)
        b_sqrt := math.Sqrt(b.X*b.X + b.Y*b.Y)
        cos := (a.X*b.X + a.Y*b.Y)/(a_sqrt*b_sqrt)
        res := math.Acos(cos)
        return res
    }
    
    func DeduplicationVec2(crossPoint []Vector2) []Vector2 {
        //去重
        if crossPoint==nil {
            return crossPoint
        }
        var res []Vector2
        var temp = true
        res = append(res, crossPoint[0])
        for _,v1 := range crossPoint{
            for _,v2:= range res{
                if v2.Equal(v1) {
                    temp = false
                    break
                }
            }
            if temp {
                res = append(res, v1)
            }
            temp = true
        }
        return res
    }
    
    func IsInNedge(list []Vector2,point Vector2) bool {
        nArea := GetNedgeArea(list)
        var a float64
        for i:=0;i<len(list) ;i++  {
            if i==len(list)-1 {
                a+=GetTriangleAreaByVector(point,list[i],list[0])
            }else {
                a+=GetTriangleAreaByVector(point,list[i],list[i+1])
            }
        }
        if math.Abs(a-nArea)<0.1 {
            return true
        }else {
            return false
        }
    }
    func CrossPoint(line1,line2,line3,line4 Vector2) []Vector2 {
        var res []Vector2
        if line1.Equal(line3) && line2.Equal(line4) {
            res = append(res, line1)
            res = append(res, line2)
            return res
        }
    
        if line1.Equal(line4) && line2.Equal(line3) {
            res = append(res, line1)
            res = append(res, line2)
            return res
        }
    
        if line1.Equal(line3) && !line2.Equal(line4) {
            res = append(res,line1)
            return res
        }
    
        if line1.Equal(line4) && !line2.Equal(line3) {
            res = append(res,line1)
            return res
        }
        if line2.Equal(line3) && !line1.Equal(line4) {
            res = append(res,line2)
            return res
        }
        if line2.Equal(line4) && !line1.Equal(line3) {
            res = append(res,line2)
            return res
        }
        var cross_point Vector2
        var a = float64(0)
        var b = float64(0)
        var state = 0
        if math.Abs(line1.X - line2.X)>1e-6 {
            a = (line2.Y - line1.Y) / (line2.X - line1.X)
            state |= 1
        }
        if math.Abs(line3.X - line4.X)>1e-6 {
            b = (line4.Y - line3.Y) / (line4.X - line3.X)
            state |= 2
        }
        switch state {
        case 0: //L1与L2都平行Y轴
            if math.Abs(line1.X - line3.X)<1e-6{
                //throw new Exception("两条直线互相重合,且平行于Y轴,无法计算交点。");
                cross_point.Set(-1000,-1000)
            }else{
                //throw new Exception("两条直线互相平行,且平行于Y轴,无法计算交点。");
                cross_point.Set(-1000,-1000)
            }
        case 1:    //L1存在斜率, L2平行Y轴
            x := line3.X
            y := (line1.X - x) * (-a) + line1.Y
            cross_point.Set(x,y)
        case 2://L1 平行Y轴,L2存在斜率
            x := line1.X
            y := (line3.X - x) * (-b) + line3.Y
            cross_point.Set(x,y)
        case 3://L1,L2都存在斜率
            if math.Abs(a - b)<1e-6 {
                // throw new Exception("两条直线平行或重合,无法计算交点。");
                cross_point.Set(-1000,-1000)
            }
            x := (a * line1.X - b * line3.X - line1.Y + line3.Y) / (a - b)
            y := a * x - a * line1.X + line1.Y
            cross_point.Set(x,y)
        }
        //beego.Debug(cross_point)
        if !((OnSegment(line1,line2,cross_point)) && (OnSegment(line3,line4,cross_point))){
            cross_point.Set(-1000,-1000)
        }
        res = append(res, cross_point)
        return res  //没有交点返回(-1000,-1000)
    }
    
    
    func GetTriangleAreaByVector(x Vector2,y Vector2,z Vector2) float64 {
        //根据三点坐标获得三角形面积
        area := (x.X*y.Y+y.X*z.Y+z.X*x.Y-x.X*z.Y-y.X*x.Y-z.X*y.Y)/2
        if area<0 {
            area = -area
        }
        return area
    }
    
    func OnSegment( p1,p2,Q Vector2) bool {
        //判断一个点是不是在一个线段内
    
        maxx := math.Max(p1.X,p2.X)
        minx := math.Min(p1.X,p2.X)
        maxy := math.Max(p1.Y,p2.Y)
        miny := math.Min(p1.Y,p2.Y)
        index := (Q.X -p1.X )*(p2.Y -p1.Y) - (p2.X -p1.X) *(Q.Y -p1.Y)
        if index<=1e-5 && ( (Q.X > minx || math.Abs(Q.X-minx)<1e-5) && (Q.X < maxx || math.Abs(Q.X-maxx)<1e-5)&&
            (Q.Y > miny || math.Abs(Q.Y-miny)<1e-5) && (Q.Y < maxy || math.Abs(Q.Y-maxy)<1e-5)) {
            return true
        }else {
            return false
        }
    }

     参考文献:徐元铭,龙伟,王永庆.军机易损性分析中多重遮挡投影面积计算[J].北京航空航天大学学报,2002(02):245-248.

    相关链接:http://kns.cnki.net/KCMS/detail/detail.aspx?dbcode=CJFQ&dbname=CJFD2002&filename=BJHK200202032&uid=WEEvREcwSlJHSldRa1FhdkJkVG1BVnRVeWZHNVVIbWExVGhucVdORzVtVT0=$9A4hF_YAuvQ5obgVAqNKPCYcEjKensW4IQMovwHtwkF4VYPoHbKxJw!!&v=MzIwOTVnVmIzSUp5ZkRaYkc0SHRQTXJZOUdab1I4ZVgxTHV4WVM3RGgxVDNxVHJXTTFGckNVUkxPZlkrZHBGeXo=

     

    转载于:https://www.cnblogs.com/zheng123/p/10717644.html

    展开全文
  • 110kV/10kV变电站电气一次部分设计,内含电气主接线图、电气总平面布置图、10kV配电装置布置图、110kV电气平面布置图、110kV出线间隔断面图、110kV主变压器及其进线间隔断面图、母线设备间隔断面图等等,内涵图纸...
  • 办公室平面布局图CAD文件打包,里面包含建材城售楼部平面图、办公室平面布局图、总平面图等等,文件还是比价多的有参考意义。
  • 折线分割平面

    2016-05-11 16:32:41
    思路:参考大神的思路,如果n条直线可以将平面分为1+1+2+……n,如果每次增加两条相互平行的直线, 当第n次添加时,第2n-1条直线和第2n条直线都各能增加2*(n-1)+1 个平面。 所以第n次添加增加的面数是2[2(n-1...

    题意:

    一条折线可以将平面分割成两部分,两条可以分割为7部分。那么n条呢?

    思路:参考大神的思路,如果n条直线可以将平面分为1+1+2+……n,如果每次增加两条相互平行的直线,

    当第n次添加时,2n-1条直线和第2n条直线都各能增加2*n-1+1 个平面。

    所以第n次添加增加的面数是2[2(n-1) + 1 个。因此,总面数应该是

    1 + 4n(n+1)/2 - 2n = 2n2 + 1 

     

    如果把每次加进来的平行边让它们一头相交

    杭电acm2050 <wbr>折线分割平面

    则平面13已经合为一个面,因此,每一组平行线相交后,就会较少一个面,

    所以所求就是平行线分割平面数减去N,为2n2 -n + 1

    ac代码:

    #include<iostream>
    using namespace std;
    int main()
    {
        int n,m;
        cin>>n;
        while(n--)
        {
            cin>>m;
            cout<<2*m*m-m+1<<endl;


        }
    }

    展开全文
  • AD18 分割平面方法

    千次阅读 2020-03-02 21:49:58
    此篇仅作笔记保留,参考链接如下,如有侵权请联系; 小编参考链接,...3、添加内平面 Internal Plane,的添加两层内平面:选择AddInternal Plane 4、设...

    此篇仅作笔记保留,参考链接如下,如有侵权请联系;

    小编参考链接,https://jingyan.baidu.com/article/d5a880ebf956c313f147ccf9.html

    1、总截图

    2、添加PCB层数操作:  设计 --》 层叠管理器

    3、添加内平面 Internal Plane,总的添加两层内平面:选择 Add Internal Plane

    4、设置层名称并选择OK:

    5、打开PCB属性的对话框:

    6、选择内平面编辑:Split Plane Editor

    7、分割平面只需要放置线条,选择对应的平面即可分离平面

    8、设置内平面层电气连接

    8、设置内平面层过孔外形

    展开全文
  • 1、甲方需在合同签订之日起两个工作日内将委托设计费用的30%付给乙方(乙方收到甲方的款项后作为设...该文档为广告平面设计委托合同书范文,是一份很不错的参考资料,具有较高参考价值,感兴趣的可以下载看看
  • 平面法向量由点云协方差最小的特征值对应的特征向量给出(平面特征中,有一个特征值明显小于另两个特征值); 平面均方差(MSE)由点云协方差最小特征值给出; 平面性评估由点云协方差第二大特征值与最小特征的...
  • 如下图所示,平面上有一些关键点集,现需要将所有的点连接起来,使得任何一个点都可以和其他点连通(直接或者间接的连接)且连接连接线段长度总和最短 例:如下图中A、B、C、D四点,连接AB、BC、BD即可满足ABCD四点...
  • 自动端口的上下边沿与传输线和参考地相连 模式驱动下设置集端口 波端口平面设置 设置集端口 设置积分校准线 终端驱动模式下设置集端口 将当前驱动模型设置为终端驱动模型 ...
  • 在高频范围内,信号传输过程中,信号沿到达的地方,信号线和参考平面(电源或地平面)间由于电场的建立,会产生一个瞬间电流,如果传输线是各向同性的,那么只要信号在传输,就始终存在一个电流I,而如果信号的输出...
  • 在高频范围内,信号传输过程中,信号沿到达的地方,信号线和参考平面(电源或地平面)间由于电场的建立,会产生一个瞬间电流,如果传输线是各向同性的,那么只要信号在传输,就始终存在一个电流I,而如果信号的输出...
  • 实用标准文案 精心整理 Photoshop 经典教程 10000 例与常见问题处理 177 例 很多朋友都很羡慕那些处理图片的高手后期制作可以把拍下的片子处理的哪么好 看唯美 其实想想咱自自己就可以学习的俗话说的好自己动手...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 141
精华内容 56
关键字:

参考总平面