/////////////////////////////////////////////////////////////
// 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: 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: Creates new solid bodies affected by the future
// CoilFeature for Tapered Thread.
/////////////////////////////////////////////////////////////
private static bool CreateCoilBodyTapered(PartDocument doc,
ThreadInfo threadInfo,
Face threadedFace,
double depth,
bool isInteriorFace)
{
try
{
PartComponentDefinition compDef =
doc.ComponentDefinition;
Vector direction = threadInfo.ThreadDirection;
Point basePoint =
threadInfo.ThreadBasePoints[1] as Point;
Point endPoint = _Tg.CreatePoint(
basePoint.X + direction.X,
basePoint.Y + direction.Y,
basePoint.Z + direction.Z);
UnitVector yAxis = direction.AsUnitVector();
UnitVector xAxis = Toolkit.GetOrthoVector(yAxis);
WorkPoint wpt = compDef.WorkPoints.AddFixed(basePoint,
_ConstructionWorkFeature);
WorkPlane wpl = compDef.WorkPlanes.AddFixed(basePoint,
xAxis, yAxis, _ConstructionWorkFeature);
WorkAxis xWa = compDef.WorkAxes.AddFixed(basePoint,
xAxis, _ConstructionWorkFeature);
WorkAxis yWa = compDef.WorkAxes.AddFixed(basePoint,
yAxis, _ConstructionWorkFeature);
PlanarSketch sketch =
compDef.Sketches.AddWithOrientation(wpl,
xWa, true, true, wpt, false);
Cone cone = threadedFace.Geometry as Cone;
double revDepth =
depth / Math.Cos(cone.HalfAngle) *
(isInteriorFace ? -1.0 : 1.0);
Line l1 = Toolkit.GetFaceSideDirection(threadedFace, xAxis);
Line l2 = _Tg.CreateLine(basePoint, xAxis.AsVector());
Line l3 = _Tg.CreateLine(endPoint, xAxis.AsVector());
Point p1 = l1.IntersectWithCurve(l2, 0.0001)[1] as Point;
Point p2 = l1.IntersectWithCurve(l3, 0.0001)[1] as Point;
Point p3 = _Tg.CreatePoint(
p2.X - xAxis.X * revDepth,
p2.Y - xAxis.Y * revDepth,
p2.Z - xAxis.Z * revDepth);
Point p4 = _Tg.CreatePoint(
p1.X - xAxis.X * revDepth,
p1.Y - xAxis.Y * revDepth,
p1.Z - xAxis.Z * revDepth);
SketchPoint skp1 = sketch.SketchPoints.Add(
sketch.ModelToSketchSpace(p1), false);
SketchPoint skp2 = sketch.SketchPoints.Add(
sketch.ModelToSketchSpace(p2), false);
SketchPoint skp3 = sketch.SketchPoints.Add(
sketch.ModelToSketchSpace(p3), false);
SketchPoint skp4 = sketch.SketchPoints.Add(
sketch.ModelToSketchSpace(p4), false);
sketch.SketchLines.AddByTwoPoints(skp1, skp2);
sketch.SketchLines.AddByTwoPoints(skp2, skp3);
sketch.SketchLines.AddByTwoPoints(skp3, skp4);
sketch.SketchLines.AddByTwoPoints(skp4, skp1);
Profile profile = sketch.Profiles.AddForSolid(true,
null, null);
RevolveFeature rev1 =
compDef.Features.RevolveFeatures.AddFull(
profile,
yWa,
PartFeatureOperationEnum.kCutOperation);
sketch = compDef.Sketches.AddWithOrientation(wpl,
xWa, true, true, wpt, false);
skp1 = sketch.SketchPoints.Add(
sketch.ModelToSketchSpace(p1), false);
skp2 = sketch.SketchPoints.Add(
sketch.ModelToSketchSpace(p2), false);
skp3 = sketch.SketchPoints.Add(
sketch.ModelToSketchSpace(p3), false);
skp4 = sketch.SketchPoints.Add(
sketch.ModelToSketchSpace(p4), false);
sketch.SketchLines.AddByTwoPoints(skp1, skp2);
sketch.SketchLines.AddByTwoPoints(skp2, skp3);
sketch.SketchLines.AddByTwoPoints(skp3, skp4);
sketch.SketchLines.AddByTwoPoints(skp4, skp1);
profile = sketch.Profiles.AddForSolid(true, null, null);
RevolveFeature rev2 =
compDef.Features.RevolveFeatures.AddFull(
profile,
yWa,
PartFeatureOperationEnum.kNewBodyOperation);
return(true);
}
catch
{
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);
}
}
}
