Quickstart Visualization

Visualization implies to have a GUI, which will help to display many things: graphs, text, 3D representations, … This software provides a clean interface to PyQt. PyQt works that way:

  • A QMainWindow that includes layouts, (ex: horizontal, vertical, grid, …)

  • Layouts can include widgets.

  • Widgets can be anything: buttons, menu, opengl 3D representation, graphs, … Several high-level widgets are proposed, check optimeed.visualize.gui.widgets .

Simple gui using OpenGL:

"""This example shows how to create a simple gui that contains an openGL widget. First define the imports:"""
from optimeed.visualize.gui.widgets.widget_openGL import widget_openGL
from optimeed.visualize.gui.gui_mainWindow import gui_mainWindow

from optimeed.visualize.gui.widgets.openGLWidget.DeviceDrawerInterface import DeviceDrawerInterface
from optimeed.core.interfaceDevice import InterfaceDevice
from optimeed.visualize.gui.widgets.openGLWidget.OpenGlFunctions_Library import *
from optimeed.visualize.gui.widgets.openGLWidget.Materials_visual import *


class Cone(InterfaceDevice):
    """Device to be drawn"""
    def __init__(self):
        self.width = 1  # base width
        self.height = 1.5  # height


class ConeDrawer(DeviceDrawerInterface):
    """Drawer of the device"""
    def __init__(self):
        self.theCone = None

    def draw(self, theCone):
        self.theCone = theCone
        glPushMatrix()  # Remove the previous matrices transformations
        glTranslate(0, 0, -theCone.height/2)  # Move the cone
        Bronze_material.activateMaterialProperties()  # Change colour aspect of the cones
        draw_disk(0, theCone.width, 50, translate=theCone.height)  # Draw the base
        gluCylinder(gluNewQuadric(), 0, theCone.width, theCone.height, 50, 10)  # Draw the cylinde
        glPopMatrix()  # Push back previous matrices transformations

    def get_init_camera(self, theDevice):
        tipAngle = 10
        viewAngle = 10
        zoomLevel = 0.5
        return tipAngle, viewAngle, zoomLevel

    def keyboard_push_action(self, theKey):
        if theKey == ord(b'H'):
            self.theCone.x += 0.2  # Change the radius length when h is pressed


def run():
    """Instantiates objects and run the code"""
    openGlWidget = widget_openGL()
    theDrawer = ConeDrawer()
    theCone = Cone()
    openGlWidget.set_deviceDrawer(theDrawer)
    openGlWidget.set_deviceToDraw(theCone)
    myWindow = gui_mainWindow([openGlWidget])
    myWindow.run(True)

Advanced visualization:

"""This example truly shows the potential of this tool, by linking saved data to graphs."""

from optimeed.core import ListDataStruct
# Visuals imports
from optimeed.core.linkDataGraph import LinkDataGraph, HowToPlotGraph
from optimeed.visualize.gui.gui_mainWindow import gui_mainWindow
# Graph visuals imports
from optimeed.visualize.gui.widgets.widget_graphs_visual import widget_graphs_visual
from optimeed.visualize.gui.widgets.graphsVisualWidget.examplesActionOnClick import *
from optimeed.visualize.gui.widgets.graphsVisualWidget.smallGui import guiPyqtgraph
# OpenGL imports
from optimeed.visualize.gui.widgets.widget_openGL import widget_openGL
from optimeed.visualize.gui.widgets.openGLWidget.DeviceDrawerInterface import DeviceDrawerInterface
from optimeed.visualize.gui.widgets.openGLWidget.OpenGlFunctions_Library import *
from optimeed.visualize.gui.widgets.openGLWidget.Materials_visual import *

import os


class Drawer(DeviceDrawerInterface):
    def __init__(self):
        self.theDevice = None

    def draw(self, theDevice):
        self.theDevice = theDevice
        glPushMatrix()
        Bronze_material.activateMaterialProperties()
        draw_simple_rectangle(theDevice.x, theDevice.y)
        glPopMatrix()

    def get_init_camera(self, theDevice):
        return 0, 0, 0.5


def run():
    """Example on how to get back data from optimization"""

    """Load collections. File is relative to this directory __file__"""
    foldername = os.path.join(os.path.dirname(__file__), 'resources')
    collection_devices = ListDataStruct.load(foldername + '/autosaved.json')
    collection_logOpti = ListDataStruct.load(foldername + '/logopti.json')

    """Instantiates high level module that links the data contained in collections to graphs (that will be later created)"""
    theDataLink = LinkDataGraph()
    id_logOpti = theDataLink.add_collection(collection_logOpti)
    id_devices = theDataLink.add_collection(collection_devices)

    """The attributes to plots on x and y axis, and additional kwargs."""
    howToPlot = HowToPlotGraph('objectives[0]', 'objectives[1]', {'x_label': "Objective 1", 'y_label': "Objective 2", 'is_scattered': True})

    """The trick here is that the objective functions is not directly stocked in collection_devices but in collection_logOpti. So we display the
    objectives coming from collection_logOpti but we link collection_devices from it."""
    howToPlot.exclude_col(id_devices)
    theDataLink.link_collection_to_graph_collection(id_logOpti, id_devices)  # Link the devices to the logopti

    """Generate the graphs"""
    theDataLink.add_graph(howToPlot)
    theGraphs = theDataLink.createGraphs()

    """Add additional actions to perform when the graph is clicked. This is what makes this software extremely powerful."""
    theActionsOnClick = list()

    openGlDrawing = widget_openGL()
    openGlDrawing.set_deviceDrawer(Drawer())

    theActionsOnClick.append(on_graph_click_showAnim(theDataLink, DataAnimationOpenGL(openGlDrawing)))
    theActionsOnClick.append(on_graph_click_showInfo(theDataLink, visuals=[Repr_opengl(Drawer())]))
    theActionsOnClick.append(on_click_extract_pareto(theDataLink, max_x=False, max_y=False))
    theActionsOnClick.append(on_graph_click_delete(theDataLink))

    """Create the widget of the graphs, and the associated GUI"""
    myWidgetGraphsVisuals = widget_graphs_visual(theGraphs, highlight_last=True, refresh_time=-1)
    guiPyqtgraph(myWidgetGraphsVisuals, actionsOnClick=theActionsOnClick)  # Add GUI to change action easily and export graphs
    myWidgetGraphsVisuals = myWidgetGraphsVisuals

    """Launch the window"""
    myWindow = gui_mainWindow([myWidgetGraphsVisuals])
    myWindow.run(True)

run()