Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
var RhinoCompute = {
version: '0.12.0',
url: 'https://compute.rhino3d.com/',
authToken: null,
apiKey: null,
getAuthToken: function (useLocalStorage=true) {
let auth = null
if (useLocalStorage)
auth = localStorage['compute_auth']
if (auth == null) {
auth = window.prompt('Rhino Accounts auth token\nVisit https://www.rhino3d.com/compute/login')
if (auth != null && auth.length>20) {
auth = 'Bearer ' + auth
localStorage.setItem('compute_auth', auth)
}
}
return auth
},
computeFetch: function(endpoint, arglist, returnJson=true) {
let request = {
'method':'POST',
'body': JSON.stringify(arglist),
'headers': {'User-Agent': `compute.rhino3d.js/${RhinoCompute.version}`}
}
if (RhinoCompute.authToken) {
request.headers['Authorization'] = RhinoCompute.authToken
}
if (RhinoCompute.apiKey) {
request.headers['RhinoComputeKey'] = RhinoCompute.apiKey
request.headers['api_token'] = RhinoCompute.apiToken
}
let p = fetch(RhinoCompute.url+endpoint, request)
if (returnJson) return p.then(r=>r.json())
return p
},
Grasshopper: {
DataTree: class {
constructor (name) {
this.data = { 'ParamName': name, 'InnerTree': {} }
}
/**
* Append a path to this tree
* @param path (arr): a list of integers defining a path
* @param items (arr): list of data to add to the tree
*/
append (path, items) {
let key = path.join(';')
let innerTreeData = []
items.forEach(item => {
innerTreeData.push({ 'data': item })
})
this.data.InnerTree[key] = innerTreeData
}
},
/**
* Evaluate a grasshopper definition
* @param definition (str|bytearray) contents of .gh/.ghx file or
* url pointing to a grasshopper definition file
* @param trees (arr) list of DataTree instances
* @param returnJson (bool) if true, return a Promise with json data
* otherwise a Promise with Response data
*/
evaluateDefinition : function (definition, trees, returnJson=true) {
let args = {
'algo': null,
'pointer': null,
'values': null
}
if (definition.constructor === Uint8Array) {
args['algo'] = base64ByteArray(definition)
} else {
if (definition.startsWith('http')) {
args['pointer'] = definition
} else {
args['algo'] = btoa(definition)
}
}
let values = []
trees.forEach(tree => {
values.push(tree.data)
})
args['values'] = values
return RhinoCompute.computeFetch('grasshopper', args, returnJson)
}
},
zipArgs: function(multiple, ...args) {
if (!multiple) return args
if (args.length==1)
return args[0].map(function(_,i) { return [args[0][i]] })
if (args.length==2)
return args[0].map(function(_,i) { return [args[0][i],args[1][i]] })
if (args.length==3)
return args[0].map(function(_,i) {
return [args[0][i],args[1][i],args[2][i]] }
)
if (args.length==4)
return args[0].map(function(_,i) {
return [args[0][i],args[1][i],args[2][i],args[3][i]] }
)
if (args.length==5)
return args[0].map(function(_,i) {
return [args[0][i],args[1][i],args[2][i],args[3][i],args[4][i]] }
)
if (args.length==6)
return args[0].map(function(_,i) {
return [args[0][i],args[1][i],args[2][i],args[3][i],args[4][i],args[5][i]] }
)
if (args.length==7)
return args[0].map(function(_,i) {
return [args[0][i],args[1][i],args[2][i],args[3][i],args[4][i],args[5][i],args[6][i]] }
)
return args[0].map(function(_,i) {
return [args[0][i],args[1][i],args[2][i],args[3][i],args[4][i],args[5][i],args[6][i],args[7][i]] }
)
},
Extrusion : {
getWireframe : function(extrusion, multiple=false) {
let url='rhino/geometry/extrusion/getwireframe-extrusion'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, extrusion)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
},
BezierCurve : {
createCubicBeziers : function(sourceCurve, distanceTolerance, kinkTolerance, multiple=false) {
let url='rhino/geometry/beziercurve/createcubicbeziers-curve_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, sourceCurve, distanceTolerance, kinkTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBeziers : function(sourceCurve, multiple=false) {
let url='rhino/geometry/beziercurve/createbeziers-curve'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, sourceCurve)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
},
Brep : {
changeSeam : function(face, direction, parameter, tolerance, multiple=false) {
let url='rhino/geometry/brep/changeseam-brepface_int_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, face, direction, parameter, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
copyTrimCurves : function(trimSource, surfaceSource, tolerance, multiple=false) {
let url='rhino/geometry/brep/copytrimcurves-brepface_surface_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, trimSource, surfaceSource, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBaseballSphere : function(center, radius, tolerance, multiple=false) {
let url='rhino/geometry/brep/createbaseballsphere-point3d_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, center, radius, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createDevelopableLoft : function(crv0, crv1, reverse0, reverse1, density, multiple=false) {
let url='rhino/geometry/brep/createdevelopableloft-curve_curve_bool_bool_int'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, crv0, crv1, reverse0, reverse1, density)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createDevelopableLoft1 : function(rail0, rail1, fixedRulings, multiple=false) {
let url='rhino/geometry/brep/createdevelopableloft-nurbscurve_nurbscurve_point2darray'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, rail0, rail1, fixedRulings)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createPlanarBreps : function(inputLoops, multiple=false) {
let url='rhino/geometry/brep/createplanarbreps-curvearray'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, inputLoops)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createPlanarBreps1 : function(inputLoops, tolerance, multiple=false) {
let url='rhino/geometry/brep/createplanarbreps-curvearray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, inputLoops, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createPlanarBreps2 : function(inputLoop, multiple=false) {
let url='rhino/geometry/brep/createplanarbreps-curve'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, inputLoop)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createPlanarBreps3 : function(inputLoop, tolerance, multiple=false) {
let url='rhino/geometry/brep/createplanarbreps-curve_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, inputLoop, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createTrimmedSurface : function(trimSource, surfaceSource, multiple=false) {
let url='rhino/geometry/brep/createtrimmedsurface-brepface_surface'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, trimSource, surfaceSource)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createTrimmedSurface1 : function(trimSource, surfaceSource, tolerance, multiple=false) {
let url='rhino/geometry/brep/createtrimmedsurface-brepface_surface_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, trimSource, surfaceSource, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromCornerPoints : function(corner1, corner2, corner3, tolerance, multiple=false) {
let url='rhino/geometry/brep/createfromcornerpoints-point3d_point3d_point3d_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, corner1, corner2, corner3, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromCornerPoints1 : function(corner1, corner2, corner3, corner4, tolerance, multiple=false) {
let url='rhino/geometry/brep/createfromcornerpoints-point3d_point3d_point3d_point3d_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, corner1, corner2, corner3, corner4, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createEdgeSurface : function(curves, multiple=false) {
let url='rhino/geometry/brep/createedgesurface-curvearray'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curves)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createPlanarBreps4 : function(inputLoops, multiple=false) {
let url='rhino/geometry/brep/createplanarbreps-rhino.collections.curvelist'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, inputLoops)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createPlanarBreps5 : function(inputLoops, tolerance, multiple=false) {
let url='rhino/geometry/brep/createplanarbreps-rhino.collections.curvelist_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, inputLoops, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromOffsetFace : function(face, offsetDistance, offsetTolerance, bothSides, createSolid, multiple=false) {
let url='rhino/geometry/brep/createfromoffsetface-brepface_double_double_bool_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, face, offsetDistance, offsetTolerance, bothSides, createSolid)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createSolid : function(breps, tolerance, multiple=false) {
let url='rhino/geometry/brep/createsolid-breparray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, breps, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
mergeSurfaces : function(surface0, surface1, tolerance, angleToleranceRadians, multiple=false) {
let url='rhino/geometry/brep/mergesurfaces-surface_surface_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, surface0, surface1, tolerance, angleToleranceRadians)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
mergeSurfaces1 : function(brep0, brep1, tolerance, angleToleranceRadians, multiple=false) {
let url='rhino/geometry/brep/mergesurfaces-brep_brep_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep0, brep1, tolerance, angleToleranceRadians)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
mergeSurfaces2 : function(brep0, brep1, tolerance, angleToleranceRadians, point0, point1, roundness, smooth, multiple=false) {
let url='rhino/geometry/brep/mergesurfaces-brep_brep_double_double_point2d_point2d_double_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep0, brep1, tolerance, angleToleranceRadians, point0, point1, roundness, smooth)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createPatch : function(geometry, startingSurface, tolerance, multiple=false) {
let url='rhino/geometry/brep/createpatch-geometrybasearray_surface_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, geometry, startingSurface, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createPatch1 : function(geometry, uSpans, vSpans, tolerance, multiple=false) {
let url='rhino/geometry/brep/createpatch-geometrybasearray_int_int_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, geometry, uSpans, vSpans, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createPatch2 : function(geometry, startingSurface, uSpans, vSpans, trim, tangency, pointSpacing, flexibility, surfacePull, fixEdges, tolerance, multiple=false) {
let url='rhino/geometry/brep/createpatch-geometrybasearray_surface_int_int_bool_bool_double_double_double_boolarray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, geometry, startingSurface, uSpans, vSpans, trim, tangency, pointSpacing, flexibility, surfacePull, fixEdges, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createPipe : function(rail, radius, localBlending, cap, fitRail, absoluteTolerance, angleToleranceRadians, multiple=false) {
let url='rhino/geometry/brep/createpipe-curve_double_bool_pipecapmode_bool_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, rail, radius, localBlending, cap, fitRail, absoluteTolerance, angleToleranceRadians)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createPipe1 : function(rail, railRadiiParameters, radii, localBlending, cap, fitRail, absoluteTolerance, angleToleranceRadians, multiple=false) {
let url='rhino/geometry/brep/createpipe-curve_doublearray_doublearray_bool_pipecapmode_bool_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, rail, railRadiiParameters, radii, localBlending, cap, fitRail, absoluteTolerance, angleToleranceRadians)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createThickPipe : function(rail, radius0, radius1, localBlending, cap, fitRail, absoluteTolerance, angleToleranceRadians, multiple=false) {
let url='rhino/geometry/brep/createthickpipe-curve_double_double_bool_pipecapmode_bool_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, rail, radius0, radius1, localBlending, cap, fitRail, absoluteTolerance, angleToleranceRadians)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createThickPipe1 : function(rail, railRadiiParameters, radii0, radii1, localBlending, cap, fitRail, absoluteTolerance, angleToleranceRadians, multiple=false) {
let url='rhino/geometry/brep/createthickpipe-curve_doublearray_doublearray_doublearray_bool_pipecapmode_bool_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, rail, railRadiiParameters, radii0, radii1, localBlending, cap, fitRail, absoluteTolerance, angleToleranceRadians)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromSweep : function(rail, shape, closed, tolerance, multiple=false) {
let url='rhino/geometry/brep/createfromsweep-curve_curve_bool_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, rail, shape, closed, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromSweep1 : function(rail, shapes, closed, tolerance, multiple=false) {
let url='rhino/geometry/brep/createfromsweep-curve_curvearray_bool_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, rail, shapes, closed, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromSweepSegmented : function(rail, shape, closed, tolerance, multiple=false) {
let url='rhino/geometry/brep/createfromsweepsegmented-curve_curve_bool_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, rail, shape, closed, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromSweepSegmented1 : function(rail, shapes, closed, tolerance, multiple=false) {
let url='rhino/geometry/brep/createfromsweepsegmented-curve_curvearray_bool_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, rail, shapes, closed, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromSweep2 : function(rail1, rail2, shape, closed, tolerance, multiple=false) {
let url='rhino/geometry/brep/createfromsweep-curve_curve_curve_bool_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, rail1, rail2, shape, closed, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromSweep3 : function(rail1, rail2, shapes, closed, tolerance, multiple=false) {
let url='rhino/geometry/brep/createfromsweep-curve_curve_curvearray_bool_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, rail1, rail2, shapes, closed, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromSweep4 : function(rail1, rail2, shapes, start, end, closed, tolerance, rebuild, rebuildPointCount, refitTolerance, preserveHeight, multiple=false) {
let url='rhino/geometry/brep/createfromsweep-curve_curve_curvearray_point3d_point3d_bool_double_sweeprebuild_int_double_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, rail1, rail2, shapes, start, end, closed, tolerance, rebuild, rebuildPointCount, refitTolerance, preserveHeight)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromSweepInParts : function(rail1, rail2, shapes, rail_params, closed, tolerance, multiple=false) {
let url='rhino/geometry/brep/createfromsweepinparts-curve_curve_curvearray_point2darray_bool_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, rail1, rail2, shapes, rail_params, closed, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromTaperedExtrude : function(curveToExtrude, distance, direction, basePoint, draftAngleRadians, cornerType, tolerance, angleToleranceRadians, multiple=false) {
let url='rhino/geometry/brep/createfromtaperedextrude-curve_double_vector3d_point3d_double_extrudecornertype_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curveToExtrude, distance, direction, basePoint, draftAngleRadians, cornerType, tolerance, angleToleranceRadians)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromTaperedExtrude1 : function(curveToExtrude, distance, direction, basePoint, draftAngleRadians, cornerType, multiple=false) {
let url='rhino/geometry/brep/createfromtaperedextrude-curve_double_vector3d_point3d_double_extrudecornertype'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curveToExtrude, distance, direction, basePoint, draftAngleRadians, cornerType)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromTaperedExtrudeWithRef : function(curve, direction, distance, draftAngle, plane, tolerance, multiple=false) {
let url='rhino/geometry/brep/createfromtaperedextrudewithref-curve_vector3d_double_double_plane_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, direction, distance, draftAngle, plane, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBlendSurface : function(face0, edge0, domain0, rev0, continuity0, face1, edge1, domain1, rev1, continuity1, multiple=false) {
let url='rhino/geometry/brep/createblendsurface-brepface_brepedge_interval_bool_blendcontinuity_brepface_brepedge_interval_bool_blendcontinuity'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, face0, edge0, domain0, rev0, continuity0, face1, edge1, domain1, rev1, continuity1)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBlendShape : function(face0, edge0, t0, rev0, continuity0, face1, edge1, t1, rev1, continuity1, multiple=false) {
let url='rhino/geometry/brep/createblendshape-brepface_brepedge_double_bool_blendcontinuity_brepface_brepedge_double_bool_blendcontinuity'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, face0, edge0, t0, rev0, continuity0, face1, edge1, t1, rev1, continuity1)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFilletSurface : function(face0, uv0, face1, uv1, radius, extend, tolerance, multiple=false) {
let url='rhino/geometry/brep/createfilletsurface-brepface_point2d_brepface_point2d_double_bool_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, face0, uv0, face1, uv1, radius, extend, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFilletSurface1 : function(face0, uv0, face1, uv1, radius, trim, extend, tolerance, multiple=false) {
let url='rhino/geometry/brep/createfilletsurface-brepface_point2d_brepface_point2d_double_bool_bool_double_breparray_breparray'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, face0, uv0, face1, uv1, radius, trim, extend, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createChamferSurface : function(face0, uv0, radius0, face1, uv1, radius1, extend, tolerance, multiple=false) {
let url='rhino/geometry/brep/createchamfersurface-brepface_point2d_double_brepface_point2d_double_bool_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, face0, uv0, radius0, face1, uv1, radius1, extend, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createChamferSurface1 : function(face0, uv0, radius0, face1, uv1, radius1, trim, extend, tolerance, multiple=false) {
let url='rhino/geometry/brep/createchamfersurface-brepface_point2d_double_brepface_point2d_double_bool_bool_double_breparray_breparray'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, face0, uv0, radius0, face1, uv1, radius1, trim, extend, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFilletEdges : function(brep, edgeIndices, startRadii, endRadii, blendType, railType, tolerance, multiple=false) {
let url='rhino/geometry/brep/createfilletedges-brep_intarray_doublearray_doublearray_blendtype_railtype_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, edgeIndices, startRadii, endRadii, blendType, railType, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createOffsetBrep : function(brep, distance, solid, extend, tolerance, multiple=false) {
let url='rhino/geometry/brep/createoffsetbrep-brep_double_bool_bool_double_breparray_breparray'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, distance, solid, extend, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
removeFins : function(brep, multiple=false) {
let url='rhino/geometry/brep/removefins-brep'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromJoinedEdges : function(brep0, edgeIndex0, brep1, edgeIndex1, joinTolerance, multiple=false) {
let url='rhino/geometry/brep/createfromjoinededges-brep_int_brep_int_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep0, edgeIndex0, brep1, edgeIndex1, joinTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromLoft : function(curves, start, end, loftType, closed, multiple=false) {
let url='rhino/geometry/brep/createfromloft-curvearray_point3d_point3d_lofttype_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curves, start, end, loftType, closed)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromLoftRebuild : function(curves, start, end, loftType, closed, rebuildPointCount, multiple=false) {
let url='rhino/geometry/brep/createfromloftrebuild-curvearray_point3d_point3d_lofttype_bool_int'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curves, start, end, loftType, closed, rebuildPointCount)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFromLoftRefit : function(curves, start, end, loftType, closed, refitTolerance, multiple=false) {
let url='rhino/geometry/brep/createfromloftrefit-curvearray_point3d_point3d_lofttype_bool_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curves, start, end, loftType, closed, refitTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createPlanarUnion : function(breps, plane, tolerance, multiple=false) {
let url='rhino/geometry/brep/createplanarunion-breparray_plane_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, breps, plane, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createPlanarUnion1 : function(b0, b1, plane, tolerance, multiple=false) {
let url='rhino/geometry/brep/createplanarunion-brep_brep_plane_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, b0, b1, plane, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createPlanarDifference : function(b0, b1, plane, tolerance, multiple=false) {
let url='rhino/geometry/brep/createplanardifference-brep_brep_plane_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, b0, b1, plane, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createPlanarIntersection : function(b0, b1, plane, tolerance, multiple=false) {
let url='rhino/geometry/brep/createplanarintersection-brep_brep_plane_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, b0, b1, plane, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanUnion : function(breps, tolerance, multiple=false) {
let url='rhino/geometry/brep/createbooleanunion-breparray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, breps, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanUnion1 : function(breps, tolerance, manifoldOnly, multiple=false) {
let url='rhino/geometry/brep/createbooleanunion-breparray_double_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, breps, tolerance, manifoldOnly)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanIntersection : function(firstSet, secondSet, tolerance, multiple=false) {
let url='rhino/geometry/brep/createbooleanintersection-breparray_breparray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, firstSet, secondSet, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanIntersection1 : function(firstSet, secondSet, tolerance, manifoldOnly, multiple=false) {
let url='rhino/geometry/brep/createbooleanintersection-breparray_breparray_double_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, firstSet, secondSet, tolerance, manifoldOnly)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanIntersection2 : function(firstBrep, secondBrep, tolerance, multiple=false) {
let url='rhino/geometry/brep/createbooleanintersection-brep_brep_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, firstBrep, secondBrep, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanIntersection3 : function(firstBrep, secondBrep, tolerance, manifoldOnly, multiple=false) {
let url='rhino/geometry/brep/createbooleanintersection-brep_brep_double_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, firstBrep, secondBrep, tolerance, manifoldOnly)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanDifference : function(firstSet, secondSet, tolerance, multiple=false) {
let url='rhino/geometry/brep/createbooleandifference-breparray_breparray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, firstSet, secondSet, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanDifference1 : function(firstSet, secondSet, tolerance, manifoldOnly, multiple=false) {
let url='rhino/geometry/brep/createbooleandifference-breparray_breparray_double_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, firstSet, secondSet, tolerance, manifoldOnly)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanDifference2 : function(firstBrep, secondBrep, tolerance, multiple=false) {
let url='rhino/geometry/brep/createbooleandifference-brep_brep_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, firstBrep, secondBrep, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanDifference3 : function(firstBrep, secondBrep, tolerance, manifoldOnly, multiple=false) {
let url='rhino/geometry/brep/createbooleandifference-brep_brep_double_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, firstBrep, secondBrep, tolerance, manifoldOnly)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanSplit : function(firstBrep, secondBrep, tolerance, multiple=false) {
let url='rhino/geometry/brep/createbooleansplit-brep_brep_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, firstBrep, secondBrep, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanSplit1 : function(firstSet, secondSet, tolerance, multiple=false) {
let url='rhino/geometry/brep/createbooleansplit-breparray_breparray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, firstSet, secondSet, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createShell : function(brep, facesToRemove, distance, tolerance, multiple=false) {
let url='rhino/geometry/brep/createshell-brep_intarray_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, facesToRemove, distance, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
joinBreps : function(brepsToJoin, tolerance, multiple=false) {
let url='rhino/geometry/brep/joinbreps-breparray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brepsToJoin, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
mergeBreps : function(brepsToMerge, tolerance, multiple=false) {
let url='rhino/geometry/brep/mergebreps-breparray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brepsToMerge, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createContourCurves : function(brepToContour, contourStart, contourEnd, interval, multiple=false) {
let url='rhino/geometry/brep/createcontourcurves-brep_point3d_point3d_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brepToContour, contourStart, contourEnd, interval)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createContourCurves1 : function(brepToContour, sectionPlane, multiple=false) {
let url='rhino/geometry/brep/createcontourcurves-brep_plane'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brepToContour, sectionPlane)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createCurvatureAnalysisMesh : function(brep, state, multiple=false) {
let url='rhino/geometry/brep/createcurvatureanalysismesh-brep_rhino.applicationsettings.curvatureanalysissettingsstate'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, state)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
getRegions : function(brep, multiple=false) {
let url='rhino/geometry/brep/getregions-brep'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
getWireframe : function(brep, density, multiple=false) {
let url='rhino/geometry/brep/getwireframe-brep_int'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, density)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
closestPoint : function(brep, testPoint, multiple=false) {
let url='rhino/geometry/brep/closestpoint-brep_point3d'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, testPoint)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
isPointInside : function(brep, point, tolerance, strictlyIn, multiple=false) {
let url='rhino/geometry/brep/ispointinside-brep_point3d_double_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, point, tolerance, strictlyIn)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
getPointInside : function(brep, tolerance, multiple=false) {
let url='rhino/geometry/brep/getpointinside-brep_double_point3d'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
capPlanarHoles : function(brep, tolerance, multiple=false) {
let url='rhino/geometry/brep/capplanarholes-brep_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
join : function(brep, otherBrep, tolerance, compact, multiple=false) {
let url='rhino/geometry/brep/join-brep_brep_double_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, otherBrep, tolerance, compact)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
joinNakedEdges : function(brep, tolerance, multiple=false) {
let url='rhino/geometry/brep/joinnakededges-brep_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
mergeCoplanarFaces : function(brep, tolerance, multiple=false) {
let url='rhino/geometry/brep/mergecoplanarfaces-brep_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
mergeCoplanarFaces1 : function(brep, tolerance, angleTolerance, multiple=false) {
let url='rhino/geometry/brep/mergecoplanarfaces-brep_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, tolerance, angleTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
split : function(brep, cutter, intersectionTolerance, multiple=false) {
let url='rhino/geometry/brep/split-brep_brep_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, cutter, intersectionTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
split1 : function(brep, cutter, intersectionTolerance, multiple=false) {
let url='rhino/geometry/brep/split-brep_brep_double_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, cutter, intersectionTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
split2 : function(brep, cutters, intersectionTolerance, multiple=false) {
let url='rhino/geometry/brep/split-brep_breparray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, cutters, intersectionTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
split3 : function(brep, cutters, intersectionTolerance, multiple=false) {
let url='rhino/geometry/brep/split-brep_curvearray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, cutters, intersectionTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
split4 : function(brep, cutters, normal, planView, intersectionTolerance, multiple=false) {
let url='rhino/geometry/brep/split-brep_geometrybasearray_vector3d_bool_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, cutters, normal, planView, intersectionTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
trim : function(brep, cutter, intersectionTolerance, multiple=false) {
let url='rhino/geometry/brep/trim-brep_brep_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, cutter, intersectionTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
trim1 : function(brep, cutter, intersectionTolerance, multiple=false) {
let url='rhino/geometry/brep/trim-brep_plane_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, cutter, intersectionTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
unjoinEdges : function(brep, edgesToUnjoin, multiple=false) {
let url='rhino/geometry/brep/unjoinedges-brep_intarray'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, edgesToUnjoin)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
joinEdges : function(brep, edgeIndex0, edgeIndex1, joinTolerance, compact, multiple=false) {
let url='rhino/geometry/brep/joinedges-brep_int_int_double_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, edgeIndex0, edgeIndex1, joinTolerance, compact)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
transformComponent : function(brep, components, xform, tolerance, timeLimit, useMultipleThreads, multiple=false) {
let url='rhino/geometry/brep/transformcomponent-brep_componentindexarray_transform_double_double_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, components, xform, tolerance, timeLimit, useMultipleThreads)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
getArea : function(brep, multiple=false) {
let url='rhino/geometry/brep/getarea-brep'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
getArea1 : function(brep, relativeTolerance, absoluteTolerance, multiple=false) {
let url='rhino/geometry/brep/getarea-brep_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, relativeTolerance, absoluteTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
getVolume : function(brep, multiple=false) {
let url='rhino/geometry/brep/getvolume-brep'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
getVolume1 : function(brep, relativeTolerance, absoluteTolerance, multiple=false) {
let url='rhino/geometry/brep/getvolume-brep_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, relativeTolerance, absoluteTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
rebuildTrimsForV2 : function(brep, face, nurbsSurface, multiple=false) {
let url='rhino/geometry/brep/rebuildtrimsforv2-brep_brepface_nurbssurface'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, face, nurbsSurface)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
makeValidForV2 : function(brep, multiple=false) {
let url='rhino/geometry/brep/makevalidforv2-brep'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
repair : function(brep, tolerance, multiple=false) {
let url='rhino/geometry/brep/repair-brep_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
removeHoles : function(brep, tolerance, multiple=false) {
let url='rhino/geometry/brep/removeholes-brep_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
removeHoles1 : function(brep, loops, tolerance, multiple=false) {
let url='rhino/geometry/brep/removeholes-brep_componentindexarray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brep, loops, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
},
BrepFace : {
pullPointsToFace : function(brepface, points, tolerance, multiple=false) {
let url='rhino/geometry/brepface/pullpointstoface-brepface_point3darray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brepface, points, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
draftAnglePoint : function(brepface, testPoint, testAngle, pullDirection, edge, multiple=false) {
let url='rhino/geometry/brepface/draftanglepoint-brepface_point2d_double_vector3d_bool_point3d_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brepface, testPoint, testAngle, pullDirection, edge)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
removeHoles : function(brepface, tolerance, multiple=false) {
let url='rhino/geometry/brepface/removeholes-brepface_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brepface, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
shrinkSurfaceToEdge : function(brepface, multiple=false) {
let url='rhino/geometry/brepface/shrinksurfacetoedge-brepface'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brepface)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
split : function(brepface, curves, tolerance, multiple=false) {
let url='rhino/geometry/brepface/split-brepface_curvearray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brepface, curves, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
isPointOnFace : function(brepface, u, v, multiple=false) {
let url='rhino/geometry/brepface/ispointonface-brepface_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brepface, u, v)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
trimAwareIsoIntervals : function(brepface, direction, constantParameter, multiple=false) {
let url='rhino/geometry/brepface/trimawareisointervals-brepface_int_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brepface, direction, constantParameter)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
trimAwareIsoCurve : function(brepface, direction, constantParameter, multiple=false) {
let url='rhino/geometry/brepface/trimawareisocurve-brepface_int_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brepface, direction, constantParameter)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
changeSurface : function(brepface, surfaceIndex, multiple=false) {
let url='rhino/geometry/brepface/changesurface-brepface_int'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brepface, surfaceIndex)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
rebuildEdges : function(brepface, tolerance, rebuildSharedEdges, rebuildVertices, multiple=false) {
let url='rhino/geometry/brepface/rebuildedges-brepface_double_bool_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, brepface, tolerance, rebuildSharedEdges, rebuildVertices)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
},
Curve : {
getConicSectionType : function(curve, multiple=false) {
let url='rhino/geometry/curve/getconicsectiontype-curve'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createInterpolatedCurve : function(points, degree, multiple=false) {
let url='rhino/geometry/curve/createinterpolatedcurve-point3darray_int'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, points, degree)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createInterpolatedCurve1 : function(points, degree, knots, multiple=false) {
let url='rhino/geometry/curve/createinterpolatedcurve-point3darray_int_curveknotstyle'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, points, degree, knots)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createInterpolatedCurve2 : function(points, degree, knots, startTangent, endTangent, multiple=false) {
let url='rhino/geometry/curve/createinterpolatedcurve-point3darray_int_curveknotstyle_vector3d_vector3d'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, points, degree, knots, startTangent, endTangent)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createSoftEditCurve : function(curve, t, delta, length, fixEnds, multiple=false) {
let url='rhino/geometry/curve/createsofteditcurve-curve_double_vector3d_double_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, t, delta, length, fixEnds)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFilletCornersCurve : function(curve, radius, tolerance, angleTolerance, multiple=false) {
let url='rhino/geometry/curve/createfilletcornerscurve-curve_double_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, radius, tolerance, angleTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createArcBlend : function(startPt, startDir, endPt, endDir, controlPointLengthRatio, multiple=false) {
let url='rhino/geometry/curve/createarcblend-point3d_vector3d_point3d_vector3d_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, startPt, startDir, endPt, endDir, controlPointLengthRatio)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createMeanCurve : function(curveA, curveB, angleToleranceRadians, multiple=false) {
let url='rhino/geometry/curve/createmeancurve-curve_curve_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curveA, curveB, angleToleranceRadians)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createMeanCurve1 : function(curveA, curveB, multiple=false) {
let url='rhino/geometry/curve/createmeancurve-curve_curve'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curveA, curveB)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBlendCurve : function(curveA, curveB, continuity, multiple=false) {
let url='rhino/geometry/curve/createblendcurve-curve_curve_blendcontinuity'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curveA, curveB, continuity)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBlendCurve1 : function(curveA, curveB, continuity, bulgeA, bulgeB, multiple=false) {
let url='rhino/geometry/curve/createblendcurve-curve_curve_blendcontinuity_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curveA, curveB, continuity, bulgeA, bulgeB)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBlendCurve2 : function(curve0, t0, reverse0, continuity0, curve1, t1, reverse1, continuity1, multiple=false) {
let url='rhino/geometry/curve/createblendcurve-curve_double_bool_blendcontinuity_curve_double_bool_blendcontinuity'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve0, t0, reverse0, continuity0, curve1, t1, reverse1, continuity1)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createTweenCurves : function(curve0, curve1, numCurves, multiple=false) {
let url='rhino/geometry/curve/createtweencurves-curve_curve_int'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve0, curve1, numCurves)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createTweenCurves1 : function(curve0, curve1, numCurves, tolerance, multiple=false) {
let url='rhino/geometry/curve/createtweencurves-curve_curve_int_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve0, curve1, numCurves, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createTweenCurvesWithMatching : function(curve0, curve1, numCurves, multiple=false) {
let url='rhino/geometry/curve/createtweencurveswithmatching-curve_curve_int'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve0, curve1, numCurves)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createTweenCurvesWithMatching1 : function(curve0, curve1, numCurves, tolerance, multiple=false) {
let url='rhino/geometry/curve/createtweencurveswithmatching-curve_curve_int_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve0, curve1, numCurves, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createTweenCurvesWithSampling : function(curve0, curve1, numCurves, numSamples, multiple=false) {
let url='rhino/geometry/curve/createtweencurveswithsampling-curve_curve_int_int'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve0, curve1, numCurves, numSamples)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createTweenCurvesWithSampling1 : function(curve0, curve1, numCurves, numSamples, tolerance, multiple=false) {
let url='rhino/geometry/curve/createtweencurveswithsampling-curve_curve_int_int_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve0, curve1, numCurves, numSamples, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
joinCurves : function(inputCurves, multiple=false) {
let url='rhino/geometry/curve/joincurves-curvearray'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, inputCurves)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
joinCurves1 : function(inputCurves, joinTolerance, multiple=false) {
let url='rhino/geometry/curve/joincurves-curvearray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, inputCurves, joinTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
joinCurves2 : function(inputCurves, joinTolerance, preserveDirection, multiple=false) {
let url='rhino/geometry/curve/joincurves-curvearray_double_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, inputCurves, joinTolerance, preserveDirection)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
makeEndsMeet : function(curveA, adjustStartCurveA, curveB, adjustStartCurveB, multiple=false) {
let url='rhino/geometry/curve/makeendsmeet-curve_bool_curve_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curveA, adjustStartCurveA, curveB, adjustStartCurveB)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFillet : function(curve0, curve1, radius, t0Base, t1Base, multiple=false) {
let url='rhino/geometry/curve/createfillet-curve_curve_double_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve0, curve1, radius, t0Base, t1Base)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createFilletCurves : function(curve0, point0, curve1, point1, radius, join, trim, arcExtension, tolerance, angleTolerance, multiple=false) {
let url='rhino/geometry/curve/createfilletcurves-curve_point3d_curve_point3d_double_bool_bool_bool_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve0, point0, curve1, point1, radius, join, trim, arcExtension, tolerance, angleTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanUnion : function(curves, multiple=false) {
let url='rhino/geometry/curve/createbooleanunion-curvearray'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curves)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanUnion1 : function(curves, tolerance, multiple=false) {
let url='rhino/geometry/curve/createbooleanunion-curvearray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curves, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanIntersection : function(curveA, curveB, multiple=false) {
let url='rhino/geometry/curve/createbooleanintersection-curve_curve'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curveA, curveB)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanIntersection1 : function(curveA, curveB, tolerance, multiple=false) {
let url='rhino/geometry/curve/createbooleanintersection-curve_curve_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curveA, curveB, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanDifference : function(curveA, curveB, multiple=false) {
let url='rhino/geometry/curve/createbooleandifference-curve_curve'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curveA, curveB)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanDifference1 : function(curveA, curveB, tolerance, multiple=false) {
let url='rhino/geometry/curve/createbooleandifference-curve_curve_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curveA, curveB, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanDifference2 : function(curveA, subtractors, multiple=false) {
let url='rhino/geometry/curve/createbooleandifference-curve_curvearray'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curveA, subtractors)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanDifference3 : function(curveA, subtractors, tolerance, multiple=false) {
let url='rhino/geometry/curve/createbooleandifference-curve_curvearray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curveA, subtractors, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanRegions : function(curves, plane, points, combineRegions, tolerance, multiple=false) {
let url='rhino/geometry/curve/createbooleanregions-curvearray_plane_point3darray_bool_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curves, plane, points, combineRegions, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createBooleanRegions1 : function(curves, plane, combineRegions, tolerance, multiple=false) {
let url='rhino/geometry/curve/createbooleanregions-curvearray_plane_bool_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curves, plane, combineRegions, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createTextOutlines : function(text, font, textHeight, textStyle, closeLoops, plane, smallCapsScale, tolerance, multiple=false) {
let url='rhino/geometry/curve/createtextoutlines-string_string_double_int_bool_plane_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, text, font, textHeight, textStyle, closeLoops, plane, smallCapsScale, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createCurve2View : function(curveA, curveB, vectorA, vectorB, tolerance, angleTolerance, multiple=false) {
let url='rhino/geometry/curve/createcurve2view-curve_curve_vector3d_vector3d_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curveA, curveB, vectorA, vectorB, tolerance, angleTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
doDirectionsMatch : function(curveA, curveB, multiple=false) {
let url='rhino/geometry/curve/dodirectionsmatch-curve_curve'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curveA, curveB)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
projectToMesh : function(curve, mesh, direction, tolerance, multiple=false) {
let url='rhino/geometry/curve/projecttomesh-curve_mesh_vector3d_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, mesh, direction, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
projectToMesh1 : function(curve, meshes, direction, tolerance, multiple=false) {
let url='rhino/geometry/curve/projecttomesh-curve_mesharray_vector3d_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, meshes, direction, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
projectToMesh2 : function(curves, meshes, direction, tolerance, multiple=false) {
let url='rhino/geometry/curve/projecttomesh-curvearray_mesharray_vector3d_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curves, meshes, direction, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
projectToBrep : function(curve, brep, direction, tolerance, multiple=false) {
let url='rhino/geometry/curve/projecttobrep-curve_brep_vector3d_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, brep, direction, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
projectToBrep1 : function(curve, breps, direction, tolerance, multiple=false) {
let url='rhino/geometry/curve/projecttobrep-curve_breparray_vector3d_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, breps, direction, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
projectToBrep2 : function(curve, breps, direction, tolerance, multiple=false) {
let url='rhino/geometry/curve/projecttobrep-curve_breparray_vector3d_double_intarray'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, breps, direction, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
projectToBrep3 : function(curves, breps, direction, tolerance, multiple=false) {
let url='rhino/geometry/curve/projecttobrep-curvearray_breparray_vector3d_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curves, breps, direction, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
projectToBrep4 : function(curves, breps, direction, tolerance, multiple=false) {
let url='rhino/geometry/curve/projecttobrep-curvearray_breparray_vector3d_double_intarray_intarray'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curves, breps, direction, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
projectToPlane : function(curve, plane, multiple=false) {
let url='rhino/geometry/curve/projecttoplane-curve_plane'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, plane)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
pullToBrepFace : function(curve, face, tolerance, multiple=false) {
let url='rhino/geometry/curve/pulltobrepface-curve_brepface_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, face, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
planarClosedCurveRelationship : function(curveA, curveB, testPlane, tolerance, multiple=false) {
let url='rhino/geometry/curve/planarclosedcurverelationship-curve_curve_plane_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curveA, curveB, testPlane, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
planarCurveCollision : function(curveA, curveB, testPlane, tolerance, multiple=false) {
let url='rhino/geometry/curve/planarcurvecollision-curve_curve_plane_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curveA, curveB, testPlane, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
duplicateSegments : function(curve, multiple=false) {
let url='rhino/geometry/curve/duplicatesegments-curve'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
smooth : function(curve, smoothFactor, bXSmooth, bYSmooth, bZSmooth, bFixBoundaries, coordinateSystem, multiple=false) {
let url='rhino/geometry/curve/smooth-curve_double_bool_bool_bool_bool_smoothingcoordinatesystem'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, smoothFactor, bXSmooth, bYSmooth, bZSmooth, bFixBoundaries, coordinateSystem)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
smooth1 : function(curve, smoothFactor, bXSmooth, bYSmooth, bZSmooth, bFixBoundaries, coordinateSystem, plane, multiple=false) {
let url='rhino/geometry/curve/smooth-curve_double_bool_bool_bool_bool_smoothingcoordinatesystem_plane'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, smoothFactor, bXSmooth, bYSmooth, bZSmooth, bFixBoundaries, coordinateSystem, plane)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
getLocalPerpPoint : function(curve, testPoint, seedParmameter, multiple=false) {
let url='rhino/geometry/curve/getlocalperppoint-curve_point3d_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, testPoint, seedParmameter)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
getLocalPerpPoint1 : function(curve, testPoint, seedParmameter, subDomain, multiple=false) {
let url='rhino/geometry/curve/getlocalperppoint-curve_point3d_double_interval_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, testPoint, seedParmameter, subDomain)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
getLocalTangentPoint : function(curve, testPoint, seedParmameter, multiple=false) {
let url='rhino/geometry/curve/getlocaltangentpoint-curve_point3d_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, testPoint, seedParmameter)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
getLocalTangentPoint1 : function(curve, testPoint, seedParmameter, subDomain, multiple=false) {
let url='rhino/geometry/curve/getlocaltangentpoint-curve_point3d_double_interval_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, testPoint, seedParmameter, subDomain)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
inflectionPoints : function(curve, multiple=false) {
let url='rhino/geometry/curve/inflectionpoints-curve'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
maxCurvaturePoints : function(curve, multiple=false) {
let url='rhino/geometry/curve/maxcurvaturepoints-curve'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
makeClosed : function(curve, tolerance, multiple=false) {
let url='rhino/geometry/curve/makeclosed-curve_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
lcoalClosestPoint : function(curve, testPoint, seed, multiple=false) {
let url='rhino/geometry/curve/lcoalclosestpoint-curve_point3d_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, testPoint, seed)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
localClosestPoint : function(curve, testPoint, seed, multiple=false) {
let url='rhino/geometry/curve/localclosestpoint-curve_point3d_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, testPoint, seed)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
closestPoint : function(curve, testPoint, multiple=false) {
let url='rhino/geometry/curve/closestpoint-curve_point3d_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, testPoint)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
closestPoint1 : function(curve, testPoint, maximumDistance, multiple=false) {
let url='rhino/geometry/curve/closestpoint-curve_point3d_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, testPoint, maximumDistance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
closestPoints : function(curve, otherCurve, multiple=false) {
let url='rhino/geometry/curve/closestpoints-curve_curve_point3d_point3d'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, otherCurve)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
contains : function(curve, testPoint, multiple=false) {
let url='rhino/geometry/curve/contains-curve_point3d'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, testPoint)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
contains1 : function(curve, testPoint, plane, multiple=false) {
let url='rhino/geometry/curve/contains-curve_point3d_plane'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, testPoint, plane)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
contains2 : function(curve, testPoint, plane, tolerance, multiple=false) {
let url='rhino/geometry/curve/contains-curve_point3d_plane_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, testPoint, plane, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
extremeParameters : function(curve, direction, multiple=false) {
let url='rhino/geometry/curve/extremeparameters-curve_vector3d'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, direction)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createPeriodicCurve : function(curve, multiple=false) {
let url='rhino/geometry/curve/createperiodiccurve-curve'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
createPeriodicCurve1 : function(curve, smooth, multiple=false) {
let url='rhino/geometry/curve/createperiodiccurve-curve_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, smooth)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
pointAtLength : function(curve, length, multiple=false) {
let url='rhino/geometry/curve/pointatlength-curve_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, length)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
pointAtNormalizedLength : function(curve, length, multiple=false) {
let url='rhino/geometry/curve/pointatnormalizedlength-curve_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, length)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
perpendicularFrameAt : function(curve, t, multiple=false) {
let url='rhino/geometry/curve/perpendicularframeat-curve_double_plane'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, t)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
getPerpendicularFrames : function(curve, parameters, multiple=false) {
let url='rhino/geometry/curve/getperpendicularframes-curve_doublearray'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, parameters)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
getLength : function(curve, multiple=false) {
let url='rhino/geometry/curve/getlength-curve'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
getLength1 : function(curve, fractionalTolerance, multiple=false) {
let url='rhino/geometry/curve/getlength-curve_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, fractionalTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
getLength2 : function(curve, subdomain, multiple=false) {
let url='rhino/geometry/curve/getlength-curve_interval'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, subdomain)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
getLength3 : function(curve, fractionalTolerance, subdomain, multiple=false) {
let url='rhino/geometry/curve/getlength-curve_double_interval'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, fractionalTolerance, subdomain)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
isShort : function(curve, tolerance, multiple=false) {
let url='rhino/geometry/curve/isshort-curve_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
isShort1 : function(curve, tolerance, subdomain, multiple=false) {
let url='rhino/geometry/curve/isshort-curve_double_interval'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, tolerance, subdomain)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
removeShortSegments : function(curve, tolerance, multiple=false) {
let url='rhino/geometry/curve/removeshortsegments-curve_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
lengthParameter : function(curve, segmentLength, multiple=false) {
let url='rhino/geometry/curve/lengthparameter-curve_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, segmentLength)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
lengthParameter1 : function(curve, segmentLength, fractionalTolerance, multiple=false) {
let url='rhino/geometry/curve/lengthparameter-curve_double_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, segmentLength, fractionalTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
lengthParameter2 : function(curve, segmentLength, subdomain, multiple=false) {
let url='rhino/geometry/curve/lengthparameter-curve_double_double_interval'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, segmentLength, subdomain)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
lengthParameter3 : function(curve, segmentLength, fractionalTolerance, subdomain, multiple=false) {
let url='rhino/geometry/curve/lengthparameter-curve_double_double_double_interval'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, segmentLength, fractionalTolerance, subdomain)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
normalizedLengthParameter : function(curve, s, multiple=false) {
let url='rhino/geometry/curve/normalizedlengthparameter-curve_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, s)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
normalizedLengthParameter1 : function(curve, s, fractionalTolerance, multiple=false) {
let url='rhino/geometry/curve/normalizedlengthparameter-curve_double_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, s, fractionalTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
normalizedLengthParameter2 : function(curve, s, subdomain, multiple=false) {
let url='rhino/geometry/curve/normalizedlengthparameter-curve_double_double_interval'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, s, subdomain)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
normalizedLengthParameter3 : function(curve, s, fractionalTolerance, subdomain, multiple=false) {
let url='rhino/geometry/curve/normalizedlengthparameter-curve_double_double_double_interval'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, s, fractionalTolerance, subdomain)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
normalizedLengthParameters : function(curve, s, absoluteTolerance, multiple=false) {
let url='rhino/geometry/curve/normalizedlengthparameters-curve_doublearray_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, s, absoluteTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
normalizedLengthParameters1 : function(curve, s, absoluteTolerance, fractionalTolerance, multiple=false) {
let url='rhino/geometry/curve/normalizedlengthparameters-curve_doublearray_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, s, absoluteTolerance, fractionalTolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
normalizedLengthParameters2 : function(curve, s, absoluteTolerance, subdomain, multiple=false) {
let url='rhino/geometry/curve/normalizedlengthparameters-curve_doublearray_double_interval'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, s, absoluteTolerance, subdomain)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
normalizedLengthParameters3 : function(curve, s, absoluteTolerance, fractionalTolerance, subdomain, multiple=false) {
let url='rhino/geometry/curve/normalizedlengthparameters-curve_doublearray_double_double_interval'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, s, absoluteTolerance, fractionalTolerance, subdomain)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
divideByCount : function(curve, segmentCount, includeEnds, multiple=false) {
let url='rhino/geometry/curve/dividebycount-curve_int_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, segmentCount, includeEnds)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
divideByCount1 : function(curve, segmentCount, includeEnds, multiple=false) {
let url='rhino/geometry/curve/dividebycount-curve_int_bool_point3darray'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, segmentCount, includeEnds)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
divideByLength : function(curve, segmentLength, includeEnds, multiple=false) {
let url='rhino/geometry/curve/dividebylength-curve_double_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, segmentLength, includeEnds)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
divideByLength1 : function(curve, segmentLength, includeEnds, reverse, multiple=false) {
let url='rhino/geometry/curve/dividebylength-curve_double_bool_bool'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, segmentLength, includeEnds, reverse)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
divideByLength2 : function(curve, segmentLength, includeEnds, multiple=false) {
let url='rhino/geometry/curve/dividebylength-curve_double_bool_point3darray'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, segmentLength, includeEnds)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
divideByLength3 : function(curve, segmentLength, includeEnds, reverse, multiple=false) {
let url='rhino/geometry/curve/dividebylength-curve_double_bool_bool_point3darray'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, segmentLength, includeEnds, reverse)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
divideEquidistant : function(curve, distance, multiple=false) {
let url='rhino/geometry/curve/divideequidistant-curve_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, distance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
divideAsContour : function(curve, contourStart, contourEnd, interval, multiple=false) {
let url='rhino/geometry/curve/divideascontour-curve_point3d_point3d_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, contourStart, contourEnd, interval)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
trim : function(curve, side, length, multiple=false) {
let url='rhino/geometry/curve/trim-curve_curveend_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, side, length)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
split : function(curve, cutter, tolerance, multiple=false) {
let url='rhino/geometry/curve/split-curve_brep_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, cutter, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
split1 : function(curve, cutter, tolerance, angleToleranceRadians, multiple=false) {
let url='rhino/geometry/curve/split-curve_brep_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, cutter, tolerance, angleToleranceRadians)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
split2 : function(curve, cutter, tolerance, multiple=false) {
let url='rhino/geometry/curve/split-curve_surface_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, cutter, tolerance)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
split3 : function(curve, cutter, tolerance, angleToleranceRadians, multiple=false) {
let url='rhino/geometry/curve/split-curve_surface_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, cutter, tolerance, angleToleranceRadians)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
extend : function(curve, t0, t1, multiple=false) {
let url='rhino/geometry/curve/extend-curve_double_double'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, t0, t1)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
extend1 : function(curve, domain, multiple=false) {
let url='rhino/geometry/curve/extend-curve_interval'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, domain)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
extend2 : function(curve, side, length, style, multiple=false) {
let url='rhino/geometry/curve/extend-curve_curveend_double_curveextensionstyle'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, side, length, style)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
extend3 : function(curve, side, style, geometry, multiple=false) {
let url='rhino/geometry/curve/extend-curve_curveend_curveextensionstyle_geometrybasearray'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, side, style, geometry)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
extend4 : function(curve, side, style, endPoint, multiple=false) {
let url='rhino/geometry/curve/extend-curve_curveend_curveextensionstyle_point3d'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, side, style, endPoint)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
extendOnSurface : function(curve, side, surface, multiple=false) {
let url='rhino/geometry/curve/extendonsurface-curve_curveend_surface'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, side, surface)
let promise = RhinoCompute.computeFetch(url, args)
return promise
},
extendOnSurface1 : function(curve, side, face, multiple=false) {
let url='rhino/geometry/curve/extendonsurface-curve_curveend_brepface'
if(multiple) url = url + '?multiple=true'
let args = RhinoCompute.zipArgs(multiple, curve, side, face)
let promise = RhinoCompute.computeFetch(url, args)
return promise