C# obj模型转换成ply格式

最新推荐文章于 2023-12-26 14:07:09 发布
最新推荐文章于 2023-12-26 14:07:09 发布
阅读量154 收藏
点赞数
分类专栏： C# 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40147088/article/details/131921543
版权

记录下，使用C#将obj模型转换成ply
完整代码如下

1、这个脚本定义了部分使用到的结构

using System;
using System.Collections.Generic;

namespace ModelProcess
{
    class MathUtils
    {
        public class Vector3
        {
            public float x, y, z;
            public Vector3() { }
            public Vector3(float x, float y, float z)
            {
                this.x = x;
                this.y = y;
                this.z = z;
            }

            public static Vector3 Min
            {
                get
                {
                    return new Vector3(float.MinValue, float.MinValue, float.MinValue);
                }
            }

            public static Vector3 Max
            {
                get
                {
                    return new Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
                }
            }

            public static Vector3 operator +(Vector3 a, Vector3 b)
            {
                return new Vector3(a.x + b.x, a.y + b.y, a.z + b.z);
            }

            public static Vector3 operator -(Vector3 a, Vector3 b)
            {
                return new Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
            }

            public static Vector3 operator *(Vector3 v, float a)
            {
                return new Vector3(v.x * a, v.y * a, v.z * a);
            }

            public static Vector3 operator /(Vector3 v, float a)
            {
                if (a == 0) throw new Exception("除数不能为0！");
                return new Vector3(v.x / a, v.y / a, v.z / a);
            }

            /// <summary>
            /// 获取向量长度
            /// </summary>
            /// <returns></returns>
            public float Length()
            {
                return (float)Math.Sqrt(x * x + y * y + z * z);
            }

            /// <summary>
            /// 向量单位化
            /// </summary>
            /// <returns></returns>
            public Vector3 Normalize()
            {
                float length = Length();
                if (length == 0) return new Vector3(x, y, z);
                return new Vector3(x / length, y / length, z / length);
            }

            /// <summary>
            /// 获取两个向量中的更小元素，用于获取包围盒
            /// </summary>
            /// <param name="a"></param>
            /// <param name="b"></param>
            /// <returns></returns>
            public static Vector3 GetMaxComponent(Vector3 a, Vector3 b)
            {
                return new Vector3(Math.Max(a.x, b.x), Math.Max(a.y, b.y), Math.Max(a.z, b.z));
            }

            /// <summary>
            /// 获取两个向量中的更大元素，用于获取包围盒
            /// </summary>
            /// <param name="a"></param>
            /// <param name="b"></param>
            /// <returns></returns>
            public static Vector3 GetMinComponent(Vector3 a, Vector3 b)
            {
                return new Vector3(Math.Min(a.x, b.x), Math.Min(a.y, b.y), Math.Min(a.z, b.z));
            }

            /// <summary>
            /// 向量叉乘
            /// </summary>
            /// <param name="a"></param>
            /// <param name="b"></param>
            /// <returns></returns>
            public static Vector3 Cross(Vector3 a, Vector3 b)
            {

                if (Equals(Dot(a, b), 1.0)) return new Vector3(0, 0, 0);

                Vector3 res = new Vector3
                {
                    x = a.y * b.z - a.z * b.y,
                    y = a.z * b.x - a.x * b.z,
                    z = a.x * b.y - a.y * b.x
                };
                return res;
            }

            public static float Dot(Vector3 a, Vector3 b)
            {
                return a.x * b.x + a.y * b.y + a.z * b.z;
            }

            public override string ToString()
            {
                return "x : " + x + "  y : " + y + "  z : " + z;
            }
        }

        public class Vector2
        {
            public float x, y;
            public Vector2() { }
            public Vector2(float x,float y)
            {
                this.x = x;
                this.y = y;
            }
        }

        public class Triangle
        {
            // vertex
            public int a;
            public int b;
            public int c;
            // normal
            public int an;
            public int bn;
            public int cn;
            // uv
            public int au;
            public int bu;
            public int cu;

            public bool hasNormal;
            public bool hasUv;
        }

        public class Group
        {
            public string groupName;
            public string mtlName;
            public List<Triangle> triangles;
        }

        public class ColladaMaterial
        {
            public Vector3 diffuse;
            public Vector3 emissive;
            public string diffuseMap;

            public ColladaMaterial()
            {
                diffuse = new Vector3(1, 1, 1);
                emissive = new Vector3(0, 0, 0);
                diffuseMap = "";
            }
        }
    }
}

2、这个脚本定义了将obj转换成ply的函数，调用方式为ExportPlyFromObj.Export(objPath,outputPath)，记得引入命名空间

using System;
using System.Collections.Generic;
using System.IO;
using static ModelProcess.MathUtils;

namespace ModelProcess
{
    class ExportPlyFromObj
    {
        /// <summary>
        /// 将obj转换成ply格式
        /// </summary>
        /// <param name="objPath">obj模型的完整路径</param>
        /// <param name="outputPath">导出的ply的完整路径，带后缀</param>
        public static void Export(string objPath, string outputPath)
        {
            List<Vector3> vertices = new List<Vector3>();
            List<Vector3> normals = new List<Vector3>();
            Dictionary<string, Vector3> mtl = new Dictionary<string, Vector3>();
            string mtlPath = Utils.GetFirstModelPath(Path.GetDirectoryName(objPath), new string[] { ".mtl" });
            if (!string.IsNullOrEmpty(mtlPath))
            {
                FileStream fs = new FileStream(mtlPath, FileMode.Open, FileAccess.Read);
                StreamReader sr = new StreamReader(fs);
                string line = "";
                Vector3 currentColor = new Vector3();
                while (!sr.EndOfStream)
                {
                    line = Utils.GetStrFields(sr.ReadLine()).Trim();
                    if (line.StartsWith("newmtl "))
                    {
                        string name = line.Substring(7);
                        name = Utils.ReplaceAll(name, " ", "_");
                        currentColor = new Vector3(1, 1, 1);
                        if (!mtl.ContainsKey(name))
                        {
                            mtl.Add(name, currentColor);
                        }
                    }
                    else
                    {
                        if (line.StartsWith("Kd "))
                        {
                            string[] strs = line.Split(' ');
                            currentColor.x = float.Parse(strs[1]);
                            currentColor.y = float.Parse(strs[2]);
                            currentColor.z = float.Parse(strs[3]);
                        }
                    }
                }

                sr.Close();
                fs.Close();
            }
            int triangleCount = 0;
            {
                FileStream fs = new FileStream(objPath, FileMode.Open, FileAccess.Read);
                StreamReader sr = new StreamReader(fs);
                string line = "";
                while (!sr.EndOfStream)
                {
                    line = Utils.GetStrFields(sr.ReadLine()).Trim();
                    if (line.StartsWith("v "))
                    {
                        string[] strs = line.Split(' ');
                        if (strs.Length >= 4)
                        {
                            vertices.Add(new Vector3(float.Parse(strs[1]), float.Parse(strs[2]), float.Parse(strs[3])));
                        }
                    }
                    else if (line.StartsWith("vn "))
                    {
                        string[] strs = line.Split(' ');
                        if (strs.Length >= 4)
                        {
                            normals.Add(new Vector3(float.Parse(strs[1]), float.Parse(strs[2]), float.Parse(strs[3])));
                        }
                    }
                    else if (line.StartsWith("f "))
                    {
                        string[] strs = line.Split(' ');
                        triangleCount += strs.Length - 3;
                    }
                }
                sr.Close();
                fs.Close();
            }

            {
                FileStream outFs = new FileStream(outputPath, FileMode.Create, FileAccess.Write);
                StreamWriter sw = new StreamWriter(outFs);
                sw.WriteLine("ply");
                sw.WriteLine("format ascii 1.0");
                sw.WriteLine("element vertex " + triangleCount * 3);
                sw.WriteLine("property float x");
                sw.WriteLine("property float y");
                sw.WriteLine("property float z");
                sw.WriteLine("property float nx");
                sw.WriteLine("property float ny");
                sw.WriteLine("property float nz");
                sw.WriteLine("property uchar red");
                sw.WriteLine("property uchar green");
                sw.WriteLine("property uchar blue");
                sw.WriteLine("element face " + triangleCount);
                sw.WriteLine("property list uchar int vertex_index");
                sw.WriteLine("end_header");
                FileStream fs = new FileStream(objPath, FileMode.Open, FileAccess.Read);
                StreamReader sr = new StreamReader(fs);
                string line = "";
                int avi, ani, bvi, bni, cvi, cni;
                Vector3 a, b, c, n, an, bn, cn;
                Vector3 currenColor = new Vector3(1, 1, 1);
                while (!sr.EndOfStream)
                {
                    line = Utils.GetStrFields(sr.ReadLine()).Trim();
                    if (line.StartsWith("usemtl "))
                    {
                        string name = line.Substring(7);
                        name = Utils.ReplaceAll(name, " ", "_");
                        if (mtl.TryGetValue(name, out Vector3 v))
                        {
                            currenColor = v;
                        }
                    }
                    if (line.StartsWith("f "))
                    {
                        string[] strs = line.Split(' ');
                        string[] first = strs[1].Split('/');
                        avi = int.Parse(first[0]);
                        if (avi < 0) avi += vertices.Count;
                        else avi -= 1;
                        ani = 0;
                        if (first.Length >= 3 && !string.IsNullOrEmpty(first[2]))
                        {
                            ani = int.Parse(first[2]);
                        }
                        for (int k = 2; k < strs.Length - 1; k++)
                        {
                            string[] second = strs[k].Split('/');
                            string[] third = strs[k + 1].Split('/');
                            bvi = int.Parse(second[0]);
                            if (bvi < 0) bvi += vertices.Count;
                            else bvi -= 1;
                            cvi = int.Parse(third[0]);
                            if (cvi < 0) cvi += vertices.Count;
                            else cvi -= 1;

                            a = vertices[avi];
                            b = vertices[bvi];
                            c = vertices[cvi];

                            if (ani != 0)
                            {
                                if (ani < 0) ani += normals.Count;
                                else ani -= 1;
                                bni = int.Parse(second[2]);
                                if (bni < 0) bni += normals.Count;
                                else bni -= 1;
                                cni = int.Parse(third[2]);
                                if (cni < 0) cni += normals.Count;
                                else cni -= 1;
                                an = normals[ani];
                                bn = normals[bni];
                                cn = normals[cni];
                            }
                            else
                            {
                                Vector3 ab = b - a;
                                Vector3 ac = c - a;
                                n = Vector3.Cross(ab, ac).Normalize();
                                an = n;
                                bn = n;
                                cn = n;
                            }
                            sw.WriteLine(a.x + " " + a.y + " " + a.z + " " + an.x + " " + an.y + " " + an.z + " " + (uint)Math.Floor(currenColor.x * 255) + " " + (uint)Math.Floor(currenColor.y * 255) + " " + (uint)Math.Floor(currenColor.z * 255));
                            sw.WriteLine(b.x + " " + b.y + " " + b.z + " " + bn.x + " " + bn.y + " " + bn.z + " " + (uint)Math.Floor(currenColor.x * 255) + " " + (uint)Math.Floor(currenColor.y * 255) + " " + (uint)Math.Floor(currenColor.z * 255));
                            sw.WriteLine(c.x + " " + c.y + " " + c.z + " " + cn.x + " " + cn.y + " " + cn.z + " " + (uint)Math.Floor(currenColor.x * 255) + " " + (uint)Math.Floor(currenColor.y * 255) + " " + (uint)Math.Floor(currenColor.z * 255));
                        }
                    }
                }
                sr.Close();
                fs.Close();

                for (int i = 0; i < triangleCount; i++)
                {
                    sw.WriteLine("3 " + (i * 3) + " " + (i * 3 + 1) + " " + (i * 3 + 2));
                }
                sw.Close();
                outFs.Close();
            }

            vertices.Clear();
            normals.Clear();
            mtl.Clear();
        }
    }
}
~在水一方
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
模型格式转换工具(osgb-obj-ive)
12-24
模型格式转换工具(osgb-obj-ive) 可在osgb、ogb、obj、ive间转换，亲测可用。
C#导入Obj模型文件并显示
07-07
使用C#WinForm加载OBJ的三维模型文件并显示出来,支持鼠标拾取模型,支持三维场景漫游，支持自动计算帧率，。
obj模型转换成gltf和b3dm文件
03-25
java实现obj模型转换成支持cesium支持的gltf文件和b3dm文件，生成tileset.json，和为b3dm模型添加属性信息。https://pan.baidu.com/s/10S5VKVehrI6Ozc-8yINvwA 提取码：fdwk
obj模型转换成gltf和b3dm文件 new
03-25
java实现obj模型转换成支持cesium支持的gltf文件和b3dm文件，生成tileset.json，和为b3dm模型添加属性信息。https://pan.baidu.com/s/1aC_jhAI4i769F8FhZiLadg 提取码：5d5l
BIM三维模型ifc转obj格式的工具
04-13
可将BIM的通用交换格式ifc转换成obj格式，转换成一个完整的obj。obj以后就可以转成各种想要的三维模型的格式了，非常好用的一个转换工具，需要的不要错过 操作方式 ifcConvert.exe bgl.ifc //bgl.ifc 放在exe的相同目录，否则不生效
ply.zip_obj文件转ply_ply文件_ply文件读取_site:www.pudn.com_读取ply文件
07-15
基于vc++的ply文件的读取和写入，实用于ASCII和binary两种
OBJ/PLY格式在线转换
wangming100110的博客
08-11 286
3D模型在线转换（https://3dconvert.nsdt.cloud/）是一个可以进行3D模型格式转换的在线工具，支持多种3D模型格式进行在线预览和互相转换。
OBJ格式转成PCD或者PLY格式（带纹理信息）
qq_29572513的博客
08-12 5867
文章目录利用PCL库函数解析OBJ利用meshlab转化自己解析OBJOBJ格式解析转换代码编译环境可视化效果 利用PCL库函数解析OBJ 利用pcl库函数解析obj的方法有bug，解析过来的时候纹理坐标确实，也就是缺少RGB信息。 这是PCL库的bug，见参考1 参考2 因此，只好自己读懂obj的格式后，自己写一下解析函数。 利用meshlab转化 转化后也缺失了RGB信息 自己解析OBJ OB...
生成ply文件
weixin_42181600的博客
04-04 299
【代码】生成ply文件。
CAD三维模型（OBJ）转换成PCL的点云格式（PCD,PLY）
changhong1996的博客
04-16 4704
我收集到2种转换方式 1、用PCL库中自带的exe文件直接转化 参考：https://blog.csdn.net/qq_31128845/article/details/83047415 先按照参考博客生成OBJ文件，以管理员方式启动命令行控制台 输入：cd C:\Program Files\PCL 1.8.1\bin pcl_mesh_sampling_release.exe gear.obj ...
Meshlab---3d数据文件转换器(支持很多种格式)
05-19
支持格式比较多(ply stl u3d ...)，特别是支持ply，找了很久才找到支持转换ply的
C# DLL类库的创建和使用
Q_Q1111的专栏
09-28 362
动态链接库 (DLL) 在运行时链接到程序。为说明如何生成和使用 DLL，请看以下方案： MathLibrary.DLL：为库文件，其中包含运行时要调用的方法。此例中，DLL 包含两个方法：Add 和 Multiply。 Add.cs：为源文件，其中包含 Add(long i, long j) 方法。该方法返回参数之和。包含 Add 方法的 AddClass 类是命名空间 Util
C#下将点云数据保存为PLY格式
最新发布
easyboot的专栏
12-26 622
目前没有找到C#下将点云数据保存为PLY格式的库，查看了一下PLY格式，所以自己写了个方法实现点云数据保存PLY格式。
混合编程之一：c#调用c++pcl库，生成c++动态链接库文件
qq_57377241的博客
03-02 2733
一：创建PCL动态链接库项目 二、将预编译头（.h）文件删除，新建头文件PNative.h文件，并配置好PCL库环境 在头文件（PNative.h）中输入如下代码： #pragma once #include <iostream> #include <string> #include <sstream> #include <stdio.h> //extern "C" _declspec(dllexport) int Sum(int a, int
三维数据学习笔记：ply数据内容介绍
目前涉及领域：目标检测，语义分割以及数字图像处理
05-06 2508
三维数据的形式多种多样，截止到现在我已经看到了ply格式数据、obj格式数据、pcd格式数据、osgb格式数据、b3dm格式数据等等。相比于二维图像，三维数据的形式更多且复杂。因此，我打算整理出常用的三维数据存储格式总结文章。本篇以ply格式数据作为开篇。
C# 读取pcd、ply点云文件数据
海盗Isaac
08-18 1571
C#读取点云数据 ply pcd格式
PCL文件格式转换OBJ转PLY
com1098247427的博客
11-11 1276
OBJ转PLY
pcl：三维模型obj格式转成pcl常用点云处理格式.pcd+matlab:.ply<->.pcd+其他.stl,.obj,.ply等三维格式互相转化方法
热门推荐
starDu
12-29 1万+
代码： #include #include #include #include #include #include //loadPolygonFileOBJ所属头文件； using namespace pcl; int main() { pcl::PolygonMesh mesh; pcl::io::loadPolygonFileOBJ("d:\head1.ob
sarscape 将dem文件转化成stl_从STL文件生成有限元FEA网格
weixin_39651325的博客
11-22 452
随着计算机图形、硬件、以及3D打印技术的发展，基于面片网格的图形渲染及其格式变得越来越普及。有限元分析（FEA）中，工程师们也常常拿到基于面片网格的几何文件（如STL文件等），并进行后续的分析工作。由于面片网格和有限元实体网格有着根本性的区别，面片网格是无法直接用于有限元计算的，需要将面片网格转换为有限元分析可用的实体网格。本文就STL面片网格和有限元网格的特点做一个概述，同时实例演示如何将STL...
将ply格式转换成dae格式
07-25
要将PLY格式转换为DAE格式，你可以使用Bear File Converter网站进行转换。在该网站的Input Formats中选择PLY格式，然后在Output Formats中选择DAE格式。然后，将你的PLY文件上传到网站上，并点击下载按钮，即可将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值