public void NotEquals_FalseForEqual()
{
var a = new LineSegment3(new Vector3(1, 2, 3), new Vector3(4, 5, 6));
var b = a;
Assert.IsFalse(a != b);
}
public void NotEquals_TrueForNotEqual()
{
var a = new LineSegment3(new Vector3(1, 2, 3), new Vector3(4, 5, 6));
var b = new LineSegment3(new Vector3(6, 5, 4), new Vector3(3, 2, 1));
Assert.IsTrue(a != b);
}
public void GetHashCode_SameForEqual()
{
var a = new LineSegment3(new Vector3(1, 2, 3), new Vector3(4, 5, 6));
var b = new LineSegment3(new Vector3(1, 2, 3), new Vector3(4, 5, 6));
Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
}
public Angle MaximalAngleWith(LineSegment3 line)
{
if (!this.valid)
{
return(Angle.ZERO);
}
return(this.direction.MaximalAngleWithAxis(line.VectorAB));
}
public void Equals_FalseForNotEqual()
{
var a = new LineSegment3(new Vector3(1, 2, 3), new Vector3(4, 5, 6));
var b = new LineSegment3(new Vector3(6, 5, 4), new Vector3(3, 2, 1));
Assert.IsFalse(a.Equals(b));
Assert.IsFalse(a.Equals((object)b));
Assert.IsFalse(a == b);
}
public LineSegment3 Reflect(LineSegment3 segment)
{
if (!this.valid)
{
return(segment);
}
return(new LineSegment3(Reflect(segment.A), Reflect(segment.B)));
}
public void Equals_TrueForEqual()
{
var a = new LineSegment3(new Vector3(1, 2, 3), new Vector3(4, 5, 6));
var b = a;
Assert.IsTrue(a.Equals(b));
Assert.IsTrue(a.Equals((object)b));
Assert.IsTrue(a == b);
}
public RayHitResult HitWithClick(RayCastInfo clickInfo)
{
var globalRay = clickInfo.GlobalRay;
var sphere = getSphere(master);
var segmentLength = (sphere.Center - globalRay.Point).Length() * 3;
var segment = new LineSegment3(globalRay.Point, globalRay.Point + globalRay.Direction * segmentLength);
sphere.Intersect(segment, out var p1, out var p2);
if (!p1.HasValue)
{
return(RayHitResult.Failure());
}
var d1 = (p1.Value - globalRay.Point).Length();
Vector3 globalPoint;
float distance;
if (p2.HasValue)
{
var d2 = (p2.Value - globalRay.Point).Length();
var use1 = (d1 <= d2) ^ inverted;
if (use1)
{
globalPoint = p1.Value;
distance = d1;
}
else
{
globalPoint = p2.Value;
distance = d2;
}
}
else
{
globalPoint = p1.Value;
distance = d1;
}
// todo: consider rotation
var localPoint = (globalPoint - sphere.Center) / sphere.Radius;
return(new RayHitResult
{
Successful = true,
Node = Node,
Distance = distance,
GlobalHitPoint = globalPoint,
LocalHitPoint = localPoint,
IntTag = intTag,
StrTag = strTag
});
}
private static List <Polygon3> GenerateContourScaffolding(List <Mesh3> regions, float plateSpacing, Point3Tree <List <Polygon3> > edgeFacetIndex)
{
List <Polygon3> scaffolding = new List <Polygon3>();
foreach (Mesh3 region in regions)
{
foreach (Polygon3 facet in region.Facets)
{
for (int i = 0; i != facet.EdgeMidPoints.Length; i++)
{
if (edgeFacetIndex[facet.EdgeMidPoints[i]].Count == 1)
{
LineSegment3 boundingEdge = facet.Edges[i];
scaffolding.AddRange(CreateTesselatedLineSupport(new List <Point3> {
boundingEdge.StartPoint, boundingEdge.EndPoint
}, plateSpacing, region));
}
}
}
}
return(scaffolding);
}
// ========================================================
public bool IsEqualTo(LineSegment3 line)
{
return((A.IsEqualTo(line.A) && B.IsEqualTo(line.B)) || (A.IsEqualTo(line.B) && B.IsEqualTo(line.A)));
}
public static LineSegment3 TurnAt90Degrees(LineSegment3 segment)
{
return(new LineSegment3(TurnAt90Degrees(segment.A), TurnAt90Degrees(segment.B)));
}
public static LineSegment3 Reflect(LineSegment3 segment)
{
return(new LineSegment3(Reflect(segment.A), Reflect(segment.B)));
}
public BuildingWallSegment(Vector3 p1, Vector3 p2, float height)
{
Basement = new LineSegment3(p1, p2);
Height = height;
}
public LineSegment3(LineSegment3 line)
{
this.A = line.A;
this.B = line.B;
}
public bool IsParallelTo(LineSegment3 segment)
{
return(this.valid && this.direction.IsParallelTo(segment.VectorAB));
}
public bool IsOrthogonalTo(LineSegment3 segment)
{
return(this.valid && this.direction.IsOrthogonalTo(segment.VectorAB));
}
/// <summary>
/// Helper - returns the closest point on this curve to a line
/// </summary>
public float FindClosestPoint( LineSegment3 line, int iterations )
{
return FindClosestPoint( new DistanceToPointDelegate( line.GetSqrDistanceToPoint ), iterations );
}
public bool IsParallelTo(LineSegment3 segment)
{
return((B - A).IsParallelTo(segment.B - segment.A));
}
public bool IsOrthogonalTo(LineSegment3 segment)
{
return((B - A).IsOrthogonalTo(segment.B - segment.A));
}
private static void GetExternalPart(LineSegment3 segment, BuildingPrimitive primitive, List <LineSegment3> results)
{
var invTransform = primitive.Transform.Invert();
var transformedSeg = new LineSegment3(segment.Point1 * invTransform, segment.Point2 * invTransform);
var seg = new LineSegment2(transformedSeg.Point1.Xz, transformedSeg.Point2.Xz);
if (primitive.Type == BuildingPrimitiveType.Rectangle)
{
var rect = new AaRectangle2(Vector2.Zero, primitive.Scale.X, primitive.Scale.Z);
var conains1 = rect.ContainsPoint(seg.Point1);
var conains2 = rect.ContainsPoint(seg.Point2);
if (conains1 && conains2)
{
return;
}
if (!conains1 && !conains2)
{
var p = Vector2.Zero;
int c = 0;
foreach (var rectSegment in rect.GetSegments())
{
var rsi = rectSegment.Intersect(seg);
if (rsi.HasValue)
{
p += rsi.Value;
c++;
}
}
if (c > 0)
{
var t = ((p / c) - seg.Point1).Length() / (seg.Point2 - seg.Point1).Length();
var m = segment.Point1 + (segment.Point2 - segment.Point1) * t;
GetExternalPart(new LineSegment3(segment.Point1, m), primitive, results);
GetExternalPart(new LineSegment3(m, segment.Point2), primitive, results);
return;
}
results.Add(segment);
return;
}
var swap = conains1;
if (swap)
{
CodingHelper.Swap(ref seg.Point1, ref seg.Point2);
}
var inter = seg.Intersect(new LineSegment2(
new Vector2(-primitive.Scale.X, -primitive.Scale.Z),
new Vector2(-primitive.Scale.X, primitive.Scale.Z)));
if (inter.HasValue)
{
var rs1 = To3(seg.Point1, inter.Value, primitive.Transform, swap);
results.Add(rs1);
return;
}
inter = seg.Intersect(new LineSegment2(
new Vector2(primitive.Scale.X, -primitive.Scale.Z),
new Vector2(primitive.Scale.X, primitive.Scale.Z)));
if (inter.HasValue)
{
var rs1 = To3(seg.Point1, inter.Value, primitive.Transform, swap);
results.Add(rs1);
return;
}
inter = seg.Intersect(new LineSegment2(
new Vector2(-primitive.Scale.X, primitive.Scale.Z),
new Vector2(primitive.Scale.X, primitive.Scale.Z)));
if (inter.HasValue)
{
var rs1 = To3(seg.Point1, inter.Value, primitive.Transform, swap);
results.Add(rs1);
return;
}
inter = seg.Intersect(new LineSegment2(
new Vector2(-primitive.Scale.X, -primitive.Scale.Z),
new Vector2(primitive.Scale.X, -primitive.Scale.Z)));
if (inter.HasValue)
{
var rs1 = To3(seg.Point1, inter.Value, primitive.Transform, swap);
results.Add(rs1);
return;
}
var rs2 = segment;
results.Add(rs2);
return;
}
else
{
var circle = new Circle2(Vector2.Zero, primitive.Scale.X);
var conains1 = circle.Contains(seg.Point1);
var conains2 = circle.Contains(seg.Point2);
if (conains1 && conains2)
{
return;
}
if (!conains1 && !conains2)
{
var rs1 = segment;
results.Add(rs1);
return;
}
var swap = conains1;
if (swap)
{
CodingHelper.Swap(ref seg.Point1, ref seg.Point2);
}
var dpp = seg.Point2 - seg.Point1;
var dpc = seg.Point1;
var a = dpp.LengthSquared();
var b = Vector2.Dot(dpp, dpc);
var c = dpc.LengthSquared() - circle.Radius.Sq();
var discr = b * b - a * c;
if (discr < 0)
{
results.Add(segment);
return;
}
if (discr < MathHelper.Eps5)
{
results.Add(segment);
return;
//var l = -b / a;
//if (0 <= l && l <= 1)
}
{
var sqrdscr = MathHelper.Sqrt(discr);
var l1 = (-b + sqrdscr) / a;
var l2 = (-b - sqrdscr) / a;
if (0 <= l1 && l1 <= 1)
{
var rs1 = To3(seg.Point1, Vector2.Lerp(seg.Point1, seg.Point2, l1), primitive.Transform, swap);
results.Add(rs1);
}
if (0 <= l2 && l2 <= 1)
{
var rs1 = To3(seg.Point1, Vector2.Lerp(seg.Point1, seg.Point2, l2), primitive.Transform, swap);
results.Add(rs1);
}
}
}
}
public Angle MaximalAngleWith(LineSegment3 line)
{
return(this.VectorAB.MaximalAngleWithAxis(line.VectorAB));
}
