private void MakeBlock(int horLeft, int horRight, int verDown, int verUp, double distX, double distY) { // läuft asynchron backgroundBlock = Block.Construct(); for (int i = -horLeft; i <= horRight; ++i) { if (i != 0) // i=0 ist das Original, soll nicht verdoppelt werden! { GeoObjectList li = new GeoObjectList(); // für jede Kopie ein Clone machen li = originals.CloneObjects(); // AbstandX * Kopienwinkel: GeoVector vect = (i * distX) * dirV; ModOp m = ModOp.Translate(vect); li.Modify(m); backgroundBlock.Add(li); } for (int j = -verDown; j <= verUp; ++j) { if (j != 0) // J=0 ist das Original, soll nicht verdoppelt werden! { GeoObjectList liV = new GeoObjectList(); // für jede Kopie ein Clone machen liV = originals.CloneObjects(); // der senkrechte Winkel auf Kopienwinkel dirV GeoVector dirV_Vert = base.ActiveDrawingPlane.Normal ^ dirV; GeoVector vectV = (i * distX) * dirV + (j * distY) * dirV_Vert; ModOp m = ModOp.Translate(vectV); liV.Modify(m); backgroundBlock.Add(liV); } } } }
private bool showCirc() { block = Block.Construct(); for (int i = 1; i < copCount; ++i) { GeoObjectList li = new GeoObjectList(); // für jede Kopie ein Clone machen li = originals.CloneObjects(); ModOp m = ModOp.Rotate(rotationPoint, base.ActiveDrawingPlane.Normal, i * copAngle); if (!objRot) // Objekte drehen mit: einfach modifizieren { li.Modify(m); } else { // Objekte drehen nicht mit: Translation des gedrehten centerpoints ModOp mt = ModOp.Translate(new GeoVector(centerPoint, m * centerPoint)); li.Modify(mt); } block.Add(li); } if (block.Count > 0) { base.ActiveObject = block; return(true); } else { base.ActiveObject = null; return(false); } }
private void SetPositionPoint(GeoPoint p) { GeoVector move = p - block.RefPoint; ModOp m = ModOp.Translate(move); block.Modify(m); }
public override void OnDone() { // ist die Shift Taste gehalten, so werden Kopien gemacht, d.h. der die Elemente // des blocks werden eingefügt. Ansonsten werden die original-Objekte verändert // TODO: Feedback über Cursor bei Shift-Taste fehlt noch // TODO: die neuen oder veränderten Objekte sollten markiert sein. using (Frame.Project.Undo.UndoFrame) { ModOp m = ModOp.Translate(offset); if (((Frame.UIService.ModifierKeys & Keys.Shift) != 0) || copyObject) { GeoObjectList cloned = new GeoObjectList(); foreach (IGeoObject go in originals) { IGeoObject cl = go.Clone(); cl.Modify(m); // go.Owner.Add(cl); cloned.Add(cl); } base.Frame.Project.GetActiveModel().Add(cloned); } else { originals.Modify(m); } } base.ActiveObject = null; // damit es nicht gleich eingefügt wird base.OnDone(); }
static public void SpaceDown(GeoObjectList gl, Projection projection, Project pr) { using (pr.Undo.UndoFrame) { IGeoObject[] geoArray = new IGeoObject[gl.Count]; for (int i = 0; i < gl.Count; ++i) // umkopieren auf ein Array, um den Sort machen zu können { geoArray[i] = gl[i]; } // hier nun Sort, der Compare steht oben als lokal class und braucht die Parameter: Sort nach y = false und pm Array.Sort(geoArray, 0, geoArray.Length, new CompareGeoObject(false, projection)); // die Rechtecke des ersten und letzten Objeks für die Gesamtausdehnung BoundingRect reStart = IGeoObjectImpl.GetExtent(geoArray[0], projection, false); BoundingRect reEnd = IGeoObjectImpl.GetExtent(geoArray[geoArray.Length - 1], projection, false); double reTotal = reEnd.Top - reStart.Bottom; // Gesamtausdehnung double distRe = 0; for (int i = 0; i < geoArray.Length; ++i) // Summe der Ausdehnung der Einzelnen: { BoundingRect re = IGeoObjectImpl.GetExtent(geoArray[i], projection, false); distRe = distRe + re.Height; } double space = (reTotal - distRe) / (geoArray.Length - 1); // Gesamt - Summe Einzelne / Zwischenräume double pos = reStart.Top; for (int i = 1; i < geoArray.Length - 1; ++i) // vom zweiten bis zum vorletzten, die Äußeren bleiben unverändert { BoundingRect re = IGeoObjectImpl.GetExtent(geoArray[i], projection, false); GeoVector2D trans2D = new GeoVector2D(0, pos + space - re.Bottom); pos = pos + space + re.Height; // pos hochzählen auf den oberen Rand des aktuellen GeoVector trans = projection.DrawingPlane.ToGlobal(trans2D); ModOp m = ModOp.Translate(trans); geoArray[i].Modify(m); } } }
/// <summary> /// Overrides <see cref="CADability.GeoObject.IGeoObjectImpl.PaintTo3D (IPaintTo3D)"/> /// </summary> /// <param name="paintTo3D"></param> public override void PaintTo3D(IPaintTo3D paintTo3D) { ModOp m = ModOp.Translate(location.x, location.y, location.z) * ModOp.Scale(paintTo3D.PixelToWorld); paintTo3D.PushMultModOp(m); geoObject.PaintTo3D(paintTo3D); paintTo3D.PopModOp(); }
/// <summary> /// While the normal <see cref="HitTest(Projection.PickArea, bool)">HitTest</see> only checkes the <see cref="Location"/> of the object /// this method checks the hittest of the object expanded according to the projection in this <paramref name="area"/> /// </summary> /// <param name="area">Pick area to check</param> /// <param name="onlyInside">true, if the whole object must reside inside the pickarea, false if overlapping will suffice</param> /// <returns>true when a hit is recognized</returns> public bool RealHitTest(Projection.PickArea area, bool onlyInside) { ModOp m = ModOp.Translate(location.x, location.y, location.z) * ModOp.Scale(area.Projection.DeviceToWorldFactor); IGeoObject clone = geoObject.Clone(); clone.Modify(m); return(clone.HitTest(area, onlyInside)); }
/// <summary> /// Overrides <see cref="CADability.GeoObject.ISurfaceImpl.FixedU (double, double, double)"/> /// </summary> /// <param name="u"></param> /// <param name="vmin"></param> /// <param name="vmax"></param> /// <returns></returns> public override ICurve FixedU(double u, double vmin, double vmax) { ICurve2D btr = basisCurve2D.Trim(GetPos(vmin), GetPos(vmax)); ICurve b3d = btr.MakeGeoObject(Plane.XYPlane) as ICurve; ModOp rot = ModOp.Rotate(1, (SweepAngle)u); ModOp movePitch = ModOp.Translate(0, pitch * u / (Math.PI * 2.0), 0); return(b3d.CloneModified(toSurface * movePitch * rot)); }
/// <summary> /// Overrides <see cref="CADability.GeoObject.ISurfaceImpl.FixedV (double, double, double)"/> /// </summary> /// <param name="v"></param> /// <param name="umin"></param> /// <param name="umax"></param> /// <returns></returns> public override ICurve FixedV(double v, double umin, double umax) { double pos1 = (umin - curveStartParameter) / (curveEndParameter - curveStartParameter); double pos2 = (umax - curveStartParameter) / (curveEndParameter - curveStartParameter); ICurve res = basisCurve.CloneModified(ModOp.Translate(v * direction)); res.Trim(pos1, pos2); return(res); }
private bool Vec_OnSetGeoVector(GeoVector vector) { ModOp m = ModOp.Translate(vector - offset); block.Modify(m); base.ActiveObject = block; offset = vector; return(true); }
/// <summary> /// Overrides <see cref="CADability.GeoObject.ISurfaceImpl.GetOffsetSurface (double)"/> /// </summary> /// <param name="offset"></param> /// <returns></returns> public override ISurface GetOffsetSurface(double offset) { GeoVector n = fromUnitPlane * GeoVector.ZAxis; n.Norm(); ModOp newToUnit = toUnitPlane * ModOp.Translate(-offset * n); return(new PlaneSurface(newToUnit.GetInverse())); }
/// <summary> /// Overrides <see cref="CADability.GeoObject.ISurfaceImpl.PointAt (GeoPoint2D)"/> /// </summary> /// <param name="uv"></param> /// <returns></returns> public override GeoPoint PointAt(GeoPoint2D uv) { double pos = GetPos(uv.y); GeoPoint2D p2d = basisCurve2D.PointAt(pos); ModOp rot = ModOp.Rotate(1, (SweepAngle)uv.x); ModOp movePitch = ModOp.Translate(0, pitch * uv.x / (Math.PI * 2.0), 0); return(toSurface * movePitch * rot * p2d); }
static public void AlignPageCenter(GeoObjectList gl, double width, double height, Project pr) { using (pr.Undo.UndoFrame) { // nur in der Draufsicht, sonst macht das keinen Sinn BoundingRect re = gl.GetExtent(Projection.FromTop, false, false); GeoVector2D trans2D = new GeoVector2D(width / 2.0 - (re.Bottom + re.Top) / 2, height / 2.0 - (re.Bottom + re.Top) / 2); GeoVector trans = Plane.XYPlane.ToGlobal(trans2D); ModOp m = ModOp.Translate(trans); gl.Modify(m); } }
private ModOp modOpAt(double v) { GeoPoint loc = along.PointAt(v); GeoVector deriv1 = along.DirectionAt(v); GeoVector dirX = (along as IOrientation).OrientationAt(v); GeoVector dirZ = deriv1; GeoVector dirY = dirZ ^ dirX; ModOp res = ModOp.Translate(loc - GeoPoint.Origin) * ModOp.Fit(new GeoVector[] { baseDirX.Normalized, baseDirY.Normalized, baseDirZ.Normalized }, new GeoVector[] { dirX.Normalized, dirY.Normalized, dirZ.Normalized }) * ModOp.Translate(GeoPoint.Origin - baseLoc); bool dbgort = res.IsOrthogonal; return(res); }
static public void AlignCenter(GeoObjectList gl, Projection projection, Project pr) { // nur zum Nullpunkt zentieren using (pr.Undo.UndoFrame) { for (int i = 0; i < gl.Count; ++i) { BoundingRect re = IGeoObjectImpl.GetExtent(gl[i], projection, false); GeoVector2D trans2D = new GeoVector2D(-(re.Left + re.Right) / 2, -(re.Bottom + re.Top) / 2); GeoVector trans = projection.DrawingPlane.ToGlobal(trans2D); ModOp m = ModOp.Translate(trans); gl[i].Modify(m); } } }
private void SetEndPoint(GeoPoint p) { endPoint = p; if (startPointInput.Fixed) { vec.Fixed = true; // damit die Aktion nach dem Endpunkt aufhört GeoVector vect = new GeoVector(startPoint, p); ModOp m = ModOp.Translate(vect - offset); block.Modify(m); base.ActiveObject = block; feedBackLine.SetTwoPoints(startPoint, p); offset = vect; } }
ModOp IMovement.GetPosition(double u) { GeoVector du, dv; GeoPoint loc; surface.DerivationAt(c2d.PointAt(u), out loc, out du, out dv); GeoVector2D dir2d = c2d.DirectionAt(u); GeoVector ux = dir2d.x * du + dir2d.y * dv; GeoVector uz = du ^ dv; GeoVector uy = ux ^ uz; ModOp res = ModOp.Translate(loc - GeoPoint.Origin) * ModOp.Fit(new GeoVector[] { startX.Normalized, startY.Normalized, startZ.Normalized }, new GeoVector[] { ux.Normalized, uy.Normalized, uz.Normalized }) * ModOp.Translate(GeoPoint.Origin - startPos); return(res); //return new ModOp(toUnit * ux, toUnit * uy, toUnit * uz, toUnit * loc); }
static public void AlignLeft(GeoObjectList gl, Projection projection, Project pr) { using (pr.Undo.UndoFrame) { BoundingRect re1 = IGeoObjectImpl.GetExtent(gl[gl.Count - 1], projection, false); for (int i = 0; i < gl.Count - 1; ++i) { BoundingRect re = IGeoObjectImpl.GetExtent(gl[i], projection, false); GeoVector2D trans2D = new GeoVector2D(re1.Left - re.Left, 0); GeoVector trans = projection.DrawingPlane.ToGlobal(trans2D); ModOp m = ModOp.Translate(trans); gl[i].Modify(m); } } }
public override void OnDone() { using (Frame.Project.Undo.UndoFrame) { ModOp m = ModOp.Translate(block.RefPoint - orgRefPoint); originals.Modify(m); Frame.Project.GetActiveModel().Add(originals); for (int i = 0; i < originals.Count; i++) { originals[i].UpdateAttributes(Frame.Project); } } base.ActiveObject = null; // damit es nicht gleich eingefügt wird base.OnDone(); }
static public void AlignHcenter(GeoObjectList gl, Projection projection, Project pr) { using (pr.Undo.UndoFrame) { BoundingRect re1 = IGeoObjectImpl.GetExtent(gl[gl.Count - 1], projection, false); double center1 = (re1.Left + re1.Right) / 2; if (gl.Count == 1) { center1 = 0.0; // um den Ursprung, wenns nur eines ist } for (int i = 0; i < Math.Max(1, gl.Count - 1); ++i) { BoundingRect re = IGeoObjectImpl.GetExtent(gl[i], projection, false); GeoVector2D trans2D = new GeoVector2D(center1 - (re.Left + re.Right) / 2, 0); GeoVector trans = projection.DrawingPlane.ToGlobal(trans2D); ModOp m = ModOp.Translate(trans); gl[i].Modify(m); } } }
private bool extrudeOrg() { if (selectedObjectsList == null) { return(false); } IGeoObject iGeoObjectSel; // IGeoObject iGeoObjectOrg; blk = Block.Construct(); // zur Darstellung if (base.ActiveObject != null) { blk.CopyAttributes(base.ActiveObject); } // der block wird das neue aktive Objekt, er muss die Attribute tragen, weil sie später // wieder von ihm verlangt werden blk.IsTmpContainer = true; Boolean success = false; // hat er wenigstens eins gefunden int extrudeModeTemp = extrudeMode; // Merker, da extrudeMode evtl. umgeschaltet wird Plane pln; CompoundShape dbg = CompoundShape.CreateFromList(selectedObjectsList, Precision.eps, out pln); for (int i = 0; i < selectedObjectsList.Count; i++) // läuft über alle selektierten Objekte. Evtl nur eins bei Konstruktion { IGeoObject iGeoObjectTemp = null; // lokaler Merker extrudeMode = extrudeModeTemp; iGeoObjectSel = selectedObjectsList[i]; // zur Vereinfachung geoObjectOrgList[i] = iGeoObjectSel; // zum Weglöschen des Originals in onDone ownerList[i] = iGeoObjectSel.Owner; // owner merken für löschen pathCreatedFromModelList[i] = null; shapeList[i] = null; // Boolean VectorOrHeightTemp = VectorOrHeight; if ((iGeoObjectSel is Face) || (iGeoObjectSel is Shell)) { // nur kopieren iGeoObjectTemp = iGeoObjectSel.Clone(); } else { if (iGeoObjectSel is ICurve) { Path p = null; p = CADability.GeoObject.Path.CreateFromModel(iGeoObjectSel as ICurve, base.Frame.ActiveView.Model, Frame.ActiveView.Projection, true); if (p == null) { // also nur Einzelelement if (iGeoObjectSel is Path) { // schon fertig p = iGeoObjectSel.Clone() as Path; } else { // Pfad aus Einzelobjekt machen: p = Path.Construct(); if (iGeoObjectSel is Polyline) { p.Set(new ICurve[] { iGeoObjectSel.Clone() as ICurve }); p.Flatten(); } else if (iGeoObjectSel is Ellipse && !(iGeoObjectSel as Ellipse).IsArc) { Ellipse elli = iGeoObjectSel as Ellipse; p.Set(elli.Split(0.5)); // zwei Halbkreise } else { p.Set(new ICurve[] { iGeoObjectSel.Clone() as ICurve }); } } } else { // CreateFromModel hat was zusammengesetzt if (p.IsClosed) { // iGeoObjectOrg = null; // zum nicht Weglöschen des Originals in onDone geoObjectOrgList[i] = null; // zum nicht Weglöschen des Originals in onDone pathCreatedFromModelList[i] = p; // kopie merken für onDone p = p.Clone() as Path; p.Flatten(); } } if (p.IsClosed) { // jetzt face machen iGeoObjectTemp = Make3D.MakeFace(p, Frame.Project); } } } if (iGeoObjectTemp != null) { // also was geeignetes dabei if (planeMode) // Objektebene soll Grundlage sein { Face faceTemp = null; if (iGeoObjectTemp is Face) { faceTemp = (iGeoObjectTemp as Face); } if ((iGeoObjectTemp is Shell) && ((iGeoObjectTemp as Shell).Faces.Length == 1)) { faceTemp = (iGeoObjectTemp as Shell).Faces[0]; } if (faceTemp != null) { if (faceTemp.Surface is PlaneSurface) { GeoVector faceNormal = faceTemp.Surface.GetNormal(GeoPoint2D.Origin); // GeoVector temp = base.ActiveDrawingPlane.ToLocal(faceNormal); // die ActiveDrawingPlane ändert sich wenn immer der Cursor durch ein Fenster bewegt wird // das hat manchmal komische Effekte. deshalb hier die etwas statischere // ActiveView.Projection.DrawingPlane verwenden GeoVector temp = base.Frame.ActiveView.Projection.DrawingPlane.ToLocal(faceNormal); if (temp.z < 0.0) { faceNormal.Reverse(); } vector = height * faceNormal; vectorOffset = heightOffset * faceNormal; } else { heightInput.ReadOnly = true; extrudeMode = 2; // VectorOrHeight = true; optionalOrg(); } } } if (!vectorOffset.IsNullVector()) { ModOp m = ModOp.Translate(vectorOffset); iGeoObjectTemp.Modify(m); } // IGeoObject shape = Make3D.MakePrism(iGeoObjectTemp, vector, Frame.Project); IGeoObject shape; if (pipePath == null) { shape = Make3D.MakePrism(iGeoObjectTemp, vector, Frame.Project, false); } else { shape = Make3D.MakePipe(iGeoObjectTemp, pipePath, Frame.Project); } if (shape != null) { // shape.CopyAttributes(iGeoObjectSel as IGeoObject); shape.CopyAttributes(blk); // die Attribute müssen vom Block übernommen werden shapeList[i] = shape; // fertiger Körper in shapeList blk.Add(shape); // zum Darstellen base.FeedBack.AddSelected(iGeoObjectTemp); // zum Markieren des Ursprungsobjekts success = true; } } // VectorOrHeight = VectorOrHeightTemp; } // for-Schleife über die Objekte der Liste extrudeMode = extrudeModeTemp; if (success) { base.ActiveObject = blk; // darstellen base.ShowActiveObject = true; return(true); } else { optionalOrg(); heightInput.ReadOnly = false; base.ShowActiveObject = false; base.FeedBack.ClearSelected(); return(false); } }
private void initSecondaryData() { GeoPoint loc = along.PointAt(0.0); GeoVector deriv1 = along.DirectionAt(0.0); baseLoc = loc; baseDirZ = deriv1; if (normal.IsValid()) { baseDirX = normal; } else { baseDirX = (along as IOrientation).OrientationAt(0); } baseDirY = baseDirX ^ baseDirZ; toStartPos = ModOp.Fit(new GeoVector[] { baseDirX, baseDirY, baseDirZ }, new GeoVector[] { GeoVector.XAxis, GeoVector.YAxis, GeoVector.ZAxis }) * ModOp.Translate(GeoPoint.Origin - loc); }
private bool extrudeOrg() { if (selectedObjectsList == null) { return(false); } IGeoObject iGeoObjectSel; blk = Block.Construct(); // zur Darstellung if (base.ActiveObject != null) { blk.CopyAttributes(base.ActiveObject); } // der block wird das neue aktive Objekt, er muss die Attribute tragen, weil sie später // wieder von ihm verlangt werden Boolean success = false; // hat er wenigstens eins gefunden int extrudeModeTemp = extrudeMode; // Merker, da extrudeMode evtl. umgeschaltet wird for (int i = 0; i < selectedObjectsList.Count; i++) // läuft über alle selektierten Objekte. Evtl nur eins bei Konstruktion { extrudeMode = extrudeModeTemp; iGeoObjectSel = selectedObjectsList[i]; // zur Vereinfachung geoObjectOrgList[i] = iGeoObjectSel; // zum Weglöschen des Originals in onDone ownerList[i] = iGeoObjectSel.Owner; // owner merken für löschen pathCreatedFromModelList[i] = null; shapeList[i] = null; Path p = null; if (iGeoObjectSel is ICurve) { p = CADability.GeoObject.Path.CreateFromModel(iGeoObjectSel as ICurve, Frame.ActiveView.Model, Frame.ActiveView.Projection, true); if (p == null) { // also nur Einzelelement if (iGeoObjectSel is Path) { // schon fertig p = iGeoObjectSel.Clone() as Path; } else { // Pfad aus Einzelobjekt machen: p = Path.Construct(); p.Set(new ICurve[] { iGeoObjectSel.Clone() as ICurve }); } } else { // CreateFromModel hat was zusammengesetzt geoObjectOrgList[i] = null; // zum nicht Weglöschen des Originals in onDone pathCreatedFromModelList[i] = p; // kopie merken für onDone p = p.Clone() as Path; p.Flatten(); } } if (p != null) { // Objekt hat keine Ebene und Objektebene eingestellt: Höheneingabe sperren // heightInput.ReadOnly = ((p.GetPlanarState() != PlanarState.Planar) && planeMode); if (planeMode) { if (p.GetPlanarState() != PlanarState.Planar) { heightInput.ReadOnly = true; // heightOffsetInput.ReadOnly = true; // VectorOrHeight = true; extrudeMode = 2; optionalOrg(); } else { Plane pl = p.GetPlane(); pl.Align(base.ActiveDrawingPlane, false, true); // planeVector = pl.Normal; vector = height * pl.Normal; vectorOffset = heightOffset * pl.Normal; } } if (!vectorOffset.IsNullVector()) { ModOp m = ModOp.Translate(vectorOffset); p.Modify(m); } IGeoObject shape; if (pipePath == null) { shape = Make3D.MakePrism(p, vector, Frame.Project, true); } else { shape = Make3D.MakePipe(p, pipePath, Frame.Project); } if (shape != null) { // shape.CopyAttributes(iGeoObjectSel as IGeoObject); shape.CopyAttributes(blk); // die Attribute müssen vom Block übernommen werden shapeList[i] = shape; // fertiger Körper in shapeList blk.Add(shape); // zum Darstellen base.FeedBack.AddSelected(p); // zum Markieren des Ursprungsobjekts success = true; } } // VectorOrHeight = VectorOrHeightTemp; } extrudeMode = extrudeModeTemp; if (success) { base.ActiveObject = blk; // darstellen base.ShowActiveObject = true; return(true); } else { optionalOrg(); heightInput.ReadOnly = false; base.ShowActiveObject = false; base.FeedBack.ClearSelected(); return(false); } }
ModOp IMovement.GetPosition(double u) { return(ModOp.Translate(u * dir)); }
protected BlockRef(Block referredBlock) { idea = referredBlock; insertion = ModOp.Translate(0.0, 0.0, 0.0); }
/// <summary> /// Overrides <see cref="CADability.GeoObject.ISurfaceImpl.GetPlaneIntersection (PlaneSurface, double, double, double, double, double)"/> /// </summary> /// <param name="pl"></param> /// <param name="umin"></param> /// <param name="umax"></param> /// <param name="vmin"></param> /// <param name="vmax"></param> /// <param name="precision"></param> /// <returns></returns> public override IDualSurfaceCurve[] GetPlaneIntersection(PlaneSurface pl, double umin, double umax, double vmin, double vmax, double precision) { if (Precision.IsPerpendicular(pl.Plane.Normal, direction, false)) { // Ebene, die parallel zur Auszugsrichtung liegt. Es entstehen Linien List <IDualSurfaceCurve> res = new List <IDualSurfaceCurve>(); double[] cpar = basisCurve.GetPlaneIntersection(pl.Plane); for (int i = 0; i < cpar.Length; i++) { // von 0..1 auf startParameter..endParameter umrechnen double pos = curveStartParameter + cpar[i] * (curveEndParameter - curveStartParameter); if (pos >= umin && pos <= umax) { ICurve c3d = FixedU(pos, vmin, vmax); Line2D l2d = new Line2D(new GeoPoint2D(pos, vmin), new GeoPoint2D(pos, vmax)); DualSurfaceCurve dsc = new DualSurfaceCurve(c3d, this, l2d, pl, c3d.GetProjectedCurve(pl.Plane)); res.Add(dsc); } } return(res.ToArray()); //return new IDualSurfaceCurve[] { }; //return base.GetPlaneIntersection(pl, umin, umax, vmin, vmax, precision); // stürzt ab mit 50050020_012_1_FMZ.stp } else if (Precision.SameDirection(direction, pl.Plane.Normal, false)) { if (basisCurve.GetPlanarState() == PlanarState.Planar && Precision.SameDirection(direction, basisCurve.GetPlane().Normal, false)) { Plane cp = basisCurve.GetPlane(); if (!Precision.SameNotOppositeDirection(cp.Normal, direction)) { cp = new Plane(cp.Location, cp.DirectionY, cp.DirectionX); } double v = cp.Distance(pl.Plane.Location) / direction.Length; Line2D l2d = new Line2D(new GeoPoint2D(curveStartParameter, v), new GeoPoint2D(curveEndParameter, v)); DualSurfaceCurve dsc = new DualSurfaceCurve(basisCurve.CloneModified(ModOp.Translate(v * direction)), this, l2d, pl, basisCurve.GetProjectedCurve(pl.Plane)); return(new IDualSurfaceCurve[] { dsc }); } } // keine Lösung gefunden double[] upos = basisCurve.GetSavePositions(); InterpolatedDualSurfaceCurve.SurfacePoint[] sp = new InterpolatedDualSurfaceCurve.SurfacePoint[upos.Length]; for (int i = 0; i < upos.Length; ++i) { GeoPoint p0 = basisCurve.PointAt(upos[i]); double pos = curveStartParameter + upos[i] * (curveEndParameter - curveStartParameter); GeoPoint2D[] ips = pl.GetLineIntersection(p0, direction); if (ips.Length == 1) { GeoPoint p3d = pl.PointAt(ips[0]); double v = Geometry.LinePar(p0, direction, p3d); sp[i] = new InterpolatedDualSurfaceCurve.SurfacePoint(p3d, new GeoPoint2D(pos, v), ips[0]); } } InterpolatedDualSurfaceCurve idsc = new InterpolatedDualSurfaceCurve(this, pl, sp, true); return(new IDualSurfaceCurve[] { idsc.ToDualSurfaceCurve() }); //return base.GetPlaneIntersection(pl, umin, umax, vmin, vmax, precision); }
/// <summary> /// Overrides <see cref="CADability.GeoObject.ISurfaceImpl.Make3dCurve (ICurve2D)"/> /// </summary> /// <param name="curve2d"></param> /// <returns></returns> public override ICurve Make3dCurve(ICurve2D curve2d) { if (curve2d is Curve2DAspect) { ICurve res = (curve2d as Curve2DAspect).Get3DCurve(this); if (res != null) { return(res); } } if (curve2d is ProjectedCurve pc) { if (pc.Surface is SurfaceOfLinearExtrusion) { BoundingRect otherBounds = new BoundingRect(PositionOf(pc.Surface.PointAt(pc.StartPoint)), PositionOf(pc.Surface.PointAt(pc.EndPoint))); if (pc.Surface.SameGeometry(pc.GetExtent(), this, otherBounds, Precision.eps, out ModOp2D notneeded)) { return(pc.Curve3DFromParams); // if trimmed or reversed still returns the correct 3d curve (but trimmed and/or reversed) } } } if (curve2d is Line2D) { Line2D l2d = curve2d as Line2D; GeoVector2D dir = l2d.EndPoint - l2d.StartPoint; if (Math.Abs(dir.x) < Precision.eps) { // das Ergebnis ist eine Mantel-Linie Line res = Line.Construct(); res.StartPoint = PointAt(l2d.StartPoint); res.EndPoint = PointAt(l2d.EndPoint); return(res); } else if (Math.Abs(dir.y) < Precision.eps) { // Basiskurve bzw. Abschnitt derselben ModOp move = ModOp.Translate(l2d.StartPoint.y * direction); ICurve res = basisCurve.CloneModified(move); double sp = (l2d.StartPoint.x - curveStartParameter) / (curveEndParameter - curveStartParameter); double ep = (l2d.EndPoint.x - curveStartParameter) / (curveEndParameter - curveStartParameter); //double sp = l2d.StartPoint.x; //double ep = l2d.EndPoint.x; if (!(basisCurve is BSpline)) { // hier geht auch Verlängern if (sp > ep) { res.Reverse(); if (ep != 0.0 || sp != 1.0) { res.Trim(1.0 - sp, 1.0 - ep); } } else { if (sp != 0.0 || ep != 1.0) { res.Trim(sp, ep); } } } else { if (sp > 1.0 && ep > 1.0) { return(null); } if (sp < 0.0 && ep < 0.0) { return(null); } if (sp > ep) { res.Reverse(); if (ep != 0.0 || sp != 1.0) { res.Trim(1.0 - sp, 1.0 - ep); } } else { if (sp != 0.0 || ep != 1.0) { res.Trim(sp, ep); } } } return(res); } } if (curve2d is BSpline2D) { BSpline2D b2d = (curve2d as BSpline2D); int numpts = b2d.Poles.Length * b2d.Degree; GeoPoint[] pts = new GeoPoint[numpts + 1]; for (int i = 0; i <= numpts; ++i) { pts[i] = PointAt(b2d.PointAt((double)i / (double)numpts)); } BSpline b3d = BSpline.Construct(); b3d.ThroughPoints(pts, b2d.Degree, false); return(b3d); } return(base.Make3dCurve(curve2d)); }