segmentation / graph_gui

  #!/usr/bin/env python3
  # -*- coding: utf-8 -*-
  """
  Created on Mon Aug  5 15:53:16 2019
  
  @author: pavel
  """
  
  """
      Qt wrapper/container class that handles all the top level events and maintains the
      methods necessary to use the QT signals and slots API.
  """
  

  #from pyqtgraph.Qt import QtCore, QtGui, QtWidgets
  from PyQt5 import QtCore, QtGui, QtWidgets

  from TubeCanvas import TubeDraw

  import numpy as np

  #import trimesh as tm

  DEBUG = False
  

  class TubeWidget(QtWidgets.QWidget):

      sigUpdate = QtCore.pyqtSignal(float, float, float)
      #Initializes the QT wrapper class.
      def __init__(self):
          super(TubeWidget, self).__init__()

          box = QtWidgets.QVBoxLayout(self)

          self.resize(500,500)
          self.setLayout(box)
          self.canvas = TubeDraw()
          #self.canvas.create_native()
          box.addWidget(self.canvas.native)
          self.camera = [0,0,0]
          self.down = False

          self.other = None

          self.canvas.location = self.geometry().center()

          self.canvas.events.mouse_press.connect(self.on_mouse_press)
          self.canvas.events.mouse_release.connect(self.on_mouse_release)
          self.canvas.events.mouse_move.connect(self.on_mouse_move)
          self.canvas.events.mouse_wheel.connect(self.on_mouse_wheel)
  
          #self.show()
  

  
      def link_cameras(self, o_canvas):
          self.canvas.events.mouse_press.connect(o_canvas.on_mouse_press)
          self.canvas.events.mouse_release.connect(o_canvas.on_mouse_release)
          self.canvas.events.mouse_move.connect(o_canvas.on_mouse_move)
          self.canvas.events.mouse_wheel.connect(o_canvas.on_mouse_wheel)
          
      def set_other(self, other):
          self.other = other
      
      def pass_event(self, event, case):
          if self.other != None:
              if case == 0:
                  self.other.canvas.on_mouse_wheel(event)
              if case == 1:
                  self.other.canvas.on_mouse_press(event)
              if case == 2:
                  self.other.canvas.on_mouse_move(event)
              if case == 3:
                  self.other.canvas.on_mouse_release(event)
              #if case == 4:
              #    self.other.sendCameraInfo()
          
          

      #Handles the mouse release event
      def on_mouse_release(self, event):
          self.down=False
          self.sendCameraInfo()

          self.pass_event(event, 3)

  
      #Handles the mouse move event
      def on_mouse_move(self, event):
          if self.down:
              self.sendCameraInfo()

              self.pass_event(event, 2)

      #Handles the mouse press events

      def on_mouse_press(self, event):
          self.down = True

          if event.button == 2:
              menu = QtWidgets.QMenu(self)
              NS = menu.addAction('Export Model')
              action = menu.exec_(event.native.globalPos())
              if action == NS:
                  self.save_stl_mesh()

          else:
              self.pass_event(event, 1)

  
      #Handles the mouse wheel event
      def on_mouse_wheel(self, event):
          self.sendCameraInfo()

          self.pass_event(event, 0)

  
      #controls the emit function of the QT class to send a signal to the slot
      #located in the other window.
      def sendCameraInfo(self):
          #self.view = self.canvas.view
          self.camera = self.canvas.camera
          #print("stuff", self.view[3, 0], self.view[3, 1], self.view[3, 2])

          if DEBUG:
              print("stuff", self.camera[0], self.camera[1], self.camera[2])

          #self.pass_event(None, 4)

          self.sigUpdate.emit(self.camera[0], self.camera[1], self.camera[2])

          
      """
      Function to receive the signal with the information necessary to visualize
      specific fibers only. With the rest of them being minimized.
      """
      @QtCore.pyqtSlot(list)
      def select(self, x):

          self.canvas.select_edges(x)
  #        for e in x:
  #            if e in self.canvas.edge_dict:    
  #                print(self.canvas.edge_dict[e])
  #            elif (e[1], e[0]) in self.canvas.edge_dict:
  #                print(self.canvas.edge_dict[(e[1], e[0])])

          print("got signal", x)

      """
          Initialization method that connects the slot to the function that handles
          the information being sent.
      """
      def connect(self, signal_object):
          signal_object.select.connect(self.select)

          
      def save_stl_mesh(self):
          triangles = self.canvas.triangle_data
          caps = self.canvas.cap_data
          points = self.canvas.cylinder_data['a_position']
          colors = self.canvas.cylinder_data['a_fg_color']
          normals = self.canvas.cylinder_data['a_normal']
          
          mesh = tm.Trimesh(vertices=points, faces=np.append(triangles, caps, axis=0),
                            vertex_colors=colors, vertex_normals=normals)
          mesh.export('with_caps.obj')
          mesh.export('with_caps.ply')