private void getValueByDelegate(CogoStation station, out tupleNullableDoubles theOutValue, verticalCurve.getSwitchForProfiles getFunction)
{
if (null == allVCs)
{
theOutValue.ahead = 0.0;
theOutValue.back = 0.0;
theOutValue.isSingleValue = true;
return;
}
if ((station.trueStation < BeginProfTrueStation - stationEqualityTolerance) ||
(station.trueStation > EndProfTrueStation + stationEqualityTolerance))
{ // it means we are off the profile
theOutValue.back = null;
theOutValue.ahead = null;
theOutValue.isSingleValue = true;
return;
}
try { setIndexToTheCorrectVC(station); }
catch (IndexOutOfRangeException) { }
verticalCurve aVC = allVCs[vcIndex];
// if there are effectively no VCs, treat it as singleElevation
if (allVCs.Count == 1 && aVC.Length < 0.00000001)
{
theOutValue.back = aVC.BeginElevation;
theOutValue.ahead = aVC.BeginElevation;
theOutValue.isSingleValue = true;
}
// if we are at the begin station, check to see how we relate to the previous vc
else if (utilFunctions.tolerantCompare(station.trueStation, aVC.BeginStation.trueStation, stationEqualityTolerance) == 0)
{
// if we are at the beginning of the profile, split theOutValue
if (vcIndex == 0)
{
theOutValue.back = null;
theOutValue.ahead = getFunction(aVC, station);
theOutValue.isSingleValue = false;
}
else // if station is on the boundary between two verticalCurves,
{ // then see if we need to split theOutValue
if (getFunction == verticalCurve.getKvalue &&
aVC.IsBeginPINC)
{
theOutValue.back = theOutValue.ahead = 0.0;
theOutValue.isSingleValue = true;
}
else
{
theOutValue.ahead = getFunction(aVC, station);
theOutValue.back = getFunction(allVCs[vcIndex - 1], station);
if (utilFunctions.tolerantCompare(theOutValue.back, theOutValue.ahead, 0.00005) == 0)
{
theOutValue.isSingleValue = true;
}
else theOutValue.isSingleValue = false;
}
}
}
// End: if we are at the begin station, check to see how we relate to the previous vc
// if we are at the end station, check to see how we relate to the next vc
else if (utilFunctions.tolerantCompare(station.trueStation, aVC.EndStation.trueStation, stationEqualityTolerance) == 0)
{
// if we are at the end of the profile, split theOutValue
if (vcIndex == allVCs.Count - 1)
{
theOutValue.back = getFunction(aVC, station);
theOutValue.ahead = null;
theOutValue.isSingleValue = false;
}
else // if station is on the boundary between two verticalCurves,
{ // then see if we need to split theOutValue
if (getFunction == verticalCurve.getKvalue &&
aVC.IsEndPINC)
{
theOutValue.back = theOutValue.ahead = 0.0;
theOutValue.isSingleValue = true;
}
else
{
theOutValue.back = getFunction(aVC, station);
theOutValue.ahead = getFunction(allVCs[vcIndex + 1], station);
if (utilFunctions.tolerantCompare(theOutValue.back, theOutValue.ahead, 0.00005) == 0)
{
theOutValue.isSingleValue = true;
}
else theOutValue.isSingleValue = false;
}
}
}
// End: if we are at the end station, check to see how we relate to the next vc
else
{
theOutValue.back = getFunction(aVC, station);
theOutValue.ahead = theOutValue.back;
theOutValue.isSingleValue = true;
}
}
private static Profile scaleAprofile(Profile ProfileToScale, double scaleSecondProfile)
{
if (null == ProfileToScale) throw new ArgumentNullException();
Profile retProfile = new Profile();
retProfile.BeginProfTrueStation = ProfileToScale.BeginProfTrueStation;
retProfile.EndProfTrueStation = ProfileToScale.EndProfTrueStation;
retProfile.allVCs = new List<verticalCurve>();
foreach (verticalCurve vc in ProfileToScale.allVCs)
{
verticalCurve newVC = new verticalCurve(vc);
if (newVC.IsaProfileGap == false)
{
newVC.BeginElevation *= scaleSecondProfile;
newVC.BeginSlope *= scaleSecondProfile;
newVC.EndSlope *= scaleSecondProfile;
newVC.Length = vc.Length; // force computation of slopeRateOfChange_
}
retProfile.allVCs.Add(newVC);
}
return retProfile;
}
private void buildThisFromRawVPIlist(vpiList rawVPIlist)
{
iHaveOneOrMoreVerticalCurves = false;
if (rawVPIlist.Count < 2)
{
throw new NotImplementedException("Profile can not have less than 2 VPIs");
}
else if (rawVPIlist.Count == 2)
{
thisAsVpiList_ = rawVPIlist;
rawVPI vpi1 = rawVPIlist.getVPIbyIndex(0);
rawVPI vpi2 = rawVPIlist.getVPIbyIndex(1);
verticalCurve aNewVerticalCurve = new verticalCurve();
aNewVerticalCurve.BeginElevation = vpi1.Elevation;
aNewVerticalCurve.BeginStation = vpi1.Station;
BeginProfTrueStation = vpi1.Station.trueStation;
aNewVerticalCurve.Length = vpi2.Station - vpi1.Station;
EndProfTrueStation = vpi2.Station.trueStation;
aNewVerticalCurve.BeginSlope = (vpi2.Elevation - vpi1.Elevation) /
aNewVerticalCurve.Length;
aNewVerticalCurve.IsTangent = true;
aNewVerticalCurve.IsBeginPINC = false;
aNewVerticalCurve.IsEndPINC = false;
allVCs = new List<verticalCurve>();
allVCs.Add(aNewVerticalCurve);
}
else
{
thisAsVpiList_ = rawVPIlist;
double g1; double g2;
Int64 count=0;
rawVPI vpi1; rawVPI vpi2;
verticalCurve newVC;
// Note: These next two lines are here to suppress compiler errors.
// The real assignments for vpi1 and 2 are at the end of the foureach loop
vpi1 = rawVPIlist.getVPIbyIndex(0);
vpi2 = rawVPIlist.getVPIbyIndex(1);
foreach (rawVPI vpi3 in rawVPIlist.getVPIlist())
{
count++;
if (count > 1)
{
if (count > 2)
{
if (count == 3)
{
allVCs = new List<verticalCurve>();
BeginProfTrueStation = vpi1.Station.trueStation;
}
g1 = (vpi2.Elevation - vpi1.Elevation) /
(vpi2.Station.trueStation - vpi1.Station.trueStation);
g2 = (vpi3.Elevation - vpi2.Elevation) /
(vpi3.Station.trueStation - vpi2.Station.trueStation);
double incomingTanLen;
incomingTanLen = vpi2.getBeginStation() - vpi1.getEndStation();
// add a VC for the incoming tangent when necessary
if (incomingTanLen > 0.0)
{
newVC = new verticalCurve();
newVC.BeginSlope = g1;
newVC.BeginStation = vpi1.getEndStation();
newVC.EndSlope = g1;
newVC.Length = incomingTanLen;
newVC.BeginElevation = vpi2.Elevation + getELchangeAlongSlope(g1,
(vpi1.getEndStation() - vpi2.Station));
newVC.IsBeginPINC = false;
if (allVCs.Count > 0)
{
newVC.IsBeginPINC = allVCs.Last<verticalCurve>().IsEndPINC;
}
newVC.IsEndPINC = false;
if (utilFunctions.tolerantCompare(vpi2.Length, 0.0, stationEqualityTolerance) == 0)
{
newVC.IsEndPINC = true;
}
allVCs.Add(newVC);
}
// End: add a VC for the incoming tangent when necessary
// add a VC for the current vertical curve if VClen > 0
if (vpi2.Length > 0.0)
{
iHaveOneOrMoreVerticalCurves = true;
newVC = new verticalCurve();
newVC.BeginSlope = g1;
newVC.BeginStation = vpi2.getBeginStation();
newVC.EndSlope = g2;
newVC.Length = vpi2.Length;
newVC.BeginElevation = vpi2.Elevation - getELchangeAlongSlope(g1, newVC.Length / 2.0);
allVCs.Add(newVC);
EndProfTrueStation = newVC.BeginStation.trueStation + newVC.Length;
}
// End: add a VC for the current vertical curve if VClen > 0
// if this is the final VPI, add a final tangent if necessary
if (count == rawVPIlist.Count)
{
double outgoingTangentLength = vpi3.getBeginStation() - vpi2.getEndStation();
if (outgoingTangentLength > 0.0)
{
newVC = new verticalCurve();
newVC.BeginSlope = g2;
newVC.BeginStation = vpi2.getEndStation();
newVC.EndSlope = g2;
newVC.Length = outgoingTangentLength;
newVC.BeginElevation = vpi2.Elevation + getELchangeAlongSlope(g2, vpi2.Length / 2.0);
newVC.IsBeginPINC = false;
if (allVCs.Count > 0)
{
newVC.IsBeginPINC = allVCs.Last<verticalCurve>().IsEndPINC;
}
newVC.IsEndPINC = false;
allVCs.Add(newVC);
EndProfTrueStation = newVC.BeginStation.trueStation + newVC.Length;
}
}
// End: if this is the final VPI, add a final tangent if necessary
}
vpi1 = vpi2;
}
vpi2 = vpi3;
}
}
}
public void addSegment(CogoStation beginStation, double beginElevation,
double beginSlope, double endSlope, double length, bool isBeginPINC,
bool isEndPINC, bool isAProfileGap)
{
this.BeginProfTrueStation = Math.Min(this.BeginProfTrueStation, beginStation.trueStation);
this.EndProfTrueStation = Math.Max(this.EndProfTrueStation, beginStation.trueStation + length);
verticalCurve aVC = new verticalCurve();
aVC.IsaProfileGap = isAProfileGap;
if (false == isAProfileGap)
{
aVC.BeginStation = beginStation;
aVC.BeginElevation = beginElevation;
aVC.BeginSlope = beginSlope;
aVC.EndSlope = endSlope;
aVC.Length = length;
aVC.IsBeginPINC = isBeginPINC;
aVC.IsEndPINC = isEndPINC;
}
if (null == this.allVCs)
this.allVCs = new List<verticalCurve>();
this.allVCs.Add(aVC);
}
public void appendStationAndElevation(CogoStation newStation, double newElevation)
{
verticalCurve newVC, otherVC;
if (iHaveOneOrMoreVerticalCurves == true)
{
throw new NotImplementedException("Currently unable to add VPI to a profile with a vertical curve.");
}
newVC = new verticalCurve();
// To Do's
//Insert new pi after last station
if (newStation > EndProfTrueStation)
{
vcIndex = allVCs.Count - 1;
otherVC = allVCs[vcIndex];
newVC.BeginStation = otherVC.EndStation;
EndProfTrueStation = newStation.trueStation;
otherVC.IsEndPINC = true;
newVC.BeginElevation = verticalCurve.getElevation(otherVC, (CogoStation)otherVC.EndStation);
newVC.IsBeginPINC = true;
newVC.IsEndPINC = false;
newVC.IsTangent = true;
newVC.BeginSlope = (newElevation - newVC.BeginElevation) /
(newStation - newVC.BeginStation);
newVC.EndSlope = newVC.BeginSlope;
newVC.Length = newStation - newVC.BeginStation;
allVCs.Add(newVC);
}
else if (newStation < BeginProfTrueStation) //Insert new pi before first station
{
vcIndex = 0;
otherVC = allVCs[vcIndex];
newVC.BeginStation = newStation;
BeginProfTrueStation = newStation.trueStation;
otherVC.IsBeginPINC = true;
newVC.BeginElevation = newElevation;
newVC.IsBeginPINC = false;
newVC.IsEndPINC = true;
newVC.IsTangent = true;
newVC.BeginSlope = (otherVC.BeginElevation - newElevation) /
(otherVC.BeginStation - newStation);
newVC.EndSlope = newVC.BeginSlope;
newVC.Length = otherVC.BeginStation - newStation;
allVCs.Insert(0, newVC);
}
//insert new pi interior to the profile, but one that has no vertical curves
else
{ //(CogoStation newStation, double newElevation)
setIndexToTheCorrectVC(newStation);
otherVC = allVCs[vcIndex];
// see if new station is already in the profile as a vpi
if(newStation == otherVC.BeginStation)
{
if (vcIndex == 0) // currently at the first vc
{
throw new NotImplementedException();
}
else
{
throw new NotImplementedException();
}
}
else if(newStation == otherVC.EndStation)
{
if (vcIndex == allVCs.Count - 1) // currently at the last vc
{
throw new NotImplementedException();
}
else
{
throw new NotImplementedException();
}
} // End: see if new station is already in the profile as a vpi
else // new station is interior to an existing VC
{
CogoStation station1, station2, station3;
double elevation1, elevation2, elevation3;
station1 = otherVC.BeginStation; station2 = newStation; station3 = otherVC.EndStation;
elevation1 = otherVC.BeginElevation; elevation2 = newElevation;
elevation3 = verticalCurve.getElevation(otherVC, station3);
otherVC.setVerticalTangent(station1, elevation1, station2, elevation2);
newVC = new verticalCurve();
newVC.setVerticalTangent(station2, elevation2, station3, elevation3);
verticalCurve otherOtherVC;
if (vcIndex > 0)
{
int VCindex0 = vcIndex - 1;
otherOtherVC = allVCs[VCindex0];
if (otherOtherVC.EndSlope == otherVC.BeginSlope)
otherOtherVC.IsEndPINC = otherVC.IsBeginPINC = false;
else
otherOtherVC.IsEndPINC = otherVC.IsBeginPINC = true;
}
if (vcIndex < allVCs.Count-1)
{
int VCindex3 = vcIndex + 1;
otherOtherVC = allVCs[VCindex3];
if (otherOtherVC.BeginSlope == otherVC.EndSlope)
otherOtherVC.IsBeginPINC = otherVC.IsEndPINC = false;
else
otherOtherVC.IsBeginPINC = otherVC.IsEndPINC = true;
}
allVCs.Insert(vcIndex+1, newVC);
} // End: new station is interior to an existing VC
}
// To Do: dissolve two vc's into one when they are really the same slope/elevation
}
private List<verticalCurve> getRayIntersectionsOnTangentSegment(ptsRay aRay)
{
if (this.slopeRateOfChange_ != Double.PositiveInfinity)
throw new Exception("Parabolic profile segment encountered where tangent profile segment expected.");
if (aRay.get_m() == this.get_m())
{
if (this.get_b() == aRay.get_b())
return null;
else
throw new NotImplementedException();
}
double intersectionX = (this.get_b() - aRay.get_b()) /
(aRay.get_m() - this.get_m());
if (intersectionX < this.BeginStation.trueStation || intersectionX > this.EndStation.trueStation)
return null;
if (false == aRay.isWithinDomain(intersectionX))
return null;
int sign = 1;
verticalCurve newVC = null;
if (1 == aRay.advanceDirection)
{
newVC = new verticalCurve((CogoStation)aRay.StartPoint.x, aRay.StartPoint.z,
aRay.Slope, intersectionX - aRay.StartPoint.x, Double.PositiveInfinity);
}
else
{
sign = -1;
newVC = new verticalCurve((CogoStation)intersectionX, getElevation(this, (CogoStation)intersectionX),
sign * aRay.Slope, Math.Abs(intersectionX - aRay.StartPoint.x), Double.PositiveInfinity);
}
var returnList = new List<verticalCurve>();
returnList.Add(newVC);
return returnList;
}
public static Profile arithmaticAddProfile(Profile This, Profile Other, double scaleSecondProfile)
{
if (Other == null) throw new ArgumentNullException();
if (null == Other.allVCs) throw new Exception("Second profile variable has no profile segments.");
// to do: check to see if both profiles are on the same hor alignment or
// are both unassociated with a horizontal alignment
Profile scaledProfileOther = scaleAprofile(Other, scaleSecondProfile);
if (null == This) return scaledProfileOther;
Profile newProf = new Profile();
newProf.allVCs = new List<verticalCurve>();
This.vcIndex = 0; Other.vcIndex = 0;
Profile prof1; Profile prof2;
/* if profile stations do not overlap, append end to end */
if (This.EndProfTrueStation <= Other.BeginProfTrueStation ||
Other.EndProfTrueStation <= This.BeginProfTrueStation)
{
if (This.EndProfTrueStation <= Other.BeginProfTrueStation)
{
prof1 = This;
prof2 = Other;
}
else
{
prof1 = Other;
prof2 = This;
}
foreach (var vc in prof1.allVCs)
{
newProf.allVCs.Add(new verticalCurve(vc));
}
double gapLength = prof2.BeginProfTrueStation - prof1.EndProfTrueStation;
if (gapLength > 0.0)
{
var gapVC = new verticalCurve();
gapVC.IsaProfileGap = true;
gapVC.BeginStation = (CogoStation) prof1.EndProfTrueStation;
gapVC.Length = gapLength;
newProf.allVCs.Add(gapVC);
}
foreach(var vc in prof2.allVCs)
{
var dupVC = new verticalCurve(vc);
dupVC.Scale(scaleSecondProfile);
newProf.allVCs.Add(dupVC);
}
newProf.BeginProfTrueStation = Math.Min(prof1.BeginProfTrueStation, prof2.BeginProfTrueStation);
newProf.EndProfTrueStation = Math.Max(prof1.EndProfTrueStation, prof2.EndProfTrueStation);
newProf.iHaveOneOrMoreVerticalCurves = prof1.iHaveOneOrMoreVerticalCurves && prof2.iHaveOneOrMoreVerticalCurves;
return newProf;
}
/* end if profile stations do not overlap, append end to end */
prof1 = This;
prof2 = scaledProfileOther;
List<CogoStation> mergedStationList = mergeStationLists(prof1, prof2);
CogoStation begSta = new CogoStation();
verticalCurve prevVC = new verticalCurve();
long count = -1;
foreach (var endSta in mergedStationList)
{
count++;
if (count == 0)
{
begSta = endSta;
newProf.BeginProfTrueStation = begSta.trueStation;
continue;
}
double? begEL1 = prof1.getElevationFromTheRight(begSta);
double? begEL2 = prof2.getElevationFromTheRight(begSta);
double? endEL1 = prof1.getElevationFromTheLeft(endSta); //start here. why is this returning null?
double? endEL2 = prof2.getElevationFromTheLeft(endSta);
double? begSlope1 = prof1.getSlopeFromTheRight(begSta);
double? begSlope2 = prof2.getSlopeFromTheRight(begSta);
double? endSlope1 = prof1.getSlopeFromTheLeft(endSta);
double? endSlope2 = prof2.getSlopeFromTheLeft(endSta);
double? Kvalue1 = prof1.getKValueFromTheRight(begSta);
double? Kvalue2 = prof2.getKValueFromTheRight(begSta);
double newBegEL = utilFunctions.addNullableDoubles(begEL1, begEL2);
double newEndEL = utilFunctions.addNullableDoubles(endEL1, endEL2);
double newBegSlope = utilFunctions.addNullableDoubles(begSlope1, begSlope2);
double newEndSlope = utilFunctions.addNullableDoubles(endSlope1, endSlope2);
double newKValue = utilFunctions.addRecipricals(Kvalue1, Kvalue2);
double length = endSta - begSta;
var newVC = new verticalCurve(begSta, newBegEL, newBegSlope, length, newKValue); // bug: add EndStation value
newProf.allVCs.Add(newVC);
if (count == 1)
{
newVC.IsBeginPINC = false;
}
else
{
prevVC.IsEndPINC = newVC.IsBeginPINC = false;
if (prevVC.EndSlope != newVC.BeginSlope)
prevVC.IsEndPINC = newVC.IsBeginPINC = true;
else if (prevVC.EndElevation != newVC.BeginElevation)
prevVC.IsEndPINC = newVC.IsBeginPINC = true;
}
prevVC = newVC;
begSta = endSta;
newProf.EndProfTrueStation = endSta.trueStation;
}
return newProf;
}
// currently untested code
public verticalCurve createVerticalCurveAsAProfileGap(CogoStation beginStation, CogoStation endStation)
{
verticalCurve returnVC = new verticalCurve();
returnVC.BeginStation = beginStation;
returnVC.BeginElevation = 0.0;
returnVC.BeginSlope = 0.0;
returnVC.EndSlope = 0.0;
returnVC.Length = endStation - beginStation;
returnVC.IsBeginPINC = returnVC.IsEndPINC = true;
returnVC.IsaProfileGap = true;
return returnVC;
}
private List<List<verticalCurve>> getRayIntersectionsOnParabolicSegment(ptsRay aRay)
{
List<List<verticalCurve>> returnListOfLists = null;
double xForZeroSlope = getXforSlopeZero();
var parabola0_0point = new { x = xForZeroSlope, elev = getElevation(this, (CogoStation) xForZeroSlope) };
/* in which m is slope of the ray, b is the y-intercept of the ray
* from y = mx + b
* k is the slope rate of change of the parabola
* from y = kx^2
* Solved into a quadratic equation, it is in the form of
* -kx^2 + mx + b = 0
*
* which then is solved by the quadratic formula:
* -m +/- sqrt(m^2 + 4kb)
* x = ----------------------
* -2k
*
* Finally, the part under the square root is called the discriminant.
* If the discriminant is negative, the roots are imaginary and
* we have no interest in those for our application. - Paul Schrum
* http://en.wikipedia.org/wiki/Quadratic_equation
* */
// Ray parts
double m = aRay.get_m();
double untransformedB = aRay.get_b();
double rayElevAtParabolaInflectionStation = (m * parabola0_0point.x) + untransformedB;
double b = rayElevAtParabolaInflectionStation - parabola0_0point.elev;
// parabola parts
double k = this.slopeRateOfChange_ / 2.0;
double discriminant = (m * m) + (4 * k * b);
if (discriminant < 0.0)
return null;
double sqrtDisc = Math.Sqrt(discriminant);
double xIntercept1;
double xIntercept2;
int sign = 1;
verticalCurve newVC = null;
xIntercept1 = ((-m + sqrtDisc) / (-2 * k)) + parabola0_0point.x;
if (true == aRay.isWithinDomain(xIntercept1) && true == this.isWithinDomain(xIntercept1))
{
if (1 == aRay.advanceDirection)
newVC = new verticalCurve((CogoStation)aRay.StartPoint.x, aRay.StartPoint.z,
aRay.Slope, xIntercept1 - aRay.StartPoint.x, Double.PositiveInfinity);
else
{
sign = -1;
newVC = new verticalCurve((CogoStation) xIntercept1, getElevation(this, (CogoStation)xIntercept1),
sign * aRay.Slope, Math.Abs(xIntercept1 - aRay.StartPoint.x), Double.PositiveInfinity);
}
if (null == returnListOfLists)
returnListOfLists = new List<List<verticalCurve>>();
List<verticalCurve> listOfVerticalCurves = new List<verticalCurve>();
listOfVerticalCurves.Add(newVC);
returnListOfLists.Add(listOfVerticalCurves);
}
if (discriminant > 0)
{
xIntercept2 = ((-m - sqrtDisc) / (-2 * k)) + parabola0_0point.x;
if (true == aRay.isWithinDomain(xIntercept2) && true == this.isWithinDomain(xIntercept2))
{
if (1 == aRay.advanceDirection)
{
sign = 1;
newVC = new verticalCurve((CogoStation)aRay.StartPoint.x, aRay.StartPoint.z,
aRay.Slope, xIntercept2 - aRay.StartPoint.x, Double.PositiveInfinity);
}
else
{
sign = -1;
newVC = new verticalCurve((CogoStation)xIntercept2, getElevation(this, (CogoStation)xIntercept2),
sign * aRay.Slope, Math.Abs(xIntercept2 - aRay.StartPoint.x), Double.PositiveInfinity);
}
if (null == returnListOfLists)
returnListOfLists = new List<List<verticalCurve>>();
List<verticalCurve> listOfVerticalCurves = new List<verticalCurve>();
listOfVerticalCurves.Add(newVC);
returnListOfLists.Add(listOfVerticalCurves);
}
}
return returnListOfLists;
}
public static double getSlope(verticalCurve aVC, CogoStation station)
{
double theSlope;
double lenSquared; double lenIntoVC;
if (aVC.IsTangent == true)
return aVC.BeginSlope;
lenIntoVC = station - aVC.BeginStation;
lenSquared = lenIntoVC * lenIntoVC;
theSlope = aVC.BeginSlope +
(lenIntoVC / (100.0 * aVC.Kvalue));
return theSlope;
}
public static double getKvalue(verticalCurve aVC, CogoStation station)
{
return aVC.Kvalue;
}
public static double getElevation(verticalCurve aVC, CogoStation station)
{
double theElevation;
double lenSquared; double lenIntoVC;
lenIntoVC = station - aVC.BeginStation;
lenSquared = lenIntoVC * lenIntoVC;
theElevation = aVC.BeginElevation +
(lenIntoVC * aVC.BeginSlope);
if (aVC.IsTangent == false)
theElevation += (lenSquared / (200.0 * aVC.Kvalue));
return theElevation;
}
// currently untested code
// candidate for deleting becuase it is not needed
public verticalCurve(verticalCurve vc1, verticalCurve vc2, CogoStation beginStation, CogoStation endStation)
{
double actualBeginStation = Math.Max(vc1.BeginStation.trueStation, Math.Max(vc2.BeginStation.trueStation, beginStation.trueStation));
double actualEndStation = Math.Min(vc1.EndStation.trueStation, Math.Min(vc2.EndStation.trueStation, endStation.trueStation));
double newLength = actualEndStation - actualBeginStation;
if(newLength == 0.0)
throw new Exception("Can't create vertical curve with Length = 0");
if(newLength < 0)
throw new Exception("Can't create vertical curve with Length < 0");
double newBeginElevation =
getElevation(vc1, (CogoStation) actualBeginStation) +
getElevation(vc2, (CogoStation) actualBeginStation);
double newEndElevation =
getElevation(vc1, (CogoStation)actualEndStation) +
getElevation(vc2, (CogoStation)actualEndStation);
double newBeginSlope =
getSlope(vc1, (CogoStation)actualBeginStation) +
getSlope(vc2, (CogoStation)actualBeginStation);
double newEndSlope =
getSlope(vc1, (CogoStation)actualEndStation) +
getSlope(vc2, (CogoStation)actualEndStation);
double testPIdistance = Profile.intersect2SlopesInX(
actualBeginStation, newBeginElevation, newBeginSlope,
actualEndStation, newEndElevation, newEndSlope);
}
public verticalCurve(verticalCurve otherVC)
{
this.BeginStation = (CogoStation) otherVC.BeginStation.trueStation;
this.BeginElevation = otherVC.BeginElevation;
this.BeginSlope = otherVC.BeginSlope;
this.EndSlope = otherVC.EndSlope;
this.Length = otherVC.Length;
this.IsBeginPINC = otherVC.IsBeginPINC;
this.IsEndPINC = otherVC.IsEndPINC;
this.IsaProfileGap = otherVC.IsaProfileGap;
}
