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