/////////////////////////////////////////////////////////////
// Use: Initializes parameters to create new solid bodies
// affected by the future CoilFeature for Tapered
// Thread.
/////////////////////////////////////////////////////////////
private static bool InitializeForCoilTapered(
PartDocument doc,
ThreadInfo threadInfo,
Face threadedFace,
string sketchName,
bool isInteriorFace, double pitchValue)
{
Parameter pitch =
Toolkit.FindAndUpdateParameter(doc,
"Pitch",
sketchName);
if (pitch == null)
{
return(false);
}
Parameter offset =
Toolkit.FindAndUpdateParameter(doc,
"ThreadOffset",
sketchName);
if (offset == null)
{
return(false);
}
Parameter major =
Toolkit.FindAndUpdateParameter(doc,
"MajorRadius",
sketchName);
if (major == null)
{
return(false);
}
Parameter minor =
Toolkit.FindAndUpdateParameter(doc,
"MinorRadius",
sketchName);
if (minor == null)
{
return(false);
}
pitch.Value = pitchValue;
offset.Value = 0;
double majorRad = 0;
major.Value = (isInteriorFace ? 0 : majorRad);
doc.Update();
double minorRad =
(isInteriorFace ?
majorRad + Math.Abs((double)minor.Value) :
Math.Abs((double)minor.Value));
bool ret = ThreadWorker.CreateCoilBodyTapered(doc,
threadInfo,
threadedFace,
Math.Abs(majorRad - minorRad),
isInteriorFace);
return(ret);
}
/////////////////////////////////////////////////////////////
// Use: Modelizes a Standard ThreadFeature.
//
/////////////////////////////////////////////////////////////
public static bool ModelizeThreadStandard(PartDocument doc,
PartFeature feature,
PlanarSketch templateSketch,
ThreadInfo threadInfo,
Face threadedFace,
double extraPitch)
{
Transaction Tx =
_Application.TransactionManager.StartTransaction(
doc as _Document,
"Modelizing Thread " + feature.Name);
try
{
double pitch =
ThreadWorker.GetThreadPitch(threadInfo);
Vector threadDirection =
threadInfo.ThreadDirection;
bool isInteriorFace =
Toolkit.IsInteriorFace(threadedFace);
Point basePoint =
threadInfo.ThreadBasePoints[1] as Point;
if (isInteriorFace)
{
Vector normal =
Toolkit.GetOrthoVector(
threadDirection.AsUnitVector()).AsVector();
normal.ScaleBy(
ThreadWorker.GetThreadMajorRadiusStandard(
threadedFace));
basePoint.TranslateBy(normal);
}
PlanarSketch newSketch = Toolkit.InsertSketch(doc,
templateSketch,
threadDirection.AsUnitVector(),
Toolkit.GetOrthoVector(
threadDirection.AsUnitVector()),
basePoint);
Point coilBase =
threadInfo.ThreadBasePoints[1] as Point;
bool rightHanded = threadInfo.RightHanded;
double taper = 0;
if (!ThreadWorker.InitializeForCoilStandard(doc,
threadInfo,
threadedFace,
newSketch.Name,
isInteriorFace, pitch))
{
Tx.Abort();
return(false);
}
Profile profile =
newSketch.Profiles.AddForSolid(true, null, null);
if (!ThreadWorker.CreateCoilFeature(doc,
profile,
threadDirection,
coilBase,
rightHanded,
taper,
pitch,
extraPitch))
{
Tx.Abort();
return(false);
}
newSketch.Shared = false;
feature.Suppressed = true;
Tx.End();
return(true);
}
catch
{
Tx.Abort();
return(false);
}
}
/////////////////////////////////////////////////////////////
// Use: Modelizes a Tapered ThreadFeature.
//
/////////////////////////////////////////////////////////////
public static bool ModelizeThreadTapered(PartDocument doc,
PartFeature feature,
PlanarSketch templateSketch,
ThreadInfo threadInfo,
Face threadedFace,
double extraPitch)
{
Transaction Tx =
_Application.TransactionManager.StartGlobalTransaction(
doc as _Document,
"Modelizing Thread ");
try
{
double pitch =
ThreadWorker.GetThreadPitch(threadInfo);
Vector threadDirection =
threadInfo.ThreadDirection;
Point coilBase =
threadInfo.ThreadBasePoints[1] as Point;
bool isInteriorFace =
Toolkit.IsInteriorFace(threadedFace);
Line sideDir =
ThreadWorker.GetThreadSideDirection(
threadInfo,
threadedFace);
Vector sketchYAxis =
sideDir.RootPoint.VectorTo(coilBase);
sketchYAxis.ScaleBy((isInteriorFace ? -1.0 : 1.0));
PlanarSketch newSketch = Toolkit.InsertSketch(doc,
templateSketch,
sideDir.Direction,
sketchYAxis.AsUnitVector(),
sideDir.RootPoint);
bool rightHanded = threadInfo.RightHanded;
bool IsExpanding = ThreadWorker.IsExpanding(
threadInfo,
threadedFace);
double taper =
Math.Abs(threadDirection.AngleTo(
sideDir.Direction.AsVector()))
* (IsExpanding ? 1.0 : -1.0);
if (!ThreadWorker.InitializeForCoilTapered(doc,
threadInfo,
threadedFace,
newSketch.Name,
isInteriorFace, pitch))
{
Tx.Abort();
return(false);
}
Profile profile =
newSketch.Profiles.AddForSolid(true,
null,
null);
if (!ThreadWorker.CreateCoilFeature(doc,
profile,
threadDirection,
coilBase,
rightHanded,
taper,
pitch,
extraPitch))
{
Tx.Abort();
return(false);
}
newSketch.Shared = false;
feature.Suppressed = true;
Tx.End();
return(true);
}
catch
{
try
{
Tx.Abort();
return(false);
}
catch
{
return(false);
}
}
}
