比较文本

查找两个文本文件之间的差异

实时编辑器

隐藏空白更改

折叠未更改行

关闭换行

视图

比对精度

文本样式

语法高亮

Diffchecker Desktop 运行Diffchecker最安全的方式。获取Diffchecker桌面应用：您的差异永远不会离开您的电脑！获取桌面版

Untitled diff

创建于 9年前差异永不过期

21 删除

行
总计
删除

字符
总计
删除

要继续使用此功能，请升级到 Diffchecker Pro 查看价格

357 行

56 添加

行
总计
添加

字符
总计
添加

要继续使用此功能，请升级到 Diffchecker Pro 查看价格

386 行

T-Slot Joint

This custom feature adds a bolted T-slot connection between two planar parts.

Version 1.0 - July 6, 2016 - Arul Suresh - Initial development and validation.

Version 2.0 - July 20, 2016 - Arul Suresh - Added some utility functions, lookup tables.

Initial forum release.

Version 2.1 - Sept 18, 2016 - Arul Suresh - Update to newest FS, published release.

Version 2.1.1 - Sept 18, 2016 - Arul Suresh - Document description.

Version 2.2 - April 7, 2017 - Eric Miller - Added single-hole centered spacing and multiple plane selection, and fixed handling of angled surfaces.

FeatureScript 422;

import(path : "onshape/std/geometry.fs", version : "422.0");

import(path : "4dfdd9c6856db10dd896e29b", version : "c92857bc5898d90ad6f21cc3");

import(path : "5695a84e0bdf321f1d91df84", version : "90245e5cbffb04b2d7c533ad");

import(path : "f4e7238da5afaf5a3f1498c0/962c2d4fc4ca0f12fa54d8f4/22d17eb94c85900576fbf53e", version : "130b19167f35ae1dc291873b");

annotation { "Feature Type Name" : "T-Slot Joint", "Editing Logic Function" : "tsEditLogic" }

export const tSlotJoint = defineFeature(function(context is Context, id is Id, definition is map)

precondition

{

annotation { "Name" : "Choose edge face", "Filter" : EntityType.FACE && SketchObject.NO, "MaxNumberOfPicks" : 1 }

annotation { "Name" : "Choose edge face", "Filter" : EntityType.FACE && SketchObject.NO }

definition.base is Query;

annotation { "Name" : "Standard", "Lookup Table" : tSlotTable, "UIHint" : "REMEMBER_PREVIOUS_VALUE" }

definition.connectorStandard is LookupTablePath;

annotation { "Name" : "Clearance diameter", "UIHint" : "REMEMBER_PREVIOUS_VALUE" }

isLength(definition.holeD, TSLOT_DIAMETER_LENGTH_BOUNDS);

annotation { "Name" : "Nut width", "UIHint" : "REMEMBER_PREVIOUS_VALUE" }

isLength(definition.nutW, TSLOT_NUT_W_LENGTH_BOUNDS);

annotation { "Name" : "Nut thickness", "UIHint" : "REMEMBER_PREVIOUS_VALUE" }

isLength(definition.nutT, TSLOT_NUT_T_LENGTH_BOUNDS);

annotation { "Name" : "Show nut allowance", "UIHint" : "ALWAYS_HIDDEN" }

definition.showNutA is boolean;

if (definition.showNutA)

{

annotation { "Name" : "Nut allowance" }

isLength(definition.nutA, LENGTH_BOUNDS);

}

annotation { "Name" : "Screw length", "UIHint" : "REMEMBER_PREVIOUS_VALUE" }

isLength(definition.screwLen, TSLOT_SCREWLEN_LENGTH_BOUNDS);

annotation { "Name" : "Hole termination face", "Filter" : EntityType.FACE, "MaxNumberOfPicks" : 1 }

definition.terminationFace is Query;

annotation { "Name" : "Switch start side" }

definition.switchStart is boolean;

annotation { "Name" : "Space from edge", "UIHint" : "REMEMBER_PREVIOUS_VALUE" }

isLength(definition.edgeSpace, TSLOT_EDGE_LENGTH_BOUNDS);

annotation { "Name" : "# of connectors" }

isInteger(definition.numConnectors, NUM_CONN_BOUNDS);

annotation { "Name" : "Equal spacing" }

annotation { "Name" : "Equal spacing", "Default": true }

definition.equalSpacing is boolean;

if (!definition.equalSpacing)

{

annotation { "Name" : "Spacing", "UIHint" : "REMEMBER_PREVIOUS_VALUE" }

isLength(definition.spacing, TSLOT_SPACING_LENGTH_BOUNDS);

annotation { "Name" : "Symmetric" }

definition.symmetric is boolean;

}

{

var faceInfo = getFaceInfo(context, definition);

var bases = evaluateQuery(context, definition.base);

var faceInfo;

var connectionPoints is array = getConnectionPoints(context, definition, faceInfo);

var i = 0;

for (var base in bases)

var connectionCount = 0;

for (var connPoint in connectionPoints)

{

connectionCount += 1;

i += 1;

createTSlotJoint(context, id + ("tsj" ~ connectionCount), definition, connPoint);

faceInfo = getFaceInfo(context, definition, base);

var connectionPoints is array = getConnectionPoints(context, definition, faceInfo);

var connectionCount = 0;

for (var connPoint in connectionPoints)

{

connectionCount += 1;

createTSlotJoint(context, id + ("tsj" ~ i ~ connectionCount), definition, connPoint, base);

}

});

* Creates geometry for a single T-Slot at the provided coordinate frame.

function createTSlotJoint(context is Context, id is Id, definition is map, csys is CoordSystem)

function createTSlotJoint(context is Context, id is Id, definition is map, csys is CoordSystem, base is Query)

{

var endClearance = 0.25 * definition.holeD;

// hole through continuous material

var holeSketchPlane = plane(csys.origin, csys.zAxis, csys.xAxis);

var depth = undefined;

if (evaluateQuery(context, definition.terminationFace) != [])

{

var faceCoords = evPlane(context, {

"face" : definition.terminationFace

}).origin;

depth = fromWorld(csys, faceCoords)[2];

}

else

{

depth = getContinuousDepth(context, id + "cd", {

"csys" : csys,

"D" : definition.holeD

});

}

if (definition.screwLen - depth - definition.nutT - endClearance < 0)

{

throw regenError("Screw length is too short for desired connection.", ["screwLen"]);

}

var sketch = newSketchOnPlane(context, id + "holeSketch", {

"sketchPlane" : holeSketchPlane

});

skCircle(sketch, "clearanceHole", {

"center" : vector(0, 0) * inch,

"radius" : 0.5 * definition.holeD

});

skSolve(sketch);

if (tolerantEquals(depth, 0 * meter))

{

throw regenError("Edge connection does not intersect any clamped parts.", qCreatedBy(id + "holeSketch", EntityType.EDGE));

}

extrude(context, id + "cutHole", {

"entities" : qSketchRegion(id + "holeSketch"),

"endBound" : BoundingType.BLIND,

"depth" : depth,

"operationType" : NewBodyOperationType.REMOVE

});

opDeleteBodies(context, id + "deleteHoleSketch", {

"entities" : qCreatedBy(id + "holeSketch", EntityType.BODY)

});

// At this point, hole is cut, and depth stores how much of the bolt is in clamped material

// Generate a sketch and cut out the slot for the thread/nut

var threadSketchPlane = plane(csys.origin, yAxis(csys), csys.xAxis);

var threadSketch = newSketchOnPlane(context, id + "threadsketch", {

"sketchPlane" : threadSketchPlane

});

skRectangle(threadSketch, "screwPocket", {

"firstCorner" : vector(-0.5 * definition.holeD, 0 * meter),

"secondCorner" : vector(0.5 * definition.holeD, (definition.screwLen + 2 * definition.nutA) - depth)

});

skRectangle(threadSketch, "nutPocket", {

"firstCorner" : vector(-0.5 * definition.nutW - definition.nutA, definition.screwLen - depth - endClearance - (definition.nutT + 2 * definition.nutA)),

"secondCorner" : vector(0.5 * definition.nutW + definition.nutA, definition.screwLen - depth - endClearance)

});

skSolve(threadSketch);

extrude(context, id + "threadExtrude", {

"entities" : qSketchRegion(id + "threadsketch"),

"endBound" : BoundingType.THROUGH_ALL,

"hasSecondDirection" : true,

"secondDirectionBound" : SecondDirectionBoundingType.THROUGH_ALL,

"operationType" : NewBodyOperationType.REMOVE,

"defaultScope" : false,

"booleanScope" : qOwnerBody(definition.base)

"booleanScope" : qOwnerBody(base)

});

opDeleteBodies(context, id + "deleteThreadSketch", {

"entities" : qCreatedBy(id + "threadsketch", EntityType.BODY)

});

}

* Returns a coordinate system and bounding box for the provided face

function getFaceInfo(context is Context, definition is map) returns map

function getFaceInfo(context is Context, definition is map, base is Query) returns map

{

if (size(evaluateQuery(context, definition.base)) != 1)

if (size(evaluateQuery(context, base)) != 1)

{

throw regenError("Cannot generate without edge face selection", ["base"]);

}

var facePlane = evPlane(context, {

"face" : definition.base

"face" : base

});

var defaultCSys = planeToCSys(facePlane);

var defaultCSys = planeToCSys(facePlane) as CoordSystem;

try

{

var longEdge = qNthElement(qLargest(qGeometry(qEdgeAdjacent(base, EntityType.EDGE), GeometryType.LINE)), 0);

var axis = evAxis(context, {

"axis" : longEdge

}) as Line;

defaultCSys.xAxis = axis.direction;

}

var bbox = evBox3d(context, {

"topology" : definition.base,

"topology" : base,

"cSys" : defaultCSys

});

var xrange = bbox.maxCorner[0] - bbox.minCorner[0];

var yrange = bbox.maxCorner[1] - bbox.minCorner[1];

// generate a coordinate system such that x is along the long dimension of the face

var csys is CoordSystem = coordSystem(facePlane.origin,

(xrange > yrange) ? defaultCSys.xAxis : yAxis(defaultCSys),

facePlane.normal);

bbox = evBox3d(context, {

"topology" : definition.base,

"topology" : base,

"cSys" : csys

});

return { "csys" : csys, "bbox" : bbox };

}

* Given feature parameters and face selection, generates array of points at which T-Slots will be created

function getConnectionPoints(context is Context, definition is map, faceInfo is map) returns array

{

if (definition.equalSpacing)

{

definition.symmetric = false;

var length = faceInfo.bbox.maxCorner[0] - faceInfo.bbox.minCorner[0];

definition.spacing = (length - 2 * definition.edgeSpace) / (definition.numConnectors - 1);

if (definition.numConnectors > 1)

{

definition.spacing = (length - 2 * definition.edgeSpace) / (definition.numConnectors - 1);

}

else

{

definition.edgeSpace = length / 2;

}

var coordList = makeCoordArray(context, definition, faceInfo);

if (definition.symmetric)

{

var localDefinition = definition;

localDefinition.switchStart = !localDefinition.switchStart;

var symmetricCoordList = makeCoordArray(context, localDefinition, faceInfo);

coordList = concatenateArrays([coordList, symmetricCoordList]);

}

return coordList;

}

function makeCoordArray(context is Context, definition is map, faceInfo is map) returns array

{

var coordArray is array = makeArray(definition.numConnectors);

var sense = (definition.switchStart) ? -1 : 1;

var startx = ((definition.switchStart) ? faceInfo.bbox.maxCorner[0] : faceInfo.bbox.minCorner[0]) + sense * definition.edgeSpace;

var dir = faceInfo.csys.xAxis;

var startOrigin = faceInfo.csys.origin + startx * dir;

for (var i = 0; i < definition.numConnectors; i += 1)

{

coordArray[i] = coordSystem(startOrigin + sense * definition.spacing * dir * i, dir, faceInfo.csys.zAxis);

}

return coordArray;

}

export function tsEditLogic(context is Context, id is Id, oldDefinition is map, definition is map,

isCreating is boolean, specifiedParameters is map, hiddenBodies is Query) returns map

{

if (oldDefinition.connectorStandard != definition.connectorStandard)

{

definition = updateTSDefinitionWithStandard(oldDefinition, definition);

}

definition = setToCustomIfStandardViolated(definition);

if (definition.equalSpacing)

// if (definition.equalSpacing)

{

// {

definition.numConnectors = max(2, definition.numConnectors);

// definition.numConnectors = max(2, definition.numConnectors);

}

// }

return definition;

}

export function updateTSDefinitionWithStandard(oldDefinition is map, definition is map) returns map

{

var table = getLookupTable(tSlotTable, definition.connectorStandard);

definition.showNutA = false;

for (var entry in table)

{

definition[entry.key] = lookupTableFixExpression(entry.value);

}

return definition;

}

function setToCustomIfStandardViolated(definition is map) returns map

{

var table = getLookupTable(tSlotTable, definition.connectorStandard);

if (isLookupTableViolated(definition, table))

{

definition.connectorStandard = lookupTablePath({ "standard" : "Custom" });

definition.showNutA = true;

}

return definition;

}

export const NUM_CONN_BOUNDS =

{

"min" : 1,

"max" : 500,

(unitless) : [1, 1, 500]

} as IntegerBoundSpec;

export const TSLOT_DIAMETER_LENGTH_BOUNDS =

{

"min" : -TOLERANCE.zeroLength * meter,

"max" : 500 * meter,

(inch) : [1e-4, 0.1285, 19685]

} as LengthBoundSpec;

export const TSLOT_NUT_W_LENGTH_BOUNDS =

{

"min" : -TOLERANCE.zeroLength * meter,

"max" : 500 * meter,

(inch) : [1e-4, 0.25, 19685]

} as LengthBoundSpec;

export const TSLOT_NUT_T_LENGTH_BOUNDS =

{

"min" : -TOLERANCE.zeroLength * meter,

"max" : 500 * meter,

(inch) : [1e-4, 0.09375, 19685]

} as LengthBoundSpec;

export const TSLOT_SCREWLEN_LENGTH_BOUNDS =

{

"min" : -TOLERANCE.zeroLength * meter,

"max" : 500 * meter,

(inch) : [1e-4, 0.625, 19685],

(millimeter) : 15,

(centimeter) : 1.5

} as LengthBoundSpec;

export const TSLOT_EDGE_LENGTH_BOUNDS =

{

"min" : -TOLERANCE.zeroLength * meter,

"max" : 500 * meter,

(inch) : [1e-4, 0.5, 19685],

(millimeter) : 10,

(centimeter) : 1

} as LengthBoundSpec;

export const TSLOT_SPACING_LENGTH_BOUNDS =

{

"min" : -TOLERANCE.zeroLength * meter,

"max" : 500 * meter,

(inch) : [1e-4, 0.375, 19685],

(millimeter) : 10,

(centimeter) : 1

} as LengthBoundSpec;

已保存差异

原始文本

打开文件

/*    
    T-Slot Joint
    
    This custom feature adds a bolted T-slot connection between two planar parts.

Version 1.0     - July  6, 2016 - Arul Suresh - Initial development and validation.
    Version 2.0     - July 20, 2016 - Arul Suresh - Added some utility functions, lookup tables.
                                                    Initial forum release.
    Version 2.1     - Sept 18, 2016 - Arul Suresh - Update to newest FS, published release.
    Version 2.1.1   - Sept 18, 2016 - Arul Suresh - Document description.
*/

FeatureScript 422;
import(path : "onshape/std/geometry.fs", version : "422.0");
import(path : "4dfdd9c6856db10dd896e29b", version : "c92857bc5898d90ad6f21cc3");
import(path : "f4e7238da5afaf5a3f1498c0/962c2d4fc4ca0f12fa54d8f4/22d17eb94c85900576fbf53e", version : "130b19167f35ae1dc291873b");

annotation { "Feature Type Name" : "T-Slot Joint", "Editing Logic Function" : "tsEditLogic" }
export const tSlotJoint = defineFeature(function(context is Context, id is Id, definition is map)
    precondition
    {
        annotation { "Name" : "Choose edge face", "Filter" : EntityType.FACE && SketchObject.NO, "MaxNumberOfPicks" : 1 }
        definition.base is Query;

annotation { "Name" : "Standard", "Lookup Table" : tSlotTable, "UIHint" : "REMEMBER_PREVIOUS_VALUE" }
        definition.connectorStandard is LookupTablePath;

annotation { "Name" : "Clearance diameter", "UIHint" : "REMEMBER_PREVIOUS_VALUE" }
        isLength(definition.holeD, TSLOT_DIAMETER_LENGTH_BOUNDS);

annotation { "Name" : "Nut  width", "UIHint" : "REMEMBER_PREVIOUS_VALUE" }
        isLength(definition.nutW, TSLOT_NUT_W_LENGTH_BOUNDS);

annotation { "Name" : "Nut thickness", "UIHint" : "REMEMBER_PREVIOUS_VALUE" }
        isLength(definition.nutT, TSLOT_NUT_T_LENGTH_BOUNDS);

annotation { "Name" : "Show nut allowance", "UIHint" : "ALWAYS_HIDDEN" }
        definition.showNutA is boolean;

if (definition.showNutA)
        {
            annotation { "Name" : "Nut allowance" }
            isLength(definition.nutA, LENGTH_BOUNDS);
        }

annotation { "Name" : "Screw length", "UIHint" : "REMEMBER_PREVIOUS_VALUE" }
        isLength(definition.screwLen, TSLOT_SCREWLEN_LENGTH_BOUNDS);

annotation { "Name" : "Hole termination face", "Filter" : EntityType.FACE, "MaxNumberOfPicks" : 1 }
        definition.terminationFace is Query;

annotation { "Name" : "Switch start side" }
        definition.switchStart is boolean;

annotation { "Name" : "Space from edge", "UIHint" : "REMEMBER_PREVIOUS_VALUE" }
        isLength(definition.edgeSpace, TSLOT_EDGE_LENGTH_BOUNDS);

annotation { "Name" : "# of connectors" }
        isInteger(definition.numConnectors, NUM_CONN_BOUNDS);

annotation { "Name" : "Equal spacing" }
        definition.equalSpacing is boolean;

if (!definition.equalSpacing)
        {
            annotation { "Name" : "Spacing", "UIHint" : "REMEMBER_PREVIOUS_VALUE" }
            isLength(definition.spacing, TSLOT_SPACING_LENGTH_BOUNDS);

annotation { "Name" : "Symmetric" }
            definition.symmetric is boolean;
        }
    }
    {
        var faceInfo = getFaceInfo(context, definition);

var connectionPoints is array = getConnectionPoints(context, definition, faceInfo);

var connectionCount = 0;
        for (var connPoint in connectionPoints)
        {
            connectionCount += 1;
            createTSlotJoint(context, id + ("tsj" ~ connectionCount), definition, connPoint);
        }
    });

/*
 * Creates geometry for a single T-Slot at the provided coordinate frame.
 */
function createTSlotJoint(context is Context, id is Id, definition is map, csys is CoordSystem)
{
    var endClearance = 0.25 * definition.holeD;

// hole through continuous material
    var holeSketchPlane = plane(csys.origin, csys.zAxis, csys.xAxis);

var depth = undefined;
    if (evaluateQuery(context, definition.terminationFace) != [])
    {
        var faceCoords = evPlane(context, {
                    "face" : definition.terminationFace
                }).origin;

depth = fromWorld(csys, faceCoords)[2];
    }
    else
    {
        depth = getContinuousDepth(context, id + "cd", {
                    "csys" : csys,
                    "D" : definition.holeD
                });
    }

if (definition.screwLen - depth - definition.nutT - endClearance < 0)
    {
        throw regenError("Screw length is too short for desired connection.", ["screwLen"]);
    }

var sketch = newSketchOnPlane(context, id + "holeSketch", {
            "sketchPlane" : holeSketchPlane
        });

skCircle(sketch, "clearanceHole", {
                "center" : vector(0, 0) * inch,
                "radius" : 0.5 * definition.holeD
            });

skSolve(sketch);

if (tolerantEquals(depth, 0 * meter))
    {
        throw regenError("Edge connection does not intersect any clamped parts.", qCreatedBy(id + "holeSketch", EntityType.EDGE));
    }

extrude(context, id + "cutHole", {
                "entities" : qSketchRegion(id + "holeSketch"),
                "endBound" : BoundingType.BLIND,
                "depth" : depth,
                "operationType" : NewBodyOperationType.REMOVE
            });

opDeleteBodies(context, id + "deleteHoleSketch", {
                "entities" : qCreatedBy(id + "holeSketch", EntityType.BODY)
            });

// At this point, hole is cut, and depth stores how much of the bolt is in clamped material
    // Generate a sketch and cut out the slot for the thread/nut
    var threadSketchPlane = plane(csys.origin, yAxis(csys), csys.xAxis);
    var threadSketch = newSketchOnPlane(context, id + "threadsketch", {
            "sketchPlane" : threadSketchPlane
        });

skRectangle(threadSketch, "screwPocket", {
                "firstCorner" : vector(-0.5 * definition.holeD, 0 * meter),
                "secondCorner" : vector(0.5 * definition.holeD, (definition.screwLen + 2 * definition.nutA) - depth)
            });

skRectangle(threadSketch, "nutPocket", {
                "firstCorner" : vector(-0.5 * definition.nutW - definition.nutA, definition.screwLen - depth - endClearance - (definition.nutT + 2 * definition.nutA)),
                "secondCorner" : vector(0.5 * definition.nutW + definition.nutA, definition.screwLen - depth - endClearance)
            });

skSolve(threadSketch);

extrude(context, id + "threadExtrude", {
                "entities" : qSketchRegion(id + "threadsketch"),
                "endBound" : BoundingType.THROUGH_ALL,
                "hasSecondDirection" : true,
                "secondDirectionBound" : SecondDirectionBoundingType.THROUGH_ALL,
                "operationType" : NewBodyOperationType.REMOVE,
                "defaultScope" : false,
                "booleanScope" : qOwnerBody(definition.base)
            });

opDeleteBodies(context, id + "deleteThreadSketch", {
                "entities" : qCreatedBy(id + "threadsketch", EntityType.BODY)
            });
}

/*
 * Returns a coordinate system and bounding box for the provided face
 */
function getFaceInfo(context is Context, definition is map) returns map
{
    if (size(evaluateQuery(context, definition.base)) != 1)
    {
        throw regenError("Cannot generate without edge face selection", ["base"]);
    }

var facePlane = evPlane(context, {
            "face" : definition.base
        });
    var defaultCSys = planeToCSys(facePlane);

var bbox = evBox3d(context, {
            "topology" : definition.base,
            "cSys" : defaultCSys
        });
    var xrange = bbox.maxCorner[0] - bbox.minCorner[0];
    var yrange = bbox.maxCorner[1] - bbox.minCorner[1];

// generate a coordinate system such that x is along the long dimension of the face
    var csys is CoordSystem = coordSystem(facePlane.origin,
        (xrange > yrange) ? defaultCSys.xAxis : yAxis(defaultCSys),
        facePlane.normal);

bbox = evBox3d(context, {
                "topology" : definition.base,
                "cSys" : csys
            });

return { "csys" : csys, "bbox" : bbox };
}

/*
 * Given feature parameters and face selection, generates array of points at which T-Slots will be created
 */
function getConnectionPoints(context is Context, definition is map, faceInfo is map) returns array
{
    if (definition.equalSpacing)
    {
        definition.symmetric = false;

var length = faceInfo.bbox.maxCorner[0] - faceInfo.bbox.minCorner[0];

definition.spacing = (length - 2 * definition.edgeSpace) / (definition.numConnectors - 1);
    }

var coordList = makeCoordArray(context, definition, faceInfo);

if (definition.symmetric)
    {
        var localDefinition = definition;
        localDefinition.switchStart = !localDefinition.switchStart;
        var symmetricCoordList = makeCoordArray(context, localDefinition, faceInfo);

coordList = concatenateArrays([coordList, symmetricCoordList]);
    }

return coordList;
}

function makeCoordArray(context is Context, definition is map, faceInfo is map) returns array
{
    var coordArray is array = makeArray(definition.numConnectors);

var sense = (definition.switchStart) ? -1 : 1;
    var startx = ((definition.switchStart) ? faceInfo.bbox.maxCorner[0] : faceInfo.bbox.minCorner[0]) + sense * definition.edgeSpace;
    var dir = faceInfo.csys.xAxis;

var startOrigin = faceInfo.csys.origin + startx * dir;

for (var i = 0; i < definition.numConnectors; i += 1)
    {
        coordArray[i] = coordSystem(startOrigin + sense * definition.spacing * dir * i, dir, faceInfo.csys.zAxis);
    }

return coordArray;
}

export function tsEditLogic(context is Context, id is Id, oldDefinition is map, definition is map,
    isCreating is boolean, specifiedParameters is map, hiddenBodies is Query) returns map
{
    if (oldDefinition.connectorStandard != definition.connectorStandard)
    {
        definition = updateTSDefinitionWithStandard(oldDefinition, definition);
    }
    definition = setToCustomIfStandardViolated(definition);

if (definition.equalSpacing)
    {
        definition.numConnectors = max(2, definition.numConnectors);
    }

return definition;
}

export function updateTSDefinitionWithStandard(oldDefinition is map, definition is map) returns map
{
    var table = getLookupTable(tSlotTable, definition.connectorStandard);
    definition.showNutA = false;

for (var entry in table)
    {
        definition[entry.key] = lookupTableFixExpression(entry.value);
    }

return definition;
}

function setToCustomIfStandardViolated(definition is map) returns map
{
    var table = getLookupTable(tSlotTable, definition.connectorStandard);

if (isLookupTableViolated(definition, table))
    {
        definition.connectorStandard = lookupTablePath({ "standard" : "Custom" });
        definition.showNutA = true;
    }

return definition;
}

export const NUM_CONN_BOUNDS =
{
            "min" : 1,
            "max" : 500,
            (unitless) : [1, 1, 500]
        } as IntegerBoundSpec;

export const TSLOT_DIAMETER_LENGTH_BOUNDS =
{
            "min" : -TOLERANCE.zeroLength * meter,
            "max" : 500 * meter,
            (inch) : [1e-4, 0.1285, 19685]
        } as LengthBoundSpec;

export const TSLOT_NUT_W_LENGTH_BOUNDS =
{
            "min" : -TOLERANCE.zeroLength * meter,
            "max" : 500 * meter,
            (inch) : [1e-4, 0.25, 19685]
        } as LengthBoundSpec;

export const TSLOT_NUT_T_LENGTH_BOUNDS =
{
            "min" : -TOLERANCE.zeroLength * meter,
            "max" : 500 * meter,
            (inch) : [1e-4, 0.09375, 19685]
        } as LengthBoundSpec;

export const TSLOT_SCREWLEN_LENGTH_BOUNDS =
{
            "min" : -TOLERANCE.zeroLength * meter,
            "max" : 500 * meter,
            (inch) : [1e-4, 0.625, 19685],
            (millimeter) : 15,
            (centimeter) : 1.5
        } as LengthBoundSpec;

export const TSLOT_EDGE_LENGTH_BOUNDS =
{
            "min" : -TOLERANCE.zeroLength * meter,
            "max" : 500 * meter,
            (inch) : [1e-4, 0.5, 19685],
            (millimeter) : 10,
            (centimeter) : 1
        } as LengthBoundSpec;

export const TSLOT_SPACING_LENGTH_BOUNDS =
{
            "min" : -TOLERANCE.zeroLength * meter,
            "max" : 500 * meter,
            (inch) : [1e-4, 0.375, 19685],
            (millimeter) : 10,
            (centimeter) : 1
        } as LengthBoundSpec;

更改后文本

打开文件

/*    
    T-Slot Joint
    
    This custom feature adds a bolted T-slot connection between two planar parts.

FeatureScript 422;
import(path : "onshape/std/geometry.fs", version : "422.0");
import(path : "5695a84e0bdf321f1d91df84", version : "90245e5cbffb04b2d7c533ad");
import(path : "f4e7238da5afaf5a3f1498c0/962c2d4fc4ca0f12fa54d8f4/22d17eb94c85900576fbf53e", version : "130b19167f35ae1dc291873b");