protected override void Process(IFCAnyHandle ifcFaceSurface)
{
base.Process(ifcFaceSurface);
// Only allow IfcFaceSurface for certain supported surfaces.
IFCAnyHandle faceSurface = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcFaceSurface, "FaceSurface", false);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(faceSurface))
{
FaceSurface = IFCSurface.ProcessIFCSurface(faceSurface);
bool validSurface = (FaceSurface is IFCPlane) || (FaceSurface is IFCCylindricalSurface) || (FaceSurface is IFCBSplineSurface) ||
(FaceSurface is IFCSurfaceOfLinearExtrusion) || (FaceSurface is IFCSurfaceOfRevolution);
if (!validSurface)
{
Importer.TheLog.LogError(ifcFaceSurface.StepId,
"cannot handle IfcFaceSurface with FaceSurface of type " + IFCAnyHandleUtil.GetEntityType(faceSurface).ToString(), true);
}
}
bool found = false;
bool sameSense = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcFaceSurface, "SameSense", out found);
if (found)
{
SameSense = sameSense;
}
else
{
Importer.TheLog.LogWarning(ifcFaceSurface.StepId,
"cannot find SameSense attribute, defaulting to true", false);
SameSense = true;
}
}
private IFCCurve ProcessIFCCompositeCurveSegment(IFCAnyHandle ifcCurveSegment)
{
bool found = false;
bool sameSense = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcCurveSegment, "SameSense", out found);
if (!found)
{
sameSense = true;
}
IFCAnyHandle ifcParentCurve = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcCurveSegment, "ParentCurve", true);
IFCCurve parentCurve = null;
using (TemporaryVerboseLogging logger = new TemporaryVerboseLogging())
{
parentCurve = IFCCurve.ProcessIFCCurve(ifcParentCurve);
}
if (parentCurve == null)
{
Importer.TheLog.LogWarning(ifcCurveSegment.StepId, "Error processing ParentCurve (#" + ifcParentCurve.StepId + ") for IfcCompositeCurveSegment; this may be repairable.", false);
return(null);
}
if (parentCurve.IsEmpty())
{
Importer.TheLog.LogWarning(ifcCurveSegment.StepId, "Error processing ParentCurve (#" + ifcParentCurve.StepId + ") for IfcCompositeCurveSegment; this may be repairable.", false);
return(null);
}
return(parentCurve);
}
/// <summary>
/// Processes IfcGridAxis attributes.
/// </summary>
/// <param name="ifcGridAxis">The IfcGridAxis handle.</param>
protected override void Process(IFCAnyHandle ifcGridAxis)
{
base.Process(ifcGridAxis);
AxisTag = IFCImportHandleUtil.GetOptionalStringAttribute(ifcGridAxis, "AxisTag", null);
IFCAnyHandle axisCurve = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcGridAxis, "AxisCurve", true);
AxisCurve = IFCCurve.ProcessIFCCurve(axisCurve);
bool found = false;
bool sameSense = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcGridAxis, "SameSense", out found);
SameSense = found ? sameSense : true;
// We are going to check if this grid axis is a vertical duplicate of any existing axis.
// If so, we will throw an exception so that we don't create duplicate grids.
// We will only initialize these values if we actually intend to use them below.
IList <Curve> curves = null;
int curveCount = 0;
ElementId gridId = ElementId.InvalidElementId;
if (Importer.TheCache.GridNameToElementMap.TryGetValue(AxisTag, out gridId))
{
Grid grid = IFCImportFile.TheFile.Document.GetElement(gridId) as Grid;
if (grid != null)
{
IList <Curve> otherCurves = new List <Curve>();
Curve gridCurve = grid.Curve;
if (gridCurve != null)
{
otherCurves.Add(gridCurve);
int matchingGridId = FindMatchingGrid(otherCurves, grid.Id.IntegerValue, ref curves, ref curveCount);
if (matchingGridId != -1)
{
Importer.TheCache.UseGrid(grid);
CreatedElementId = grid.Id;
return;
}
}
}
}
IDictionary <string, IFCGridAxis> gridAxes = IFCImportFile.TheFile.IFCProject.GridAxes;
IFCGridAxis gridAxis = null;
if (gridAxes.TryGetValue(AxisTag, out gridAxis))
{
int matchingGridId = FindMatchingGrid(gridAxis, ref curves, ref curveCount);
if (matchingGridId != -1)
{
DuplicateAxisId = matchingGridId;
return;
}
}
gridAxes.Add(new KeyValuePair <string, IFCGridAxis>(AxisTag, this));
}
private void ProcessIFCCompositeCurveSegment(IFCAnyHandle ifcCurveSegment)
{
bool found = false;
bool sameSense = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcCurveSegment, "SameSense", out found);
if (!found)
{
sameSense = true;
}
IFCAnyHandle parentCurve = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcCurveSegment, "ParentCurve", true);
IFCCurve ifcParentCurve = IFCCurve.ProcessIFCCurve(parentCurve);
if (ifcParentCurve == null)
{
IFCImportFile.TheLog.LogError(ifcCurveSegment.StepId, "Error processing ParentCurve for IfcCompositeCurveSegment.", false);
return;
}
bool hasCurve = (ifcParentCurve.Curve != null);
bool hasCurveLoop = (ifcParentCurve.CurveLoop != null);
if (!hasCurve && !hasCurveLoop)
{
IFCImportFile.TheLog.LogError(ifcCurveSegment.StepId, "Error processing ParentCurve for IfcCompositeCurveSegment.", false);
return;
}
else
{
// The CurveLoop here is from the parent IfcCurve, which is the IfcCompositeCurve, which will correspond to a CurveLoop.
// IfcCompositiveCurveSegment may be either a curve or a curveloop, which we want to append to the parent curveloop.
if (CurveLoop == null)
{
CurveLoop = new CurveLoop();
}
}
try
{
if (hasCurve)
{
AddCurveToLoop(CurveLoop, ifcParentCurve.Curve, !sameSense, true);
}
else if (hasCurveLoop)
{
foreach (Curve subCurve in ifcParentCurve.CurveLoop)
{
AddCurveToLoop(CurveLoop, subCurve, !sameSense, true);
}
}
}
catch (Exception ex)
{
IFCImportFile.TheLog.LogError(ifcParentCurve.Id, ex.Message, true);
}
}
private IList <Curve> ProcessIFCCompositeCurveSegment(IFCAnyHandle ifcCurveSegment)
{
bool found = false;
bool sameSense = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcCurveSegment, "SameSense", out found);
if (!found)
{
sameSense = true;
}
IFCAnyHandle ifcParentCurve = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcCurveSegment, "ParentCurve", true);
IFCCurve parentCurve = null;
using (TemporaryVerboseLogging logger = new TemporaryVerboseLogging())
{
parentCurve = IFCCurve.ProcessIFCCurve(ifcParentCurve);
}
if (parentCurve == null)
{
Importer.TheLog.LogWarning(ifcCurveSegment.StepId, "Error processing ParentCurve (#" + ifcParentCurve.StepId + ") for IfcCompositeCurveSegment; this may be repairable.", false);
return(null);
}
bool hasCurve = (parentCurve.Curve != null);
bool hasCurveLoop = (parentCurve.CurveLoop != null);
if (!hasCurve && !hasCurveLoop)
{
Importer.TheLog.LogWarning(ifcCurveSegment.StepId, "Error processing ParentCurve (#" + ifcParentCurve.StepId + ") for IfcCompositeCurveSegment; this may be repairable.", false);
return(null);
}
IList <Curve> curveSegments = new List <Curve>();
if (hasCurve)
{
curveSegments.Add(parentCurve.Curve);
}
else if (hasCurveLoop)
{
foreach (Curve subCurve in parentCurve.CurveLoop)
{
curveSegments.Add(subCurve);
}
}
return(curveSegments);
}
protected override void Process(IFCAnyHandle ifcEdgeCurve)
{
base.Process(ifcEdgeCurve);
IFCAnyHandle edgeGeometry = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcEdgeCurve, "EdgeGeometry", true);
EdgeGeometry = IFCCurve.ProcessIFCCurve(edgeGeometry);
bool found = false;
bool sameSense = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcEdgeCurve, "SameSense", out found);
if (found)
{
SameSense = sameSense;
}
else
{
Importer.TheLog.LogWarning(ifcEdgeCurve.StepId, "Cannot find SameSense attribute, defaulting to true", false);
SameSense = true;
}
}
override protected void Process(IFCAnyHandle ifcOrientedEdge)
{
base.Process(ifcOrientedEdge);
IFCAnyHandle edgeElement = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcOrientedEdge, "EdgeElement", true);
EdgeElement = IFCEdge.ProcessIFCEdge(edgeElement);
bool found = false;
bool orientation = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcOrientedEdge, "Orientation", out found);
if (found)
{
Orientation = orientation;
}
else
{
Importer.TheLog.LogWarning(ifcOrientedEdge.StepId, "Cannot find Orientation attribute, defaulting to true", false);
Orientation = true;
}
}
override protected void Process(IFCAnyHandle ifcOrientedEdge)
{
base.Process(ifcOrientedEdge);
IFCAnyHandle edgeElement = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcOrientedEdge, "EdgeElement", true);
EdgeElement = IFCEdge.ProcessIFCEdge(edgeElement);
bool found = false;
bool orientation = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcOrientedEdge, "Orientation", out found);
if (found)
{
Orientation = orientation;
}
else
{
Importer.TheLog.LogWarning(ifcOrientedEdge.StepId, "Cannot find Orientation attribute, defaulting to true", false);
Orientation = true;
}
// ODA Toolkit doesn't support derived attributes. Set EdgeStart and EdgeEnd
// if they haven't been set.
if (EdgeStart == null)
{
EdgeStart = Orientation ? EdgeElement.EdgeStart : EdgeElement.EdgeEnd;
if (EdgeStart == null)
{
Importer.TheLog.LogError(ifcOrientedEdge.StepId, "Cannot find the starting vertex", true);
}
}
if (EdgeEnd == null)
{
EdgeEnd = Orientation ? EdgeElement.EdgeEnd : EdgeElement.EdgeStart;
if (EdgeEnd == null)
{
Importer.TheLog.LogError(ifcOrientedEdge.StepId, "Cannot find the ending vertex", true);
}
}
}
override protected void Process(IFCAnyHandle solid)
{
base.Process(solid);
bool found = false;
bool agreementFlag = IFCImportHandleUtil.GetRequiredBooleanAttribute(solid, "AgreementFlag", out found);
if (found)
{
AgreementFlag = agreementFlag;
}
IFCAnyHandle baseSurface = IFCImportHandleUtil.GetRequiredInstanceAttribute(solid, "BaseSurface", true);
BaseSurface = IFCSurface.ProcessIFCSurface(baseSurface);
if (!(BaseSurface is IFCPlane))
{
Importer.TheLog.LogUnhandledSubTypeError(baseSurface, IFCEntityType.IfcSurface, true);
}
if (IFCAnyHandleUtil.IsValidSubTypeOf(solid, IFCEntityType.IfcPolygonalBoundedHalfSpace))
{
IFCAnyHandle position = IFCImportHandleUtil.GetRequiredInstanceAttribute(solid, "Position", false);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(position))
{
BaseBoundingCurveTransform = IFCLocation.ProcessIFCAxis2Placement(position);
}
else
{
BaseBoundingCurveTransform = Transform.Identity;
}
IFCAnyHandle boundaryCurveHandle = IFCImportHandleUtil.GetRequiredInstanceAttribute(solid, "PolygonalBoundary", true);
BaseBoundingCurve = IFCCurve.ProcessIFCCurve(boundaryCurveHandle);
if (BaseBoundingCurve == null || BaseBoundingCurve.GetTheCurveLoop() == null)
{
Importer.TheLog.LogError(Id, "IfcPolygonalBoundedHalfSpace has an invalid boundary, ignoring.", true);
}
}
}
protected override void Process(IFCAnyHandle ifcCurve)
{
base.Process(ifcCurve);
bool found = false;
bool sameSense = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcCurve, "SenseAgreement", out found);
if (!found)
{
sameSense = true;
}
IFCAnyHandle basisCurve = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcCurve, "BasisCurve", true);
IFCCurve ifcBasisCurve = IFCCurve.ProcessIFCCurve(basisCurve);
if (ifcBasisCurve == null || (ifcBasisCurve.IsEmpty()))
{
// LOG: ERROR: Error processing BasisCurve # for IfcTrimmedCurve #.
return;
}
if (ifcBasisCurve.Curve == null)
{
// LOG: ERROR: Expected a single curve, not a curve loop for BasisCurve # for IfcTrimmedCurve #.
return;
}
IFCData trim1 = ifcCurve.GetAttribute("Trim1");
if (trim1.PrimitiveType != IFCDataPrimitiveType.Aggregate)
{
// LOG: ERROR: Invalid data type for Trim1 attribute for IfcTrimmedCurve #.
return;
}
IFCData trim2 = ifcCurve.GetAttribute("Trim2");
if (trim2.PrimitiveType != IFCDataPrimitiveType.Aggregate)
{
// LOG: ERROR: Invalid data type for Trim1 attribute for IfcTrimmedCurve #.
return;
}
// Note that these are the "unprocessed" values. These can be used for, e.g., adding up the IFC parameter length
// of the file, to account for export errors. The "processed" values can be determined from the Revit curves.
Trim1 = GetRawTrimParameter(trim1);
Trim2 = GetRawTrimParameter(trim2);
IFCTrimmingPreference trimPreference = IFCEnums.GetSafeEnumerationAttribute <IFCTrimmingPreference>(ifcCurve, "MasterRepresentation", IFCTrimmingPreference.Parameter);
double param1 = 0.0, param2 = 0.0;
Curve baseCurve = ifcBasisCurve.Curve;
try
{
GetTrimParameters(ifcBasisCurve.Id, trim1, trim2, baseCurve, trimPreference, out param1, out param2);
if (NeedToReverseBaseCurve(baseCurve, param1, param2, trimPreference))
{
Importer.TheLog.LogWarning(Id, "Invalid Param1 > Param2 for non-cyclic IfcTrimmedCurve using Cartesian trimming preference, reversing.", false);
baseCurve = baseCurve.CreateReversed();
GetTrimParameters(ifcBasisCurve.Id, trim1, trim2, baseCurve, trimPreference, out param1, out param2);
}
}
catch (Exception ex)
{
Importer.TheLog.LogError(ifcCurve.StepId, ex.Message, false);
return;
}
if (MathUtil.IsAlmostEqual(param1, param2))
{
Importer.TheLog.LogError(Id, "Param1 = Param2 for IfcTrimmedCurve #, ignoring.", false);
return;
}
Curve curve = null;
if (baseCurve.IsCyclic)
{
double period = baseCurve.Period;
if (!sameSense)
{
MathUtil.Swap(ref param1, ref param2);
}
// We want to make sure both values are within period of one another.
param1 = MathUtil.PutInRange(param1, 0, period);
param2 = MathUtil.PutInRange(param2, 0, period);
if (param2 < param1)
{
param2 = MathUtil.PutInRange(param2, param1 + period / 2, period);
}
// This is effectively an unbound curve.
double numberOfPeriods = (param2 - param1) / period;
if (MathUtil.IsAlmostEqual(numberOfPeriods, Math.Round(numberOfPeriods)))
{
Importer.TheLog.LogWarning(Id, "Start and end parameters indicate a zero-length closed curve, assuming unbound is intended.", false);
curve = baseCurve;
}
else
{
curve = baseCurve.Clone();
if (!SafelyBoundCurve(curve, param1, param2))
{
return;
}
}
}
else
{
if (param1 > param2 - MathUtil.Eps())
{
Importer.TheLog.LogWarning(Id, "Param1 > Param2 for IfcTrimmedCurve #, reversing.", false);
MathUtil.Swap(ref param1, ref param2);
sameSense = !sameSense;
}
Curve copyCurve = baseCurve.Clone();
double length = param2 - param1;
if (length <= IFCImportFile.TheFile.ShortCurveTolerance)
{
string lengthAsString = IFCUnitUtil.FormatLengthAsString(length);
Importer.TheLog.LogError(Id, "curve length of " + lengthAsString + " is invalid, ignoring.", false);
return;
}
if (!SafelyBoundCurve(copyCurve, param1, param2))
{
return;
}
if (sameSense)
{
curve = copyCurve;
}
else
{
curve = copyCurve.CreateReversed();
}
}
CurveLoop curveLoop = new CurveLoop();
curveLoop.Append(curve);
SetCurveLoop(curveLoop);
}
protected override void Process(IFCAnyHandle ifcCurve)
{
base.Process(ifcCurve);
bool found = false;
bool sameSense = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcCurve, "SenseAgreement", out found);
if (!found)
{
sameSense = true;
}
IFCAnyHandle basisCurve = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcCurve, "BasisCurve", true);
IFCCurve ifcBasisCurve = IFCCurve.ProcessIFCCurve(basisCurve);
if (ifcBasisCurve == null || (ifcBasisCurve.Curve == null && ifcBasisCurve.CurveLoop == null))
{
// LOG: ERROR: Error processing BasisCurve # for IfcTrimmedCurve #.
return;
}
if (ifcBasisCurve.Curve == null)
{
// LOG: ERROR: Expected a single curve, not a curve loop for BasisCurve # for IfcTrimmedCurve #.
return;
}
IFCData trim1 = ifcCurve.GetAttribute("Trim1");
if (trim1.PrimitiveType != IFCDataPrimitiveType.Aggregate)
{
// LOG: ERROR: Invalid data type for Trim1 attribute for IfcTrimmedCurve #.
return;
}
IFCData trim2 = ifcCurve.GetAttribute("Trim2");
if (trim2.PrimitiveType != IFCDataPrimitiveType.Aggregate)
{
// LOG: ERROR: Invalid data type for Trim1 attribute for IfcTrimmedCurve #.
return;
}
IFCTrimmingPreference trimPreference = IFCEnums.GetSafeEnumerationAttribute <IFCTrimmingPreference>(ifcCurve, "MasterRepresentation", IFCTrimmingPreference.Parameter);
double param1 = 0.0, param2 = 0.0;
try
{
GetTrimParameters(trim1, trim2, ifcBasisCurve, trimPreference, out param1, out param2);
}
catch (Exception ex)
{
Importer.TheLog.LogError(ifcCurve.StepId, ex.Message, false);
return;
}
Curve baseCurve = ifcBasisCurve.Curve;
if (baseCurve.IsCyclic)
{
if (!sameSense)
{
MathUtil.Swap(ref param1, ref param2);
}
if (param2 < param1)
{
param2 = MathUtil.PutInRange(param2, param1 + Math.PI, 2 * Math.PI);
}
if (param2 - param1 > 2.0 * Math.PI - MathUtil.Eps())
{
Importer.TheLog.LogWarning(ifcCurve.StepId, "IfcTrimmedCurve length is greater than 2*PI, leaving unbound.", false);
Curve = baseCurve;
return;
}
Curve = baseCurve.Clone();
try
{
Curve.MakeBound(param1, param2);
}
catch (Exception ex)
{
if (ex.Message.Contains("too small"))
{
Curve = null;
Importer.TheLog.LogError(Id, "curve length is invalid, ignoring.", false);
return;
}
else
{
throw ex;
}
}
}
else
{
if (MathUtil.IsAlmostEqual(param1, param2))
{
Importer.TheLog.LogError(Id, "Param1 = Param2 for IfcTrimmedCurve #, ignoring.", false);
return;
}
if (param1 > param2 - MathUtil.Eps())
{
Importer.TheLog.LogWarning(Id, "Param1 > Param2 for IfcTrimmedCurve #, reversing.", false);
MathUtil.Swap(ref param1, ref param2);
return;
}
Curve copyCurve = baseCurve.Clone();
double length = param2 - param1;
if (length <= IFCImportFile.TheFile.Document.Application.ShortCurveTolerance)
{
string lengthAsString = IFCUnitUtil.FormatLengthAsString(length);
Importer.TheLog.LogError(Id, "curve length of " + lengthAsString + " is invalid, ignoring.", false);
return;
}
copyCurve.MakeBound(param1, param2);
if (sameSense)
{
Curve = copyCurve;
}
else
{
Curve = copyCurve.CreateReversed();
}
}
CurveLoop = new CurveLoop();
CurveLoop.Append(Curve);
}
private void ProcessIFCTrimmedCurve(IFCAnyHandle ifcCurve)
{
bool found = false;
bool sameSense = IFCImportHandleUtil.GetRequiredBooleanAttribute(ifcCurve, "SenseAgreement", out found);
if (!found)
{
sameSense = true;
}
IFCAnyHandle basisCurve = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcCurve, "BasisCurve", true);
IFCCurve ifcBasisCurve = IFCCurve.ProcessIFCCurve(basisCurve);
if (ifcBasisCurve == null || (ifcBasisCurve.Curve == null && ifcBasisCurve.CurveLoop == null))
{
// LOG: ERROR: Error processing BasisCurve # for IfcTrimmedCurve #.
return;
}
if (ifcBasisCurve.Curve == null)
{
// LOG: ERROR: Expected a single curve, not a curve loop for BasisCurve # for IfcTrimmedCurve #.
return;
}
IFCData trim1 = ifcCurve.GetAttribute("Trim1");
if (trim1.PrimitiveType != IFCDataPrimitiveType.Aggregate)
{
// LOG: ERROR: Invalid data type for Trim1 attribute for IfcTrimmedCurve #.
return;
}
IFCData trim2 = ifcCurve.GetAttribute("Trim2");
if (trim2.PrimitiveType != IFCDataPrimitiveType.Aggregate)
{
// LOG: ERROR: Invalid data type for Trim1 attribute for IfcTrimmedCurve #.
return;
}
string trimPreferenceAsString = IFCAnyHandleUtil.GetEnumerationAttribute(ifcCurve, "MasterRepresentation");
IFCTrimmingPreference trimPreference = IFCTrimmingPreference.Parameter;
if (trimPreferenceAsString != null)
{
trimPreference = (IFCTrimmingPreference)Enum.Parse(typeof(IFCTrimmingPreference), trimPreferenceAsString, true);
}
double param1 = 0.0, param2 = 0.0;
try
{
GetTrimParameters(trim1, trim2, ifcBasisCurve, trimPreference, out param1, out param2);
}
catch (Exception ex)
{
IFCImportFile.TheLog.LogError(ifcCurve.StepId, ex.Message, false);
return;
}
Curve baseCurve = ifcBasisCurve.Curve;
if (baseCurve.IsCyclic)
{
if (!sameSense)
{
MathUtil.Swap(ref param1, ref param2);
}
if (param2 < param1)
{
param2 = MathUtil.PutInRange(param2, param1 + Math.PI, 2 * Math.PI);
}
if (param2 - param1 > 2.0 * Math.PI - MathUtil.Eps())
{
// LOG: WARNING: #Id: IfcTrimmedCurve length is greater than 2*PI, leaving unbound.
Curve = baseCurve;
return;
}
Curve = baseCurve.Clone();
Curve.MakeBound(param1, param2);
}
else
{
if (MathUtil.IsAlmostEqual(param1, param2))
{
// LOG: ERROR: Param1 = Param2 for IfcTrimmedCurve #, ignoring.
return;
}
if (param1 > param2 - MathUtil.Eps())
{
// LOG: WARNING: Param1 > Param2 for IfcTrimmedCurve #, reversing.
MathUtil.Swap(ref param1, ref param2);
return;
}
Curve copyCurve = baseCurve.Clone();
copyCurve.MakeBound(param1, param2);
if (sameSense)
{
Curve = copyCurve;
}
else
{
Curve = copyCurve.CreateReversed();
}
}
}
