// Meshes
        public Mesh MeshToSpeckle(DS.Mesh mesh, string units = null)
        {
            var u             = units ?? ModelUnits;
            var vertices      = PointListToFlatArray(mesh.VertexPositions);
            var defaultColour = System.Drawing.Color.FromArgb(255, 100, 100, 100);

            var faces = mesh.FaceIndices.SelectMany(f =>
            {
                if (f.Count == 4)
                {
                    return(new int[5] {
                        1, (int)f.A, (int)f.B, (int)f.C, (int)f.D
                    });
                }
                else
                {
                    return(new int[4] {
                        0, (int)f.A, (int)f.B, (int)f.C
                    });
                }
            })
                        .ToArray();

            var colors = Enumerable.Repeat(defaultColour.ToArgb(), vertices.Count()).ToArray();
            //double[] textureCoords;

            //if (SpeckleRhinoConverter.AddMeshTextureCoordinates)
            //{
            //  textureCoords = mesh.TextureCoordinates.Select(pt => pt).ToFlatArray();
            //  return new SpeckleMesh(vertices, faces, Colors, textureCoords, properties: mesh.UserDictionary.ToSpeckle());
            //}

            var speckleMesh = new Mesh(vertices, faces, colors, units: u);

            CopyProperties(speckleMesh, mesh);

            using (var box = ComputeMeshBoundingBox(mesh))
                speckleMesh.bbox = BoxToSpeckle(box, u);

            return(speckleMesh);
        }
        private DS.Cuboid ComputeMeshBoundingBox(DS.Mesh mesh)
        {
            double lowX = double.PositiveInfinity, lowY = double.PositiveInfinity, lowZ = double.PositiveInfinity;
            double highX = double.NegativeInfinity, highY = double.NegativeInfinity, highZ = double.NegativeInfinity;

            mesh.VertexPositions.ForEach(pos =>
            {
                if (pos.X < lowX)
                {
                    lowX = pos.X;
                }
                if (pos.Y < lowY)
                {
                    lowY = pos.Y;
                }
                if (pos.Z < lowZ)
                {
                    lowZ = pos.Z;
                }
                if (pos.X > highX)
                {
                    highX = pos.X;
                }
                if (pos.Y > highY)
                {
                    highY = pos.Y;
                }
                if (pos.Z > highZ)
                {
                    highZ = pos.Z;
                }
            });

            using (var low = DS.Point.ByCoordinates(lowX, lowY, lowZ))
                using (var high = DS.Point.ByCoordinates(highX, highY, highZ))
                    return(DS.Cuboid.ByCorners(low, high));
        }