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));
}
