예제 #1
0
        public override Curve[] GetRailCurves(List <Curve> curves)
        {
            var bounds = AcadObjects.First().ObjectId.QOpenForRead <Entity>().Bounds.Value;

            var pts   = curves.SelectMany(p => p.GetStartEndPoints()).ToList();
            var p0    = pts.OrderBy(p => p.DistanceTo(bounds.MaxPoint)).First();
            var rail0 = curves.Where(p => p.HasPoint(p0)).OrderBy(p => Math.Min(p.StartPoint.Z, p.EndPoint.Z)).First();

            if (rail0.StartPoint.Z < rail0.EndPoint.Z)
            {
                rail0.ReverseCurve();
            }
            var p1    = pts.OrderBy(p => p.DistanceTo(bounds.MinPoint)).First();
            var rail1 = curves.Where(p => p.HasPoint(p1)).OrderBy(p => Math.Max(p.StartPoint.Z, p.EndPoint.Z)).Last();

            return(new Curve[] { rail0, rail1 });
        }
예제 #2
0
        public void BuildProcessing(CableCommandGenerator generator)
        {
            var offsetDistance = TechProcess.ToolThickness / 2 + Delta;
            var dbObject       = AcadObjects.First().ObjectId.QOpenForRead();

            if (AcadObjects.Count == 2)
            {
                var matrix     = Matrix3d.Displacement(Vector3d.ZAxis * offsetDistance);
                var railCurves = AcadObjects.Select(p => (Curve)p.ObjectId.QOpenForRead <Curve>().GetTransformedCopy(matrix))
                                 .Select(p => new Line(p.StartPoint, p.EndPoint)).ToArray();
                if (railCurves[0].StartPoint.GetVectorTo(railCurves[0].EndPoint).GetAngleTo(railCurves[1].StartPoint.GetVectorTo(railCurves[1].EndPoint)) > Math.PI / 2)
                {
                    railCurves[1].ReverseCurve();
                }

                if (IsRevereseDirection)
                {
                    railCurves[0].ReverseCurve();
                    railCurves[1].ReverseCurve();
                }

                var points = new List <Point3d[]>();
                if (Approach > 0)
                {
                    points.Add(railCurves.Select(p => p.StartPoint.GetExtendedPoint(p.EndPoint, Approach)).ToArray());
                }
                //if (Approach < 0)
                //    zStart += Approach;
                points.Add(railCurves.Select(p => p.StartPoint).ToArray());
                points.Add(railCurves.Select(p => Departure >= 0 ? p.EndPoint : p.GetPointAtDist(p.Length + Departure)).ToArray());
                if (Departure > 0)
                {
                    points.Add(railCurves.Select(p => p.EndPoint.GetExtendedPoint(p.StartPoint, Departure)).ToArray());
                }

                generator.GCommand(0, points[0][0], points[0][1], IsRevereseAngle);

                for (int i = 1; i < points.Count; i++)
                {
                    generator.GCommand(1, points[i][0], points[i][1]);
                }

                return;
            }

            if (dbObject is Line rail)
            {
                var matrix = Matrix3d.Displacement(Vector3d.ZAxis * offsetDistance);
                rail = (Line)rail.GetTransformedCopy(matrix);

                //if (railCurves[0].StartPoint.GetVectorTo(railCurves[0].EndPoint).GetAngleTo(railCurves[1].StartPoint.GetVectorTo(railCurves[1].EndPoint)) > Math.PI / 2)
                //    railCurves[1].ReverseCurve();

                var points = new List <Point3d>();
                if (Approach > 0)
                {
                    points.Add(rail.StartPoint.GetExtendedPoint(rail.EndPoint, Approach));
                }
                //if (Approach < 0)
                //    zStart += Approach;
                points.Add(rail.StartPoint);
                points.Add(rail.EndPoint);
                if (Departure > 0)
                {
                    points.Add(rail.EndPoint.GetExtendedPoint(rail.StartPoint, Departure));
                }

                foreach (var point in points)
                {
                    var line = new Line3d(point, rail.Delta.GetPerpendicularVector());
                    if (point == points[0])
                    {
                        generator.GCommand(0, line);
                    }
                    else
                    {
                        generator.GCommand(1, line);
                    }
                }

                return;
            }


            var surface = dbObject as DbSurface;

            if (dbObject is Region region)
            {
                var planeSurface = new PlaneSurface();
                planeSurface.CreateFromRegion(region);
                surface = planeSurface;
            }

            surface.GeometricExtents.GetCenter();
            var basePoint = surface.GeometricExtents.GetCenter();

            if (IsRevereseOffset)
            {
                offsetDistance *= -1;
            }
            var offsetSurface   = DbSurface.CreateOffsetSurface(surface, offsetDistance);
            var basePointOffset = offsetSurface.GeometricExtents.GetCenter();

            //if (curves[0] is Region r)
            //{
            //    curves.Clear();
            //    r.Explode(curves);
            //}
            //var plane = offsetSurface.GetPlane();

            var curves = new DBObjectCollection();

            offsetSurface.Explode(curves);
            var pts      = curves.Cast <Curve>().SelectMany(p => p.GetStartEndPoints()).OrderBy(x => x.Z).ToList();
            var maxPoint = pts.Last();
            var minPoint = pts.First();

            if (maxPoint.Z - minPoint.Z < 10) // горизонтальная
            {
                var matrix        = Matrix3d.Displacement(Vector3d.ZAxis * offsetDistance);
                var railCurvesAll = curves.Cast <Curve>().ToList();
                var railCurves    = new Curve[2];
                var rc            = railCurvesAll.Where(p => p.HasPoint(maxPoint)).OrderBy(p => p.Length());
                railCurves[0] = Across ?  rc.First() : rc.Last();
                railCurves[1] = railCurvesAll.Where(p => !p.HasPoint(railCurves[0].StartPoint) && !p.HasPoint(railCurves[0].EndPoint)).First();

                if (railCurves[0].StartPoint.GetVectorTo(railCurves[0].EndPoint).GetAngleTo(railCurves[1].StartPoint.GetVectorTo(railCurves[1].EndPoint)) > Math.PI / 2)
                {
                    railCurves[1].ReverseCurve();
                }

                if (IsRevereseDirection)
                {
                    railCurves[0].ReverseCurve();
                    railCurves[1].ReverseCurve();
                }

                var points = new List <Point3d[]>();
                if (Approach > 0)
                {
                    points.Add(railCurves.Select(p => p.StartPoint.GetExtendedPoint(p.EndPoint, Approach)).ToArray());
                }
                points.Add(railCurves.Select(p => Approach >= 0 ? p.StartPoint : p.GetPointAtDist(-Approach)).ToArray());
                points.Add(railCurves.Select(p => p.EndPoint).ToArray());
                if (Departure > 0)
                {
                    points.Add(railCurves.Select(p => p.EndPoint.GetExtendedPoint(p.StartPoint, Departure)).ToArray());
                }

                generator.GCommand(0, points[0][0], points[0][1], IsRevereseAngle);

                for (int i = 1; i < points.Count; i++)
                {
                    generator.GCommand(1, points[i][0], points[i][1]);
                }

                return;
            }


            var baseCurves = curves.Cast <Curve>().Where(p => p.HasPoint(maxPoint)).ToArray();

            var plane = new Plane(maxPoint, baseCurves[0].EndPoint - baseCurves[0].StartPoint, baseCurves[1].EndPoint - baseCurves[1].StartPoint);

            var zStart = pts.Last().Z;
            var zEnd   = pts.First().Z;
            var zPos   = new List <double>();

            if (Approach > 0)
            {
                zPos.Add(zStart + Approach);
            }
            if (Approach < 0)
            {
                zStart += Approach;
            }
            zPos.Add(zStart);
            if (Departure < 0)
            {
                zEnd -= Departure;
            }
            zPos.Add(zEnd);
            if (Departure > 0)
            {
                zPos.Add(zEnd - Departure);
            }

            foreach (var z in zPos)
            {
                var line = plane.IntersectWith(new Plane(new Point3d(0, 0, z), Vector3d.ZAxis));
                var u    = line.GetDistanceTo(new Point3d(TechProcess.OriginX, TechProcess.OriginY, z));
                if (z == zPos[0])
                {
                    //var angle = line.Direction.ToVector2d().MinusPiToPiAngleTo(Vector2d.YAxis);
                    //generator.GCommandAngle(line.Direction.ToVector2d(), S);
                    //generator.GCommand(0, u);
                    //generator.GCommand(0, u, z);
                    generator.GCommand(0, line, IsRevereseAngle);
                }
                else
                {
                    generator.GCommand(1, line);
                    //generator.GCommand(1, u, z, CuttingFeed);
                }
            }
        }
예제 #3
0
        public void BuildProcessing(CableCommandGenerator generator)
        {
            //var dbObject = ProcessingArea.ObjectId.QOpenForRead();
            var surface        = AcadObjects.First().ObjectId.QOpenForRead <DbSurface>();
            var offsetDistance = TechProcess.ToolThickness / 2 + Delta;

            if (IsRevereseOffset)
            {
                offsetDistance *= -1;
            }
            //var offsetSurface = DbSurface.CreateOffsetSurface(surface, offsetDistance);
            var collection = new DBObjectCollection();

            surface.Explode(collection);

            var curves    = collection.Cast <Curve>().ToList();
            var vertex    = curves.SelectMany(p => p.GetStartEndPoints()).OrderBy(p => p.Z).ToList();
            var maxPoint  = vertex.Last();
            var minPoint  = vertex.First();
            var maxCurves = curves.FindAll(p => p.HasPoint(maxPoint));
            var minCurves = curves.FindAll(p => p.HasPoint(minPoint));

            //var rail1s = new List<Curve>
            //{
            //    maxCurves[0],
            //    minCurves.Single(p => p.HasPoint(maxCurves[0].StartPoint) || p.HasPoint(maxCurves[0].EndPoint))
            //};
            //var rail2s = new List<Curve>
            //{
            //    maxCurves[1],
            //    minCurves.Single(p => p != rail1s[1])
            //};

            //var rail1 = ((Spline)maxCurves[0]).ToPolyline(); // GetRail(maxPoint, maxCurves[0], minCurves.Single(p => p.HasPoint(maxCurves[0].StartPoint) || p.HasPoint(maxCurves[0].EndPoint)));
            //var rail2 = ((Spline)maxCurves[1]).ToPolyline(); //  GetRail(maxPoint, maxCurves[1], minCurves.Single(p => p.HasPoint(maxCurves[1].StartPoint) || p.HasPoint(maxCurves[1].EndPoint)));

            var rail1 = new Rail(maxPoint, maxCurves[0], curves);
            var rail2 = new Rail(maxPoint, maxCurves[1], curves);

            //var length1 = rail1.GetDistanceAtParameter(rail1.EndParam);
            //var length2 = rail2.GetDistanceAtParameter(rail2.EndParam);
            //double dist1 = 0;
            //double dist2 = 0;
            double step = 2;

            generator.Feed   = CuttingFeed;
            generator.S      = S;
            generator.Center = new Point2d(TechProcess.OriginX, TechProcess.OriginY);

            while (!rail1.IsEnd && !rail2.IsEnd)
            {
                var pt1 = rail1.Step(step);
                var pt2 = rail2.Step(step);

                if (pt2.Z - pt1.Z > 2)
                {
                    rail2.StepToZ(pt1.Z, 0.1);
                }
                else
                if (pt1.Z - pt2.Z > 2)
                {
                    rail1.StepToZ(pt2.Z, 0.1);
                }

                //dist1 += step;
                //if (dist1 >= length1)
                //    break;
                //var pt1 = rail1.GetPointAtDist(dist1);

                //dist2 += step;
                //if (dist2 >= length2)
                //    break;
                //var pt2 = rail2.GetPointAtDist(dist2);

                //if (pt1.Z < pt2.Z)
                //{
                //    var dist = dist2;
                //    var pt = pt2;
                //    while(dist < length2 && pt.Z > pt1.Z)
                //    {
                //        dist2 = dist;
                //        pt2 = pt;

                //        dist += step;
                //        pt = rail2.GetPointAtDist(dist);
                //    }
                //    if (dist < length2 && pt1.Z - pt.Z < pt2.Z - pt1.Z)
                //    {
                //        dist2 = dist;
                //        pt2 = pt;
                //    }
                //}
                //else
                //{
                //    var dist = dist1;
                //    var pt = pt1;
                //    while (dist < length1 && pt.Z > pt2.Z)
                //    {
                //        dist1 = dist;
                //        pt1 = pt;

                //        dist += step;
                //        pt = rail1.GetPointAtDist(dist);
                //    }
                //    if (dist < length1 && pt2.Z - pt.Z < pt1.Z - pt2.Z)
                //    {
                //        dist1 = dist;
                //        pt1 = pt;
                //    }
                //}

                generator.GCommand(1, rail1.Point, rail2.Point);
            }
        }