def parse_net(self, args):
""" Assembles a net from a list of junctions, segments, and labels. """
thisnet = Net(args)
subdata = self.sub_nodes('J S A L Q B'.split())
# finish building thisnet
for netpt in subdata['netpoint'][:]:
# using a copy so that we can modify subdata['netpoint'] inside loop
if netpt.point_id not in thisnet.points:
thisnet.add_point(netpt)
else:
# oh yeah, a net can have a point more than once, because that
# makes *great* sense.
for point in netpt.connected_points:
thisnet.points[netpt.point_id].add_connected_point(point)
for comp in netpt.connected_components:
thisnet.points[netpt.point_id].add_connected_component(comp)
# update subdata['netpoint'] so that ref to netpt points to the
# new combined point
i = subdata['netpoint'].index(netpt)
subdata['netpoint'][i] = thisnet.points[netpt.point_id]
# yuck, passing in-band
thisnet.ibpts = subdata['netpoint']
for pt_a, pt_b in subdata['segment']:
thisnet.connect((subdata['netpoint'][pt_a - 1],
subdata['netpoint'][pt_b - 1]))
for annot in subdata['annot']:
thisnet.add_annotation(annot)
if '=' in annot.value:
thisnet.add_attribute(*(annot.value.split('=', 1)))
return ('net', thisnet)
def make_net(self, net):
""" Construct an openjson net from an eagle net. """
points = {} # (x, y) -> NetPoint
def get_point(x, y):
""" Return a new or existing NetPoint for an (x,y) point """
if (x, y) not in points:
points[x, y] = NetPoint('%da%d' % (x, y), x, y)
out_net.add_point(points[x, y])
return points[x, y]
out_net = Net(net.name)
for segment in get_subattr(net, 'segment', ()):
for wire in get_subattr(segment, 'wire', ()):
out_net.connect((get_point(self.make_length(wire.x1),
self.make_length(wire.y1)),
get_point(self.make_length(wire.x2),
self.make_length(wire.y2))))
for pinref in get_subattr(segment, 'pinref', ()):
self.connect_pinref(pinref,
get_point(*self.get_pinref_point(pinref)))
return out_net
def parse_net(self, args):
""" Assembles a net from a list of junctions, segments, and labels. """
thisnet = Net(args)
subdata = self.sub_nodes('J S A L Q B'.split())
# finish building thisnet
for netpt in subdata['netpoint'][:]:
# using a copy so that we can modify subdata['netpoint'] inside loop
if netpt.point_id not in thisnet.points:
thisnet.add_point(netpt)
else:
# oh yeah, a net can have a point more than once, because that
# makes *great* sense.
for point in netpt.connected_points:
thisnet.points[netpt.point_id].add_connected_point(point)
for comp in netpt.connected_components:
thisnet.points[netpt.point_id].add_connected_component(
comp)
# update subdata['netpoint'] so that ref to netpt points to the
# new combined point
i = subdata['netpoint'].index(netpt)
subdata['netpoint'][i] = thisnet.points[netpt.point_id]
# yuck, passing in-band
thisnet.ibpts = subdata['netpoint']
for pt_a, pt_b in subdata['segment']:
thisnet.connect(
(subdata['netpoint'][pt_a - 1], subdata['netpoint'][pt_b - 1]))
for annot in subdata['annot']:
thisnet.add_annotation(annot)
if '=' in annot.value:
thisnet.add_attribute(*(annot.value.split('=', 1)))
return ('net', thisnet)
def make_net(self, net):
""" Construct an openjson net from an eagle net. """
points = {} # (x, y) -> NetPoint
def get_point(x, y):
""" Return a new or existing NetPoint for an (x,y) point """
if (x, y) not in points:
points[x, y] = NetPoint('%da%d' % (x, y), x, y)
out_net.add_point(points[x, y])
return points[x, y]
out_net = Net(net.name)
for segment in get_subattr(net, 'segment', ()):
for wire in get_subattr(segment, 'wire', ()):
out_net.connect((get_point(self.make_length(wire.x1),
self.make_length(wire.y1)),
get_point(self.make_length(wire.x2),
self.make_length(wire.y2))))
for pinref in get_subattr(segment, 'pinref', ()):
self.connect_pinref(pinref,
get_point(*self.get_pinref_point(pinref)))
return out_net
def calc_nets(self, design, segments):
""" Return a set of Nets from segments """
coord2point = {} # (x, y) -> NetPoint
def get_point(coord):
""" Return a new or existing NetPoint for an (x,y) point """
coord = (int(coord[0]), int(coord[1]))
if coord not in coord2point:
coord2point[coord] = NetPoint('%da%d' % coord, coord[0],
coord[1])
return coord2point[coord]
# use this to track connected pins not yet added to a net
self.make_pin_points(design, get_point)
# set of points connected to pins
pin_points = set(coord2point.itervalues())
# turn the (x, y) points into unique NetPoint objects
segments = set((get_point(p1), get_point(p2)) for p1, p2 in segments)
nets = []
# Iterate over the segments, removing segments when added to a net
while segments:
seg = segments.pop() # pick a point
newnet = Net('')
map(pin_points.discard, seg) # mark points as used
newnet.connect(seg)
found = True
while found:
found = set()
for seg in segments: # iterate over segments
if newnet.connected(seg): # segment touching the net
map(pin_points.discard, seg) # mark points as used
newnet.connect(seg) # add the segment
found.add(seg)
for seg in found:
segments.remove(seg)
nets.append(newnet)
# add single-point nets for overlapping pins that are not
# already in other nets
for point in pin_points:
if len(point.connected_components) > 1:
net = Net('')
net.add_point(point)
nets.append(net)
for net in nets:
net.net_id = min(net.points)
nets.sort(key=lambda net: net.net_id)
return nets
def calc_nets(self, design, segments):
""" Return a set of Nets from segments """
coord2point = {} # (x, y) -> NetPoint
def get_point(coord):
""" Return a new or existing NetPoint for an (x,y) point """
coord = (int(coord[0]), int(coord[1]))
if coord not in coord2point:
coord2point[coord] = NetPoint('%da%d' % coord, coord[0], coord[1])
return coord2point[coord]
# use this to track connected pins not yet added to a net
self.make_pin_points(design, get_point)
# set of points connected to pins
pin_points = set(coord2point.itervalues())
# turn the (x, y) points into unique NetPoint objects
segments = set((get_point(p1), get_point(p2)) for p1, p2 in segments)
nets = []
# Iterate over the segments, removing segments when added to a net
while segments:
seg = segments.pop() # pick a point
newnet = Net('')
map(pin_points.discard, seg) # mark points as used
newnet.connect(seg)
found = True
while found:
found = set()
for seg in segments: # iterate over segments
if newnet.connected(seg): # segment touching the net
map(pin_points.discard, seg) # mark points as used
newnet.connect(seg) # add the segment
found.add(seg)
for seg in found:
segments.remove(seg)
nets.append(newnet)
# add single-point nets for overlapping pins that are not
# already in other nets
for point in pin_points:
if len(point.connected_components) > 1:
net = Net('')
net.add_point(point)
nets.append(net)
for net in nets:
net.net_id = min(net.points)
nets.sort(key=lambda net : net.net_id)
return nets
def calc_nets(self, segments):
""" Return a set of Nets from segments """
points = {} # (x, y) -> NetPoint
def get_point(point):
""" Return a new or existing NetPoint for an (x,y) point """
point = (make_length(point[0]), make_length(point[1]))
if point not in points:
points[point] = NetPoint('%da%d' % point, point[0], point[1])
return points[point]
# turn the (x, y) points into unique NetPoint objects
segments = set((get_point(p1), get_point(p2)) for p1, p2 in segments)
nets = []
# Iterate over the segments, removing segments when added to a net
while segments:
seg = segments.pop() # pick a point
newnet = Net('')
newnet.connect(seg)
found = True
while found:
found = set()
for seg in segments: # iterate over segments
if newnet.connected(seg): # segment touching the net
newnet.connect(seg) # add the segment
found.add(seg)
for seg in found:
segments.remove(seg)
nets.append(newnet)
for net in nets:
net.net_id = min(net.points)
nets.sort(key=lambda net: net.net_id)
return nets
def calc_nets(self, segments):
""" Return a set of Nets from segments """
points = {} # (x, y) -> NetPoint
def get_point(point):
""" Return a new or existing NetPoint for an (x,y) point """
point = (make_length(point[0]), make_length(point[1]))
if point not in points:
points[point] = NetPoint('%da%d' % point, point[0], point[1])
return points[point]
# turn the (x, y) points into unique NetPoint objects
segments = set((get_point(p1), get_point(p2)) for p1, p2 in segments)
nets = []
# Iterate over the segments, removing segments when added to a net
while segments:
seg = segments.pop() # pick a point
newnet = Net('')
newnet.connect(seg)
found = True
while found:
found = set()
for seg in segments: # iterate over segments
if newnet.connected(seg): # segment touching the net
newnet.connect(seg) # add the segment
found.add(seg)
for seg in found:
segments.remove(seg)
nets.append(newnet)
for net in nets:
net.net_id = min(net.points)
nets.sort(key=lambda net : net.net_id)
return nets
def parse_net(self, args):
""" Assembles a net from a list of junctions, segments, and labels. """
thisnet = Net(args)
subdata = defaultdict(list)
for phrase in self.stream:
print phrase
cmd, _sep, args = phrase.partition(' ')
if cmd not in ('J', 'S', 'A', 'L', 'Q', 'B'):
self.stream.push(phrase)
break
print args
k, v = self.parsenode(cmd)(args)
subdata[k].append(v)
# finish building thisnet
for netpt in subdata['netpoint'][:]:
# using a copy so that we can modify subdata['netpoint'] inside loop
if netpt.point_id not in thisnet.points:
thisnet.add_point(netpt)
else:
# oh yeah, a net can have a point more than once, because that
# makes *great* sense.
for point in netpt.connected_points:
thisnet.points[netpt.point_id].add_connected_point(point)
for comp in netpt.connected_components:
thisnet.points[netpt.point_id].add_connected_component(comp)
# update subdata['netpoint'] so that ref to netpt points to the
# new combined point
i = subdata['netpoint'].index(netpt)
subdata['netpoint'][i] = thisnet.points[netpt.point_id]
# yuck, passing in-band
thisnet.ibpts = subdata['netpoint']
for pt_a, pt_b in subdata['segment']:
thisnet.connect((subdata['netpoint'][pt_a - 1],
subdata['netpoint'][pt_b - 1]))
for annot in subdata['annot']:
thisnet.add_annotation(annot)
if '=' in annot.value:
thisnet.add_attribute(*(annot.value.split('=', 1)))
return ('net', thisnet)
def parse_net(self, args):
""" Assembles a net from a list of junctions, segments, and labels. """
thisnet = Net(args)
subdata = defaultdict(list)
for phrase in self.stream:
cmd, _sep, args = phrase.partition(' ')
if cmd not in ('J', 'S', 'A', 'L', 'Q', 'B'):
self.stream.push(phrase)
break
k, v = self.parsenode(cmd)(args)
subdata[k].append(v)
# finish building thisnet
for netpt in subdata['netpoint'][:]:
# using a copy so that we can modify subdata['netpoint'] inside loop
if netpt.point_id not in thisnet.points:
thisnet.add_point(netpt)
else:
# oh yeah, a net can have a point more than once, because that
# makes *great* sense.
for point in netpt.connected_points:
thisnet.points[netpt.point_id].add_connected_point(point)
for comp in netpt.connected_components:
thisnet.points[netpt.point_id].add_connected_component(comp)
# update subdata['netpoint'] so that ref to netpt points to the
# new combined point
i = subdata['netpoint'].index(netpt)
subdata['netpoint'][i] = thisnet.points[netpt.point_id]
# yuck, passing in-band
thisnet.ibpts = subdata['netpoint']
for pt_a, pt_b in subdata['segment']:
thisnet.connect((subdata['netpoint'][pt_a - 1],
subdata['netpoint'][pt_b - 1]))
for annot in subdata['annot']:
thisnet.add_annotation(annot)
if '=' in annot.value:
thisnet.add_attribute(*(annot.value.split('=', 1)))
return ('net', thisnet)
