public bool Extend(CurveEnd end, double length)
{
Curve c = Centreline.Extend(end, length, CurveExtensionStyle.Smooth);
Centreline = c;
return(true);
}
public bool Extend(CurveEnd end, double length, CurveExtensionStyle style = CurveExtensionStyle.Smooth)
{
Curve c = Centreline.Extend(end, length, style);
if (c == null)
{
return(false);
}
Centreline = c;
return(true);
}
/// <summary>
/// Generate a series of planes on the glulam cross-section. TODO: Re-implement as GlulamOrientation function
/// </summary>
/// <param name="N">Number of planes to extract.</param>
/// <param name="extension">Extension of the centreline curve</param>
/// <param name="frames">Output cross-section planes.</param>
/// <param name="parameters">Output t-values along centreline curve.</param>
/// <param name="interpolation">Type of interpolation to use (default is Linear).</param>
public override void GenerateCrossSectionPlanes(int N, out Plane[] frames, out double[] parameters, GlulamData.Interpolation interpolation = GlulamData.Interpolation.LINEAR)
{
Curve curve = Centreline;
double multiplier = RhinoMath.UnitScale(Rhino.RhinoDoc.ActiveDoc.ModelUnitSystem, UnitSystem.Millimeters);
//PolylineCurve discrete = curve.ToPolyline(Glulam.Tolerance * 10, Glulam.AngleTolerance, 0.0, 0.0);
PolylineCurve discrete = curve.ToPolyline(multiplier * Tolerance, AngleTolerance, multiplier * MininumSegmentLength, curve.GetLength() / MinimumNumSegments);
if (discrete.TryGetPolyline(out Polyline discrete2))
{
N = discrete2.Count;
parameters = new double[N];
for (int i = 0; i < N; ++i)
{
curve.ClosestPoint(discrete2[i], out parameters[i]);
}
}
else
{
parameters = curve.DivideByCount(N - 1, true).ToArray();
}
//frames = parameters.Select(x => GetPlane(x)).ToArray();
//return;
frames = new Plane[parameters.Length];
var vectors = Orientation.GetOrientations(curve, parameters);
Plane temp;
for (int i = 0; i < parameters.Length; ++i)
{
temp = Misc.PlaneFromNormalAndYAxis(
curve.PointAt(parameters[i]),
curve.TangentAt(parameters[i]),
vectors[i]);
if (temp.IsValid)
{
frames[i] = temp;
}
else
{
throw new Exception(string.Format("Plane is invalid: vector {0} tangent {1}", vectors[i], curve.TangentAt(parameters[i])));
}
// TODO: Make back-up orientation direction in this case.
}
return;
N = Math.Max(N, 2);
frames = new Plane[N];
Curve CL;
double extension = 0;
if (Centreline.IsClosed)
{
CL = Centreline.DuplicateCurve();
}
else
{
CL = Centreline.Extend(CurveEnd.Both, extension, CurveExtensionStyle.Smooth);
}
parameters = CL.DivideByCount(N - 1, true);
GlulamOrientation TempOrientation = Orientation.Duplicate();
TempOrientation.Remap(Centreline, CL);
for (int i = 0; i < N; ++i)
{
Vector3d v = TempOrientation.GetOrientation(CL, parameters[i]);
frames[i] = tas.Core.Util.Misc.PlaneFromNormalAndYAxis(CL.PointAt(parameters[i]), CL.TangentAt(parameters[i]), v);
}
return;
/*
* double[] ft = new double[Frames.Count];
* double[] fa = new double[Frames.Count];
*
* Plane temp;
* for (int i = 0; i < Frames.Count; ++i)
* {
* CL.PerpendicularFrameAt(Frames[i].Item1, out temp);
* ft[i] = Frames[i].Item1;
* //fa[i] = Math.Acos(temp.YAxis * Frames[i].Item2.YAxis);
* fa[i] = Vector3d.VectorAngle(temp.YAxis, Frames[i].Item2.YAxis, Frames[i].Item2);
* }
*
* for (int i = 1; i < fa.Length; ++i)
* {
* if (fa[i] - fa[i - 1] > Math.PI)
* fa[i] -= Constants.Tau;
* else if (fa[i] - fa[i - 1] < -Math.PI)
* fa[i] += Constants.Tau;
* }
*
* int res;
* int max = ft.Length - 1;
* double mu;
*
* double[] angles = new double[N];
*
* if (Frames.Count < 3)
* interpolation = GlulamData.Interpolation.LINEAR;
*
* switch (interpolation)
* {
* case (GlulamData.Interpolation.HERMITE): // Hermite Interpolation
* for (int i = 0; i < N; ++i)
* {
* if (t[i] < ft[0])
* {
* angles[i] = fa[0];
* continue;
* }
* else if (t[i] > ft.Last())
* {
* angles[i] = fa.Last();
* continue;
* }
*
* res = Array.BinarySearch(ft, t[i]);
* if (res < 0)
* {
* res = ~res;
* res--;
* }
*
* if (res == 0 && res < max - 1)
* {
* mu = (t[i] - ft[0]) / (ft[1] - ft[0]);
* angles[i] = Interpolation.HermiteInterpolate(fa[0], fa[0], fa[1], fa[2], mu, 0, 0);
* }
* else if (res > 0 && res < max - 1)
* {
* mu = (t[i] - ft[res]) / (ft[res + 1] - ft[res]);
* angles[i] = Interpolation.HermiteInterpolate(fa[res - 1], fa[res], fa[res + 1], fa[res + 2], mu, 0, 0);
*
* }
* else if (res > 0 && res < max)
* {
* mu = (t[i] - ft[res]) / (ft[res + 1] - ft[res]);
* angles[i] = Interpolation.HermiteInterpolate(fa[res - 1], fa[res], fa[res + 1], fa[res + 1], mu, 0, 0);
* }
* else if (res == max)
* {
* angles[i] = fa[res];
* }
*
* else
* continue;
* }
* break;
*
* case (GlulamData.Interpolation.CUBIC): // Cubic Interpolation
* for (int i = 0; i < N; ++i)
* {
* if (t[i] <= ft[0])
* {
* angles[i] = fa[0];
* continue;
* }
* else if (t[i] >= ft.Last())
* {
* angles[i] = fa.Last();
* continue;
* }
*
* res = Array.BinarySearch(ft, t[i]);
* if (res < 0)
* {
* res = ~res;
* res--;
* }
*
* if (res == 0 && res < max - 1)
* {
* mu = (t[i] - ft[0]) / (ft[1] - ft[0]);
* angles[i] = Interpolation.CubicInterpolate(fa[0], fa[0], fa[1], fa[2], mu);
* }
* else if (res > 0 && res < max - 1)
* {
* mu = (t[i] - ft[res]) / (ft[res + 1] - ft[res]);
* angles[i] = Interpolation.CubicInterpolate(fa[res - 1], fa[res], fa[res + 1], fa[res + 2], mu);
*
* }
* else if (res > 0 && res < max)
* {
* mu = (t[i] - ft[res]) / (ft[res + 1] - ft[res]);
* angles[i] = Interpolation.CubicInterpolate(fa[res - 1], fa[res], fa[res + 1], fa[res + 1], mu);
* }
* else if (res == max)
* {
* angles[i] = fa[res];
* }
*
* else
* continue;
* }
* break;
*
* default: // Default linear interpolation
* for (int i = 0; i < N; ++i)
* {
* res = Array.BinarySearch(ft, t[i]);
* if (res < 0)
* {
* res = ~res;
* res--;
* }
* if (res >= 0 && res < max)
* {
* if (ft[res + 1] - ft[res] == 0)
* mu = 0.5;
* else
* mu = Math.Min(1.0, Math.Max(0, (t[i] - ft[res]) / (ft[res + 1] - ft[res])));
* angles[i] = Interpolation.Lerp(fa[res], fa[res + 1], mu);
* }
* else if (res < 0)
* angles[i] = fa[0];
* else if (res >= max)
* angles[i] = fa[max];
* }
* break;
* }
*
* for (int i = 0; i < N; ++i)
* {
* CL.PerpendicularFrameAt(t[i], out temp);
* temp.Transform(Rhino.Geometry.Transform.Rotation(angles[i], temp.ZAxis, temp.Origin));
* planes[i] = temp;
* }
*/
}
