テキスト比較

2 つのテキストファイルの違いを見つける

ライブエディター

空白の変更を非表示

未変更行を折りたたむ

折り返しなし

レイアウト

比較精度

テキストスタイル

シンタックスハイライト

Diffchecker Desktop Diffcheckerを実行する最も安全な方法。Diffchecker Desktopアプリを入手：あなたの差分はコンピューターから出ることはありません！Desktopを入手

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");