obj转pcd格式

心已赠人 2022-10-07 15:43 194阅读 0赞

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjE0NTU1NA_size_16_color_FFFFFF_t_70_pic_center][]

**功能说明**：创建空白文件夹`workpace`，创建文件`obj2pcd_py.py`，将代码复制到`obj2pcd_py.py`，在脚本所在目录创建`data`文件夹，将`.obj`文件放入到`data`中，运行脚本。（在data中自动创建pcd文件目录）  
**详细代码**：

import os 
    import numpy as np
    import sys
    import shutil
    
    filedir = os.path.dirname(sys.argv[0])
    os.chdir(filedir)
    wdir = os.getcwd()
    print('当前工作目录为：{}\n'.format(wdir))
    
    
    for parent,dirs,files in os.walk(wdir):
    	print(dirs)
    	if 'data' in parent: 
    		os.chdir('data')
    		os.mkdir('pcd_files')
    		#os.mkdir('pcd_files')
    		for file in files:
    			prefix = file.split('.')[0]
    			#f = open('0_pred.obj','rb')
    			new_name = prefix + '.' + 'pcd'
    			print(new_name)
    			f = open(new_name,'w')
    		
    			num_lines = sum(1 for line in open(file))
    			print(num_lines)  
    			#pcd的数据格式 https://blog.csdn.net/BaiYu_King/article/details/81782789  
    			
    			f.write('# .PCD v0.7 - Point Cloud Data file format \nVERSION 0.7 \nFIELDS x y z rgba \nSIZE 4 4 4 4 \nTYPE F F F U \nCOUNT 1 1 1 1 \n' )
    			f.write('WIDTH {} \nHEIGHT 1 \nVIEWPOINT 0 0 0 1 0 0 0 \n'.format(num_lines))
    			f.write('POINTS {} \nDATA ascii\n'.format(num_lines))
    			f1 = open(file,'rb')
    			#f2 = open('new_book.pcd','w')
    
    			lines = f1.readlines()
    			a = []
    			for line in lines:
    				line1 = line.decode()
    	
    				new_line = line1.split(' ')[1] + ' ' + line1.split(' ')[2] + ' ' + line1.split(' ')[3] + ' ' + line1.split(' ')[4] + ' ' + line1.split(' ')[5] + ' ' + line1.split(' ')[6] 
    				#new_line = line.split(' ')[1]
    	
    				#f2.write(new_line)
    				f.write(new_line)
    			f.close()
    			
    			shutil.move(new_name,'pcd_files')
    
    原文链接：https://blog.csdn.net/RNG_uzi_/article/details/87365214

python另一个版本：

import os
    import numpy as np
    
    
    def read_obj(obj_path):
        with open(obj_path) as file:
            points = []
            faces = []
            while 1:
                line = file.readline()
                if not line:
                    break
                strs = line.split(" ")
                if strs[0] == "v":
                    points.append((float(strs[1]), float(strs[2]), float(strs[3])))
                if strs[0] == "f":
                    faces.append((int(strs[1]), int(strs[2]), int(strs[3])))
        points = np.array(points)
        faces = np.array(faces)
    
        return points, faces
    
    
    def save_pcd(filename, pcd):
        num_points = np.shape(pcd)[0]
        f = open(filename, 'w')
        f.write('# .PCD v0.7 - Point Cloud Data file format \nVERSION 0.7 \nFIELDS x y z \nSIZE 4 4 4 \nTYPE F F F \nCOUNT 1 1 1 \n')
        f.write('WIDTH {} \nHEIGHT 1 \nVIEWPOINT 0 0 0 1 0 0 0 \n'.format(num_points))
        f.write('POINTS {} \nDATA ascii\n'.format(num_points))
        for i in range(num_points):
            new_line = str(pcd[i,0]) + ' ' + str(pcd[i,1]) + ' ' + str(pcd[i,2]) + '\n'
            f.write(new_line)
        f.close()
    
    
    if __name__ == "__main__":
        objfile = "000000.obj"
        points, _ = read_obj(objfile)
        pcdfile = objfile.replace('.obj', '.pcd')
        save_pcd(pcdfile, points)
    
    原文链接：https://blog.csdn.net/weixin_42145554/article/details/117387027

c++ pcl格式转换：

参考：[https://www.cnblogs.com/BambooEatPanda/p/8149922.html][https_www.cnblogs.com_BambooEatPanda_p_8149922.html]

#include <pcl/io/io.h>
    #include <pcl/io/pcd_io.h>
    #include <pcl/io/obj_io.h>
    #include <pcl/PolygonMesh.h>
    //#include <pcl/ros/conversions.h>//formROSMsg所属头文件；
    #include <pcl/point_cloud.h>
    #include <pcl/io/vtk_lib_io.h>//loadPolygonFileOBJ所属头文件；
    //#include <pcl/visualization/pcl_visualizer.h>
     
    using namespace std;
    using namespace pcl;
    int main()
    {
        pcl::PolygonMesh mesh;
        pcl::io::loadPolygonFile("sofa.obj", mesh);
     
        pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(new pcl::PointCloud<pcl::PointXYZ>);
        pcl::fromPCLPointCloud2(mesh.cloud, *cloud);
        pcl::io::savePCDFileASCII("result.pcd", *cloud);
     
        cout << cloud->size() << endl;
     
        cout << "OK!";
        cin.get();
        return 0;
    }

转换之前的obj：

![0168881d3b23ee8ee32a4b8e5273c8d5.png][]

转换之后的pcd点云后：

![76cb466e177f1637bd866f06415f1ecd.png][]

提取3D模型的meshes的顶点(Vertex)坐标，对于点云来说点数不够，而且在3D模型存在平面或者是简单立方体的情况下几乎没有点。

所以又需要PCL库了，pcl\_mesh\_sampling可以轻松解决这个问题。

它是通过调用VTK(Visualization ToolKit)读取模型，在3D模型平面均匀地采样点然后生成点云，并且你可以选择需要的点数, 以及voxel grid的采样距离。

#include <pcl/visualization/pcl_visualizer.h>
    #include <pcl/io/pcd_io.h>
    #include <pcl/io/vtk_lib_io.h>
    #include <pcl/common/transforms.h>
    #include <vtkVersion.h>
    #include <vtkPLYReader.h>
    #include <vtkOBJReader.h>
    #include <vtkTriangle.h>
    #include <vtkTriangleFilter.h>
    #include <vtkPolyDataMapper.h>
    #include <pcl/filters/voxel_grid.h>
    #include <pcl/console/print.h>
    #include <pcl/console/parse.h>
     
    inline double
    uniform_deviate (int seed)
    {
      double ran = seed * (1.0 / (RAND_MAX + 1.0));
      return ran;
    }
     
    inline void
    randomPointTriangle (float a1, float a2, float a3, float b1, float b2, float b3, float c1, float c2, float c3,
                         Eigen::Vector4f& p)
    {
      float r1 = static_cast<float> (uniform_deviate (rand ()));
      float r2 = static_cast<float> (uniform_deviate (rand ()));
      float r1sqr = std::sqrt (r1);
      float OneMinR1Sqr = (1 - r1sqr);
      float OneMinR2 = (1 - r2);
      a1 *= OneMinR1Sqr;
      a2 *= OneMinR1Sqr;
      a3 *= OneMinR1Sqr;
      b1 *= OneMinR2;
      b2 *= OneMinR2;
      b3 *= OneMinR2;
      c1 = r1sqr * (r2 * c1 + b1) + a1;
      c2 = r1sqr * (r2 * c2 + b2) + a2;
      c3 = r1sqr * (r2 * c3 + b3) + a3;
      p[0] = c1;
      p[1] = c2;
      p[2] = c3;
      p[3] = 0;
    }
     
    inline void
    randPSurface (vtkPolyData * polydata, std::vector<double> * cumulativeAreas, double totalArea, Eigen::Vector4f& p, bool calcNormal, Eigen::Vector3f& n)
    {
      float r = static_cast<float> (uniform_deviate (rand ()) * totalArea);
     
      std::vector<double>::iterator low = std::lower_bound (cumulativeAreas->begin (), cumulativeAreas->end (), r);
      vtkIdType el = vtkIdType (low - cumulativeAreas->begin ());
     
      double A[3], B[3], C[3];
      vtkIdType npts = 0;
      vtkIdType *ptIds = NULL;
      polydata->GetCellPoints (el, npts, ptIds);
      polydata->GetPoint (ptIds[0], A);
      polydata->GetPoint (ptIds[1], B);
      polydata->GetPoint (ptIds[2], C);
      if (calcNormal)
      {
        // OBJ: Vertices are stored in a counter-clockwise order by default
        Eigen::Vector3f v1 = Eigen::Vector3f (A[0], A[1], A[2]) - Eigen::Vector3f (C[0], C[1], C[2]);
        Eigen::Vector3f v2 = Eigen::Vector3f (B[0], B[1], B[2]) - Eigen::Vector3f (C[0], C[1], C[2]);
        n = v1.cross (v2);
        n.normalize ();
      }
      randomPointTriangle (float (A[0]), float (A[1]), float (A[2]),
                           float (B[0]), float (B[1]), float (B[2]),
                           float (C[0]), float (C[1]), float (C[2]), p);
    }
     
    void
    uniform_sampling (vtkSmartPointer<vtkPolyData> polydata, size_t n_samples, bool calc_normal, pcl::PointCloud<pcl::PointNormal> & cloud_out)
    {
      polydata->BuildCells ();
      vtkSmartPointer<vtkCellArray> cells = polydata->GetPolys ();
     
      double p1[3], p2[3], p3[3], totalArea = 0;
      std::vector<double> cumulativeAreas (cells->GetNumberOfCells (), 0);
      size_t i = 0;
      vtkIdType npts = 0, *ptIds = NULL;
      for (cells->InitTraversal (); cells->GetNextCell (npts, ptIds); i++)
      {
        polydata->GetPoint (ptIds[0], p1);
        polydata->GetPoint (ptIds[1], p2);
        polydata->GetPoint (ptIds[2], p3);
        totalArea += vtkTriangle::TriangleArea (p1, p2, p3);
        cumulativeAreas[i] = totalArea;
      }
     
      cloud_out.points.resize (n_samples);
      cloud_out.width = static_cast<pcl::uint32_t> (n_samples);
      cloud_out.height = 1;
     
      for (i = 0; i < n_samples; i++)
      {
        Eigen::Vector4f p;
        Eigen::Vector3f n;
        randPSurface (polydata, &cumulativeAreas, totalArea, p, calc_normal, n);
        cloud_out.points[i].x = p[0];
        cloud_out.points[i].y = p[1];
        cloud_out.points[i].z = p[2];
        if (calc_normal)
        {
          cloud_out.points[i].normal_x = n[0];
          cloud_out.points[i].normal_y = n[1];
          cloud_out.points[i].normal_z = n[2];
        }
      }
    }
     
    using namespace pcl;
    using namespace pcl::io;
    using namespace pcl::console;
     
    const int default_number_samples = 100000;
    const float default_leaf_size = 0.01f;
     
    void
    printHelp (int, char **argv)
    {
      print_error ("Syntax is: %s input.{ply,obj} output.pcd <options>\n", argv[0]);
      print_info ("  where options are:\n");
      print_info ("                     -n_samples X      = number of samples (default: ");
      print_value ("%d", default_number_samples);
      print_info (")\n");
      print_info (
                  "                     -leaf_size X  = the XYZ leaf size for the VoxelGrid -- for data reduction (default: ");
      print_value ("%f", default_leaf_size);
      print_info (" m)\n");
      print_info ("                     -write_normals = flag to write normals to the output pcd\n");
      print_info (
                  "                     -no_vis_result = flag to stop visualizing the generated pcd\n");
    }
     
    /* ---[ */
    int
    main (int argc, char **argv)
    {
      print_info ("Convert a CAD model to a point cloud using uniform sampling. For more information, use: %s -h\n",
                  argv[0]);
     
      if (argc < 3)
      {
        printHelp (argc, argv);
        return (-1);
      }
     
      // Parse command line arguments
      int SAMPLE_POINTS_ = default_number_samples;
      parse_argument (argc, argv, "-n_samples", SAMPLE_POINTS_);
      float leaf_size = default_leaf_size;
      parse_argument (argc, argv, "-leaf_size", leaf_size);
      bool vis_result = ! find_switch (argc, argv, "-no_vis_result");
      const bool write_normals = find_switch (argc, argv, "-write_normals");
     
      // Parse the command line arguments for .ply and PCD files
      std::vector<int> pcd_file_indices = parse_file_extension_argument (argc, argv, ".pcd");
      if (pcd_file_indices.size () != 1)
      {
        print_error ("Need a single output PCD file to continue.\n");
        return (-1);
      }
      std::vector<int> ply_file_indices = parse_file_extension_argument (argc, argv, ".ply");
      std::vector<int> obj_file_indices = parse_file_extension_argument (argc, argv, ".obj");
      if (ply_file_indices.size () != 1 && obj_file_indices.size () != 1)
      {
        print_error ("Need a single input PLY/OBJ file to continue.\n");
        return (-1);
      }
     
      vtkSmartPointer<vtkPolyData> polydata1 = vtkSmartPointer<vtkPolyData>::New ();
      if (ply_file_indices.size () == 1)
      {
        pcl::PolygonMesh mesh;
        pcl::io::loadPolygonFilePLY (argv[ply_file_indices[0]], mesh);
        pcl::io::mesh2vtk (mesh, polydata1);
      }
      else if (obj_file_indices.size () == 1)
      {
        vtkSmartPointer<vtkOBJReader> readerQuery = vtkSmartPointer<vtkOBJReader>::New ();
        readerQuery->SetFileName (argv[obj_file_indices[0]]);
        readerQuery->Update ();
        polydata1 = readerQuery->GetOutput ();
      }
     
      //make sure that the polygons are triangles!
      vtkSmartPointer<vtkTriangleFilter> triangleFilter = vtkSmartPointer<vtkTriangleFilter>::New ();
    #if VTK_MAJOR_VERSION < 6
      triangleFilter->SetInput (polydata1);
    #else
      triangleFilter->SetInputData (polydata1);
    #endif
      triangleFilter->Update ();
     
      vtkSmartPointer<vtkPolyDataMapper> triangleMapper = vtkSmartPointer<vtkPolyDataMapper>::New ();
      triangleMapper->SetInputConnection (triangleFilter->GetOutputPort ());
      triangleMapper->Update ();
      polydata1 = triangleMapper->GetInput ();
     
      bool INTER_VIS = false;
     
      if (INTER_VIS)
      {
        visualization::PCLVisualizer vis;
        vis.addModelFromPolyData (polydata1, "mesh1", 0);
        vis.setRepresentationToSurfaceForAllActors ();
        vis.spin ();
      }
     
      pcl::PointCloud<pcl::PointNormal>::Ptr cloud_1 (new pcl::PointCloud<pcl::PointNormal>);
      uniform_sampling (polydata1, SAMPLE_POINTS_, write_normals, *cloud_1);
     
      if (INTER_VIS)
      {
        visualization::PCLVisualizer vis_sampled;
        vis_sampled.addPointCloud<pcl::PointNormal> (cloud_1);
        if (write_normals)
          vis_sampled.addPointCloudNormals<pcl::PointNormal> (cloud_1, 1, 0.02f, "cloud_normals");
        vis_sampled.spin ();
      }
     
      // Voxelgrid
      VoxelGrid<PointNormal> grid_;
      grid_.setInputCloud (cloud_1);
      grid_.setLeafSize (leaf_size, leaf_size, leaf_size);
     
      pcl::PointCloud<pcl::PointNormal>::Ptr voxel_cloud (new pcl::PointCloud<pcl::PointNormal>);
      grid_.filter (*voxel_cloud);
     
      if (vis_result)
      {
        visualization::PCLVisualizer vis3 ("VOXELIZED SAMPLES CLOUD");
        vis3.addPointCloud<pcl::PointNormal> (voxel_cloud);
        if (write_normals)
          vis3.addPointCloudNormals<pcl::PointNormal> (voxel_cloud, 1, 0.02f, "cloud_normals");
        vis3.spin ();
      }
     
      if (!write_normals)
      {
        pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_xyz (new pcl::PointCloud<pcl::PointXYZ>);
        // Strip uninitialized normals from cloud:
        pcl::copyPointCloud (*voxel_cloud, *cloud_xyz);
        savePCDFileASCII (argv[pcd_file_indices[0]], *cloud_xyz);
      }
      else
      {
        savePCDFileASCII (argv[pcd_file_indices[0]], *voxel_cloud);
      }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjE0NTU1NA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221005/9f5ef7d9738f44aaa5aa993802541334.png
[https_www.cnblogs.com_BambooEatPanda_p_8149922.html]: https://www.cnblogs.com/BambooEatPanda/p/8149922.html
[0168881d3b23ee8ee32a4b8e5273c8d5.png]: /images/20221005/1a0b7afec6fd48db91f4decb6d21e6fa.png
[76cb466e177f1637bd866f06415f1ecd.png]: /images/20221005/b84ddbefe20a40a1ba6789f8c9b5114e.png