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.