auto_layouteditor.py

-#!/usr/bin/env python
-
-import numpy as np
-import ezdxf 
-import random
-from math import sqrt
-import copy
-from LayoutEditor import LayoutScript
-from LayoutScript import *
-
-l=project.newLayout();
-
-#rename a layer
-layers.num(6).name="new text"
-
-c=l.drawing.currentCell
-c.cellName="test-cell-python"
-
-c.addBox(0,0,5000,7000,5)
-c.addRoundedBox(10000,0,5000,7000,500,5)
-c.addChamferedBox(20000,0,5000,7000,500,5)
-c.addCircleBox(point(0,10000),point(5000,17000),5)
-c.addEllipse(5,point(12500,15000),2500,3500)
-c.addPolygonArc(point(22500,15000),2500,3500,0,340,5)
-e=c.addText(5,point(25,25000),layers.num(6).name)
-e.setWidth(1000)
-l.drawing.saveFile("/home/jingyan/Documents/summer_intern_lemur/roco_electrical/testout.dsn")
-
-print("Python script completed")
\ No newline at end of file

dsn_python/README.md

+# dsn_python

dsn_python/dsn_geo.py

+
+
+from pykicad.sexpr import *
+import numpy as np
+
+class load_drawing():
+    def __init__(self,afile):
+        import ezdxf
+        self.dwg=ezdxf.readfile(afile)
+        self.msp=self.dwg.modelspace()
+    
+    def load_all(self):
+        return [self.load_line,self.load_polygon]
+    
+    def load_line(self):
+        startlist=[]
+        endlist=[]
+        line_list=[]
+        for e in self.msp.query('LINE'):
+            startlist.append(e.dxf.start[:2])
+            endlist.append(e.dxf.end[:2])
+        
+        for i in range(len(startlist)):
+            line_list.append(startlist[i])
+            line_list.append(endlist[i])
+        
+        line_list=np.array(line_list)
+        # line_list[:,1]*=-1
+        line_list*=1000
+        line_list=line_list.flatten()
+        line_list=list(line_list)
+
+        return line_list
+    def load_polygon(self):
+        pts_list=[]
+        for e in self.msp.query('LWPOLYLINE'):
+            pts_list.append(np.array(e.get_points()))
+
+        for i in range(len(pts_list)):
+            pts_list[i]=pts_list[i][:,:2]
+            # pts_list[i][:,1]*=-1
+
+            ##Unit = um
+            pts_list[i]=pts_list[i]*1000
+            pts_list[i]=pts_list[i].flatten()
+            pts_list[i]=list(pts_list[i])
+        return pts_list  
+    def load_line_as_polygon(self):
+        pts_list=self.load_polygon()
+        ply_list=[]
+        for i in range(len(pts_list)):
+            for j in range(len(pts_list[i])):
+                ply_list.append(pts_list[i][j])
+        return ply_list
+
+class Boundary(AST):
+    tag='boundary'
+    schema={
+        'path pcb':{
+            '0':{
+                '_parser':integer,
+                '_attr':'brd_index'
+            },
+            '1':{
+                '_parser': number,
+                '_attr': 'path'
+            },
+
+        }
+    }
+
+    def __init__(self,path,brd_index=0):
+        super(Boundary,self).__init__(path=path,brd_index=brd_index)
+  
+
+
+class Keepout(AST):
+    tag='keepout'
+    schema={
+        '0':{
+            '0':{
+                '_parser':text,
+                '_attr':'name'
+            },
+
+            ' ':{
+                '0': {
+                    '_parser':text,
+                    '_attr':'shape'
+                },
+                '1':{
+                    '_parser':text,
+                    '_attr':'typex'
+                },
+                '2':{
+                    '_parser':integer,
+                    '_attr':'brd_index'
+                },
+                '3':{
+                    '_parser': number,
+                    '_attr':'path'
+                },
+            },
+        },
+    }
+    def __init__(self,path,name='\"\"',brd_index=0,shape='polygon',typex='signal'):
+
+        super(Keepout,self).__init__(path=path,name=name,brd_index=brd_index,shape=shape,typex=typex)
\ No newline at end of file

dsn_python/dsn_module.py

+
+from pykicad.sexpr import *
+
+unit_convert=1000
+
+class Placement(AST):
+    tag='component'
+    schema={
+        '0':{
+            '_parser':text,
+            '_attr':'ref1',
+            # '_multiple':True
+        },
+        'place':{
+            '0':{
+                '_parser':text,
+                '_attr':'ref2',
+            },
+            '1':{
+                '_parser':number + number,
+                '_attr':'at'
+            },
+            '2':{
+                '_parser':text,
+                '_attr':'flip'
+            },
+            '3':{
+                '_parser':integer,
+                '_attr':'orientation'
+            },
+            'PN':{
+                '_parser':text,
+                '_attr':'name'
+            }
+        }
+    }  
+    def __init__(self,ref1,at=[0,0],ref2=None,flip='front',orientation=0,name=None):
+        # at[1]=-at[1] #flip y for dsn
+        ref2=ref1
+        super(Placement,self).__init__(ref1=ref1,ref2=ref2,at=at,flip=flip,orientation=orientation,name=name)
+
+class Outline(AST):
+    tag='outline'
+    schema={
+        '0':{
+            'path signal':{
+                '0':{
+                    '_parser':integer,
+                    '_attr':'width'
+                },
+                '1':{
+                    '_parser':integer,
+                    '_attr':'outline_start'
+                },
+                '2':{
+                    '_parser':integer,
+                    '_attr':'outline_end'
+                }
+            }
+
+        }
+    }
+    def __init__(self,width=None,outline_start=None,outline_end=None):
+        super(Outline,self).__init__(width=width,outline_start=outline_start,outline_end=outline_end)
+
+class Pin(AST):
+    tag='pin'
+    schema={
+        '0':{
+            '_parser':text,
+            '_attr':'pin_type',
+        },
+        '1':{
+            '_parser':integer,
+            '_attr':'pin_index',
+        },
+        '2':{
+            '_parser':number+number,
+            '_attr':'pin_at',
+        }
+    }
+    def __init__(self,pin_index=None,pin_at=None,pin_type='Round[A]Pad_1524_um'):
+        super(Pin,self).__init__(pin_type=pin_type,pin_index=pin_index,pin_at=pin_at)
+
+class Shape(AST):
+    tag='shape'
+    schema={
+        ' ':{
+            '0':{
+                '_parser': text,
+                '_attr':'shape'
+                
+            },
+            '1':{
+                '_parser': text,
+                '_attr':'layer'
+            },
+            '2':{
+                '_parser': integer,
+                '_attr': 'size'
+            }
+        }
+    }
+    def __init__(self,shape='circle',layer=None,size=1524):
+        super(Shape,self).__init__(shape=shape,layer=layer,size=size)
+class Padstack(AST):
+    tag='padstack'
+    schema={
+        '0':{
+            '_parser': text,
+            '_attr': 'pin_type'
+        },
+        '1':{
+            'shape':{
+                '_parser':Shape,
+                '_multiple':True
+            },
+        },
+
+        'attach':{
+            '_parser': text
+        }
+    }
+    def __init__(self,pin_type='Round[A]Pad_1524_um',shape=None,attach='off'):
+        shape=self.init_list(shape,[])
+        super(Padstack,self).__init__(pin_type=pin_type,shape=shape,attach=attach)
+    
+    @classmethod
+    def auto_detect(cls,path,attach='off'):
+        """
+        load a module footprint file and auto detect pad info
+        output: padstack class
+        """
+        from pykicad.module import Module as mod 
+        import numpy as np
+        module=mod.from_file(path)
+        
+        pad_types=[]
+        for i in range(len(module.pads)):
+            pad=module.pads[i]
+            combo=[pad.shape,pad.layers,int(pad.size[0]*unit_convert)]
+            if not combo in pad_types:
+                pad_types.append(combo)
+        padstack=[]
+        for i in range(len(pad_types)):
+            shape_class=[]
+            for layer in pad_types[i][1]:
+                if '*' in layer:
+                    layer_ext=layer.split('.')[-1]
+                    shape_class.append(Shape(pad_types[i][0],'F.'+layer_ext,pad_types[i][2]))
+                    shape_class.append(Shape(pad_types[i][0],'B.'+layer_ext,pad_types[i][2]))
+                else:
+                    shape_class.append(Shape(pad_types[i][0],layer,pad_types[i][2]))
+                
+            pin_type='Round[A]Pad_'+str(int(pad_types[i][2]))+'_um'
+            padstack_class=cls(pin_type,shape_class,attach)
+            padstack.append(padstack_class)
+        return padstack
+
+        
+            
+class Footprint(AST):
+    tag='image'
+    schema={
+        '0':{
+            '_parser':text,
+            '_attr':'ref',
+        },
+        'outline':{
+            '_parser':Outline,
+            '_multiple':True
+        },
+        'pin':{
+            '_parser':Pin,
+            '_multiple':True
+
+        }
+
+    }
+    def __init__(self,ref=None,outline=None,pin=None):
+        outline=self.init_list(outline,[])
+        pin=self.init_list(pin,[])
+        super(Footprint,self).__init__(ref=ref,outline=outline,pin=pin)
+
+    
+    @classmethod
+    def from_file(cls,path,ref='REF**'):
+        """ 
+        load module footprint from a '.kicad_mod' file
+        path: afile
+        ref: ref name of module eg. U1
+        output: footprint class
+        """
+        from pykicad.module import Module as mod 
+        import numpy as np
+        module=mod.from_file(path)
+
+        outlines=[]
+        for i in range(len(module.lines)):
+            outline=module.lines[i]
+            width=outline.width*unit_convert
+            outline_start=np.array(outline.start)*unit_convert
+            # outline_start[1]*=-1
+            outline_start=list(outline_start)
+            outline_end=np.array(outline.end)*unit_convert
+            # outline_end[1]*=-1
+            outline_end=list(outline_end)
+            outline_class=Outline(width,outline_start,outline_end)
+            outlines.append(outline_class)
+        
+        pads=[]
+        for i in range(len(module.pads)):
+            pad=module.pads[i]
+            pin_index=int(pad.name)
+            pin_at=np.array(pad.at)*unit_convert
+            pin_at[1]*=-1
+            pin_at=list(pin_at)
+            pin_size=pad.size[0]*unit_convert
+            pin_type='Round[A]Pad_'+str(int(pin_size))+'_um'
+            pin_class=Pin(pin_index,pin_at,pin_type)
+            pads.append(pin_class)
+        return cls(ref=ref,outline=outlines,pin=pads)
+        
+        
+    
+
+

dsn_python/dsn_net.py

+
+from pykicad.sexpr import *
+
+class Net(AST):
+    tag='net'
+    schema={
+        '0':{
+            '_parser': text,
+            '_attr': 'net_name'
+        },
+        '1':{
+            'pins':{
+                '0':{
+                    '_parser':text +text,
+                    '_attr':'conn_pins'
+                },              
+            }
+        }
+    }
+    def __init__(self,net_name,conn_pins=None):
+        super(Net,self).__init__(net_name=net_name,conn_pins=conn_pins)
+
+class NetClass(AST):
+    tag='class'
+    schema={
+        '0':{
+            '0':{
+                '_parser':text,
+                '_attr':'net_class_name'
+            },
+            '1':{
+                '_parser':text+text,
+                '_attr':'nets_name'
+            },
+        },
+        'circuit':{
+            '0':{
+                'use_via':{
+                    '_parser':text,
+                    '_attr':'via_name'
+                }
+            }
+        },
+        'rule':{
+            'width':{
+                '_parser':integer
+            },
+            'clearance':{
+                '_parser': number
+            }
+        }
+    }
+    def __init__(self,net_class_name='default',nets_name=None,
+                via_name='',width=3000,clearance=200.1):
+
+        super(NetClass,self).__init__(net_class_name=net_class_name,nets_name=nets_name,
+                                    via_name=via_name,width=width,clearance=clearance)
+                

dsn_python/dsn_rule.py

+
+
+from pykicad.sexpr import *
+class Clearance(AST):
+    tag='clearance'
+    schema={
+        '0':{
+            '_parser':number,
+            '_attr':'number'
+        },
+        '1':{
+            'type':{
+                '_parser':text,
+                '_attr':'typex'
+            },
+            '_optional':True
+        },
+    }
+    def __init__(self,number=200.1,typex=None):
+        super(Clearance,self).__init__(number=number,typex=typex)
+
+class Rule(AST):
+    tag='rule'
+    schema={
+        '0':{
+            'width':{
+                '_parser': number
+            },
+        },
+        '1':{
+            'clearance':{
+                '_parser':Clearance,
+                '_multiple':True
+            },
+            
+        },
+    }
+
+    def __init__(self,width=250,clearance=None):
+        clearance=self.init_list(clearance,[])
+       
+        super(Rule,self).__init__(width=width,clearance=clearance)
\ No newline at end of file

dsn_python/dsnwritier.py

+#!/usr/bin/env python3
+from pykicad.sexpr import *
+from dsn_rule import *
+from dsn_module import Placement,Footprint, Padstack
+import dsn_module as module
+from dsn_net import *
+from dsn_geo import *
+
+class Parser(AST):
+    tag = 'parser'
+    schema = {
+        'string_quote' : {
+            '_parser' : text,
+            '_attr' : 'quote_char'
+        },
+        'space_in_quoted_tokens' : {
+            '_parser': yes_no,
+            '_attr' : 'tokens_on_off'
+        },
+        'host_cad':{
+            '_parser': text
+        },
+        'host_version':{
+            '_parser':text
+        }
+    }
+    def __init__(self,
+        quote_char='\"',
+        tokens_on_off='on',
+        host_cad= "KiCad's Pcbnew",
+        host_version="5.1.3-ffb9f22~84~ubuntu18.04.1"):
+
+        super(Parser,self).__init__(quote_char=quote_char,
+                                    tokens_on_off=tokens_on_off,
+                                    host_cad=host_cad,
+                                    host_version=host_version)
+
+                         
+class Layer(AST):
+    tag='layer'
+    schema={
+        '0':{
+            '_parser': text,
+            '_attr': 'name'
+        },
+        'type':{
+            '_parser': Literal('signal') | 'power' | 'mixed' | 'jumper' | 'user',
+            '_attr': 'typex'
+        },
+        'property':{
+            'index':{
+                '_parser':text,
+                '_attr':'index'
+            },
+        },
+    }
+    index_ctr=0
+
+    def __init__(self,name,typex='signal',index=None):
+        index=Layer.index_ctr
+        Layer.index_ctr+=1
+        super(Layer,self).__init__(name=name,typex=typex,index=index)
+
+class Dsn(AST):
+    tag = 'PCB "kicad_board"'
+    schema = {
+        '0':{
+            'parser' : {
+            '_parser': Parser
+            },
+        },
+        '1':{
+            'resolution':{
+                '_parser': text + integer
+            },
+        },
+        '2':{    
+            'unit':{
+                '_parser': text
+            },
+        },
+        '3':{
+            'structure':{
+                '0':{
+                    'layers':{
+                        '_parser':Layer,
+                        '_multiple':True
+                    },
+                },
+                '1':{
+                    'boundary':{
+                        '_parser':Boundary, 
+                        '_multiple':False
+                    },                    
+                },
+                '2':{
+                    'keepout':{
+                        '_parser': Keepout,
+                        '_multiple': True
+                    },
+                },
+                '3':{
+                    'via':{
+                        '_parser': text,
+                        '_attr': 'via_type'
+                    },
+                },
+                '4':{
+                    'rule':{
+                        '_parser': Rule
+                    }
+                }
+            },
+            '_optional':True
+        },
+        '4':{
+            'placement':{
+                '0':{
+                    'placement':{
+                        '_parser':Placement,
+                        '_multiple':True
+                    },
+                },
+            },
+        },
+        '5':{
+            'library':{
+                '0':{
+                    'image':{
+                        '_parser': Footprint,
+                        '_multiple': True
+                    },
+                },
+
+                '1':{
+                    '_parser':Padstack,
+                    '_multiple': True,
+                    '_attr':'padstack'
+                }
+
+            }
+        },
+        '6':{
+            'network':{
+                'net':{
+                    '_parser':Net,
+                    '_multiple':True
+                },
+                'netclass':{
+                    '_parser':NetClass,
+                    '_multiple':True
+                }
+            }
+        },
+        '7':{
+            'wiring':{
+                '_parser':text,  #not available before auto-routing, code can be modificed if want to set route from script manually
+                
+            }
+        }
+
+
+           
+    }
+
+    def __init__(self,
+        resolution=['um',10],
+        unit='um',
+        parser=None,
+        layers=None,
+        boundary=None,
+        keepout=None,
+        via_type=None,
+        rule=None,
+        placement=None,
+        image=None,
+        padstack=None,
+        net=None,
+        netclass=None,
+        wiring= None
+        ):
+
+        layers=self.init_list(layers,[])
+        parser=self.init_list(parser,[])
+        boundary=self.init_list(boundary,[])
+        keepout=self.init_list(keepout,[])
+        placement=self.init_list(placement,[])
+        image=self.init_list(image,[])
+        padstack=self.init_list(padstack,[])
+        net=self.init_list(net,[])
+        net=self.init_list(netclass,[])
+
+        super(Dsn,self).__init__(
+            resolution=resolution,
+            unit=unit,
+            parser=parser,
+            layers=layers,
+            boundary=boundary,
+            keepout=keepout,
+            via_type=via_type,
+            rule=rule,
+            placement=placement,
+            image=image,
+            padstack=padstack,
+            net=net,
+            netclass=netclass,
+            wiring=wiring
+            )
+
+    def to_file(self, path):
+        if not path.endswith('.dsn'):
+            path += '.dsn'
+        with open(path, 'w', encoding='utf-8') as f:
+            f.write(self.to_string())     
+
+    @classmethod
+    def from_file(cls, path):
+        return cls.parse(open(path, encoding='utf-8').read())
\ No newline at end of file

dsn_python/gui_defaults.par

+
+(gui_defaults
+  (windows
+    (board_frame
+      visible
+      (bounds
+        351 29 1150 916
+      )
+    )
+    (color_manager
+      not_visible
+      (bounds
+        0 600 1110 134
+      )
+    )
+    (layer_visibility
+      not_visible
+      (bounds
+        0 450 359 162
+      )
+    )
+    (object_visibility
+      not_visible
+      (bounds
+        0 550 395 396
+      )
+    )
+    (display_miscellanious
+      not_visible
+      (bounds
+        0 350 241 333
+      )
+    )
+    (snapshots
+      not_visible
+      (bounds
+        0 250 230 255
+      )
+    )
+    (select_parameter
+      not_visible
+      (bounds
+        0 0 246 467
+      )
+    )
+    (route_parameter
+      not_visible
+      (bounds
+        0 100 261 542
+      )
+    )
+    (manual_rules
+      not_visible
+      (bounds
+        0 27 284 196
+      )
+    )
+    (route_details
+      not_visible
+      (bounds
+        0 27 263 240
+      )
+    )
+    (move_parameter
+      not_visible
+      (bounds
+        0 50 304 139
+      )
+    )
+    (clearance_matrix
+      not_visible
+      (bounds
+        0 150 470 257
+      )
+    )
+    (via_rules
+      not_visible
+      (bounds
+        50 150 335 450
+      )
+    )
+    (edit_vias
+      not_visible
+      (bounds
+        100 150 413 87
+      )
+    )
+    (edit_net_rules
+      not_visible
+      (bounds
+        100 200 913 103
+      )
+    )
+    (assign_net_rules
+      not_visible
+      (bounds
+        100 250 213 84
+      )
+    )
+    (padstack_info
+      not_visible
+      (bounds
+        100 30 0 0
+      )
+    )
+    (package_info
+      not_visible
+      (bounds
+        200 30 0 0
+      )
+    )
+    (component_info
+      not_visible
+      (bounds
+        300 30 0 0
+      )
+    )
+    (net_info
+      not_visible
+      (bounds
+        350 30 0 0
+      )
+    )
+    (incompletes_info
+      not_visible
+      (bounds
+        400 30 0 0
+      )
+    )
+    (violations_info
+      not_visible
+      (bounds
+        500 30 0 0
+      )
+    )
+  )
+  (colors
+    (background
+      204 204 204
+    )
+    (hilight 1.0
+      0 0 204
+    )
+    (incompletes 1.0
+      0 153 153
+    )
+    (outline
+      0 0 0
+    )
+    (component_front
+      0 0 255
+    )
+    (component_back
+      255 0 0
+    )
+    (violations
+      255 0 255
+    )
+    (length_matching 1.0
+      0 255 0
+    )
+    (traces 1.0
+      255 0 0
+      0 0 255
+    )
+    (fixed_traces 1.0
+      255 0 0
+      0 0 255
+    )
+    (vias 1.0
+      200 200 0
+      200 200 0
+    )
+    (fixed_vias 1.0
+      200 200 0
+      200 200 0
+    )
+    (pins 1.0
+      150 50 0
+      160 80 0
+    )
+    (conduction 1.0
+      0 150 0
+      100 100 0
+    )
+    (keepout 1.0
+      0 110 110
+      0 100 160
+    )
+    (via_keepout 1.0
+      100 100 100
+      100 100 100
+    )
+  )
+  (parameter
+    (selection_layers 
+      all_visible
+    )
+    (selectable_items 
+      TRACES VIAS PINS FIXED UNFIXED 
+    )
+    (via_snap_to_smd_center 
+      on
+    )
+    (route_mode 
+      dynamic
+    )
+    (shove_enabled 
+      on
+    )
+    (drag_components_enabled 
+      on
+    )
+    (hilight_routing_obstacle 
+      off
+    )
+    (pull_tight_region 
+      2147483647
+    )
+    (pull_tight_accuracy 
+      500
+    )
+    (clearance_compensation 
+      off
+    )
+    (ignore_conduction_areas 
+      on
+    )
+    (automatic_layer_dimming 
+      0.7
+    )
+    (deselected_snapshot_attributes 
+    )
+  )
+)
\ No newline at end of file

dsn_python/gui_defaults.par.bak

+
+(gui_defaults
+  (windows
+    (board_frame
+      visible
+      (bounds
+        351 29 1150 916
+      )
+    )
+    (color_manager
+      not_visible
+      (bounds
+        0 600 1110 134
+      )
+    )
+    (layer_visibility
+      not_visible
+      (bounds
+        0 450 369 162
+      )
+    )
+    (object_visibility
+      not_visible
+      (bounds
+        0 550 405 396
+      )
+    )
+    (display_miscellanious
+      not_visible
+      (bounds
+        0 350 241 333
+      )
+    )
+    (snapshots
+      not_visible
+      (bounds
+        0 250 230 255
+      )
+    )
+    (select_parameter
+      not_visible
+      (bounds
+        0 0 246 467
+      )
+    )
+    (route_parameter
+      not_visible
+      (bounds
+        0 100 261 542
+      )
+    )
+    (manual_rules
+      not_visible
+      (bounds
+        0 27 284 196
+      )
+    )
+    (route_details
+      not_visible
+      (bounds
+        0 27 263 240
+      )
+    )
+    (move_parameter
+      not_visible
+      (bounds
+        0 50 304 139
+      )
+    )
+    (clearance_matrix
+      not_visible
+      (bounds
+        0 150 470 257
+      )
+    )
+    (via_rules
+      not_visible
+      (bounds
+        50 150 335 450
+      )
+    )
+    (edit_vias
+      not_visible
+      (bounds
+        100 150 413 103
+      )
+    )
+    (edit_net_rules
+      not_visible
+      (bounds
+        100 200 913 103
+      )
+    )
+    (assign_net_rules
+      not_visible
+      (bounds
+        100 250 213 84
+      )
+    )
+    (padstack_info
+      not_visible
+      (bounds
+        100 30 0 0
+      )
+    )
+    (package_info
+      not_visible
+      (bounds
+        200 30 0 0
+      )
+    )
+    (component_info
+      not_visible
+      (bounds
+        300 30 0 0
+      )
+    )
+    (net_info
+      not_visible
+      (bounds
+        350 30 0 0
+      )
+    )
+    (incompletes_info
+      not_visible
+      (bounds
+        400 30 0 0
+      )
+    )
+    (violations_info
+      not_visible
+      (bounds
+        500 30 0 0
+      )
+    )
+  )
+  (colors
+    (background
+      204 204 204
+    )
+    (hilight 1.0
+      230 255 255
+    )
+    (incompletes 1.0
+      255 255 255
+    )
+    (outline
+      0 0 0
+    )
+    (component_front
+      0 0 255
+    )
+    (component_back
+      255 0 0
+    )
+    (violations
+      255 0 255
+    )
+    (length_matching 1.0
+      0 255 0
+    )
+    (traces 1.0
+      255 0 0
+      0 0 255
+    )
+    (fixed_traces 1.0
+      255 0 0
+      0 0 255
+    )
+    (vias 1.0
+      200 200 0
+      200 200 0
+    )
+    (fixed_vias 1.0
+      200 200 0
+      200 200 0
+    )
+    (pins 1.0
+      150 50 0
+      160 80 0
+    )
+    (conduction 1.0
+      0 150 0
+      100 100 0
+    )
+    (keepout 1.0
+      0 110 110
+      0 100 160
+    )
+    (via_keepout 1.0
+      100 100 100
+      100 100 100
+    )
+  )
+  (parameter
+    (selection_layers 
+      all_visible
+    )
+    (selectable_items 
+      TRACES VIAS PINS FIXED UNFIXED 
+    )
+    (via_snap_to_smd_center 
+      on
+    )
+    (route_mode 
+      dynamic
+    )
+    (shove_enabled 
+      on
+    )
+    (drag_components_enabled 
+      on
+    )
+    (hilight_routing_obstacle 
+      off
+    )
+    (pull_tight_region 
+      2147483647
+    )
+    (pull_tight_accuracy 
+      500
+    )
+    (clearance_compensation 
+      off
+    )
+    (ignore_conduction_areas 
+      on
+    )
+    (automatic_layer_dimming 
+      0.7
+    )
+    (deselected_snapshot_attributes 
+    )
+  )
+)
\ No newline at end of file

dsn_python/sesreader.py

+#!/usr/bin/env python3
+
+import copy
+import numpy as np
+from math import sqrt
+def find_wire(file_path,pin_loc=None):
+    if not file_path.endswith('.ses'):
+        file_path+='.ses'
+    ses=open(file_path,'r').read().splitlines()
+    pathsec_list=[]
+    for i in range(len(ses)):
+        if 'path' in ses[i]:
+            for j in range(i,len(ses)):
+                if ')' in ses[j]:
+                    pathsec=[i,j]
+                    pathsec_list.append(pathsec)
+                    break
+    path_list=[]
+    for sec_bry in pathsec_list:
+        onepath=[]
+        for j in range(sec_bry[0]+1,sec_bry[1]):
+            pts_str=ses[j].split()
+            ptstart=int(pts_str[0])
+            ptend=int(pts_str[1])
+            pts=[ptstart,ptend]
+            onepath.append(pts)
+        path_list.append(onepath)
+
+
+    pin_loc_=[]
+    for module in pin_loc:
+        for pin in module:
+            pin=np.array(pin)*10000
+            pin=pin.astype(int)
+            pin=pin.tolist()
+            pin_loc_.append(pin)
+    merged_path_list=[]
+    while len(path_list)!=0:
+        merged_path=path_list[0]
+        path_list.remove(merged_path)
+        flag=True
+        s_merge_flag=True
+        e_merge_flag=True
+        while flag:
+            s=merged_path[0]
+            e=merged_path[-1]
+            # m1_len=len(merged_path)
+            flag=False
+            if s in pin_loc_:
+                s_merge_flag=False
+            if e in pin_loc_:
+                e_merge_flag=False
+            
+            to_merge_temp=[]
+            for restpath in path_list:
+                s_=restpath[0]
+                e_=restpath[-1]
+                # m2_len=len(restpath)
+                # if m1_len<3 or m2_len<3:
+                if (s==s_ or s==e_ or e==s_ or e==e_) and (s_merge_flag or e_merge_flag):
+                    to_merge_temp.append(restpath)
+            if len(to_merge_temp)!=0:
+                dis=[]
+                for temp_path in to_merge_temp:
+                    leng=len_of_path(temp_path)
+                    dis.append(leng)
+                to_merge=to_merge_temp[np.argmin(dis)]
+                to_merge_copy=copy.deepcopy(to_merge)
+                s_=to_merge[0]
+                e_=to_merge[-1]
+                if s==s_ and s_merge_flag:
+                    merged_path.remove(s)
+                    merged_path=list(reversed(merged_path))+(to_merge_copy)
+                    path_list.remove(to_merge) 
+                    flag=True               
+      
+                if s==e_ and s_merge_flag:
+                    merged_path.remove(s)
+                    merged_path=to_merge_copy+(merged_path)
+                    path_list.remove(to_merge) 
+                    flag=True               
+                if e==s_ and e_merge_flag:
+                    merged_path.remove(e)
+                    merged_path=(merged_path)+(to_merge_copy)
+                    path_list.remove(to_merge) 
+                    flag=True               
+                if e==e_ and e_merge_flag:
+                    merged_path.remove(e)
+                    merged_path=to_merge_copy+(list(reversed(merged_path)))
+                    path_list.remove(to_merge) 
+                    flag=True               
+                
+        merged_path_list.append(merged_path)
+    for path in merged_path_list:
+        if len(path)>=3:
+            path_cp=copy.deepcopy(path)
+            for i in range(len(path_cp)-2):
+                pt1=path_cp[i]
+                pt2=path_cp[i+1]
+                pt3=path_cp[i+2]
+                x1,x2,x3=pt1[0],pt2[0],pt3[0]
+                y1,y2,y3=pt1[1],pt2[1],pt3[1]
+                if x1==x2 and x2==x3:
+                    path.remove(pt2)
+                elif y1==y2 and y2==y3:
+                    path.remove(pt2)      
+    return merged_path_list
+
+def len_of_path(path):
+    
+    leng=0
+    for i in range(len(path)-1):
+        pt1=path[i]
+        pt2=path[i+1]
+        x1,y1=pt1[0],pt1[1]
+        x2,y2=pt2[0],pt2[1]
+        dis= sqrt((x1-x2)**2+(y1-y2)**2)
+        leng+=dis
+    return leng
+