Search Algorithm Playground

Search Algorithm Playground is a python package to work with graph related algorithm, mainly dealing with different Artificial Intelligence Search alorithms. The tool provides an user interface to work with the graphs and visualise the effect of algorithm on the graph while giving the freedom to programmer to make adjustments in the way they wants. It also provides a way to save the graph in json format hence enabling the programmers to share the files and use different algorithm on same graph with ease.

The package is made using pygame module.

Currently supports only undirected graphs

Table of Contents

• Installation
• Controls
• Basic Use
• Documentation
• Implemented Examples

Installation

Install from pip

pip install SearchAlgoPlayground

Manually install it

Copy the repository in your system then do

python setup.py install

You can also copy/paste the SearchAlgoPlayground folder into your project

Controls

Creating a node

Double click on any empty block will create a node on it.

NOTE: Single click highlights the selected block and info label area will display it's location in 2D Matrix.

Creating an edge between two nodes

Clicking on a node single time selects the node for creating an edge with that.
Select one node, once selected select another node to create an edge between them.

Modify element mode

Double click on any element makes it go in modify mode which allows the element to be deleted or edited.

To delete an edge double click on it and then press DELETE

To edit an edge weight double click and use keyboard to modify it's value, once done hit ENTER or click anywhere else.

To delete a node double click on it and then hit DELETE on keyboard

To edit node label double click on a node and use keyboard to modify the label, once done hit ENTER or click anywhere else.

NOTE: Label of a node must be unique

Move nodes on the playground

Click on the node and drag it on the playground.

Basic Use:

• simple PlayGround
• Loading graph from file
• Set filename to save your work into
• PlayGround with weighted edge
• Setting up dimension for the world in playground
• Setting onStart event
• Changing configuration for playground
• Working with neighbouring nodes

simple PlayGround:

Creates PlayGround object with default values

from SearchAlgoPlayground import PlayGround

pg = PlayGround() #Creating a playground object
pg.run() #run the playground

Loading graph from file:

Method Used: fromfilename()

NOTE: The graph file here in below example Graph.json must have been saved by the playground, i.e. saved by clicking Save Work button.

from SearchAlgoPlayground import PlayGround

pg = PlayGround.fromfilename("Graph.json") #loading a playground from a file
pg.run() #run the playground

Set filename to save your work into:

Parameter used: saveToFile

from SearchAlgoPlayground import PlayGround

pg = PlayGround(saveToFile = "MyWork.json") #Creating a playground object with name of the file provided where the work will be saved
pg.run() #run the playground

PlayGround with weighted edge:

Parameter used: weighted

from SearchAlgoPlayground import PlayGround

pg = PlayGround(weighted=True) #Weighted playground
pg.run() #run the playground

Setting up dimension for the world in playground:

Parameter used: saveToFile, weighted, block_dimensions

from SearchAlgoPlayground import PlayGround

#A weighted playground with a name of the file where work need to be saved given as MyWork.json
#block_dimension is dimension of 2D matrix (rows,cols) here both are 20
pg = PlayGround(saveToFile = "MyWork.json",weighted=True,blocks_dimension=(20,20))
pg.run() #run the playground

Setting onStart event:

Method set as onStart will be executed once the Start button is clicked shown on playground.

Parameter used: saveToFile, weighted, block_dimensions

Method used: onStart()

from SearchAlgoPlayground import PlayGround

#A weighted playground with a name of the file where work need to be saved given as MyWork.json
#block_dimension is dimension of 2D matrix (rows,cols) here both are 20
pg = PlayGround(saveToFile = "MyWork.json",weighted=True,blocks_dimension=(20,20))

##Sample function to be put as start for playground
def sayHello():
    print("Hello From Playground!")


pg.onStart(sayHello) #Setting method for on start click
pg.run() #run the playground

Changing configuration for playground:

Changing values in configuration can modify the default values for PlayGround and world related to it.

from SearchAlgoPlayground import PlayGround
from SearchAlgoPlayground import config
from SearchAlgoPlayground.config import YELLOW,PURPLE

config["BACKGROUND_COLOR"] = YELLOW #set background color as yellow
config["NODE_COLOR"] = PURPLE #set node color as purple

#A weighted playground with a name of the file where work need to be saved given as MyWork.json
#block_dimension is dimension of 2D matrix (rows,cols) here both are 20
pg = PlayGround(saveToFile = "MyWork.json",weighted=True,blocks_dimension=(20,20))

pg.run() #run the playground

Below are the given default values, or look into the file config.py

config = {
    "TITLE":"Algo PlayGround",               #Title of the playground window
    "BLOCKS_DIMENSION":(21,23),              #ROWS,COLUMNS
    "BLOCK_SIZE":30,                         #Size of each block i.e. sides
    "BOTTOM_PANEL_HEIGHT":200,               #Size of bottom panel for control
    "MARGIN":15,                             #Margin between sides and the grid 
    "GRID_WIDTH":1,                          #Width of the boundary of the block
    "BACKGROUND_COLOR":WHITE,                #Color of the background of the world
    "GRID_COLOR":GRAY,                       #Block boundary color
    "HIGHLIGHT_COLOR":DARK_GRAY,             #Highlighting color
    "BUTTON_COLOR_PRIMARY":BROWN,            #Color for the button larger
    "BUTTON_COLOR_SECONDARY": PURPLE,        #color for the smaller button
    "INFO_LABEL_COLOR":DARK_GRAY,            #color for the info text
    "NODE_COLOR":GRAY,                       #color of the node
    "NODE_BORDER_COLOR":BLACK,               #color of the border of node
    "SPECIAL_NODE_BORDER_COLOR": DARK_PURPLE,#Special node border color
    "SPECIAL_NODE_COLOR":GREEN,              #special node color
    "SELECTED_NODE_COLOR" : RED,             #color of the node selected
    "ELEMENT_ACTIVE_COLOR":BLUE,             #Element selected by user is considered as active to the playground
    "MY_WORK_DIR": "MyGraph/"                #Directory in which the work is saved
}

Working with neighbouring nodes:

Parameter used: saveToFile, weighted, block_dimensions

Method used: onStart(), getStartNode(), MoveGen(), get_edge(),get_weight(), get_label()

from SearchAlgoPlayground import PlayGround

#A weighted playground with a name of the file where work need to be saved given as MyWork.json
#block_dimension is dimension of 2D matrix (rows,cols) here both are 20
pg = PlayGround(saveToFile = "MyWork.json",weighted=True,blocks_dimension=(20,20))

#Function prints all the neighbouring nodes of the start node in the playground and the weight of the edge connecteding them
def printNeighbours():
    S = pg.getStartNode() #get start node from playground

    #MoveGen method returns the neighbouring nodes
    neighbours = pg.MoveGen(S) #Generating the neighbouring nodes

    #print details of the node
    for node in neighbours:
        #get weight of the edge between S and node
        edge = pg.get_edge(S,node) #method will return Edge class object
        weight = edge.get_weight() #method in Edge class will return weight of the edge

        #Display the details
        print("Edge: {} - {}, Weight: {}".format(S.get_label(),node.get_label(),weight))


pg.onStart(printNeighbours) #Setting method for on start click
pg.run() #run the playground

Above prints value for the following graph

Edge: S - A, Weight: 17
Edge: S - B, Weight: 34
Edge: S - C, Weight: 10

Check more implemented examples here.

Documentation

Classes

• PlayGround
• World
• Block
• Node
• Edge
• UI Module
  • Label
  • Button

PlayGround

PlayGround class represents the ground which which consists of the world of blocks on which the graph is displayed or modified. PlayGround class provide controls on the elements in the world like Edge and Nodes.

Parameters

world, saveToFile, weighted, startNode, goalNode, block_dimensions, block_size

world : World

saveToFile : str

weighted : bool

startNode : Node

goalNode : Node

blocks_dimension : tuple

block_size : int

Attribute

world

world: World

Methods

fromfilename(), addUIElement(), removeUIElement(), onStart(), delay(),getAllNodes(),getAllEges(), MoveGen(), get_edge(), getGoalNode(), getStartNode(), setGoalNode(), setStartNode(), getScreen(), add_node(), add_edge(), remove_edge(), remove_node(), saveWork(), showInfoText(),get_dimension(), to_dict()

fromfilename(filename:str)

addUIElement(element)

removeUIElement(element)

onStart(func)

delay(millisecond:int)

MoveGen(node:Node)

get_edge(nodeStart:Node,nodeEnd:Node)->Edge

getAllNodes()->list

getAllEdges()->list

getGoalNode()->Node

getSartNode()->Node

setGoalNode(node:Node)

setStartNode(node:Node)

getScreen()

add_node(node: Node)

add_edge(edge: Edge)

remove_edge(edge:Edge)

remove_node(node:Node)

saveWork(filename:str=None)

showInfoText(text:str)

to_dict()->dict

setTitle(title:str)

run()

World

A World class represents the world for the playground which is responsible for Maintaining Node,Edge and Block of the playground

Parameters

blocks_dimension, block_size, bottom_panel_size, grid_width, background_color, gird_color, margin

blocks_dimension:tuple

block_size:int

bottom_panel_size:int

grid_width:int

background_color:tuple

gird_color:tuple

margin:int

Methods

fromdict(), create_grids(), add_node(), remove_node(), update_node_loc(), getEdges(), add_edge(), remove_edge(), getNodes(), getNode(), getBlock(), get_dimension(), to_dict()

fromdict(datadict:dict)

create_grids()

add_node(node:Node)

remove_node(node:Node)

update_node_loc(node:Node,newBlock:Block)

getEdges()->dict

add_edge(e:Edge)

remove_edge(e:Edge)

getEdge(startNodeID:tuple,endNodeID:tuple)->Edge

getNodes()->dict

getNode(key:tuple)->Node

getBlock(id)->Block

get_dimension()->tuple

to_dict()->dict

Block

Block defines the world tiles. Blocks represents the world in 2-Dimensional array format.

Attribute

x, y, size, id, pgObj

x:int

y:int

size:int

id:tuple

pgObj

Parameters

x, y, size, id, gird_color, grid_width

x:int

y:int

size:int

id:tuple

gird_color:tuple

grid_width:int

Methods

draw_block(), highlight(), pos(), setHasNode(), hasNode(), to_dict()

draw_block(screen)

highlight(val:bool)

pos() -> tuple

setHasNode(val:bool)

hasNode()->bool

to_dict()->dict

Node

A node is a type of block that is important to the world Node class inherits the Block class.

Parameters

block, label, colorOutline, colorNode, outlineWidth, specialNodeStatus

block:Block

label:str

colorOutline:tuple

colorNode:tuple

outlineWidth:int

specialNodeStatus:bool

Attributes

x, y, size, id, pgObj, pos

x:int

y:int

size:int

id:tuple

pgObj

pos:tuple

Methods

draw_block(), highlight(), pos(), setHasNode(), hasNode(), to_dict(), set_label(), selected(), set_color(), get_label(), setLocation(), handle_event(), add_neighbour(), remove_neighbour(), get_neighbours()

draw_block(screen)

highlight(val:bool)

pos() -> tuple

setHasNode(val:bool)

hasNode()->bool

to_dict()->dict

set_label(label:str,screen)

selected(val:bool)

set_color(color:tuple)

get_label()->str

setLocation(block:Block)

handle_event(world:World,event,infoLabel)

add_neighbour(node:Node)

remove_neighbour(node:Node)

get_neighbour()->list

Edge

An edge class represents an edge between 2 nodes

Parameters

nodeStart, nodeEnd, isWeighted, weight, edgeColor, edgeWidth,

nodeStart:Node

nodeEnd:Node

isWeighted:bool

weight:int

edgeColor:tuple

Attribute

pgObj

pgObj

Methods

handle_event(), set_color(), collidePoint(), draw_edge(), getNodes(), get_weight(), to_dict()

handle_event(world:World,event,infoLabel)

set_color(color:tuple)

collidePoint(clickPoint,offeset=5)

draw_edge(screen)

getNodes()->tuple

get_weight()->int

to_dict()->dict

UI Module

Label

Label to add on pygame screens

Methods

draw(), setValue()

draw(screen)

setValue(text:str)

Parameters

color, size, pos

color:tuple

size:int

pos:tuple

Button

Button elements for pygame screen

Method

draw_button(), isClicked()

draw_button(screen)

isClicked(pos)

Parameters

pos, size, bgColor, color, label, labelSize, fill_value,

pos:tuple

size:tuple

bgColor:tuple

color:tuple

label:str

labelSize:int

fill_value:int