From c69aee05aaccebe6a8ceb155f26d65fa6e7fdca2 Mon Sep 17 00:00:00 2001
From: Changsheng <zcstkhk@163.com>
Date: Mon, 11 Oct 2021 21:47:11 +0800
Subject: [PATCH] finish face to brep translate

---
 README.md                                     |   6 +-
 RhinoInside.NX Starter/MainWindow.xaml        |   2 +-
 RhinoInside.NX Starter/MainWindow.xaml.cs     |  34 +-
 RhinoInside.NX.Core/NX/GH_Object.cs           |  82 +++
 .../RhinoInside.NX.Core.csproj                |   1 +
 .../RhinoInside.NX.GH.Loader.cs               |   2 +-
 .../DisplayableObject/Param_NXBody.cs         |  30 +-
 RhinoInside.NX.GH/RhinoInside.NX.GH.csproj    |   3 +
 .../TestComponents/TestComponent.cs           |  22 +
 RhinoInside.NX.GH/TestComponents/UDOTest.cs   |  44 ++
 RhinoInside.NX.GH/Types/BaseCurve/NX_Edge.cs  |   8 +-
 RhinoInside.NX.GH/Types/NX_Body.cs            |  16 +
 RhinoInside.NX.GH/Types/NX_Face.cs            |   5 +
 .../Utilities/CSharpScriptComponent.cs        |   2 +
 .../Utilities/GetBrepLogComponent.cs          |  49 ++
 .../Geometry/{ => Decoder}/CurveDecoder.cs    |  64 ++-
 .../Geometry/Decoder/CurveRawDecoder.cs       | 210 ++++++++
 .../Geometry/Decoder/PointDecoder.cs          |  47 ++
 .../PointRawDecoder.cs}                       |  39 +-
 .../Geometry/Decoder/SurfaceDcoder.cs         |  40 ++
 .../Geometry/Decoder/SurfaceRawDecoder.cs     | 509 ++++++++++++++++++
 .../Geometry/GeometryDecoder.cs               | 205 +------
 .../Geometry/PointEncoder.cs                  |   8 -
 .../Geometry/Raw/Decoder/BrepRawDecoder.cs    | 419 --------------
 .../Geometry/Raw/Decoder/CurveRawDecoder.cs   | 104 ----
 .../Geometry/Raw/Decoder/SurfaceRawDecoder.cs | 221 --------
 .../Geometry/UnitConverter.cs                 |   2 -
 .../RhinoInside.NX.Translator.csproj          |  11 +-
 28 files changed, 1153 insertions(+), 1032 deletions(-)
 create mode 100644 RhinoInside.NX.Core/NX/GH_Object.cs
 create mode 100644 RhinoInside.NX.GH/TestComponents/TestComponent.cs
 create mode 100644 RhinoInside.NX.GH/TestComponents/UDOTest.cs
 create mode 100644 RhinoInside.NX.GH/Utilities/GetBrepLogComponent.cs
 rename RhinoInside.NX.Translator/Geometry/{ => Decoder}/CurveDecoder.cs (55%)
 create mode 100644 RhinoInside.NX.Translator/Geometry/Decoder/CurveRawDecoder.cs
 create mode 100644 RhinoInside.NX.Translator/Geometry/Decoder/PointDecoder.cs
 rename RhinoInside.NX.Translator/Geometry/{Raw/Decoder/StructuresRawDecoder.cs => Decoder/PointRawDecoder.cs} (52%)
 create mode 100644 RhinoInside.NX.Translator/Geometry/Decoder/SurfaceDcoder.cs
 create mode 100644 RhinoInside.NX.Translator/Geometry/Decoder/SurfaceRawDecoder.cs
 delete mode 100644 RhinoInside.NX.Translator/Geometry/Raw/Decoder/BrepRawDecoder.cs
 delete mode 100644 RhinoInside.NX.Translator/Geometry/Raw/Decoder/CurveRawDecoder.cs
 delete mode 100644 RhinoInside.NX.Translator/Geometry/Raw/Decoder/SurfaceRawDecoder.cs

diff --git a/README.md b/README.md
index cee8470..cad365f 100644
--- a/README.md
+++ b/README.md
@@ -26,4 +26,8 @@ The program offered is signed with NX 1872, that means if you use 1847 or other
 # 编译方法
 >1. 安装 NX 时将安装目录设置为如下形式，XXX\Siemens\NXVER，其中 XXX 为任意文件夹，注意最好不要有空格，否则可能会引发其它问题，NXVER 为 NX 的版本号，比如 NX1872、NX1953，注意 NX 和 版本号之间不要有空格。
 >2. 创建环境变量 SPLM_ROOT_DIR，指向第一步安装路径中的 XXX\Siemens。
->3. 创建环境变量 RHINO_ROOT_DIR，指向 RHINO 的安装目录，比如 C:\Programs\Rhino\7。
\ No newline at end of file
+>3. 创建环境变量 RHINO_ROOT_DIR，指向 RHINO 的安装目录，比如 C:\Programs\Rhino\7。
+
+#已知问题
+>1. 不能修改 Grasshopper 中组件的描述（名称），否则会卡死，原因暂时未知。
+>2. 无法正确创建被平面修剪后断面为椭圆的圆锥/圆锥面，提示 ON_Brep.m_T[1] 2d curve is not inside surface domain。
\ No newline at end of file
diff --git a/RhinoInside.NX Starter/MainWindow.xaml b/RhinoInside.NX Starter/MainWindow.xaml
index 5c26672..7f8d015 100644
--- a/RhinoInside.NX Starter/MainWindow.xaml	
+++ b/RhinoInside.NX Starter/MainWindow.xaml	
@@ -5,7 +5,7 @@
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
         xmlns:local="clr-namespace:RhinoInside_Starter"
         mc:Ignorable="d"
-        Title="RhinoInside 鍚姩鍣�" Height="400" Width="750" WindowStyle="ToolWindow" ResizeMode="NoResize">
+        Title="RhinoInside 鍚姩鍣�" Height="400" Width="750" ResizeMode="NoResize">
     <Window.Resources>
         <Style TargetType="Button">
             <Setter Property="Margin" Value="2" />
diff --git a/RhinoInside.NX Starter/MainWindow.xaml.cs b/RhinoInside.NX Starter/MainWindow.xaml.cs
index b4fe30f..ed190df 100644
--- a/RhinoInside.NX Starter/MainWindow.xaml.cs	
+++ b/RhinoInside.NX Starter/MainWindow.xaml.cs	
@@ -42,10 +42,10 @@ public MainWindow()
             {
                 string[] configContent = System.IO.File.ReadAllLines(configPath);
 
-                comboBoxSelectLanguage.SelectedIndex = Convert.ToInt32(configContent[0]);
-                NxInstallPath.SelectedPath = configContent[1];
-                RhinoInsidePath.SelectedPath = configContent[2];
-                RhinoPath.SelectedPath = configContent[3];
+                comboBoxSelectLanguage.SelectedIndex = Convert.ToInt32(configContent[0].Substring(2));
+                NxInstallPath.SelectedPath = configContent[1].Substring(2);
+                RhinoInsidePath.SelectedPath = configContent[2].Substring(2);
+                RhinoPath.SelectedPath = configContent[3].Substring(2);
             }
             else
             {
@@ -105,10 +105,10 @@ private void buttonStart_Click(object sender, RoutedEventArgs e)
 
             using (var stream = System.IO.File.CreateText(configFilePath))
             {
-                stream.WriteLine(comboBoxSelectLanguage.SelectedIndex.ToString());
-                stream.WriteLine(textBoxNxInstallPath.Text);
-                stream.WriteLine(textBoxRhinoInsidePath.Text);
-                stream.WriteLine(textBoxRhinoPath.Text);
+                stream.WriteLine("# " + comboBoxSelectLanguage.SelectedIndex.ToString());
+                stream.WriteLine("# " + textBoxNxInstallPath.Text);
+                stream.WriteLine("# " + textBoxRhinoInsidePath.Text);
+                stream.WriteLine("# " + textBoxRhinoPath.Text);
             }
 
             Process nxProcess = new Process();
@@ -118,9 +118,23 @@ private void buttonStart_Click(object sender, RoutedEventArgs e)
             else
                 Environment.SetEnvironmentVariable("UGII_LANG", "english");
 
-            Environment.SetEnvironmentVariable("UGII_CUSTOM_DIRECTORY_FILE", "");
+            if (System.IO.Directory.Exists(@"E:\Documents\Programming\Repos\NXOpen Debug Utilities\00~Program"))
+            {
+                using (var writer = System.IO.File.AppendText(configFilePath))
+                {
+                    writer.WriteLine(System.IO.Path.Combine( @"E:\Documents\Programming\Repos\NXOpen Debug Utilities\00~Program", textBoxNxInstallPath.Text.Split('\\').Last()));
+
+                    writer.WriteLine(textBoxRhinoInsidePath.Text);
+                }
+                
+                Environment.SetEnvironmentVariable("UGII_CUSTOM_DIRECTORY_FILE", configFilePath);
+            }
+            else
+            {
+                Environment.SetEnvironmentVariable("UGII_CUSTOM_DIRECTORY_FILE", "");
 
-            Environment.SetEnvironmentVariable("UGII_USER_DIR", textBoxRhinoInsidePath.Text);
+                Environment.SetEnvironmentVariable("UGII_USER_DIR", textBoxRhinoInsidePath.Text);
+            }
 
             Environment.SetEnvironmentVariable("UGII_RhinoInside_Dir", textBoxRhinoInsidePath.Text);
 
diff --git a/RhinoInside.NX.Core/NX/GH_Object.cs b/RhinoInside.NX.Core/NX/GH_Object.cs
new file mode 100644
index 0000000..56edfbe
--- /dev/null
+++ b/RhinoInside.NX.Core/NX/GH_Object.cs
@@ -0,0 +1,82 @@
+锘縰sing System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using NXOpen.UserDefinedObjects;
+using static NXOpen.Extensions.Globals;
+using NXOpen.Extensions;
+using NXOpen;
+
+namespace RhinoInside.NX.Core
+{
+    public class GH_UserDefinedObject
+    {
+        static UserDefinedClass GHFeatureClass;
+
+        static GH_UserDefinedObject()
+        {
+            try
+            {
+                Console.WriteLine("娉ㄥ唽");
+
+                // Define your custom UDO class 
+                GHFeatureClass = TheSession.UserDefinedClassManager.CreateUserDefinedObjectClass
+                              ("GHFeature", "Object Created From Grasshopper");
+                // Setup properties on the custom UDO class 
+                GHFeatureClass.AllowQueryClassFromName = UserDefinedClass.AllowQueryClass.On;
+                // Register callbacks for the UDO class 
+                //            GHFeature.AddDisplayHandler(new UserDefinedClass.DisplayCallback(Program.myDisplayCB));
+                //            GHFeature.AddAttentionPointHandler(new UserDefinedClass.DisplayCallback(Program.myDisplayCB));
+                //            GHFeature.AddFitHandler(new UserDefinedClass.DisplayCallback
+                //(Program.myDisplayCB));
+                //            GHFeature.AddSelectionHandler(new
+                //UserDefinedClass.DisplayCallback(Program.myDisplayCB));
+                //            GHFeature.AddEditHandler(new UserDefinedClass.GenericCallback(Program.myEditCB));
+                //            GHFeature.AddInformationHandler(new
+                //UserDefinedClass.GenericCallback(Program.myInfoCB));
+                // Add this class to the list of object types available for selection in NX. 
+                // If you skip this step you won't be able to select UDO's of this class, 
+                // even though you registered a selection callback. 
+                TheUI.SelectionManager.SetSelectionStatusOfUserDefinedClass(GHFeatureClass, true);
+            }
+            catch (NXOpen.NXException ex)
+            {
+                // ---- Enter your exception handling code here ----- 
+                TheUI.NXMessageBox.Show("Caught exception", NXMessageBox.DialogType.Error, ex.Message);
+                throw ex;
+            }
+        }
+
+        public static UserDefinedObject CreateGHFeatureObject()
+        {
+            var ghFeatureObj = WorkPart.UserDefinedObjectManager.CreateUserDefinedObject(GHFeatureClass);
+
+            ghFeatureObj.Color = 36;
+
+            View myView = null;
+            Point3d myCursor;
+            myCursor.X = 0;
+            myCursor.Y = 0;
+            myCursor.Z = 0;
+            // ask the user to select an origin for this UDO 
+            Selection.DialogResponse myResponse =
+    TheUI.SelectionManager.SelectScreenPosition("Select Origin of C# UDO", out myView, out myCursor);
+
+            double[] myUDOdoubles = new double[3];
+            myUDOdoubles[0] = myCursor.X;
+            myUDOdoubles[1] = myCursor.Y;
+            myUDOdoubles[2] = myCursor.Z;
+            ghFeatureObj.SetDoubles(myUDOdoubles);
+
+            TheUfSession.Disp.AddItemToDisplay(ghFeatureObj.Tag);
+
+            NXOpen.Features.UserDefinedObjectFeatureBuilder fb = WorkPart.Features.CreateUserDefinedObjectFeatureBuilder(null);
+            fb.UserDefinedObject = ghFeatureObj;
+            fb.Commit();
+            fb.Destroy();
+
+            return ghFeatureObj;
+        }
+    }
+}
diff --git a/RhinoInside.NX.Core/RhinoInside.NX.Core.csproj b/RhinoInside.NX.Core/RhinoInside.NX.Core.csproj
index 4a2dbc6..b58db74 100644
--- a/RhinoInside.NX.Core/RhinoInside.NX.Core.csproj
+++ b/RhinoInside.NX.Core/RhinoInside.NX.Core.csproj
@@ -81,6 +81,7 @@
     <Compile Include="GH\GrasshopperCommands.cs" />
     <Compile Include="GH\GrasshopperPlayerCommand.cs" />
     <Compile Include="ImageBuilder.cs" />
+    <Compile Include="NX\GH_Object.cs" />
     <Compile Include="ObjectTypes.cs" />
     <Compile Include="Rhino\Import.cs" />
     <Compile Include="Rhino\RhinoCommands.cs" />
diff --git a/RhinoInside.NX.GH.Loader/RhinoInside.NX.GH.Loader.cs b/RhinoInside.NX.GH.Loader/RhinoInside.NX.GH.Loader.cs
index a7a8bed..4028ae3 100644
--- a/RhinoInside.NX.GH.Loader/RhinoInside.NX.GH.Loader.cs
+++ b/RhinoInside.NX.GH.Loader/RhinoInside.NX.GH.Loader.cs
@@ -47,7 +47,7 @@ internal static Assembly AssemblyResolveHandler(object sender, ResolveEventArgs
             {
                 return Assembly.LoadFrom(Path.Combine(NXBinPath, assemblyName + ".dll"));
             }
-            else if (assemblyName == "NXOpen.Extensions" || assemblyName == "RhinoInside.NX.Core")
+            else if (assemblyName == "NXOpen.Extensions" || assemblyName == "RhinoInside.NX.Core" || assemblyName == "RhinoInside.NX.Translator")
             {
                 return Assembly.LoadFrom(Path.Combine(RhinoInsideDirectory, "Startup", assemblyName + ".dll"));
             }
diff --git a/RhinoInside.NX.GH/Parameters/DisplayableObject/Param_NXBody.cs b/RhinoInside.NX.GH/Parameters/DisplayableObject/Param_NXBody.cs
index cdb5a3e..3f7fcf2 100644
--- a/RhinoInside.NX.GH/Parameters/DisplayableObject/Param_NXBody.cs
+++ b/RhinoInside.NX.GH/Parameters/DisplayableObject/Param_NXBody.cs
@@ -1,5 +1,6 @@
 锘縰sing Grasshopper.Kernel;
 using Grasshopper.Kernel.Parameters;
+using NXOpen.Extensions;
 using RhinoInside.NX.GH.Properties;
 using RhinoInside.NX.GH.Types;
 using System;
@@ -24,12 +25,37 @@ public Param_NXBody() : base(Languages.GetString("NXBodyParamName"), Languages.G
 
         protected override GH_GetterResult Prompt_Plural(ref List<NX_Body> values)
         {
-            throw new NotImplementedException();
+            SelectionPreparation();
+
+            var selectedObjects = Select_Plural(MaskTripleEx.Body);
+            if (selectedObjects != null)
+            {
+                values = new List<NX_Body>();
+                for (int i = 0; i < selectedObjects.Length; i++)
+                {
+                    values.Add(new NX_Body(selectedObjects[i].Tag, Attributes.Selected));
+                }
+
+                return GH_GetterResult.success;
+            }
+
+            return GH_GetterResult.cancel;
         }
 
         protected override GH_GetterResult Prompt_Singular(ref NX_Body value)
         {
-            throw new NotImplementedException();
+            SelectionPreparation();
+
+            var selectedObject = Select_Singular(MaskTripleEx.Body);
+
+            if (selectedObject != null)
+            {
+                value = new NX_Body(selectedObject.Tag, Attributes.Selected);
+
+                return GH_GetterResult.success;
+            }
+
+            return GH_GetterResult.cancel;
         }
     }
 }
diff --git a/RhinoInside.NX.GH/RhinoInside.NX.GH.csproj b/RhinoInside.NX.GH/RhinoInside.NX.GH.csproj
index 46238ff..defd725 100644
--- a/RhinoInside.NX.GH/RhinoInside.NX.GH.csproj
+++ b/RhinoInside.NX.GH/RhinoInside.NX.GH.csproj
@@ -83,6 +83,8 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="TestComponents\UDOTest.cs" />
+    <Compile Include="TestComponents\TestComponent.cs" />
     <Compile Include="Utilities\CSharpScriptComponent.cs" />
     <Compile Include="Parameters\DisplayableObject\Param_NXCurve.cs" />
     <Compile Include="Parameters\DisplayableObject\Param_NXDisplayableObject.cs" />
@@ -105,6 +107,7 @@
     <Compile Include="Types\NX_Plane.cs" />
     <Compile Include="Types\NX_Point.cs" />
     <Compile Include="Types\NX_SmartObject.cs" />
+    <Compile Include="Utilities\GetBrepLogComponent.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\RhinoInside.NX.Core\RhinoInside.NX.Core.csproj">
diff --git a/RhinoInside.NX.GH/TestComponents/TestComponent.cs b/RhinoInside.NX.GH/TestComponents/TestComponent.cs
new file mode 100644
index 0000000..1d3fd4d
--- /dev/null
+++ b/RhinoInside.NX.GH/TestComponents/TestComponent.cs
@@ -0,0 +1,22 @@
+锘縰sing Grasshopper.Kernel;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace RhinoInside.NX.GH.TestComponents
+{
+    public abstract class TestComponent : GH_Component
+    {
+        public override Guid ComponentGuid
+        {
+            get { return Guid.NewGuid(); }
+        }
+
+        public TestComponent(string name) : base(name, name, name, "NX", "Test")
+        {
+
+        }
+    }
+}
diff --git a/RhinoInside.NX.GH/TestComponents/UDOTest.cs b/RhinoInside.NX.GH/TestComponents/UDOTest.cs
new file mode 100644
index 0000000..dabc037
--- /dev/null
+++ b/RhinoInside.NX.GH/TestComponents/UDOTest.cs
@@ -0,0 +1,44 @@
+锘縰sing Grasshopper.Kernel;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using RhinoInside.NX.Core;
+
+namespace RhinoInside.NX.GH.TestComponents
+{
+    public class UDOTest : TestComponent
+    {
+        public UDOTest() : base("UDO Test")
+        {
+
+        }
+
+        /// <summary>
+        /// Registers all the input parameters for this component.
+        /// </summary>
+        protected override void RegisterInputParams(GH_Component.GH_InputParamManager pManager)
+        {
+            pManager.AddGenericParameter("Geometry", "G", "Geometry that want to Created In NX", GH_ParamAccess.item);
+        }
+
+        /// <summary>
+        /// Registers all the output parameters for this component.
+        /// </summary>
+        protected override void RegisterOutputParams(GH_Component.GH_OutputParamManager pManager)
+        {
+            pManager.AddGenericParameter("NX Geonetry", "G", "Geometry Created In NX", GH_ParamAccess.item);
+        }
+
+        /// <summary>
+        /// This is the method that actually does the work.
+        /// </summary>
+        /// <param name="DA">The DA object can be used to retrieve data from input parameters and 
+        /// to store data in output parameters.</param>
+        protected override void SolveInstance(IGH_DataAccess DA)
+        {
+            GH_UserDefinedObject.CreateGHFeatureObject();
+        }
+    }
+}
diff --git a/RhinoInside.NX.GH/Types/BaseCurve/NX_Edge.cs b/RhinoInside.NX.GH/Types/BaseCurve/NX_Edge.cs
index 18285c0..e05c74b 100644
--- a/RhinoInside.NX.GH/Types/BaseCurve/NX_Edge.cs
+++ b/RhinoInside.NX.GH/Types/BaseCurve/NX_Edge.cs
@@ -40,12 +40,12 @@ public override bool CastTo<Q>(ref Q target)
         {
             if (typeof(Q) == typeof(GH_Curve))
             {
-                Globals.TheUfSession.Modl.CreateCurveFromEdge(Tag, out var curveTag);
+                var edge = Tag.GetTaggedObject() as NXOpen.Edge;
 
-                target = (Q)(object)new GH_Curve((curveTag.GetTaggedObject() as NXOpen.Curve).ToRhino());
+                var rhinoCurve = edge.ToRhinoCurve();
+
+                target = (Q)(object)new GH_Curve(rhinoCurve);
 
-                Globals.TheUfSession.Obj.DeleteObject(curveTag);
-                
                 return true;
             }
             else
diff --git a/RhinoInside.NX.GH/Types/NX_Body.cs b/RhinoInside.NX.GH/Types/NX_Body.cs
index 4468001..0ece0e9 100644
--- a/RhinoInside.NX.GH/Types/NX_Body.cs
+++ b/RhinoInside.NX.GH/Types/NX_Body.cs
@@ -1,4 +1,6 @@
 锘縰sing Grasshopper.Kernel.Parameters;
+using Grasshopper.Kernel.Types;
+using RhinoInside.NX.Translator.Geometry;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -32,6 +34,20 @@ public NX_Body(NXOpen.Tag tag, bool highlight) : base(tag, highlight)
 
         }
 
+        public override bool CastTo<Q>(ref Q target)
+        {
+            if (typeof(Q) == typeof(GH_Brep))
+            {
+                target = (Q)(object)new GH_Brep(Value.ToBrep());
+                return true;
+            }
+            else
+            {
+                Console.WriteLine(typeof(Q));
+                return base.CastTo(ref target);
+            }
+        }
+
         public override string ToString()
         {
             if (Value != null)
diff --git a/RhinoInside.NX.GH/Types/NX_Face.cs b/RhinoInside.NX.GH/Types/NX_Face.cs
index 3fb86d1..89223be 100644
--- a/RhinoInside.NX.GH/Types/NX_Face.cs
+++ b/RhinoInside.NX.GH/Types/NX_Face.cs
@@ -42,6 +42,11 @@ public override bool CastTo<Q>(ref Q target)
                 target = (Q)(object)new GH_Brep(Value.ToBrep());
                 return true;
             }
+            else if (typeof(Q) == typeof(GH_Surface))
+            {
+                target = (Q)(object)new GH_Surface(Value.ToRhinoSurface());
+                return true;
+            }
             else
             {
                 Console.WriteLine(typeof(Q));
diff --git a/RhinoInside.NX.GH/Utilities/CSharpScriptComponent.cs b/RhinoInside.NX.GH/Utilities/CSharpScriptComponent.cs
index 122c305..60fd585 100644
--- a/RhinoInside.NX.GH/Utilities/CSharpScriptComponent.cs
+++ b/RhinoInside.NX.GH/Utilities/CSharpScriptComponent.cs
@@ -63,6 +63,8 @@ protected override string CreateSourceForEdit(ScriptSource script)
             //originalSource = originalSource.Insert(0, "using RhinoInside.NX.GH.Types;\r\n");
 
             originalSource = originalSource.Insert(0, "using NXOpen;\r\n");
+            //originalSource = originalSource.Insert(0, "using RhinoInside.NX.Translator.Geometry;\r\n");
+            //originalSource = originalSource.Insert(0, "using NXOpen.Extensions;\r\n");
 
             return originalSource;
         }
diff --git a/RhinoInside.NX.GH/Utilities/GetBrepLogComponent.cs b/RhinoInside.NX.GH/Utilities/GetBrepLogComponent.cs
new file mode 100644
index 0000000..59277bf
--- /dev/null
+++ b/RhinoInside.NX.GH/Utilities/GetBrepLogComponent.cs
@@ -0,0 +1,49 @@
+锘縰sing Grasshopper.Kernel;
+using Grasshopper.Kernel.Types;
+using Rhino.Geometry;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace RhinoInside.NX.GH
+{
+    public class GetBrepLogComponent : GH_Component
+    {
+        public override Guid ComponentGuid
+        {
+            get => Guid.NewGuid();
+        }
+
+        public GetBrepLogComponent() : base("Brep Log", "Log", "Get Brep Log", "NX", "Utilities")
+        {
+        }
+
+        protected override void RegisterInputParams(GH_Component.GH_InputParamManager pManager)
+        {
+            pManager.AddBrepParameter("Brep", "B", "Brep to Ask Log", GH_ParamAccess.item);
+        }
+
+        protected override void RegisterOutputParams(GH_Component.GH_OutputParamManager pManager)
+        {
+            pManager.AddTextParameter("Log", "L", "Log of Brep", GH_ParamAccess.item);
+        }
+
+        protected override void SolveInstance(IGH_DataAccess DA)
+        {
+            object obj = null;
+            if (!DA.GetData(0, ref obj))
+                return;
+
+            if (obj is GH_Brep brep)
+            {
+                brep.Value.IsValidWithLog(out string brepLog);
+
+                DA.SetData(0, brepLog);
+            }
+            else
+                return;
+        }
+    }
+}
diff --git a/RhinoInside.NX.Translator/Geometry/CurveDecoder.cs b/RhinoInside.NX.Translator/Geometry/Decoder/CurveDecoder.cs
similarity index 55%
rename from RhinoInside.NX.Translator/Geometry/CurveDecoder.cs
rename to RhinoInside.NX.Translator/Geometry/Decoder/CurveDecoder.cs
index d94b963..20e7897 100644
--- a/RhinoInside.NX.Translator/Geometry/CurveDecoder.cs
+++ b/RhinoInside.NX.Translator/Geometry/Decoder/CurveDecoder.cs
@@ -5,71 +5,79 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using static NXOpen.Extensions.Globals;
+using NXOpen.Extensions;
 
 namespace RhinoInside.NX.Translator.Geometry
 {
+    using Raw;
+
     /// <summary>
     /// 灏� NX 瀵硅薄杞崲涓� Rhino 瀵硅薄
     /// </summary>
-    public static class CurveDecoder
+    public static partial class Decoder
     {
         public static Point ToRhino(this NXOpen.Point point)
         {
-            var rhino = RawDecoder.ToRhino(point); 
-            UnitConverter.Scale(rhino, UnitConverter.NXToRhinoUnitsRatio); 
-            return rhino; 
+            var rhino = RawDecoder.ToRhino(point);
+            UnitConverter.Scale(rhino, UnitConverter.NXToRhinoUnitsRatio);
+            return rhino;
         }
 
         public static Curve ToRhinoCurve(this NXOpen.Arc value)
-        { 
-            var rhino = RawDecoder.ToRhinoArcCurve(value);
+        {
+            var rhino = RawDecoder.ToRhinoCurve(value);
             UnitConverter.Scale(rhino, UnitConverter.NXToRhinoUnitsRatio);
             return rhino;
         }
 
         public static Curve ToRhinoCurve(this NXOpen.Ellipse value)
-        { 
-            var rhino = RawDecoder.ToRhinoNurbsCurve(value);
+        {
+            var rhino = RawDecoder.ToRhinoCurve(value);
             UnitConverter.Scale(rhino, UnitConverter.NXToRhinoUnitsRatio);
             return rhino;
         }
 
         public static Curve ToRhinoCurve(this NXOpen.Spline value)
         {
-            var rhino = RawDecoder.ToRhinoNurbsCurve(value);
+            var rhino = RawDecoder.ToRhinoCurve(value);
             UnitConverter.Scale(rhino, UnitConverter.NXToRhinoUnitsRatio); return rhino;
         }
 
-        public static Curve ToRhino(this NXOpen.Curve value)
+        public static Curve ToRhinoCurve(this NXOpen.IBaseCurve value)
         {
-            Curve rhino;
-
+            Curve rhino = null;
             switch (value)
             {
-                case null: return null;
-                case NXOpen.Line line:
-                    rhino = RawDecoder.ToRhinoLineCurve(line);
-                    break;
-                case NXOpen.Arc arc:
-                    rhino = RawDecoder.ToRhinoArcCurve(arc);
-                    break;
-                case NXOpen.Ellipse ellipse:
-                    rhino = RawDecoder.ToRhinoNurbsCurve(ellipse);
+                case NXOpen.Edge edge:
+                    rhino = RawDecoder.ToRhinoCurve(edge);
                     break;
-                case NXOpen.Spline nurb:
-                    rhino = RawDecoder.ToRhinoNurbsCurve(nurb);
+                case NXOpen.Curve c:
+                    rhino = RawDecoder.ToRhinoCurve(c);
                     break;
-                default: throw new NotImplementedException();
+                default:
+                    throw new NotImplementedException("鏈疄鐜扮殑鏇茬嚎杞崲绫诲瀷锛�" + value.GetType().FullName);
             }
 
-            UnitConverter.Scale(rhino, UnitConverter.NXToRhinoUnitsRatio); return rhino;
+            UnitConverter.Scale(rhino, UnitConverter.NXToRhinoUnitsRatio);
+
+            return rhino;
+        }
+
+        public static Curve ToRhino(this NXOpen.Curve value)
+        {
+            Curve rhino = RawDecoder.ToRhinoCurve(value);
+
+            UnitConverter.Scale(rhino, UnitConverter.NXToRhinoUnitsRatio);
+
+            return rhino;
         }
 
         public static PolylineCurve ToPolylineCurve(this NXOpen.Polyline value)
         {
-            var rhino = RawDecoder.ToRhinoPolylineCurve(value); 
-            UnitConverter.Scale(rhino, UnitConverter.NXToRhinoUnitsRatio); 
-            return rhino; 
+            var rhino = RawDecoder.ToRhinoCurve(value);
+            UnitConverter.Scale(rhino, UnitConverter.NXToRhinoUnitsRatio);
+            return rhino;
         }
     }
 }
diff --git a/RhinoInside.NX.Translator/Geometry/Decoder/CurveRawDecoder.cs b/RhinoInside.NX.Translator/Geometry/Decoder/CurveRawDecoder.cs
new file mode 100644
index 0000000..1823119
--- /dev/null
+++ b/RhinoInside.NX.Translator/Geometry/Decoder/CurveRawDecoder.cs
@@ -0,0 +1,210 @@
+锘縰sing System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Rhino.Geometry;
+using NXOpen.Extensions;
+using static NXOpen.Extensions.Globals;
+
+namespace RhinoInside.NX.Translator.Geometry
+{
+    public static partial class RawDecoder
+    {
+        public static LineCurve ToRhinoCurve(NXOpen.Line line)
+        {
+            return new LineCurve(new Line(line.StartPoint.ToRhino(), line.EndPoint.ToRhino()));
+        }
+
+        public static ArcCurve ToRhinoCurve(NXOpen.Arc arc)
+        {
+            return CreateArc(arc.CenterPoint.ToRhino(), arc.Matrix.Element.GetAxisX().ToRhino(), arc.Matrix.Element.GetAxisY().ToRhino(), arc.StartAngle, arc.EndAngle, arc.Radius);
+        }
+
+        internal static ArcCurve CreateArc(Point3d center, Vector3d axisX, Vector3d axisY, double startAngle, double endAngle, double radius)
+        {
+            var circle = new Circle(new Plane(center, axisX, axisY), radius);
+
+            if (Math.Abs(Math.Abs(endAngle - startAngle) - 2 * Math.PI) < AngleTolerance)
+                return new ArcCurve(circle);
+            else
+                return new ArcCurve(new Arc(circle, new Interval(startAngle, endAngle)));
+        }
+
+        public static NurbsCurve ToRhinoCurve(NXOpen.Ellipse ellipse)
+        {
+            return CreateNurbsCurve(ellipse.CenterPoint.ToRhino(), ellipse.Matrix.Element.GetAxisX().ToRhino(), ellipse.Matrix.Element.GetAxisY().ToRhino(), ellipse.StartAngle, ellipse.EndAngle, ellipse.MajorRadius, ellipse.MinorRadius, ellipse.GetPoint(0.0).ToRhino(), ellipse.GetPoint(1.0).ToRhino());
+        }
+
+        /// <summary>
+        /// 鍒涘缓妞渾褰� NurbsCurve
+        /// </summary>
+        /// <param name="center"></param>
+        /// <param name="axisX"></param>
+        /// <param name="axisY"></param>
+        /// <param name="startAngle"></param>
+        /// <param name="endAngle"></param>
+        /// <param name="majorRadius"></param>
+        /// <param name="minorRadius"></param>
+        /// <param name="startPoint">濡傛灉妞渾涓嶆槸瀹屾暣妞渾锛岄渶瑕佹彁渚�</param>
+        /// <param name="endPoint">濡傛灉妞渾涓嶆槸瀹屾暣妞渾锛岄渶瑕佹彁渚�</param>
+        /// <returns></returns>
+        internal static NurbsCurve CreateNurbsCurve(Point3d center, Vector3d axisX, Vector3d axisY, double startAngle, double endAngle, double majorRadius, double minorRadius, Point3d startPoint = default, Point3d endPoint = default)
+        {
+            var plane = new Plane(center, axisX, axisY);
+            var e = new Ellipse(plane, majorRadius, minorRadius);
+            var nurbsCurve = e.ToNurbsCurve();
+
+            if (Math.Abs(Math.Abs(endAngle - startAngle) - Math.PI * 2) > DistanceTolerance)
+            {
+                nurbsCurve.ClosestPoint(startPoint, out var startParam);
+                if (!nurbsCurve.ChangeClosedCurveSeam(startParam))
+                    nurbsCurve.Domain = new Interval(startParam, startParam + nurbsCurve.Domain.Length);
+
+                nurbsCurve.ClosestPoint(endPoint, out var endParam);
+                nurbsCurve = nurbsCurve.Trim(startParam, endParam) as NurbsCurve;
+                nurbsCurve.Domain = new Interval(startAngle / (Math.PI * 2.0), endAngle / (Math.PI * 2.0));
+            }
+
+            return nurbsCurve;
+        }
+
+        public static NurbsCurve ToRhinoCurve(NXOpen.Spline spline)
+        {
+            return CreateNurbsCurve(spline.GetPoles(), spline.GetKnots(), spline.Rational, spline.Order);
+        }
+
+        /// <summary>
+        /// 鏍规嵁鏋佺偣鍜岃妭鐐瑰垱寤� NurbsCurve
+        /// </summary>
+        /// <param name="poles">鍖呭惈鎺у埗鐐瑰潗鏍囦互鍙婃潈閲嶄俊鎭殑 Point4d 鏁扮粍</param>
+        /// <param name="knots">鑺傜偣</param>
+        /// <param name="isRational"></param>
+        /// <param name="order"></param>
+        /// <returns></returns>
+        internal static NurbsCurve CreateNurbsCurve(NXOpen.Point4d[] poles, double[] knots, bool isRational, int order)
+        {
+            var n = new NurbsCurve(3, isRational, order, poles.Length);
+
+            Point3d[] controlPoints = new Point3d[poles.Length];
+            double[] weights = new double[poles.Length];
+            for (int i = 0; i < poles.Length; i++)
+            {
+                controlPoints[i] = new Point3d(poles[i].X, poles[i].Y, poles[i].Z);
+                weights[i] = poles[i].W;
+            }
+
+            if (isRational)
+            {
+                int index = 0;
+                foreach (var pt in controlPoints)
+                {
+                    var w = weights[index];
+                    n.Points.SetPoint(index++, pt.X * w, pt.Y * w, pt.Z * w, w);
+                }
+            }
+            else
+            {
+                int index = 0;
+                foreach (var pt in controlPoints)
+                    n.Points.SetPoint(index++, pt.X, pt.Y, pt.Z);
+            }
+
+            int knotIndex = 0;
+            foreach (var w in knots.Cast<double>().Skip(1).Take(n.Knots.Count))
+                n.Knots[knotIndex++] = w;
+
+            return n;
+        }
+
+        public static PolylineCurve ToRhinoCurve(NXOpen.Polyline polyline)
+        {
+            return new PolylineCurve(polyline.GetPoints().Select(x => x.ToRhino()));
+        }
+
+        public static Curve ToRhinoCurve(NXOpen.Curve curve)
+        {
+            switch (curve)
+            {
+                case null: return null;
+                case NXOpen.Line line: return ToRhinoCurve(line);
+                case NXOpen.Arc arc: return ToRhinoCurve(arc);
+                case NXOpen.Ellipse ellipse: return ToRhinoCurve(ellipse);
+                case NXOpen.Spline nurb: return ToRhinoCurve(nurb);
+                default: throw new NotImplementedException();
+            }
+        }
+
+        public static Curve ToRhinoCurve(NXOpen.Edge edge)
+        {
+            var edgeType = edge.SolidEdgeType;
+
+            switch (edgeType)
+            {
+                case NXOpen.Edge.EdgeType.Rubber:
+                    break;
+                case NXOpen.Edge.EdgeType.Linear:
+                    edge.GetVertices(out var sp, out var ep);
+                    return new LineCurve(new Line(sp.ToRhino(), ep.ToRhino()));
+                case NXOpen.Edge.EdgeType.Circular:
+                    TheUfSession.Eval.Initialize2(edge.Tag, out var edgeEvaluator);
+                    TheUfSession.Eval.AskArc(edgeEvaluator, out var arc);
+                    TheUfSession.Eval.Free(edgeEvaluator);
+
+                    return RawDecoder.CreateArc(arc.center.ToRhinoPoint3d(), arc.x_axis.ToRhinoVector3d(), arc.y_axis.ToRhinoVector3d(), arc.limits[0], arc.limits[1], arc.radius);
+                case NXOpen.Edge.EdgeType.Elliptical:
+                    TheUfSession.Eval.Initialize2(edge.Tag, out var evaluator);
+                    TheUfSession.Eval.AskEllipse(evaluator, out var ellipse);
+                    TheUfSession.Eval.Free(evaluator);
+
+                    NurbsCurve nurbsCurve = RawDecoder.CreateNurbsCurve(ellipse.center.ToRhinoPoint3d(), ellipse.x_axis.ToRhinoVector3d(), ellipse.y_axis.ToRhinoVector3d(), ellipse.limits[0], ellipse.limits[1], ellipse.major, ellipse.minor, edge.GetPoint(0.0).ToRhino(), edge.GetPoint(1.0).ToRhino());
+
+                    return nurbsCurve;
+                case NXOpen.Edge.EdgeType.Intersection:
+                    break;
+                case NXOpen.Edge.EdgeType.Spline:
+                    TheUfSession.Eval.Initialize2(edge.Tag, out var splineEvaluator);
+                    TheUfSession.Eval.AskSplineControlPts(splineEvaluator, out var controlPointCount, out var controlPoints);
+                    TheUfSession.Eval.AskSplineKnots(splineEvaluator, out var knotsCount, out var knots);
+                    TheUfSession.Eval.AskSpline(splineEvaluator, out var splineData);
+                    TheUfSession.Eval.Free(splineEvaluator);
+
+                    NXOpen.Point4d[] controlPoint4ds = new NXOpen.Point4d[controlPointCount];
+                    for (int i = 0; i < controlPointCount; i++)
+                    {
+                        controlPoint4ds[i] = new NXOpen.Point4d
+                        {
+                            X = controlPoints[i * 4],
+                            Y = controlPoints[i * 4 + 1],
+                            Z = controlPoints[i * 4 + 2],
+                            W = controlPoints[i * 4 + 3],
+                        };
+                    }
+
+                    return RawDecoder.CreateNurbsCurve(controlPoint4ds, knots, splineData.is_rational, splineData.order);
+                case NXOpen.Edge.EdgeType.SpCurve:
+                    break;
+                case NXOpen.Edge.EdgeType.Foreign:
+                    break;
+                case NXOpen.Edge.EdgeType.ConstantParameter:
+                    break;
+                case NXOpen.Edge.EdgeType.TrimmedCurve:
+                    break;
+                case NXOpen.Edge.EdgeType.Convergent:
+                    break;
+                case NXOpen.Edge.EdgeType.Undefined:
+                    break;
+                default:
+                    break;
+            }
+
+            var nxCurve = edge.CreateCurveFromEdge();
+
+            var rhinoCurve = nxCurve.ToRhino();
+
+            nxCurve.Delete();
+
+            return rhinoCurve;
+        }
+    }
+}
diff --git a/RhinoInside.NX.Translator/Geometry/Decoder/PointDecoder.cs b/RhinoInside.NX.Translator/Geometry/Decoder/PointDecoder.cs
new file mode 100644
index 0000000..afe4bf7
--- /dev/null
+++ b/RhinoInside.NX.Translator/Geometry/Decoder/PointDecoder.cs
@@ -0,0 +1,47 @@
+锘縰sing Rhino.Geometry;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace RhinoInside.NX.Translator.Geometry
+{
+    public static partial class Decoder
+    {
+        public static Vector3d ToRhinoVector3d(this double[] value)
+        {
+            var rhino = RawDecoder.ToRhinoVector3d(value);
+            UnitConverter.Scale(ref rhino, UnitConverter.NXToRhinoUnitsRatio);
+            return rhino;
+        }
+
+        public static Point3d ToRhinoPoint3d(this double[] value)
+        {
+            var rhino = RawDecoder.ToRhinoPoint3d(value);
+            UnitConverter.Scale(ref rhino, UnitConverter.NXToRhinoUnitsRatio);
+            return rhino;
+        }
+
+        public static Point3d ToRhino(this NXOpen.Point3d value)
+        {
+            Point3d rhino = RawDecoder.ToRhino(value);
+            UnitConverter.Scale(ref rhino, UnitConverter.NXToRhinoUnitsRatio);
+            return rhino;
+        }
+
+        public static Vector3d ToRhino(this NXOpen.Vector3d value)
+        {
+            Vector3d rhino = RawDecoder.ToRhino(value);
+            UnitConverter.Scale(ref rhino, UnitConverter.NXToRhinoUnitsRatio);
+            return rhino;
+        }
+
+        public static Rhino.Geometry.Transform ToRhino(this NXOpen.Matrix4x4 value)
+        {
+            var rhino = RawDecoder.ToRhinoTransform(value);
+            UnitConverter.Scale(ref rhino, UnitConverter.NXToRhinoUnitsRatio);
+            return rhino;
+        }
+    }
+}
diff --git a/RhinoInside.NX.Translator/Geometry/Raw/Decoder/StructuresRawDecoder.cs b/RhinoInside.NX.Translator/Geometry/Decoder/PointRawDecoder.cs
similarity index 52%
rename from RhinoInside.NX.Translator/Geometry/Raw/Decoder/StructuresRawDecoder.cs
rename to RhinoInside.NX.Translator/Geometry/Decoder/PointRawDecoder.cs
index d49b0ef..8ce87a0 100644
--- a/RhinoInside.NX.Translator/Geometry/Raw/Decoder/StructuresRawDecoder.cs
+++ b/RhinoInside.NX.Translator/Geometry/Decoder/PointRawDecoder.cs
@@ -1,31 +1,28 @@
+锘縰sing Rhino.Geometry;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
-using System.Reflection;
-using Rhino.Geometry;
-using NXOpen.Extensions;
-using static NXOpen.Extensions.Globals;
+using System.Text;
+using System.Threading.Tasks;
 
-namespace RhinoInside.NX.Translator.Geometry.Raw
+namespace RhinoInside.NX.Translator.Geometry
 {
-    /// <summary>
-    /// 此类中的方法是将 NX 几何体转换为 NX 单位的对象。
-    /// <para>如需在 Rhino 中使用，需要转换到 Rhino 的单位。</para>
-    /// </summary>
     public static partial class RawDecoder
     {
-        #region Values
-        public static Point3d ToRhino(NXOpen.Point3d p)
+        public static Vector3d ToRhino(NXOpen.Vector3d value)
         {
-            return new Point3d(p.X, p.Y, p.Z);
+            return new Vector3d(value.X, value.Y, value.Z);
         }
 
-        public static Vector3d ToRhino(NXOpen.Vector3d p)
+        public static Point3d ToRhino(NXOpen.Point3d value)
         {
-            return new Vector3d(p.X, p.Y, p.Z);
+            return new Point3d(value.X, value.Y, value.Z);
         }
 
+        public static Point3d ToRhinoPoint3d(double[] value) => new Point3d(value[0], value[1], value[2]);
+
+        public static Vector3d ToRhinoVector3d(double[] value) => new Vector3d(value[0], value[1], value[2]);
+
         public static Rhino.Geometry.Transform ToRhinoTransform(NXOpen.Matrix4x4 transform)
         {
             var value = new Rhino.Geometry.Transform
@@ -54,17 +51,9 @@ public static Rhino.Geometry.Transform ToRhinoTransform(NXOpen.Matrix4x4 transfo
             return value;
         }
 
-        public static Plane ToRhino(NXOpen.Plane plane)
-        {
-            return new Plane(ToRhino(plane.Origin), ToRhino(plane.Matrix.GetAxisX()), ToRhino(plane.Matrix.GetAxisY()));
-        }
-        #endregion
-
-        #region Point
         public static Point ToRhino(NXOpen.Point point)
         {
-            return new Point(ToRhino(point.Coordinates));
+            return new Point(point.Coordinates.ToRhino());
         }
-        #endregion
-    };
+    }
 }
diff --git a/RhinoInside.NX.Translator/Geometry/Decoder/SurfaceDcoder.cs b/RhinoInside.NX.Translator/Geometry/Decoder/SurfaceDcoder.cs
new file mode 100644
index 0000000..50128c8
--- /dev/null
+++ b/RhinoInside.NX.Translator/Geometry/Decoder/SurfaceDcoder.cs
@@ -0,0 +1,40 @@
+锘縰sing Rhino.Geometry;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace RhinoInside.NX.Translator.Geometry
+{
+    public static partial class Decoder
+    {
+        public static Brep ToBrep(this NXOpen.Body value)
+        {
+            var rhino = RawDecoder.ToRhinoBrep(value);
+            UnitConverter.Scale(rhino, UnitConverter.NXToRhinoUnitsRatio);
+            return rhino;
+        }
+
+        public static Brep ToBrep(this NXOpen.Face value)
+        {
+            var rhino = RawDecoder.ToRhinoBrep(value);
+            UnitConverter.Scale(rhino, UnitConverter.NXToRhinoUnitsRatio);
+            return rhino;
+        }
+
+        public static Surface ToRhinoSurface(this NXOpen.Face face)
+        {
+            var rhino = RawDecoder.ToRhinoSurface(face, out _);
+            UnitConverter.Scale(rhino, UnitConverter.NXToRhinoUnitsRatio);
+            return rhino;
+        }
+
+        public static Plane ToRhino(this NXOpen.Plane value)
+        {
+            var rhino = RawDecoder.ToRhino(value);
+            UnitConverter.Scale(ref rhino, UnitConverter.NXToRhinoUnitsRatio);
+            return rhino;
+        }
+    }
+}
diff --git a/RhinoInside.NX.Translator/Geometry/Decoder/SurfaceRawDecoder.cs b/RhinoInside.NX.Translator/Geometry/Decoder/SurfaceRawDecoder.cs
new file mode 100644
index 0000000..29c15eb
--- /dev/null
+++ b/RhinoInside.NX.Translator/Geometry/Decoder/SurfaceRawDecoder.cs
@@ -0,0 +1,509 @@
+锘縰sing System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Rhino.Geometry;
+using NXOpen.Extensions;
+using static NXOpen.Extensions.Globals;
+
+namespace RhinoInside.NX.Translator.Geometry
+{
+    public static partial class RawDecoder
+    {
+        public static Brep ToRhinoBrep(NXOpen.Body body)
+        {
+            if (false)
+            {
+                Brep brep = new Brep();
+
+                for (int i = 0; i < body.GetFaces().Length; i++)
+                {
+                    AddNXFace(body.GetFaces()[i], brep);
+                }
+
+                return brep;
+            }
+            else
+                return JoinAndMerge(body.GetFaces().Select(x => ToRhinoBrep(x)).ToArray(), Globals.DistanceTolerance);
+        }
+
+        static Brep JoinAndMerge(ICollection<Brep> brepFaces, double tolerance)
+        {
+            if (brepFaces.Count == 0)
+                return null;
+
+            if (brepFaces.Count == 1)
+                return brepFaces.First();
+
+            var joinedBreps = Brep.JoinBreps(brepFaces.OfType<Brep>(), tolerance) ?? brepFaces;
+            if (joinedBreps.Count == 1)
+                return joinedBreps.First();
+
+            var merged = Brep.MergeBreps(joinedBreps, Globals.DistanceTolerance);
+            if (merged?.IsValid == false)
+                merged.Repair(tolerance);
+
+            return merged;
+        }
+
+        public static Brep ToRhinoBrep(NXOpen.Face face)
+        {
+            //using RhinoInside.NX.Translator.Geometry;
+            //using NXOpen.Extensions;
+            //using System.Linq;
+
+            Brep brep = new Brep();
+
+            AddNXFace(face, brep);
+
+            return brep;
+#if 娣诲姞椤剁偣
+                        Point3d startVertetexpnt = curve3d.PointAtStart;
+
+                        BrepVertex startVertex = brep.Vertices.Add(startVertetexpnt, Globals.DistanceTolerance);
+
+                        Point3d endVertetexpnt = curve3d.PointAtEnd;
+
+                        BrepVertex endVertex = brep.Vertices.Add(endVertetexpnt, Globals.DistanceTolerance);
+
+                        // Curve curve2d = surface.Pullback(curve3d, Globals.DistanceTolerance, new Interval(0, 1.0));
+
+                        int startVertexIndex = startVertex.VertexIndex;
+
+                        int endVertexIndex = endVertex.VertexIndex;
+
+                        int curve3dIndex = brep.AddEdgeCurve(curve3d);
+
+                        BrepEdge edge = brep.Edges.Add(startVertexIndex, endVertexIndex, curve3dIndex, Globals.DistanceTolerance);
+
+                        int curve2dIndex = brep.AddTrimCurve(curve2d);
+
+                        BrepTrim trim = brepLoop.Trims.Add(edge, currentFin.Sense == NXOpen.Sense.Forward, brepLoop, curve2dIndex);
+
+                        trim.IsoStatus = Rhino.Geometry.IsoStatus.None;
+
+                        trim.TrimType = BrepTrimType.Boundary;
+
+                        trim.SetTolerances(Globals.DistanceTolerance, Globals.DistanceTolerance);
+#endif            
+        }
+
+        private static void AddNXFace(NXOpen.Face face, Brep brep)
+        {
+            Surface surface = face.ToRhinoSurface();
+
+            var surfIndex = brep.AddSurface(surface);
+
+            var brepFace = brep.Faces.Add(surfIndex);
+
+            // Console.WriteLine("***************************************************");
+
+            try
+            {
+                var loopList = face.GetLoops().ToList();
+
+                if (loopList.Count == 0)
+                    return;
+
+                if (loopList[0].Type != NXOpen.Extensions.Topology.LoopType.Outer && loopList[0].Type != NXOpen.Extensions.Topology.LoopType.LikelyOuter)
+                {
+                    var outerLoop = loopList.FirstOrDefault(obj => obj.Type == NXOpen.Extensions.Topology.LoopType.Outer || obj.Type == NXOpen.Extensions.Topology.LoopType.LikelyOuter);
+
+                    if (outerLoop != null)
+                    {
+                        loopList.Remove(outerLoop);
+
+                        loopList.Insert(0, outerLoop);
+                    }
+                }
+
+                var faceSense = face.GetSense();
+
+                // Console.WriteLine("Face Sense:" + faceSense);
+
+                var outerLoopSense = loopList[0].FirstFin.Sense;
+
+                // Console.WriteLine("Outer loop:" + outerLoopSense);
+
+                for (int i = 0; i < loopList.Count; i++)
+                {
+                    // Console.WriteLine("********Loop*******");
+
+                    var currentNxLoop = loopList[i];
+
+                    if (currentNxLoop.Fins.Length == 0)
+                        continue;
+
+                    BrepLoopType brepLoopType;
+                    switch (currentNxLoop.Type)
+                    {
+                        case NXOpen.Extensions.Topology.LoopType.LikelyOuter:
+                        case NXOpen.Extensions.Topology.LoopType.Outer:
+                            brepLoopType = BrepLoopType.Outer;
+                            break;
+                        case NXOpen.Extensions.Topology.LoopType.LikelyInner:
+                        case NXOpen.Extensions.Topology.LoopType.Inner:
+                        case NXOpen.Extensions.Topology.LoopType.InnerSingular:
+                            brepLoopType = BrepLoopType.Inner;
+                            break;
+                        case NXOpen.Extensions.Topology.LoopType.Winding:
+                            if (i == 0)
+                                brepLoopType = BrepLoopType.Outer;
+                            else
+                                brepLoopType = BrepLoopType.Inner;
+                            break;
+                        case NXOpen.Extensions.Topology.LoopType.Unknown:
+                        default:
+                            brepLoopType = BrepLoopType.Unknown;
+                            break;
+                    }
+
+                    var brepLoop = brep.Loops.Add(brepLoopType, brepFace);
+
+                    var currentFin = currentNxLoop.FirstFin;
+
+                    var trims = new PolyCurve();
+
+                    Dictionary<BrepEdge, int> brepEdges = new Dictionary<BrepEdge, int>();
+
+                    int finCount = 0;
+
+                    do
+                    {
+                        finCount++;
+
+                        var curve3d = currentFin.Edge.ToRhinoCurve();
+
+                        if (currentFin.StartVertex != null && curve3d.PointAtStart.DistanceTo(currentFin.StartVertex.Position.ToRhino()) > Globals.DistanceTolerance)
+                        {
+                            curve3d.Reverse();
+                        }
+
+                        var brepEdgeCurve = brep.AddEdgeCurve(curve3d);
+
+                        var brepEdge = brep.Edges.Add(brepEdgeCurve);
+
+                        //Console.WriteLine("Start of Fin" + currentFin.StartVertex.Position);
+                        //Console.WriteLine("Start of Edge" + curve3d.PointAtStart);
+                        //Console.WriteLine("End of Fin" + currentFin.EndVertex.Position);
+                        //Console.WriteLine("End of Edge" + curve3d.PointAtEnd);
+
+                        brepEdges.Add(brepEdge, curve3d.TangentAt(curve3d.Domain.Mid).IsParallelTo(brepEdge.TangentAt(brepEdge.Domain.Mid)));
+
+                        var curve2d = surface.Pullback(curve3d, Globals.DistanceTolerance);
+
+                        trims.Append(curve2d);
+
+                        currentFin = currentFin.Next;
+
+                    } while (currentFin != currentNxLoop.FirstFin);
+
+                    trims.MakeClosed(Globals.DistanceTolerance);
+
+                    for (int j = 0; j < brepEdges.Count; j++)
+                    {
+                        if (trims.SegmentCurve(j) is Curve)
+                        {
+                            var curve = trims.SegmentCurve(j) as Curve;
+                            var ti = brep.AddTrimCurve(curve);
+
+                            if (brepEdges.ElementAt(j).Value == 0)
+                                continue;
+
+                            var brepTrim = brep.Trims.Add(brepEdges.ElementAt(j).Key, brepEdges.ElementAt(j).Value < 0, brepLoop, ti);
+
+                            brepTrim.TrimType = BrepTrimType.Boundary;
+                        }
+                    }
+
+                    // brepLoop.Trims.MatchEnds();
+
+                    // brep.Trims.MatchEnds(brepLoop.Trims[0], brepLoop.Trims.Last());
+
+                    // brep.Repair(Globals.DistanceTolerance);
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine("鏃犳硶娣诲姞 NX 闈細" + ex);
+            }
+
+            brep.Trims.MatchEnds();
+
+            brep.Repair(Globals.DistanceTolerance);
+        }
+
+        public static Plane ToRhino(NXOpen.Plane plane)
+        {
+            return new Plane(plane.Origin.ToRhino(),
+                ToRhino(plane.Matrix.GetAxisX()),
+                ToRhino(plane.Matrix.GetAxisY()));
+        }
+
+        public static Surface ToRhinoSurface(NXOpen.Face face, out bool parametricOrientation, double relativeTolerance = 0.0)
+        {
+            FaceEx.FaceData faceData = face.GetData();
+            parametricOrientation = faceData.NormalReversed;
+
+            switch (faceData.FaceType)
+            {
+                case NXOpen.Face.FaceType.Planar:
+                    return ToRhinoPlaneSurface(face, relativeTolerance);
+                case NXOpen.Face.FaceType.Conical:
+                    return ToRhinoConicalSurface(face, faceData, relativeTolerance);
+                case NXOpen.Face.FaceType.Cylindrical:
+                    return ToRhinoCylindricalSurface(face, faceData);
+                case NXOpen.Face.FaceType.SurfaceOfRevolution:
+                    return ToRhinoRevSurface(face, faceData, relativeTolerance);
+                case NXOpen.Face.FaceType.Spherical:
+                    return ToRhinoSphereSurface(face);
+                default: return FromBsurf(face);
+            }
+        }
+
+        /// <summary>
+        /// 鍒涘缓鏈慨鍓殑 Rhino PlaneSurface
+        /// </summary>
+        /// <param name="face"></param>
+        /// <param name="relativeTolerance"></param>
+        /// <returns></returns>
+        static PlaneSurface ToRhinoPlaneSurface(NXOpen.Face face, double relativeTolerance)
+        {
+            double[] facePt = new double[3];
+            double[] direction = new double[3];
+            double[] box = new double[6];
+            TheUfSession.Modl.AskFaceData(face.Tag, out int type, facePt, direction, box, out double radius, out double radData, out int normDir);
+
+            Plane plane = new Plane(new Point3d(facePt[0], facePt[1], facePt[2]), new Vector3d(direction[0], direction[1], direction[2]));
+
+            return PlaneSurface.CreateThroughBox(plane, new BoundingBox(new Point3d(box[0], box[1], box[2]), new Point3d(box[3], box[4], box[5])));
+        }
+
+        static RevSurface ToRhinoConicalSurface(NXOpen.Face face, FaceEx.FaceData faceData, double relativeTolerance)
+        {
+            double totalHeight;           // 鍦嗛敟鎬婚珮搴�
+            NXOpen.Point3d top;           // 鍦嗛敟椤剁偣
+
+            double radius;                // 閿ュ簳鍗婂緞
+            var faceBoundingBox = face.GetAlignedBoundingBox(faceData.Direction);
+
+            if (face.GetEdges().Length == 1 && face.GetEdges()[0].SolidEdgeType == NXOpen.Edge.EdgeType.Circular)
+            {
+                // 鏃犱慨鍓殑閿ュ舰
+                TheUfSession.Eval.Initialize2(face.GetEdges()[0].Tag, out var edgeEvaluator);
+                TheUfSession.Eval.AskArc(edgeEvaluator, out var arc);
+                TheUfSession.Eval.Free(edgeEvaluator);
+
+                NXOpen.Point3d bottom = arc.center.ToPoint3d();        // 閿ュ簳涓績鐐�
+
+                totalHeight = faceBoundingBox.Height;
+
+                top = bottom.Move(faceBoundingBox.HeightDirection, totalHeight);
+
+                radius = arc.radius;
+            }
+            else
+            {
+                var tangentOfHalfAngle = Math.Tan(faceData.RadiusData);
+
+                top = faceData.Point.Move(faceBoundingBox.HeightDirection, faceData.Radius / tangentOfHalfAngle);
+
+                totalHeight = faceBoundingBox.Height + faceData.Radius / Math.Tan(faceData.RadiusData);
+
+                radius = faceData.Radius + faceBoundingBox.Height * tangentOfHalfAngle;
+            }
+
+            var cone = new Cone(new Plane(top.ToRhino(), faceBoundingBox.HeightDirection.Reverse().ToRhino()), totalHeight, radius);
+
+            return cone.ToRevSurface();
+
+            // var curve = new LineCurve(outerPointOnCircle.ToRhino(), top.ToRhino());
+            // return RevSurface.Create(curve, new Line(bottom.ToRhino(), top.ToRhino()), 0.0, Math.PI * 2.0);
+        }
+
+        static RevSurface ToRhinoRevSurface(NXOpen.Face face, FaceEx.FaceData faceData, double relativeTolerance)
+        {
+            var bodyFeatures = face.GetBody().GetFeatures();
+
+            var revolveFeature = bodyFeatures.FirstOrDefault(obj => obj is NXOpen.Features.Revolve);
+
+            Curve faceSectionCurve = default;
+            double startRadian = 0.0;
+            double endRadian = Math.PI * 2;
+            if (revolveFeature != null)
+            {
+                NXOpen.Features.RevolveBuilder revolveBuilder = WorkPart.Features.CreateRevolveBuilder(revolveFeature);
+                revolveBuilder.Section.GetOutputCurves(out var sectionCurves);
+
+                startRadian = revolveBuilder.Limits.StartExtend.Value.Value * Math.PI / 180.0;
+
+                endRadian = revolveBuilder.Limits.EndExtend.Value.Value * Math.PI / 180.0;
+
+                revolveBuilder.Destroy();
+
+                for (int i = 0; i < sectionCurves.Length; i++)
+                {
+                    var baseCurve = sectionCurves[i] as NXOpen.IBaseCurve;
+
+                    var curveMidPt = baseCurve.GetPoint(0.5);
+                    if (curveMidPt.DistanceTo(face.Tag).Distance < DistanceTolerance)
+                    {
+                        faceSectionCurve = baseCurve.ToRhinoCurve();
+                        break;
+                    }
+                }
+            }
+            else
+            {
+                var faceBoundingBox = face.GetAlignedBoundingBox(faceData.Direction);
+
+                var point1 = faceData.Point.Move(faceData.Direction, faceBoundingBox.Height * 1.5);
+
+                var point2 = point1.Move(faceBoundingBox.LengthDirection, faceBoundingBox.Length);
+
+                var point3 = point2.Move(faceData.Direction.Reverse(), faceBoundingBox.Height * 3);
+
+                var point4 = point3.Move(faceBoundingBox.LengthDirection.Reverse(), faceBoundingBox.Length);
+
+                var fourPointSurface = WorkPart.Features.CreateFourPointSurface(point1, point2, point3, point4);
+
+                var intersectionCurveFeature = WorkPart.Features.CreateIntersectionCurve(fourPointSurface.GetFaces(), face);
+
+                faceSectionCurve = (intersectionCurveFeature.GetEntities()[0] as NXOpen.Curve).ToRhino();
+
+                intersectionCurveFeature.Delete();
+                fourPointSurface.Delete();
+            }
+
+            return RevSurface.Create(faceSectionCurve, new Line(faceData.Point.ToRhino(), faceData.Point.Move(faceData.Direction, 10.0).ToRhino()), startRadian, endRadian);
+        }
+
+        static RevSurface ToRhinoSphereSurface(NXOpen.Face face)
+        {
+            var faceData = face.GetData();
+
+            return RevSurface.CreateFromSphere(new Sphere(faceData.Point.ToRhino(), faceData.Radius));
+        }
+
+        static NurbsSurface ToRhinoCylindricalSurface(NXOpen.Face face, FaceEx.FaceData faceData)
+        {
+            NXOpen.Point3d top;           // 鍦嗘煴椤剁偣
+
+            double radius;                // 鍦嗘煴鍗婂緞
+
+            NXOpen.Point3d bottom;          // 鍦嗘煴搴曢潰涓績鐐�
+
+            var faceBoundingBox = face.GetAlignedBoundingBox(faceData.Direction);
+
+            double totalHeight = faceBoundingBox.Height;          // 鍦嗘煴鎬婚珮搴� 
+
+            if (face.GetEdges().Length == 2 && face.GetEdges().All(obj => obj.SolidEdgeType == NXOpen.Edge.EdgeType.Circular))
+            {
+                // 鏈慨鍓殑鍦嗘煴
+                TheUfSession.Eval.Initialize2(face.GetEdges()[0].Tag, out var edgeEvaluator);
+                TheUfSession.Eval.AskArc(edgeEvaluator, out var arc1);
+                TheUfSession.Eval.Free(edgeEvaluator);
+
+                TheUfSession.Eval.Initialize2(face.GetEdges()[1].Tag, out edgeEvaluator);
+                TheUfSession.Eval.AskArc(edgeEvaluator, out var arc2);
+                TheUfSession.Eval.Free(edgeEvaluator);
+
+                if (arc2.center.ToPoint3d().Subtract(arc1.center.ToPoint3d()).GetUnitVector().IsEqual(faceData.Direction.GetUnitVector()))
+                {
+                    bottom = arc1.center.ToPoint3d();
+                }
+                else
+                {
+                    bottom = arc2.center.ToPoint3d();
+                }
+
+                top = bottom.Move(faceBoundingBox.HeightDirection, totalHeight);
+
+                radius = arc1.radius;
+            }
+            else
+            {
+                var topExtremePt = WorkPart.MeasureManager.MeasureRectangularExtreme(face, faceBoundingBox.HeightDirection, faceBoundingBox.LengthDirection, faceBoundingBox.WidthDirection);
+
+                var distToFacePoint = topExtremePt.DistanceTo(faceData.Point, faceData.Direction);
+
+                top = faceData.Point.Move(faceBoundingBox.HeightDirection, distToFacePoint);
+
+                bottom = top.Move(faceBoundingBox.HeightDirection.Reverse(), totalHeight);
+
+                radius = faceData.Radius;
+            }
+
+            Circle baseCircle = new Circle(new Plane(bottom.ToRhino(), faceBoundingBox.HeightDirection.ToRhino()), radius);
+
+            var cyl = new Rhino.Geometry.Cylinder(baseCircle, totalHeight);
+
+            return cyl.ToNurbsSurface();
+        }
+
+        public static NurbsSurface FromBsurf(NXOpen.Face face)
+        {
+            TheUfSession.Modl.AskBsurf(face.Tag, out NXOpen.UF.UFModl.Bsurface surfaceData);
+
+            var degreeU = surfaceData.order_u - 1;
+            var degreeV = surfaceData.order_v - 1;
+
+            var knotsU = surfaceData.knots_u;
+            var knotsV = surfaceData.knots_v;
+
+            //int controlPointCountU = knotsU.Length - degreeU - 1;
+            //int controlPointCountV = knotsV.Length - degreeV - 1;
+
+            var nurbsSurface = NurbsSurface.Create(3, surfaceData.is_rational == 1, degreeU + 1, degreeV + 1, surfaceData.num_poles_u, surfaceData.num_poles_v);
+
+            Point3d[,] controlPoints = new Point3d[surfaceData.num_poles_u, surfaceData.num_poles_v];
+            double[,] weights = new double[surfaceData.num_poles_u, surfaceData.num_poles_v];
+            for (int i = 0; i < surfaceData.num_poles_v; i++)
+            {
+                for (int j = 0; j < surfaceData.num_poles_u; j++)
+                {
+                    int offset = j + i * surfaceData.num_poles_u;
+
+                    controlPoints[j, i] = new Point3d(surfaceData.poles[offset, 0], surfaceData.poles[offset, 1], surfaceData.poles[offset, 2]);
+
+                    weights[j, i] = surfaceData.poles[offset, 3];
+                }
+            }
+
+            var points = nurbsSurface.Points;
+            for (int v = 0; v < surfaceData.num_poles_v; v++)
+            {
+                for (int u = 0; u < surfaceData.num_poles_u; u++)
+                {
+                    var pt = controlPoints[u, v];
+                    if (surfaceData.is_rational == 1)
+                    {
+                        double w = weights[u, v];
+                        points.SetPoint(u, v, pt.X * w, pt.Y * w, pt.Z * w, w);
+                    }
+                    else
+                    {
+                        points.SetPoint(u, v, pt.X, pt.Y, pt.Z);
+                    }
+                }
+            }
+
+            {
+                var knots = nurbsSurface.KnotsU;
+                int index = 0;
+                foreach (var w in knotsU.Skip(1).Take(knots.Count))
+                    knots[index++] = w;
+            }
+
+            {
+                var knots = nurbsSurface.KnotsV;
+                int index = 0;
+                foreach (var w in knotsV.Skip(1).Take(knots.Count))
+                    knots[index++] = w;
+            }
+
+            return nurbsSurface;
+        }
+    }
+}
diff --git a/RhinoInside.NX.Translator/Geometry/GeometryDecoder.cs b/RhinoInside.NX.Translator/Geometry/GeometryDecoder.cs
index ee011d7..c596a33 100644
--- a/RhinoInside.NX.Translator/Geometry/GeometryDecoder.cs
+++ b/RhinoInside.NX.Translator/Geometry/GeometryDecoder.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Rhino.Geometry;
+using NXOpen.Extensions;
 
 namespace RhinoInside.NX.Translator.Geometry
 {
@@ -14,32 +15,12 @@ namespace RhinoInside.NX.Translator.Geometry
     /// </summary>
     public static class GeometryDecoder
     {
-        #region Context
-        //public sealed class Context : State<Context>
-        //{
-        //    public DB.Element Element = default;
-        //    public DB.Visibility Visibility = DB.Visibility.Invisible;
-        //    public DB.ElementId GraphicsStyleId = DB.ElementId.InvalidElementId;
-        //    public DB.ElementId MaterialId = DB.ElementId.InvalidElementId;
-        //}
-        #endregion
-
         #region Geometry values
-        public static Point3d ToRhino(this NXOpen.Point3d value)
-        {
-            var rhino = RawDecoder.ToRhino(value);
-            UnitConverter.Scale(ref rhino, UnitConverter.NXToRhinoUnitsRatio);
-            return rhino;
-        }
+        
+
 
-        public static Vector3d ToVector3d(this NXOpen.Vector3d value)
-        { return new Vector3d(value.X, value.Y, value.Z); }
 
-        public static Plane ToPlane(this NXOpen.Plane value)
-        { var rhino = RawDecoder.ToRhino(value); UnitConverter.Scale(ref rhino, UnitConverter.NXToRhinoUnitsRatio); return rhino; }
 
-        public static Transform ToTransform(this NXOpen.Matrix4x4 value)
-        { var rhino = RawDecoder.ToRhinoTransform(value); UnitConverter.Scale(ref rhino, UnitConverter.NXToRhinoUnitsRatio); return rhino; }
 
         //public static BoundingBox ToBoundingBox(this DB.BoundingBoxXYZ value)
         //{ var rhino = RawDecoder.AsBoundingBox(value); UnitConverter.Scale(ref rhino, UnitConverter.ToRhinoUnits); return rhino; }
@@ -80,192 +61,14 @@ public static Transform ToTransform(this NXOpen.Matrix4x4 value)
 
         #region GeometryBase
 
-        public static Brep ToBrep(this NXOpen.Face value)
-        {
-            var rhino = RawDecoder.ToRhinoBrep(value);
-            UnitConverter.Scale(rhino, UnitConverter.NXToRhinoUnitsRatio);
-            return rhino;
-        }
 
-        public static Surface ToRhinoSurface(this NXOpen.Face face)
-        {
-            var rhino = RawDecoder.ToRhinoSurface(face, out _);
-            UnitConverter.Scale(rhino, UnitConverter.NXToRhinoUnitsRatio);
-            return rhino;
-        }
 
-        //public static Brep ToBrep(this DB.Solid value)
-        //{ var rhino = RawDecoder.ToRhino(value); UnitConverter.Scale(rhino, UnitConverter.ToRhinoUnits); return rhino; }
+
 
         //public static Mesh ToMesh(this DB.Mesh value)
         //{ var rhino = MeshDecoder.ToRhino(value); UnitConverter.Scale(rhino, UnitConverter.ToRhinoUnits); return rhino; }
         #endregion
 
-        /// <summary>
-        /// Converts a <see cref="DB.CurveLoop"/> into a Rhino <see cref="Curve"/>
-        /// </summary>
-        //public static Curve ToCurve(this DB.CurveLoop value)
-        //{
-        //    if (value.NumberOfCurves() == 1)
-        //        return value.First().ToCurve();
-
-        //    var polycurve = new PolyCurve();
-
-        //    foreach (var curve in value)
-        //        polycurve.AppendSegment(curve.ToCurve());
-
-        //    return polycurve;
-        //}
-
-        /// <summary>
-        /// Converts a <see cref="DB.CurveArray"/> into a Rhino <see cref="Curve"/>[]
-        /// </summary>
-        /// <seealso cref="ToPolyCurves(DB.CurveArrArray)"/>
-        //public static Curve[] ToCurves(this DB.CurveArray value)
-        //{
-        //    var count = value.Size;
-        //    var curves = new Curve[count];
-
-        //    int index = 0;
-        //    foreach (var curve in value.Cast<DB.Curve>())
-        //        curves[index++] = curve.ToCurve();
 
-        //    return curves;
-        //}
-
-        /// <summary>
-        /// Converts a <see cref="DB.CurveArrArray"/> into a <see cref="PolyCurve"/>[]
-        /// </summary>
-        /// <seealso cref="ToCurves(DB.CurveArrArray)"/>
-        //public static PolyCurve[] ToPolyCurves(this DB.CurveArrArray value)
-        //{
-        //    var count = value.Size;
-        //    var list = new PolyCurve[count];
-
-        //    int index = 0;
-        //    foreach (var curveArray in value.Cast<DB.CurveArray>())
-        //    {
-        //        var polycurve = new PolyCurve();
-
-        //        foreach (var curve in curveArray.Cast<DB.Curve>())
-        //            polycurve.AppendSegment(curve.ToCurve());
-
-        //        list[index++] = polycurve;
-        //    }
-
-        //    return list;
-        //}
-
-        /// <summary>
-        /// Update Context from <see cref="DB.GeometryObject"/> <paramref name="geometryObject"/>
-        /// </summary>
-        /// <param name="geometryObject"></param>
-        //static void UpdateGraphicAttributes(DB.GeometryObject geometryObject)
-        //{
-        //    if (geometryObject is object)
-        //    {
-        //        var context = Context.Peek;
-        //        if (context.Element is object)
-        //        {
-        //            if (geometryObject is DB.GeometryInstance instance)
-        //                context.Element = instance.Symbol;
-
-        //            context.Visibility = geometryObject.Visibility;
-
-        //            if (geometryObject.GraphicsStyleId != DB.ElementId.InvalidElementId)
-        //            {
-        //                context.GraphicsStyleId = geometryObject.GraphicsStyleId;
-
-        //                if (context.Element.Document.GetElement(context.GraphicsStyleId) is DB.GraphicsStyle graphicsStyle)
-        //                {
-        //                    if (graphicsStyle.GraphicsStyleCategory.Material is DB.Material material)
-        //                        context.MaterialId = material.Id;
-        //                }
-        //            }
-
-        //            if (geometryObject is DB.GeometryElement element)
-        //            {
-        //                if (element.MaterialElement is object)
-        //                    context.MaterialId = element.MaterialElement.Id;
-        //            }
-        //            else if (geometryObject is DB.Solid solid)
-        //            {
-        //                if (!solid.Faces.IsEmpty)
-        //                {
-        //                    var face0 = solid.Faces.get_Item(0);
-        //                    if (face0.MaterialElementId != DB.ElementId.InvalidElementId)
-        //                        context.MaterialId = face0.MaterialElementId;
-        //                }
-        //            }
-        //            else if (geometryObject is DB.Mesh mesh)
-        //            {
-        //                if (mesh.MaterialElementId != DB.ElementId.InvalidElementId)
-        //                    context.MaterialId = mesh.MaterialElementId;
-        //            }
-        //        }
-        //    }
-        //}
-
-        /// <summary>
-        /// Set graphic attributes to <see cref="GeometryBase"/> <paramref name="geometry"/> from Context
-        /// </summary>
-        /// <param name="geometry"></param>
-        /// <returns><paramref name="geometry"/> with graphic attributes</returns>
-        //static GeometryBase SetGraphicAttributes(GeometryBase geometry)
-        //{
-        //    if (geometry is object)
-        //    {
-        //        var context = Context.Peek;
-        //        if (context.Element is object)
-        //        {
-        //            if (context.GraphicsStyleId.IsValid() && context.Element.Document.GetElement(context.GraphicsStyleId) is DB.GraphicsStyle graphicsStyle)
-        //            {
-        //                var category = graphicsStyle.GraphicsStyleCategory;
-        //                geometry.SetUserString(DB.BuiltInParameter.FAMILY_ELEM_SUBCATEGORY.ToString(), category.Id.IntegerValue.ToString());
-        //            }
-
-        //            if (context.MaterialId.IsValid() && context.Element.Document.GetElement(context.MaterialId) is DB.Material material)
-        //            {
-        //                geometry.SetUserString(DB.BuiltInParameter.MATERIAL_ID_PARAM.ToString(), material.Id.IntegerValue.ToString());
-        //            }
-        //        }
-        //    }
-
-        //    return geometry;
-        //}
-
-        //public static IEnumerable<GeometryBase> ToGeometryBaseMany(this DB.GeometryObject geometry)
-        //{
-        //    UpdateGraphicAttributes(geometry);
-
-        //    switch (geometry)
-        //    {
-        //        case DB.GeometryElement element:
-        //            foreach (var g in element.SelectMany(x => x.ToGeometryBaseMany()))
-        //                yield return g;
-        //            yield break;
-
-        //        case DB.GeometryInstance instance:
-        //            foreach (var g in instance.GetInstanceGeometry().ToGeometryBaseMany())
-        //                yield return g;
-        //            yield break;
-
-        //        case DB.Mesh mesh:
-        //            yield return SetGraphicAttributes(mesh.ToMesh());
-        //            yield break;
-
-        //        case DB.Solid solid:
-        //            yield return SetGraphicAttributes(solid.ToBrep());
-        //            yield break;
-
-        //        case DB.Curve curve:
-        //            yield return SetGraphicAttributes(curve.ToCurve());
-        //            yield break;
-
-        //        case DB.PolyLine polyline:
-        //            yield return SetGraphicAttributes(polyline.ToPolylineCurve());
-        //            yield break;
-        //    }
-        //}
     }
 }
diff --git a/RhinoInside.NX.Translator/Geometry/PointEncoder.cs b/RhinoInside.NX.Translator/Geometry/PointEncoder.cs
index 50124eb..bcfa07f 100644
--- a/RhinoInside.NX.Translator/Geometry/PointEncoder.cs
+++ b/RhinoInside.NX.Translator/Geometry/PointEncoder.cs
@@ -16,14 +16,6 @@ namespace RhinoInside.NX.Translator
     /// </summary>
     public static class PointEncoder
     {
-        #region Context
-        public sealed class Context : State<Context>
-        {
-            public NXOpen.Tag MaterialId = NXOpen.Tag.Null;
-            public NXOpen.Tag GraphicsStyleId = NXOpen.Tag.Null;
-        }
-        #endregion
-
         #region Geometry values
         public static UV ToUV(this Point2f value)
         {
diff --git a/RhinoInside.NX.Translator/Geometry/Raw/Decoder/BrepRawDecoder.cs b/RhinoInside.NX.Translator/Geometry/Raw/Decoder/BrepRawDecoder.cs
deleted file mode 100644
index 8783473..0000000
--- a/RhinoInside.NX.Translator/Geometry/Raw/Decoder/BrepRawDecoder.cs
+++ /dev/null
@@ -1,419 +0,0 @@
-锘縰sing System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Threading.Tasks;
-using Rhino.Geometry;
-using NXOpen.Extensions;
-using static NXOpen.Extensions.Globals;
-using PK = PLMComponents.Parasolid.PK_.Unsafe;
-
-namespace RhinoInside.NX.Translator.Geometry.Raw
-{
-    public static partial class RawDecoder
-    {
-        public struct BrepBoundary
-        {
-            public BrepLoopType type;
-            public List<BrepEdge> edges;
-            public PolyCurve trims;
-            public List<NXOpen.Sense> orientation;
-        }
-
-        public static int AddSurface(Brep brep, NXOpen.Face face, out List<BrepBoundary>[] shells, Dictionary<NXOpen.Edge, BrepEdge> brepEdges = null)
-        {
-            // Extract base surface
-            if (ToRhinoSurface(face, out bool parametricOrientation) is Surface surface)
-            {
-                int si = brep.AddSurface(surface);
-
-                if (surface is PlaneSurface planar)
-                {
-                    var nurbs = planar.ToNurbsSurface();
-                    nurbs.KnotsU.InsertKnot(surface.Domain(0).Mid);
-                    nurbs.KnotsV.InsertKnot(surface.Domain(1).Mid);
-                    surface = nurbs;
-                }
-
-                var brepFace = brep.Faces.Add(si);
-
-                // 鎶藉彇骞跺垎绫昏竟鐨� Loop
-                var edgeLoops = new List<BrepBoundary>(face.GetLoops().Length);
-                foreach (var currentLoop in face.GetLoops())
-                {
-                    if (currentLoop.Edges.Length == 0)
-                        continue;
-
-                    var loopVertices = currentLoop.Vertices;
-
-                    Dictionary<int, BrepVertex> loopVerticesDic = new Dictionary<int, BrepVertex>();
-
-                    foreach (var vertex in loopVertices)
-                    {
-                        var brepVertex = brep.Vertices.Add(new Point3d(vertex.Position.X, vertex.Position.Y, vertex.Position.Z), DistanceTolerance);
-                        loopVerticesDic.Add(vertex.ParasolidTag, brepVertex);
-                    }
-
-                    var brepLoop = brep.Loops.Add(currentLoop.Type == NXOpen.Extensions.Topology.LoopType.Inner ? BrepLoopType.Inner : BrepLoopType.Outer, brepFace);
-
-                    foreach (var loopEdge in currentLoop.Edges)
-                    {
-                        var brepCurve3dIndex = brep.Curves3D.Add(loopEdge.ToCurve().ToRhino());
-
-                        var brepEdge = brep.Edges.Add(loopVerticesDic[loopEdge.GetParasolidVertices()[0].ParasolidTag], loopVerticesDic[loopEdge.GetParasolidVertices()[1].ParasolidTag], brepCurve3dIndex, Globals.DistanceTolerance);
-
-                        var curve2D = brep.Curves2D.Add(CreateTrimmingCurve());
-
-                        // Create new trim topology that references edge, direction
-                        // reletive to edge, loop and trim curve geometry
-                        var trim = brep.Trims.Add(brepEdge, false, brepLoop, curve2D);
-                        trim.IsoStatus = IsoStatus.None;
-
-                        // This one Brep face, so all trims are boundary ones.
-                        trim.TrimType = BrepTrimType.Boundary;
-
-                        // This simple example is exact - for models with
-                        // non-exact data, set tolerance as explained in
-                        // definition of BrepTrim.
-                        trim.SetTolerances(0.0, 0.0);
-                    }
-
-                    continue;
-
-
-
-
-
-
-
-
-
-
-
-
-
-                    var edges = currentLoop.Edges;
-                    if (face.GetSense() == NXOpen.Sense.Reverse)
-                        edges = edges.Reverse().ToArray();
-
-                    var loop = new BrepBoundary()
-                    {
-                        type = BrepLoopType.Unknown,
-                        edges = new List<BrepEdge>(edges.Length),
-                        trims = new PolyCurve(),
-                        orientation = new List<NXOpen.Sense>(edges.Length),
-                    };
-
-                    foreach (var edge in edges)
-                    {
-                        var brepEdge = default(BrepEdge);
-                        var curve = edge.ToCurve();
-                        if (brepEdges?.TryGetValue(edge, out brepEdge) != true)
-                        {
-                            if (curve is null)
-                                continue;
-
-                            var curveIndex = brep.AddEdgeCurve(curve.ToRhino());
-
-                            brepEdge = brep.Edges.Add(loopVerticesDic[edge.GetParasolidVertices()[0].ParasolidTag], loopVerticesDic[edge.GetParasolidVertices()[1].ParasolidTag], curveIndex, Globals.DistanceTolerance);
-                            //brepEdge.SetStartPoint = loopVerticesDic[edge.Vertices[0]];
-                            brepEdges?.Add(edge, brepEdge);
-                        }
-
-                        loop.edges.Add(brepEdge);
-
-                        Rhino.Geometry.Curve segment = null;
-
-                        var currentEdgeFin = currentLoop.Fins.FirstOrDefault(obj => obj.Edge.Tag == edge.Tag);
-                        if (currentEdgeFin.Sense == NXOpen.Sense.Reverse)
-                        {
-                            unsafe
-                            {
-                                TheUfSession.Ps.AskPsTagOfObject(edge.Tag, out var edgePsTag);
-
-                                PK.CURVE_t edgeCurve;
-                                PK.EDGE.ask_curve(new PK.EDGE_t((int)edgePsTag), &edgeCurve);
-
-                                PK.CURVE_t reversedPsCurve;
-                                PK.CURVE.make_curve_reversed(edgeCurve, &reversedPsCurve);
-
-                                //TheUfSession.Ps.AskObjectOfPsTag((NXOpen.Tag)reversedPsCurve.Value, out var reversedCurve);
-
-                                //segment = (reversedCurve.GetTaggedObject() as NXOpen.Curve).ToRhino();
-                            }
-                        }
-
-                        segment = curve.ToRhino();
-
-                        loop.orientation.Add(currentEdgeFin.Sense);
-
-                        var trim = surface.Pullback(segment, DistanceTolerance);
-                        loop.trims.Append(trim);
-                    }
-
-                    loop.trims.MakeClosed(DistanceTolerance);
-
-                    switch (loop.trims.ClosedCurveOrientation())
-                    {
-                        case CurveOrientation.Undefined:
-                            loop.type = BrepLoopType.Unknown;
-                            break;
-                        case CurveOrientation.Clockwise:
-                            loop.type = parametricOrientation ? BrepLoopType.Inner : BrepLoopType.Outer;
-                            break;
-                        case CurveOrientation.CounterClockwise:
-                            loop.type = parametricOrientation ? BrepLoopType.Outer : BrepLoopType.Inner;
-                            break;
-                        default:
-                            break;
-                    }
-
-                    edgeLoops.Add(loop);
-                }
-
-                var outerLoops = edgeLoops.Where(obj => obj.type == BrepLoopType.Outer);
-                var innerLoops = edgeLoops.Where(obj => obj.type == BrepLoopType.Inner);
-
-                // 灏嗚竟鐨� Loops 褰掔被鍒� shells 閲嶏紝浣垮閮╨oop涓虹涓�涓�
-                shells = outerLoops.Select(obj => new List<BrepBoundary>() { obj }).ToArray();
-
-                if (shells.Length == 1)
-                {
-                    shells[0].AddRange(innerLoops);
-                }
-                else
-                {
-                    foreach (var edgeLoop in innerLoops)
-                    {
-                        foreach (var shell in shells)
-                        {
-                            var containment = Curve.PlanarClosedCurveRelationship(edgeLoop.trims, shell[0].trims, Plane.WorldXY, DistanceTolerance);
-                            if (containment == RegionContainment.AInsideB)
-                            {
-                                shell.Add(edgeLoop);
-                                break;
-                            }
-                        }
-                    }
-                }
-
-                return si;
-
-
-                //// 1銆� 娣诲姞椤剁偣  2銆佸垱寤�3D 鏇茬嚎
-                //var faceEdges = face.GetEdges();
-                //for (int i = 0; i < faceEdges.Length; i++)
-                //{
-                //    var vertices = faceEdges[i].GetVertices();
-                //    brep.Vertices.Add(vertices.startPoint3d.ToRhino(), DistanceTolerance);
-                //    brep.Vertices.Add(vertices.endPoint3d.ToRhino(), DistanceTolerance);
-
-                //    TheUfSession.Modl.CreateCurveFromEdge(faceEdges[i].Tag, out var edgeCurveTag);
-                //    brep.Curves3D.Add((edgeCurveTag.GetTaggedObject() as NXOpen.Curve).ToRhino());
-                //}
-
-                //// 3銆佸垱寤鸿竟
-                //for (int i = 0; i < faceEdges.Length; i++)
-                //{
-                //    brep.Edges.Add(i * 2, i * 2 + 1, i, 0.0);
-                //}
-
-                //// 4銆佸垱寤烘洸闈�
-                //int si = brep.AddSurface(surface);
-
-                //// 5銆佷慨鍓�
-                //BrepFace brepFace = brep.Faces.Add(si);
-                //Surface brepSurface = brep.Surfaces[brepFace.SurfaceIndex];
-
-                //Snap.NX.Face snapFace = Snap.NX.Face.Wrap(face.Tag);
-                //Snap.Topology.Loop[] snapFaceLoops = snapFace.Loops;
-
-                //for (int i = 0; i < snapFaceLoops.Length; i++)
-                //{
-                //    var loop = brep.Loops.Add((BrepLoopType)snapFaceLoops[i].Type, brepFace);
-
-                //    var finCount = snapFaceLoops[i].Fins.Length;
-                //    for (int e = 0; e < finCount; ++e)
-                //    {
-                //        var currentFin = snapFaceLoops[i].Fins[e];
-
-                //        var rhinoCurve = (snapFaceLoops[i].Fins[e].Edge.ToCurve().NXOpenTaggedObject as NXOpen.Curve).ToRhino();
-
-                //        int ti = brep.AddTrimCurve(rhinoCurve);
-
-                //        brep.Trims.Add(currentFin.Sense == Snap.Topology.Sense.Positive, loop, ti);
-                //    }
-                //}
-
-                //shells = null;
-
-                //return 0;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-            }
-
-            shells = default;
-            return -1;
-        }
-
-        private static Curve CreateTrimmingCurve()
-        {
-            // A trimming curve is a 2d curve whose image lies in the surface's domain.
-            // The "active" portion of the surface is to the left of the trimming curve.
-            // An outer trimming loop consists of a simple closed curve running 
-            // counter-clockwise around the region it trims.
-            //
-            // An inner trimming loop consists of a simple closed curve running 
-            // clockwise around the region the hole.
-
-            var curve = new LineCurve(new Point2d(0.0, 0.0), new Point2d(1.0, 1.0)) { Domain = new Interval(0.0, 1.0) };
-
-            return curve;
-        }
-
-        static void TrimSurface(Brep brep, int surface, bool orientationIsReversed, List<BrepBoundary>[] shells)
-        {
-            foreach (var shell in shells)
-            {
-                BrepFace brepFace = brep.Faces.Add(surface);
-                brepFace.OrientationIsReversed = orientationIsReversed;
-
-                foreach (var loop in shell)
-                {
-                    var brepLoop = brep.Loops.Add(loop.type, brepFace);
-
-                    var edgeCount = loop.edges.Count;
-                    for (int e = 0; e < edgeCount; ++e)
-                    {
-                        var brepEdge = loop.edges[e];
-
-                        int orientation = (int)loop.orientation[e];
-                        if (orientation == 0)
-                            continue;
-
-                        if (loop.trims.SegmentCurve(e) is Curve trim)
-                        {
-                            int ti = brep.AddTrimCurve(trim);
-                            brep.Trims.Add(brepEdge, orientation < 0, brepLoop, ti);
-                        }
-                    }
-
-                    brep.Trims.MatchEnds(brepLoop);
-                }
-            }
-        }
-
-        public static Brep ToRhinoBrep(NXOpen.Face face)
-        {
-            Brep brep;
-
-            if (face is null)
-                return null;
-
-            brep = new Brep();
-
-            // Set surface
-            var si = AddSurface(brep, face, out List<BrepBoundary>[] shells);
-            if (si < 0)
-                return null;
-
-            // Set edges & trims
-            //Snap.NX.Face snapFace = Snap.NX.Face.Wrap(face.Tag);
-            //TrimSurface(brep, si, snapFace.Sense == Snap.Topology.Sense.Negative, shells);
-
-            // Set vertices
-            //brep.SetVertices();
-
-            // Set flags
-            brep.SetTolerancesBoxesAndFlags
-            (
-              true,
-              true,
-              true,
-              true,
-              true,
-              true,
-              true,
-              true
-            );
-
-            if (!brep.IsValid)
-            {
-#if DEBUG
-                brep.IsValidWithLog(out var log);
-                log.ConsoleWriteLine();
-#endif
-                brep.Repair(DistanceTolerance);
-            }
-
-            return brep;
-        }
-
-        //        public static Brep ToRhino(DB.Solid solid)
-        //        {
-        //            if (solid is null)
-        //                return null;
-
-        //            var brep = new Brep();
-
-        //            if (!solid.Faces.IsEmpty)
-        //            {
-        //                var brepEdges = new Dictionary<DB.Edge, BrepEdge>();
-
-        //                foreach (var face in solid.Faces.Cast<DB.Face>())
-        //                {
-        //                    // Set surface
-        //                    var si = AddSurface(brep, face, out var shells, brepEdges);
-        //                    if (si < 0)
-        //                        continue;
-
-        //                    // Set edges & trims
-        //                    TrimSurface(brep, si, !face.MatchesSurfaceOrientation(), shells);
-        //                }
-
-        //                // Set vertices
-        //                brep.SetVertices();
-
-        //                // Set flags
-        //                brep.SetTolerancesBoxesAndFlags
-        //                (
-        //                  true,
-        //                  true,
-        //                  true,
-        //                  true,
-        //                  true,
-        //                  true,
-        //                  true,
-        //                  true
-        //                );
-
-        //                if (!brep.IsValid)
-        //                {
-        //#if DEBUG
-        //                    brep.IsValidWithLog(out var log);
-        //                    Debug.WriteLine($"{MethodInfo.GetCurrentMethod().DeclaringType.FullName}.{MethodInfo.GetCurrentMethod().Name}()\n{log}");
-        //#endif
-        //                    brep.Repair(Revit.VertexTolerance);
-        //                }
-        //            }
-
-        //            return brep;
-        //        }
-    }
-}
diff --git a/RhinoInside.NX.Translator/Geometry/Raw/Decoder/CurveRawDecoder.cs b/RhinoInside.NX.Translator/Geometry/Raw/Decoder/CurveRawDecoder.cs
deleted file mode 100644
index 48ae818..0000000
--- a/RhinoInside.NX.Translator/Geometry/Raw/Decoder/CurveRawDecoder.cs
+++ /dev/null
@@ -1,104 +0,0 @@
-锘縰sing System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Rhino.Geometry;
-using NXOpen.Extensions;
-using static NXOpen.Extensions.Globals;
-
-namespace RhinoInside.NX.Translator.Geometry.Raw
-{
-    public static partial class RawDecoder
-    {
-        #region Curve
-        public static LineCurve ToRhinoLineCurve(NXOpen.Line line)
-        {
-            return new LineCurve(new Line(ToRhino(line.StartPoint), ToRhino(line.EndPoint)));
-        }
-
-        public static ArcCurve ToRhinoArcCurve(NXOpen.Arc arc)
-        {
-            var circle = new Circle(new Plane(ToRhino(arc.CenterPoint), ToRhino(arc.Matrix.Element.GetAxisX()), ToRhino(arc.Matrix.Element.GetAxisY())), arc.Radius);
-
-            if (Math.Abs((arc.EndAngle - arc.StartAngle) - 2 * Math.PI) < AngleTolerance)
-            {
-                return new ArcCurve(circle);
-            }
-            else
-            {
-                return new ArcCurve(new Arc(circle, new Interval(arc.StartAngle, arc.EndAngle)));
-            }
-        }
-
-        public static NurbsCurve ToRhinoNurbsCurve(NXOpen.Ellipse ellipse)
-        {
-            var plane = new Plane(ToRhino(ellipse.CenterPoint), ToRhino(ellipse.Matrix.Element.GetAxisX()), ToRhino(ellipse.Matrix.Element.GetAxisY()));
-            var e = new Ellipse(plane, ellipse.MajorRadius, ellipse.MinorRadius);
-            var nurbsCurve = e.ToNurbsCurve();
-
-            if (Math.Abs(Math.Abs(ellipse.EndAngle - ellipse.StartAngle) - Math.PI * 2) > DistanceTolerance)
-            {
-                nurbsCurve.ClosestPoint(ToRhino(ellipse.GetPoint(0.0)), out var param0);
-                if (!nurbsCurve.ChangeClosedCurveSeam(param0))
-                    nurbsCurve.Domain = new Interval(param0, param0 + nurbsCurve.Domain.Length);
-
-                nurbsCurve.ClosestPoint(ToRhino(ellipse.GetPoint(1.0)), out var param1);
-                nurbsCurve = nurbsCurve.Trim(param0, param1) as NurbsCurve;
-                nurbsCurve.Domain = new Interval(ellipse.StartAngle / (Math.PI * 2.0), ellipse.EndAngle / (Math.PI * 2.0));
-            }
-
-            return nurbsCurve;
-        }
-
-        public static NurbsCurve ToRhinoNurbsCurve(NXOpen.Spline spline)
-        {
-            var controlPoints = spline.GetPoles();
-            var n = new NurbsCurve(3, spline.Rational, spline.Order, controlPoints.Length);
-
-            if (spline.Rational)
-            {
-                var weights = controlPoints.Select(obj => obj.W).ToArray();
-                int index = 0;
-                foreach (var pt in controlPoints)
-                {
-                    var w = weights[index];
-                    n.Points.SetPoint(index++, pt.X * w, pt.Y * w, pt.Z * w, w);
-                }
-            }
-            else
-            {
-                int index = 0;
-                foreach (var pt in controlPoints)
-                    n.Points.SetPoint(index++, pt.X, pt.Y, pt.Z);
-            }
-
-            var Knots = spline.GetKnots();
-
-            int knotIndex = 0;
-            foreach (var w in Knots.Cast<double>().Skip(1).Take(n.Knots.Count))
-                n.Knots[knotIndex++] = w;
-
-            return n;
-        }
-
-        public static PolylineCurve ToRhinoPolylineCurve(NXOpen.Polyline polyline)
-        {
-            return new PolylineCurve(polyline.GetPoints().Select(x => ToRhino(x)));
-        }
-
-        public static Curve ToRhino(NXOpen.Curve curve)
-        {
-            switch (curve)
-            {
-                case null: return null;
-                case NXOpen.Line line: return ToRhinoLineCurve(line);
-                case NXOpen.Arc arc: return ToRhinoArcCurve(arc);
-                case NXOpen.Ellipse ellipse: return ToRhinoNurbsCurve(ellipse);
-                case NXOpen.Spline nurb: return ToRhinoNurbsCurve(nurb);
-                default: throw new NotImplementedException();
-            }
-        }
-        #endregion
-    }
-}
diff --git a/RhinoInside.NX.Translator/Geometry/Raw/Decoder/SurfaceRawDecoder.cs b/RhinoInside.NX.Translator/Geometry/Raw/Decoder/SurfaceRawDecoder.cs
deleted file mode 100644
index e2813cf..0000000
--- a/RhinoInside.NX.Translator/Geometry/Raw/Decoder/SurfaceRawDecoder.cs
+++ /dev/null
@@ -1,221 +0,0 @@
-锘縰sing System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Rhino.Geometry;
-using NXOpen.Extensions;
-using static NXOpen.Extensions.Globals;
-
-namespace RhinoInside.NX.Translator.Geometry.Raw
-{
-    public static partial class RawDecoder
-    {
-        public static Surface ToRhinoSurface(NXOpen.Face face, out bool parametricOrientation, double relativeTolerance = 0.0)
-        {
-            var faceData = face.GetData();
-            parametricOrientation = faceData.NormalReversed;
-
-            switch (faceData.FaceType)
-            {
-                case NXOpen.Face.FaceType.Planar:
-                    return ToRhinoPlaneSurface(face, relativeTolerance);
-                case NXOpen.Face.FaceType.Conical:
-                    return ToRhinoRevSurface(face, relativeTolerance);
-                case NXOpen.Face.FaceType.Cylindrical:
-                    return FromCylindricalSurface(face, relativeTolerance);
-                case NXOpen.Face.FaceType.Spherical:
-                    return FromSphereSurface(face, relativeTolerance);
-                default: return FromBsurf(face);
-            }
-        }
-
-        /// <summary>
-        /// 鍒涘缓鏈慨鍓殑 Rhino PlaneSurface
-        /// </summary>
-        /// <param name="face"></param>
-        /// <param name="relativeTolerance"></param>
-        /// <returns></returns>
-        static PlaneSurface ToRhinoPlaneSurface(NXOpen.Face face, double relativeTolerance)
-        {
-            double[] facePt = new double[3];
-            double[] direction = new double[3];
-            double[] box = new double[6];
-            TheUfSession.Modl.AskFaceData(face.Tag, out int type, facePt, direction, box, out double radius, out double radData, out int normDir);
-
-            Plane plane = new Plane(new Point3d(facePt[0], facePt[1], facePt[2]), new Vector3d(direction[0], direction[1], direction[2]));
-
-            return PlaneSurface.CreateThroughBox(plane, new BoundingBox(new Point3d(box[0], box[1], box[2]), new Point3d(box[3], box[4], box[5])));
-        }
-
-        static RevSurface ToRhinoRevSurface(NXOpen.Face face, double relativeTolerance)
-        {
-            var bboxUV = face.GetUVBoundingBox();
-            var faceData = face.GetData();
-
-            var atol = relativeTolerance * AngleTolerance * 10.0;
-            var ctol = relativeTolerance * DistanceTolerance;
-            var uu = new Interval(bboxUV.Min.U - atol, bboxUV.Max.U + atol);
-            var vv = new Interval(bboxUV.Min.V - ctol, bboxUV.Max.V + ctol);
-
-            var plane = new Plane(ToRhino(faceData.Point), ToRhino(faceData.Direction));
-
-            var dir = ToRhino(faceData.Direction) + Math.Tan(faceData.RadiusData) * plane.XAxis;
-            dir.Unitize();
-
-            var curve = new LineCurve
-            (
-              new Line
-              (
-                plane.Origin + (vv.Min * dir),
-                plane.Origin + (vv.Max * dir)
-              ),
-              vv.Min,
-              vv.Max
-            );
-
-            var axis = new Line(plane.Origin, plane.Normal);
-            return RevSurface.Create(curve, axis, uu.Min, uu.Max);
-        }
-
-        static RevSurface FromSphereSurface(NXOpen.Face face, double relativeTolerance)
-        {
-            var faceData = face.GetData();
-
-            return RevSurface.CreateFromSphere(new Sphere(ToRhino(faceData.Point), faceData.Radius));
-        }
-
-        static RevSurface FromCylindricalSurface(NXOpen.Face face, double relativeTolerance)
-        {
-            var bboxUV = face.GetUVBoundingBox();
-            var faceData = face.GetData();
-
-            var atol = relativeTolerance * AngleTolerance;
-            var ctol = relativeTolerance * DistanceTolerance;
-            var uu = new Interval(bboxUV.Min.U - atol, bboxUV.Max.U + atol);
-            var vv = new Interval(bboxUV.Min.V - ctol, bboxUV.Max.V + ctol);
-
-            var plane = new Plane(ToRhino(faceData.Point), ToRhino(faceData.Direction));
-
-            var curve = new LineCurve
-            (
-              new Line
-              (
-                plane.Origin + (faceData.Radius * plane.XAxis) + (vv.Min * ToRhino(faceData.Direction)),
-                plane.Origin + (faceData.Radius * plane.XAxis) + (vv.Max * ToRhino(faceData.Direction))
-              ),
-              vv.Min,
-              vv.Max
-            );
-
-            var axis = new Line(plane.Origin, plane.Normal);
-            return RevSurface.Create(curve, axis, uu.Min, uu.Max);
-        }
-
-
-
-
-
-
-
-        //        public static NurbsSurface ToRhinoSurface(DB.HermiteFace face, double relativeTolerance)
-        //        {
-        //            NurbsSurface nurbsSurface = default;
-        //            try
-        //            {
-        //#if REVIT_2021
-        //        using (var surface = DB.ExportUtils.GetNurbsSurfaceDataForSurface(face.GetSurface()))
-        //          nurbsSurface = ToRhino(surface, face.GetBoundingBox());
-        //#else
-        //                using (var surface = DB.ExportUtils.GetNurbsSurfaceDataForFace(face))
-        //                    nurbsSurface = ToRhino(surface, face.GetBoundingBox());
-        //#endif
-        //            }
-        //            catch (Autodesk.Revit.Exceptions.ApplicationException) { }
-
-        //            if (nurbsSurface is null)
-        //            {
-        //                nurbsSurface = FromHermiteSurface
-        //                (
-        //                  face.Points,
-        //                  face.MixedDerivs,
-        //                  face.get_Params(0).Cast<double>().ToArray(),
-        //                  face.get_Params(1).Cast<double>().ToArray(),
-        //                  face.get_Tangents(0),
-        //                  face.get_Tangents(1)
-        //                );
-        //            }
-
-        //            if (nurbsSurface is object)
-        //            {
-        //                double ctol = relativeTolerance * Revit.ShortCurveTolerance * 5.0;
-        //                if (ctol != 0.0)
-        //                {
-        //                    // Extend using smooth way avoids creating C2 discontinuities
-        //                    nurbsSurface = nurbsSurface.Extend(IsoStatus.West, ctol, true) as NurbsSurface ?? nurbsSurface;
-        //                    nurbsSurface = nurbsSurface.Extend(IsoStatus.East, ctol, true) as NurbsSurface ?? nurbsSurface;
-        //                    nurbsSurface = nurbsSurface.Extend(IsoStatus.South, ctol, true) as NurbsSurface ?? nurbsSurface;
-        //                    nurbsSurface = nurbsSurface.Extend(IsoStatus.North, ctol, true) as NurbsSurface ?? nurbsSurface;
-        //                }
-        //            }
-
-        //            return nurbsSurface;
-        //        }
-
-        public static NurbsSurface FromBsurf(NXOpen.Face face)
-        {
-            //throw new NotImplementedException("鏇查潰杞崲灏氭湭瀹屾垚");
-
-            TheUfSession.Modl.AskBsurf(face.Tag, out var surface);
-
-            var degreeU = surface.order_u - 1;
-            var degreeV = surface.order_v - 1;
-
-            var knotsU = surface.knots_u;
-            var knotsV = surface.knots_v;
-
-            int controlPointCountU = knotsU.Length - degreeU - 1;
-            int controlPointCountV = knotsV.Length - degreeV - 1;
-
-            var nurbsSurface = NurbsSurface.Create(3, surface.is_rational == 1, degreeU + 1, degreeV + 1, controlPointCountU, controlPointCountV);
-
-            //var controlPoints = surface.poles;
-            //var weights = surface.GetWeights();
-
-            //var points = nurbsSurface.Points;
-            //for (int u = 0; u < controlPointCountU; u++)
-            //{
-            //    int u_offset = u * controlPointCountV;
-            //    for (int v = 0; v < controlPointCountV; v++)
-            //    {
-            //        var pt = controlPoints[u_offset + v];
-            //        if (surface.is_rational == 1)
-            //        {
-            //            double w = weights[u_offset + v];
-            //            points.SetPoint(u, v, pt.X * w, pt.Y * w, pt.Z * w, w);
-            //        }
-            //        else
-            //        {
-            //            points.SetPoint(u, v, pt.X, pt.Y, pt.Z);
-            //        }
-            //    }
-            //}
-
-            //{
-            //    var knots = nurbsSurface.KnotsU;
-            //    int index = 0;
-            //    foreach (var w in knotsU.Skip(1).Take(knots.Count))
-            //        knots[index++] = w;
-            //}
-
-            //{
-            //    var knots = nurbsSurface.KnotsV;
-            //    int index = 0;
-            //    foreach (var w in knotsV.Skip(1).Take(knots.Count))
-            //        knots[index++] = w;
-            //}
-
-            return nurbsSurface;
-        }
-    }
-}
diff --git a/RhinoInside.NX.Translator/Geometry/UnitConverter.cs b/RhinoInside.NX.Translator/Geometry/UnitConverter.cs
index ed11799..2617412 100644
--- a/RhinoInside.NX.Translator/Geometry/UnitConverter.cs
+++ b/RhinoInside.NX.Translator/Geometry/UnitConverter.cs
@@ -24,8 +24,6 @@ public static class UnitConverter
         /// Factor for converting a value from Rhino model units to NX internal units.
         /// </summary>
         public static double RhinoToNXUnitsRatio => RhinoMath.UnitScale(RhinoDoc.ActiveDoc?.ModelUnitSystem ?? UnitSystem.Millimeters, PartUnit.ToRhinoUnits());
-
-
         #endregion
 
         #region Scale
diff --git a/RhinoInside.NX.Translator/RhinoInside.NX.Translator.csproj b/RhinoInside.NX.Translator/RhinoInside.NX.Translator.csproj
index 6332b6d..0b356fd 100644
--- a/RhinoInside.NX.Translator/RhinoInside.NX.Translator.csproj
+++ b/RhinoInside.NX.Translator/RhinoInside.NX.Translator.csproj
@@ -62,18 +62,19 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Geometry\BrepEncoder.cs" />
-    <Compile Include="Geometry\CurveDecoder.cs" />
+    <Compile Include="Geometry\Decoder\CurveDecoder.cs" />
     <Compile Include="Geometry\CurveEncoder.cs" />
+    <Compile Include="Geometry\Decoder\PointDecoder.cs" />
+    <Compile Include="Geometry\Decoder\PointRawDecoder.cs" />
     <Compile Include="Geometry\GeometryDecoder.cs" />
     <Compile Include="Geometry\PointEncoder.cs" />
+    <Compile Include="Geometry\Decoder\SurfaceDcoder.cs" />
     <Compile Include="Geometry\Raw\Encoder\BrepRawEncoder.cs" />
     <Compile Include="Geometry\Raw\Encoder\CurveRawEncoder.cs" />
-    <Compile Include="Geometry\Raw\Decoder\BrepRawDecoder.cs" />
-    <Compile Include="Geometry\Raw\Decoder\CurveRawDecoder.cs" />
-    <Compile Include="Geometry\Raw\Decoder\StructuresRawDecoder.cs" />
+    <Compile Include="Geometry\Decoder\CurveRawDecoder.cs" />
     <Compile Include="Geometry\Raw\Encoder\MeshRawEncoder.cs" />
     <Compile Include="Geometry\Raw\Encoder\StructuresRawEncoder.cs" />
-    <Compile Include="Geometry\Raw\Decoder\SurfaceRawDecoder.cs" />
+    <Compile Include="Geometry\Decoder\SurfaceRawDecoder.cs" />
     <Compile Include="Geometry\ShapeEncoder.cs" />
     <Compile Include="Geometry\UnitConverter.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />