Example #1
0
        private Topologic.Wire ByPolylineCurve(PolylineCurve ghPolylineCurve)
        {
            int numPoints = ghPolylineCurve.PointCount;

            if (numPoints < 1)
            {
                return(null);
            }

            List <Topologic.Vertex> vertices = new List <Topologic.Vertex>();
            List <int> indices = new List <int>();

            for (int i = 0; i < numPoints; ++i)
            {
                Point3d          ghPoint = ghPolylineCurve.Point(i);
                Topologic.Vertex vertex  = ByPoint(ghPoint);
                vertices.Add(vertex);
                indices.Add(i);
            }

            if (ghPolylineCurve.IsClosed)
            {
                //vertices.Add(vertices[0]);
                //indices.Add(0);
                List <List <int> > listOfIndices = new List <List <int> >();
                listOfIndices.Add(indices);
                return(Topologic.Topology.ByVerticesIndices(vertices, listOfIndices)[0].Wires[0]);
            }
            else
            {
                List <List <int> > listOfIndices = new List <List <int> >();
                listOfIndices.Add(indices);
                return(Topologic.Topology.ByVerticesIndices(vertices, listOfIndices)[0] as Topologic.Wire);
            }
        }
Example #2
0
        //private void ProcessFace(
        //    Wire wire, ref Brep ghBrep, BrepFace ghBrepFace, BrepLoopType ghBrepLoopType, Rhino.Geometry.Surface ghSurface,
        //    Dictionary<Edge, Tuple<int, int>> edge2DIndices, Dictionary<Edge, BrepEdge> edgeIndices)
        //{
        //    List<Edge> edges = wire.Edges;
        //    BrepLoop ghBrepLoop = ghBrep.Loops.Add(ghBrepLoopType, ghBrepFace);

        //    // 2f.For each loop, add a trim(2D edge)
        //    List<BrepEdge> ghEdges = new List<BrepEdge>();
        //    List<Tuple<Curve, int, Curve, int>> gh2DCurves = new List<Tuple<Curve, int, Curve, int>>(); // original curve, index, reverse curve, reverse index
        //    foreach (Edge edge in edges)
        //    {
        //        Tuple<int, int> thisEdge2DIndices = edge2DIndices.
        //            Where(edgeIndexPair => edgeIndexPair.Key.IsSame(edge)).
        //            Select(edgeIndexPair => edgeIndexPair.Value).
        //            FirstOrDefault();

        //        int thisEdge2DIndex = thisEdge2DIndices.Item1;
        //        int thisReverseEdge2DIndex = thisEdge2DIndices.Item2;

        //        Curve ghCurve2D = ghBrep.Curves2D[thisEdge2DIndex];
        //        Curve ghReverseCurve2D = ghBrep.Curves2D[thisReverseEdge2DIndex];
        //        gh2DCurves.Add(Tuple.Create(ghCurve2D, thisEdge2DIndex, ghReverseCurve2D, thisReverseEdge2DIndex));

        //        BrepEdge ghBrepEdge = edgeIndices.
        //            Where(edgeIndexPair => edgeIndexPair.Key.IsSame(edge)).
        //            Select(edgeIndexPair => edgeIndexPair.Value).
        //            FirstOrDefault();

        //        String ghBrepEdgeLog = "";
        //        if (!ghBrepEdge.IsValidWithLog(out ghBrepEdgeLog))
        //        {
        //            throw new Exception("Fails to create a valid Brep with the following message: " + ghBrepEdgeLog);
        //        }

        //        ghEdges.Add(ghBrepEdge);
        //    }

        //    for (int currentEntryID = 0; currentEntryID < gh2DCurves.Count; ++currentEntryID)
        //    {
        //        int previousEntryID = currentEntryID - 1;
        //        if (previousEntryID < 0)
        //        {
        //            previousEntryID = edges.Count - 1;
        //        }

        //        bool isCurrentStartEqualToPreviousStart = gh2DCurves[currentEntryID].Item1.PointAtStart.DistanceTo(
        //                                                    gh2DCurves[previousEntryID].Item1.PointAtStart) < tolerance;
        //        bool isCurrentStartEqualToPreviousEnd = gh2DCurves[currentEntryID].Item1.PointAtStart.DistanceTo(
        //                                                    gh2DCurves[previousEntryID].Item1.PointAtEnd) < tolerance;
        //        bool isTrimReversed = false;
        //        if (!isCurrentStartEqualToPreviousStart && !isCurrentStartEqualToPreviousEnd)
        //        {
        //            // Reverse trim
        //            isTrimReversed = true;
        //        }

        //        BrepTrim ghBrepTrim = ghBrep.Trims.Add(
        //            ghEdges[currentEntryID],       // 3D edge
        //            isTrimReversed,                // is reversed?
        //            ghBrepLoop,                    // 2D loop
        //            isTrimReversed ? gh2DCurves[currentEntryID].Item4 : gh2DCurves[currentEntryID].Item2);  // 2D curve index, use the reversed one if reversed

        //        ghBrepTrim.IsoStatus = ghSurface.IsIsoparametric(gh2DCurves[currentEntryID].Item1);
        //        ghBrepTrim.TrimType = BrepTrimType.Boundary;
        //        ghBrepTrim.SetTolerances(0.0, 0.0);

        //        String ghBrepTrimLog = "";
        //        if (!ghBrepTrim.IsValidWithLog(out ghBrepTrimLog))
        //        {
        //            throw new Exception("Fails to create a valid BrepTrim with the following message: " + ghBrepTrimLog);
        //        }
        //    }

        //    String brepLoopLog = "";
        //    if (!ghBrepLoop.IsValidWithLog(out brepLoopLog))
        //    {
        //        throw new Exception("Fails to create a valid outer BrepLoop with the following message: " + brepLoopLog);
        //    }
        //}

        private Rhino.Geometry.NurbsSurface ToRhinoNurbsSurface(Topologic.NurbsSurface nurbsSurface)
        {
            int  uDegree    = nurbsSurface.UDegree;
            int  vDegree    = nurbsSurface.VDegree;
            bool isRational = nurbsSurface.IsURational && nurbsSurface.IsVRational;
            int  uCount     = nurbsSurface.NumOfUControlVertices;
            int  vCount     = nurbsSurface.NumOfVControlVertices;

            Rhino.Geometry.NurbsSurface ghNurbsSurface = Rhino.Geometry.NurbsSurface.Create(
                3,
                isRational,
                uDegree + 1,
                vDegree + 1,
                uCount,
                vCount
                );

            int i = 0;

            for (int u = 0; u < uCount; ++u)
            {
                for (int v = 0; v < vCount; ++v)
                {
                    Topologic.Vertex controlVertex = nurbsSurface.ControlVertex(u, v);
                    ghNurbsSurface.Points.SetPoint(u, v, ToPoint(controlVertex));
                    ++i;
                }
            }

            List <double> uKnots = nurbsSurface.UKnots;

            uKnots = uKnots.GetRange(1, uKnots.Count - 2);
            for (int u = 0; u < uKnots.Count; u++)
            {
                ghNurbsSurface.KnotsU[u] = uKnots[u];
            }

            List <double> vKnots = nurbsSurface.VKnots;

            vKnots = vKnots.GetRange(1, vKnots.Count - 2);
            for (int v = 0; v < vKnots.Count; v++)
            {
                ghNurbsSurface.KnotsV[v] = vKnots[v];
            }

            if (!ghNurbsSurface.IsValid)
            {
                throw new Exception("A valid surface cannot be created from this Face.");
            }

            return(ghNurbsSurface);
        }
Example #3
0
 private Topologic.Edge ByLine(Rhino.Geometry.Line ghLine)
 {
     Topologic.Vertex vertex1 = ByPoint(ghLine.From);
     Topologic.Vertex vertex2 = ByPoint(ghLine.To);
     return(Topologic.Edge.ByStartVertexEndVertex(vertex1, vertex2));
 }