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]; } } }