/// <summary>
/// Overrides <see cref="CADability.GeoObject.ISurfaceImpl.HitTest (BoundingCube, out GeoPoint2D)"/>
/// </summary>
/// <param name="bc"></param>
/// <param name="uv"></param>
/// <returns></returns>
public override bool HitTest(BoundingCube bc, out GeoPoint2D uv)
{
GeoPoint[] cube = bc.Points;
bool[] pos = new bool[8];
// any vertex of the cube on the plane?
for (int i = 0; i < 8; ++i)
{
GeoPoint p = cube[i];
if (Math.Abs((toUnitPlane * p).z) < Precision.eps)
{
uv = PositionOf(p);
return(true);
}
pos[i] = Orientation(p) < 0;
}
// any line of the cube interfering the plane?
int[,] l = bc.LineNumbers;
for (int k = 0; k < 12; ++k)
{
int i = l[k, 0];
int j = l[k, 1];
if (pos[i] != pos[j])
{
GeoPoint2D[] erg = GetLineIntersection(cube[i], cube[j] - cube[i]);
uv = erg[0];
return(true);
}
}
// now the cube´s vertices are on one side only
uv = GeoPoint2D.Origin;
return(false); //convexity of the inner and outer points
}
/// <summary>
/// Overrides <see cref="CADability.GeoObject.IGeoObjectImpl.GetBoundingCube ()"/>
/// </summary>
/// <returns></returns>
public override BoundingCube GetBoundingCube()
{
BoundingCube res = BoundingCube.EmptyBoundingCube;
res.MinMax(location);
return(res);
}
public override void OnSetAction()
{
// base.ActiveObject = Polyline.Construct();
base.TitleId = "Constr.PlaneIntersection";
plane = base.ActiveDrawingPlane;
feedBackPolyLine = Polyline.Construct();
BoundingCube ext = toSplit.GetBoundingCube();
width = ext.DiagonalLength;
height = ext.DiagonalLength;
base.ActiveObject = feedBackPolyLine;
PlaneInput planeInput = new PlaneInput("Constr.Plane");
planeInput.SetPlaneEvent += new PlaneInput.SetPlaneDelegate(SetPlaneInput);
base.SetInput(planeInput);
base.ShowAttributes = true;
feedBackplane = new FeedBackPlane(plane, width, height);
base.ShowActiveObject = false;
base.OnSetAction();
RecalcFeedbackPolyLine();
base.Frame.SnapMode |= SnapPointFinder.SnapModes.SnapToFaceSurface;
}
void OnFeedBackChanged(IFeedBack sender)
{
BoundingCube ext = BoundingCube.EmptyBoundingCube;
for (int i = 0; i < repaintObjects.Count; i++)
{
ext.MinMax(repaintObjects[i].GetExtent());
}
for (int i = 0; i < paintAsSelected.Count; i++)
{
ext.MinMax(paintAsSelected[i].GetExtent(0.0));
}
for (int i = 0; i < paintAsTransparent.Count; i++)
{
ext.MinMax(paintAsTransparent[i].GetExtent(0.0));
}
if (frame != null)
{
foreach (IView vw in frame.AllViews)
{
if (!ext.IsEmpty && vw is IActionInputView)
{
(vw as IActionInputView).SetAdditionalExtent(ext);
(vw as IActionInputView).MakeEverythingTranparent(makeTransparent);
}
vw.InvalidateAll();
}
}
}
BoundingCube IOctTreeInsertable.GetExtent(double precision)
{
BoundingCube bc = new BoundingCube(start);
GeoPoint p = new GeoPoint();
if (dir.x > 0)
{
p.x = double.MaxValue;
}
else
{
p.x = double.MinValue;
}
if (dir.y > 0)
{
p.y = double.MaxValue;
}
else
{
p.y = double.MinValue;
}
if (dir.z > 0)
{
p.z = double.MaxValue;
}
else
{
p.z = double.MinValue;
}
bc.MinMax(p);
return(bc);
}
private void facOnMouseClick(bool up, GeoPoint MousePosition, IView View)
{
if (!up) // also beim Drücken, nicht beim Loslassen
{
// statt des umgebenden Kubus der Objekte ist es nun der definierter Punkt p
cube = BoundingCube.EmptyBoundingCube;
cube.MinMax(base.BasePoint); // der FixPunkt
cube.MinMax(MousePosition); // der Skalierungspunkt kommt dazu
startPoint = MousePosition; // den Runterdrückpunkt merken
// base.BasePoint = startPoint;
startPointInput.Fixed = true; // und sagen dass er existiert
if (dis)
{
fac1.Fixed = true;
fac2.Fixed = true;
fac3.Fixed = true;
}
else
{
fac.Fixed = true;
}
base.FeedBack.Add(feedBackLine);
base.SetFocus(endPointInput, true); // Focus auf den Endpunkt setzen
}
}
/// <summary>
/// Overrides <see cref="CADability.GeoObject.IGeoObjectImpl.GetBoundingCube ()"/>
/// </summary>
/// <returns></returns>
public override BoundingCube GetBoundingCube()
{
BoundingCube res = BoundingCube.EmptyBoundingCube;
res.MinMax(startPoint);
res.MinMax(endPoint);
return(res);
}
private void SetStartPoint(GeoPoint p)
{
// statt des umgebenden Rechtecks der Objekte ist es nun der definierter Punkt p
startPoint = p;
cube = BoundingCube.EmptyBoundingCube;
cube.MinMax(base.BasePoint); // der FixPunkt
cube.MinMax(p); // der Skalierungspunkt kommt hinzu
}
public BoundingCube GetExtent()
{
BoundingCube res = BoundingCube.EmptyBoundingCube;
foreach (IGeoObject go in list)
{
res.MinMax(go.GetBoundingCube());
}
return(res);
}
/// <summary>
/// Overrides <see cref="CADability.GeoObject.ISurfaceImpl.HitTest (BoundingCube, out GeoPoint2D)"/>
/// </summary>
/// <param name="bc"></param>
/// <param name="uv"></param>
/// <returns></returns>
public override bool HitTest(BoundingCube bc, out GeoPoint2D uv)
{
Plane p = new Plane(GeoPoint.Origin, direction);
PlaneSurface ps = new PlaneSurface(p);
ICurve2D c = basisCurve.GetProjectedCurve(p);
GeoPoint[] points = bc.Points;
GeoPoint2D[] points2D = new GeoPoint2D[8];
for (int i = 0; i < 8; ++i)
{
points2D[i] = ps.PositionOf(points[i]);
}
// does c hit the polygon?
int[,] l = bc.LineNumbers;
for (int k = 0; k < 12; ++k)
{
int i = l[k, 0];
int j = l[k, 1];
ICurve2D c2 = new Line2D(points2D[i], points2D[j]);
if (c2.Length > 0)
{
GeoPoint2DWithParameter[] list = c.Intersect(c2);
for (int m = 0; m < list.Length; ++m)
{
GeoPoint2D d0 = list[m].p;
double d1 = (points2D[i] - d0).Length;
double d2 = (points2D[j] - d0).Length;
double d3 = (points2D[i] - points2D[j]).Length;
if (Math.Abs(d1 + d2 - d3) < Precision.eps)
{
if (d3 < Precision.eps)
{
throw new Exception();
}
GeoPoint gp = points[i] + (d1 / d3) * (points[j] - points[i]);
uv = PositionOf(gp);
return(true);
}
}
}
}
// is c in the polygon?
GeoPoint e = ps.PointAt(c.EndPoint);
bool res = (bc.Interferes(e, direction, bc.Size * 1e-8, false));
if (res)
{ // nur berechnen, wenn auch gültig
uv = PositionOf(e);
}
else
{
uv = GeoPoint2D.Origin;
}
return(res);
}
public PlanePolygon(GeoPoint2D uv, GeoPoint loc, GeoVector diru, GeoVector dirv, GeoPoint edgeStart, GeoPoint edgeEnd, Tangulation tangulation)
{
// TODO: Complete member initialization
plane = new Plane(loc, diru, dirv);
toUV = ModOp2D.Translate(uv.x, uv.y) * ModOp2D.Fit(new GeoVector2D[] { GeoVector2D.XAxis, GeoVector2D.YAxis }, new GeoVector2D[] { plane.Project(diru), plane.Project(dirv) });
polygon = new List <GeoPoint2D>();
polygon.Add(plane.Project(edgeStart)); // die beiden Punkte geben die Linie an, die die Ebene begrenzt
polygon.Add(plane.Project(edgeEnd));
isOpen = true; // die Linie "halbiert" die Ebene, links davon ist innerhalb
extend = BoundingCube.EmptyBoundingCube;
}
private LasDataManager()
{
//init leaf loading thread
leafLoadRequestQueue = new Queue <QTreeLeaf>(500);
runLeafLoader = true;
leafLoadingThread = new Thread(new ThreadStart(LeafLoader));
leafLoadingThread.Start();
//set event handler
QTreeLeaf.LeafLoadRequestEvent += new LeafLoadRequest(RequestLeafLoad);
GlobalBoundingCube = new BoundingCube();
}
/// <summary>
/// Overrides <see cref="CADability.GeoObject.IGeoObjectImpl.GetBoundingCube ()"/>
/// </summary>
/// <returns></returns>
public override BoundingCube GetBoundingCube()
{
BoundingCube res = BoundingCube.EmptyBoundingCube;
// lock (this)
{
for (int i = 0; i < containedObjects.Count; ++i)
{
res.MinMax(containedObjects[i].GetBoundingCube());
}
}
return(res);
}
/// <summary>
/// Overrides <see cref="CADability.GeoObject.IGeoObjectImpl.HitTest (ref BoundingCube, double)"/>
/// </summary>
/// <param name="cube"></param>
/// <param name="precision"></param>
/// <returns></returns>
public override bool HitTest(ref BoundingCube cube, double precision)
{
// lock (this)
{
for (int i = 0; i < containedObjects.Count; ++i)
{
if (containedObjects[i].HitTest(ref cube, precision))
{
return(true);
}
}
return(false);
}
}
private bool GlobalCollisionCheck()
{
// Spline => //bezier => //iterationList //(array) splineChain=> //(Vector3) chainFragment
foreach (List <Bezier> splineBeziers in sceneSplinesBeziers)
{
foreach (Bezier bezierManager in splineBeziers)
{
int targetedIter = 0;
foreach (List <Vector3[]> iteration in bezierManager.algIterations)
{
foreach (Vector3[] fragment in iteration)
{
BoundingCube checkerBox = new BoundingCube(fragment);
// Now search all the targets
foreach (List <Bezier> splineBeziersTarget in sceneSplinesBeziers)
{
if (!splineBeziers.Equals(splineBeziersTarget))
{
foreach (Bezier bezierManagerTarget in splineBeziersTarget)
{
foreach (Vector3[] fragmentTarget in bezierManagerTarget.algIterations[targetedIter])
{
BoundingCube targetBox = new BoundingCube(fragmentTarget);
var collisionPoints = CheckCollision(checkerBox, targetBox);
if (collisionPoints != null)
{
DeleteAllCollPoints();
CreateCollsisionPoitns(collisionPoints);
return(true);
}
//if (CheckCollision(checkerBox, targetBox)){
// return true;
//}
}
}
}
} // End of Targeting
}
targetedIter++;
}
}
}
print("...No Collision...");
DeleteAllCollPoints();
return(false);
// get list of splineChain of each Objcet
// check if minimal boundries are coliding
}
/// <summary>
/// Overrides <see cref="CADability.GeoObject.IGeoObjectImpl.GetExtent (double)"/>
/// </summary>
/// <param name="precision"></param>
/// <returns></returns>
public override BoundingCube GetExtent(double precision)
{
BoundingCube res = BoundingCube.EmptyBoundingCube;
if (compoundShape != null)
{
for (int i = 0; i < compoundShape.SimpleShapes.Length; ++i)
{
SimpleShape ss = compoundShape.SimpleShapes[i];
Border bdr = ss.Outline;
res.MinMax(bdr.AsPath().MakeGeoObject(plane).GetExtent(precision));
}
}
return(res);
}
BoundingCube IFeedBack.GetExtent()
{
GeoPoint[] pnts = new GeoPoint[4];
pnts[0] = pln.ToGlobal(new GeoPoint2D(-width / 2, -height / 2));
pnts[1] = pln.ToGlobal(new GeoPoint2D(width / 2, -height / 2));
pnts[2] = pln.ToGlobal(new GeoPoint2D(width / 2, height / 2));
pnts[3] = pln.ToGlobal(new GeoPoint2D(-width / 2, height / 2));
BoundingCube res = BoundingCube.EmptyBoundingCube;
for (int i = 0; i < 4; i++)
{
res.MinMax(pnts[i]);
}
return(res);
}
static BoundingCube[] subCubes(BoundingCube start)
{
GeoPoint m = start.GetCenter();
BoundingCube[] res = new BoundingCube[8];
res[0] = new BoundingCube(m.x, start.Xmax, m.y, start.Ymax, m.z, start.Zmax);
res[1] = new BoundingCube(start.Xmin, m.x, m.y, start.Ymax, m.z, start.Zmax);
res[2] = new BoundingCube(m.x, start.Xmax, start.Ymin, m.y, m.z, start.Zmax);
res[3] = new BoundingCube(start.Xmin, m.x, start.Ymin, m.y, m.z, start.Zmax);
res[4] = new BoundingCube(m.x, start.Xmax, m.y, start.Ymax, start.Zmin, m.z);
res[5] = new BoundingCube(start.Xmin, m.x, m.y, start.Ymax, start.Zmin, m.z);
res[6] = new BoundingCube(m.x, start.Xmax, start.Ymin, m.y, start.Zmin, m.z);
res[7] = new BoundingCube(start.Xmin, m.x, start.Ymin, m.y, start.Zmin, m.z);
return(res);
}
public override void OnSetAction()
{
// base.ActiveObject = block;
base.TitleId = "MoveObjects";
copyObject = ConstrDefaults.DefaultCopyObjects;
feedBackLine = Line.Construct();
Color backColor = base.Frame.GetColorSetting("Colors.Feedback", Color.DarkGray);
feedBackLine.ColorDef = new ColorDef("", backColor);
base.SetCursor(SnapPointFinder.DidSnapModes.DidNotSnap, "Move");
vec = new GeoVectorInput("MoveObjects.Vector");
vec.SetGeoVectorEvent += new CADability.Actions.ConstructAction.GeoVectorInput.SetGeoVectorDelegate(Vec_OnSetGeoVector);
vec.MouseClickEvent += new MouseClickDelegate(VecOnMouseClick);
vec.CalculateGeoVectorEvent += new GeoVectorInput.CalculateGeoVectorDelegate(vecCalculateGeoVector);
vec.GetGeoVectorEvent += new GeoVectorInput.GetGeoVectorDelegate(vecGetGeoVector);
startPointInput = new GeoPointInput("Objects.StartPoint");
startPointInput.Optional = true;
startPointInput.SetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.SetGeoPointDelegate(SetStartPoint);
startPointInput.GetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.GetGeoPointDelegate(GetStartPoint);
endPointInput = new GeoPointInput("Objects.EndPoint");
endPointInput.Optional = true;
endPointInput.SetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.SetGeoPointDelegate(SetEndPoint);
endPointInput.GetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.GetGeoPointDelegate(GetEndPoint);
BooleanInput copy = new BooleanInput("Modify.CopyObjects", "YesNo.Values");
copy.DefaultBoolean = ConstrDefaults.DefaultCopyObjects;
copy.SetBooleanEvent += new CADability.Actions.ConstructAction.BooleanInput.SetBooleanDelegate(SetCopy);
base.SetInput(vec, startPointInput, endPointInput, copy);
BoundingCube result = BoundingCube.EmptyBoundingCube;
foreach (IGeoObject go in originals)
{
result.MinMax(go.GetBoundingCube());
}
GeoPoint blockCenter = result.GetCenter();
block.RefPoint = blockCenter;
vec.SetVectorFromPoint(blockCenter);
base.OnSetAction();
}
public override void OnSetAction()
{
base.ActiveObject = block;
base.TitleId = "ReflectObjects";
copyObject = ConstrDefaults.DefaultCopyObjects;
GeoPointInput reflectPoint = new GeoPointInput("ReflectObjects.Point");
// reflectPoint.GetGeoPointEvent += new GeoPointInput.GetGeoPointDelegate(GetReflectPoint);
reflectPoint.SetGeoPointEvent += new GeoPointInput.SetGeoPointDelegate(SetReflectPoint);
reflectPoint.Optional = true;
reflectLine = new CurveInput("ReflectObjects.Line");
reflectLine.Decomposed = true; // nur Einzelelemente, auch bei Polyline und Pfad
reflectLine.MouseOverCurvesEvent += new CurveInput.MouseOverCurvesDelegate(ReflectLine);
reflectLine.CurveSelectionChangedEvent += new CurveInput.CurveSelectionChangedDelegate(ReflectLineChanged);
PlaneInput reflectPlane = new PlaneInput("ReflectObjects.Plane");
reflectPlane.SetPlaneEvent += new PlaneInput.SetPlaneDelegate(SetReflectPlane);
// reflectPlane.GetPlaneEvent += new PlaneInput.GetPlaneDelegate(GetReflectPlane);
reflectPlane.Optional = true;
BooleanInput copy = new BooleanInput("Modify.CopyObjects", "YesNo.Values");
copy.DefaultBoolean = ConstrDefaults.DefaultCopyObjects;
copy.SetBooleanEvent += new CADability.Actions.ConstructAction.BooleanInput.SetBooleanDelegate(SetCopy);
base.SetInput(reflectPoint, reflectLine, reflectPlane, copy);
BoundingCube result = BoundingCube.EmptyBoundingCube;
foreach (IGeoObject go in originals)
{
result.MinMax(go.GetBoundingCube());
}
GeoPoint blockCenter = result.GetCenter();
block.RefPoint = blockCenter;
base.BasePoint = blockCenter;
reflectModOp = ModOp.ReflectPlane(new Plane(base.BasePoint, base.ActiveDrawingPlane.Normal, base.ActiveDrawingPlane.DirectionY));
reflectModOpStart = reflectModOp;
block.Modify(reflectModOp);
base.OnSetAction();
}
private void Add(List <byte> voxelList, BoundingCube test, IOctTreeInsertable obj, double precision)
{
int ind = voxelList.Count;
voxelList.Add(0); // 0 means: this is a final voxel, belonging to the object (we know, test interferes with the object)
if (test.XDiff > precision)
{
BoundingCube[] sc = subCubes(test);
for (int i = 0; i < 8; i++)
{
if (obj.HitTest(ref sc[i], precision))
{
voxelList[ind] |= (byte)(1 << i); // this adds a subvoxel to the list, it is no more final
Add(voxelList, sc[i], obj, precision);
}
}
}
}
/// <summary>
/// Overrides <see cref="CADability.GeoObject.IGeoObjectImpl.HitTest (ref BoundingCube, double)"/>
/// </summary>
/// <param name="cube"></param>
/// <param name="precision"></param>
/// <returns></returns>
public override bool HitTest(ref BoundingCube cube, double precision)
{
if (base.Count == 0)
{
Recalc();
}
if (base.Count > 0)
{ // LinienSchraffur oder so
return(base.HitTest(ref cube, precision));
}
else
{ // SolidSchraffur
//for (int i = 0; i < compoundShape.SimpleShapes.Length; ++i)
//{
// Face fc = Face.MakeFace(new PlaneSurface(plane), compoundShape.SimpleShapes[i]);
// if (fc.HitTest(ref cube, precision)) return true;
//}
return(false);
}
}
private ICurve[] Intersect(IGeoObject go, PlaneSurface pls)
{
Plane plane = pls.Plane;
if (go is Solid)
{
BoundingCube bc = go.GetBoundingCube();
if (bc.Interferes(plane))
{
return((go as Solid).GetPlaneIntersection(pls));
}
}
if (go is Shell)
{
BoundingCube bc = go.GetBoundingCube();
if (bc.Interferes(plane))
{
return((go as Shell).GetPlaneIntersection(pls));
}
}
if (go is Face)
{
BoundingCube bc = go.GetBoundingCube();
if (bc.Interferes(plane))
{
return((go as Face).GetPlaneIntersection(pls));
}
}
List <ICurve> res = new List <ICurve>();
if (go is Block)
{
for (int i = 0; i < go.NumChildren; i++)
{
res.AddRange(Intersect(go.Child(i), pls));
}
}
return(res.ToArray());
}
public VoxelIterator(VoxelTree vt) //byte[] voxels, int index, BoundingCube start)
{
voxels = vt.voxels;
index = 0;
double size;
current = new BoundingCube();
if (vt.baseCube >= 0)
{
size = 1 << vt.baseCube;
}
else
{
size = 1.0 / (1 << -vt.baseCube);
}
current.Set(-size, size, -size, size, -size, size); // this BoundingCube contains the whole object
for (int i = 0; i < vt.startCube.Length; i++)
{
GeoPoint m = current.GetCenter();
switch (vt.startCube[i])
{
case 0: current = new BoundingCube(m.x, current.Xmax, m.y, current.Ymax, m.z, current.Zmax); break;
case 1: current = new BoundingCube(current.Xmin, m.x, m.y, current.Ymax, m.z, current.Zmax); break;
case 2: current = new BoundingCube(m.x, current.Xmax, current.Ymin, m.y, m.z, current.Zmax); break;
case 3: current = new BoundingCube(current.Xmin, m.x, current.Ymin, m.y, m.z, current.Zmax); break;
case 4: current = new BoundingCube(m.x, current.Xmax, m.y, current.Ymax, current.Zmin, m.z); break;
case 5: current = new BoundingCube(current.Xmin, m.x, m.y, current.Ymax, current.Zmin, m.z); break;
case 6: current = new BoundingCube(m.x, current.Xmax, current.Ymin, m.y, current.Zmin, m.z); break;
case 7: current = new BoundingCube(current.Xmin, m.x, current.Ymin, m.y, current.Zmin, m.z); break;
}
}
}
private Vector2[] CheckCollision(BoundingCube A, BoundingCube B)
{
//print (Mathf.Abs(box2.xMax - box1.xMin) +" @ "+ Mathf.Abs(box2.xMin - box1.xMax) +" @ "+ Mathf.Abs(box2.yMax - box1.yMin) +" @ "+ Mathf.Abs(box2.yMin - box1.yMax));
// Check if colliding
if (Mathf.Abs(B.xMax - A.xMin) < minimalDistanceThreshold &&
Mathf.Abs(B.yMin - A.yMax) < minimalDistanceThreshold)
{
return new Vector2[] { new Vector2(A.xMin, B.yMin), new Vector2(B.xMax, A.yMax) }
}
;
else if (Mathf.Abs(B.xMin - A.xMax) < minimalDistanceThreshold &&
Mathf.Abs(B.yMin - A.yMax) < minimalDistanceThreshold)
{
return new Vector2[] { new Vector2(A.xMax, B.yMin), new Vector2(B.xMin, A.yMax) }
}
;
else if (Mathf.Abs(B.xMin - A.xMax) < minimalDistanceThreshold &&
Mathf.Abs(B.yMax - A.yMin) < minimalDistanceThreshold)
{
return new Vector2[] { new Vector2(B.xMin, A.yMin), new Vector2(A.xMax, B.yMax) }
}
;
else if (Mathf.Abs(B.xMax - A.xMin) < minimalDistanceThreshold &&
Mathf.Abs(B.yMax - A.yMin) < minimalDistanceThreshold)
{
return new Vector2[] { new Vector2(B.xMax, A.yMin), new Vector2(A.xMin, B.yMax) }
}
;
return(null);
}
/// <summary>
/// Overrides <see cref="CADability.GeoObject.IGeoObjectImpl.HitTest (ref BoundingCube, double)"/>
/// </summary>
/// <param name="cube"></param>
/// <param name="precision"></param>
/// <returns></returns>
public override bool HitTest(ref BoundingCube cube, double precision)
{
return(cube.Contains(location));
}
/// <summary>
/// Finds a plane that best fits through the given points. Calculates also the maximum distance
/// of the points from that plane. If <paramref name="MaxDistance"/> is 0.0 or small, the points are coplanar.
/// </summary>
/// <param name="Points">points to build the plane from</param>
/// <param name="MaxDistance">maximum distance of the points from the plane</param>
/// <returns>the plane</returns>
//public static Plane FromPoints(GeoPoint [] Points, out double MaxDistance)
//{
// CndOCas.Plane opln = new CndOCas.Plane();
// gp.Pnt[] tPoints = new gp.Pnt[Points.Length];
// for (int i = 0; i < Points.Length; ++i) tPoints[i] = Points[i].gpPnt();
// MaxDistance = opln.InitFromPoints(tPoints);
// return new Plane(opln);
//}
public static Plane FromPoints(GeoPoint[] Points, out double MaxDistance, out bool isLinear)
{
// nach http://www.ilikebigbits.com/blog/2015/3/2/plane-from-points
// nicht unbedingt das optimale Ergebnis :"this method will minimize the squares of the residuals as perpendicular to the main axis,
// not the residuals perpendicular to the plane." Sonst wohl besser: https://math.stackexchange.com/questions/99299/best-fitting-plane-given-a-set-of-points
#if DEBUG
// Plane dbgsvd = FromPointsSVD(Points, out MaxDistance, out isLinear); // bringt nichts!
// double dbgerr = GaussNewtonMinimizer.PlaneFit(Points, out Plane dbgpln);
//if (Points.Length > 4)
//{
// bool lmok = BoxedSurfaceExtension.PlaneFit(Points, out GeoPoint lmLoc, out GeoVector lmNormal);
//}
#endif
if (Points.Length < 3)
{
isLinear = true;
MaxDistance = double.MaxValue;
return(Plane.XYPlane);
}
isLinear = false;
MaxDistance = double.MaxValue;
GeoPoint centroid = new GeoPoint(Points);
BoundingCube ext = new BoundingCube(Points);
if (ext.Size == 0.0)
{
isLinear = true;
MaxDistance = double.MaxValue;
return(Plane.XYPlane);
}
double xx = 0.0; double xy = 0.0; double xz = 0.0;
double yy = 0.0; double yz = 0.0; double zz = 0.0;
for (int i = 0; i < Points.Length; i++)
{
GeoVector r = Points[i] - centroid;
xx += r.x * r.x;
xy += r.x * r.y;
xz += r.x * r.z;
yy += r.y * r.y;
yz += r.y * r.z;
zz += r.z * r.z;
}
double det_x = yy * zz - yz * yz;
double det_y = xx * zz - xz * xz;
double det_z = xx * yy - xy * xy;
double det_max = Math.Max(Math.Max(det_x, det_y), det_z);
if (det_max < ext.Size * 1e-13) // this is not a good condition
{
double prec = Geometry.LineFit(Points, out GeoPoint lpos, out GeoVector ldir);
if (prec < ext.Size * 1e-6)
{
isLinear = true;
return(Plane.XYPlane);
}
try
{
prec = BoxedSurfaceExtension.LineFit(Points, ext.Size * 1e-6, out lpos, out ldir);
// prec = GaussNewtonMinimizer.LineFit(Points.ToIArray(), ext.Size * 1e-6, out lpos, out ldir);
if (prec < ext.Size * 1e-6)
{
isLinear = true;
return(Plane.XYPlane);
}
}
catch { }
// there must be a better way than this!
double mindist = double.MaxValue;
GeoVector dir = GeoVector.NullVector;
GeoPoint loc = GeoPoint.Origin;
for (int i = 0; i < Points.Length; i++)
{
for (int j = i + 1; j < Points.Length; j++)
{
GeoVector tdir = Points[i] - Points[j];
if (tdir.Length < mindist)
{
mindist = tdir.Length;
loc = Points[j];
dir = tdir;
}
}
}
prec = 0;
for (int i = 0; i < Points.Length; i++)
{
double d = Geometry.DistPL(Points[i], loc, dir);
if (d > prec)
{
prec = d;
}
}
if (prec < ext.Size * 1e-4)
{
isLinear = true;
return(Plane.XYPlane);
}
}
GeoVector normal;
if (det_x == det_max)
{
normal = new GeoVector(1, (xz * yz - xy * zz) / det_x, (xy * yz - xz * yy) / det_x);
}
else if (det_max == det_y)
{
normal = new GeoVector((yz * xz - xy * zz) / det_y, 1, (xy * xz - yz * xx) / det_y);
}
else
{
normal = new GeoVector((yz * xy - xz * yy) / det_z, (xz * xy - yz * xx) / det_z, 1);
}
#if DEBUG
//MaxDistance = 0.0;
//for (int i = 0; i < Points.Length; ++i)
//{
// double d = Math.Abs(dbgpln.Distance(Points[i]));
// if (d > MaxDistance) MaxDistance = d;
//}
#endif
Plane res = new Plane(centroid, normal);
MaxDistance = 0.0;
double error = 0.0;
for (int i = 0; i < Points.Length; ++i)
{
double d = Math.Abs(res.Distance(Points[i]));
if (d > MaxDistance)
{
MaxDistance = d;
}
error += d * d;
}
return(res);
}
bool IOctTreeInsertable.HitTest(ref BoundingCube cube, double precision)
{
throw new NotImplementedException();
}
/// <summary>
/// Overrides <see cref="CADability.GeoObject.IGeoObjectImpl.HitTest (ref BoundingCube, double)"/>
/// </summary>
/// <param name="cube"></param>
/// <param name="precision"></param>
/// <returns></returns>
public override bool HitTest(ref BoundingCube cube, double precision)
{
return(cube.Interferes(new GeoPoint[] { location, location + directionWidth, location + directionWidth + directionHeight, location + directionHeight }, new int[] { 0, 1, 2, 0, 2, 3 }));
}
private void mapPanel_Paint(object sender, PaintEventArgs e)
{
if (dataSource != null && dataSource.QTrees.Count > 0)
{
Graphics g = e.Graphics;
int offset = 5;
int mmSide = mapPanel.Width - 2 * offset;
//draw sorrounding box
g.DrawRectangle(Pens.Black, offset, offset, mmSide, mmSide);
//draw global bounding box(gbb) with position relative to the sorrounding box
BoundingCube gbb = dataSource.GlobalBoundingCube;
Rectangle gbb_draw_rect = new Rectangle();
float xAxisScale = 1;
float yAxisScale = 1;
if (gbb.width > gbb.depth)
{
//gbb is wider and will span from x=0 to x=mmSide;
gbb_draw_rect.X = offset;
gbb_draw_rect.Width = mmSide;
yAxisScale = gbb.depth / gbb.width;
float gbb_height = mmSide * yAxisScale;
gbb_draw_rect.Y = offset + (int)((mmSide - gbb_height) / 2.0f);
gbb_draw_rect.Height = (int)gbb_height;
}
else
{
//gbb is higher than wider, so it will have dominant vertical axis
gbb_draw_rect.Y = offset;
gbb_draw_rect.Height = mmSide;
xAxisScale = gbb.width / gbb.depth;
float gbb_width = mmSide * xAxisScale;
gbb_draw_rect.X = offset + (int)((mmSide - gbb_width) / 2.0f);
gbb_draw_rect.Width = (int)gbb_width;
}
g.FillRectangle(Brushes.Blue, gbb_draw_rect);
double xMin = float.MaxValue;
double yMin = float.MaxValue;
//draw all bounding boxes of all loaded point trees
for (int i = 0; i < dataSource.QTrees.Count; i++)
{
QTreeWrapper qtree = dataSource.QTrees[i];
Rectangle qrect = new Rectangle();
if (xMin > qtree.lasFile.header.MinX)
{
xMin = qtree.lasFile.header.MinX;
}
if (yMin > qtree.lasFile.header.MinY)
{
yMin = qtree.lasFile.header.MinY;
}
qrect.X = (int)(gbb_draw_rect.X + mmSide * xAxisScale * (qtree.lasFile.header.MinX - gbb.minX) / gbb.width);
qrect.Y = (int)(gbb_draw_rect.Y + mmSide * yAxisScale * (qtree.lasFile.header.MinY - gbb.minY) / gbb.depth);
qrect.Width = (int)(gbb_draw_rect.Width * (qtree.qtree.RootNode.boundingBox.width / gbb.width));
qrect.Height = (int)(gbb_draw_rect.Height * (qtree.qtree.RootNode.boundingBox.height / gbb.depth));
Brush b = new SolidBrush(Color.FromArgb(100, minimapColors[i]));
g.FillRectangle(b, qrect);
}
//calculate the largest offset in negative values over the first loaded Qtree
xMin -= dataSource.QTrees[0].lasFile.header.MinX;
yMin -= dataSource.QTrees[0].lasFile.header.MinY;
//draw users position and lookAt vector
Point userPos = new Point();
int circleRadius = 5;
//offsets to gbb and offset within gbb are a must, because coords will be relative to the (0,0)
//of gbb
userPos.X = (int)(gbb_draw_rect.X + mmSide * ((xPos - xMin) / gbb.width) * xAxisScale);
userPos.Y = (int)(gbb_draw_rect.Y + mmSide * ((yPos - yMin) / gbb.depth) * yAxisScale);
g.FillEllipse(Brushes.Yellow, userPos.X - circleRadius, userPos.Y - circleRadius,
2 * circleRadius, 2 * circleRadius);
Point userLookAt = new Point();
userLookAt.X = (int)(userPos.X + eyeVector.x * 100.0f);
userLookAt.Y = (int)(userPos.Y + eyeVector.z * 100.0f);
g.DrawLine(Pens.Yellow, userPos, userLookAt);
}
}
