Example #1
0
            /// <summary>
            /// The constructor.
            /// </summary>
            /// <param name="scope">The associated shape edit scope.</param>
            /// <param name="targetGeometry">The current target geometry.</param>
            /// <param name="fallbackGeometry">The current fallback geometry.</param>
            public IFCTargetSetter(IFCImportShapeEditScope scope, TessellatedShapeBuilderTarget targetGeometry, TessellatedShapeBuilderFallback fallbackGeometry)
            {
                if (scope != null)
                {
                    m_Scope = scope;

                    m_TargetGeometry   = m_Scope.TargetGeometry;
                    m_FallbackGeometry = m_Scope.FallbackGeometry;

                    m_Scope.SetTargetAndFallbackGeometry(targetGeometry, fallbackGeometry);
                }
            }
Example #2
0
        // Insipred by
        // https://github.com/DynamoDS/DynamoRevit/blob/master/src/Libraries/RevitNodes/GeometryConversion/ProtoToRevitMesh.cs
        public IList <GeometryObject> MeshToNative(Mesh mesh)
        {
            TessellatedShapeBuilderTarget   target   = TessellatedShapeBuilderTarget.Mesh;
            TessellatedShapeBuilderFallback fallback = TessellatedShapeBuilderFallback.Salvage;

            var tsb = new TessellatedShapeBuilder()
            {
                Fallback = fallback, Target = target, GraphicsStyleId = ElementId.InvalidElementId
            };

            tsb.OpenConnectedFaceSet(false);

            var vertices = ArrayToPoints(mesh.vertices, mesh.units);

            int i = 0;

            while (i < mesh.faces.Count)
            {
                var points = new List <XYZ>();

                if (mesh.faces[i] == 0)
                { // triangle
                    points = new List <XYZ> {
                        vertices[mesh.faces[i + 1]], vertices[mesh.faces[i + 2]], vertices[mesh.faces[i + 3]]
                    };
                    var face = new TessellatedFace(points, ElementId.InvalidElementId);
                    tsb.AddFace(face);
                    i += 4;
                }
                else
                { // quad
                    points = new List <XYZ> {
                        vertices[mesh.faces[i + 1]], vertices[mesh.faces[i + 2]], vertices[mesh.faces[i + 4]]
                    };
                    var face1 = new TessellatedFace(points, ElementId.InvalidElementId);
                    tsb.AddFace(face1);
                    points = new List <XYZ> {
                        vertices[mesh.faces[i + 2]], vertices[mesh.faces[i + 3]], vertices[mesh.faces[i + 4]]
                    };
                    var face2 = new TessellatedFace(points, ElementId.InvalidElementId);
                    tsb.AddFace(face2);
                    i += 5;
                }
            }

            tsb.CloseConnectedFaceSet();
            tsb.Build();
            var result = tsb.GetBuildResult();

            return(result.GetGeometricalObjects());
        }
        public static IList <GeometryObject> ToRevitType(
            this Autodesk.DesignScript.Geometry.Solid solid,
            TessellatedShapeBuilderTarget target     = TessellatedShapeBuilderTarget.Mesh,
            TessellatedShapeBuilderFallback fallback = TessellatedShapeBuilderFallback.Salvage,
            ElementId MaterialId           = null,
            bool performHostUnitConversion = true)
        {
            var rp = new DefaultRenderPackage();

            if (performHostUnitConversion)
            {
                var newSolid = solid.InHostUnits();
                newSolid.Tessellate(rp, new TessellationParameters());
                newSolid.Dispose();
            }
            else
            {
                solid.Tessellate(rp, new TessellationParameters());
            }

            var tsb = new TessellatedShapeBuilder()
            {
                Fallback = fallback, Target = target, GraphicsStyleId = ElementId.InvalidElementId
            };

            tsb.OpenConnectedFaceSet(false);

            var v = rp.MeshVertices.ToList();

            for (int i = 0; i < v.Count; i += 9)
            {
                var a = new XYZ(v[i], v[i + 1], v[i + 2]);
                var b = new XYZ(v[i + 3], v[i + 4], v[i + 5]);
                var c = new XYZ(v[i + 6], v[i + 7], v[i + 8]);

                var face = new TessellatedFace(new List <XYZ>()
                {
                    a, b, c
                }, MaterialId != null ? MaterialId : MaterialsManager.Instance.DynamoMaterialId);
                tsb.AddFace(face);
            }

            tsb.CloseConnectedFaceSet();
            tsb.Build();
            var result = tsb.GetBuildResult();

            return(result.GetGeometricalObjects());
        }
        public static IList <GeometryObject> ToRevitType(
            this Autodesk.DesignScript.Geometry.Mesh mesh,
            TessellatedShapeBuilderTarget target     = TessellatedShapeBuilderTarget.Mesh,
            TessellatedShapeBuilderFallback fallback = TessellatedShapeBuilderFallback.Salvage,
            ElementId MaterialId           = null,
            bool performHostUnitConversion = true)
        {
            var verts   = mesh.VertexPositions;
            var indices = mesh.FaceIndices;

            var tsb = new TessellatedShapeBuilder()
            {
                Fallback = fallback, Target = target, GraphicsStyleId = ElementId.InvalidElementId
            };

            tsb.OpenConnectedFaceSet(false);

            for (int faceindex = 0, count = indices.Count(); faceindex < count; faceindex++)
            {
                var f = indices[faceindex];
                //if this is a quad face triangulate it
                if (f.Count > 3)
                {
                    //and add two triangles to the tessellated shape builder
                    var tri1 = IndexGroup.ByIndices(f.B, f.C, f.A);
                    var tri2 = IndexGroup.ByIndices(f.A, f.C, f.D);

                    AddFace(tsb, tri1, verts, performHostUnitConversion, MaterialId);
                    AddFace(tsb, tri2, verts, performHostUnitConversion, MaterialId);
                }
                else
                {
                    AddFace(tsb, f, verts, performHostUnitConversion, MaterialId);
                }
            }

            tsb.CloseConnectedFaceSet();

            tsb.Build();
            var result = tsb.GetBuildResult();

            foreach (IDisposable vert in verts)
            {
                vert.Dispose();
            }

            return(result.GetGeometricalObjects());
        }
Example #5
0
        // Insipred by
        // https://github.com/DynamoDS/DynamoRevit/blob/master/src/Libraries/RevitNodes/GeometryConversion/ProtoToRevitMesh.cs
        public IList <GeometryObject> MeshToNative(Mesh mesh, TessellatedShapeBuilderTarget target = TessellatedShapeBuilderTarget.Mesh, TessellatedShapeBuilderFallback fallback = TessellatedShapeBuilderFallback.Salvage)
        {
            var tsb = new TessellatedShapeBuilder()
            {
                Fallback = fallback, Target = target, GraphicsStyleId = ElementId.InvalidElementId
            };

            var valid = tsb.AreTargetAndFallbackCompatible(target, fallback);

            tsb.OpenConnectedFaceSet(target == TessellatedShapeBuilderTarget.Solid);

            var vertices = ArrayToPoints(mesh.vertices, mesh.units);

            int i = 0;

            while (i < mesh.faces.Count)
            {
                int n = mesh.faces[i];
                if (n < 3)
                {
                    n += 3; // 0 -> 3, 1 -> 4 to preserve backwards compatibility
                }
                var points = mesh.faces.GetRange(i + 1, n).Select(x => vertices[x]).ToArray();

                if (IsNonPlanarQuad(points))
                {
                    //Non-planar quads will be triangulated as it's more desirable than `TessellatedShapeBuilder.Build`'s attempt to make them planar.
                    //TODO consider triangulating all n > 3 polygons
                    var triPoints = new List <XYZ> {
                        points[0], points[1], points[3]
                    };
                    var face1 = new TessellatedFace(triPoints, ElementId.InvalidElementId);
                    tsb.AddFace(face1);

                    triPoints = new List <XYZ> {
                        points[1], points[2], points[3]
                    };;
                    var face2 = new TessellatedFace(triPoints, ElementId.InvalidElementId);
                    tsb.AddFace(face2);
                }
                else
                {
                    var face = new TessellatedFace(points, ElementId.InvalidElementId);
                    tsb.AddFace(face);
                }

                i += n + 1;
            }

            tsb.CloseConnectedFaceSet();
            try
            {
                tsb.Build();
            }
            catch (Exception e)
            {
                Report.LogConversionError(e);
                return(null);
            }
            var result = tsb.GetBuildResult();

            return(result.GetGeometricalObjects());
Example #6
0
 /// <summary>
 /// Set the target and fallback geometry for this scope.
 /// </summary>
 /// <param name="targetGeometry">The target geometry.</param>
 /// <param name="fallbackGeometry">The fallback geometry.</param>
 /// <remarks>This should not be directly called, but instead set with the IFCTargetSetter and the "using" scope.</remarks>
 public void SetTargetAndFallbackGeometry(TessellatedShapeBuilderTarget targetGeometry, TessellatedShapeBuilderFallback fallbackGeometry)
 {
     TargetGeometry   = targetGeometry;
     FallbackGeometry = fallbackGeometry;
 }
 /// <summary>
 /// Set the target and fallback geometry for this scope.
 /// </summary>
 /// <param name="targetGeometry">The target geometry.</param>
 /// <param name="fallbackGeometry">The fallback geometry.</param>
 /// <remarks>This should not be directly called, but instead set with the IFCTargetSetter and the "using" scope.</remarks>
 public void SetTargetAndFallbackGeometry(TessellatedShapeBuilderTarget targetGeometry, TessellatedShapeBuilderFallback fallbackGeometry)
 {
     TargetGeometry = targetGeometry;
     FallbackGeometry = fallbackGeometry;
 }
            /// <summary>
            /// The constructor.
            /// </summary>
            /// <param name="scope">The associated shape edit scope.</param>
            /// <param name="targetGeometry">The current target geometry.</param>
            /// <param name="fallbackGeometry">The current fallback geometry.</param>
            public IFCTargetSetter(IFCImportShapeEditScope scope, TessellatedShapeBuilderTarget targetGeometry, TessellatedShapeBuilderFallback fallbackGeometry)
            {
                if (scope != null)
                {
                    m_Scope = scope;

                    m_TargetGeometry = m_Scope.TargetGeometry;
                    m_FallbackGeometry = m_Scope.FallbackGeometry;

                    m_Scope.SetTargetAndFallbackGeometry(targetGeometry, fallbackGeometry);
                }
            }
Example #9
0
        // Insipred by
        // https://github.com/DynamoDS/DynamoRevit/blob/master/src/Libraries/RevitNodes/GeometryConversion/ProtoToRevitMesh.cs
        public IList <GeometryObject> MeshToNative(Mesh mesh, TessellatedShapeBuilderTarget target = TessellatedShapeBuilderTarget.Mesh, TessellatedShapeBuilderFallback fallback = TessellatedShapeBuilderFallback.Salvage)
        {
            var tsb = new TessellatedShapeBuilder()
            {
                Fallback = fallback, Target = target, GraphicsStyleId = ElementId.InvalidElementId
            };

            var valid = tsb.AreTargetAndFallbackCompatible(target, fallback);

            tsb.OpenConnectedFaceSet(target == TessellatedShapeBuilderTarget.Solid);

            var vertices = ArrayToPoints(mesh.vertices, mesh.units);

            int i = 0;

            while (i < mesh.faces.Count)
            {
                var points = new List <XYZ>();

                if (mesh.faces[i] == 0)
                { // triangle
                    points = new List <XYZ> {
                        vertices[mesh.faces[i + 1]], vertices[mesh.faces[i + 2]], vertices[mesh.faces[i + 3]]
                    };
                    var face  = new TessellatedFace(points, ElementId.InvalidElementId);
                    var check = !tsb.DoesFaceHaveEnoughLoopsAndVertices(face);
                    tsb.AddFace(face);
                    i += 4;
                }
                else
                { // quad
                    points = new List <XYZ> {
                        vertices[mesh.faces[i + 1]], vertices[mesh.faces[i + 2]], vertices[mesh.faces[i + 4]]
                    };
                    var face1  = new TessellatedFace(points, ElementId.InvalidElementId);
                    var check1 = tsb.DoesFaceHaveEnoughLoopsAndVertices(face1);
                    tsb.AddFace(face1);
                    points = new List <XYZ> {
                        vertices[mesh.faces[i + 2]], vertices[mesh.faces[i + 3]], vertices[mesh.faces[i + 4]]
                    };
                    var face2  = new TessellatedFace(points, ElementId.InvalidElementId);
                    var check2 = tsb.DoesFaceHaveEnoughLoopsAndVertices(face2);

                    tsb.AddFace(face2);
                    i += 5;
                }
            }

            tsb.CloseConnectedFaceSet();
            try
            {
                tsb.Build();
            }
            catch (Exception e)
            {
                ConversionErrors.Add(e);
                return(null);
            }
            var result = tsb.GetBuildResult();

            return(result.GetGeometricalObjects());
        }