public override void Compute(List <Node> allNodes)
{
List <Triple> points = new List <Triple>(NodeCount);
for (int i = 0; i < NodeCount; i++)
{
points.Add(allNodes[NodeIndices[i]].Position);
}
// Here we use our own circle fitting function (implemented in the Util class)
// .. which runs much faster than calling the DynamoAPI method Circle.ByBestFitThroughPoints()
if (Util.ComputeBestFitCircle(points, out Triple c, out Triple n, out float r))
{
for (int i = 0; i < NodeCount; i++)
{
Triple d = allNodes[NodeIndices[i]].Position - c;
Moves[i] = (d - d.Dot(n) * n).Normalise() * r - d;
Weights[i] = Weight;
if (float.IsNaN(Moves[i].X))
{
throw new Exception("Damn!!!");
}
}
}
public override void Compute(List <Node> allNodes)
{
Triple v = allNodes[NodeIndices[1]].Position - allNodes[NodeIndices[0]].Position;
Moves[0] = 0.5f * (v - v.Dot(TargetDirection) * TargetDirection);
Moves[1] = -Moves[0];
}
public override void Compute(List <Node> allNodes)
{
Triple n = (allNodes[NodeIndices[1]].Position - allNodes[NodeIndices[0]].Position)
.Cross(allNodes[NodeIndices[2]].Position - allNodes[NodeIndices[0]].Position);
Moves[0] = Moves[1] = Moves[2] = WindVector * (WindVector.Dot(n) * 0.16666666666666666f);
}
public override void Compute(List <Node> allNodes)
{
List <Triple> points = new List <Triple>(NodeCount);
for (int i = 0; i < NodeCount; i++)
{
points.Add(allNodes[NodeIndices[i]].Position);
}
Triple c, n;
float r;
// Here we use our own circle fitting function (implemented in the Util class)
// .. which runs much faster than calling the Dynamo method Circle.ByBestFitThroughPoints()
if (Util.ComputeBestFitCircle(points, out c, out n, out r))
{
for (int i = 0; i < NodeCount; i++)
{
Triple d = allNodes[NodeIndices[i]].Position - c;
Moves[i] = (d - d.Dot(n) * n).Normalise() * r - d;
}
}
else
{
Moves.FillArray(Triple.Zero);
}
}
internal override void Compute(List <Node> allNodes)
{
Triple A = allNodes[NodeIndices[0]].Position;
Triple B = allNodes[NodeIndices[1]].Position;
Triple C = allNodes[NodeIndices[2]].Position;
Triple BA = A - B;
Triple BC = C - B;
Triple m = (BA + BC).Normalise();
Triple N = BA.Cross(BC);
if (N.IsAlmostZero())
{
N = Triple.BasisX;
}
Triple mA = m.Rotate(Triple.Zero, N, -0.5f * TargetAngle);
Triple mB = m.Rotate(Triple.Zero, N, +0.5f * TargetAngle);
Moves[0] = B + m * mA.Dot(BA) - A;
Moves[2] = B + m * mB.Dot(BC) - C;
Weights[0] = Weights[1] = Weights[2] = Weight;
}
public override void Compute(List <Node> allNodes)
{
for (int i = 0; i < NodeCount; i++)
{
Moves[i] = TargetPlaneNormal * -TargetPlaneNormal.Dot(allNodes[NodeIndices[i]].Position);
}
}
public override void Compute(List <Node> allNodes)
{
for (int i = 0; i < NodeCount; i++)
{
Triple v = allNodes[NodeIndices[i]].Position - TargetLineOrigin;
Moves[i] = v.Dot(TargetLineDirection) * TargetLineDirection - v;
}
}
public AngleGoal(Triple A, Triple B, Triple C, float weight = 1000f)
{
Weight = weight;
StartingPositions = new[] { A, B, C };
Moves = new Triple[3];
Moves[1] = Triple.Zero;
Triple BA = A - B;
Triple BC = C - B;
TargetAngle = (float)Math.Acos(BA.Dot(BC) / (BA.Length * BC.Length));
}
internal override void Compute(List <Node> allNodes)
{
Moves = new Triple[NodeCount];
Weights = new float[NodeCount];
if (polygonVertices == null || polygonVertices.Count <= 3)
{
return;
}
Moves = new Triple[NodeCount];
Weights = new float[NodeCount];
int[] moveCounts = new int[NodeCount];
for (int j = 0; j < polygonVertices.Count; j++)
{
Triple s = polygonVertices[j];
Triple e = polygonVertices[j + 1 < polygonVertices.Count ? j + 1 : 0];
Triple d = e - s;
Triple n = d.Cross(planeNormal).Normalise();
for (int i = 0; i < NodeCount; i++)
{
Triple c = allNodes[NodeIndices[i]].Position;
float r = Radii[i];
Triple v = c - s;
float shadow = n.Dot(v);
if (shadow <= -r)
{
continue;
}
Moves[i] += n * (-r - shadow);
moveCounts[i]++;
}
for (int i = 0; i < NodeIndices.Length; i++)
{
if (moveCounts[i] != 0)
{
Moves[i] /= moveCounts[i];
Weights[i] = Weight;
}
}
}
}
internal override void Compute(List <Node> allNodes)
{
List <Triple> points = new List <Triple>(NodeCount);
for (int i = 0; i < NodeCount; i++)
{
points.Add(allNodes[NodeIndices[i]].Position);
}
// Here we use our own line fitting function (implemented in the Util class)
// .. which runs much faster than calling the DynamoAPI method Line.ByBestFitThroughPoints()
Util.ComputeBestFitLine(points, out Triple lineOrigin, out Triple lineDirection);
for (int i = 0; i < NodeCount; i++)
{
Triple v = allNodes[NodeIndices[i]].Position - lineOrigin;
Moves[i] = v.Dot(lineDirection) * lineDirection - v;
Weights[i] = Weight;
}
}
public override void Compute(List <Node> allNodes)
{
int lineCount = NodeCount / 2;
Triple targetDirection = Triple.Zero;
for (int i = 0; i < lineCount; i++)
{
targetDirection += (allNodes[NodeIndices[2 * i + 1]].Position - allNodes[NodeIndices[2 * i]].Position).Normalise();
}
targetDirection =
targetDirection.IsAlmostZero()
? Triple.BasisX
: targetDirection.Normalise();
for (int i = 0; i < lineCount; i++)
{
Triple v = allNodes[NodeIndices[2 * i + 1]].Position - allNodes[NodeIndices[2 * i]].Position;
Moves[2 * i] = 0.5f * (v - v.Dot(targetDirection) * targetDirection);
Moves[2 * i + 1] = -Moves[2 * i];
}
}
internal override void Compute(List <Node> allNodes)
{
if (LineStarts == null)
{
return;
}
Moves.FillArray(Triple.Zero);
Weights.FillArray(Weight);
int[] moveCounts = new int[NodeCount];
for (int j = 0; j < LineStarts.Count; j++)
{
Triple s = LineStarts[j];
Triple e = LineEnds[j];
Triple d = e - s;
float lineLength = d.Length;
d /= lineLength;
for (int i = 0; i < NodeIndices.Length; i++)
{
Triple c = allNodes[NodeIndices[i]].Position;
float r = Radii[i];
Triple v = c - s;
float shadow = v.Dot(d);
if (0f < shadow && shadow < lineLength)
{
Triple move = v - d * shadow;
float distance = move.Length;
if (distance < r)
{
Moves[i] += move * (r - distance) / distance;
}
moveCounts[i]++;
}
else
{
if (shadow >= lineLength)
{
v = c - e;
}
float vLength = v.Length;
if (vLength < r)
{
Moves[i] += v * (r - vLength) / vLength;
moveCounts[i]++;
}
}
}
}
for (int i = 0; i < NodeIndices.Length; i++)
{
if (moveCounts[i] != 0)
{
Moves[i] /= moveCounts[i];
}
}
}
