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

Add value diagram calculator saving

Browse Source
This commit is contained in:
Evgeny Redikultsev
2025-11-16 13:56:09 +05:00
parent 43f46b83af
commit f7e60e0bb3
30 changed files with 786 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
DataAccess/DTOs/Converters/CalculatorToDTOConvertStrategy.cs
View File

@@ -4,12 +4,8 @@ using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Loggers;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
using StructureHelperLogics.NdmCalculations.Cracking;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DataAccess.DTOs
{
@@ -65,11 +61,26 @@ namespace DataAccess.DTOs
{
TraceLogger?.AddMessage($"Current version of StructureHelper does not suppurt saving interaction diagram calculator, {limitCalculator.Name} was ignored");
}
if (source is IValueDiagramCalculator valueDiagramCalculator)
{
return ProcessValueDiagramCalcualtor(valueDiagramCalculator);
}
string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source);
TraceLogger?.AddMessage(errorString, TraceLogStatuses.Error);
throw new StructureHelperException(errorString);
}
private ValueDiagramCalculatorDTO ProcessValueDiagramCalcualtor(IValueDiagramCalculator valueDiagramCalculator)
{
var convertStrategy = new ValueDiagramCalculatorToDTOConvertStrategy()
{
ReferenceDictionary = ReferenceDictionary,
TraceLogger = TraceLogger
};
var dictionaryConvertStrategy = new DictionaryConvertStrategy<ValueDiagramCalculatorDTO, IValueDiagramCalculator>(this, convertStrategy);
return convertStrategy.Convert(valueDiagramCalculator);
}
private CrackCalculatorDTO ProcessCrackCalculator(ICrackCalculator crackCalculator)
{
crackCalculatorStrategy.ReferenceDictionary = ReferenceDictionary;

16
DataAccess/DTOs/Converters/CalculatorsFromDTOConvertStrategy.cs
View File

@@ -3,6 +3,7 @@ using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
using StructureHelperLogics.NdmCalculations.Cracking;
using System;
using System.Collections.Generic;
@@ -39,11 +40,26 @@ namespace DataAccess.DTOs
ICrackCalculator calculator = GetCrackCalculator(crackCalculator);
return calculator;
}
if (source is ValueDiagramCalculatorDTO valueDiagramCalculator)
{
TraceLogger?.AddMessage($"{CalculatorIs} value digram calculator");
return GetValueDiagramCalculator(valueDiagramCalculator);
}
string errorString = ErrorStrings.ObjectTypeIsUnknownObj(source);
TraceLogger.AddMessage(errorString, TraceLogStatuses.Error);
throw new StructureHelperException(errorString);
}
private ValueDiagramCalculator GetValueDiagramCalculator(ValueDiagramCalculatorDTO valueDiagramCalculator)
{
var convertStrategy = new ValueDiagramCalcualtorFromDTOConvertStrategy()
{
ReferenceDictionary = ReferenceDictionary,
TraceLogger = TraceLogger,
};
return convertStrategy.Convert(valueDiagramCalculator);
}
private ICrackCalculator GetCrackCalculator(ICrackCalculator crackCalculator)
{
crackConvertStrategy.ReferenceDictionary = ReferenceDictionary;

47
DataAccess/DTOs/Converters/Shapes/Point2DRangeFromDTOConvertStrategy.cs Normal file
View File

@@ -0,0 +1,47 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Shapes;
using StructureHelperCommon.Services;
namespace DataAccess.DTOs
{
public class Point2DRangeFromDTOConvertStrategy : ConvertStrategy<Point2DRange, Point2DRangeDTO>
{
private IConvertStrategy<Point2D, Point2DDTO> pointConvertStrategy;
public Point2DRangeFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
}
public override Point2DRange GetNewItem(Point2DRangeDTO source)
{
ChildClass = this;
CheckSourceObject(source);
NewItem = new(source.Id);
InitializeStrategies();
if (source.StartPoint is not Point2DDTO startPoint)
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.StartPoint) + ": start point");
}
if (source.EndPoint is not Point2DDTO endPoint)
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.StartPoint) + ": end point");
}
NewItem.StartPoint = pointConvertStrategy.Convert(startPoint);
NewItem.EndPoint = pointConvertStrategy.Convert(endPoint);
return NewItem;
}
private static void CheckSourceObject(Point2DRangeDTO source)
{
CheckObject.IsNull(source, ": point range source object");
CheckObject.IsNull(source.StartPoint + ": point range start point");
CheckObject.IsNull(source.EndPoint + ": point range end point");
}
private void InitializeStrategies()
{
pointConvertStrategy ??= new Point2DFromDTOConvertStrategy(this);
}
}
}

25
DataAccess/DTOs/Converters/Shapes/Point2DRangeToDTOConvertStrategy.cs Normal file
View File

@@ -0,0 +1,25 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Shapes;
namespace DataAccess.DTOs
{
public class Point2DRangeToDTOConvertStrategy : ConvertStrategy<Point2DRangeDTO, IPoint2DRange>
{
private IConvertStrategy<Point2DDTO, IPoint2D> pointConvertStrategy = new Point2DToDTOConvertStrategy();
public Point2DRangeToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
}
public override Point2DRangeDTO GetNewItem(IPoint2DRange source)
{
ChildClass = this;
NewItem = new(source.Id)
{
StartPoint = pointConvertStrategy.Convert(source.StartPoint),
EndPoint = pointConvertStrategy.Convert(source.EndPoint)
};
return NewItem;
}
}
}

30
DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalcualtorFromDTOConvertStrategy.cs Normal file
View File

@@ -0,0 +1,30 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
using System;
using System.Collections.Generic;
using System.Text;
namespace DataAccess.DTOs
{
public class ValueDiagramCalcualtorFromDTOConvertStrategy : ConvertStrategy<ValueDiagramCalculator, ValueDiagramCalculatorDTO>
{
private IUpdateStrategy<IValueDiagramCalculator> updateStrategy;
private IConvertStrategy<ValueDiagramCalculatorInputData, ValueDiagramCalculatorInputDataDTO> inputDataConvertStrategy;
public override ValueDiagramCalculator GetNewItem(ValueDiagramCalculatorDTO source)
{
ChildClass = this;
NewItem = new(source.Id);
InitializeStrategies();
updateStrategy.Update(NewItem, source);
NewItem.InputData = inputDataConvertStrategy.Convert(source.InputData as ValueDiagramCalculatorInputDataDTO);
return NewItem;
}
private void InitializeStrategies()
{
updateStrategy ??= new ValueDiagramCalculatorUpdateStrategy() { UpdateChildren = false };
inputDataConvertStrategy ??= new ValueDiagramCalculatorInputDataFromDTOConvertStrategy(this);
}
}
}

68
DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalculatorInputDataFromDTOConvertStrategy.cs Normal file
View File

@@ -0,0 +1,68 @@
using DataAccess.DTOs.Converters;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Calculators;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace DataAccess.DTOs
{
public class ValueDiagramCalculatorInputDataFromDTOConvertStrategy : ConvertStrategy<ValueDiagramCalculatorInputData, ValueDiagramCalculatorInputDataDTO>
{
private IUpdateStrategy<IValueDiagramCalculatorInputData> updateStrategy;
private IConvertStrategy<ValueDiagramEntity, ValueDiagramEntityDTO> diagramConvertStrategy;
private IHasPrimitivesProcessLogic primitivesProcessLogic;
private IHasForceActionsProcessLogic actionsProcessLogic;
private IConvertStrategy<Accuracy, AccuracyDTO> accuracyConvertStrategy;
public ValueDiagramCalculatorInputDataFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
}
public override ValueDiagramCalculatorInputData GetNewItem(ValueDiagramCalculatorInputDataDTO source)
{
ChildClass = this;
NewItem = new(source.Id);
InitializeStrategies();
updateStrategy.Update(NewItem, source);
ProcessPrimitives(source);
ProcessActions(source);
NewItem.Digrams.Clear();
foreach (var diagram in source.Digrams)
{
if (diagram is not ValueDiagramEntityDTO diagramDTO)
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(diagram));
}
NewItem.Digrams.Add(diagramConvertStrategy.Convert(diagramDTO));
}
return NewItem;
}
private void ProcessPrimitives(IHasPrimitives source)
{
primitivesProcessLogic.Source = source;
primitivesProcessLogic.Target = NewItem;
primitivesProcessLogic.ReferenceDictionary = ReferenceDictionary;
primitivesProcessLogic.TraceLogger = TraceLogger;
primitivesProcessLogic.Process();
}
private void ProcessActions(IHasForceActions source)
{
actionsProcessLogic.Source = source;
actionsProcessLogic.Target = NewItem;
actionsProcessLogic.ReferenceDictionary = ReferenceDictionary;
actionsProcessLogic.TraceLogger = TraceLogger;
actionsProcessLogic.Process();
}
private void InitializeStrategies()
{
updateStrategy ??= new ValueDiagramCalculatorInputDataUpdateStrategy() { UpdateChildren = false };
diagramConvertStrategy ??= new ValueDiagramEntityFromDTOConvertStrategy(this);
primitivesProcessLogic ??= new HasPrimitivesProcessLogic(ConvertDirection.FromDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
actionsProcessLogic ??= new HasForceActionsProcessLogic(ConvertDirection.FromDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
accuracyConvertStrategy ??= new AccuracyFromDTOConvertStrategy() { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
}
}
}

64
DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalculatorInputDataToDTOConvertStrategy.cs Normal file
View File

@@ -0,0 +1,64 @@
using DataAccess.DTOs.Converters;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace DataAccess.DTOs
{
public class ValueDiagramCalculatorInputDataToDTOConvertStrategy : ConvertStrategy<ValueDiagramCalculatorInputDataDTO, IValueDiagramCalculatorInputData>
{
private IUpdateStrategy<IValueDiagramCalculatorInputData> updateStrategy;
private IConvertStrategy<ValueDiagramEntityDTO, IValueDiagramEntity> diagramConvertStrategy;
private IHasPrimitivesProcessLogic primitivesProcessLogic;
private IHasForceActionsProcessLogic actionsProcessLogic;
public ValueDiagramCalculatorInputDataToDTOConvertStrategy() : base()
{
}
public ValueDiagramCalculatorInputDataToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
}
public override ValueDiagramCalculatorInputDataDTO GetNewItem(IValueDiagramCalculatorInputData source)
{
ChildClass = this;
NewItem = new(source.Id);
InitializeStrategies();
updateStrategy.Update(NewItem, source);
ProcessPrimitives(source);
ProcessActions(source);
NewItem.Digrams.Clear();
foreach (var diagram in source.Digrams)
{
NewItem.Digrams.Add(diagramConvertStrategy.Convert(diagram));
}
return NewItem;
}
private void ProcessPrimitives(IHasPrimitives source)
{
primitivesProcessLogic.Source = source;
primitivesProcessLogic.Target = NewItem;
primitivesProcessLogic.ReferenceDictionary = ReferenceDictionary;
primitivesProcessLogic.TraceLogger = TraceLogger;
primitivesProcessLogic.Process();
}
private void ProcessActions(IHasForceActions source)
{
actionsProcessLogic.Source = source;
actionsProcessLogic.Target = NewItem;
actionsProcessLogic.ReferenceDictionary = ReferenceDictionary;
actionsProcessLogic.TraceLogger = TraceLogger;
actionsProcessLogic.Process();
}
private void InitializeStrategies()
{
updateStrategy ??= new ValueDiagramCalculatorInputDataUpdateStrategy() { UpdateChildren = false};
diagramConvertStrategy ??= new ValueDiagramEntityToDTOConvertStrategy(this);
primitivesProcessLogic ??= new HasPrimitivesProcessLogic(ConvertDirection.ToDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
actionsProcessLogic ??= new HasForceActionsProcessLogic(ConvertDirection.ToDTO) { ReferenceDictionary = ReferenceDictionary, TraceLogger = TraceLogger };
}
}
}

31
DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalculatorToDTOConvertStrategy.cs Normal file
View File

@@ -0,0 +1,31 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
namespace DataAccess.DTOs
{
internal class ValueDiagramCalculatorToDTOConvertStrategy : ConvertStrategy<ValueDiagramCalculatorDTO, IValueDiagramCalculator>
{
private IUpdateStrategy<IValueDiagramCalculator> updateStrategy;
private IConvertStrategy<ValueDiagramCalculatorInputDataDTO, IValueDiagramCalculatorInputData> inputDataConvertStrategy;
public override ValueDiagramCalculatorDTO GetNewItem(IValueDiagramCalculator source)
{
ChildClass = this;
NewItem = new(source.Id);
InitializeStrategies();
updateStrategy.Update(NewItem, source);
NewItem.InputData = inputDataConvertStrategy.Convert(source.InputData);
return NewItem;
}
private void InitializeStrategies()
{
updateStrategy ??= new ValueDiagramCalculatorUpdateStrategy()
{
UpdateChildren = false
};
inputDataConvertStrategy ??= new DictionaryConvertStrategy<ValueDiagramCalculatorInputDataDTO, IValueDiagramCalculatorInputData>(
this,
new ValueDiagramCalculatorInputDataToDTOConvertStrategy(this));
}
}
}

36
DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramEntityFromDTOConvertStrategy.cs Normal file
View File

@@ -0,0 +1,36 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
namespace DataAccess.DTOs
{
public class ValueDiagramEntityFromDTOConvertStrategy : ConvertStrategy<ValueDiagramEntity, ValueDiagramEntityDTO>
{
private IUpdateStrategy<IValueDiagramEntity> updateStrategy;
private IConvertStrategy<ValueDiagram, ValueDiagramDTO> diagramConvertStrategy;
public ValueDiagramEntityFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
}
public override ValueDiagramEntity GetNewItem(ValueDiagramEntityDTO source)
{
ChildClass = this;
NewItem = new(source.Id);
InitializeStrategies();
updateStrategy.Update(NewItem, source);
if (source.ValueDigram is not ValueDiagramDTO diagramDTO)
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.ValueDigram));
}
NewItem.ValueDigram = diagramConvertStrategy.Convert(diagramDTO);
return NewItem;
}
private void InitializeStrategies()
{
updateStrategy ??= new ValueDiagramEntityUpdateStrategy() { UpdateChildren = false};
diagramConvertStrategy ??= new ValueDiagramFromDTOConvertStrategy(this);
}
}
}

31
DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramEntityToDTOConvertStrategy.cs Normal file
View File

@@ -0,0 +1,31 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
namespace DataAccess.DTOs
{
public class ValueDiagramEntityToDTOConvertStrategy : ConvertStrategy<ValueDiagramEntityDTO, IValueDiagramEntity>
{
private IUpdateStrategy<IValueDiagramEntity> updateStrategy;
private IConvertStrategy<ValueDiagramDTO, IValueDiagram> diagramConvertStrategy;
public ValueDiagramEntityToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
}
public override ValueDiagramEntityDTO GetNewItem(IValueDiagramEntity source)
{
ChildClass = this;
NewItem = new(source.Id);
InitializeStrategies();
updateStrategy.Update(NewItem, source);
NewItem.ValueDigram = diagramConvertStrategy.Convert(source.ValueDigram);
return NewItem;
}
private void InitializeStrategies()
{
updateStrategy ??= new ValueDiagramEntityUpdateStrategy() { UpdateChildren = false };
diagramConvertStrategy ??= new ValueDiagramToDTOConvertStrategy(this);
}
}
}

37
DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramFromDTOConvertStrategy.cs Normal file
View File

@@ -0,0 +1,37 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Shapes;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
namespace DataAccess.DTOs
{
public class ValueDiagramFromDTOConvertStrategy : ConvertStrategy<ValueDiagram, ValueDiagramDTO>
{
private IUpdateStrategy<IValueDiagram> updateStrategy;
private IConvertStrategy<Point2DRange, Point2DRangeDTO> pointConvertStrategy;
public ValueDiagramFromDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
}
public override ValueDiagram GetNewItem(ValueDiagramDTO source)
{
ChildClass = this;
NewItem = new(source.Id);
InitializeStrategies();
updateStrategy.Update(NewItem, source);
if (source.Point2DRange is not Point2DRangeDTO point2DRangeDTO)
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.Point2DRange));
}
NewItem.Point2DRange = pointConvertStrategy.Convert(point2DRangeDTO);
return NewItem;
}
private void InitializeStrategies()
{
updateStrategy ??= new ValueDiagramUpdateStrategy() { UpdateChildren = false };
pointConvertStrategy ??= new Point2DRangeFromDTOConvertStrategy(this);
}
}
}

32
DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramToDTOConvertStrategy.cs Normal file
View File

@@ -0,0 +1,32 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Shapes;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
namespace DataAccess.DTOs
{
public class ValueDiagramToDTOConvertStrategy : ConvertStrategy<ValueDiagramDTO, IValueDiagram>
{
private IUpdateStrategy<IValueDiagram> updateStrategy;
private IConvertStrategy<Point2DRangeDTO, IPoint2DRange> pointConvertStrategy;
public ValueDiagramToDTOConvertStrategy(IBaseConvertStrategy baseConvertStrategy) : base(baseConvertStrategy)
{
}
public override ValueDiagramDTO GetNewItem(IValueDiagram source)
{
ChildClass = this;
NewItem = new(source.Id);
InitializeStrategies();
updateStrategy.Update(NewItem, source);
NewItem.Point2DRange = pointConvertStrategy.Convert(source.Point2DRange);
return NewItem;
}
private void InitializeStrategies()
{
updateStrategy ??= new ValueDiagramUpdateStrategy() { UpdateChildren = false };
pointConvertStrategy ??= new Point2DRangeToDTOConvertStrategy(this);
}
}
}

26
DataAccess/DTOs/DTOEntities/Shapes/Point2DRangeDTO.cs Normal file
View File

@@ -0,0 +1,26 @@
using Newtonsoft.Json;
using StructureHelperCommon.Models.Shapes;
namespace DataAccess.DTOs
{
public class Point2DRangeDTO : IPoint2DRange
{
[JsonProperty("Id")]
public Guid Id { get; }
[JsonProperty("StartPoint")]
public IPoint2D StartPoint { get; set; }
[JsonProperty("EndPoint")]
public IPoint2D EndPoint { get; set; }
public Point2DRangeDTO(Guid id)
{
Id = id;
}
public object Clone()
{
return this;
}
}
}

11
DataAccess/DTOs/DTOEntities/StateCalcTermPairDTO.cs Normal file
View File

@@ -0,0 +1,11 @@
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Models.States;
namespace DataAccess.DTOs
{
public class StateCalcTermPairDTO : IStateCalcTermPair
{
public LimitStates LimitState { get; set; }
public CalcTerms CalcTerm { get; set; }
}
}

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

@@ -7,6 +7,7 @@ using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.Materials.Libraries;
using StructureHelperCommon.Models.Shapes;
using StructureHelperLogics.Models.BeamShears;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace DataAccess.DTOs
@@ -45,6 +46,7 @@ namespace DataAccess.DTOs
{ (typeof(List<LimitStates>), "ListOfLimitState") },
{ (typeof(List<IPartialFactor>), "ListOfPartialFactor") },
{ (typeof(RebarSectionDTO), "RebarSection") },
{ (typeof(StateCalcTermPairDTO), "StateCalcTermPair") },
{ (typeof(VisualPropertyDTO), "VisualProperty") },
{ (typeof(WorkPlanePropertyDTO), "WorkPlanePropertyDTO") },
};
@@ -55,6 +57,20 @@ namespace DataAccess.DTOs
newList.AddRange(GetCalculatorList());
newList.AddRange(GetNdmPrimitiveList());
newList.AddRange(GetBeamShearList());
newList.AddRange(GetValueDiagramList());
return newList;
}
private static IEnumerable<(Type type, string name)> GetValueDiagramList()
{
List<(Type type, string name)> newList = new()
{
{ (typeof(List<IValueDiagramEntity>), "ListOfValueDiagramEntity") },
{ (typeof(ValueDiagramCalculatorDTO), "ValueDiagramCalculator") },
{ (typeof(ValueDiagramCalculatorInputDataDTO), "ValueDiagramCalculatorInputData") },
{ (typeof(ValueDiagramEntityDTO), "ValueDiagramEntity") },
{ (typeof(ValueDiagramDTO), "ValueDiagram") },
};
return newList;
}
@@ -131,6 +147,7 @@ namespace DataAccess.DTOs
{
{ (typeof(List<IVertex>), "ListOfVertex2D") },
{ (typeof(Point2DDTO), "Point2D") },
{ (typeof(Point2DRangeDTO), "Point2DRange") },
{ (typeof(VertexDTO), "Vertex2D") },
{ (typeof(RectangleShapeDTO), "RectangleShape") },
{ (typeof(CircleShapeDTO), "CircleShape") },

39
DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramCalculatorDTO.cs Normal file
View File

@@ -0,0 +1,39 @@
using Newtonsoft.Json;
using StructureHelperCommon.Models;
using StructureHelperCommon.Models.Calculators;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
namespace DataAccess.DTOs
{
public class ValueDiagramCalculatorDTO : IValueDiagramCalculator
{
[JsonProperty("Id")]
public Guid Id { get; }
[JsonProperty("Name")]
public string Name { get; set; }
[JsonProperty("InputData")]
public IValueDiagramCalculatorInputData InputData { get; set; }
[JsonProperty("ShowTraceData")]
public bool ShowTraceData { get; set; }
[JsonIgnore]
public IResult Result => throw new NotImplementedException();
[JsonIgnore]
public IShiftTraceLogger? TraceLogger { get; set; }
public ValueDiagramCalculatorDTO(Guid id)
{
Id = id;
}
public object Clone()
{
return this;
}
public void Run()
{
throw new NotImplementedException();
}
}
}

32
DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramCalculatorInputDataDTO.cs Normal file
View File

@@ -0,0 +1,32 @@
using Newtonsoft.Json;
using StructureHelperCommon.Models.Forces;
using StructureHelperCommon.Models.States;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
using StructureHelperLogics.NdmCalculations.Primitives;
namespace DataAccess.DTOs
{
public class ValueDiagramCalculatorInputDataDTO : IValueDiagramCalculatorInputData
{
[JsonProperty("Id")]
public Guid Id { get; }
[JsonProperty("StateTermPair")]
public IStateCalcTermPair StateTermPair { get; set; } = new StateCalcTermPairDTO();
[JsonProperty("Diagrams")]
public List<IValueDiagramEntity> Digrams { get; } = [];
[JsonProperty("CheckStrainLimits")]
public bool CheckStrainLimit { get; set; } = true;
[JsonProperty("ForceActions")]
public List<IForceAction> ForceActions { get; } = [];
[JsonProperty("Primitives")]
public List<INdmPrimitive> Primitives { get; } = [];
public ValueDiagramCalculatorInputDataDTO(Guid id)
{
Id = id;
}
}
}

26
DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramDTO.cs Normal file
View File

@@ -0,0 +1,26 @@
using Newtonsoft.Json;
using StructureHelperCommon.Models.Shapes;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
namespace DataAccess.DTOs
{
public class ValueDiagramDTO : IValueDiagram
{
[JsonProperty("Id")]
public Guid Id { get; }
[JsonProperty("Point2DRange")]
public IPoint2DRange Point2DRange { get; set; }
[JsonProperty("StepNumber")]
public int StepNumber { get; set; }
public ValueDiagramDTO(Guid id)
{
Id = id;
}
public object Clone()
{
return this;
}
}
}

28
DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramEntityDTO.cs Normal file
View File

@@ -0,0 +1,28 @@
using Newtonsoft.Json;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
namespace DataAccess.DTOs
{
public class ValueDiagramEntityDTO : IValueDiagramEntity
{
[JsonProperty("Id")]
public Guid Id { get; }
[JsonProperty("Name")]
public string Name { get; set; }
[JsonProperty("IsTaken")]
public bool IsTaken { get; set; }
[JsonProperty("ValueDiagram")]
public IValueDiagram ValueDigram { get; set; }
public ValueDiagramEntityDTO(Guid id)
{
Id = id;
}
public object Clone()
{
return this;
}
}
}

3
StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramEntityView.xaml
View File

@@ -21,6 +21,7 @@
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
<RowDefinition Height="22"/>
<RowDefinition Height="22"/>
<RowDefinition Height="22"/>
<RowDefinition Height="15"/>
@@ -29,6 +30,8 @@
<CheckBox Grid.Column="1" Margin="0,3" IsChecked="{Binding IsTaken}"/>
<TextBlock Grid.Row="1" Text="Name"/>
<TextBox Grid.Column="1" Grid.Row="1" Text="{Binding Name}"/>
<TextBlock Grid.Row="2" Text="Step number"/>
<TextBox Grid.Column="1" Grid.Row="2" Text="{Binding ValueDiagram.StepNumber}"/>
</Grid>
<Grid>
<Grid.ColumnDefinitions>

110
StructureHelper/Windows/Graphs/GraphView.xaml
View File

@@ -61,61 +61,69 @@
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="5*"/>
</Grid.ColumnDefinitions>
<Grid>
<Grid.RowDefinitions>
<RowDefinition/>
<RowDefinition Height="170"/>
</Grid.RowDefinitions>
<ListBox ItemsSource="{Binding Series}">
<ListBox.ItemTemplate>
<DataTemplate>
<Expander Header="{Binding Name}" IsExpanded="True" Background="{Binding Color}">
<Grid HorizontalAlignment="Stretch">
<Grid.RowDefinitions>
<RowDefinition Height="70"/>
<RowDefinition/>
</Grid.RowDefinitions>
<GroupBox Grid.Row="0" Margin="10,0,10,0" Header="X-axis values">
<StackPanel>
<ComboBox ItemsSource="{Binding XItems.Collection}" SelectedItem="{Binding XItems.SelectedItem}">
<ComboBox.ItemTemplate>
<DataTemplate>
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="20"/>
<ColumnDefinition/>
</Grid.ColumnDefinitions>
<Rectangle Grid.Column="0" Margin="3">
<Rectangle.Fill>
<SolidColorBrush Color="{Binding Color}"/>
</Rectangle.Fill>
</Rectangle>
<TextBlock Grid.Column="1" Text="{Binding Name}"/>
</Grid>
</DataTemplate>
</ComboBox.ItemTemplate>
</ComboBox>
<CheckBox Margin="5" Content="Invert Values" IsChecked="{Binding InvertXValues}"/>
</StackPanel>
</GroupBox>
<GroupBox Grid.Row="1" Margin="10,0,10,0" Header="Y-axis values">
<Grid>
<TabControl>
<TabItem Header="Series">
<ScrollViewer>
<ListBox ItemsSource="{Binding Series}" ScrollViewer.VerticalScrollBarVisibility="Hidden">
<ListBox.ItemTemplate>
<DataTemplate>
<Expander Header="{Binding Name}" IsExpanded="True" Background="{Binding Color}">
<Grid HorizontalAlignment="Stretch">
<Grid.RowDefinitions>
<RowDefinition Height="70"/>
<RowDefinition/>
<RowDefinition Height="30"/>
</Grid.RowDefinitions>
<ContentControl ContentTemplate="{StaticResource ResourceKey=SelectItems}" Content="{Binding YItems}"/>
<CheckBox Grid.Row="1" Margin="5" Content="Invert Values" IsChecked="{Binding InvertYValues}"/>
<GroupBox Grid.Row="0" Margin="10,0,10,0" Header="X-axis values">
<StackPanel>
<ComboBox ItemsSource="{Binding XItems.Collection}" SelectedItem="{Binding XItems.SelectedItem}">
<ComboBox.ItemTemplate>
<DataTemplate>
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="20"/>
<ColumnDefinition/>
</Grid.ColumnDefinitions>
<Rectangle Grid.Column="0" Margin="3">
<Rectangle.Fill>
<SolidColorBrush Color="{Binding Color}"/>
</Rectangle.Fill>
</Rectangle>
<TextBlock Grid.Column="1" Text="{Binding Name}"/>
</Grid>
</DataTemplate>
</ComboBox.ItemTemplate>
</ComboBox>
<CheckBox Margin="5" Content="Invert Values" IsChecked="{Binding InvertXValues}"/>
</StackPanel>
</GroupBox>
<GroupBox Grid.Row="1" Margin="10,0,10,0" Header="Y-axis values">
<Grid>
<Grid.RowDefinitions>
<RowDefinition/>
<RowDefinition Height="30"/>
</Grid.RowDefinitions>
<ContentControl ContentTemplate="{StaticResource ResourceKey=SelectItems}" Content="{Binding YItems}"/>
<CheckBox Grid.Row="1" Margin="5" Content="Invert Values" IsChecked="{Binding InvertYValues}"/>
</Grid>
</GroupBox>
</Grid>
</GroupBox>
</Grid>
</Expander>
</DataTemplate>
</ListBox.ItemTemplate>
</ListBox>
<ContentControl Grid.Row="1" ContentTemplate="{StaticResource ResourceKey=LineVisualProperties}" Content="{Binding VisualProps}"/>
</Grid>
</Expander>
</DataTemplate>
</ListBox.ItemTemplate>
</ListBox>
</ScrollViewer>
</TabItem>
<TabItem Header="Settings">
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="170"/>
<RowDefinition/>
</Grid.RowDefinitions>
<ContentControl ContentTemplate="{StaticResource ResourceKey=LineVisualProperties}" Content="{Binding VisualProps}"/>
</Grid>
</TabItem>
</TabControl>
<GridSplitter Grid.Column="1" Width="3" VerticalAlignment="Stretch" HorizontalAlignment="Center" ShowsPreview="False"/>
<Grid Grid.Column="2">
<lvc:CartesianChart Name="MainChart" Series="{Binding SeriesCollection}" LegendLocation="Bottom" Zoom="Xy" Background="White">

16
StructureHelper/Windows/MainWindow/CrossSections/ValueDiagramLogic.cs
View File

@@ -1,6 +1,4 @@
using LoaderCalculator.Data.Matrix;
using LoaderCalculator.Data.Ndms;
using LoaderCalculator.Logics;
using StructureHelper.Services.ResultViewers;
using StructureHelper.Windows.CalculationWindows.CalculatorsViews.ForceCalculatorViews;
using StructureHelper.Windows.Graphs;
@@ -18,7 +16,6 @@ namespace StructureHelper.Windows.MainWindow.CrossSections
{
internal class ValueDiagramLogic
{
private IStressLogic stressLogic = new StressLogic();
private IValueDiagramCalculatorResult valueDiagramResult;
private List<ForceResultFunc> resultFuncs = [];
private List<string> labels;
@@ -49,6 +46,10 @@ namespace StructureHelper.Windows.MainWindow.CrossSections
var primitives = valueDiagramResult.InputData.Primitives
.Where(x => x is IHasDivisionSize);
Series series = GetSeries(forceTupleResult, valueDiagramResult.InputData.Primitives, entityResult.PointList);
if (valueDiagramResult.EntityResults.Count > 1)
{
series.Name = $"${entityResult.ValueDiagramEntity.Name} ({series.Name})";
}
seriesList.Add(series);
}
}
@@ -60,10 +61,15 @@ namespace StructureHelper.Windows.MainWindow.CrossSections
private Series GetSeries(IForceTupleCalculatorResult tupleResult, List<INdmPrimitive> ndmPrimitives, List<IPoint2D> points)
{
List<(INdmPrimitive ndmPrimitive, IPoint2D point)> pointPrimitives = GetPrimitivePoints(ndmPrimitives, points);
if (pointPrimitives.Count == 0)
{
throw new StructureHelperException("There are not points for drawings");
}
ArrayParameter<double> arrayParameter = new(pointPrimitives.Count + 3, labels);
var data = arrayParameter.Data;
IPoint2D startPoint = pointPrimitives[0].point;
IPoint2D endPoint = pointPrimitives[^1].point;
IStrainMatrix strainMatrix = tupleResult.LoaderResults.StrainMatrix;
for (int i = 0; i < pointPrimitives.Count; i++)
{
IPoint2D currentPoint = pointPrimitives[i].point;
@@ -73,7 +79,7 @@ namespace StructureHelper.Windows.MainWindow.CrossSections
data[i, 2] = currentPoint.Y;
for (int j = 0; j < resultFuncs.Count; j++)
{
data[i, j + 3] = GetValueByPoint(tupleResult.LoaderResults.StrainMatrix, pointPrimitives[i].ndmPrimitive, pointPrimitives[i].point, resultFuncs[j]);
data[i, j + 3] = GetValueByPoint(strainMatrix, pointPrimitives[i].ndmPrimitive, pointPrimitives[i].point, resultFuncs[j]);
}
}
@@ -92,7 +98,7 @@ namespace StructureHelper.Windows.MainWindow.CrossSections
{
data[pointPrimitives.Count, j+3] = 0.0;
data[pointPrimitives.Count + 1, j+3] = 0.0;
data[pointPrimitives.Count + 2, j + 3] = GetValueByPoint(tupleResult.LoaderResults.StrainMatrix, pointPrimitives[0].ndmPrimitive, pointPrimitives[0].point, resultFuncs[j]);
data[pointPrimitives.Count + 2, j + 3] = GetValueByPoint(strainMatrix, pointPrimitives[0].ndmPrimitive, pointPrimitives[0].point, resultFuncs[j]);
}
StructureHelperCommon.Models.Forces.IForceTuple inputForceTuple = tupleResult.InputData.ForceTuple;

28
StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/CalculatorCloningStrategyContainer.cs Normal file
View File

@@ -0,0 +1,28 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
using StructureHelperLogics.NdmCalculations.Cracking;
using System;
using System.Collections.Generic;
using System.Text;
namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics
{
public class CalculatorCloningStrategyContainer : ICalculatorCloningStrategyContainer
{
private ICloningStrategy cloningStrategy;
public IUpdateStrategy<IForceCalculator> ForceCalculatorStrategy => new ForceCalculatorUpdateCloningStrategy(cloningStrategy);
public IUpdateStrategy<ICrackCalculator> CrackCalculatorStrategy => new CrackCalculatorUpdateCloningStrategy(cloningStrategy);
public IUpdateStrategy<ILimitCurvesCalculator> LimitCurvesCalculatorStrategy => new LimitCurvesCalculatorUpdateCloningStrategy(cloningStrategy);
public IUpdateStrategy<IValueDiagramCalculator> ValueDiagramCalculatorStrategy => new ValueDiagramCalculatorUpdateCloningStrategy(cloningStrategy);
public CalculatorCloningStrategyContainer(ICloningStrategy cloningStrategy)
{
this.cloningStrategy = cloningStrategy;
}
}
}

1
StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateCloningStrategy.cs
View File

@@ -1,5 +1,4 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Infrastructures.Settings;
using StructureHelperCommon.Services;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives.Logics;

27
StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/HasCalculatorsUpdateCloningStrategy.cs
View File

@@ -6,6 +6,7 @@ using StructureHelperCommon.Models.Parameters;
using StructureHelperCommon.Services;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
using StructureHelperLogics.NdmCalculations.Cracking;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives.Logics;
@@ -18,28 +19,20 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
public class HasCalculatorsUpdateCloningStrategy : IUpdateStrategy<IHasCalculators>
{
private ICloningStrategy cloningStrategy;
private IUpdateStrategy<IForceCalculator> forceCalculatorUpdateStrategy;
private IUpdateStrategy<ICrackCalculator> crackCalculatorUpdateStrategy;
private IUpdateStrategy<ILimitCurvesCalculator> limitCurvesCalculatorUpdateStrategy;
private ICalculatorCloningStrategyContainer cloningStrategyContainer;
public HasCalculatorsUpdateCloningStrategy(
ICloningStrategy cloningStrategy,
IUpdateStrategy<IForceCalculator> forceCalculatorUpdateStrategy,
IUpdateStrategy<ICrackCalculator> crackCalculatorUpdateStrategy,
IUpdateStrategy<ILimitCurvesCalculator> limitCurvesCalculatorUpdateStrategy)
ICalculatorCloningStrategyContainer cloningStrategyContainer)
{
this.cloningStrategy = cloningStrategy;
this.forceCalculatorUpdateStrategy = forceCalculatorUpdateStrategy;
this.crackCalculatorUpdateStrategy = crackCalculatorUpdateStrategy;
this.limitCurvesCalculatorUpdateStrategy = limitCurvesCalculatorUpdateStrategy;
this.cloningStrategyContainer = cloningStrategyContainer;
}
public HasCalculatorsUpdateCloningStrategy(ICloningStrategy cloningStrategy) : this(
cloningStrategy,
new ForceCalculatorUpdateCloningStrategy(cloningStrategy),
new CrackCalculatorUpdateCloningStrategy(cloningStrategy),
new LimitCurvesCalculatorUpdateCloningStrategy(cloningStrategy)
new CalculatorCloningStrategyContainer(cloningStrategy)
)
{
}
@@ -58,15 +51,19 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
//var newCalculator = calculator.Clone() as ICalculator;
if (calculator is IForceCalculator forceCalculator)
{
forceCalculatorUpdateStrategy.Update(newCalculator as IForceCalculator, forceCalculator);
cloningStrategyContainer.ForceCalculatorStrategy.Update(newCalculator as IForceCalculator, forceCalculator);
}
else if (calculator is ICrackCalculator crackCalculator)
{
crackCalculatorUpdateStrategy.Update(newCalculator as ICrackCalculator, crackCalculator);
cloningStrategyContainer.CrackCalculatorStrategy.Update(newCalculator as ICrackCalculator, crackCalculator);
}
else if (calculator is ILimitCurvesCalculator limitCalculator)
{
limitCurvesCalculatorUpdateStrategy.Update(newCalculator as ILimitCurvesCalculator, limitCalculator);
cloningStrategyContainer.LimitCurvesCalculatorStrategy.Update(newCalculator as ILimitCurvesCalculator, limitCalculator);
}
else if (calculator is IValueDiagramCalculator valueDiagramCalculator)
{
cloningStrategyContainer.ValueDiagramCalculatorStrategy.Update(newCalculator as IValueDiagramCalculator, valueDiagramCalculator);
}
else
{

14
StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ICalculatorCloningStrategyContainer.cs Normal file
View File

@@ -0,0 +1,14 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams;
using StructureHelperLogics.NdmCalculations.Cracking;
namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
public interface ICalculatorCloningStrategyContainer
{
IUpdateStrategy<IForceCalculator> ForceCalculatorStrategy { get; }
IUpdateStrategy<ICrackCalculator> CrackCalculatorStrategy { get; }
IUpdateStrategy<ILimitCurvesCalculator> LimitCurvesCalculatorStrategy { get; }
IUpdateStrategy<IValueDiagramCalculator> ValueDiagramCalculatorStrategy { get; }
}
}

2
StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/IValueDiagram.cs
View File

@@ -5,7 +5,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
{
public interface IValueDiagram : ISaveable, ICloneable
{
IPoint2DRange Point2DRange { get; }
IPoint2DRange Point2DRange { get; set; }
public int StepNumber { get; set; }
}
}

44
StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramCalculatorUpdateCloningStrategy.cs Normal file
View File

@@ -0,0 +1,44 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives.Logics;
namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
{
public class ValueDiagramCalculatorUpdateCloningStrategy : IUpdateStrategy<IValueDiagramCalculator>
{
private readonly ICloningStrategy cloningStrategy;
private readonly IUpdateStrategy<IHasForceActions> forcesUpdateStrategy;
private readonly IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy;
public ValueDiagramCalculatorUpdateCloningStrategy(ICloningStrategy cloningStrategy) : this(
cloningStrategy,
new HasForceActionUpdateCloningStrategy(cloningStrategy),
new HasPrimitivesUpdateCloningStrategy(cloningStrategy))
{
this.cloningStrategy = cloningStrategy;
}
public ValueDiagramCalculatorUpdateCloningStrategy(ICloningStrategy cloningStrategy,
IUpdateStrategy<IHasForceActions> forcesUpdateStrategy,
IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy)
{
this.cloningStrategy = cloningStrategy;
this.forcesUpdateStrategy = forcesUpdateStrategy;
this.primitivesUpdateStrategy = primitivesUpdateStrategy;
}
public void Update(IValueDiagramCalculator targetObject, IValueDiagramCalculator sourceObject)
{
CheckObject.IsNull(cloningStrategy);
CheckObject.IsNull(sourceObject);
CheckObject.IsNull(targetObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
var sourceData = sourceObject.InputData;
var targetData = targetObject.InputData;
primitivesUpdateStrategy.Update(targetData, sourceData);
forcesUpdateStrategy.Update(targetData, sourceData);
}
}
}

2
StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/Logics/ValueDiagramUpdateStrategy.cs
View File

@@ -4,7 +4,7 @@ using StructureHelperCommon.Services;
namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
{
internal class ValueDiagramUpdateStrategy : IParentUpdateStrategy<IValueDiagram>
public class ValueDiagramUpdateStrategy : IParentUpdateStrategy<IValueDiagram>
{
private IUpdateStrategy<IPoint2DRange> rangeUpdateStrategy;
public bool UpdateChildren { get; set; } = true;

2
StructureHelperLogics/NdmCalculations/Analyses/ValueDiagrams/ValueDiagram.cs
View File

@@ -6,7 +6,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ValueDiagrams
{
public Guid Id { get; }
public int StepNumber { get; set; } = 50;
public IPoint2DRange Point2DRange { get; } = new Point2DRange(Guid.NewGuid());
public IPoint2DRange Point2DRange { get; set; } = new Point2DRange(Guid.NewGuid());
public ValueDiagram(Guid id)