/// <summary> /// This method calculates the distance of the array to a line only in case, if the distance is /// smaller than MaxDist., otherwise Utils.big will be returned. /// Imagine a cylinder with radius MaxDist around the polygon. /// If the line goes through the /// one of the cylinders, /// this line will be taken and the distance will be calculated and returned. /// </summary> /// <param name="L">The line, which will be tested</param> /// <param name="MaxDist">The maximal distance, for which a reasonable result can be returned.</param> /// <param name="param">A value for which the nearset point in the array can be evaluated with <see cref="Value"/></param> /// <param name="LineLam">A value for which the nearset point on the line can evaluated</param> /// <returns>In case the distance of the line is smaller than Maxdist, the distance is returned. Otherwise <see cref="Utils.big"/> /// </returns> public double Distance(LineType L, double MaxDist, out double param, out double LineLam) { double result = Utils.big; int i; double di = -1; double _lam = -1; double _mue = -1; param = -1; LineLam = -1; xyz P1 = new xyz(0, 0, 0); xyz P2 = new xyz(0, 0, 0); for (i = 0; i < Count - 1; i++) { if (this[i + 1].dist(this[i]) < 0.00000001) { continue; } LineType _L = new LineType(this[i], this[i + 1] - this[i]); di = _L.Distance(L, MaxDist, out _mue, out _lam); if (!Utils.Less(MaxDist, di) && (Utils.Less(di, result)) && (-0.001 < _mue) && (_mue < 1.0001)) { result = di; param = i + _mue; LineLam = _lam; } } return(result); }
/// <summary> /// Calculates the distance to a Point, if this distance is smaller than MaxDist. Otherwise <see cref="Utils.big"/> will be returned. /// </summary> /// <param name="Point">A Point</param> /// <param name="MaxDist">Maximal distance</param> /// <param name="LineLam">A value for which the nearest point in the array can evaluated with <see cref="Value"/></param> /// <returns>Distance.</returns> public double Distance(xyz Point, double MaxDist, out double LineLam) { double result = Utils.big; xyz Dummy; int i; double di, _lam; LineType L2; LineLam = -1; for (i = 1; i < Count; i++) { L2 = new LineType(this[i - 1], this[i].sub(this[i - 1])); di = L2.Distance(Point, out _lam, out Dummy); if (!Utils.Less(_lam, 0) && !Utils.Less(1, _lam)) { if (!Utils.Less(MaxDist, di) && (Utils.Less(di, result))) { result = di; if (Utils.Equals(_lam, 1)) { LineLam = i; } else { LineLam = i - 1 + _lam; } } } else { double _di = Point.dist(this[i]); if (!Utils.Less(MaxDist, _di) && (Utils.Less(_di, result))) { result = _di; LineLam = i; } if (i == 1) { _di = Point.dist(this[0]); if (!Utils.Less(MaxDist, _di) && (Utils.Less(_di, result))) { result = _di; LineLam = 0; } } } } return(result); }
/// <summary> /// Checks intersecting of a not bounded Line with the Triangle /// </summary> /// <param name="L">Not bounded Line</param> /// <returns></returns> public bool Intersect(LineType L) { double Lam = -1; xyz Pkt = new Drawing3d.xyz(0, 0, 0); Plane P = new Plane(A, B, C); P.Cross(L, out Lam, out Pkt); xyz Dummy = new xyz(0, 0, 0); xyz SA = A.sub(Pkt); xyz SB = B.sub(Pkt); xyz SC = C.sub(Pkt); LineType LL = new LineType(A, (B - A).normalized()); double bb = LL.Distance(Pkt, out Lam, out Dummy); if (bb < 0.1) { } LL = new LineType(B, (C - B).normalized()); bb = LL.Distance(Pkt, out Lam, out Dummy); if (bb < 0.1) { } LL = new LineType(C, (C - A).normalized()); bb = LL.Distance(Pkt, out Lam, out Dummy); if (bb < 0.1) { } //double D1 = Utils.Spat(SA, SB, L.Direction); //double D2 = Utils.Spat(SB, SC, L.Direction); //double D3 = Utils.Spat(SC, SA, L.Direction); double D1 = Utils.Spat(SA, SB, SC); return(true); //if (Utils.Less(0, D1)) //{ // return (Utils.Less(0, D2) && Utils.Less(0, D3)); //} //else // return (Utils.Less(D2, 0)) && (Utils.Less(D3, 0)); }