Public Member Functions
def	__init__ (self, graph)

def	reset (self)

def	get (self, coord)

def	getPath (self, node)

def	neighbours (self, node)

def	findPath (self, fromLoc, toLoc)

Public Attributes
	graph

	xs

	ys

	cols

	open

Detailed Description

Definition at line 297 of file graph.py.

Constructor & Destructor Documentation

◆ init()

def gui.graph.grid.__init__	(	self,
		graph
	)

Definition at line 298 of file graph.py.

   def __init__(self,graph):
     self.graph=graph
     xs=set()
     ys=set()
     xmargin=5
     ymargin=5
     for n in graph:
       h=n.height()
       w=n.width()
       x=n.x()
       y=n.y()
       xs.add(x-xmargin)
       xs.add(x+w+xmargin)
       ys.add(y-ymargin)
       ys.add(y+h+ymargin)
  
     xs=list(xs)
     xs.sort()
     x0=xs[0]-36
     xs.insert(0,x0)
     x0=xs[-1]+36
     xs.append(x0)
  
     ys=list(ys)
     ys.sort()
     y0=ys[0]-36
     ys.insert(0,y0)
     y0=ys[-1]+36
     ys.append(y0)
  
     self.xs=xs
     self.ys=ys
     self.cols=[]
     for w in range(len(xs)-1):
       col=[]
       x=(xs[w]+xs[w+1])/2
       for h in range(len(ys)-1):
         y=(ys[h]+ys[h+1])/2
         col.append(node((x,y),(w,h)))
       self.cols.append(col)
  
     for n in graph:
       h=n.height()
       w=n.width()
       x=n.x()
       y=n.y()
       l1,l2=bisect.bisect_left(ys,y-ymargin),bisect.bisect_left(ys,y+h+ymargin)
       i1,i2=bisect.bisect_left(xs,x-xmargin),bisect.bisect_left(xs,x+w+xmargin)
       for c in self.cols[i1:i2]:
         for e in c[l1:l2]:
           e.blocked=1
  
     #for col in self.cols:
     #  print [e.coord +(e.blocked,) for e in col]
  

Member Function Documentation

◆ findPath()

def gui.graph.grid.findPath	(	self,
		fromLoc,
		toLoc
	)

Find shortest path from fromLoc to toLoc

Definition at line 407 of file graph.py.

   def findPath(self,fromLoc,toLoc):
     """Find shortest path from fromLoc to toLoc"""
     self.reset()
     self.open=[]
     fromNode=self.get(fromLoc)
     self.open.append((fromNode.total,fromNode))
     toNode=self.get(toLoc)
     if toNode.blocked:
       print("toNode is blocked")
       return []
     destx,desty=toNode.coord
     while self.open:
       #if open is not void, take the best node (the first one) 
       t,node=self.open.pop(0)
       node.close=1
       if node == toNode:
         #got toLoc
         return self.getPath(node)
  
       for new_node in self.neighbours(node):
         if new_node.close :
           continue
         x,y =new_node.coord
         path_cost=node.path_cost+distance(node,new_node)
         total=path_cost+h(x,y,destx,desty)
         if new_node.open :
           #the node is already in open
           if total < new_node.total:
             self.open.remove((new_node.total,new_node))
             new_node.path_cost=path_cost
             new_node.parent=node
             new_node.total=total
             bisect.insort(self.open,(new_node.total,new_node))
         else:
           #the node is not yet in open
           new_node.path_cost=path_cost
           new_node.parent=node
           new_node.total=total
           bisect.insort(self.open,(new_node.total,new_node))
           new_node.open=1
  
     return []
  

References YACS::ENGINE::Logger.reset(), YACS::HMI::YACSGuiLoader.reset(), gui.graph.grid.reset(), and arguments.reset.

◆ get()

def gui.graph.grid.get	(	self,
		coord
	)

Definition at line 360 of file graph.py.

   def get(self,coord):
     x,y=coord
     col= bisect.bisect_left(self.xs,x)-1
     if col < 0 or col >= len(self.cols):
       return None
     col=self.cols[col]
     row=bisect.bisect_left(self.ys,y)-1
     if row < 0 or row >= len(col):
       return None
     return col[row]
  

References gui.graph.grid.cols, gui.graph.grid.xs, and gui.graph.grid.ys.

◆ getPath()

def gui.graph.grid.getPath	(	self,
		node
	)

Definition at line 371 of file graph.py.

   def getPath(self,node):
     path=[node.coord]
     parent=node.parent
     while parent:
       prev=node
       node=parent
       parent=node.parent
       if parent:
         #if points are aligned don't keep the middle point
         x,y=node.coord
         x0,y0=prev.coord
         x1,y1=parent.coord
         if (x1-x)*(y0-y)-(y1-y)*(x0-x) == 0: 
           continue
       path.append(node.coord)
     path.reverse()
     return path
  

◆ neighbours()

def gui.graph.grid.neighbours	(	self,
		node
	)

Definition at line 389 of file graph.py.

   def neighbours(self,node):
     col,row=node.index
     l=[]
     steps=((0,  +1), (+1,  0), (0,  -1), (-1,  0 ))
     for step in steps:
       c=col+step[0]
       r=row+step[1]
       if c < 0 or c >=len(self.cols):
         continue
       co=self.cols[c]
       if r <0 or r >= len(co):
         continue
       n=co[r]
       if n.blocked:
         continue
       l.append(n)
     return l
  

References gui.graph.grid.cols.

◆ reset()

def gui.graph.grid.reset ( self )

Definition at line 353 of file graph.py.

   def reset(self):
     for c in self.cols:
       for n in c:
         n.open=n.close=0
         n.total= n.path_cost=0
         n.parent=None
  

References gui.graph.grid.cols.

Referenced by gui.graph.grid.findPath().

Member Data Documentation

◆ cols

gui.graph.grid.cols

Definition at line 330 of file graph.py.

Referenced by gui.graph.grid.get(), gui.graph.grid.neighbours(), and gui.graph.grid.reset().

◆ graph

gui.graph.grid.graph

Definition at line 299 of file graph.py.

Referenced by gui.Items.ItemComposedNode.layout(), and gui.Items.ItemComposedNode.panel1().

◆ open

gui.graph.grid.open

Definition at line 410 of file graph.py.

◆ xs

gui.graph.grid.xs

Definition at line 328 of file graph.py.

Referenced by gui.graph.grid.get().

◆ ys

gui.graph.grid.ys

Definition at line 329 of file graph.py.