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 TubeCanvas import TubeDraw

  import numpy as np
  import trimesh as tm

  DEBUG = False
  

  class TubeWidget(QtGui.QWidget):
      sigUpdate = QtCore.pyqtSignal(float, float, float)
      #Initializes the QT wrapper class.
      def __init__(self):
          super(TubeWidget, self).__init__()
          box = QtGui.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.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()
  
      #Handles the mouse release event
      def on_mouse_release(self, event):
          self.down=False
          self.sendCameraInfo()
  
      #Handles the mouse move event
      def on_mouse_move(self, event):
          if self.down:
              self.sendCameraInfo()
  

      #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()
                  

  
      #Handles the mouse wheel event
      def on_mouse_wheel(self, event):
          self.sendCameraInfo()
  
      #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.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')