Ejemplo n.º 1
0
 def __init__(self):
     self.plot_object = PlotBot()
     self.b_conflicts = self.plot_object.b_conflicts
     self.labels = {}
     self.root = ""
     self.graph = None
Ejemplo n.º 2
0
class PlotNetwork:
    def __init__(self):
        self.plot_object = PlotBot()
        self.b_conflicts = self.plot_object.b_conflicts
        self.labels = {}
        self.root = ""
        self.graph = None

    def generate_network(self, max_nodes=None):
        """Generates a network from the b_conflicts in the plot_object, with
        nodes as conflicts and edges as suggested linked conflicts as per the
        Plotto text. User can set the max_nodes argument if they wish to produce
        a sub_graph of max_nodes nodes

        :param max_nodes: set the limit to the number of nodes generated in the network.
        :return: Returns a networkx DiGraph G

        """
        self.graph = nx.DiGraph()
        first = True
        i = 0
        for conflict in self.b_conflicts:
            if max_nodes is not None and nx.number_of_nodes(self.graph) >= max_nodes:
                break
            curr = self.b_conflicts[conflict]
            self.labels[curr.label] = curr.label
            if first:
                self.root = curr.label
                first = False
            self.graph.add_node(curr.label, object_data=curr)
            for sequel in self.plot_object.get_links(self.b_conflicts[conflict], "sequels"):
                self.graph.add_edge(curr.label, sequel.label)
                self.labels[sequel.label] = sequel.label
            for prequel in self.plot_object.get_links(self.b_conflicts[conflict], "prequels"):
                self.graph.add_edge(prequel.label, curr.label)
                self.labels[prequel.label] = prequel.label

            i += 1
        return self.graph

    def draw_circular_graph(self):
        """ Draws a circular graph from the previously computed graph
        :return: None
        """

        pos = graphviz_layout(self.graph, prog="twopi", args="")
        plt.figure(figsize=(8, 8))
        nx.draw(self.graph, pos, node_size=20, alpha=0.5, node_color="blue", with_labels=False)
        nx.draw_networkx_labels(self.graph, pos, self.labels, font_size=6)

        plt.axis("equal")
        plt.savefig("circular_tree.png")
        plt.show()

    def draw_node_color_map(self):
        """ Draws a node color map based on node degree from
            the previously computed graph.
        :return: None
        """
        pos = nx.spring_layout(self.graph, iterations=2000)
        nx.draw(self.graph, pos, node_color=range(nx.number_of_nodes(self.graph)), node_size=100, cmap=plt.cm.Blues)
        plt.savefig("../../College/FYP/FinalReport/images/node_colormap.png")  # save as png
        plt.show()  # display

    def draw_lanl_graph(self):
        """ Draws a lanl graph from the previously computed graph.
        :return: None
        """
        lanl_graph = sorted(nx.connected_component_subgraphs(self.graph), key=len, reverse=True)[0]

        plt.figure(figsize=(8, 8))
        # use graphviz to find radial layout
        pos = graphviz_layout(self.graph, prog="twopi", root=self.root)
        # draw nodes, coloring by rtt ping time
        nx.draw(self.graph, pos, with_labels=False, alpha=0.5, node_size=15)
        # adjust the plot limits
        xmax = 1.02 * max(xx for xx, yy in pos.values())
        ymax = 1.02 * max(yy for xx, yy in pos.values())
        plt.xlim(0, xmax)
        plt.ylim(0, ymax)
        # plt.show()
        plt.savefig("lanl_routes.png")
Ejemplo n.º 3
0
from flask_video_streaming.camera_pi import Camera
from flask import Flask, render_template, Response
from gpiozero import Button
from time import sleep
from threading import Thread
from sketch import to_sketch
from plotbot import PlotBot

bot = PlotBot()
take_picture = False
drawing = False
drawing_thread = None
frame = None


def cam2bot(p):
    """convert camera resolution 720*480 to bot coordinate"""
    return (p[1] / 480 * 55 + 25, p[0] / 480 * 55 - 50)


def _stop_drawing():
    global drawing
    bot.relax()
    drawing = False
    Camera().get_frame()


def draw():
    global drawing, frame
    lines = to_sketch(frame)
    for line in lines:
Ejemplo n.º 4
0
from flask import Flask, render_template, send_from_directory
from flask_socketio import SocketIO, emit
from plotbot import PlotBot
from time import sleep, time
from threading import Thread
from gpiozero import Button

app = Flask(__name__)
socketio = SocketIO(app, async_mode='threading')
bot = PlotBot()
user_id = None
timestamp = None
background_thread = None
background_run = True
lines = []


def reset():
    global user_id, lines
    user_id = None
    lines = []
    socketio.emit('reset')
    notify()


button = Button(18, pull_up=True, hold_time=2)
button.when_held = reset


def notify(broadcast=True):
    global user_id
Ejemplo n.º 5
0
from plotbot import PlotBot
from time import sleep


def drange(start, stop, step):
    r = start
    while True:
        yield r
        r += step
        if start < stop and r > stop or start > stop and r < stop:
            break


b = PlotBot()


def rect(x1, y1, x2, y2):
    for x in drange(x1, x2, 0.1):
        b.goto([x, y1])
        sleep(.0005)
    for y in drange(y1, y2, 0.1):
        b.goto([x2, y])
        sleep(.0005)
    for x in drange(x2, x1, -0.1):
        b.goto([x, y2])
        sleep(.0005)
    for y in drange(y2, y1, -0.1):
        b.goto([x1, y])
        sleep(.0005)