avpon/StructureHelper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add triangulation of polygon

Browse Source
This commit is contained in:
Evgeny Redikultsev
2025-10-26 22:19:25 +05:00
parent 196dc636bb
commit 09dcf4e7e9
52 changed files with 686 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
DataAccess/DTOs/Converters/DivisionSizeFromDTOConvertStrategy.cs Normal file
View File

@@ -0,0 +1,32 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace DataAccess.DTOs
{
public class DivisionSizeFromDTOConvertStrategy : ConvertStrategy<IDivisionSize, IDivisionSize>
{
IUpdateStrategy<IDivisionSize> updateStrategy;
public DivisionSizeFromDTOConvertStrategy(IUpdateStrategy<IDivisionSize> updateStrategy)
{
this.updateStrategy = updateStrategy;
}
public DivisionSizeFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
updateStrategy = new DivisionSizeUpdateStrategy();
}
public override IDivisionSize GetNewItem(IDivisionSize source)
{
if (source is not DivisionSizeDTO sourceDTO)
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source));
}
NewItem = new DivisionSize(source.Id);
updateStrategy.Update(NewItem, sourceDTO);
return NewItem;
}
}
}

2
DataAccess/DTOs/Converters/Forces/ForceCombinationFromFileFromDTOConvertStrategy.cs
View File

@@ -104,7 +104,7 @@ namespace DataAccess.DTOs
private void InitializeStrategies()
{
updateStrategy ??= new ForceCombinationFromFileUpdateStrategy();
pointConvertStrategy = new Point2DFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger};
pointConvertStrategy = new Point2DFromDTOConvertStrategy(this);
combinationPropertyConvertStrategy = new FactoredCombinationPropertyFromDTOConvertStrategy(ReferenceDictionary, TraceLogger);
fileConvertStrategy ??= new ColumnedFilePropertyFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
}

2
DataAccess/DTOs/Converters/Forces/ForceCombinationListFromDTOConvertStrategy.cs
View File

@@ -72,7 +72,7 @@ namespace DataAccess.DTOs
{
baseUpdateStrategy ??= new ForceActionBaseUpdateStrategy();
updateStrategy ??= new ForceCombinationListUpdateStrategy();
pointConvertStrategy ??= new Point2DFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger};
pointConvertStrategy ??= new Point2DFromDTOConvertStrategy(this);
designTupleConvertStrategy ??= new DesignForceTupleFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
}
}

2
DataAccess/DTOs/Converters/Forces/ForceFactoredListFromDTOConvertStrategy.cs
View File

@@ -85,7 +85,7 @@ namespace DataAccess.DTOs
{
baseUpdateStrategy ??= new ForceActionBaseUpdateStrategy();
updateStrategy ??= new ForceFactoredListUpdateStrategy();
pointConvertStrategy ??= new Point2DFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger};
pointConvertStrategy ??= new Point2DFromDTOConvertStrategy(this);
forceTupleConvertStrategy ??= new ForceTupleFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
combinationPropertyConvertStrategy ??= new FactoredCombinationPropertyFromDTOConvertStrategy(ReferenceDictionary, TraceLogger);
}

5
DataAccess/DTOs/Converters/NdmCrossSections/EllipseNdmPrimitiveFromDTOConvertStrategy.cs
View File

@@ -1,10 +1,5 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DataAccess.DTOs
{

5
DataAccess/DTOs/Converters/NdmCrossSections/HasPrimitivesFromDTOUpdateStrategy.cs
View File

@@ -1,11 +1,6 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DataAccess.DTOs.Converters
{

36
DataAccess/DTOs/Converters/NdmCrossSections/NdmElementFromDTOConvertStrategy.cs Normal file
View File

@@ -0,0 +1,36 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives.Logics;
namespace DataAccess.DTOs
{
public class NdmElementFromDTOConvertStrategy : ConvertStrategy<INdmElement, INdmElement>
{
private IUpdateStrategy<INdmElement> updateStrategy;
private IUpdateStrategy<IForceTuple> forceUpdateStrategy = new ForceTupleUpdateStrategy();
private NdmElement newItem;
public NdmElementFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
}
public override INdmElement GetNewItem(INdmElement source)
{
if (source is not NdmElementDTO sourceDTO)
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source));
}
newItem = new NdmElement(sourceDTO.Id);
updateStrategy = new NdmElementUpdateStrategy() { UpdateChildren = false};
updateStrategy.Update(newItem, sourceDTO);
forceUpdateStrategy.Update(newItem.UsersPrestrain, source.UsersPrestrain);
//newItem.UsersPrestrain.Id = source.UsersPrestrain.Id;
//forceUpdateStrategy.Update(newItem.AutoPrestrain, source.AutoPrestrain);
//(newItem.AutoPrestrain as ForceTupleDTO).Id = source.AutoPrestrain.Id;
NewItem = newItem;
return NewItem;
}
}
}

14
DataAccess/DTOs/Converters/NdmCrossSections/NdmElementToDTOConvertStrategy.cs
View File

@@ -54,16 +54,20 @@ namespace DataAccess.DTOs
updateStrategy.Update(newItem, source);
headMaterialConvertStrategy.ReferenceDictionary = ReferenceDictionary;
headMaterialConvertStrategy.TraceLogger = TraceLogger;
var convertLogic = new DictionaryConvertStrategy<HeadMaterialDTO, IHeadMaterial>(this, headMaterialConvertStrategy);
var headMaterialLogic = new DictionaryConvertStrategy<HeadMaterialDTO, IHeadMaterial>(this, headMaterialConvertStrategy);
if (source.HeadMaterial != null)
{
var headMaterial = convertLogic.Convert(source.HeadMaterial);
var headMaterial = headMaterialLogic.Convert(source.HeadMaterial);
newItem.HeadMaterial = headMaterial;
}
}
else
{
newItem.HeadMaterial = null;
}
forceUpdateStrategy.Update(newItem.UsersPrestrain, source.UsersPrestrain);
(newItem.UsersPrestrain as ForceTupleDTO).Id = source.UsersPrestrain.Id;
forceUpdateStrategy.Update(newItem.AutoPrestrain, source.AutoPrestrain);
(newItem.AutoPrestrain as ForceTupleDTO).Id = source.AutoPrestrain.Id;
//forceUpdateStrategy.Update(newItem.AutoPrestrain, source.AutoPrestrain);
//(newItem.AutoPrestrain as ForceTupleDTO).Id = source.AutoPrestrain.Id;
return newItem;
}

19
DataAccess/DTOs/Converters/NdmCrossSections/NdmPrimitiveFromDTOConvertStrategy.cs
View File

@@ -45,9 +45,12 @@ namespace DataAccess.DTOs
public override INdmPrimitive GetNewItem(INdmPrimitive source)
{
GetMaterial(source.NdmElement.HeadMaterial);
INdmPrimitive newItem = GetNewPrimitive(source);
newItem.NdmElement.HeadMaterial = headMaterial;
if (source.NdmElement.HeadMaterial != null)
{
GetMaterial(source.NdmElement.HeadMaterial);
newItem.NdmElement.HeadMaterial = headMaterial;
}
return newItem;
}
@@ -69,11 +72,23 @@ namespace DataAccess.DTOs
{
return GetRectangle(rectangle);
}
if (source is ShapeNdmPrimitiveDTO shape)
{
return GetShape(shape);
}
string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source);
TraceLogger.AddMessage(errorString, TraceLogStatuses.Error);
throw new StructureHelperException(errorString);
}
private INdmPrimitive GetShape(ShapeNdmPrimitiveDTO shape)
{
TraceLogger?.AddMessage($"{PrimitiveIs} shape ndm primitive");
ShapeNdmPrimitiveFromDTOConvertStrategy convertStrategy = new(this);
IShapeNdmPrimitive shapeNdmPrimitive = convertStrategy.Convert(shape);
return shapeNdmPrimitive;
}
private void GetMaterial(IHeadMaterial source)
{
HeadMaterialFromDTOConvertStrategy convertStrategy = new()

5
DataAccess/DTOs/Converters/NdmCrossSections/RebarNdmPrimitiveFromDTOConvertStrategy.cs
View File

@@ -1,10 +1,5 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DataAccess.DTOs
{

52
DataAccess/DTOs/Converters/NdmCrossSections/ShapeNdmPrimitiveFromDTOConvertStrategy.cs Normal file
View File

@@ -0,0 +1,52 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Shapes;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace DataAccess.DTOs
{
public class ShapeNdmPrimitiveFromDTOConvertStrategy : ConvertStrategy<IShapeNdmPrimitive, IShapeNdmPrimitive>
{
IUpdateStrategy<IShapeNdmPrimitive> updateStrategy;
private IConvertStrategy<IShape, IShape> shapeConvertStrategy;
private IConvertStrategy<INdmElement, INdmElement> ndmElementConvertStrategy;
private IConvertStrategy<Point2D, Point2DDTO> pointConvertStrategy;
private IConvertStrategy<IVisualProperty, VisualPropertyDTO> visualPropsConvertStrategy;
private IConvertStrategy<IDivisionSize, IDivisionSize> divisionConvertStrategy;
private ShapeNdmPrimitive newItem;
public ShapeNdmPrimitiveFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
updateStrategy = new ShapeNdmPrimitiveUpdateStrategy() { UpdateChildren = false };
shapeConvertStrategy = new ShapeFromDTOConvertStrategy(this);
ndmElementConvertStrategy = new NdmElementFromDTOConvertStrategy(this);
pointConvertStrategy = new Point2DFromDTOConvertStrategy(this);
visualPropsConvertStrategy = new VisualPropertyFromDTOConvertStrategy(this);
divisionConvertStrategy = new DivisionSizeFromDTOConvertStrategy(this);
}
public override IShapeNdmPrimitive GetNewItem(IShapeNdmPrimitive source)
{
ChildClass = this;
if (source is not ShapeNdmPrimitiveDTO sourceDTO)
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source) + ": source shape is not DTO object");
}
newItem = new(source.Id);
updateStrategy.Update(newItem, sourceDTO);
updateChildProperties(sourceDTO);
NewItem = newItem;
return NewItem;
}
private void updateChildProperties(ShapeNdmPrimitiveDTO source)
{
newItem.SetShape(shapeConvertStrategy.Convert(source.Shape));
newItem.NdmElement = ndmElementConvertStrategy.Convert(source.NdmElement);
newItem.Center = pointConvertStrategy.Convert(source.Center as Point2DDTO);
newItem.VisualProperty = visualPropsConvertStrategy.Convert(source.VisualProperty as VisualPropertyDTO);
newItem.DivisionSize = divisionConvertStrategy.Convert(source.DivisionSize);
}
}
}

43
DataAccess/DTOs/Converters/Shapes/LinePolygonFromDTOConvertStrategy.cs Normal file
View File

@@ -0,0 +1,43 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Shapes;
namespace DataAccess.DTOs
{
public class LinePolygonFromDTOConvertStrategy : ConvertStrategy<ILinePolygonShape, ILinePolygonShape>
{
private IUpdateStrategy<ILinePolygonShape> updateStrategy;
private IConvertStrategy<IVertex, IVertex> vertexConvertStrategy;
private LinePolygonShape newItem;
public LinePolygonFromDTOConvertStrategy(IUpdateStrategy<ILinePolygonShape> updateStrategy)
{
this.updateStrategy = updateStrategy;
}
public LinePolygonFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
updateStrategy = new LinePolygonShapeUpdateStrategy() { UpdateChildren = false };
vertexConvertStrategy = new VertexFtomDTOConvertStrategy(this);
}
public override ILinePolygonShape GetNewItem(ILinePolygonShape source)
{
ChildClass = this;
if (source is not LinePolygonShapeDTO sourceDTO)
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source) + ": source line polygon is not DTO object");
}
newItem = new(sourceDTO.Id);
updateStrategy.Update(newItem, sourceDTO);
newItem.Clear();
foreach (var item in source.Vertices)
{
IVertex newVertex = vertexConvertStrategy.Convert(item);
newItem.AddVertex(newVertex);
}
NewItem = newItem;
return NewItem;
}
}
}

14
DataAccess/DTOs/Converters/Shapes/LinePolygonToDTOConvertStrategy.cs
View File

@@ -12,24 +12,26 @@ namespace DataAccess.DTOs
{
private IUpdateStrategy<ILinePolygonShape> updateStrategy;
private IConvertStrategy<VertexDTO, IVertex> vertexConvertStrategy;
private LinePolygonShapeDTO newItem;
public LinePolygonToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
updateStrategy = new LinePolygonShapeUpdateStrategy() { UpdateChildren = false };
vertexConvertStrategy = new VertexToDTOConvertStrategy(this);
}
public override LinePolygonShapeDTO GetNewItem(ILinePolygonShape source)
{
ChildClass = this;
NewItem = new(source.Id);
updateStrategy = new LinePolygonShapeUpdateStrategy() { UpdateChildren = false };
vertexConvertStrategy = new VertexToDTOConvertStrategy(this);
updateStrategy.Update(NewItem, source);
NewItem.Clear();
newItem = new(source.Id);
updateStrategy.Update(newItem, source);
newItem.Clear();
foreach (var item in source.Vertices)
{
VertexDTO newVertex = vertexConvertStrategy.Convert(item);
NewItem.AddVertex(newVertex);
newItem.AddVertex(newVertex);
}
NewItem = newItem;
return NewItem;
}
}

30
DataAccess/DTOs/Converters/Shapes/Point2DFromDTOConvertStrategy.cs
View File

@@ -1,12 +1,5 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Loggers;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Shapes;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DataAccess.DTOs
{
@@ -24,27 +17,16 @@ namespace DataAccess.DTOs
}
public override Point2D GetNewItem(Point2DDTO source)
public Point2DFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
TraceLogger?.AddMessage("Point 2D converting has been started");
try
{
Point2D newItem = GetNewItemBySource(source);
TraceLogger?.AddMessage("Point 2D converting has been finished");
return newItem;
}
catch (Exception ex)
{
TraceLogger?.AddMessage($"Logic: {LoggerStrings.LogicType(this)} made error: {ex.Message}", TraceLogStatuses.Error);
throw;
}
updateStrategy = new Point2DUpdateStrategy();
}
private Point2D GetNewItemBySource(Point2DDTO source)
public override Point2D GetNewItem(Point2DDTO source)
{
Point2D newItem = new(source.Id);
updateStrategy.Update(newItem, source);
return newItem;
NewItem = new(source.Id);
updateStrategy.Update(NewItem, source);
return NewItem;
}
}
}

6
DataAccess/DTOs/Converters/Shapes/ShapeFromDTOConvertStrategy.cs
View File

@@ -28,6 +28,12 @@ namespace DataAccess.DTOs
(this, new CircleShapeFromDTOConvertStrategy(this));
NewItem = circleConvertStrategy.Convert(circleShapeDTO);
}
else if (source is LinePolygonShapeDTO linePolygonDTO)
{
var polygonConvertStrategy = new DictionaryConvertStrategy<ILinePolygonShape, ILinePolygonShape>
(this, new LinePolygonFromDTOConvertStrategy(this));
NewItem = polygonConvertStrategy.Convert(linePolygonDTO);
}
else
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source) + ": shape is unknown");

33
DataAccess/DTOs/Converters/Shapes/VertexFtomDTOConvertStrategy.cs Normal file
View File

@@ -0,0 +1,33 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Shapes;
namespace DataAccess.DTOs
{
public class VertexFtomDTOConvertStrategy : ConvertStrategy<IVertex, IVertex>
{
private IUpdateStrategy<IVertex> updateStrategy;
private IConvertStrategy<Point2D, Point2DDTO> pointConvertStrategy;
private Vertex newItem;
public VertexFtomDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
updateStrategy = new VertexUpdateStrategy() { UpdateChildren = false };
pointConvertStrategy = new Point2DFromDTOConvertStrategy(this);
}
public override IVertex GetNewItem(IVertex source)
{
ChildClass = this;
if (source is not VertexDTO sourceDTO)
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source) + ": source vertex is not DTO object");
}
newItem = new(sourceDTO.Id);
updateStrategy.Update(newItem, sourceDTO);
newItem.Point = pointConvertStrategy.Convert(sourceDTO.Point as Point2DDTO);
NewItem = newItem;
return NewItem;
}
}
}

27
DataAccess/DTOs/Converters/VisualPropertyFromDTOConvertStrategy.cs Normal file
View File

@@ -0,0 +1,27 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace DataAccess.DTOs
{
public class VisualPropertyFromDTOConvertStrategy : ConvertStrategy<IVisualProperty, VisualPropertyDTO>
{
IUpdateStrategy<IVisualProperty> updateStrategy;
public VisualPropertyFromDTOConvertStrategy(IUpdateStrategy<IVisualProperty> updateStrategy)
{
this.updateStrategy = updateStrategy;
}
public VisualPropertyFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
updateStrategy = new VisualPropsUpdateStrategy();
}
public override IVisualProperty GetNewItem(VisualPropertyDTO source)
{
NewItem = new VisualProperty(source.Id);
updateStrategy.Update(NewItem, source);
return NewItem;
}
}
}

2
DataAccess/DTOs/DTOEntities/NdmCrossSections/NdmElementDTO.cs
View File

@@ -15,7 +15,7 @@ namespace DataAccess.DTOs
public bool Triangulate { get; set; }
[JsonProperty("UsersPrestrain")]
public IForceTuple UsersPrestrain { get; set; } = new ForceTupleDTO(Guid.NewGuid());
[JsonProperty("AutoPrestrain")]
[JsonIgnore]
public IForceTuple AutoPrestrain { get; set; } = new ForceTupleDTO(Guid.NewGuid());
public NdmElementDTO(Guid id)

2
DataAccess/DTOs/DTOEntities/NdmCrossSections/ShapeNdmPrimitiveDTO.cs
View File

@@ -21,7 +21,7 @@ namespace DataAccess.DTOs
[JsonProperty("Name")]
public string? Name { get; set; }
[JsonProperty("Shape")]
public IShape Shape => shape;
public IShape Shape { get => shape; set => shape = value; }
[JsonProperty("NdmElement")]
public INdmElement NdmElement { get; set; }
[JsonProperty("Center")]

5
DataAccess/DTOs/DTOEntities/Shapes/LinePolygonShapeDTO.cs
View File

@@ -9,10 +9,11 @@ namespace DataAccess.DTOs
[JsonProperty("Id")]
public Guid Id { get; }
[JsonProperty("Vertices")]
public IReadOnlyList<IVertex> Vertices => _vertices;
public List<IVertex> VerticesList {get => _vertices;}
[JsonProperty("IsClosed")]
public bool IsClosed { get; set; }
[JsonIgnore]
public IReadOnlyList<IVertex> Vertices => _vertices;
public LinePolygonShapeDTO(Guid id)
{

137
DataAccess/DTOs/DTOEntities/TypeBinderListFactory.cs
View File

@@ -5,6 +5,7 @@ using StructureHelperCommon.Models.Analyses;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Materials.Libraries;
using StructureHelperCommon.Models.Shapes;
using StructureHelperLogics.Models.BeamShears;
using StructureHelperLogics.NdmCalculations.Primitives;
@@ -34,70 +35,117 @@ namespace DataAccess.DTOs
List<(Type type, string name)> newList = new List<(Type type, string name)>
{
{ (typeof(AccuracyDTO), "Accuracy") },
{ (typeof(CircleShapeDTO), "CircleShape") },
{ (typeof(ConcreteLibMaterialDTO), "ConcreteLibMaterial") },
{ (typeof(ColumnFilePropertyDTO), "ColumnFileProperty") },
{ (typeof(ColumnedFilePropertyDTO), "ColumnedFileProperty") },
{ (typeof(CompressedMemberDTO), "CompressedMember") },
{ (typeof(CrackCalculatorDTO), "CrackCalculator") },
{ (typeof(CrackCalculatorInputDataDTO), "CrackCalculatorInputData") },
{ (typeof(CrossSectionDTO), "CrossSection") },
{ (typeof(CrossSectionNdmAnalysisDTO), "CrossSectionNdmAnalysis") },
{ (typeof(CrossSectionRepositoryDTO), "CrossSectionRepository") },
{ (typeof(DateVersionDTO), "DateVersion") },
{ (typeof(DesignForceTupleDTO), "DesignForceTuple") },
{ (typeof(DivisionSizeDTO), "DivisionSize") },
{ (typeof(ElasticMaterialDTO), "ElasticMaterial") },
{ (typeof(EllipseNdmPrimitiveDTO), "EllipseNdmPrimitive") },
{ (typeof(FileVersionDTO), "FileVersion") },
{ (typeof(ForceCalculatorDTO), "ForceCalculator") },
{ (typeof(ForceCalculatorInputDataDTO), "ForceCalculatorInputData") },
{ (typeof(FRMaterialDTO), "FRMaterial") },
{ (typeof(HeadMaterialDTO), "HeadMaterial") },
{ (typeof(MaterialSafetyFactorDTO), "MaterialSafetyFactor") },
{ (typeof(NdmElementDTO), "NdmElement") },
{ (typeof(IVisualAnalysis), "IVisualAnalysis") },
{ (typeof(List<CalcTerms>), "ListOfCalcTerms") },
{ (typeof(List<IColumnFileProperty>), "ColumnFileProperties") },
{ (typeof(List<IColumnedFileProperty>), "ColumnedFileProperties") },
{ (typeof(List<ICalculator>), "ListOfICalculator") },
{ (typeof(List<IDateVersion>), "ListOfIDateVersion") },
{ (typeof(List<IDesignForceTuple>), "ListOfIDesignForceTuple") },
{ (typeof(List<IForceAction>), "ListOfIForceAction") },
{ (typeof(List<IForceTuple>), "ListOfIForceTuple") },
{ (typeof(List<IHeadMaterial>), "ListOfIHeadMaterial") },
{ (typeof(List<LimitStates>), "ListOfLimitState") },
{ (typeof(List<IMaterialSafetyFactor>), "ListOfMaterialSafetyFactor") },
{ (typeof(List<IMaterialPartialFactor>), "ListOfMaterialPartialFactor") },
{ (typeof(List<INdmPrimitive>), "ListOfINdmPrimitive") },
{ (typeof(List<IPartialFactor>), "ListOfPartialFactor") },
{ (typeof(List<IVisualAnalysis>), "ListOfIVisualAnalysis") },
{ (typeof(Point2DDTO), "Point2D") },
{ (typeof(PointNdmPrimitiveDTO), "PointNdmPrimitive") },
{ (typeof(PrimitiveVisualPropertyDTO), "PrimitiveVisualProperty") },
{ (typeof(ProjectDTO), "Project") },
{ (typeof(RebarNdmPrimitiveDTO), "RebarNdmPrimitive") },
{ (typeof(RebarSectionDTO), "RebarSection") },
{ (typeof(RectangleNdmPrimitiveDTO), "RectangleNdmPrimitive") },
{ (typeof(RectangleShapeDTO), "RectangleShape") },
{ (typeof(ReinforcementLibMaterialDTO), "ReinforcementLibMaterial") },
{ (typeof(RootObjectDTO), "RootObject") },
{ (typeof(MaterialPartialFactorDTO), "MaterialPartialFactor") },
{ (typeof(VersionProcessorDTO), "VersionProcessor") },
{ (typeof(VisualAnalysisDTO), "VisualAnalysis") },
{ (typeof(VisualPropertyDTO), "VisualProperty") },
{ (typeof(UserCrackInputDataDTO), "UserCrackInputData") },
{ (typeof(WorkPlanePropertyDTO), "WorkPlanePropertyDTO") },
};
newList.AddRange(GetProjectList());
newList.AddRange(GetGeometryShapeList());
newList.AddRange(GetForceList());
newList.AddRange(GetListForBeamShear());
newList.AddRange(GetMaterialList());
newList.AddRange(GetCalculatorList());
newList.AddRange(GetNdmPrimitiveList());
newList.AddRange(GetBeamShearList());
return newList;
}
private static List<(Type type, string name)> GetProjectList()
{
List<(Type type, string name)> newList = new()
{
{ (typeof(List<IVisualAnalysis>), "ListOfIVisualAnalysis") },
{ (typeof(List<IDateVersion>), "ListOfIDateVersion") },
{ (typeof(RootObjectDTO), "RootObject") },
{ (typeof(ProjectDTO), "Project") },
{ (typeof(VersionProcessorDTO), "VersionProcessor") },
{ (typeof(DateVersionDTO), "DateVersion") },
{ (typeof(IVisualAnalysis), "IVisualAnalysis") },
{ (typeof(VisualAnalysisDTO), "VisualAnalysis") },
{ (typeof(FileVersionDTO), "FileVersion") },
};
return newList;
}
private static List<(Type type, string name)> GetMaterialList()
{
List<(Type type, string name)> newList = new()
{
{ (typeof(List<IMaterialPartialFactor>), "ListOfMaterialPartialFactor") },
{ (typeof(ConcreteLibMaterialDTO), "ConcreteLibMaterial") },
{ (typeof(ElasticMaterialDTO), "ElasticMaterial") },
{ (typeof(FRMaterialDTO), "FRMaterial") },
{ (typeof(HeadMaterialDTO), "HeadMaterial") },
{ (typeof(List<IHeadMaterial>), "ListOfIHeadMaterial") },
{ (typeof(MaterialSafetyFactorDTO), "MaterialSafetyFactor") },
{ (typeof(List<IMaterialSafetyFactor>), "ListOfMaterialSafetyFactor") },
{ (typeof(MaterialPartialFactorDTO), "MaterialPartialFactor") },
{ (typeof(ReinforcementLibMaterialDTO), "ReinforcementLibMaterial") },
};
return newList;
}
private static List<(Type type, string name)> GetCalculatorList()
{
List<(Type type, string name)> newList = new()
{
{ (typeof(List<ICalculator>), "ListOfICalculator") },
{ (typeof(ForceCalculatorDTO), "ForceCalculator") },
{ (typeof(ForceCalculatorInputDataDTO), "ForceCalculatorInputData") },
{ (typeof(CrackCalculatorDTO), "CrackCalculator") },
{ (typeof(CrackCalculatorInputDataDTO), "CrackCalculatorInputData") },
{ (typeof(UserCrackInputDataDTO), "UserCrackInputData") },
};
return newList;
}
private static List<(Type type, string name)> GetNdmPrimitiveList()
{
List<(Type type, string name)> newList = new()
{
{ (typeof(List<INdmPrimitive>), "ListOfINdmPrimitive") },
{ (typeof(CrossSectionNdmAnalysisDTO), "CrossSectionNdmAnalysis") },
{ (typeof(CrossSectionDTO), "CrossSection") },
{ (typeof(CrossSectionRepositoryDTO), "CrossSectionRepository") },
{ (typeof(NdmElementDTO), "NdmElement") },
{ (typeof(PointNdmPrimitiveDTO), "PointNdmPrimitive") },
{ (typeof(RebarNdmPrimitiveDTO), "RebarNdmPrimitive") },
{ (typeof(RectangleNdmPrimitiveDTO), "RectangleNdmPrimitive") },
{ (typeof(EllipseNdmPrimitiveDTO), "EllipseNdmPrimitive") },
{ (typeof(ShapeNdmPrimitiveDTO), "ShapeNdmPrimitive") },
{ (typeof(PrimitiveVisualPropertyDTO), "PrimitiveVisualProperty") },
};
return newList;
}
private static List<(Type type, string name)> GetGeometryShapeList()
{
List<(Type type, string name)> newList = new()
{
{ (typeof(List<IVertex>), "ListOfVertex2D") },
{ (typeof(Point2DDTO), "Point2D") },
{ (typeof(VertexDTO), "Vertex2D") },
{ (typeof(RectangleShapeDTO), "RectangleShape") },
{ (typeof(CircleShapeDTO), "CircleShape") },
{ (typeof(LinePolygonShapeDTO), "LinePolygonShape") },
};
return newList;
}
private static List<(Type type, string name)> GetForceList()
{
List<(Type type, string name)> newList = new()
{
{ (typeof(List<IForceAction>), "ListOfIForceAction") },
{ (typeof(List<IDesignForceTuple>), "ListOfIDesignForceTuple") },
{ (typeof(List<IForceTuple>), "ListOfIForceTuple") },
{ (typeof(DesignForceTupleDTO), "DesignForceTuple") },
{ (typeof(ConcentratedForceDTO), "ConcentratedForce") },
{ (typeof(DistributedLoadDTO), "DistributedLoad") },
{ (typeof(FactoredForceTupleDTO), "FactoredForceTuple") },
@@ -110,8 +158,7 @@ namespace DataAccess.DTOs
};
return newList;
}
private static List<(Type type, string name)> GetListForBeamShear()
private static List<(Type type, string name)> GetBeamShearList()
{
List<(Type type, string name)> newList = new()
{

16
FieldVisualizer/Entities/Values/Primitives/ITrianglePrimitive.cs Normal file
View File

@@ -0,0 +1,16 @@
using StructureHelperCommon.Models.Shapes;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace FieldVisualizer.Entities.Values.Primitives
{
public interface ITrianglePrimitive : IValuePrimitive
{
IPoint2D Point1 { get; set; }
IPoint2D Point2 { get; set; }
IPoint2D Point3 { get; set; }
}
}

31
FieldVisualizer/Entities/Values/Primitives/TrianglePrimitive.cs Normal file
View File

@@ -0,0 +1,31 @@
using StructureHelperCommon.Models.Shapes;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace FieldVisualizer.Entities.Values.Primitives
{
public class TrianglePrimitive : ITrianglePrimitive
{
public double Value { get; set; }
public IPoint2D Point1 { get; set; }
public IPoint2D Point2 { get; set; }
public IPoint2D Point3 { get; set; }
// --- Computed properties ---
// Centroid (geometric center)
public double CenterX => (Point1.X + Point2.X + Point3.X) / 3.0;
public double CenterY => (Point1.Y + Point2.Y + Point3.Y) / 3.0;
// Triangle area using determinant formula
public double Area =>
0.5 * Math.Abs(
(Point2.X - Point1.X) * (Point3.Y - Point1.Y) -
(Point3.X - Point1.X) * (Point2.Y - Point1.Y)
);
}
}

20
FieldVisualizer/Services/PrimitiveServices/PrimitiveOperations.cs
View File

@@ -53,19 +53,23 @@ namespace FieldVisualizer.Services.PrimitiveServices
List<double> coords = new List<double>();
foreach (var primitive in valuePrimitives)
{
if (primitive is IRectanglePrimitive)
if (primitive is IRectanglePrimitive rectanglePrimitive)
{
IRectanglePrimitive rectanglePrimitive = primitive as IRectanglePrimitive;
coords.Add(rectanglePrimitive.CenterX + rectanglePrimitive.Width / 2);
coords.Add(rectanglePrimitive.CenterX - rectanglePrimitive.Width / 2);
}
else if (primitive is ICirclePrimitive)
else if (primitive is ICirclePrimitive circlePrimitive)
{
ICirclePrimitive circlePrimitive = primitive as ICirclePrimitive;
coords.Add(circlePrimitive.CenterX + circlePrimitive.Diameter / 2);
coords.Add(circlePrimitive.CenterX - circlePrimitive.Diameter / 2);
}
else { throw new FieldVisulizerException(ErrorStrings.PrimitiveTypeIsUnknown);}
else if (primitive is ITrianglePrimitive triangle)
{
coords.Add(triangle.Point1.X);
coords.Add(triangle.Point2.X);
coords.Add(triangle.Point3.X);
}
else { throw new FieldVisulizerException(ErrorStrings.PrimitiveTypeIsUnknown); }
}
return coords;
}
@@ -87,6 +91,12 @@ namespace FieldVisualizer.Services.PrimitiveServices
coords.Add(circlePrimitive.CenterY + circlePrimitive.Diameter / 2);
coords.Add(circlePrimitive.CenterY - circlePrimitive.Diameter / 2);
}
else if (primitive is ITrianglePrimitive triangle)
{
coords.Add(triangle.Point1.Y);
coords.Add(triangle.Point2.Y);
coords.Add(triangle.Point3.Y);
}
else { throw new FieldVisulizerException(ErrorStrings.PrimitiveTypeIsUnknown); }
}
return coords;

76
FieldVisualizer/ViewModels/FieldViewerViewModels/FieldViewerViewModel.cs
View File

@@ -14,7 +14,9 @@ using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Shapes;
@@ -50,20 +52,20 @@ namespace FieldVisualizer.ViewModels.FieldViewerViewModels
set
{
primitiveSet = value;
OnPropertyChanged(nameof(PrimitiveSet));
AreaTotal = primitiveSet is null ? 0 : primitiveSet.ValuePrimitives.Sum(x => x.Area);
OnPropertyChanged(nameof(AreaTotal));
AreaNeg = primitiveSet is null ? 0 : primitiveSet.ValuePrimitives.Where(x => x.Value < 0d).Sum(x => x.Area);
OnPropertyChanged(nameof(AreaNeg));
AreaZero = primitiveSet is null ? 0 : primitiveSet.ValuePrimitives.Where(x => x.Value == 0d).Sum(x => x.Area);
OnPropertyChanged(nameof(AreaZero));
AreaPos = primitiveSet is null ? 0 : primitiveSet.ValuePrimitives.Where(x => x.Value > 0d).Sum(x => x.Area);
OnPropertyChanged(nameof(AreaPos));
SumTotal = primitiveSet is null ? 0 : primitiveSet.ValuePrimitives.Sum(x => x.Value);
OnPropertyChanged(nameof(SumTotal));
SumNeg = primitiveSet is null ? 0 : primitiveSet.ValuePrimitives.Where(x => x.Value < 0d).Sum(x => x.Value);
OnPropertyChanged(nameof(SumNeg));
SumPos = primitiveSet is null ? 0 : primitiveSet.ValuePrimitives.Where(x => x.Value > 0d).Sum(x => x.Value);
OnPropertyChanged(nameof(PrimitiveSet));
OnPropertyChanged(nameof(AreaTotal));
OnPropertyChanged(nameof(AreaNeg));
OnPropertyChanged(nameof(AreaZero));
OnPropertyChanged(nameof(AreaPos));
OnPropertyChanged(nameof(SumTotal));
OnPropertyChanged(nameof(SumNeg));
OnPropertyChanged(nameof(SumPos));
}
@@ -215,21 +217,56 @@ namespace FieldVisualizer.ViewModels.FieldViewerViewModels
WorkPlaneBox.Height = ScrolHeight - 50;
foreach (var primitive in PrimitiveSet.ValuePrimitives)
{
if (primitive is IRectanglePrimitive)
if (primitive is IRectanglePrimitive rectanglePrimitive)
{
IRectanglePrimitive rectanglePrimitive = primitive as IRectanglePrimitive;
Rectangle rectangle = ProcessRectanglePrimitive(rectanglePrimitive);
WorkPlaneCanvas.Children.Add(rectangle);
}
else if (primitive is ICirclePrimitive)
else if (primitive is ICirclePrimitive circlePrimitive)
{
ICirclePrimitive circlePrimitive = primitive as ICirclePrimitive;
Ellipse ellipse = ProcessCirclePrimitive(circlePrimitive);
WorkPlaneCanvas.Children.Add(ellipse);
}
else if (primitive is ITrianglePrimitive triangle)
{
Path path = ProcessTrianglePrimitive(triangle);
WorkPlaneCanvas.Children.Add(path);
}
else { throw new FieldVisulizerException(ErrorStrings.PrimitiveTypeIsUnknown); }
}
}
private Path ProcessTrianglePrimitive(ITrianglePrimitive triangle)
{
// Create the PathFigure using triangle vertices.
var figure = new PathFigure
{
StartPoint = new Point(triangle.Point1.X, triangle.Point1.Y),
IsClosed = true,
IsFilled = true
};
// Add the remaining vertices as LineSegments
var segments = new PathSegmentCollection
{
new LineSegment(new Point(triangle.Point2.X, triangle.Point2.Y), true),
new LineSegment(new Point(triangle.Point3.X, triangle.Point3.Y), true)
// Closing is handled by IsClosed = true, so we don't need to add a segment back to Point1
};
figure.Segments = segments;
// Create geometry and path
var geometry = new PathGeometry();
geometry.Figures.Add(figure);
var path = new Path
{
Data = geometry,
};
ProcessShape(path, triangle, 0, 0, false);
return path;
}
private Rectangle ProcessRectanglePrimitive(IRectanglePrimitive rectanglePrimitive)
{
Rectangle rectangle = new Rectangle
@@ -239,7 +276,7 @@ namespace FieldVisualizer.ViewModels.FieldViewerViewModels
};
double addX = rectanglePrimitive.Width / 2;
double addY = rectanglePrimitive.Height / 2;
ProcessShape(rectangle, rectanglePrimitive, addX, addY);
ProcessShape(rectangle, rectanglePrimitive, addX, addY, true);
return rectangle;
}
private Ellipse ProcessCirclePrimitive(ICirclePrimitive circlePrimitive)
@@ -252,10 +289,10 @@ namespace FieldVisualizer.ViewModels.FieldViewerViewModels
double addX = circlePrimitive.Diameter / 2;
double addY = circlePrimitive.Diameter / 2;
ProcessShape(ellipse, circlePrimitive, addX, addY);
ProcessShape(ellipse, circlePrimitive, addX, addY, true);
return ellipse;
}
private void ProcessShape(Shape shape, IValuePrimitive valuePrimitive, double addX, double addY)
private void ProcessShape(Shape shape, IValuePrimitive valuePrimitive, double addX, double addY, bool addCenter)
{
SolidColorBrush brush = new SolidColorBrush();
brush.Color = ColorOperations.GetColorByValue(valueRange, _ColorMap, valuePrimitive.Value);
@@ -269,8 +306,15 @@ namespace FieldVisualizer.ViewModels.FieldViewerViewModels
shape.ToolTip = roundLogic.RoundValue(valuePrimitive.Value);
shape.Tag = valuePrimitive;
shape.Fill = brush;
Canvas.SetLeft(shape, valuePrimitive.CenterX - addX - dX);
Canvas.SetTop(shape, -valuePrimitive.CenterY - addY + dY);
double addLeft = - addX - dX;
double addTop = - addY + dY;
if (addCenter == true)
{
addLeft += valuePrimitive.CenterX;
addTop -= valuePrimitive.CenterY;
}
Canvas.SetLeft(shape, addLeft);
Canvas.SetTop(shape, addTop);
}
private void Zoom(double coefficient)
{

BIN
StructureHelper/Libraries/LoaderCalculator.dll
View File

Binary file not shown.

BIN
StructureHelper/Libraries/Triangle.dll Normal file
View File

Binary file not shown.

17
StructureHelper/Services/ResultViewers/ShowIsoFieldResult.cs
View File

@@ -5,6 +5,7 @@ using LoaderCalculator.Data.Ndms;
using LoaderCalculator.Data.ResultData;
using LoaderCalculator.Logics;
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Models.Shapes;
using StructureHelperCommon.Services;
using StructureHelperLogics.NdmCalculations.Cracking;
using StructureHelperLogics.NdmCalculations.Triangulations;
@@ -85,6 +86,10 @@ namespace StructureHelper.Services.ResultViewers
{
valuePrimitive = ProcessRectangle(shapeNdm, val);
}
else if (ndm is ITriangleNdm triangle)
{
valuePrimitive = ProcessTriangle(triangle, val);
}
else
{
valuePrimitive = ProcessCircle(ndm, val);
@@ -92,6 +97,18 @@ namespace StructureHelper.Services.ResultViewers
return valuePrimitive;
}
private static IValuePrimitive ProcessTriangle(ITriangleNdm triangle, double val)
{
var primitive = new TrianglePrimitive()
{
Point1 = new Point2D() { X = triangle.Point1.X, Y = triangle.Point1.Y },
Point2 = new Point2D() { X = triangle.Point2.X, Y = triangle.Point2.Y },
Point3 = new Point2D() { X = triangle.Point3.X, Y = triangle.Point3.Y },
Value = val
};
return primitive;
}
private static IValuePrimitive ProcessRectangle(IRectangleNdm shapeNdm, double val)
{
return new RectanglePrimitive()

2
StructureHelperCommon/Models/Shapes/Logics/PolygonGeometryUtils.cs
View File

@@ -9,7 +9,7 @@ namespace StructureHelperCommon.Models.Shapes
{
public static class PolygonGeometryUtils
{
public static ILinePolygonShape GetTratsfromedPolygon(ILinePolygonShape polygon, double dx, double dy)
public static ILinePolygonShape GetTransfromedPolygon(ILinePolygonShape polygon, double dx, double dy)
{
ILinePolygonShape newPolygon = new LinePolygonShape(Guid.Empty);
var updateLogic = new LinePolygonShapeUpdateStrategy();

2
StructureHelperCommon/StructureHelperCommon.csproj
View File

@@ -11,7 +11,7 @@
<ItemGroup>
<PackageReference Include="ExcelDataReader" Version="3.8.0" />
<PackageReference Include="NLog" Version="6.0.4" />
<PackageReference Include="NLog" Version="6.0.5" />
</ItemGroup>
<ItemGroup>

2
StructureHelperLogics/NdmCalculations/Primitives/EllipseNdmPrimitive.cs
View File

@@ -67,7 +67,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
var ndms = new List<INdm>();
var options = new CircleTriangulationLogicOptions(this)
{
triangulationOptions = triangulationOptions
TriangulationOptions = triangulationOptions
};
var logic = new CircleTriangulationLogic(options);
ndms.AddRange(logic.GetNdmCollection());

1
StructureHelperLogics/NdmCalculations/Primitives/Logics/EllipsePrimitiveUpdateStrategy.cs
View File

@@ -1,6 +1,5 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Shapes;
using StructureHelperCommon.Models.Shapes.Logics;
using StructureHelperCommon.Services;
namespace StructureHelperLogics.NdmCalculations.Primitives

1
StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmElementUpdateStrategy.cs
View File

@@ -28,6 +28,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
if (ReferenceEquals(targetObject, sourceObject)) { return; }
targetObject.Triangulate = sourceObject.Triangulate;
tupleUpdateStrategy.Update(targetObject.UsersPrestrain, sourceObject.UsersPrestrain);
tupleUpdateStrategy.Update(targetObject.AutoPrestrain, sourceObject.AutoPrestrain);
if (UpdateChildren == true)
{
if (sourceObject.HeadMaterial != null)

2
StructureHelperLogics/NdmCalculations/Primitives/PointNdmPrimitive.cs
View File

@@ -46,7 +46,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
public IEnumerable<INdm> GetNdms(ITriangulationOptions triangulationOptions)
{
var options = new PointTriangulationLogicOptions(this) { triangulationOptions = triangulationOptions};
var options = new PointTriangulationLogicOptions(this) { TriangulationOptions = triangulationOptions};
var logic = new PointTriangulationLogic(options);
return logic.GetNdmCollection();
}

4
StructureHelperLogics/NdmCalculations/Primitives/RebarNdmPrimitive.cs
View File

@@ -78,7 +78,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
{
var options = new RebarTriangulationLogicOptions(this)
{
triangulationOptions = triangulationOptions
TriangulationOptions = triangulationOptions
};
var logic = new RebarTriangulationLogic(options);
var rebar = logic.GetRebarNdm();
@@ -89,7 +89,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
{
var options = new RebarTriangulationLogicOptions(this)
{
triangulationOptions = triangulationOptions
TriangulationOptions = triangulationOptions
};
var logic = new RebarTriangulationLogic(options);
var concrete = logic.GetConcreteNdm();

2
StructureHelperLogics/NdmCalculations/Primitives/RectangleNdmPrimitive.cs
View File

@@ -53,7 +53,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
var ndms = new List<INdm>();
var options = new RectangleTriangulationLogicOptions(this)
{
triangulationOptions = triangulationOptions
TriangulationOptions = triangulationOptions
};
var logic = new RectangleTriangulationLogic(options);
ndms.AddRange(logic.GetNdmCollection());

12
StructureHelperLogics/NdmCalculations/Primitives/ShapeNdmPrimitive.cs
View File

@@ -16,11 +16,11 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
public string? Name { get; set; } = string.Empty;
public IPoint2D Center { get; set; } = new Point2D();
public IShape Shape => shape;
public INdmElement NdmElement { get; } = new NdmElement(Guid.NewGuid());
public INdmElement NdmElement { get; set; } = new NdmElement(Guid.NewGuid());
public ICrossSection? CrossSection { get; set; }
public IVisualProperty VisualProperty { get; } = new VisualProperty { Opacity = 0.8d };
public IVisualProperty VisualProperty { get; set; } = new VisualProperty { Opacity = 0.8d };
public double RotationAngle { get; set; }
public IDivisionSize DivisionSize { get; } = new DivisionSize(Guid.NewGuid());
public IDivisionSize DivisionSize { get; set; } = new DivisionSize(Guid.NewGuid());
public ShapeNdmPrimitive(Guid id)
{
Id = id;
@@ -38,7 +38,9 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
public IEnumerable<INdm> GetNdms(ITriangulationOptions triangulationOptions)
{
throw new NotImplementedException();
var triangulationLogicOption = new LinePolygonTriangulationLogicOption(this, triangulationOptions);
var logic = new LinePolygonTriangulationLogic(triangulationLogicOption);
return logic.GetNdmCollection();
}
public List<INamedAreaPoint> GetValuePoints()
@@ -74,7 +76,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
{
if (shape is ILinePolygonShape polygon)
{
var newShape = PolygonGeometryUtils.GetTratsfromedPolygon(polygon, Center.X, Center.Y);
var newShape = PolygonGeometryUtils.GetTransfromedPolygon(polygon, Center.X, Center.Y);
var calculator = new PolygonCalculator();
return calculator.ContainsPoint(newShape, point);
}

6
StructureHelperLogics/NdmCalculations/Triangulations/CircleTriangulationLogic.cs
View File

@@ -23,13 +23,13 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
{
double diameter = options.Circle.Diameter;
double ndmMaxSize = options.NdmMaxSize;
int ndmMinDivision = options.NdmMinDivision;
double ndmMaxSize = options.DivisionSize.NdmMaxSize;
int ndmMinDivision = options.DivisionSize.NdmMinDivision;
var logicOptions = new LoaderCalculator.Triangulations.CircleTriangulationLogicOptions(diameter, ndmMaxSize, ndmMinDivision);
var logic = LoaderCalculator.Triangulations.Triangulation.GetLogicInstance(logicOptions);
var ndmCollection = logic.GetNdmCollection(new LoaderCalculator.Data.Planes.CirclePlane
{
Material = options.HeadMaterial.GetLoaderMaterial(options.triangulationOptions.LimiteState, options.triangulationOptions.CalcTerm)
Material = options.HeadMaterial.GetLoaderMaterial(options.TriangulationOptions.LimiteState, options.TriangulationOptions.CalcTerm)
});
TriangulationService.CommonTransform(ndmCollection, options);
TriangulationService.SetPrestrain(ndmCollection, options.Prestrain);

11
StructureHelperLogics/NdmCalculations/Triangulations/CircleTriangulationLogicOptions.cs
View File

@@ -18,22 +18,19 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
public IPoint2D Center { get; set; }
public double NdmMaxSize { get; }
public int NdmMinDivision { get; }
public StrainTuple Prestrain { get; set; }
public ITriangulationOptions triangulationOptions { get; set; }
public ITriangulationOptions TriangulationOptions { get; set; }
public IHeadMaterial HeadMaterial { get; set; }
public double RotationAngle { get; set; }
public IDivisionSize DivisionSize { get; }
public CircleTriangulationLogicOptions(IEllipseNdmPrimitive primitive)
{
Center = primitive.Center.Clone() as Point2D;
//to do change to ellipse
Circle = new CircleShape() { Diameter = primitive.Width };
NdmMaxSize = primitive.DivisionSize.NdmMaxSize;
NdmMinDivision = primitive.DivisionSize.NdmMinDivision;
DivisionSize = primitive.DivisionSize;
HeadMaterial = primitive.NdmElement.HeadMaterial;
Prestrain = ForceTupleService.SumTuples(primitive.NdmElement.UsersPrestrain, primitive.NdmElement.AutoPrestrain) as StrainTuple;
}

13
StructureHelperLogics/NdmCalculations/Triangulations/IShapeTriangulationLogicOptions.cs
View File

@@ -1,5 +1,6 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Shapes;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Linq;
@@ -11,16 +12,8 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
public interface IShapeTriangulationLogicOptions : ITriangulationLogicOptions, IHasCenter2D
{
/// <summary>
/// Center of shape
/// Parameters of division
/// </summary>
IPoint2D Center { get; }
/// <summary>
/// Maximum size (width or height) of ndm part after triangulation
/// </summary>
double NdmMaxSize { get; }
/// <summary>
/// Minimum quantity of division of side of rectangle after triangulation
/// </summary>
int NdmMinDivision { get; }
IDivisionSize DivisionSize { get; }
}
}

15
StructureHelperLogics/NdmCalculations/Triangulations/ITriangulationLogic.cs
View File

@@ -1,12 +1,21 @@
using System.Collections.Generic;
using LoaderCalculator.Data.Ndms;
using LoaderCalculator.Data.Materials;
using LoaderCalculator.Data.Ndms;
namespace StructureHelperLogics.NdmCalculations.Triangulations
{
/// <summary>
/// Implements logic of obtaining of collection of ndm parts
/// </summary>
public interface ITriangulationLogic
{
/// <summary>
/// Returns collection of ndm parts
/// </summary>
/// <returns></returns>
IEnumerable<INdm> GetNdmCollection();
/// <summary>
/// Check options of triangulation
/// </summary>
/// <param name="options"></param>
void ValidateOptions(ITriangulationLogicOptions options);
}
}

2
StructureHelperLogics/NdmCalculations/Triangulations/ITriangulationLogicOptions.cs
View File

@@ -6,7 +6,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
{
public interface ITriangulationLogicOptions
{
ITriangulationOptions triangulationOptions { get; set; }
ITriangulationOptions TriangulationOptions { get; set; }
StrainTuple Prestrain { get; set; }
IHeadMaterial HeadMaterial { get; set; }
}

85
StructureHelperLogics/NdmCalculations/Triangulations/LinePolygonTriangulationLogic.cs Normal file
View File

@@ -0,0 +1,85 @@
using LoaderCalculator.Data.Materials;
using LoaderCalculator.Data.Ndms;
using LoaderCalculator.Infrastructure.Geometry;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Models.Shapes;
using TriangleNet.Geometry;
using TriangleNet.Meshing;
using static System.Windows.Forms.Design.AxImporter;
namespace StructureHelperLogics.NdmCalculations.Triangulations
{
/// <summary>
/// Logic for triangulation of line poligon shapr into collection of ndm parts
/// </summary>
public class LinePolygonTriangulationLogic : ITriangulationLogic
{
private LinePolygonTriangulationLogicOption options;
public LinePolygonTriangulationLogic(LinePolygonTriangulationLogicOption triangulationLogicOption)
{
this.options = triangulationLogicOption;
}
/// <inheritdoc/>
public IEnumerable<INdm> GetNdmCollection()
{
IMesh mesh = GetMesh();
var material = options.HeadMaterial.GetLoaderMaterial(options.TriangulationOptions.LimiteState, options.TriangulationOptions.CalcTerm);
List<INdm> ndms = GetNdmsByMesh(mesh, material);
return ndms;
}
private List<INdm> GetNdmsByMesh(IMesh mesh, IMaterial material)
{
List<INdm> ndmCollection = [];
foreach (var triangle in mesh.Triangles)
{
List<IPointLd2D> points = [];
for (int i = 0; i < 3; i++)
{
var vertex1 = triangle.GetVertex(i);
points.Add(new PointLd2D() { X = vertex1.X, Y = vertex1.Y });
}
var ndm = new TriangleNdm() { Point1 = points[0], Point2 = points[1], Point3 = points[2] };
ndm.Material = material;
var ndm2 = new RectangleNdm() { Width = Math.Sqrt(ndm.Area), Height = Math.Sqrt(ndm.Area), CenterX = ndm.CenterX, CenterY = ndm.CenterY, Material = ndm.Material};
ndmCollection.Add(ndm);
}
TriangulationService.SetPrestrain(ndmCollection, options.Prestrain);
return ndmCollection;
}
private IMesh GetMesh()
{
if (options.Shape is not ILinePolygonShape polygonShape)
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(options.Shape) + ": Shape is not line polygon shape");
}
var polygon = new Polygon();
List<IVertex> vertices = polygonShape.Vertices.ToList();
var contour = new List<TriangleNet.Geometry.Vertex>();
foreach (var vertex in vertices)
{
contour.Add(new TriangleNet.Geometry.Vertex(vertex.Point.X, vertex.Point.Y));
}
// Add contour to polygon — this automatically defines the connecting segments
polygon.Add(new Contour(contour));
var quality = new QualityOptions()
{
MinimumAngle = 25.0,
MaximumArea = options.DivisionSize.NdmMaxSize * options.DivisionSize.NdmMaxSize,
};
var mesh = polygon.Triangulate(quality);
return mesh;
}
/// <inheritdoc/>
public void ValidateOptions(ITriangulationLogicOptions options)
{
throw new NotImplementedException();
}
}
}

35
StructureHelperLogics/NdmCalculations/Triangulations/LinePolygonTriangulationLogicOption.cs Normal file
View File

@@ -0,0 +1,35 @@
using StructureHelper.Models.Materials;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Shapes;
using StructureHelperCommon.Services.Forces;
using StructureHelperLogics.Models.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.NdmCalculations.Triangulations
{
public class LinePolygonTriangulationLogicOption : IShapeTriangulationLogicOptions
{
public IPoint2D Center { get; set; }
public IDivisionSize DivisionSize { get; set; }
public ITriangulationOptions TriangulationOptions { get; set; }
public StrainTuple Prestrain { get; set; }
public IHeadMaterial HeadMaterial { get; set; }
public double RotationAngle { get; set; } = 0;
public IShape Shape { get; set; }
public LinePolygonTriangulationLogicOption(IShapeNdmPrimitive primitive, ITriangulationOptions triangulationOptions)
{
Center = primitive.Center;
DivisionSize = primitive.DivisionSize;
TriangulationOptions = triangulationOptions;
Shape = primitive.Shape;
HeadMaterial = primitive.NdmElement.HeadMaterial;
Prestrain = ForceTupleService.SumTuples(primitive.NdmElement.UsersPrestrain, primitive.NdmElement.AutoPrestrain) as StrainTuple;
}
}
}

2
StructureHelperLogics/NdmCalculations/Triangulations/PointTriangulationLogic.cs
View File

@@ -22,7 +22,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
CenterX = options.Center.X,
CenterY = options.Center.Y,
Area = options.Area,
Material = options.HeadMaterial.GetLoaderMaterial(options.triangulationOptions.LimiteState, options.triangulationOptions.CalcTerm)
Material = options.HeadMaterial.GetLoaderMaterial(options.TriangulationOptions.LimiteState, options.TriangulationOptions.CalcTerm)
};
List<INdm> ndmCollection = new () { ndm};
NdmTransform.SetPrestrain(ndmCollection, TupleConverter.ConvertToLoaderStrainMatrix(options.Prestrain));

2
StructureHelperLogics/NdmCalculations/Triangulations/PointTriangulationLogicOptions.cs
View File

@@ -12,7 +12,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
/// </summary>
public class PointTriangulationLogicOptions : ITriangulationLogicOptions
{
public ITriangulationOptions triangulationOptions { get; set; }
public ITriangulationOptions TriangulationOptions { get; set; }
/// <summary>
///
/// </summary>

4
StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs
View File

@@ -44,7 +44,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
CenterX = options.Center.X,
CenterY = options.Center.Y,
Area = options.Area,
Material = options.HeadMaterial.GetLoaderMaterial(options.triangulationOptions.LimiteState, options.triangulationOptions.CalcTerm)
Material = options.HeadMaterial.GetLoaderMaterial(options.TriangulationOptions.LimiteState, options.TriangulationOptions.CalcTerm)
};
;
NdmTransform.SetPrestrain(rebarNdm, TupleConverter.ConvertToLoaderStrainMatrix(options.Prestrain));
@@ -58,7 +58,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
var material = hostPrimitive
.NdmElement
.HeadMaterial
.GetLoaderMaterial(options.triangulationOptions.LimiteState, options.triangulationOptions.CalcTerm);
.GetLoaderMaterial(options.TriangulationOptions.LimiteState, options.TriangulationOptions.CalcTerm);
var prestrain = ForceTupleService.SumTuples(hostPrimitive.NdmElement.UsersPrestrain,
hostPrimitive.NdmElement.AutoPrestrain)

2
StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogicOptions.cs
View File

@@ -13,7 +13,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
{
public class RebarTriangulationLogicOptions : ITriangulationLogicOptions
{
public ITriangulationOptions triangulationOptions { get; set; }
public ITriangulationOptions TriangulationOptions { get; set; }
/// <summary>
///
/// </summary>

6
StructureHelperLogics/NdmCalculations/Triangulations/RectangleTriangulationLogic.cs
View File

@@ -16,13 +16,13 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
{
double width = options.Rectangle.Width;
double height = options.Rectangle.Height;
double ndmMaxSize = options.NdmMaxSize;
int ndmMinDivision = options.NdmMinDivision;
double ndmMaxSize = options.DivisionSize.NdmMaxSize;
int ndmMinDivision = options.DivisionSize.NdmMinDivision;
LoaderCalculator.Triangulations.RectangleTriangulationLogicOptions logicOptions = new LoaderCalculator.Triangulations.RectangleTriangulationLogicOptions(width, height, ndmMaxSize, ndmMinDivision);
var logic = LoaderCalculator.Triangulations.Triangulation.GetLogicInstance(logicOptions);
var ndmCollection = logic.GetNdmCollection(new LoaderCalculator.Data.Planes.RectangularPlane
{
Material = options.HeadMaterial.GetLoaderMaterial(options.triangulationOptions.LimiteState, options.triangulationOptions.CalcTerm)
Material = options.HeadMaterial.GetLoaderMaterial(options.TriangulationOptions.LimiteState, options.TriangulationOptions.CalcTerm)
});
TriangulationService.CommonTransform(ndmCollection, options);
double angle = options.RotationAngle;

17
StructureHelperLogics/NdmCalculations/Triangulations/RectangleTriangulationLogicOptions.cs
View File

@@ -16,21 +16,20 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
public double RotationAngle { get; set; } = 0d;
/// <inheritdoc />
public IRectangleShape Rectangle { get; }
/// <inheritdoc />
public double NdmMaxSize { get; }
/// <inheritdoc />
public int NdmMinDivision { get; }
/// <inheritdoc />
public StrainTuple Prestrain { get; set; }
public ITriangulationOptions triangulationOptions { get; set; }
public ITriangulationOptions TriangulationOptions { get; set; }
public IHeadMaterial HeadMaterial { get; set; }
public IDivisionSize DivisionSize { get; } = new DivisionSize(Guid.Empty);
public RectangleTriangulationLogicOptions(IPoint2D center, IRectangleShape rectangle, double ndmMaxSize, int ndmMinDivision)
{
Center = center;
Rectangle = rectangle;
NdmMaxSize = ndmMaxSize;
NdmMinDivision = ndmMinDivision;
DivisionSize.NdmMaxSize = ndmMaxSize;
DivisionSize.NdmMinDivision = ndmMinDivision;
Prestrain = new StrainTuple();
}
@@ -39,8 +38,8 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations
Center = new Point2D() {X = primitive.Center.X, Y = primitive.Center.Y };
RotationAngle = primitive.RotationAngle;
Rectangle = primitive;
NdmMaxSize = primitive.DivisionSize.NdmMaxSize;
NdmMinDivision = primitive.DivisionSize.NdmMinDivision;
DivisionSize.NdmMaxSize = primitive.DivisionSize.NdmMaxSize;
DivisionSize.NdmMinDivision = primitive.DivisionSize.NdmMinDivision;
HeadMaterial = primitive.NdmElement.HeadMaterial;
Prestrain = ForceTupleService.SumTuples(primitive.NdmElement.UsersPrestrain, primitive.NdmElement.AutoPrestrain) as StrainTuple;
}

3
StructureHelperLogics/StructureHelperLogics.csproj
View File

@@ -14,6 +14,9 @@
<Reference Include="LoaderCalculator">
<HintPath>..\StructureHelper\Libraries\LoaderCalculator.dll</HintPath>
</Reference>
<Reference Include="Triangle">
<HintPath>..\StructureHelper\Libraries\Triangle.dll</HintPath>
</Reference>
</ItemGroup>
</Project>

2
StructureHelperTests/UnitTests/Ndms/Triangulations/RectangleTriangulationTest.cs
View File

@@ -44,7 +44,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Triangulations
IRectangleShape rectangle = new RectangleShape { Width = width, Height = height};
var options = new RectangleTriangulationLogicOptions(center, rectangle, ndmMaxSize, ndmMinDivision)
{
triangulationOptions = new TriangulationOptions() { LimiteState = LimitStates.ULS, CalcTerm = CalcTerms.ShortTerm },
TriangulationOptions = new TriangulationOptions() { LimiteState = LimitStates.ULS, CalcTerm = CalcTerms.ShortTerm },
HeadMaterial = materialMock.Object,
RotationAngle = angle
};