/// <summary>The create end rebar.</summary>
/// <param name="currentOriginalRebar">The original rebar.</param>
/// <param name="maxLength">The max length.</param>
/// <param name="splitPattern">The split pattern.</param>
/// <param name="splitRebarSet">The split reinforcement bar set.</param>
/// <param name="incrementalLength">The incremental length.</param>
/// <param name="lastSegment">The last segment.</param>
/// <returns>The System.Boolean.</returns>
private bool CreateEndRebar(
SingleRebar currentOriginalRebar,
double maxLength,
Vector splitPattern,
ArrayList splitRebarSet,
ref double incrementalLength,
out double lastSegment)
{
var rebarPoints = new ArrayList();
double finalRebarLength;
splitPattern.Normalize(incrementalLength);
var firstPoint = new Vector(splitPattern);
lastSegment = Distance.PointToPoint(
(Point)currentOriginalRebar.Polygon.Points[0] + firstPoint, (Point)currentOriginalRebar.Polygon.Points[1]);
rebarPoints.Add((Point)currentOriginalRebar.Polygon.Points[0] + firstPoint);
rebarPoints.Add(currentOriginalRebar.Polygon.Points[1]);
bool result = this.CreateSplittedRebars(FirstOrLastEnum.LastRebar, rebarPoints, splitRebarSet, out finalRebarLength);
incrementalLength += maxLength + (this.splitData.LappingLength / 2.0);
return(result);
}
public static SingleRebar createDiagonal(T3D.Point p1, T3D.Point p2, double diametro)
{
SingleRebar rebar = crearBarra(p1, p2, diametro);
rebar.Name = "DIAGONAL";
return(rebar);
}
public static SingleRebar createBarraLongitudinal(T3D.Point p1, T3D.Point p2, double diametro)
{
SingleRebar rebar = crearBarra(p1, p2, diametro);
rebar.Name = "BARRA_VIGUETA";
return(rebar);
}
/// <summary>The set new reinforcement bar properties from reinforcement bar group.</summary>
/// <param name="newRebar">The new rebar.</param>
/// <param name="originalRebarGroup">The original reinforcement bar group.</param>
private void SetNewRebarPropertiesFromRebarGroup(SingleRebar newRebar, RebarGroup originalRebarGroup)
{
newRebar.Father = originalRebarGroup.Father;
newRebar.Name = originalRebarGroup.Name;
newRebar.Size = originalRebarGroup.Size;
newRebar.Grade = originalRebarGroup.Grade;
newRebar.Class = originalRebarGroup.Class;
newRebar.StartHook.Shape = originalRebarGroup.StartHook.Shape;
newRebar.StartHook.Angle = originalRebarGroup.StartHook.Angle;
newRebar.StartHook.Radius = originalRebarGroup.StartHook.Radius;
newRebar.StartHook.Length = originalRebarGroup.StartHook.Length;
newRebar.EndHook.Shape = originalRebarGroup.EndHook.Shape;
newRebar.EndHook.Angle = originalRebarGroup.EndHook.Angle;
newRebar.EndHook.Radius = originalRebarGroup.EndHook.Radius;
newRebar.EndHook.Length = originalRebarGroup.EndHook.Length;
newRebar.OnPlaneOffsets = new ArrayList();
newRebar.FromPlaneOffset = 0.0;
newRebar.EndPointOffsetValue = 0.0;
newRebar.EndPointOffsetType = originalRebarGroup.EndPointOffsetType;
newRebar.StartPointOffsetValue = 0.0;
newRebar.StartPointOffsetType = originalRebarGroup.StartPointOffsetType;
newRebar.NumberingSeries.Prefix = originalRebarGroup.NumberingSeries.Prefix;
newRebar.NumberingSeries.StartNumber = originalRebarGroup.NumberingSeries.StartNumber;
newRebar.RadiusValues = originalRebarGroup.RadiusValues;
}
/// <summary>The set new reinforcement bar properties from single rebar.</summary>
/// <param name="newRebar">The new rebar.</param>
/// <param name="originalSingleRebar">The original single rebar.</param>
private void SetNewRebarPropertiesFromSingleRebar(SingleRebar newRebar, SingleRebar originalSingleRebar)
{
newRebar.Father = originalSingleRebar.Father;
newRebar.Name = originalSingleRebar.Name;
newRebar.Size = originalSingleRebar.Size;
newRebar.Grade = originalSingleRebar.Grade;
newRebar.Class = originalSingleRebar.Class;
newRebar.StartHook.Shape = originalSingleRebar.StartHook.Shape;
newRebar.StartHook.Angle = originalSingleRebar.StartHook.Angle;
newRebar.StartHook.Radius = originalSingleRebar.StartHook.Radius;
newRebar.StartHook.Length = originalSingleRebar.StartHook.Length;
newRebar.EndHook.Shape = originalSingleRebar.EndHook.Shape;
newRebar.EndHook.Angle = originalSingleRebar.EndHook.Angle;
newRebar.EndHook.Radius = originalSingleRebar.EndHook.Radius;
newRebar.EndHook.Length = originalSingleRebar.EndHook.Length;
newRebar.FromPlaneOffset = originalSingleRebar.FromPlaneOffset;
newRebar.OnPlaneOffsets = originalSingleRebar.OnPlaneOffsets;
newRebar.NumberingSeries.Prefix = originalSingleRebar.NumberingSeries.Prefix;
newRebar.NumberingSeries.StartNumber = originalSingleRebar.NumberingSeries.StartNumber;
newRebar.RadiusValues = originalSingleRebar.RadiusValues;
newRebar.EndPointOffsetValue = originalSingleRebar.EndPointOffsetValue;
newRebar.EndPointOffsetType = originalSingleRebar.EndPointOffsetType;
newRebar.StartPointOffsetValue = originalSingleRebar.StartPointOffsetValue;
newRebar.StartPointOffsetType = originalSingleRebar.StartPointOffsetType;
}
/// <summary>The create different middle rebar in center symmetry.</summary>
/// <param name="remainingLength">The remaining length.</param>
/// <param name="currentOriginalRebar">The original rebar.</param>
/// <param name="splitPattern">The split pattern.</param>
/// <param name="incrementalLength">The incremental length.</param>
/// <param name="splitRebarSet">The split reinforcement bar set.</param>
/// <returns>The System.Boolean.</returns>
private bool CreateDifferentMiddleRebarInCenterSymmetry(
double remainingLength,
SingleRebar currentOriginalRebar,
ref Vector splitPattern,
ref double incrementalLength,
ref ArrayList splitRebarSet)
{
double rebarLength, finalRebarLength;
var rebarPoints = new ArrayList();
if (this.splitData.SpliceType == 0)
{
rebarLength = remainingLength - this.splitData.LappingLength;
}
else
{
rebarLength = remainingLength;
}
splitPattern.Normalize(incrementalLength);
var firstPoint = new Vector(splitPattern);
splitPattern.Normalize(rebarLength);
var secondPoint = new Vector(splitPattern);
rebarPoints.Add((Point)currentOriginalRebar.Polygon.Points[0] + firstPoint);
rebarPoints.Add((Point)currentOriginalRebar.Polygon.Points[0] + firstPoint + secondPoint);
bool result = this.CreateSplittedRebars(FirstOrLastEnum.MiddleRebar, rebarPoints, splitRebarSet, out finalRebarLength);
incrementalLength += finalRebarLength;
return(result);
}
/// <summary>The split rebar.</summary>
/// <param name="originalRebar">The original rebar.</param>
/// <param name="section">The section.</param>
/// <param name="barPosition">The bar position.</param>
/// <param name="remainingOffset">The remaining offset.</param>
/// <param name="splitRebarSet">The split reinforcement bar set.</param>
/// <returns>The System.Boolean.</returns>
private bool SplitRebar(
SingleRebar originalRebar,
SpliceSection section,
BarPositions barPosition,
ref double remainingOffset,
out ArrayList splitRebarSet)
{
var result = true;
double maxLength, totalOffset, remainingLength, hookLength, incrementalLength = 0.0;
splitRebarSet = new ArrayList();
var totalRebarLength = Distance.PointToPoint((Point)originalRebar.Polygon.Points[1], (Point)originalRebar.Polygon.Points[0]);
var splitPattern = new Vector((Point)originalRebar.Polygon.Points[1] - (Point)originalRebar.Polygon.Points[0]);
this.GetRebarMaximumLength(FirstOrLastEnum.MiddleRebar, out maxLength);
this.CalculateTotalOffset(
totalRebarLength,
section,
barPosition,
remainingOffset,
out totalOffset,
out remainingLength,
out hookLength);
for (var ii = 0; incrementalLength + this.GetRebarLengthEpsilon() < totalRebarLength; ii++)
{
if (ii == 0)
{
result &= this.CreateStartRebar(originalRebar, splitPattern, splitRebarSet, totalOffset, hookLength, ref incrementalLength);
}
else if (incrementalLength + maxLength + this.GetRebarLengthEpsilon() < totalRebarLength)
{
var centralBarsCount = (int)Math.Floor(totalRebarLength / maxLength);
if (this.splitData.SpliceSymmetry == 2 && barPosition == BarPositions.First && centralBarsCount > 1 &&
incrementalLength < totalRebarLength / 2.0 &&
incrementalLength + maxLength > totalRebarLength / 2.0)
{
result &= this.CreateDifferentMiddleRebarInCenterSymmetry(remainingLength, originalRebar, ref splitPattern, ref incrementalLength, ref splitRebarSet);
}
else
{
result &= this.CreateMiddleRebar(originalRebar, splitPattern, splitRebarSet, ref incrementalLength);
}
}
else
{
double lastSegment;
result &= this.CreateEndRebar(originalRebar, maxLength, splitPattern, splitRebarSet, ref incrementalLength, out lastSegment);
if (barPosition == BarPositions.First)
{
remainingOffset = lastSegment;
}
}
}
return(result);
}
private static void addRebarSettings(SingleRebar rebar, double diametro)
{
rebar.RadiusValues.Add(40.0);
rebar.Class = 3;
rebar.Size = "" + diametro;
rebar.NumberingSeries.StartNumber = 0;
rebar.Grade = "Undefined";
}
public static dynamic GetTSObject(SingleRebar dynObject)
{
if (dynObject is null)
{
return(null);
}
return(dynObject.teklaObject);
}
private static SingleRebar crearBarra(T3D.Point p1, T3D.Point p2, double diametro)
{
SingleRebar rebar = new SingleRebar();
rebar.Polygon.Points.Add(p1);
rebar.Polygon.Points.Add(p2);
addRebarSettings(rebar, diametro);
return(rebar);
}
/// <summary>The create start rebar.</summary>
/// <param name="currentOriginalRebar">The original rebar.</param>
/// <param name="splitPattern">The split pattern.</param>
/// <param name="splitRebarSet">The split reinforcement bar set.</param>
/// <param name="totalOffset">The total offset.</param>
/// <param name="hookLength">The hook length.</param>
/// <param name="incrementalLength">The incremental length.</param>
/// <returns>The System.Boolean.</returns>
private bool CreateStartRebar(
SingleRebar currentOriginalRebar,
Vector splitPattern,
ArrayList splitRebarSet,
double totalOffset,
double hookLength,
ref double incrementalLength)
{
var rebarPoints = new ArrayList();
double finalRebarLength;
if (totalOffset < DistanceEpsilon)
{
double rebarLength;
if (this.splitData.SpliceSymmetry == 2)
{
rebarLength = this.splitData.MaxLength;
if (this.splitData.SpliceType == 0)
{
rebarLength -= this.splitData.LappingLength / 2.0;
}
rebarLength -= hookLength;
}
else
{
this.GetRebarMaximumLength(FirstOrLastEnum.FirstRebar, out rebarLength);
}
splitPattern.Normalize(rebarLength);
}
else
{
splitPattern.Normalize(totalOffset);
}
var secondPoint = new Vector(splitPattern);
rebarPoints.Add(currentOriginalRebar.Polygon.Points[0]);
rebarPoints.Add((Point)currentOriginalRebar.Polygon.Points[0] + secondPoint);
bool result = this.CreateSplittedRebars(FirstOrLastEnum.FirstRebar, rebarPoints, splitRebarSet, out finalRebarLength);
incrementalLength += finalRebarLength;
return(result);
}
private void fabricarBarras()
{
T3D.Point p1 = new T3D.Point(x1(), YBarras(offset), z2());
T3D.Point p2 = new T3D.Point(x2(), YBarras(offset), z2());
T3D.Point p3 = new T3D.Point(x1(), YBarras(offset), z1());
T3D.Point p4 = new T3D.Point(x2(), YBarras(offset), z1());
SingleRebar barra1 = FabricaElementosPanel.createBarraLongitudinal(p1, p2, p.diametroBarras);
SingleRebar barra2 = FabricaElementosPanel.createBarraLongitudinal(p3, p4, p.diametroBarras);
barra1.Father = p.muro;
barra2.Father = p.muro;
barra1.Insert();
barra2.Insert();
}
private void fabricarBarras()
{
T3D.Point p1 = new T3D.Point(XBarras(offset), p.min.Y - p.adicionalInferior, z2());
T3D.Point p2 = new T3D.Point(XBarras(offset), p.max.Y + p.adicionalSuperior, z2());
T3D.Point p3 = new T3D.Point(XBarras(offset), p.min.Y - p.adicionalInferior, z1());
T3D.Point p4 = new T3D.Point(XBarras(offset), p.max.Y + p.adicionalSuperior, z1());
SingleRebar barra1 = FabricaElementosPanel.createBarraLongitudinal(p1, p2, p.diametroBarras);
SingleRebar barra2 = FabricaElementosPanel.createBarraLongitudinal(p3, p4, p.diametroBarras);
barra1.Father = p.muro;
barra2.Father = p.muro;
barra1.Insert();
barra2.Insert();
}
/// <summary>The reinforcement bars can be spliced.</summary>
/// <param name="primaryRebar">The primary rebar.</param>
/// <param name="secondaryRebar">The secondary rebar.</param>
/// <returns>The System.Boolean.</returns>
private bool RebarsCanBeSpliced(SingleRebar primaryRebar, SingleRebar secondaryRebar)
{
var result = false;
for (var primaryIndex = 0; primaryIndex < primaryRebar.Polygon.Points.Count && !result; primaryIndex++)
{
for (var secondaryIndex = 0; secondaryIndex < secondaryRebar.Polygon.Points.Count && !result; secondaryIndex++)
{
if (Distance.PointToPoint(primaryRebar.Polygon.Points[primaryIndex] as Point, secondaryRebar.Polygon.Points[secondaryIndex] as Point) < DistanceEpsilon)
{
var primaryVector = this.GetRebarVectorForSingleRebar(primaryIndex, primaryRebar);
var secondaryVector = this.GetRebarVectorForSingleRebar(secondaryIndex, secondaryRebar);
result = this.RebarsDoNotOverlap(primaryVector, secondaryVector);
}
}
}
return(result);
}
static private void ungroupRebar(TSM.RebarGroup current)
{
ArrayList currentPolygons = current.GetRebarGeometries(true);
foreach (TSM.RebarGeometry geo in currentPolygons)
{
TSM.Polygon poly = new TSM.Polygon();
PolyLine line = geo.Shape;
ArrayList points = line.Points;
poly.Points = points;
SingleRebar single = new SingleRebar();
single.Polygon = poly;
single.Father = current.Father;
single.Name = current.Name;
single.Class = current.Class;
single.Size = current.Size;
single.Grade = current.Grade;
single.RadiusValues = current.RadiusValues;
single.NumberingSeries.StartNumber = current.NumberingSeries.StartNumber;
single.NumberingSeries.Prefix = current.NumberingSeries.Prefix;
single.OnPlaneOffsets = new ArrayList();
single.OnPlaneOffsets.Add(0.0);
single.StartHook.Angle = -90;
single.StartHook.Length = 10;
single.StartHook.Radius = 10;
single.StartHook.Shape = RebarHookData.RebarHookShapeEnum.NO_HOOK;
single.EndHook.Angle = 90;
single.EndHook.Length = 10;
single.EndHook.Radius = 10;
single.EndHook.Shape = RebarHookData.RebarHookShapeEnum.NO_HOOK;
single.Insert();
}
current.Delete();
MessageBox.Show(currentPolygons.Count.ToString());
}
/// <summary>The create middle rebar.</summary>
/// <param name="currentOriginalRebar">The original rebar.</param>
/// <param name="splitPattern">The split pattern.</param>
/// <param name="splitRebarSet">The split reinforcement bar set.</param>
/// <param name="incrementalLength">The incremental length.</param>
/// <returns>The System.Boolean.</returns>
private bool CreateMiddleRebar(SingleRebar currentOriginalRebar, Vector splitPattern, ArrayList splitRebarSet, ref double incrementalLength)
{
var rebarPoints = new ArrayList();
double rebarLength, finalRebarLength;
splitPattern.Normalize(incrementalLength);
var firstPoint = new Vector(splitPattern);
this.GetRebarMaximumLength(FirstOrLastEnum.MiddleRebar, out rebarLength);
splitPattern.Normalize(rebarLength);
var secondPoint = new Vector(splitPattern);
rebarPoints.Add((Point)currentOriginalRebar.Polygon.Points[0] + firstPoint);
rebarPoints.Add((Point)currentOriginalRebar.Polygon.Points[0] + firstPoint + secondPoint);
bool result = this.CreateSplittedRebars(FirstOrLastEnum.MiddleRebar, rebarPoints, splitRebarSet, out finalRebarLength);
incrementalLength += finalRebarLength;
return(result);
}
internal static SingleRebar GetSingleRebar()
{
var beam = GetBeam();
var solid = beam.GetSolid();
Polygon Polygon = new Polygon();
Polygon.Points.Add(new Point(solid.MinimumPoint.X, solid.MaximumPoint.Y, solid.MaximumPoint.Z));
Polygon.Points.Add(new Point(solid.MaximumPoint.X, solid.MaximumPoint.Y, solid.MaximumPoint.Z));
SingleRebar singleRebar = new SingleRebar
{
Polygon = Polygon,
Father = beam,
Name = "SingleRebar",
Class = 9,
Size = "12",
Grade = "A500HW",
OnPlaneOffsets = new ArrayList {
25.00
},
NumberingSeries = new NumberingSeries("Single", 0),
StartHook = new RebarHookData()
{
Angle = -90,
Length = 10,
Radius = 10,
Shape = RebarHookData.RebarHookShapeEnum.CUSTOM_HOOK
},
EndHook = new RebarHookData()
{
Angle = 90,
Length = 10,
Radius = 10,
Shape = RebarHookData.RebarHookShapeEnum.CUSTOM_HOOK
}
};
singleRebar.Insert();
return(singleRebar);
}
/// <summary>The get single rebar.</summary>
/// <param name="rebarPoints">The reinforcement bar points.</param>
/// <returns>The Tekla.Structures.Model.SingleRebar.</returns>
public SingleRebar GetSingleRebar(ArrayList rebarPoints)
{
var newRebar = new SingleRebar();
var polyRebar = new Polygon();
polyRebar.Points.Add(rebarPoints[0]);
polyRebar.Points.Add(rebarPoints[1]);
newRebar.Polygon = polyRebar;
var originalSingleRebar = this.originalRebar as SingleRebar;
if (originalSingleRebar != null)
{
this.SetNewRebarPropertiesFromSingleRebar(newRebar, originalSingleRebar);
}
else
{
var originalRebarGroup = this.originalRebar as RebarGroup;
if (originalRebarGroup != null)
{
this.SetNewRebarPropertiesFromRebarGroup(newRebar, originalRebarGroup);
}
}
// Needed to ensure that the reinforcement bar ends will not overcome the cover thinkness.
if (newRebar.EndPointOffsetType == Reinforcement.RebarOffsetTypeEnum.OFFSET_TYPE_COVER_THICKNESS &&
newRebar.EndPointOffsetValue < OverhangEpsilon)
{
newRebar.EndPointOffsetValue = OverhangEpsilon;
}
if (newRebar.StartPointOffsetType == Reinforcement.RebarOffsetTypeEnum.OFFSET_TYPE_COVER_THICKNESS &&
newRebar.StartPointOffsetValue < OverhangEpsilon)
{
newRebar.StartPointOffsetValue = OverhangEpsilon;
}
return(newRebar);
}
private void fabricarDiagonales()
{
double i = p.max.Y - p.dy - DISTANCIA_A_TUBO;
while (i - NORMAL_DIAGONAL > p.min.Y)
{
T3D.Point p1 = new T3D.Point(XDiagonal(offset), i, z1());
T3D.Point p2 = new T3D.Point(XDiagonal(offset), p1.Y - NORMAL_DIAGONAL, z2());
T3D.Point p3 = new T3D.Point(XDiagonal(offset), p2.Y - 50.0, z2());
T3D.Point p4 = new T3D.Point(XDiagonal(offset), p3.Y - NORMAL_DIAGONAL, z1());
SingleRebar d1 = FabricaElementosPanel.createDiagonal(p1, p2, p.diametroDiagonal);
SingleRebar d2 = FabricaElementosPanel.createDiagonal(p3, p4, p.diametroDiagonal);
d1.Father = p.muro;
d2.Father = p.muro;
d1.Insert();
d2.Insert();
i -= 400.0;
}
}
private void fabricarDiagonales()
{
double i = -(p.min.X + p.dx + DISTANCIA_A_TUBO);
while (-i + NORMAL_DIAGONAL < p.max.X)
{
T3D.Point p1 = new T3D.Point(-i, YDiagonal(offset), z2());
T3D.Point p2 = new T3D.Point(p1.X + NORMAL_DIAGONAL, YDiagonal(offset), z1());
T3D.Point p3 = new T3D.Point(p2.X + 50.0, YDiagonal(offset), z1());
T3D.Point p4 = new T3D.Point(p3.X + NORMAL_DIAGONAL, YDiagonal(offset), z2());
SingleRebar d1 = FabricaElementosPanel.createDiagonal(p1, p2, p.diametroDiagonal);
SingleRebar d2 = FabricaElementosPanel.createDiagonal(p3, p4, p.diametroDiagonal);
d1.Father = p.muro;
d2.Father = p.muro;
d1.Insert();
d2.Insert();
i -= 400.0;
}
}
/// <summary>The split reinforcement bars if needed.</summary>
/// <param name="newSplitRebars">The split reinforcement bars.</param>
/// <returns>The System.Boolean.</returns>
public bool SplitRebarsIfNeeded(out ArrayList newSplitRebars)
{
var result = false;
var remainingOffset = 0.0;
newSplitRebars = new ArrayList();
if (this.singleRebars.Count > 0)
{
for (var rebarIndex = 0; rebarIndex < this.singleRebars.Count; rebarIndex++)
{
this.originalRebar = this.singleRebars[rebarIndex] as SingleRebar;
double length = Distance.PointToPoint((Point)this.originalRebar.Polygon.Points[1], (Point)this.originalRebar.Polygon.Points[0]);
double diameter = this.GetRebarDiameter(this.originalRebar.Size, this.originalRebar.Grade);
this.startHookLength = this.GetHookRealLength(this.originalRebar.StartHook, diameter);
this.endHookLength = this.GetHookRealLength(this.originalRebar.EndHook, diameter);
if (this.originalRebar != null && length > this.splitData.MaxLength + this.GetRebarLengthEpsilon())
{
bool rebarSplitted;
ArrayList splitRebarSet;
switch (this.splitData.SpliceSection)
{
case 0:
rebarSplitted = this.SplitEveryRebarInSameLocation(rebarIndex, ref remainingOffset, new List <double>(), out splitRebarSet);
break;
case 1:
rebarSplitted = this.SplitEverySecondRebarInSameLocation(rebarIndex, ref remainingOffset, new List <double>(), out splitRebarSet);
break;
case 2:
rebarSplitted = this.SplitEveryThirdRebarInSameLocation(rebarIndex, new List <double>(), ref remainingOffset, out splitRebarSet);
break;
case 3:
rebarSplitted = this.SplitEveryFourthRebarInSameLocation(rebarIndex, new List <double>(), ref remainingOffset, out splitRebarSet);
break;
default:
rebarSplitted = this.SplitEveryRebarInSameLocation(rebarIndex, ref remainingOffset, new List <double>(), out splitRebarSet);
break;
}
if (rebarSplitted)
{
foreach (SingleRebar splitRebar in splitRebarSet)
{
newSplitRebars.Add(splitRebar);
}
}
}
else
{
newSplitRebars.Add(this.originalRebar);
}
}
result = true;
}
return(result);
}
/// <summary>The split rebar.</summary>
/// <param name="originalRebar">The original rebar.</param>
/// <param name="section">The section.</param>
/// <param name="barPosition">The bar position.</param>
/// <param name="rebarSegmentLengths">Lengths of all rebars segments.</param>
/// <param name="remainingOffset">The remaining offset.</param>
/// <param name="splitRebarSet">The split reinforcement bar set.</param>
/// <returns>The System.Boolean.</returns>
private bool SplitRebar(
SingleRebar originalRebar,
SpliceSection section,
BarPositions barPosition,
List <double> rebarSegmentLengths,
ref double remainingOffset,
out ArrayList splitRebarSet)
{
bool result = true;
double maxLength;
double totalOffset;
double remainingLength;
double hookLength;
double incrementalLength = 0.0;
double totalRebarLength = 0.0;
double previousLength = 0.0;
splitRebarSet = new ArrayList();
ArrayList previousPoints = new ArrayList();
foreach (double length in rebarSegmentLengths)
{
totalRebarLength += length;
}
CreateSingleRebar createSingleRebar = new CreateSingleRebar(originalRebar);
for (int jj = 0; jj < originalRebar.Polygon.Points.Count - 1; jj++)
{
Vector splitPattern = new Vector((Point)originalRebar.Polygon.Points[jj + 1] - (Point)originalRebar.Polygon.Points[jj]);
this.GetRebarMaximumLength(FirstOrLastEnum.MiddleRebar, out maxLength);
this.CalculateTotalOffset(
totalRebarLength,
section,
barPosition,
remainingOffset,
out totalOffset,
out remainingLength,
out hookLength);
ArrayList splitRebarSegment = new ArrayList();
ArrayList rebarPoints = new ArrayList();
rebarPoints.Add(originalRebar.Polygon.Points[jj]);
rebarPoints.Add(originalRebar.Polygon.Points[jj + 1]);
SingleRebar segmentToSplit = createSingleRebar.GetSingleRebar(rebarPoints);
if ((previousLength + rebarSegmentLengths[jj]) > maxLength)
{
for (int ii = 0; incrementalLength + this.GetRebarLengthEpsilon() < totalRebarLength; ii++)
{
if (ii == 0 && jj == 0)
{
result &= this.CreateStartRebar(segmentToSplit, splitPattern, splitRebarSegment, totalOffset, hookLength, ref incrementalLength);
}
else if (incrementalLength + maxLength + this.GetRebarLengthEpsilon() < totalRebarLength)
{
int centralBarsCount = (int)Math.Floor(totalRebarLength / maxLength);
if (this.splitData.SpliceSymmetry == 2 &&
barPosition == BarPositions.First &&
centralBarsCount > 1 &&
incrementalLength < totalRebarLength / 2.0 &&
incrementalLength + maxLength > totalRebarLength / 2.0)
{
result &= this.CreateDifferentMiddleRebarInCenterSymmetry(remainingLength, segmentToSplit, ref splitPattern, ref incrementalLength, ref splitRebarSegment);
}
else
{
result &= this.CreateMiddleRebar(segmentToSplit, splitPattern, splitRebarSegment, ref incrementalLength);
}
}
else
{
double lastSegment;
double segmentLength;
if (incrementalLength < maxLength + DistanceEpsilon)
{
segmentLength = rebarSegmentLengths[jj] - (maxLength - incrementalLength);
}
else
{
int multiplayer = (int)(incrementalLength / maxLength);
segmentLength = rebarSegmentLengths[jj] - ((multiplayer + 1) * maxLength - incrementalLength);
}
result &= this.CreateEndRebar(segmentToSplit, maxLength, splitPattern, splitRebarSegment, ref segmentLength, out lastSegment);
incrementalLength = segmentLength;
if (barPosition == BarPositions.First)
{
remainingOffset = lastSegment;
}
}
}
}
else
{
incrementalLength += rebarSegmentLengths[jj];
previousLength += rebarSegmentLengths[jj];
this.AddRebarPoint(originalRebar.Polygon.Points[jj] as Point, previousPoints);
this.AddRebarPoint(originalRebar.Polygon.Points[jj + 1] as Point, previousPoints);
DrawPoint(originalRebar.Polygon.Points[jj] as Point, jj.ToString());
DrawPoint(originalRebar.Polygon.Points[jj + 1] as Point, (jj + 1).ToString());
}
if (splitRebarSegment.Count != 0 && previousPoints.Count > 0)
{
DrawPoint(((SingleRebar)splitRebarSegment[0]).Polygon.Points[0] as Point, "SP" + jj.ToString());
DrawPoint(((SingleRebar)splitRebarSegment[0]).Polygon.Points[1] as Point, "SP" + (jj + 1).ToString());
previousPoints.Add(((SingleRebar)splitRebarSegment[0]).Polygon.Points[0]);
SingleRebar previousBar = createSingleRebar.GetSingleRebar(previousPoints);
splitRebarSegment.Insert(0, previousBar);
previousPoints.Clear();
previousLength = 0.0;
}
splitRebarSet.AddRange(splitRebarSegment);
}
return(result);
}
/// <summary>The get reinforcement bar vector for single rebar.</summary>
/// <param name="pointIndex">The point index.</param>
/// <param name="rebar">The rebar.</param>
/// <returns>The Tekla.Structures.Geometry3d.Vector.</returns>
private Vector GetRebarVectorForSingleRebar(int pointIndex, SingleRebar rebar)
{
return(pointIndex == 0 ?
new Vector((Point)rebar.Polygon.Points[1] - (Point)rebar.Polygon.Points[0]) :
new Vector((Point)rebar.Polygon.Points[0] - (Point)rebar.Polygon.Points[1]));
}
