From c10d6eb94ea1fd3bc7ccab3374c37b5463a9f966 Mon Sep 17 00:00:00 2001 From: Evgeny Redikultsev Date: Sat, 14 Sep 2024 19:03:35 +0500 Subject: [PATCH] Add VisualAnalysisDTO --- .../FileVersionFromDTOConvertStrategy.cs | 30 ++++++++ .../FileVersionToDTOConvertStrategy.cs | 30 ++++++++ .../Converters/ProjectToDTOConvertStrategy.cs | 51 ++++++++++++++ .../VisualAnalysisToDTOConvertStrategy.cs | 26 +++++++ .../DTOs/FileVersionDTOConvertStrategy.cs | 41 ----------- DataAccess/DTOs/NdmPrimitiveDTO.cs | 2 - DataAccess/DTOs/ProjectDTO.cs | 7 +- DataAccess/DTOs/VisualAnalysisDTO.cs | 29 ++++++++ DataAccess/Infrastructures/FileSaveLogic.cs | 37 ++++++++-- .../JsonConverters/ProjectDTOJsonConverter.cs | 18 +++++ .../VisualAnalysisDTOJsonConverter.cs | 17 +++++ .../UI/DataContexts/CircleViewPrimitive.cs | 14 ++-- .../UI/DataContexts/PrimitiveBase.cs | 28 ++++---- .../UI/DataContexts/PrimitiveOperations.cs | 4 +- .../UI/DataContexts/RectangleViewPrimitive.cs | 2 +- .../ValuePointDiagramLogic.cs | 6 +- .../ForcesResultsViewModel.cs | 18 +++-- .../MainWindow/Analyses/VisualAnalysis.cs | 9 +++ .../Materials/HeadMaterialsViewModel.cs | 2 +- .../Materials/MaterialsViewModel.cs | 2 +- .../NdmCrossSections/HasDivisionViewModel.cs | 6 +- .../PrimitiveViewModelLogic.cs | 8 +-- .../PrimitivePropertiesViewModel.cs | 5 +- .../Infrastructures/Exceptions/ErrorString.cs | 2 + .../Interfaces/BaseUpdateStrategy.cs | 19 ++++++ .../Interfaces/DictionaryConvertStrategy.cs | 24 +------ .../Interfaces/IConvertStrategy.cs | 4 +- .../Interfaces/IHasCenter2D.cs | 20 ++++++ .../Analyses/{Version.cs => DateVersion.cs} | 2 +- .../Analyses/DateVersionUpdateStrategy.cs | 22 ++++++ .../Models/Analyses/IAnalysis.cs | 2 +- .../Analyses/{IVersion.cs => IDateVersion.cs} | 4 +- .../Models/Analyses/IVersionProcessor.cs | 4 +- .../Models/Analyses/IVisualAnalysis.cs | 2 +- .../Models/Analyses/VersionProcessor.cs | 8 +-- .../Analyses/VisualAnalysisUpdateStrategy.cs | 18 +++++ .../Projects/FileVersionUpdateStrategy.cs | 3 +- .../Models/Projects/ProjectUpdateStrategy.cs | 39 +++++++++++ .../Shapes/Logics/Point2DUpdateStrategy.cs | 6 +- .../Logics/RectangleShapeUpdateStrategy.cs | 3 + .../Shapes/Logics/ShapeUpdateStrategy.cs | 59 ++++++++++++++++ .../Analyses/CrossSectionNdmAnalysis.cs | 13 ++-- .../CrossSectionNdmAnalysisUpdateStrategy.cs | 68 +++++++++++++++++++ .../CrossSections/RCs/CircleGeometryLogic.cs | 7 +- .../CrossSections/RCs/RectGeometryLogic.cs | 32 ++++++--- .../Analyses/RC/InputDataFactory.cs | 11 +-- .../Cracking/RebarCrackInputDataFactory.cs | 2 +- .../Primitives/DivisionSize.cs | 19 ++++++ ...CirclePrimitive.cs => EllipsePrimitive.cs} | 66 ++++++++++-------- .../Primitives/IDivisionSize.cs | 29 ++++++++ ...irclePrimitive.cs => IEllipsePrimitive.cs} | 5 +- .../Primitives/IHasDivisionSize.cs | 18 +---- .../Primitives/ILinePrimitive.cs | 2 +- .../NdmCalculations/Primitives/INdmElement.cs | 4 -- .../Primitives/INdmPrimitive.cs | 24 ++----- .../Primitives/Logics/BaseUpdateStrategy.cs | 9 ++- .../Logics/CheckRebarPrimitiveLogic.cs | 4 +- .../Primitives/Logics/CircleUpdateStrategy.cs | 25 ------- .../Logics/DivisionPropsUpdateStrategy.cs | 4 +- .../Logics/EllipsePrimitiveUpdateStrategy.cs | 39 +++++++++++ ...trategy.cs => NdmElementUpdateStrategy.cs} | 13 +--- .../Logics/NdmPrimitiveUpdateStrategy.cs | 6 +- .../RectanglePrimitiveUpdateStrategy.cs | 45 ++++++++++++ .../Logics/RectangleUpdateStrategy.cs | 24 ------- .../NdmCalculations/Primitives/NdmElement.cs | 4 +- .../Primitives/PointPrimitive.cs | 18 ++--- .../Primitives/RebarPrimitive.cs | 18 ++--- .../Primitives/RectanglePrimitive.cs | 34 +++------- .../CircleTriangulationLogicOptions.cs | 13 ++-- .../PointTriangulationLogicOptions.cs | 4 +- .../Triangulations/RebarTriangulationLogic.cs | 5 +- .../RebarTriangulationLogicOptions.cs | 4 +- .../RectangleTriangulationLogicOptions.cs | 8 +-- .../Triangulations/Triangulation.cs | 2 +- .../CheckPrimitivesForMeshingLogic.cs | 8 ++- .../NdmPrimitives/IMeshHasDivisionLogic.cs | 16 ++++- .../NdmPrimitives/MeshCrackedConcreteLogic.cs | 10 +-- .../NdmPrimitives/MeshHasDivisionLogic.cs | 49 ++++++++++--- .../TriangulatePrimitiveLogic.cs | 2 +- .../ForceCalculatorTests/RCSectionsTest.cs | 2 +- .../Ndms/CheckRebarPrimitiveLogicTests.cs | 2 +- .../CheckTupleCalculatorInputDataTests.cs | 4 +- .../RectangleTriangulationTest.cs | 51 +++++++++----- .../ViewModelTests/NdmPrimitiveTests.cs | 12 ++-- 84 files changed, 958 insertions(+), 410 deletions(-) create mode 100644 DataAccess/DTOs/Converters/FileVersionFromDTOConvertStrategy.cs create mode 100644 DataAccess/DTOs/Converters/FileVersionToDTOConvertStrategy.cs create mode 100644 DataAccess/DTOs/Converters/ProjectToDTOConvertStrategy.cs create mode 100644 DataAccess/DTOs/Converters/VisualAnalysisToDTOConvertStrategy.cs delete mode 100644 DataAccess/DTOs/FileVersionDTOConvertStrategy.cs create mode 100644 DataAccess/DTOs/VisualAnalysisDTO.cs create mode 100644 DataAccess/JsonConverters/ProjectDTOJsonConverter.cs create mode 100644 DataAccess/JsonConverters/VisualAnalysisDTOJsonConverter.cs create mode 100644 StructureHelperCommon/Infrastructures/Interfaces/BaseUpdateStrategy.cs create mode 100644 StructureHelperCommon/Infrastructures/Interfaces/IHasCenter2D.cs rename StructureHelperCommon/Models/Analyses/{Version.cs => DateVersion.cs} (88%) create mode 100644 StructureHelperCommon/Models/Analyses/DateVersionUpdateStrategy.cs rename StructureHelperCommon/Models/Analyses/{IVersion.cs => IDateVersion.cs} (78%) create mode 100644 StructureHelperCommon/Models/Analyses/VisualAnalysisUpdateStrategy.cs create mode 100644 StructureHelperCommon/Models/Projects/ProjectUpdateStrategy.cs create mode 100644 StructureHelperCommon/Models/Shapes/Logics/ShapeUpdateStrategy.cs create mode 100644 StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysisUpdateStrategy.cs create mode 100644 StructureHelperLogics/NdmCalculations/Primitives/DivisionSize.cs rename StructureHelperLogics/NdmCalculations/Primitives/{CirclePrimitive.cs => EllipsePrimitive.cs} (65%) create mode 100644 StructureHelperLogics/NdmCalculations/Primitives/IDivisionSize.cs rename StructureHelperLogics/NdmCalculations/Primitives/{ICirclePrimitive.cs => IEllipsePrimitive.cs} (60%) delete mode 100644 StructureHelperLogics/NdmCalculations/Primitives/Logics/CircleUpdateStrategy.cs create mode 100644 StructureHelperLogics/NdmCalculations/Primitives/Logics/EllipsePrimitiveUpdateStrategy.cs rename StructureHelperLogics/NdmCalculations/Primitives/Logics/{INdmElementUpdateStrategy.cs => NdmElementUpdateStrategy.cs} (63%) create mode 100644 StructureHelperLogics/NdmCalculations/Primitives/Logics/RectanglePrimitiveUpdateStrategy.cs delete mode 100644 StructureHelperLogics/NdmCalculations/Primitives/Logics/RectangleUpdateStrategy.cs diff --git a/DataAccess/DTOs/Converters/FileVersionFromDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/FileVersionFromDTOConvertStrategy.cs new file mode 100644 index 0000000..0945828 --- /dev/null +++ b/DataAccess/DTOs/Converters/FileVersionFromDTOConvertStrategy.cs @@ -0,0 +1,30 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Projects; + +namespace DataAccess.DTOs +{ + public class FileVersionFromDTOConvertStrategy : IConvertStrategy + { + private IUpdateStrategy updateStrategy; + + public IShiftTraceLogger TraceLogger { get; set; } + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get => throw new NotImplementedException(); set => throw new NotImplementedException(); } + + public FileVersionFromDTOConvertStrategy(IUpdateStrategy updateStrategy) + { + this.updateStrategy = updateStrategy; + } + public FileVersionFromDTOConvertStrategy() : this(new FileVersionUpdateStrategy()) + { + + } + + public FileVersion Convert(FileVersionDTO source) + { + FileVersion fileVersion = new(source.Id); + updateStrategy.Update(fileVersion, source); + return fileVersion; + } + } +} diff --git a/DataAccess/DTOs/Converters/FileVersionToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/FileVersionToDTOConvertStrategy.cs new file mode 100644 index 0000000..d2aeb0e --- /dev/null +++ b/DataAccess/DTOs/Converters/FileVersionToDTOConvertStrategy.cs @@ -0,0 +1,30 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Projects; + +namespace DataAccess.DTOs +{ + public class FileVersionToDTOConvertStrategy : IConvertStrategy + { + private IUpdateStrategy updateStrategy; + + public IShiftTraceLogger TraceLogger { get; set; } + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + + public FileVersionToDTOConvertStrategy(IUpdateStrategy updateStrategy) + { + this.updateStrategy = updateStrategy; + } + public FileVersionToDTOConvertStrategy() : this(new FileVersionUpdateStrategy()) + { + + } + + public FileVersionDTO Convert(IFileVersion source) + { + FileVersionDTO fileVersion = new(source.Id); + updateStrategy.Update(fileVersion, source); + return fileVersion; + } + } +} diff --git a/DataAccess/DTOs/Converters/ProjectToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/ProjectToDTOConvertStrategy.cs new file mode 100644 index 0000000..b95294b --- /dev/null +++ b/DataAccess/DTOs/Converters/ProjectToDTOConvertStrategy.cs @@ -0,0 +1,51 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Analyses; +using StructureHelperCommon.Models.Projects; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class ProjectToDTOConvertStrategy : IConvertStrategy + { + private IUpdateStrategy updateStrategy; + private IConvertStrategy convertStrategy; + + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + public IShiftTraceLogger TraceLogger { get; set; } + + public ProjectToDTOConvertStrategy(IUpdateStrategy updateStrategy, IConvertStrategy convertStrategy) + { + this.updateStrategy = updateStrategy; + this.convertStrategy = convertStrategy; + } + + public ProjectToDTOConvertStrategy() : this(new ProjectUpdateStrategy(), new VisualAnalysisToDTOConvertStrategy()) + { + + } + + public ProjectDTO Convert(IProject source) + { + ProjectDTO projectDTO = new(source.Id); + updateStrategy.Update(projectDTO, source); + convertStrategy.ReferenceDictionary = ReferenceDictionary; + var convertLogic = new DictionaryConvertStrategy() + { + ReferenceDictionary = ReferenceDictionary, + ConvertStrategy = convertStrategy, + TraceLogger = TraceLogger + }; + foreach (var item in source.VisualAnalyses) + { + var newVisualAnalysis = convertLogic.Convert(item); + projectDTO.VisualAnalyses.Add(newVisualAnalysis); + } + return projectDTO; + } + } +} diff --git a/DataAccess/DTOs/Converters/VisualAnalysisToDTOConvertStrategy.cs b/DataAccess/DTOs/Converters/VisualAnalysisToDTOConvertStrategy.cs new file mode 100644 index 0000000..a1fd3c3 --- /dev/null +++ b/DataAccess/DTOs/Converters/VisualAnalysisToDTOConvertStrategy.cs @@ -0,0 +1,26 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Analyses; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + internal class VisualAnalysisToDTOConvertStrategy : IConvertStrategy + { + public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } + public IShiftTraceLogger TraceLogger { get; set; } + + public VisualAnalysisDTO Convert(IVisualAnalysis source) + { + VisualAnalysisDTO visualAnalysisDTO = new() + { + Id = source.Id + }; + return visualAnalysisDTO; + } + } +} diff --git a/DataAccess/DTOs/FileVersionDTOConvertStrategy.cs b/DataAccess/DTOs/FileVersionDTOConvertStrategy.cs deleted file mode 100644 index 78e934c..0000000 --- a/DataAccess/DTOs/FileVersionDTOConvertStrategy.cs +++ /dev/null @@ -1,41 +0,0 @@ -using StructureHelperCommon.Infrastructures.Interfaces; -using StructureHelperCommon.Models; -using StructureHelperCommon.Models.Projects; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace DataAccess.DTOs -{ - public class FileVersionDTOConvertStrategy : IConvertStrategy - { - private IUpdateStrategy updateStrategy; - - public IShiftTraceLogger TraceLogger { get; set; } - - public FileVersionDTOConvertStrategy(IUpdateStrategy updateStrategy) - { - this.updateStrategy = updateStrategy; - } - public FileVersionDTOConvertStrategy() : this(new FileVersionUpdateStrategy()) - { - - } - - public FileVersionDTO ConvertTo(FileVersion source) - { - FileVersionDTO fileVersion = new(source.Id); - updateStrategy.Update(fileVersion, source); - return fileVersion; - } - - public FileVersion ConvertFrom(FileVersionDTO source) - { - FileVersion fileVersion = new(source.Id); - updateStrategy.Update(fileVersion, source); - return fileVersion; - } - } -} diff --git a/DataAccess/DTOs/NdmPrimitiveDTO.cs b/DataAccess/DTOs/NdmPrimitiveDTO.cs index e24b87c..0e3b3a0 100644 --- a/DataAccess/DTOs/NdmPrimitiveDTO.cs +++ b/DataAccess/DTOs/NdmPrimitiveDTO.cs @@ -15,8 +15,6 @@ namespace DataAccess.DTOs { [JsonProperty("Id")] public Guid Id { get; set; } - [JsonProperty("Center")] - public IPoint2D Center { get; set; } [JsonProperty("HeadMaterial")] public IHeadMaterial? HeadMaterial { get; set; } [JsonProperty("Triangulate")] diff --git a/DataAccess/DTOs/ProjectDTO.cs b/DataAccess/DTOs/ProjectDTO.cs index 8014ba9..d5f6172 100644 --- a/DataAccess/DTOs/ProjectDTO.cs +++ b/DataAccess/DTOs/ProjectDTO.cs @@ -21,7 +21,7 @@ namespace DataAccess.DTOs public bool IsActual { get; set; } [JsonProperty("VisualAnalyses")] - public List VisualAnalyses { get; private set; } + public List VisualAnalyses { get; private set; } = new(); [JsonIgnore] public string FileName { get; set; } @@ -31,5 +31,10 @@ namespace DataAccess.DTOs Id = id; } + public ProjectDTO() : this (Guid.NewGuid()) + { + + } + } } diff --git a/DataAccess/DTOs/VisualAnalysisDTO.cs b/DataAccess/DTOs/VisualAnalysisDTO.cs new file mode 100644 index 0000000..18914ac --- /dev/null +++ b/DataAccess/DTOs/VisualAnalysisDTO.cs @@ -0,0 +1,29 @@ +using Newtonsoft.Json; +using StructureHelperCommon.Models.Analyses; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.DTOs +{ + public class VisualAnalysisDTO : IVisualAnalysis + { + + [JsonProperty("Id")] + public Guid Id { get; set; } + [JsonProperty("Analysis")] + public IAnalysis Analysis { get; set; } + + public object Clone() + { + throw new NotImplementedException(); + } + + public void Run() + { + throw new NotImplementedException(); + } + } +} diff --git a/DataAccess/Infrastructures/FileSaveLogic.cs b/DataAccess/Infrastructures/FileSaveLogic.cs index 488c8be..7b6617b 100644 --- a/DataAccess/Infrastructures/FileSaveLogic.cs +++ b/DataAccess/Infrastructures/FileSaveLogic.cs @@ -52,6 +52,15 @@ namespace DataAccess.Infrastructures refDictinary = new Dictionary<(Guid id, Type type), ISaveable>(); FileVersionDTO versionDTO = GetVersionDTO(); var versionString = Serialize(versionDTO, TraceLogger); + SaveStringToFile(project, versionString); + refDictinary = new Dictionary<(Guid id, Type type), ISaveable>(); + ProjectDTO projectDTO = GetProjectDTO(project); + var projectString = Serialize(projectDTO, TraceLogger); + SaveStringToFile(project, projectString); + } + + private void SaveStringToFile(IProject project, string versionString) + { try { File.WriteAllText(project.FullFileName, versionString); @@ -63,19 +72,36 @@ namespace DataAccess.Infrastructures } } - private FileVersionDTO GetVersionDTO() + private ProjectDTO GetProjectDTO(IProject project) { - FileVersionDTOConvertStrategy fileVersionDTOConvertStrategy = new() + ProjectToDTOConvertStrategy convertStrategy = new() { + ReferenceDictionary = refDictinary, TraceLogger = TraceLogger }; - DictionaryConvertStrategy dictionaryConvertStrategy = new() + DictionaryConvertStrategy dictionaryConvertStrategy = new() + { + ConvertStrategy = convertStrategy, + ReferenceDictionary = refDictinary, + TraceLogger = TraceLogger + }; + return dictionaryConvertStrategy.Convert(project); + } + + private FileVersionDTO GetVersionDTO() + { + FileVersionToDTOConvertStrategy fileVersionDTOConvertStrategy = new() + { + ReferenceDictionary = refDictinary, + TraceLogger = TraceLogger + }; + DictionaryConvertStrategy dictionaryConvertStrategy = new() { ConvertStrategy = fileVersionDTOConvertStrategy, ReferenceDictionary = refDictinary, TraceLogger = TraceLogger }; - var versionDTO = dictionaryConvertStrategy.ConvertTo(version as FileVersion); + var versionDTO = dictionaryConvertStrategy.Convert(version); return versionDTO; } @@ -85,8 +111,9 @@ namespace DataAccess.Infrastructures { Converters = new List { - new FileVersionDTOJsonConverter(logger), // Add the specific converter // Add other converters if needed + new FileVersionDTOJsonConverter(logger), // Add the specific converter + new ProjectDTOJsonConverter(logger) }, Formatting = Formatting.Indented, PreserveReferencesHandling = PreserveReferencesHandling.All, diff --git a/DataAccess/JsonConverters/ProjectDTOJsonConverter.cs b/DataAccess/JsonConverters/ProjectDTOJsonConverter.cs new file mode 100644 index 0000000..389c38d --- /dev/null +++ b/DataAccess/JsonConverters/ProjectDTOJsonConverter.cs @@ -0,0 +1,18 @@ +using DataAccess.DTOs; +using StructureHelperCommon.Models; +using StructureHelperCommon.Models.Projects; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.JsonConverters +{ + internal class ProjectDTOJsonConverter : BaseJsonConverter + { + public ProjectDTOJsonConverter(IShiftTraceLogger logger) : base(logger) + { + } + } +} diff --git a/DataAccess/JsonConverters/VisualAnalysisDTOJsonConverter.cs b/DataAccess/JsonConverters/VisualAnalysisDTOJsonConverter.cs new file mode 100644 index 0000000..407e564 --- /dev/null +++ b/DataAccess/JsonConverters/VisualAnalysisDTOJsonConverter.cs @@ -0,0 +1,17 @@ +using DataAccess.DTOs; +using StructureHelperCommon.Models; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace DataAccess.JsonConverters +{ + internal class VisualAnalysisDTOJsonConverter : BaseJsonConverter + { + public VisualAnalysisDTOJsonConverter(IShiftTraceLogger logger) : base(logger) + { + } + } +} diff --git a/StructureHelper/Infrastructure/UI/DataContexts/CircleViewPrimitive.cs b/StructureHelper/Infrastructure/UI/DataContexts/CircleViewPrimitive.cs index 748b9ed..7b83503 100644 --- a/StructureHelper/Infrastructure/UI/DataContexts/CircleViewPrimitive.cs +++ b/StructureHelper/Infrastructure/UI/DataContexts/CircleViewPrimitive.cs @@ -12,16 +12,16 @@ namespace StructureHelper.Infrastructure.UI.DataContexts { public class CircleViewPrimitive : PrimitiveBase, IHasCenter { - ICirclePrimitive primitive; + IEllipsePrimitive primitive; public double Diameter { get { - return primitive.Diameter; + return primitive.DiameterByX; } set { - primitive.Diameter = value; + primitive.DiameterByX = value; RefreshPlacement(); } } @@ -31,13 +31,13 @@ namespace StructureHelper.Infrastructure.UI.DataContexts public CircleViewPrimitive(INdmPrimitive primitive) : base(primitive) { - if (primitive is not ICirclePrimitive) + if (primitive is not IEllipsePrimitive) { - throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $"\nExpected: {nameof(ICirclePrimitive)}, But was: {nameof(primitive)}"); + throw new StructureHelperException(ErrorStrings.DataIsInCorrect + $"\nExpected: {nameof(IEllipsePrimitive)}, But was: {nameof(primitive)}"); } - var circle = primitive as ICirclePrimitive; + var circle = primitive as IEllipsePrimitive; this.primitive = circle; - DivisionViewModel = new HasDivisionViewModel(circle); + DivisionViewModel = new HasDivisionViewModel(circle.DivisionSize); } public override INdmPrimitive GetNdmPrimitive() diff --git a/StructureHelper/Infrastructure/UI/DataContexts/PrimitiveBase.cs b/StructureHelper/Infrastructure/UI/DataContexts/PrimitiveBase.cs index 47bfe52..8a6d12e 100644 --- a/StructureHelper/Infrastructure/UI/DataContexts/PrimitiveBase.cs +++ b/StructureHelper/Infrastructure/UI/DataContexts/PrimitiveBase.cs @@ -60,49 +60,49 @@ namespace StructureHelper.Infrastructure.UI.DataContexts } public bool Triangulate { - get => primitive.Triangulate; + get => primitive.NdmElement.Triangulate; set { - primitive.Triangulate = value; + primitive.NdmElement.Triangulate = value; OnPropertyChanged(nameof(Triangulate)); } } public double InvertedCenterY => - CenterY; public double PrestrainKx - { get => primitive.UsersPrestrain.Mx; + { get => primitive.NdmElement.UsersPrestrain.Mx; set { - primitive.UsersPrestrain.Mx = value; + primitive.NdmElement.UsersPrestrain.Mx = value; OnPropertyChanged(nameof(PrestrainKx)); } } public double PrestrainKy - { get => primitive.UsersPrestrain.My; + { get => primitive.NdmElement.UsersPrestrain.My; set { - primitive.UsersPrestrain.My = value; + primitive.NdmElement.UsersPrestrain.My = value; OnPropertyChanged(nameof(PrestrainKy)); } } public double PrestrainEpsZ - { get => primitive.UsersPrestrain.Nz; + { get => primitive.NdmElement.UsersPrestrain.Nz; set { - primitive.UsersPrestrain.Nz = value; + primitive.NdmElement.UsersPrestrain.Nz = value; OnPropertyChanged(nameof(PrestrainEpsZ)); } } - public double AutoPrestrainKx => primitive.AutoPrestrain.Mx; - public double AutoPrestrainKy => primitive.AutoPrestrain.My; - public double AutoPrestrainEpsZ => primitive.AutoPrestrain.Nz; + public double AutoPrestrainKx => primitive.NdmElement.AutoPrestrain.Mx; + public double AutoPrestrainKy => primitive.NdmElement.AutoPrestrain.My; + public double AutoPrestrainEpsZ => primitive.NdmElement.AutoPrestrain.Nz; public IHeadMaterial HeadMaterial { - get => primitive.HeadMaterial; + get => primitive.NdmElement.HeadMaterial; set { - primitive.HeadMaterial = value; + primitive.NdmElement.HeadMaterial = value; OnPropertyChanged(nameof(HeadMaterial)); OnPropertyChanged(nameof(Color)); } @@ -121,7 +121,7 @@ namespace StructureHelper.Infrastructure.UI.DataContexts public Color Color { get => ((primitive.VisualProperty.SetMaterialColor == true) - & (primitive.HeadMaterial !=null))? primitive.HeadMaterial.Color : primitive.VisualProperty.Color; + & (primitive.NdmElement.HeadMaterial !=null))? primitive.NdmElement.HeadMaterial.Color : primitive.VisualProperty.Color; set { SetMaterialColor = false; diff --git a/StructureHelper/Infrastructure/UI/DataContexts/PrimitiveOperations.cs b/StructureHelper/Infrastructure/UI/DataContexts/PrimitiveOperations.cs index 1f963a0..37d1924 100644 --- a/StructureHelper/Infrastructure/UI/DataContexts/PrimitiveOperations.cs +++ b/StructureHelper/Infrastructure/UI/DataContexts/PrimitiveOperations.cs @@ -30,9 +30,9 @@ namespace StructureHelper.Infrastructure.UI.DataContexts var rect = primitive as IRectanglePrimitive; viewItem = new RectangleViewPrimitive(rect); } - else if (primitive is ICirclePrimitive) + else if (primitive is IEllipsePrimitive) { - var circle = primitive as ICirclePrimitive; + var circle = primitive as IEllipsePrimitive; viewItem = new CircleViewPrimitive(circle); } else if (primitive is IPointPrimitive & primitive is not RebarPrimitive) diff --git a/StructureHelper/Infrastructure/UI/DataContexts/RectangleViewPrimitive.cs b/StructureHelper/Infrastructure/UI/DataContexts/RectangleViewPrimitive.cs index f286553..e9d7b31 100644 --- a/StructureHelper/Infrastructure/UI/DataContexts/RectangleViewPrimitive.cs +++ b/StructureHelper/Infrastructure/UI/DataContexts/RectangleViewPrimitive.cs @@ -40,7 +40,7 @@ namespace StructureHelper.Infrastructure.UI.DataContexts public RectangleViewPrimitive(IRectanglePrimitive _primitive) : base(_primitive) { primitive = _primitive; - DivisionViewModel = new HasDivisionViewModel(primitive); + DivisionViewModel = new HasDivisionViewModel(primitive.DivisionSize); } public override void Refresh() { diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ValuePointDiagramLogic.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ValuePointDiagramLogic.cs index 008312e..6ab9ef0 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ValuePointDiagramLogic.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForceResultLogic/ValuePointDiagramLogic.cs @@ -139,9 +139,9 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu { var limitState = tuple.DesignForceTuple.LimitState; var calcTerm = tuple.DesignForceTuple.CalcTerm; - var material = valuePoint.ndmPrimitive.HeadMaterial.GetLoaderMaterial(limitState, calcTerm); - var userPrestrain = valuePoint.ndmPrimitive.UsersPrestrain; - var autoPrestrain = valuePoint.ndmPrimitive.AutoPrestrain; + var material = valuePoint.ndmPrimitive.NdmElement.HeadMaterial.GetLoaderMaterial(limitState, calcTerm); + var userPrestrain = valuePoint.ndmPrimitive.NdmElement.UsersPrestrain; + var autoPrestrain = valuePoint.ndmPrimitive.NdmElement.AutoPrestrain; var ndm = new Ndm() { Area = valuePoint.areaPoint.Area, diff --git a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs index 57e52e9..4da7721 100644 --- a/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs +++ b/StructureHelper/Windows/CalculationWindows/CalculatorsViews/ForceCalculatorViews/ForcesResultsViewModel.cs @@ -338,7 +338,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu { foreach (var item in ndmPrimitives) { - ForceTupleService.CopyProperties(wnd.StrainTuple, item.AutoPrestrain); + ForceTupleService.CopyProperties(wnd.StrainTuple, item.NdmElement.AutoPrestrain); } } } @@ -439,15 +439,21 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalcu var ndmRange = new List(); foreach (var item in orderedNdmPrimitives) { - if (item is IHasDivisionSize) + if (item is IHasDivisionSize hasDivision) { - var hasDivision = item as IHasDivisionSize; - if (hasDivision.ClearUnderlying == true) + + if (hasDivision.DivisionSize.ClearUnderlying == true) { - ndmRange.RemoveAll(x => hasDivision.IsPointInside(new Point2D() { X = x.CenterX, Y = x.CenterY }) == true); + ndmRange.RemoveAll(x => + hasDivision + .IsPointInside(new Point2D() + { + X = x.CenterX, Y = x.CenterY + } + ) == true); } } - if (selectedNdmPrimitives.Contains(item) & item.Triangulate == true) + if (selectedNdmPrimitives.Contains(item) & item.NdmElement.Triangulate == true) { ndmRange.AddRange(item.GetNdms(triangulationOptions)); diff --git a/StructureHelper/Windows/MainWindow/Analyses/VisualAnalysis.cs b/StructureHelper/Windows/MainWindow/Analyses/VisualAnalysis.cs index c90b5ed..51baf27 100644 --- a/StructureHelper/Windows/MainWindow/Analyses/VisualAnalysis.cs +++ b/StructureHelper/Windows/MainWindow/Analyses/VisualAnalysis.cs @@ -1,4 +1,5 @@ using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models.Analyses; using StructureHelperLogics.Models.CrossSections; using System; @@ -7,6 +8,7 @@ namespace StructureHelper.Windows.MainWindow.Analyses { public class VisualAnalysis : IVisualAnalysis { + private IUpdateStrategy updateStrategy = new VisualAnalysisUpdateStrategy(); public Guid Id { get; } public IAnalysis Analysis { get; set; } @@ -44,5 +46,12 @@ namespace StructureHelper.Windows.MainWindow.Analyses var window = new CrossSectionView(crossSection); window.ShowDialog(); } + + public object Clone() + { + var newAnalysis = Analysis.Clone() as IAnalysis; + VisualAnalysis newItem = new(newAnalysis); + return newItem; + } } } diff --git a/StructureHelper/Windows/ViewModels/Materials/HeadMaterialsViewModel.cs b/StructureHelper/Windows/ViewModels/Materials/HeadMaterialsViewModel.cs index 9845a96..61a664c 100644 --- a/StructureHelper/Windows/ViewModels/Materials/HeadMaterialsViewModel.cs +++ b/StructureHelper/Windows/ViewModels/Materials/HeadMaterialsViewModel.cs @@ -208,7 +208,7 @@ namespace StructureHelper.Windows.ViewModels.Materials if (parent is IHasPrimitives) { var primitives = (parent as IHasPrimitives).Primitives; - var primitivesWithMaterial = primitives.Where(x => x.HeadMaterial == SelectedMaterial); + var primitivesWithMaterial = primitives.Where(x => x.NdmElement.HeadMaterial == SelectedMaterial); int primitivesCount = primitivesWithMaterial.Count(); if (primitivesCount > 0) { diff --git a/StructureHelper/Windows/ViewModels/Materials/MaterialsViewModel.cs b/StructureHelper/Windows/ViewModels/Materials/MaterialsViewModel.cs index eb4b3db..47c231a 100644 --- a/StructureHelper/Windows/ViewModels/Materials/MaterialsViewModel.cs +++ b/StructureHelper/Windows/ViewModels/Materials/MaterialsViewModel.cs @@ -48,7 +48,7 @@ namespace StructureHelper.Windows.ViewModels.Materials public override void DeleteMethod(object parameter) { var primitives = repository.Primitives; - var primitivesWithMaterial = primitives.Where(x => x.HeadMaterial == SelectedItem); + var primitivesWithMaterial = primitives.Where(x => x.NdmElement.HeadMaterial == SelectedItem); int primitivesCount = primitivesWithMaterial.Count(); if (primitivesCount > 0) { diff --git a/StructureHelper/Windows/ViewModels/NdmCrossSections/HasDivisionViewModel.cs b/StructureHelper/Windows/ViewModels/NdmCrossSections/HasDivisionViewModel.cs index 0ed372b..dbd2778 100644 --- a/StructureHelper/Windows/ViewModels/NdmCrossSections/HasDivisionViewModel.cs +++ b/StructureHelper/Windows/ViewModels/NdmCrossSections/HasDivisionViewModel.cs @@ -10,9 +10,9 @@ using System.Windows.Controls; namespace StructureHelper.Windows.ViewModels.NdmCrossSections { - public class HasDivisionViewModel : ViewModelBase, IHasDivisionSize + public class HasDivisionViewModel : ViewModelBase, IDivisionSize { - private IHasDivisionSize primitive; + private IDivisionSize primitive; public double NdmMaxSize { @@ -42,7 +42,7 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections } } - public HasDivisionViewModel(IHasDivisionSize primitive) + public HasDivisionViewModel(IDivisionSize primitive) { this.primitive = primitive; } diff --git a/StructureHelper/Windows/ViewModels/NdmCrossSections/PrimitiveViewModelLogic.cs b/StructureHelper/Windows/ViewModels/NdmCrossSections/PrimitiveViewModelLogic.cs index 9c1b625..4e0a163 100644 --- a/StructureHelper/Windows/ViewModels/NdmCrossSections/PrimitiveViewModelLogic.cs +++ b/StructureHelper/Windows/ViewModels/NdmCrossSections/PrimitiveViewModelLogic.cs @@ -98,9 +98,9 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections } else if (primitiveType == PrimitiveType.Circle) { - var primitive = new CirclePrimitive + var primitive = new EllipsePrimitive { - Diameter = 0.5d + DiameterByX = 0.5d }; ndmPrimitive = primitive; viewPrimitive = new CircleViewPrimitive(primitive); @@ -251,9 +251,9 @@ namespace StructureHelper.Windows.ViewModels.NdmCrossSections { primitiveBase = new RectangleViewPrimitive(newPrimitive as IRectanglePrimitive); } - else if (newPrimitive is ICirclePrimitive) + else if (newPrimitive is IEllipsePrimitive) { - primitiveBase = new CircleViewPrimitive(newPrimitive as ICirclePrimitive); + primitiveBase = new CircleViewPrimitive(newPrimitive as IEllipsePrimitive); } else if (newPrimitive is IPointPrimitive) { diff --git a/StructureHelper/Windows/ViewModels/PrimitiveProperties/PrimitivePropertiesViewModel.cs b/StructureHelper/Windows/ViewModels/PrimitiveProperties/PrimitivePropertiesViewModel.cs index d469aa4..080aec7 100644 --- a/StructureHelper/Windows/ViewModels/PrimitiveProperties/PrimitivePropertiesViewModel.cs +++ b/StructureHelper/Windows/ViewModels/PrimitiveProperties/PrimitivePropertiesViewModel.cs @@ -305,7 +305,7 @@ namespace StructureHelper.Windows.ViewModels.PrimitiveProperties HostPrimitives = new ObservableCollection(); foreach (var item in sectionRepository.Primitives) { - if (item is RectanglePrimitive || item is CirclePrimitive) + if (item is RectanglePrimitive || item is EllipsePrimitive) { CheckHost(primitive, item); HostPrimitives.Add(PrimitiveOperations.ConvertNdmPrimitiveToPrimitiveBase(item)); @@ -320,7 +320,8 @@ namespace StructureHelper.Windows.ViewModels.PrimitiveProperties { var host = item as IHasDivisionSize; var reinforcement = ndm as RebarPrimitive; - if (host.IsPointInside(new Point2D() { X = reinforcement.Center.X, Y = reinforcement.Center.Y }) + bool checkWhenPointLocatedInsideOfItsHost = host.IsPointInside(reinforcement.Center.Clone() as IPoint2D); + if (checkWhenPointLocatedInsideOfItsHost && reinforcement.HostPrimitive is null) { var dialogResult = MessageBox.Show($"Primitive {reinforcement.Name} is inside primitive {item.Name}", diff --git a/StructureHelperCommon/Infrastructures/Exceptions/ErrorString.cs b/StructureHelperCommon/Infrastructures/Exceptions/ErrorString.cs index a0491f4..6f381e6 100644 --- a/StructureHelperCommon/Infrastructures/Exceptions/ErrorString.cs +++ b/StructureHelperCommon/Infrastructures/Exceptions/ErrorString.cs @@ -27,5 +27,7 @@ public static string ObjectNotFound => "#0018: Object not found"; public static string ErrorDuring(string operation) => string.Format("Errors appeared during {0}, see detailed information", operation); public static string CalculationError => "#0019: Error of calculation"; + public static string SourceObject => "#0020: Source object"; + public static string TargetObject => "#0021: Target object"; } } diff --git a/StructureHelperCommon/Infrastructures/Interfaces/BaseUpdateStrategy.cs b/StructureHelperCommon/Infrastructures/Interfaces/BaseUpdateStrategy.cs new file mode 100644 index 0000000..fdeaa0d --- /dev/null +++ b/StructureHelperCommon/Infrastructures/Interfaces/BaseUpdateStrategy.cs @@ -0,0 +1,19 @@ +using StructureHelperCommon.Services; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Infrastructures.Interfaces +{ + public abstract class BaseUpdateStrategy : IUpdateStrategy + { + public abstract void Update(T targetObject, T sourceObject); + public void Check(T targetObject, T sourceObject) + { + CheckObject.IsNull(targetObject, sourceObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; }; + } + } +} diff --git a/StructureHelperCommon/Infrastructures/Interfaces/DictionaryConvertStrategy.cs b/StructureHelperCommon/Infrastructures/Interfaces/DictionaryConvertStrategy.cs index adbf96d..710e0c2 100644 --- a/StructureHelperCommon/Infrastructures/Interfaces/DictionaryConvertStrategy.cs +++ b/StructureHelperCommon/Infrastructures/Interfaces/DictionaryConvertStrategy.cs @@ -17,7 +17,7 @@ namespace StructureHelperCommon.Infrastructures.Interfaces public IShiftTraceLogger? TraceLogger { get; set; } public IConvertStrategy ConvertStrategy { get; set; } public Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } - public T ConvertFrom(V source) + public T Convert(V source) { ICheckInputData(); T val; @@ -31,32 +31,12 @@ namespace StructureHelperCommon.Infrastructures.Interfaces } else { - val = ConvertStrategy.ConvertFrom(source); + val = ConvertStrategy.Convert(source); ReferenceDictionary.Add(key, val); TraceLogger?.AddMessage($"New value of {typeof(T)} (Id = {val.Id}) was added to dictionary", TraceLogStatuses.Debug); } return val; } - public V ConvertTo(T source) - { - ICheckInputData(); - V val; - var key = (source.Id, typeof(V)); - if (ReferenceDictionary.ContainsKey(key)) - { - ISaveable existValue; - ReferenceDictionary.TryGetValue(key, out existValue); - val = (V)existValue; - TraceLogger?.AddMessage($"Value of {typeof(V)} (Id = {existValue.Id}) exists already", TraceLogStatuses.Debug); - } - else - { - val = ConvertStrategy.ConvertTo(source); - ReferenceDictionary.Add(key, val); - TraceLogger?.AddMessage($"New value of {typeof(V)} (Id = {val.Id}) was added to dictionary", TraceLogStatuses.Debug); - } - return val; - } private void ICheckInputData() { if(ReferenceDictionary is null) diff --git a/StructureHelperCommon/Infrastructures/Interfaces/IConvertStrategy.cs b/StructureHelperCommon/Infrastructures/Interfaces/IConvertStrategy.cs index 8018fd1..43afc4c 100644 --- a/StructureHelperCommon/Infrastructures/Interfaces/IConvertStrategy.cs +++ b/StructureHelperCommon/Infrastructures/Interfaces/IConvertStrategy.cs @@ -11,8 +11,8 @@ namespace StructureHelperCommon.Infrastructures.Interfaces where T :ISaveable where V :ISaveable { + Dictionary<(Guid id, Type type), ISaveable> ReferenceDictionary { get; set; } IShiftTraceLogger TraceLogger { get; set; } - V ConvertTo(T source); - T ConvertFrom(V source); + T Convert(V source); } } diff --git a/StructureHelperCommon/Infrastructures/Interfaces/IHasCenter2D.cs b/StructureHelperCommon/Infrastructures/Interfaces/IHasCenter2D.cs new file mode 100644 index 0000000..69a6442 --- /dev/null +++ b/StructureHelperCommon/Infrastructures/Interfaces/IHasCenter2D.cs @@ -0,0 +1,20 @@ +using StructureHelperCommon.Models.Shapes; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Infrastructures.Interfaces +{ + /// + /// Implement center of geometry shape on 2D plane + /// + public interface IHasCenter2D + { + /// + /// 2D point of center + /// + IPoint2D Center {get;set;} + } +} diff --git a/StructureHelperCommon/Models/Analyses/Version.cs b/StructureHelperCommon/Models/Analyses/DateVersion.cs similarity index 88% rename from StructureHelperCommon/Models/Analyses/Version.cs rename to StructureHelperCommon/Models/Analyses/DateVersion.cs index 809c529..f6593eb 100644 --- a/StructureHelperCommon/Models/Analyses/Version.cs +++ b/StructureHelperCommon/Models/Analyses/DateVersion.cs @@ -7,7 +7,7 @@ using System.Threading.Tasks; namespace StructureHelperCommon.Models.Analyses { - public class Version : IVersion + public class DateVersion : IDateVersion { public DateTime DateTime { get; set; } diff --git a/StructureHelperCommon/Models/Analyses/DateVersionUpdateStrategy.cs b/StructureHelperCommon/Models/Analyses/DateVersionUpdateStrategy.cs new file mode 100644 index 0000000..9a29d46 --- /dev/null +++ b/StructureHelperCommon/Models/Analyses/DateVersionUpdateStrategy.cs @@ -0,0 +1,22 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Models.Analyses +{ + public class DateVersionUpdateStrategy : IUpdateStrategy + { + public void Update(IDateVersion targetObject, IDateVersion sourceObject) + { + CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; }; + targetObject.DateTime = sourceObject.DateTime; + } + } +} diff --git a/StructureHelperCommon/Models/Analyses/IAnalysis.cs b/StructureHelperCommon/Models/Analyses/IAnalysis.cs index 7161577..db475f6 100644 --- a/StructureHelperCommon/Models/Analyses/IAnalysis.cs +++ b/StructureHelperCommon/Models/Analyses/IAnalysis.cs @@ -7,7 +7,7 @@ using System.Threading.Tasks; namespace StructureHelperCommon.Models.Analyses { - public interface IAnalysis : ISaveable + public interface IAnalysis : ISaveable, ICloneable { string Name { get; set; } string Tags { get; set; } diff --git a/StructureHelperCommon/Models/Analyses/IVersion.cs b/StructureHelperCommon/Models/Analyses/IDateVersion.cs similarity index 78% rename from StructureHelperCommon/Models/Analyses/IVersion.cs rename to StructureHelperCommon/Models/Analyses/IDateVersion.cs index d6328ce..9ddd63d 100644 --- a/StructureHelperCommon/Models/Analyses/IVersion.cs +++ b/StructureHelperCommon/Models/Analyses/IDateVersion.cs @@ -7,9 +7,9 @@ using System.Threading.Tasks; namespace StructureHelperCommon.Models.Analyses { - public interface IVersion + public interface IDateVersion { - DateTime DateTime { get; } + DateTime DateTime { get; set; } ISaveable Item { get; set; } } } diff --git a/StructureHelperCommon/Models/Analyses/IVersionProcessor.cs b/StructureHelperCommon/Models/Analyses/IVersionProcessor.cs index 8a19534..d481b98 100644 --- a/StructureHelperCommon/Models/Analyses/IVersionProcessor.cs +++ b/StructureHelperCommon/Models/Analyses/IVersionProcessor.cs @@ -10,7 +10,7 @@ namespace StructureHelperCommon.Models.Analyses public interface IVersionProcessor : ISaveable { void AddVersion(ISaveable newItem); - List Versions { get; } - IVersion GetCurrentVersion(); + List Versions { get; } + IDateVersion GetCurrentVersion(); } } diff --git a/StructureHelperCommon/Models/Analyses/IVisualAnalysis.cs b/StructureHelperCommon/Models/Analyses/IVisualAnalysis.cs index 71ce029..d11928b 100644 --- a/StructureHelperCommon/Models/Analyses/IVisualAnalysis.cs +++ b/StructureHelperCommon/Models/Analyses/IVisualAnalysis.cs @@ -8,7 +8,7 @@ using System.Threading.Tasks; namespace StructureHelperCommon.Models.Analyses { - public interface IVisualAnalysis : ISaveable + public interface IVisualAnalysis : ISaveable, ICloneable { IAnalysis Analysis {get;set;} void Run(); diff --git a/StructureHelperCommon/Models/Analyses/VersionProcessor.cs b/StructureHelperCommon/Models/Analyses/VersionProcessor.cs index 251cbcb..c2819f7 100644 --- a/StructureHelperCommon/Models/Analyses/VersionProcessor.cs +++ b/StructureHelperCommon/Models/Analyses/VersionProcessor.cs @@ -9,7 +9,7 @@ namespace StructureHelperCommon.Models.Analyses { public class VersionProcessor : IVersionProcessor { - public List Versions { get; } + public List Versions { get; } public Guid Id { get; } @@ -24,14 +24,14 @@ namespace StructureHelperCommon.Models.Analyses } - private void AddVersion(IVersion version) + private void AddVersion(IDateVersion version) { Versions.Add(version); } public void AddVersion(ISaveable newItem) { - var version = new Version() + var version = new DateVersion() { DateTime = DateTime.Now, Item = newItem @@ -40,7 +40,7 @@ namespace StructureHelperCommon.Models.Analyses } - public IVersion GetCurrentVersion() + public IDateVersion GetCurrentVersion() { return Versions[^1]; } diff --git a/StructureHelperCommon/Models/Analyses/VisualAnalysisUpdateStrategy.cs b/StructureHelperCommon/Models/Analyses/VisualAnalysisUpdateStrategy.cs new file mode 100644 index 0000000..ea08d0b --- /dev/null +++ b/StructureHelperCommon/Models/Analyses/VisualAnalysisUpdateStrategy.cs @@ -0,0 +1,18 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Analyses; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Models.Analyses +{ + public class VisualAnalysisUpdateStrategy : IUpdateStrategy + { + public void Update(IVisualAnalysis targetObject, IVisualAnalysis sourceObject) + { + throw new NotImplementedException(); + } + } +} diff --git a/StructureHelperCommon/Models/Projects/FileVersionUpdateStrategy.cs b/StructureHelperCommon/Models/Projects/FileVersionUpdateStrategy.cs index a856d6c..160666a 100644 --- a/StructureHelperCommon/Models/Projects/FileVersionUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Projects/FileVersionUpdateStrategy.cs @@ -12,7 +12,8 @@ namespace StructureHelperCommon.Models.Projects { public void Update(IFileVersion targetObject, IFileVersion sourceObject) { - CheckObject.IsNull(targetObject, sourceObject); + CheckObject.IsNull(targetObject); + CheckObject.IsNull(sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; }; targetObject.VersionNumber = sourceObject.VersionNumber; targetObject.SubVersionNumber = sourceObject.SubVersionNumber; diff --git a/StructureHelperCommon/Models/Projects/ProjectUpdateStrategy.cs b/StructureHelperCommon/Models/Projects/ProjectUpdateStrategy.cs new file mode 100644 index 0000000..f623a74 --- /dev/null +++ b/StructureHelperCommon/Models/Projects/ProjectUpdateStrategy.cs @@ -0,0 +1,39 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Analyses; +using StructureHelperCommon.Services; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Models.Projects +{ + public class ProjectUpdateStrategy : IUpdateStrategy + { + private IUpdateStrategy updateStrategy; + + public ProjectUpdateStrategy(IUpdateStrategy updateStrategy) + { + this.updateStrategy = updateStrategy; + } + + public ProjectUpdateStrategy() : this(new VisualAnalysisUpdateStrategy()) + { + + } + + public void Update(IProject targetObject, IProject sourceObject) + { + CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; } + targetObject.VisualAnalyses.Clear(); + foreach (var item in sourceObject.VisualAnalyses) + { + targetObject.VisualAnalyses.Add(item.Clone() as IVisualAnalysis); + } + } + } +} diff --git a/StructureHelperCommon/Models/Shapes/Logics/Point2DUpdateStrategy.cs b/StructureHelperCommon/Models/Shapes/Logics/Point2DUpdateStrategy.cs index 8349a36..156c34f 100644 --- a/StructureHelperCommon/Models/Shapes/Logics/Point2DUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Shapes/Logics/Point2DUpdateStrategy.cs @@ -1,4 +1,6 @@ -using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; using System; using System.Collections.Generic; using System.Linq; @@ -17,6 +19,8 @@ namespace StructureHelperCommon.Models.Shapes /// public void Update(IPoint2D targetObject, IPoint2D sourceObject) { + CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.X = sourceObject.X; targetObject.Y = sourceObject.Y; diff --git a/StructureHelperCommon/Models/Shapes/Logics/RectangleShapeUpdateStrategy.cs b/StructureHelperCommon/Models/Shapes/Logics/RectangleShapeUpdateStrategy.cs index 713574c..8a7d234 100644 --- a/StructureHelperCommon/Models/Shapes/Logics/RectangleShapeUpdateStrategy.cs +++ b/StructureHelperCommon/Models/Shapes/Logics/RectangleShapeUpdateStrategy.cs @@ -1,4 +1,5 @@ using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; using System; using System.Collections.Generic; using System.Linq; @@ -11,6 +12,8 @@ namespace StructureHelperCommon.Models.Shapes { public void Update(IRectangleShape targetObject, IRectangleShape sourceObject) { + CheckObject.IsNull(sourceObject); + CheckObject.IsNull(targetObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Width = sourceObject.Width; targetObject.Height = sourceObject.Height; diff --git a/StructureHelperCommon/Models/Shapes/Logics/ShapeUpdateStrategy.cs b/StructureHelperCommon/Models/Shapes/Logics/ShapeUpdateStrategy.cs new file mode 100644 index 0000000..31a45a1 --- /dev/null +++ b/StructureHelperCommon/Models/Shapes/Logics/ShapeUpdateStrategy.cs @@ -0,0 +1,59 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Services; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperCommon.Models.Shapes.Logics +{ + public class ShapeUpdateStrategy : IUpdateStrategy + { + public void Update(IShape targetObject, IShape sourceObject) + { + CheckObject.IsNull(targetObject); + CheckObject.IsNull(sourceObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; } + if (sourceObject is IRectangleShape sourceRectangle) + { + ProcessRectangles(targetObject, sourceRectangle); + } + else if (sourceObject is ICircleShape sourceCircle) + { + ProcessCircles(targetObject, sourceCircle); + } + else + { + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknown); + } + } + + private static void ProcessCircles(IShape targetObject, ICircleShape sourceCircle) + { + if (targetObject is ICircleShape targetCircle) + { + var updateLogic = new CircleShapeUpdateStrategy(); + updateLogic.Update(targetCircle, sourceCircle); + } + else + { + throw new StructureHelperException(ErrorStrings.DataIsInCorrect + ": target object is not circle"); + } + } + + private static void ProcessRectangles(IShape targetObject, IRectangleShape sourceRectangle) + { + if (targetObject is IRectangleShape targetRectangle) + { + var updateLogic = new RectangleShapeUpdateStrategy(); + updateLogic.Update(targetRectangle, sourceRectangle); + } + else + { + throw new StructureHelperException(ErrorStrings.DataIsInCorrect + ": target object is not rectangle"); + } + } + } +} diff --git a/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysis.cs b/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysis.cs index 0d27cb7..77f9db8 100644 --- a/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysis.cs +++ b/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysis.cs @@ -1,15 +1,12 @@ using StructureHelperCommon.Models.Analyses; +using StructureHelperLogics.Models.Analyses; using StructureHelperLogics.Models.CrossSections; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; namespace StructureHelperLogic.Models.Analyses { public class CrossSectionNdmAnalysis : IAnalysis { + private CrossSectionNdmAnalysisUpdateStrategy updateStrategy = new(); public Guid Id { get; private set; } public string Name { get; set; } public string Tags { get; set; } @@ -21,7 +18,7 @@ namespace StructureHelperLogic.Models.Analyses VersionProcessor = versionProcessor; } - public CrossSectionNdmAnalysis() : this(new Guid(), new VersionProcessor()) + public CrossSectionNdmAnalysis() : this(Guid.NewGuid(), new VersionProcessor()) { CrossSection crossSection = new CrossSection(); VersionProcessor.AddVersion(crossSection); @@ -29,7 +26,9 @@ namespace StructureHelperLogic.Models.Analyses public object Clone() { - throw new NotImplementedException(); + CrossSectionNdmAnalysis newAnalysis = new(); + updateStrategy.Update(newAnalysis, this); + return newAnalysis; } } } diff --git a/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysisUpdateStrategy.cs b/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysisUpdateStrategy.cs new file mode 100644 index 0000000..f2ff3f4 --- /dev/null +++ b/StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysisUpdateStrategy.cs @@ -0,0 +1,68 @@ +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Analyses; +using StructureHelperCommon.Services; +using StructureHelperLogic.Models.Analyses; +using StructureHelperLogics.Models.CrossSections; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.Models.Analyses +{ + public class CrossSectionNdmAnalysisUpdateStrategy : IUpdateStrategy + { + private IUpdateStrategy analysisUpdateStrategy; + private IUpdateStrategy crossSectionUpdateStrategy; + private IUpdateStrategy dateUpdateStrategy; + + public CrossSectionNdmAnalysisUpdateStrategy(IUpdateStrategy analysisUpdateStrategy, + IUpdateStrategy crossSectionUpdateStrategy, + IUpdateStrategy dateUpdateStrategy) + { + this.analysisUpdateStrategy = analysisUpdateStrategy; + this.crossSectionUpdateStrategy = crossSectionUpdateStrategy; + this.dateUpdateStrategy = dateUpdateStrategy; + } + + public CrossSectionNdmAnalysisUpdateStrategy() : this( + new AnalysisUpdateStrategy(), + new CrossSectionUpdateStrategy(), + new DateVersionUpdateStrategy()) + { + + } + + public void Update(CrossSectionNdmAnalysis targetObject, CrossSectionNdmAnalysis sourceObject) + { + CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject); + CheckObject.IsNull(targetObject, ErrorStrings.TargetObject); + if (ReferenceEquals(targetObject, sourceObject)) { return; }; + analysisUpdateStrategy.Update(targetObject, sourceObject); + targetObject.VersionProcessor.Versions.Clear(); + foreach (var version in sourceObject.VersionProcessor.Versions) + { + if (version.Item is ICrossSection crossSection) + { + updateVersion(targetObject, version, crossSection); + } + else + { + throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(version.Item)); + } + } + } + + private void updateVersion(CrossSectionNdmAnalysis targetObject, IDateVersion version, ICrossSection crossSection) + { + DateVersion newVersion = new(); + dateUpdateStrategy.Update(newVersion, version); + CrossSection newCrossection = new(); + crossSectionUpdateStrategy.Update(newCrossection, crossSection); + newVersion.Item = newCrossection; + targetObject.VersionProcessor.Versions.Add(newVersion); + } + } +} diff --git a/StructureHelperLogics/Models/Templates/CrossSections/RCs/CircleGeometryLogic.cs b/StructureHelperLogics/Models/Templates/CrossSections/RCs/CircleGeometryLogic.cs index b9afa97..03868b7 100644 --- a/StructureHelperLogics/Models/Templates/CrossSections/RCs/CircleGeometryLogic.cs +++ b/StructureHelperLogics/Models/Templates/CrossSections/RCs/CircleGeometryLogic.cs @@ -13,7 +13,7 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs public class CircleGeometryLogic : IRCGeometryLogic { ICircleTemplate template; - CirclePrimitive concreteBlock; + EllipsePrimitive concreteBlock; public IEnumerable HeadMaterials { get; set; } @@ -35,7 +35,8 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs var diameter = template.Shape.Diameter; var concreteMaterial = HeadMaterials.ToList()[0]; var primitives = new List(); - concreteBlock = new CirclePrimitive() { Diameter = diameter, Name = "Concrete block", HeadMaterial = concreteMaterial }; + concreteBlock = new EllipsePrimitive() { DiameterByX = diameter, Name = "Concrete block"}; + concreteBlock.NdmElement.HeadMaterial = concreteMaterial; primitives.Add(concreteBlock); return primitives; } @@ -56,11 +57,11 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs { Area = barArea, Name = "Left bottom point", - HeadMaterial = reinforcementMaterial, HostPrimitive=concreteBlock }; point.Center.X = x; point.Center.Y = y; primitives.Add(point); + point.NdmElement.HeadMaterial = reinforcementMaterial; } return primitives; } diff --git a/StructureHelperLogics/Models/Templates/CrossSections/RCs/RectGeometryLogic.cs b/StructureHelperLogics/Models/Templates/CrossSections/RCs/RectGeometryLogic.cs index b62e2a2..fa7a4aa 100644 --- a/StructureHelperLogics/Models/Templates/CrossSections/RCs/RectGeometryLogic.cs +++ b/StructureHelperLogics/Models/Templates/CrossSections/RCs/RectGeometryLogic.cs @@ -48,7 +48,8 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs private IEnumerable GetConcretePrimitives() { var primitives = new List(); - concreteBlock = new RectanglePrimitive(concrete) { Width = width, Height = height, Name = "Concrete block" }; + concreteBlock = new RectanglePrimitive() { Width = width, Height = height, Name = "Concrete block" }; + concreteBlock.NdmElement.HeadMaterial = concrete; primitives.Add(concreteBlock); return primitives; } @@ -63,9 +64,10 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs { Area = area1, Name = "Left bottom rebar", - HeadMaterial = reinforcement, + HostPrimitive=concreteBlock }; + point.NdmElement.HeadMaterial = reinforcement; point.Center.X = xs[0]; point.Center.Y = ys[0]; primitives.Add(point); @@ -73,9 +75,9 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs { Area = area1, Name = "Right bottom rebar", - HeadMaterial = reinforcement, HostPrimitive = concreteBlock }; + point.NdmElement.HeadMaterial = reinforcement; point.Center.X = xs[1]; point.Center.Y = ys[0]; primitives.Add(point); @@ -83,9 +85,9 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs { Area = area2, Name = "Left top rebar", - HeadMaterial = reinforcement, HostPrimitive = concreteBlock }; + point.NdmElement.HeadMaterial = reinforcement; point.Center.X = xs[0]; point.Center.Y = ys[1]; primitives.Add(point); @@ -93,9 +95,9 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs { Area = area2, Name = "Right top rebar", - HeadMaterial = reinforcement, HostPrimitive = concreteBlock }; + point.NdmElement.HeadMaterial = reinforcement; point.Center.X = xs[1]; point.Center.Y = ys[1]; primitives.Add(point); @@ -115,11 +117,23 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs double dist = (xs[1] - xs[0]) / count; for (int i = 1; i < count; i++) { - point = new RebarPrimitive() { Area = area1, Name = $"Bottom rebar {i}", HeadMaterial = reinforcement, HostPrimitive = concreteBlock }; + point = new RebarPrimitive() + { + Area = area1, + Name = $"Bottom rebar {i}", + HostPrimitive = concreteBlock + }; + point.NdmElement.HeadMaterial = reinforcement; point.Center.X = xs[0] + dist * i; point.Center.Y = ys[0]; primitives.Add(point); - point = new RebarPrimitive() {Area = area2, Name = $"Top rebar {i}", HeadMaterial = reinforcement, HostPrimitive = concreteBlock }; + point = new RebarPrimitive() + { + Area = area2, + Name = $"Top rebar {i}", + HostPrimitive = concreteBlock + }; + point.NdmElement.HeadMaterial = reinforcement; point.Center.X = xs[0] + dist * i; point.Center.Y = ys[1]; primitives.Add(point); @@ -135,9 +149,9 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs { Area = area1, Name = $"Left point {i}", - HeadMaterial = reinforcement, HostPrimitive = concreteBlock }; + point.NdmElement.HeadMaterial = reinforcement; point.Center.X = xs[0]; point.Center.Y = ys[0] + dist * i; primitives.Add(point); @@ -145,9 +159,9 @@ namespace StructureHelperLogics.Models.Templates.CrossSections.RCs { Area = area1, Name = $"Right point {i}", - HeadMaterial = reinforcement, HostPrimitive = concreteBlock }; + point.NdmElement.HeadMaterial = reinforcement; point.Center.X = xs[1]; point.Center.Y = ys[0] + dist * i; primitives.Add(point); diff --git a/StructureHelperLogics/NdmCalculations/Analyses/RC/InputDataFactory.cs b/StructureHelperLogics/NdmCalculations/Analyses/RC/InputDataFactory.cs index 64e18a0..9efe1bb 100644 --- a/StructureHelperLogics/NdmCalculations/Analyses/RC/InputDataFactory.cs +++ b/StructureHelperLogics/NdmCalculations/Analyses/RC/InputDataFactory.cs @@ -26,7 +26,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.RC inputData.CrossSectionArea = ndmPrimitive.Area; var diameter = Math.Sqrt(ndmPrimitive.Area / Math.PI) * 2d; inputData.CrossSectionPerimeter = Math.PI * diameter; - if (ndmPrimitive.HeadMaterial is null) + if (ndmPrimitive.NdmElement.HeadMaterial is null) { throw new StructureHelperException(ErrorStrings.DataIsInCorrect + ": main material is incorrect or null"); } @@ -52,7 +52,10 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.RC if (primitive.HostPrimitive is not null) { var host = primitive.HostPrimitive; - var hostMaterial = host.HeadMaterial.HelperMaterial; + var hostMaterial = host + .NdmElement + .HeadMaterial + .HelperMaterial; if (hostMaterial is IConcreteLibMaterial) { var concreteMaterial = hostMaterial as IConcreteLibMaterial; @@ -65,9 +68,9 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.RC private static double GetReinforcementStrength(LimitStates limitState, CalcTerms calcTerm, RebarPrimitive primitive) { - if (primitive.HeadMaterial.HelperMaterial is IReinforcementLibMaterial) + if (primitive.NdmElement.HeadMaterial.HelperMaterial is IReinforcementLibMaterial) { - var material = primitive.HeadMaterial.HelperMaterial as IReinforcementLibMaterial; + var material = primitive.NdmElement.HeadMaterial.HelperMaterial as IReinforcementLibMaterial; var strength = material.GetStrength(limitState, calcTerm).Tensile; return strength; } diff --git a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputDataFactory.cs b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputDataFactory.cs index 753f9f0..14e0c65 100644 --- a/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputDataFactory.cs +++ b/StructureHelperLogics/NdmCalculations/Cracking/RebarCrackInputDataFactory.cs @@ -44,7 +44,7 @@ namespace StructureHelperLogics.NdmCalculations.Cracking RebarPrimitive rebarCopy = null; rebarCopy = Rebar.Clone() as RebarPrimitive; - rebarCopy.HeadMaterial = rebarCopy.HeadMaterial.Clone() as IHeadMaterial; + rebarCopy.NdmElement.HeadMaterial = rebarCopy.NdmElement.HeadMaterial.Clone() as IHeadMaterial; triangulationLogicLoc = new CrackedSectionTriangulationLogic(InputData.Primitives); crackableNdmsLoc = triangulationLogicLoc.GetNdmCollection(); crackedNdmsLoc = triangulationLogicLoc.GetCrackedNdmCollection(); diff --git a/StructureHelperLogics/NdmCalculations/Primitives/DivisionSize.cs b/StructureHelperLogics/NdmCalculations/Primitives/DivisionSize.cs new file mode 100644 index 0000000..cc1bd12 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Primitives/DivisionSize.cs @@ -0,0 +1,19 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Primitives +{ + /// + public class DivisionSize : IDivisionSize + { + /// + public double NdmMaxSize { get; set; } = 0.01d; + /// + public int NdmMinDivision { get; set; } = 10; + /// + public bool ClearUnderlying { get; set; } = false; + } +} diff --git a/StructureHelperLogics/NdmCalculations/Primitives/CirclePrimitive.cs b/StructureHelperLogics/NdmCalculations/Primitives/EllipsePrimitive.cs similarity index 65% rename from StructureHelperLogics/NdmCalculations/Primitives/CirclePrimitive.cs rename to StructureHelperLogics/NdmCalculations/Primitives/EllipsePrimitive.cs index f525154..a1b2e8d 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/CirclePrimitive.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/EllipsePrimitive.cs @@ -9,46 +9,54 @@ using StructureHelperLogics.NdmCalculations.Triangulations; namespace StructureHelperLogics.NdmCalculations.Primitives { - public class CirclePrimitive : ICirclePrimitive + public class EllipsePrimitive : IEllipsePrimitive { - static readonly CircleUpdateStrategy updateStrategy = new(); + private static readonly EllipsePrimitiveUpdateStrategy updateStrategy = new(); + private readonly RectangleShape rectangleShape = new(); + /// public Guid Id { get; set; } /// public string Name { get; set; } /// - public IPoint2D Center { get; private set; } - public IHeadMaterial? HeadMaterial { get; set; } - public StrainTuple UsersPrestrain { get; } - public StrainTuple AutoPrestrain { get; } - public IVisualProperty VisualProperty { get; } - public double Diameter { get; set; } - public double NdmMaxSize { get; set; } - public int NdmMinDivision { get; set; } - public bool ClearUnderlying { get; set; } - public bool Triangulate { get; set; } + public IPoint2D Center { get; set; } = new Point2D(); + /// + public IVisualProperty VisualProperty { get; } = new VisualProperty { Opacity = 0.8d }; + /// + public double DiameterByX + { + get + { + return rectangleShape.Width; + } + set + { + rectangleShape.Width = value; + rectangleShape.Height = value; + } + } + /// + public double DiameterByY { get => rectangleShape.Height; set => rectangleShape.Height = value; } + /// public ICrossSection? CrossSection { get; set; } + /// public INdmElement NdmElement { get; } = new NdmElement(); + /// + public IDivisionSize DivisionSize { get; } = new DivisionSize(); + /// + public IShape Shape => rectangleShape; - public CirclePrimitive(Guid id) + + public EllipsePrimitive(Guid id) { Id = id; Name = "New Circle"; - NdmMaxSize = 0.01d; - NdmMinDivision = 10; - Center = new Point2D(); - VisualProperty = new VisualProperty { Opacity = 0.8d }; - UsersPrestrain = new StrainTuple(); - AutoPrestrain = new StrainTuple(); - ClearUnderlying = false; - Triangulate = true; } - public CirclePrimitive() : this (Guid.NewGuid()) - {} + public EllipsePrimitive() : this (Guid.NewGuid()) {} /// public object Clone() { - var primitive = new CirclePrimitive(); + var primitive = new EllipsePrimitive(); updateStrategy.Update(primitive, this); return primitive; } @@ -70,7 +78,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives var dX = Center.X - point.X; var dY = Center.Y - point.Y; var distance = Math.Sqrt(dX * dX + dY * dY); - if (distance > Diameter / 2) { return false; } + if (distance > DiameterByX / 2) { return false; } return true; } @@ -88,28 +96,28 @@ namespace StructureHelperLogics.NdmCalculations.Primitives newPoint = new NamedAreaPoint { Name = "Left", - Point = new Point2D() { X = Center.X - Diameter / 2d, Y = Center.Y}, + Point = new Point2D() { X = Center.X - DiameterByX / 2d, Y = Center.Y}, Area = 0d }; points.Add(newPoint); newPoint = new NamedAreaPoint { Name = "Top", - Point = new Point2D() { X = Center.X, Y = Center.Y + Diameter / 2d }, + Point = new Point2D() { X = Center.X, Y = Center.Y + DiameterByX / 2d }, Area = 0d }; points.Add(newPoint); newPoint = new NamedAreaPoint { Name = "Right", - Point = new Point2D() { X = Center.X + Diameter / 2d, Y = Center.Y }, + Point = new Point2D() { X = Center.X + DiameterByX / 2d, Y = Center.Y }, Area = 0d }; points.Add(newPoint); newPoint = new NamedAreaPoint { Name = "Bottom", - Point = new Point2D() { X = Center.X, Y = Center.Y - Diameter / 2d }, + Point = new Point2D() { X = Center.X, Y = Center.Y - DiameterByX / 2d }, Area = 0d }; points.Add(newPoint); diff --git a/StructureHelperLogics/NdmCalculations/Primitives/IDivisionSize.cs b/StructureHelperLogics/NdmCalculations/Primitives/IDivisionSize.cs new file mode 100644 index 0000000..18d79ad --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Primitives/IDivisionSize.cs @@ -0,0 +1,29 @@ +using StructureHelperCommon.Models.Shapes; +using StructureHelperLogics.Models.Primitives; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Primitives +{ + /// + /// Include parameters of triangulation for shapes + /// + public interface IDivisionSize + { + /// + /// Maximum size of Ndm part + /// + double NdmMaxSize { get; set; } + /// + /// Mimimum division for sides of shape + /// + int NdmMinDivision { get; set; } + /// + /// Flag of removing ndm part which located inside shape + /// + bool ClearUnderlying { get; set; } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Primitives/ICirclePrimitive.cs b/StructureHelperLogics/NdmCalculations/Primitives/IEllipsePrimitive.cs similarity index 60% rename from StructureHelperLogics/NdmCalculations/Primitives/ICirclePrimitive.cs rename to StructureHelperLogics/NdmCalculations/Primitives/IEllipsePrimitive.cs index cc41aaa..6514816 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/ICirclePrimitive.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/IEllipsePrimitive.cs @@ -7,7 +7,10 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Primitives { - public interface ICirclePrimitive : INdmPrimitive, IHasDivisionSize, ICircleShape + public interface IEllipsePrimitive : INdmPrimitive, IHasDivisionSize { + double DiameterByX { get; set; } + double DiameterByY { get; set; } + } } diff --git a/StructureHelperLogics/NdmCalculations/Primitives/IHasDivisionSize.cs b/StructureHelperLogics/NdmCalculations/Primitives/IHasDivisionSize.cs index 3f016ff..32a7632 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/IHasDivisionSize.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/IHasDivisionSize.cs @@ -1,5 +1,4 @@ using StructureHelperCommon.Models.Shapes; -using StructureHelperLogics.Models.Primitives; using System; using System.Collections.Generic; using System.Linq; @@ -8,23 +7,10 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Primitives { - /// - /// Include parameters of triangulation for shapes - /// public interface IHasDivisionSize { - /// - /// Maximum size of Ndm part - /// - double NdmMaxSize { get; set; } - /// - /// Mimimum division for sides of shape - /// - int NdmMinDivision { get; set; } - /// - /// Flag of removing ndm part which located inside shape - /// - bool ClearUnderlying { get; set; } + /// + IDivisionSize DivisionSize { get; } /// /// Shows if point is located inside shape /// diff --git a/StructureHelperLogics/NdmCalculations/Primitives/ILinePrimitive.cs b/StructureHelperLogics/NdmCalculations/Primitives/ILinePrimitive.cs index fc78d08..2fd50b7 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/ILinePrimitive.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/ILinePrimitive.cs @@ -7,7 +7,7 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Primitives { - public interface ILinePrimitive : IHasDivisionSize, ILineShape + public interface ILinePrimitive : IDivisionSize, ILineShape { } } diff --git a/StructureHelperLogics/NdmCalculations/Primitives/INdmElement.cs b/StructureHelperLogics/NdmCalculations/Primitives/INdmElement.cs index e600468..85ef870 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/INdmElement.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/INdmElement.cs @@ -13,10 +13,6 @@ namespace StructureHelperLogics.NdmCalculations.Primitives { public interface INdmElement : ISaveable, ICloneable { - /// - /// Base point of primitive - /// - IPoint2D Center { get; } /// /// Material of primitive /// diff --git a/StructureHelperLogics/NdmCalculations/Primitives/INdmPrimitive.cs b/StructureHelperLogics/NdmCalculations/Primitives/INdmPrimitive.cs index c46eefc..0ccdde5 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/INdmPrimitive.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/INdmPrimitive.cs @@ -17,38 +17,22 @@ namespace StructureHelperLogics.NdmCalculations.Primitives /// /// Geometrical primitive which generates ndm elemtntary part /// - public interface INdmPrimitive : ISaveable, ICloneable + public interface INdmPrimitive : ISaveable, IHasCenter2D, ICloneable { /// /// Name of primitive /// string? Name { get; set; } - INdmElement NdmElement { get;} + IShape Shape { get; } /// - /// Base point of primitive + /// Base properties of primitive /// - IPoint2D Center { get; } + INdmElement NdmElement { get;} /// /// Host cross-section for primitive /// ICrossSection? CrossSection { get; set; } /// - /// Material of primitive - /// - IHeadMaterial? HeadMaterial { get; set; } - /// - /// Flag of triangulation - /// - bool Triangulate { get; set; } - /// - /// Prestrain assigned from user - /// - StrainTuple UsersPrestrain { get; } - /// - /// Prestrain assigned from calculations - /// - StrainTuple AutoPrestrain { get; } - /// /// Visual settings /// IVisualProperty VisualProperty {get; } diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/BaseUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/BaseUpdateStrategy.cs index b014d29..9f28b7f 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/BaseUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/BaseUpdateStrategy.cs @@ -23,11 +23,14 @@ namespace StructureHelperLogics.NdmCalculations.Primitives CheckObject.IsNull(targetObject, sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.Name = sourceObject.Name; - if (sourceObject.HeadMaterial != null) targetObject.HeadMaterial = sourceObject.HeadMaterial; - targetObject.Triangulate = sourceObject.Triangulate; + if (sourceObject.NdmElement.HeadMaterial != null) + { + targetObject.NdmElement.HeadMaterial = sourceObject.NdmElement.HeadMaterial; + } + targetObject.NdmElement.Triangulate = sourceObject.NdmElement.Triangulate; point2DUpdateStrategy.Update(targetObject.Center, sourceObject.Center); visualPropsUpdateStrategy.Update(targetObject.VisualProperty, sourceObject.VisualProperty); - tupleUpdateStrategy.Update(targetObject.UsersPrestrain, sourceObject.UsersPrestrain); + tupleUpdateStrategy.Update(targetObject.NdmElement.UsersPrestrain, sourceObject.NdmElement.UsersPrestrain); } } diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs index b9b03eb..a164f65 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/CheckRebarPrimitiveLogic.cs @@ -60,10 +60,10 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics } } - if (RebarPrimitive.HostPrimitive.HeadMaterial.HelperMaterial is not ICrackedMaterial) + if (RebarPrimitive.HostPrimitive.NdmElement.HeadMaterial.HelperMaterial is not ICrackedMaterial) { result = false; - string message = $"Material of host of {RebarPrimitive.Name} ({RebarPrimitive.HostPrimitive.HeadMaterial.Name}) does not support cracking\n"; + string message = $"Material of host of {RebarPrimitive.Name} ({RebarPrimitive.HostPrimitive.NdmElement.HeadMaterial.Name}) does not support cracking\n"; checkResult += message; TraceLogger?.AddMessage(message, TraceLogStatuses.Error); } diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/CircleUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/CircleUpdateStrategy.cs deleted file mode 100644 index 2d155a7..0000000 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/CircleUpdateStrategy.cs +++ /dev/null @@ -1,25 +0,0 @@ -using StructureHelperCommon.Infrastructures.Interfaces; -using StructureHelperCommon.Models.Shapes; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace StructureHelperLogics.NdmCalculations.Primitives -{ - internal class CircleUpdateStrategy : IUpdateStrategy - { - static readonly BaseUpdateStrategy basePrimitiveUpdateStrategy = new(); - static readonly DivisionPropsUpdateStrategy divisionPropsUpdateStrategy = new(); - static readonly CircleShapeUpdateStrategy shapeUpdateStrategy = new(); - - public void Update(CirclePrimitive targetObject, CirclePrimitive sourceObject) - { - if (ReferenceEquals(targetObject, sourceObject)) { return; } - basePrimitiveUpdateStrategy.Update(targetObject, sourceObject); - divisionPropsUpdateStrategy.Update(targetObject, sourceObject); - shapeUpdateStrategy.Update(targetObject, sourceObject); - } - } -} diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/DivisionPropsUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/DivisionPropsUpdateStrategy.cs index 2eac440..eb98e8d 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/DivisionPropsUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/DivisionPropsUpdateStrategy.cs @@ -7,9 +7,9 @@ using System.Threading.Tasks; namespace StructureHelperLogics.NdmCalculations.Primitives { - internal class DivisionPropsUpdateStrategy : IUpdateStrategy + internal class DivisionPropsUpdateStrategy : IUpdateStrategy { - public void Update(IHasDivisionSize targetObject, IHasDivisionSize sourceObject) + public void Update(IDivisionSize targetObject, IDivisionSize sourceObject) { if (ReferenceEquals(targetObject, sourceObject)) { return; } targetObject.NdmMaxSize = sourceObject.NdmMaxSize; diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/EllipsePrimitiveUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/EllipsePrimitiveUpdateStrategy.cs new file mode 100644 index 0000000..dc39906 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/EllipsePrimitiveUpdateStrategy.cs @@ -0,0 +1,39 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Shapes; +using StructureHelperCommon.Models.Shapes.Logics; +using StructureHelperCommon.Services; + +namespace StructureHelperLogics.NdmCalculations.Primitives +{ + internal class EllipsePrimitiveUpdateStrategy : IUpdateStrategy + { + private IUpdateStrategy basePrimitiveUpdateStrategy; + private IUpdateStrategy divisionPropsUpdateStrategy; + private IUpdateStrategy shapeUpdateStrategy; + + public EllipsePrimitiveUpdateStrategy(IUpdateStrategy basePrimitiveUpdateStrategy, + IUpdateStrategy shapeUpdateStrategy, + IUpdateStrategy divisionPropsUpdateStrategy) + { + this.basePrimitiveUpdateStrategy = basePrimitiveUpdateStrategy; + this.shapeUpdateStrategy = shapeUpdateStrategy; + this.divisionPropsUpdateStrategy = divisionPropsUpdateStrategy; + } + public EllipsePrimitiveUpdateStrategy() : this( + new BaseUpdateStrategy(), + new ShapeUpdateStrategy(), + new DivisionPropsUpdateStrategy()) + { + + } + public void Update(IEllipsePrimitive targetObject, IEllipsePrimitive sourceObject) + { + CheckObject.IsNull(sourceObject, "source object"); + CheckObject.IsNull(targetObject, "target object"); + if (ReferenceEquals(targetObject, sourceObject)) { return; } + basePrimitiveUpdateStrategy.Update(targetObject, sourceObject); + divisionPropsUpdateStrategy.Update(targetObject.DivisionSize, sourceObject.DivisionSize); + shapeUpdateStrategy.Update(targetObject.Shape, sourceObject.Shape); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/INdmElementUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmElementUpdateStrategy.cs similarity index 63% rename from StructureHelperLogics/NdmCalculations/Primitives/Logics/INdmElementUpdateStrategy.cs rename to StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmElementUpdateStrategy.cs index a160117..ab8906d 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/INdmElementUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmElementUpdateStrategy.cs @@ -5,21 +5,16 @@ using StructureHelperCommon.Services; namespace StructureHelperLogics.NdmCalculations.Primitives.Logics { - public class INdmElementUpdateStrategy : IUpdateStrategy + public class NdmElementUpdateStrategy : IUpdateStrategy { - private readonly IUpdateStrategy point2DUpdateStrategy; private readonly IUpdateStrategy tupleUpdateStrategy; - public INdmElementUpdateStrategy(IUpdateStrategy point2DUpdateStrategy, - IUpdateStrategy tupleUpdateStrategy) + public NdmElementUpdateStrategy(IUpdateStrategy tupleUpdateStrategy) { - this.point2DUpdateStrategy = point2DUpdateStrategy; this.tupleUpdateStrategy = tupleUpdateStrategy; } - public INdmElementUpdateStrategy() : this ( - new Point2DUpdateStrategy(), - new ForceTupleUpdateStrategy()) + public NdmElementUpdateStrategy() : this (new ForceTupleUpdateStrategy()) { } @@ -29,8 +24,6 @@ namespace StructureHelperLogics.NdmCalculations.Primitives.Logics { CheckObject.IsNull(targetObject, sourceObject); if (ReferenceEquals(targetObject, sourceObject)) { return; } - - point2DUpdateStrategy.Update(targetObject.Center, sourceObject.Center); if (sourceObject.HeadMaterial != null) { targetObject.HeadMaterial = sourceObject.HeadMaterial; diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmPrimitiveUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmPrimitiveUpdateStrategy.cs index 0b766bb..1c840b8 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmPrimitiveUpdateStrategy.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmPrimitiveUpdateStrategy.cs @@ -21,11 +21,11 @@ namespace StructureHelperLogics.NdmCalculations.Primitives } else if (targetObject is RectanglePrimitive rectangle) { - new RectangleUpdateStrategy().Update(rectangle, (RectanglePrimitive)sourceObject); + new RectanglePrimitiveUpdateStrategy().Update(rectangle, (RectanglePrimitive)sourceObject); } - else if (targetObject is CirclePrimitive circle) + else if (targetObject is EllipsePrimitive circle) { - new CircleUpdateStrategy().Update(circle, (CirclePrimitive)sourceObject); + new EllipsePrimitiveUpdateStrategy().Update(circle, (EllipsePrimitive)sourceObject); } else { diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/RectanglePrimitiveUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/RectanglePrimitiveUpdateStrategy.cs new file mode 100644 index 0000000..3002a80 --- /dev/null +++ b/StructureHelperLogics/NdmCalculations/Primitives/Logics/RectanglePrimitiveUpdateStrategy.cs @@ -0,0 +1,45 @@ +using StructureHelperCommon.Infrastructures.Interfaces; +using StructureHelperCommon.Models.Shapes; +using StructureHelperCommon.Models.Shapes.Logics; +using StructureHelperCommon.Services; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace StructureHelperLogics.NdmCalculations.Primitives +{ + internal class RectanglePrimitiveUpdateStrategy : IUpdateStrategy + { + private IUpdateStrategy basePrimitiveUpdateStrategy; + private IUpdateStrategy divisionPropsUpdateStrategy; + private IUpdateStrategy shapeUpdateStrategy; + + public RectanglePrimitiveUpdateStrategy(IUpdateStrategy basePrimitiveUpdateStrategy, + IUpdateStrategy shapeUpdateStrategy, + IUpdateStrategy divisionPropsUpdateStrategy) + { + this.basePrimitiveUpdateStrategy = basePrimitiveUpdateStrategy; + this.shapeUpdateStrategy = shapeUpdateStrategy; + this.divisionPropsUpdateStrategy = divisionPropsUpdateStrategy; + } + public RectanglePrimitiveUpdateStrategy() : this( + new BaseUpdateStrategy(), + new ShapeUpdateStrategy(), + new DivisionPropsUpdateStrategy()) + { + + } + + public void Update(IRectanglePrimitive targetObject, IRectanglePrimitive sourceObject) + { + CheckObject.IsNull(sourceObject, "source object"); + CheckObject.IsNull(targetObject, "target object"); + if (ReferenceEquals(targetObject, sourceObject)) { return; } + basePrimitiveUpdateStrategy.Update(targetObject, sourceObject); + divisionPropsUpdateStrategy.Update(targetObject.DivisionSize, sourceObject.DivisionSize); + shapeUpdateStrategy.Update(targetObject.Shape, sourceObject.Shape); + } + } +} diff --git a/StructureHelperLogics/NdmCalculations/Primitives/Logics/RectangleUpdateStrategy.cs b/StructureHelperLogics/NdmCalculations/Primitives/Logics/RectangleUpdateStrategy.cs deleted file mode 100644 index 18c4e3c..0000000 --- a/StructureHelperLogics/NdmCalculations/Primitives/Logics/RectangleUpdateStrategy.cs +++ /dev/null @@ -1,24 +0,0 @@ -using StructureHelperCommon.Infrastructures.Interfaces; -using StructureHelperCommon.Models.Shapes; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace StructureHelperLogics.NdmCalculations.Primitives -{ - internal class RectangleUpdateStrategy : IUpdateStrategy - { - static readonly BaseUpdateStrategy basePrimitiveUpdateStrategy = new(); - static readonly DivisionPropsUpdateStrategy divisionPropsUpdateStrategy = new(); - static readonly RectangleShapeUpdateStrategy shapeUpdateStrategy = new(); - public void Update(RectanglePrimitive targetObject, RectanglePrimitive sourceObject) - { - if (ReferenceEquals(targetObject, sourceObject)) { return; } - basePrimitiveUpdateStrategy.Update(targetObject, sourceObject); - divisionPropsUpdateStrategy.Update(targetObject, sourceObject); - shapeUpdateStrategy.Update(targetObject, sourceObject); - } - } -} diff --git a/StructureHelperLogics/NdmCalculations/Primitives/NdmElement.cs b/StructureHelperLogics/NdmCalculations/Primitives/NdmElement.cs index 60851f3..aa8f90f 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/NdmElement.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/NdmElement.cs @@ -18,11 +18,9 @@ namespace StructureHelperLogics.NdmCalculations.Primitives /// public Guid Id { get; } /// - public IPoint2D Center { get; } = new Point2D(); - /// public IHeadMaterial? HeadMaterial { get; set; } /// - public bool Triangulate { get; set; } + public bool Triangulate { get; set; } = true; /// public StrainTuple UsersPrestrain { get; } = new(); /// diff --git a/StructureHelperLogics/NdmCalculations/Primitives/PointPrimitive.cs b/StructureHelperLogics/NdmCalculations/Primitives/PointPrimitive.cs index cdf395a..b0d22eb 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/PointPrimitive.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/PointPrimitive.cs @@ -14,34 +14,26 @@ namespace StructureHelperLogics.Models.Primitives static readonly PointUpdateStrategy updateStrategy = new(); public Guid Id { get; } public string? Name { get; set; } - public IPoint2D Center { get; private set; } - public IHeadMaterial HeadMaterial { get; set; } - //public double NdmMaxSize { get; set; } - //public int NdmMinDivision { get; set; } - public StrainTuple UsersPrestrain { get; private set; } - public StrainTuple AutoPrestrain { get; private set; } + public IPoint2D Center { get; set; } public double Area { get; set; } - public IVisualProperty VisualProperty { get; } - public bool Triangulate { get; set; } + public IVisualProperty VisualProperty { get; } = new VisualProperty(); + public ICrossSection? CrossSection { get; set; } public INdmElement NdmElement { get; } = new NdmElement(); + public IShape Shape => throw new NotImplementedException(); + public PointPrimitive(Guid id) { Id = id; Name = "New Point"; Area = 0.0005d; Center = new Point2D(); - VisualProperty = new VisualProperty(); - UsersPrestrain = new StrainTuple(); - AutoPrestrain = new StrainTuple(); - Triangulate = true; } public PointPrimitive() : this (Guid.NewGuid()) {} - public PointPrimitive(IHeadMaterial material) : this() { HeadMaterial = material; } public object Clone() { diff --git a/StructureHelperLogics/NdmCalculations/Primitives/RebarPrimitive.cs b/StructureHelperLogics/NdmCalculations/Primitives/RebarPrimitive.cs index a0a1787..7b435b6 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/RebarPrimitive.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/RebarPrimitive.cs @@ -27,17 +27,9 @@ namespace StructureHelperLogics.NdmCalculations.Primitives /// public string Name { get; set; } /// - public IPoint2D Center { get; private set; } + public IPoint2D Center { get; set; } /// - public IHeadMaterial? HeadMaterial { get; set; } - /// - public bool Triangulate { get; set; } - /// - public StrainTuple UsersPrestrain { get; private set; } - /// - public StrainTuple AutoPrestrain { get; private set; } - /// - public IVisualProperty VisualProperty { get; private set; } + public IVisualProperty VisualProperty { get; private set; } = new VisualProperty(); /// public Guid Id { get; set; } /// @@ -49,16 +41,14 @@ namespace StructureHelperLogics.NdmCalculations.Primitives public INdmElement NdmElement { get; } = new NdmElement(); + public IShape Shape => throw new NotImplementedException(); + public RebarPrimitive(Guid id) { Id = id; Name = "New Reinforcement"; Area = 0.0005d; Center = new Point2D(); - VisualProperty = new VisualProperty(); - UsersPrestrain = new StrainTuple(); - AutoPrestrain = new StrainTuple(); - Triangulate = true; } public RebarPrimitive() : this(Guid.NewGuid()) { diff --git a/StructureHelperLogics/NdmCalculations/Primitives/RectanglePrimitive.cs b/StructureHelperLogics/NdmCalculations/Primitives/RectanglePrimitive.cs index 0537b4b..74520a9 100644 --- a/StructureHelperLogics/NdmCalculations/Primitives/RectanglePrimitive.cs +++ b/StructureHelperLogics/NdmCalculations/Primitives/RectanglePrimitive.cs @@ -11,46 +11,34 @@ namespace StructureHelperLogics.NdmCalculations.Primitives { public class RectanglePrimitive : IRectanglePrimitive { - readonly RectangleUpdateStrategy updateStrategy = new(); + private readonly RectanglePrimitiveUpdateStrategy updateStrategy = new(); + private readonly RectangleShape rectangleShape = new(); public Guid Id { get;} public string Name { get; set; } - public IHeadMaterial? HeadMaterial { get; set; } - public StrainTuple UsersPrestrain { get; private set; } - public StrainTuple AutoPrestrain { get; private set; } - public double NdmMaxSize { get; set; } - public int NdmMinDivision { get; set; } - public double Width { get; set; } - public double Height { get; set; } - public double Angle { get; set; } - public bool ClearUnderlying { get; set; } - public bool Triangulate { get; set; } - public IVisualProperty VisualProperty { get; } + public double Width { get => rectangleShape.Width; set => rectangleShape.Width = value; } + public double Height { get => rectangleShape.Height; set => rectangleShape.Height = value; } + public double Angle { get => rectangleShape.Angle; set => rectangleShape.Angle = value; } + public IVisualProperty VisualProperty { get; } = new VisualProperty() { Opacity = 0.8d }; public ICrossSection? CrossSection { get; set; } - public IPoint2D Center { get; private set; } + public IPoint2D Center { get; set; } = new Point2D(); public INdmElement NdmElement { get; } = new NdmElement(); + public IDivisionSize DivisionSize { get; } = new DivisionSize(); + + public IShape Shape => rectangleShape; + public RectanglePrimitive(Guid id) { Id = id; Name = "New Rectangle"; - NdmMaxSize = 0.01d; - NdmMinDivision = 10; - Center = new Point2D(); - VisualProperty = new VisualProperty { Opacity = 0.8d}; - UsersPrestrain = new StrainTuple(); - AutoPrestrain = new StrainTuple(); - ClearUnderlying = false; - Triangulate = true; } public RectanglePrimitive() : this(Guid.NewGuid()) { } - public RectanglePrimitive(IHeadMaterial material) : this() { HeadMaterial = material; } - public object Clone() { var primitive = new RectanglePrimitive(); diff --git a/StructureHelperLogics/NdmCalculations/Triangulations/CircleTriangulationLogicOptions.cs b/StructureHelperLogics/NdmCalculations/Triangulations/CircleTriangulationLogicOptions.cs index 6fe6c4f..a17f673 100644 --- a/StructureHelperLogics/NdmCalculations/Triangulations/CircleTriangulationLogicOptions.cs +++ b/StructureHelperLogics/NdmCalculations/Triangulations/CircleTriangulationLogicOptions.cs @@ -25,14 +25,15 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations public ITriangulationOptions triangulationOptions { get; set; } public IHeadMaterial HeadMaterial { get; set; } - public CircleTriangulationLogicOptions(ICirclePrimitive primitive) + public CircleTriangulationLogicOptions(IEllipsePrimitive primitive) { Center = primitive.Center.Clone() as Point2D; - Circle = primitive; - NdmMaxSize = primitive.NdmMaxSize; - NdmMinDivision = primitive.NdmMinDivision; - HeadMaterial = primitive.HeadMaterial; - Prestrain = ForceTupleService.SumTuples(primitive.UsersPrestrain, primitive.AutoPrestrain) as StrainTuple; + //to do change to ellipse + Circle = new CircleShape() { Diameter = primitive.DiameterByX }; + NdmMaxSize = primitive.DivisionSize.NdmMaxSize; + NdmMinDivision = primitive.DivisionSize.NdmMinDivision; + HeadMaterial = primitive.NdmElement.HeadMaterial; + Prestrain = ForceTupleService.SumTuples(primitive.NdmElement.UsersPrestrain, primitive.NdmElement.AutoPrestrain) as StrainTuple; } } } diff --git a/StructureHelperLogics/NdmCalculations/Triangulations/PointTriangulationLogicOptions.cs b/StructureHelperLogics/NdmCalculations/Triangulations/PointTriangulationLogicOptions.cs index 15301af..ce723ca 100644 --- a/StructureHelperLogics/NdmCalculations/Triangulations/PointTriangulationLogicOptions.cs +++ b/StructureHelperLogics/NdmCalculations/Triangulations/PointTriangulationLogicOptions.cs @@ -28,8 +28,8 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations { Center = primitive.Center.Clone() as Point2D; Area = primitive.Area; - HeadMaterial = primitive.HeadMaterial; - Prestrain = ForceTupleService.SumTuples(primitive.UsersPrestrain, primitive.AutoPrestrain) as StrainTuple; + HeadMaterial = primitive.NdmElement.HeadMaterial; + Prestrain = ForceTupleService.SumTuples(primitive.NdmElement.UsersPrestrain, primitive.NdmElement.AutoPrestrain) as StrainTuple; } } } diff --git a/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs b/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs index 37fa73a..2ca659b 100644 --- a/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs +++ b/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogic.cs @@ -55,11 +55,12 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations { var hostPrimitive = options.HostPrimitive; var material = hostPrimitive + .NdmElement .HeadMaterial .GetLoaderMaterial(options.triangulationOptions.LimiteState, options.triangulationOptions.CalcTerm); - var prestrain = ForceTupleService.SumTuples(hostPrimitive.UsersPrestrain, - hostPrimitive.AutoPrestrain) + var prestrain = ForceTupleService.SumTuples(hostPrimitive.NdmElement.UsersPrestrain, + hostPrimitive.NdmElement.AutoPrestrain) as StrainTuple; var concreteNdm = new Ndm diff --git a/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogicOptions.cs b/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogicOptions.cs index 685b7b0..93d728f 100644 --- a/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogicOptions.cs +++ b/StructureHelperLogics/NdmCalculations/Triangulations/RebarTriangulationLogicOptions.cs @@ -30,9 +30,9 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations { Center = primitive.Center.Clone() as Point2D; Area = primitive.Area; - HeadMaterial = primitive.HeadMaterial; + HeadMaterial = primitive.NdmElement.HeadMaterial; HostPrimitive = primitive.HostPrimitive; - Prestrain = ForceTupleService.SumTuples(primitive.UsersPrestrain, primitive.AutoPrestrain) as StrainTuple; + Prestrain = ForceTupleService.SumTuples(primitive.NdmElement.UsersPrestrain, primitive.NdmElement.AutoPrestrain) as StrainTuple; } } } diff --git a/StructureHelperLogics/NdmCalculations/Triangulations/RectangleTriangulationLogicOptions.cs b/StructureHelperLogics/NdmCalculations/Triangulations/RectangleTriangulationLogicOptions.cs index 7d67513..8c51c73 100644 --- a/StructureHelperLogics/NdmCalculations/Triangulations/RectangleTriangulationLogicOptions.cs +++ b/StructureHelperLogics/NdmCalculations/Triangulations/RectangleTriangulationLogicOptions.cs @@ -35,10 +35,10 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations { Center = new Point2D() {X = primitive.Center.X, Y = primitive.Center.Y }; Rectangle = primitive; - NdmMaxSize = primitive.NdmMaxSize; - NdmMinDivision = primitive.NdmMinDivision; - HeadMaterial = primitive.HeadMaterial; - Prestrain = ForceTupleService.SumTuples(primitive.UsersPrestrain, primitive.AutoPrestrain) as StrainTuple; + NdmMaxSize = primitive.DivisionSize.NdmMaxSize; + NdmMinDivision = primitive.DivisionSize.NdmMinDivision; + HeadMaterial = primitive.NdmElement.HeadMaterial; + Prestrain = ForceTupleService.SumTuples(primitive.NdmElement.UsersPrestrain, primitive.NdmElement.AutoPrestrain) as StrainTuple; } } } diff --git a/StructureHelperLogics/NdmCalculations/Triangulations/Triangulation.cs b/StructureHelperLogics/NdmCalculations/Triangulations/Triangulation.cs index be3cab4..e33f1d8 100644 --- a/StructureHelperLogics/NdmCalculations/Triangulations/Triangulation.cs +++ b/StructureHelperLogics/NdmCalculations/Triangulations/Triangulation.cs @@ -32,7 +32,7 @@ namespace StructureHelperLogics.NdmCalculations.Triangulations Dictionary headMaterials = new Dictionary(); foreach (var ndmPrimitive in ndmPrimitives) { - IHeadMaterial material = ndmPrimitive.HeadMaterial; + IHeadMaterial material = ndmPrimitive.NdmElement.HeadMaterial; if (!headMaterials.ContainsKey(material.Id)) { headMaterials.Add(material.Id, material); } } return headMaterials; diff --git a/StructureHelperLogics/Services/NdmPrimitives/CheckPrimitivesForMeshingLogic.cs b/StructureHelperLogics/Services/NdmPrimitives/CheckPrimitivesForMeshingLogic.cs index b1901da..92c9087 100644 --- a/StructureHelperLogics/Services/NdmPrimitives/CheckPrimitivesForMeshingLogic.cs +++ b/StructureHelperLogics/Services/NdmPrimitives/CheckPrimitivesForMeshingLogic.cs @@ -25,7 +25,9 @@ namespace StructureHelperLogics.Services.NdmPrimitives TraceLogger?.AddMessage(errorMessage, TraceLogStatuses.Error); throw new StructureHelperException(errorMessage); } - if (!Primitives.Any(x => x.Triangulate == true)) + if (!Primitives.Any(x => x + .NdmElement + .Triangulate == true)) { string errorMessage = string.Intern(ErrorStrings.DataIsInCorrect + $": There are not primitives to triangulate"); TraceLogger?.AddMessage(errorMessage, TraceLogStatuses.Error); @@ -33,8 +35,8 @@ namespace StructureHelperLogics.Services.NdmPrimitives } foreach (var item in Primitives) { - if (item.Triangulate == true & - item.HeadMaterial is null) + if (item.NdmElement.Triangulate == true & + item.NdmElement.HeadMaterial is null) { string errorMessage = string.Intern(ErrorStrings.DataIsInCorrect + $": Primitive: {item.Name} can't be triangulated since material is null"); TraceLogger?.AddMessage(errorMessage, TraceLogStatuses.Error); diff --git a/StructureHelperLogics/Services/NdmPrimitives/IMeshHasDivisionLogic.cs b/StructureHelperLogics/Services/NdmPrimitives/IMeshHasDivisionLogic.cs index e8094a7..11dc61a 100644 --- a/StructureHelperLogics/Services/NdmPrimitives/IMeshHasDivisionLogic.cs +++ b/StructureHelperLogics/Services/NdmPrimitives/IMeshHasDivisionLogic.cs @@ -9,10 +9,22 @@ using System.Threading.Tasks; namespace StructureHelperLogics.Services.NdmPrimitives { + /// + /// Implement logic of triangulation of primitives which have parameters of division + /// public interface IMeshHasDivisionLogic : ILogic { - List NdmCollection { get; set; } - IHasDivisionSize Primitive { get; set; } + /// + /// Input collection of existing ndm parts + /// + List? NdmCollection { get; set; } + /// + /// Input triangulated primitive + /// + IHasDivisionSize? Primitive { get; set; } + /// + /// Run process of triangulation + /// void MeshHasDivision(); } } diff --git a/StructureHelperLogics/Services/NdmPrimitives/MeshCrackedConcreteLogic.cs b/StructureHelperLogics/Services/NdmPrimitives/MeshCrackedConcreteLogic.cs index 8a54a4e..456e04d 100644 --- a/StructureHelperLogics/Services/NdmPrimitives/MeshCrackedConcreteLogic.cs +++ b/StructureHelperLogics/Services/NdmPrimitives/MeshCrackedConcreteLogic.cs @@ -30,7 +30,7 @@ namespace StructureHelperLogics.Services.NdmPrimitives TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); CheckPrimitive(); List ndmCollection = new(); - if (Primitive.HeadMaterial.HelperMaterial is ICrackedMaterial) + if (Primitive.NdmElement.HeadMaterial.HelperMaterial is ICrackedMaterial) { ProcessICracked(ndmCollection); } @@ -74,13 +74,13 @@ namespace StructureHelperLogics.Services.NdmPrimitives private void SetNewMaterial(INdmPrimitive? newPrimititve) { - TraceLogger?.AddMessage($"Process material {newPrimititve.HeadMaterial.Name} has started"); - var newHeadMaterial = newPrimititve.HeadMaterial.Clone() as IHeadMaterial; + TraceLogger?.AddMessage($"Process material {newPrimititve.NdmElement.HeadMaterial.Name} has started"); + var newHeadMaterial = newPrimititve.NdmElement.HeadMaterial.Clone() as IHeadMaterial; var newMaterial = newHeadMaterial.HelperMaterial.Clone() as ICrackedMaterial; - TraceLogger?.AddMessage($"Set work in tension zone for material {newPrimititve.HeadMaterial.Name}"); + TraceLogger?.AddMessage($"Set work in tension zone for material {newPrimititve.NdmElement.HeadMaterial.Name}"); newMaterial.TensionForSLS = false; newHeadMaterial.HelperMaterial = newMaterial as IHelperMaterial; - newPrimititve.HeadMaterial = newHeadMaterial; + newPrimititve.NdmElement.HeadMaterial = newHeadMaterial; } private List GetNdms(INdmPrimitive primitive) diff --git a/StructureHelperLogics/Services/NdmPrimitives/MeshHasDivisionLogic.cs b/StructureHelperLogics/Services/NdmPrimitives/MeshHasDivisionLogic.cs index c2d9bf0..d465670 100644 --- a/StructureHelperLogics/Services/NdmPrimitives/MeshHasDivisionLogic.cs +++ b/StructureHelperLogics/Services/NdmPrimitives/MeshHasDivisionLogic.cs @@ -1,4 +1,6 @@ using LoaderCalculator.Data.Ndms; +using StructureHelperCommon.Infrastructures.Exceptions; +using StructureHelperCommon.Infrastructures.Interfaces; using StructureHelperCommon.Models; using StructureHelperCommon.Models.Loggers; using StructureHelperCommon.Models.Shapes; @@ -12,30 +14,55 @@ using System.Threading.Tasks; namespace StructureHelperLogics.Services.NdmPrimitives { + /// public class MeshHasDivisionLogic : IMeshHasDivisionLogic { - public List NdmCollection { get; set; } - public IHasDivisionSize Primitive { get; set; } + /// + public List? NdmCollection { get; set; } + /// + public IHasDivisionSize? Primitive { get; set; } + /// public IShiftTraceLogger? TraceLogger { get; set; } public void MeshHasDivision() { TraceLogger?.AddMessage(LoggerStrings.CalculatorType(this), TraceLogStatuses.Service); + CheckInputData(); if (Primitive is IHasDivisionSize hasDivision) { - if (hasDivision.ClearUnderlying == true) + if (hasDivision.DivisionSize.ClearUnderlying == true) { TraceLogger?.AddMessage("Removing of background part has started", TraceLogStatuses.Service); - NdmCollection - .RemoveAll(x => - hasDivision - .IsPointInside(new Point2D() - { - X = x.CenterX, - Y = x.CenterY - }) == true); + NdmCollection.RemoveAll(x => IsCenterInside(x, hasDivision) == true); } } } + + private static bool IsCenterInside(INdm x, IHasDivisionSize hasDivision) + { + Point2D point = new Point2D() + { + X = x.CenterX, + Y = x.CenterY + }; + return hasDivision.IsPointInside(point); + } + + private void CheckInputData() + { + if (NdmCollection is null) + { + var message = ErrorStrings.ParameterIsNull + ": input NdmCollection"; + TraceLogger?.AddMessage(message, TraceLogStatuses.Error); + throw new StructureHelperException(message); + } + if (Primitive is null) + { + var message = ErrorStrings.ParameterIsNull + ": input Primitive"; + TraceLogger?.AddMessage(message, TraceLogStatuses.Error); + throw new StructureHelperException(message); + } + + } } } diff --git a/StructureHelperLogics/Services/NdmPrimitives/TriangulatePrimitiveLogic.cs b/StructureHelperLogics/Services/NdmPrimitives/TriangulatePrimitiveLogic.cs index 4b24777..6c2314e 100644 --- a/StructureHelperLogics/Services/NdmPrimitives/TriangulatePrimitiveLogic.cs +++ b/StructureHelperLogics/Services/NdmPrimitives/TriangulatePrimitiveLogic.cs @@ -87,7 +87,7 @@ namespace StructureHelperLogics.Services.NdmPrimitives divisionLogic.Primitive = hasDivision; divisionLogic.MeshHasDivision(); } - if (primitive.Triangulate == true) + if (primitive.NdmElement.Triangulate == true) { meshLogic.Primitive = primitive; var ndms = meshLogic.MeshPrimitive(); diff --git a/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs b/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs index e0c7b38..c996aa1 100644 --- a/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs +++ b/StructureHelperTests/FunctionalTests/Ndms/Calculators/ForceCalculatorTests/RCSectionsTest.cs @@ -75,7 +75,7 @@ namespace StructureHelperTests.FunctionalTests.Ndms.Calculators.ForceCalculatorT //Act foreach (var item in ndmPrimitives) { - ForceTupleService.CopyProperties(source, item.AutoPrestrain); + ForceTupleService.CopyProperties(source, item.NdmElement.AutoPrestrain); } calculator.Run(); var result2 = calculator.Result as IForcesResults; diff --git a/StructureHelperTests/UnitTests/Ndms/CheckRebarPrimitiveLogicTests.cs b/StructureHelperTests/UnitTests/Ndms/CheckRebarPrimitiveLogicTests.cs index a01e6c2..d82a5d1 100644 --- a/StructureHelperTests/UnitTests/Ndms/CheckRebarPrimitiveLogicTests.cs +++ b/StructureHelperTests/UnitTests/Ndms/CheckRebarPrimitiveLogicTests.cs @@ -77,7 +77,7 @@ namespace StructureHelperTests.UnitTests.Ndms _mockRebarPrimitive.Setup(x => x.HostPrimitive).Returns(mockHostPrimitive.Object); _mockRebarPrimitive.Setup(x => x.Name).Returns("RebarName"); - mockHostPrimitive.Setup(x => x.HeadMaterial).Returns(mockHeadMaterial.Object); + mockHostPrimitive.Setup(x => x.NdmElement.HeadMaterial).Returns(mockHeadMaterial.Object); mockHeadMaterial.Setup(x => x.HelperMaterial).Returns(mockHelperMaterial.Object); // Act diff --git a/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckTupleCalculatorInputDataTests.cs b/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckTupleCalculatorInputDataTests.cs index 6f716e9..d129e31 100644 --- a/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckTupleCalculatorInputDataTests.cs +++ b/StructureHelperTests/UnitTests/Ndms/Cracks/InputDataTests/CheckTupleCalculatorInputDataTests.cs @@ -56,7 +56,7 @@ public class CheckTupleCalculatorInputDataTests // Arrange _checkTupleCalculatorInputData.InputData = new TupleCrackInputData { - Primitives = new List { new CirclePrimitive() }, // Assuming at least one valid primitive + Primitives = new List { new EllipsePrimitive() }, // Assuming at least one valid primitive UserCrackInputData = null }; @@ -74,7 +74,7 @@ public class CheckTupleCalculatorInputDataTests // Arrange _checkTupleCalculatorInputData.InputData = new TupleCrackInputData { - Primitives = new List { new CirclePrimitive() }, // Assuming at least one valid primitive + Primitives = new List { new EllipsePrimitive() }, // Assuming at least one valid primitive UserCrackInputData = new UserCrackInputData() // Assuming this is valid }; diff --git a/StructureHelperTests/UnitTests/Ndms/Triangulations/RectangleTriangulationTest.cs b/StructureHelperTests/UnitTests/Ndms/Triangulations/RectangleTriangulationTest.cs index fd12e6c..ef73b4e 100644 --- a/StructureHelperTests/UnitTests/Ndms/Triangulations/RectangleTriangulationTest.cs +++ b/StructureHelperTests/UnitTests/Ndms/Triangulations/RectangleTriangulationTest.cs @@ -66,14 +66,23 @@ namespace StructureHelperTests.UnitTests.Ndms.Triangulations //Arrange ProgramSetting.NatSystem = NatSystems.RU; var material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Concrete40); - var mainBlock = new RectanglePrimitive() { Width = width, Height = height, HeadMaterial = material }; + var mainBlock = new RectanglePrimitive() + { + Width = width, + Height = height, + }; + mainBlock.NdmElement.HeadMaterial = material; mainBlock.Center.X = centerX; mainBlock.Center.Y = centerY; mainBlock.VisualProperty.ZIndex = 0; var opening = new RectanglePrimitive() - { Width = 0.3d, Height = 0.2d, - HeadMaterial = material, Triangulate = triangOpening, - ClearUnderlying = true}; + { + Width = 0.3d, + Height = 0.2d + }; + opening.DivisionSize.ClearUnderlying = true; + opening.NdmElement.HeadMaterial = material; + opening.NdmElement.Triangulate = triangOpening; opening.VisualProperty.ZIndex = 1; var primitives = new List() { mainBlock, opening }; //Act @@ -100,19 +109,28 @@ namespace StructureHelperTests.UnitTests.Ndms.Triangulations //Arrange ProgramSetting.NatSystem = NatSystems.RU; var material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Concrete40); - var mainBlock = new RectanglePrimitive() {Width = width, Height = height, HeadMaterial = material }; + var mainBlock = new RectanglePrimitive() + { + Width = width, + Height = height + }; + mainBlock.NdmElement.HeadMaterial = material; mainBlock.Center.X = centerX; mainBlock.Center.Y = centerY; mainBlock.VisualProperty.ZIndex = 0; - var opening = new CirclePrimitive() + var opening = new EllipsePrimitive() { - Diameter = 0.3d, - HeadMaterial = material, - Triangulate = triangOpening, - ClearUnderlying = true + DiameterByX = 0.3d }; + opening.DivisionSize.ClearUnderlying = true; + opening.NdmElement.HeadMaterial = material; + opening.NdmElement.Triangulate = triangOpening; opening.VisualProperty.ZIndex = 1; - var primitives = new List() { mainBlock, opening }; + var primitives = new List() + { + mainBlock, + opening + }; //Act triangulateLogic = new TriangulatePrimitiveLogic() { @@ -137,18 +155,19 @@ namespace StructureHelperTests.UnitTests.Ndms.Triangulations //Arrange ProgramSetting.NatSystem = NatSystems.RU; var material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Concrete40); - var mainBlock = new CirclePrimitive() { Diameter = diameter, HeadMaterial = material }; + var mainBlock = new EllipsePrimitive() { DiameterByX = diameter}; + mainBlock.NdmElement.HeadMaterial = material; mainBlock.Center.X = centerX; mainBlock.Center.Y = centerY; mainBlock.VisualProperty.ZIndex = 0; var opening = new RectanglePrimitive() { Width = 0.3d, - Height = 0.2d, - HeadMaterial = material, - Triangulate = triangOpening, - ClearUnderlying = true + Height = 0.2d }; + opening.DivisionSize.ClearUnderlying = true; + opening.NdmElement.HeadMaterial = material; + opening.NdmElement.Triangulate = triangOpening; opening.VisualProperty.ZIndex = 1; var primitives = new List() { mainBlock, opening }; //Act diff --git a/StructureHelperTests/ViewModelTests/NdmPrimitiveTests.cs b/StructureHelperTests/ViewModelTests/NdmPrimitiveTests.cs index e2f5277..af3a561 100644 --- a/StructureHelperTests/ViewModelTests/NdmPrimitiveTests.cs +++ b/StructureHelperTests/ViewModelTests/NdmPrimitiveTests.cs @@ -26,7 +26,8 @@ namespace StructureHelperTests.ViewModelTests { //Arrange var material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Concrete40); - var primitive = new RectanglePrimitive(material); + var primitive = new RectanglePrimitive(); + primitive.NdmElement.HeadMaterial = material; var primitiveBase = new RectangleViewPrimitive(primitive); //Act var vm = new PrimitivePropertiesViewModel(primitiveBase, new CrossSectionRepository()); @@ -39,7 +40,8 @@ namespace StructureHelperTests.ViewModelTests //Arrange ProgramSetting.NatSystem = NatSystems.RU; var material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Concrete40); - var primitive = new CirclePrimitive() { HeadMaterial = material}; + var primitive = new EllipsePrimitive(); + primitive.NdmElement.HeadMaterial = material; var primitiveBase = new CircleViewPrimitive(primitive); //Act var vm = new PrimitivePropertiesViewModel(primitiveBase, new CrossSectionRepository()); @@ -53,7 +55,8 @@ namespace StructureHelperTests.ViewModelTests //Arrange ProgramSetting.NatSystem = NatSystems.RU; var material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Concrete40); - var primitive = new PointPrimitive(material); + var primitive = new PointPrimitive(); + primitive.NdmElement.HeadMaterial = material; var primitiveBase = new PointViewPrimitive(primitive); //Act var vm = new PrimitivePropertiesViewModel(primitiveBase, new CrossSectionRepository()); @@ -66,7 +69,8 @@ namespace StructureHelperTests.ViewModelTests //Arrange ProgramSetting.NatSystem = NatSystems.RU; var material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Concrete40); - var primitive = new RebarPrimitive() { HeadMaterial = material }; + var primitive = new RebarPrimitive(); + primitive.NdmElement.HeadMaterial = material; var primitiveBase = new ReinforcementViewPrimitive(primitive); //Act var vm = new PrimitivePropertiesViewModel(primitiveBase, new CrossSectionRepository());