Skip to content
  • Categories
  • Recent
  • Tags
  • Popular
  • Users
  • Groups
  • Search
  • Get Qt Extensions
  • Unsolved
Collapse
Brand Logo
  1. Home
  2. Qt Development
  3. Qt for Python
  4. Convert cloud 3d points in Mesh
Forum Updated to NodeBB v4.3 + New Features

Convert cloud 3d points in Mesh

Scheduled Pinned Locked Moved Unsolved Qt for Python
2 Posts 1 Posters 502 Views
  • Oldest to Newest
  • Newest to Oldest
  • Most Votes
Reply
  • Reply as topic
Log in to reply
This topic has been deleted. Only users with topic management privileges can see it.
  • M Offline
    M Offline
    Mihaill
    wrote on last edited by
    #1

    Hi!
    How convert cloud 3d points in Mesh?

    1 Reply Last reply
    0
    • M Offline
      M Offline
      Mihaill
      wrote on last edited by
      #2

      It is work very slowly

      import sys
      from PyQt5 import QtWidgets, uic, QtCore, QtGui
      from PyQt5.QtWidgets import (QApplication, QWidget, QFileDialog, QLabel, QListWidgetItem, QTableWidgetItem, QHeaderView,
                                   QHBoxLayout)
      from PyQt5.QtGui import QPixmap, QPainter, QImage, QColor, QCursor, QPen, QFont
      from PyQt5.QtCore import QPoint, pyqtSignal, QTimer
      from PyQt5.QtWidgets import *
      from PyQt5.QtDataVisualization import (Q3DScatter, QScatter3DSeries, QAbstract3DSeries, Q3DTheme, QAbstract3DGraph,
                                             Q3DCamera, Q3DInputHandler, QScatterDataItem)
      import random
      import threading
      import open3d as o3d
      import trimesh
      import numpy as np
      import pyvista as pv
      import vtk
      
      import PCFrameProc as Pcp
      
      # from email.policy import Policy
      # import os
      # from pathlib import Path
      # import sys
      # import json
      
      
      
      
      
      from vtkmodules.vtkCommonColor import vtkNamedColors
      from vtkmodules.util import numpy_support
      from vtkmodules.vtkRenderingCore import (
          vtkActor,
          vtkPolyDataMapper,
          vtkRenderWindow,
          vtkRenderWindowInteractor,
          vtkRenderer,
          vtkPropPicker,
          vtkRendererCollection,
          vtkGlyph3DMapper,
      )
      from vtkmodules.vtkRenderingAnnotation import vtkAxesActor
      from vtkmodules.vtkInteractionWidgets import (
          vtkOrientationMarkerWidget, vtkCameraOrientationWidget)
      from vtkmodules.vtkInteractionStyle import vtkInteractorStyleSwitch
      from vtkmodules.vtkCommonDataModel import (
          vtkPolyData,
          vtkPointSet,
          vtkCellArray,
          vtkPolyVertex,
          vtkPolyLine,
      )
      
      from vtkmodules.vtkFiltersCore import (
          vtkGlyph3D, vtkFeatureEdges,
          vtkTubeFilter, vtkDelaunay3D,
          vtkCleanPolyData,)
      
      from vtkmodules.vtkCommonCore import (
          vtkPoints,
          vtkFloatArray,
          VTK_FLOAT,
          VTK_ID_TYPE
      )
      from vtkmodules.vtkFiltersGeneral import vtkVertexGlyphFilter
      from vtkmodules.vtkFiltersSources import (vtkPointSource, vtkSphereSource)
      from vtkmodules.qt.QVTKRenderWindowInteractor import QVTKRenderWindowInteractor
      import vtkmodules.vtkRenderingOpenGL2
      import vtkmodules
      from vtkmodules.vtkIOGeometry import vtkSTLReader, vtkOBJReader # https://kitware.github.io/vtk-examples/site/Python/IO/ReadSTL/
      import vtkmodules.vtkInteractionStyle
      import vtkmodules.vtkRenderingOpenGL2
      from vtkmodules.vtkCommonColor import vtkNamedColors
      from vtkmodules.vtkRenderingCore import (
          vtkCamera,
          vtkRenderWindow,
          vtkRenderWindowInteractor,
          vtkRenderer,
          vtkDataSetMapper,
      )
      from vtkmodules.util import numpy_support
      from vtk.qt.QVTKRenderWindowInteractor import QVTKRenderWindowInteractor
      
      
      
      
      class Mesh3D(QWidget):
          # signalEndScan = pyqtSignal()
      
          def __init__(self):
              QWidget.__init__(self)
              self.layout = QHBoxLayout(self)
              self.vtkWidget = QVTKRenderWindowInteractor()
              self.layout .addWidget(self.vtkWidget)
      
              tmp_np_array = np.load("/home/owner/PythonProjects/add3DImagesInDb/dbFiles/53_1_0.npy")  # shape = (480, 640, 4)
              tmp_np_array = Pcp.Z_Filter(tmp_np_array, Z_min=400, Z_max=950)
              print("shape = ", tmp_np_array.shape)
              tmp_np_array = tmp_np_array[:, :, 0:3].reshape([-1, 3], order='F')
              print("shape = ", tmp_np_array.shape)
              vtkDoubleArr = numpy_support.numpy_to_vtk(tmp_np_array)
              tmp_points = vtkPoints()
              tmp_points.SetData(vtkDoubleArr)
              tmp_polydata = vtkPolyData()
              tmp_polydata.SetPoints(tmp_points)
      
              tmp_sphere = vtkSphereSource()
              tmp_sphere.SetPhiResolution(10)
              tmp_sphere.SetThetaResolution(10)
              tmp_sphere.SetRadius(3.0)
      
              tmp_pointMapper = vtkGlyph3DMapper()
              tmp_pointMapper.SetInputData(tmp_polydata)
              tmp_pointMapper.SetSourceConnection(tmp_sphere.GetOutputPort())
      
              tmp_actor = vtkActor()
              tmp_actor.SetMapper(tmp_pointMapper)
              tmp_colors = vtkNamedColors()
              tmp_actor.GetProperty().SetColor(tmp_colors.GetColor3d("Peacock"))
              self.vtkRenderer = vtkRenderer()
              self.vtkRenderer.AddActor(tmp_actor)
      
              # https://kitware.github.io/vtk-examples/site/Cxx/Modelling/Delaunay3DDemo/
              # все пакеты https://stackoverflow.com/questions/4882993/mesh-generation-from-points-with-x-y-and-z-coordinates
      
              tmp_delaunay3D = vtkDelaunay3D()
              # tmp_delaunay3D.SetInputConnection(tmp_cleaner.GetOutputPort())
              tmp_delaunay3D.SetInputData(tmp_polydata)
              tmp_delaunay3D.SetAlpha(20.0)
              tmp_delaunay3D.Update()
              print("tmp_delaunay3D = ", tmp_delaunay3D)
      
              ## tmp_delaunay3D.SetInputData(tmp_polydata)
              tmp_delaunayMapper = vtkDataSetMapper()
              tmp_delaunayMapper.SetInputConnection(tmp_delaunay3D.GetOutputPort())
              ## tmp_delaunayMapper.SetInputData(tmp_delaunayMapper)
              tmp_delaunayMapper.SetScalarModeToUseCellData()
              print("tmp_delaunayMapper = ", tmp_delaunayMapper)
      
              tmp_delaunayActor = vtkActor()
              tmp_delaunayActor.SetMapper(tmp_delaunayMapper)
              tmp_delaunayActor.GetProperty().SetColor(tmp_colors.GetColor3d("banana"))
              tmp_delaunayActor.GetProperty().SetInterpolationToFlat()
              print("tmp_delaunayActor = ", tmp_delaunayActor)
              self.vtkRenderer.AddActor(tmp_delaunayActor)
              # self.vtkRenderer
      
              # self.renderWindow = vtk.vtkRenderWindow()
              # self.renderWindow.AddRenderer(self.vtkRenderer)
              # self.renderWindow.SetSize(1000, 600)
              # self.renderWindow.SetFullScreen(True)
              # self.renderWindow.
              # self.renderWindow.Render()
      
              self.vtkWidget.Initialize()
              self.vtkWidget.Start()
              # self.ren = vtk.vtkRenderer()
              self.vtkWidget.GetRenderWindow().AddRenderer(self.vtkRenderer)
      
              # self.layout.addWidget(self.renderWindow)
      
      
      
      
              # pts = np.random.rand(512*3).reshape(-1,3)
      
              # Make vtkPolyData of the points array
              # point_cloud = pv.PolyData(pts)
              # point_cloud.plot(render_points_as_spheres=True, point_size=10)
      
              # mesh = point_cloud.delaunay_3d(alpha=0.25)
      
              # # Make a wireframe with some data
              # wires = mesh.compute_cell_sizes(length=False, area=False, volume=True).wireframe()
              # # Plot it
              # wires.plot(line_width=2)
      
      
      
              # pcd = o3d.io.read_point_cloud("/home/owner/Загрузки/test3D.ply")
              # pcd.estimate_normals()
              #
              # # estimate radius for rolling ball
              # distances = pcd.compute_nearest_neighbor_distance()
              # avg_dist = np.mean(distances)
              # print(222222)
              # radius = 1.5 * avg_dist
              #
              # mesh = o3d.geometry.TriangleMesh.create_from_point_cloud_ball_pivoting(
              #            pcd,
              #            o3d.utility.DoubleVector([radius, radius * 2]))
              #
              # print(33333333333)
              #
              # # create the triangular mesh with the vertices and faces from open3d
              # tri_mesh = trimesh.Trimesh(np.asarray(mesh.vertices), np.asarray(mesh.triangles),
              #                           vertex_normals=np.asarray(mesh.vertex_normals))
              #
              # trimesh.convex.is_convex(tri_mesh)
              #
              # o3d.visualization.draw_geometries([tri_mesh])
      
      
      if __name__ == '__main__':
      
          app = QApplication(sys.argv)
      
          w = Mesh3D()
          # w.setWidth(1000)
          # w.setHeight(700)
          w.show()
          # w.renderWindow.Render()
      
          print(11111111)
      
          # widget = QWidget()
          # container = widget.createWindowContainer(w)
          # widget.show()
      
          sys.exit(app.exec_())
      
      1 Reply Last reply
      0

      • Login

      • Login or register to search.
      • First post
        Last post
      0
      • Categories
      • Recent
      • Tags
      • Popular
      • Users
      • Groups
      • Search
      • Get Qt Extensions
      • Unsolved