C# PointByCoordinates
Dark Mode
In this section were going to finish the PointByCoordinates class and create Unit Tests for it.
Let’ start of with some changes to the Abstract Classes, Base Classes, and Interfaces.
Within the IPointBase3D Interface, I added a TranslatePointAlongVector method, to aid in calculating the points location relative to an AxisSystem.
C#
x
14
14
1
//IPointBase3D.cs2
using GeometryCoreProject.AbstractClasses;3
namespace GeometryCoreProject.WireframeBaseInterfaces4
{5
public interface IPointBase3D : IGeometryBase6
{7
double X { get; }8
double Y { get; }9
double Z { get; }10
IPointBase3D TranslatePointAlongVector(IPointBase3D iRefPoint, IVectorBase3D iRefVector, double iOffset);11
void SetCoordinates(double[] iCoordinates);12
double[] GetCoordinates();13
}14
}Within the PointBase3D Class, I created the method for the TranslatePointAlongVector, and also changed the SetCoordinates method to be a Virtual method so it can be overridden higher up the code stack. Also I added two operator methods, an Add and Subtract to make adding and subtracting points from each other easier. Finally the Equal method was fully defined so we can validate if two points are equal or not.
C#
1
59
59
1
//PointBase3D.cs2
using GeometryCoreProject.AbstractClasses;3
using GeometryCoreProject.WireframeBaseInterfaces;4
namespace GeometryCoreProject.WireframeBaseClasses5
{6
public class PointBase3D : GeometryBase , IPointBase3D7
{8
public double X { get; set; } = 0;9
public double Y { get; set; } = 0;10
public double Z { get; set; } = 0;11
public PointBase3D() { }12
public PointBase3D(double iX, double iY, double iZ) { this.X = iX; this.Y = iY;this.Z = iZ; }13
public IPointBase3D TranslatePointAlongVector(IPointBase3D iRefPoint, IVectorBase3D iRefVector, double iOffset)14
{15
double X = (iRefVector.UnitVector.I * iOffset) + iRefPoint.X;16
double Y = (iRefVector.UnitVector.J * iOffset) + iRefPoint.Y;17
double Z = (iRefVector.UnitVector.K * iOffset) + iRefPoint.Z;18
IPointBase3D ReturnPoint = new PointBase3D();19
ReturnPoint.SetCoordinates(new double[]{ X,Y,Z});20
return ReturnPoint;21
}22
public virtual void SetCoordinates(double[] iCoordinates)23
{24
this.X = iCoordinates[0];25
this.Y = iCoordinates[1];26
this.Z = iCoordinates[2];27
}28
public double[] GetCoordinates()29
{30
return new double[] { this.X, this.Y, this.Z };31
}32
public static IPointBase3D operator +(PointBase3D iPoint1, PointBase3D iPoint2)33
{34
return new PointBase3D(iPoint1.X+iPoint2.X, iPoint1.Y + iPoint2.Y, iPoint1.Z + iPoint2.Z);35
}36
public static IPointBase3D operator -(PointBase3D iPoint1, PointBase3D iPoint2)37
{38
return new PointBase3D(iPoint1.X - iPoint2.X, iPoint1.Y - iPoint2.Y, iPoint1.Z - iPoint2.Z);39
}40
public override bool Equals(object obj)41
{42
bool ReturnBoolean = false;43
if((IPointBase3D)obj is IPointBase3D)44
{45
IPointBase3D ValidationPoint = (IPointBase3D)obj;46
if (this.X.Equals(ValidationPoint.X) && this.Y.Equals(ValidationPoint.Y) && this.Z.Equals(ValidationPoint.Z))47
{48
ReturnBoolean = true;49
}50
}51
return ReturnBoolean;52
}53
public override int GetHashCode()54
{55
return 1;56
}57
}58
}59
Within the IVectorBase3D Interface and additional property was added for the Inverse Vector.
C#
1
15
15
1
//IVectorBase3D.cs2
namespace GeometryCoreProject.WireframeBaseInterfaces3
{4
public interface IVectorBase3D5
{6
double I { get; set; }7
double J { get; set; }8
double K { get; set; }9
double Magnitude { get; }10
IVectorBase3D UnitVector { get; }11
IVectorBase3D InverseVector { get; }12
bool Equals(object obj);13
int GetHashCode();14
}15
}And in the Implementation VectorBase3D Class, the Inverse Vector Property was defined and two constructors created, one default constructor and one which take I,J,K parameters.
C#
1
51
51
1
//VectorBase3D.cs2
using GeometryCoreProject.AbstractClasses;3
using GeometryCoreProject.WireframeBaseInterfaces;4
using System;5
namespace GeometryCoreProject.WireframeBaseClasses6
{7
public class VectorBase3D : GeometryBase, IVectorBase3D8
{9
public double I { get; set; }10
public double J { get; set; }11
public double K { get; set; }12
public double Magnitude => Math.Sqrt(Math.Pow(this.I,2)+ Math.Pow(this.J,2) + Math.Pow(this.K,2));13
public IVectorBase3D UnitVector14
{15
get16
{17
IVectorBase3D UnitVector = new VectorBase3D();18
UnitVector.I = (this.I / this.Magnitude);19
UnitVector.J = (this.J / this.Magnitude);20
UnitVector.K = (this.K / this.Magnitude);21
return UnitVector;22
}23
}24
public IVectorBase3D InverseVector25
{26
get27
{28
IVectorBase3D InverseVector = new VectorBase3D();29
InverseVector.I = (-this.I);30
InverseVector.J = (-this.J);31
InverseVector.K = (-this.K);32
return InverseVector;33
}34
}35
public VectorBase3D() { }36
public VectorBase3D(double iI, double iJ, double iK)37
{38
this.I = iI;39
this.J = iJ;40
this.K = iK;41
}42
public override bool Equals(object obj)43
{44
return false;45
}46
public override int GetHashCode()47
{48
return 1;49
}50
}51
}A lot has changed within the PointByCoordinates Class, all of the methods and property’s have been defined to allow the correct creation of a Point By Coordinates, with either a Reference Axis System or a Reference Point (but not both).
C#
1
106
106
1
//PointByCoordinates.cs2
using GeometryCoreProject.WireframeBaseClasses;3
using GeometryCoreProject.WireframeBaseInterfaces;4
using GeometryTypesProject.GeometryTypesInterfaces;5
using System;6
namespace GeometryTypesProject.GeometryTypesClasses7
{8
public class PointByCoordinates : PointBase3D, IPointByCoordinates9
{10
IPointBase3D _BasePoint { get; set; } = new PointBase3D();11
public IPointBase3D RefPoint { get; set; } = new PointBase3D();12
public IAxisSystemBase3D RefAxisSystem { get; set; } = null;13
public void SetX(double iX){this.X = iX;}14
public void SetY(double iY){this.X = iY;}15
public void SetZ(double iZ){this.X = iZ;}16
public void SetXYZ(double iX, double iY, double iZ)17
{18
this.X = iX;19
this.Y = iY;20
this.Z = iZ;21
}22
public override void SetCoordinates(double[] iCoordinates)23
{24
this._BasePoint.SetCoordinates(iCoordinates);25
if (this.RefAxisSystem == null)26
{27
base.SetCoordinates(((PointBase3D)this._BasePoint + (PointBase3D)this.RefPoint).GetCoordinates());28
}29
else30
{31
IPointBase3D TranslatedPoint = this.PointRelativeToAxisSystem(this.RefAxisSystem);32
base.SetCoordinates(((PointBase3D)TranslatedPoint + (PointBase3D)this.RefPoint).GetCoordinates());33
}34
}35
public PointByCoordinates() { }36
public PointByCoordinates(double iX, double iY,double iZ)37
{38
this.X = iX;39
this.Y = iY;40
this.Z = iZ;41
}42
public PointByCoordinates(double iX, double iY, double iZ, IPointBase3D iRefPoint)43
{44
this.X = iRefPoint.X + iX;45
this.Y = iRefPoint.Y + iY;46
this.Z = iRefPoint.Z + iZ;47
}48
public PointByCoordinates(double iX, double iY, double iZ, IAxisSystemBase3D iRefAxisSystem)49
{50
this.RefAxisSystem = iRefAxisSystem;51
IPointBase3D NewPoint = this.TranslatePointAlongVector(iRefAxisSystem.Origin, iRefAxisSystem.XAxis,iX);52
NewPoint = this.TranslatePointAlongVector(NewPoint, iRefAxisSystem.YAxis, iY);53
NewPoint = this.TranslatePointAlongVector(NewPoint, iRefAxisSystem.ZAxis, iZ);54
this.X = NewPoint.X;55
this.Y = NewPoint.Y;56
this.Z = NewPoint.Z;57
}58
public PointByCoordinates(double iX, double iY, double iZ, IPointBase3D iRefPoint, IAxisSystemBase3D iRefAxisSystem )59
{60
this.RefAxisSystem = iRefAxisSystem;61
this.RefPoint = iRefPoint;62
}63
public void RemoveRefPoint()64
{65
this.RefPoint = new PointBase3D();66
this.SetCoordinates(this._BasePoint.GetCoordinates());67
}68
public void RemoveRefAxisSystem()69
{70
this.RefPoint = new PointBase3D();71
this.RefAxisSystem = null;72
this.SetCoordinates(this._BasePoint.GetCoordinates());73
}74
public void AddRefPoint(IPointBase3D iRefPoint)75
{76
if (this.RefAxisSystem != null) { throw new Exception("The Point Already Uses a Reference AxisSystem."); }77
// Store the Original Coordinates78
this._BasePoint.SetCoordinates(this.GetCoordinates());79
// Set the Reference Point80
this.RefPoint = iRefPoint;81
// Update the Coordinates82
this.SetCoordinates(this._BasePoint.GetCoordinates());83
}84
public void AddRefAxisSystem(IAxisSystemBase3D iRefAxisSystem)85
{86
if (!this.RefPoint.Equals(new PointBase3D())) { throw new Exception("The Point Already Uses a Reference Point."); }87
// Store the Original Coordinates88
this._BasePoint.SetCoordinates(this.GetCoordinates());89
// Set the Reference Point90
this.RefPoint = iRefAxisSystem.Origin;91
// Set the Reference AxisSystem92
this.RefAxisSystem = iRefAxisSystem;93
// Update the Coordinates94
this.SetCoordinates(this._BasePoint.GetCoordinates());95
}96
private IPointBase3D PointRelativeToAxisSystem(IAxisSystemBase3D iRefAxisSystem)97
{98
IPointBase3D ReturnPoint = new PointBase3D();99
ReturnPoint = this.TranslatePointAlongVector(ReturnPoint, iRefAxisSystem.XAxis, this._BasePoint.X);100
ReturnPoint = this.TranslatePointAlongVector(ReturnPoint, iRefAxisSystem.YAxis, this._BasePoint.Y);101
ReturnPoint = this.TranslatePointAlongVector(ReturnPoint, iRefAxisSystem.ZAxis, this._BasePoint.Z);102
return ReturnPoint;103
}104
}105
}106
Unit Testing
No Good Class is without a Unit Test to aid with Development and Production testing, there are Ten unit tests, which tests all of the end user interactions. Form the creation of a simple PointByCoordinate, to updating the initial XYZ values, Adding Reference Points and Reference AxisSystem’s and removing them.
This will help ensure we don’t break anything while making changes later on.
To do this first we need to add additional Solution Folders, Projects and Classes, not forgetting a couple of NuGet Packages.
To build the Unit tests we need to add addition NuGet Packages, like FluentAssertions which will make building the unit testing easier.
Finally we can add a new Class and build our Unit Test for PointByCoordinates.
Note :- on some of the cases I had to use System.Math.Round to simplify the resulting value so that the Should().Be(Value) could be kept simple, and ensure an exact match each time.
C#
1
209
209
1
//PointByCoordinatesUnitTest.cs2
using GeometryFactoriesProject.FactoryBaseClasses;3
using GeometryTypesProject.GeometryTypesInterfaces;4
using GeometryCoreProject.WireframeBaseInterfaces;5
using GeometryCoreProject.WireframeBaseClasses;6
using System;7
using Xunit;8
using FluentAssertions;9
namespace GeometryUnitTestsProject.PointByCoordinates10
{11
public class PointByCoordinatesUnitTest12
{13
// Create an Instance of the Factory14
WireframeFactory _WireframeFactory = new WireframeFactory();15
[Fact] // Create Point at 10,10,1016
public void PointByCoordinatesTest1()17
{18
// Create an instance of the IPointByCoordinates19
IPointByCoordinates PointByCoordinates = this._WireframeFactory.AddNewPointCoord(10, 10, 10);20
// Test the Point X,Y,Z Values21
PointByCoordinates.X.Should().Be(10);22
PointByCoordinates.Y.Should().Be(10);23
PointByCoordinates.Z.Should().Be(10);24
}25
[Fact] // Create Point at 10,10,10 then Update the Values to 12,23,3426
public void PointByCoordinatesTest2()27
{28
// Create an instance of the IPointByCoordinates29
IPointByCoordinates PointByCoordinates = this._WireframeFactory.AddNewPointCoord(10, 10, 10);30
// Update Point Locations31
PointByCoordinates.SetCoordinates(new double[] { 12,23,34});32
// Test the Point X,Y,Z Values33
PointByCoordinates.X.Should().Be(12);34
PointByCoordinates.Y.Should().Be(23);35
PointByCoordinates.Z.Should().Be(34);36
}37
[Fact] // Create a Point at 10,10,10 then Add a Reference Point at 20,20,2038
public void PointByCoordinatesTest3()39
{40
// Create an instance of the IPointByCoordinates41
IPointByCoordinates PointByCoordinates = this._WireframeFactory.AddNewPointCoord(10, 10, 10);42
// Create ReferencePoint43
IPointByCoordinates RefPointByCoordinates = this._WireframeFactory.AddNewPointCoord(20, 20, 20);44
//Set the ReferencePoint45
PointByCoordinates.AddRefPoint(RefPointByCoordinates);46
// Test the Point X,Y,Z Values47
PointByCoordinates.X.Should().Be(30);48
PointByCoordinates.Y.Should().Be(30);49
PointByCoordinates.Z.Should().Be(30);50
}51
[Fact]52
/* Create a Point at 10,10,1053
then Add a Reference Point at 20,20,20,54
then Update the Values to 12,23,34*/55
public void PointByCoordinatesTest4()56
{57
// Create an instance of the IPointByCoordinates58
IPointByCoordinates PointByCoordinates = this._WireframeFactory.AddNewPointCoord(10, 10, 10);59
// Create ReferencePoint60
IPointByCoordinates RefPointByCoordinates = this._WireframeFactory.AddNewPointCoord(20, 20, 20);61
//Set the ReferencePoint62
PointByCoordinates.AddRefPoint(RefPointByCoordinates);63
// Update Point Locations64
PointByCoordinates.SetCoordinates(new double[] { 12, 23, 34 });65
// Test the Point X,Y,Z Values66
PointByCoordinates.X.Should().Be(32);67
PointByCoordinates.Y.Should().Be(43);68
PointByCoordinates.Z.Should().Be(54);69
}70
[Fact]71
/* Create a Point at 10,10,1072
then Add a Reference Point at 20,20,20,73
then Update the Values to 12,23,34,74
then Remove the Reference Point*/75
public void PointByCoordinatesTest5()76
{77
// Create an instance of the IPointByCoordinates78
IPointByCoordinates PointByCoordinates = this._WireframeFactory.AddNewPointCoord(10, 10, 10);79
// Create ReferencePoint80
IPointByCoordinates RefPointByCoordinates = this._WireframeFactory.AddNewPointCoord(20, 20, 20);81
// Set the ReferencePoint82
PointByCoordinates.AddRefPoint(RefPointByCoordinates);83
// Update Point Locations84
PointByCoordinates.SetCoordinates(new double[] { 12, 23, 34 });85
// Remove Reference Point86
PointByCoordinates.RemoveRefPoint();87
// Test the Point X,Y,Z Values88
PointByCoordinates.X.Should().Be(12);89
PointByCoordinates.Y.Should().Be(23);90
PointByCoordinates.Z.Should().Be(34);91
}92
[Fact]93
/* Create a Point at 10,10,1094
then Add a Reference AxisSystem*/95
public void PointByCoordinatesTest6()96
{97
// Create an instance of the IPointByCoordinates98
IPointByCoordinates PointByCoordinates = this._WireframeFactory.AddNewPointCoord(10, 10, 10);99
// Create ReferenceAxisSystem100
IAxisSystemBase3D RefAxisSystem = new AxisSystemBase3D();101
RefAxisSystem.Origin = this._WireframeFactory.AddNewPointCoord(20, 20, 20);102
RefAxisSystem.XAxis = new VectorBase3D(0.707106, 0.707106,0);103
RefAxisSystem.YAxis = new VectorBase3D(-0.707106, 0.707106, 0);104
RefAxisSystem.ZAxis = new VectorBase3D(0, 0, 1);105
// Set the ReferenceAxisSystem106
PointByCoordinates.AddRefAxisSystem(RefAxisSystem);107
// Test the Point X,Y,Z Values108
PointByCoordinates.X.Should().Be(20);109
Math.Round(PointByCoordinates.Y,3).Should().Be(34.142);110
PointByCoordinates.Z.Should().Be(30);111
}112
[Fact]113
/* Create a Point at 10,10,10114
then Add a Reference AxisSystem115
then then Update the Values to 12,23,34*/116
public void PointByCoordinatesTest7()117
{118
// Create an instance of the IPointByCoordinates119
IPointByCoordinates PointByCoordinates = this._WireframeFactory.AddNewPointCoord(10, 10, 10);120
// Create ReferenceAxisSystem121
IAxisSystemBase3D RefAxisSystem = new AxisSystemBase3D();122
RefAxisSystem.Origin = this._WireframeFactory.AddNewPointCoord(20, 20, 20);123
RefAxisSystem.XAxis = new VectorBase3D(0.707106, 0.707106, 0);124
RefAxisSystem.YAxis = new VectorBase3D(-0.707106, 0.707106, 0);125
RefAxisSystem.ZAxis = new VectorBase3D(0, 0, 1);126
// Set the ReferenceAxisSystem127
PointByCoordinates.AddRefAxisSystem(RefAxisSystem);128
// Update Point Locations129
PointByCoordinates.SetCoordinates(new double[] { 12, 23, 34 });130
// Test the Point X,Y,Z Values131
Math.Round(PointByCoordinates.X,3).Should().Be(12.222);132
Math.Round(PointByCoordinates.Y, 3).Should().Be(44.749);133
PointByCoordinates.Z.Should().Be(54);134
}135
[Fact]136
/* Create a Point at 10,10,10137
then Add a Reference AxisSystem138
then then Update the Values to 12,23,34139
then Remove the Reference AxisSystem*/140
public void PointByCoordinatesTest8()141
{142
// Create an instance of the IPointByCoordinates143
IPointByCoordinates PointByCoordinates = this._WireframeFactory.AddNewPointCoord(10, 10, 10);144
// Create ReferenceAxisSystem145
IAxisSystemBase3D RefAxisSystem = new AxisSystemBase3D();146
RefAxisSystem.Origin = this._WireframeFactory.AddNewPointCoord(20, 20, 20);147
RefAxisSystem.XAxis = new VectorBase3D(0.707106, 0.707106, 0);148
RefAxisSystem.YAxis = new VectorBase3D(-0.707106, 0.707106, 0);149
RefAxisSystem.ZAxis = new VectorBase3D(0, 0, 1);150
// Set the ReferenceAxisSystem151
PointByCoordinates.AddRefAxisSystem(RefAxisSystem);152
// Update Point Locations153
PointByCoordinates.SetCoordinates(new double[] { 12, 23, 34 });154
// Remove the Referene AxisSystem155
PointByCoordinates.RemoveRefAxisSystem();156
// Test the Point X,Y,Z Values157
PointByCoordinates.X.Should().Be(12);158
PointByCoordinates.Y.Should().Be(23);159
PointByCoordinates.Z.Should().Be(34);160
}161
[Fact]162
/* Create a Point at 10,10,10163
then Add a Reference Point at 20,20,20164
then Add a Reference AxisSystem, to Throw Exception165
*/166
public void PointByCoordinatesTest9()167
{168
// Create an instance of the IPointByCoordinates169
IPointByCoordinates PointByCoordinates = this._WireframeFactory.AddNewPointCoord(10, 10, 10);170
// Create ReferencePoint171
IPointByCoordinates RefPointByCoordinates = this._WireframeFactory.AddNewPointCoord(20, 20, 20);172
//Set the ReferencePoint173
PointByCoordinates.AddRefPoint(RefPointByCoordinates);174
// Create ReferenceAxisSystem175
IAxisSystemBase3D RefAxisSystem = new AxisSystemBase3D();176
RefAxisSystem.Origin = this._WireframeFactory.AddNewPointCoord(20, 20, 20);177
RefAxisSystem.XAxis = new VectorBase3D(0.707106, 0.707106, 0);178
RefAxisSystem.YAxis = new VectorBase3D(-0.707106, 0.707106, 0);179
RefAxisSystem.ZAxis = new VectorBase3D(0, 0, 1);180
// Set the ReferenceAxisSystem181
Action comparison = () => { PointByCoordinates.AddRefAxisSystem(RefAxisSystem); };182
comparison.Should().Throw<Exception>();183
}184
[Fact]185
/* Create a Point at 10,10,10186
then Add a Reference AxisSystem187
then Add a Reference Point at 20,20,20, to Throw Exception188
*/189
public void PointByCoordinatesTest10()190
{191
// Create an instance of the IPointByCoordinates192
IPointByCoordinates PointByCoordinates = this._WireframeFactory.AddNewPointCoord(10, 10, 10);193
// Create ReferenceAxisSystem194
IAxisSystemBase3D RefAxisSystem = new AxisSystemBase3D();195
RefAxisSystem.Origin = this._WireframeFactory.AddNewPointCoord(20, 20, 20);196
RefAxisSystem.XAxis = new VectorBase3D(0.707106, 0.707106, 0);197
RefAxisSystem.YAxis = new VectorBase3D(-0.707106, 0.707106, 0);198
RefAxisSystem.ZAxis = new VectorBase3D(0, 0, 1);199
// Set the ReferenceAxisSystem200
PointByCoordinates.AddRefAxisSystem(RefAxisSystem);201
// Create ReferencePoint202
IPointByCoordinates RefPointByCoordinates = this._WireframeFactory.AddNewPointCoord(20, 20, 20);203
//Set the ReferencePoint204
Action comparison = () => { PointByCoordinates.AddRefPoint(RefPointByCoordinates); };205
comparison.Should().Throw<Exception>();206
}207
}208
}209