What can main return to the workbench?

[tve]

Is there a type signature for what main can return when used with the visualizer?
It seems to be able to return either a Shape or an array of {shape:Shape, name:string, color:string} objects?

And while I'm at it, any chance to enhance the STEP export functionality so multiple objects (shapes) can be placed into a single step file?

[raydeleu]

In returning an OpenCascade shape it can return at least an Edge (TopoDS_Edge), a Wire (TopoDS_Wire), a Face (TopoDS_Face) and a Solid (TopoDS_Solid). You can confirm this by creating one of these shapes and the writing this shape to the javascript console using console.log(shape). I did not manage to create all types of shapes as shown in the figure below, but I assume it should be possible.

[paulftw]

You can hack replicad code to send multiple objects to the same STEP writer. But when I tried that Cura loaded only the first shape in the generated file. Do you know if STEP actually supports multiple shapes at all?

[paulftw]

STEP does support multiple shapes, it was a problem with Cura (or whatever STEP viewer I was using last time).
Here's a demo of the hack I've mentioned.

[raydeleu]

I was researching the answer to the original question further but became confused. In the documentation of OpenCascade I found the following relationship between shape types. For each type of shape the third column shows what extruding this shape yield. For example, extruding an edge should yield a face, extruding a face should yield a solid.

shape	description	extruded shape
vertex	point in 3D space	edge
edge	connection between two vertices	face
wire	sequence of edges connected by vertices	shell
face	part of a surface, bounded by closed wires	solid
shell	set of faces connected by edges	compound of solids
solid	part of 3D space bounded by shells
compsolid	set of solids, connected by their faces
compound	set of any shapes listed above

In Replicad it seems to be different. I tried to create several types of shapes, each time writing the result to the javascript console with the command console.log(shape) to check the shape type. I found the following:

• You can create a vertex in Replicad with the command makeVertex, but I did not find any application for it as wires, lines and faces can be defined using 3D points [x,y,z].
• Replicad has edges, but these are not created by drawings or sketches. You can extract edges from shapes using the command shape.edges and turn these into a wire using the command assembleWire(edges).
• Wires can be used to define the path of sweeps, but can not always be extruded.
• A closed drawing is reported in the console as an innerShape, becomes a wire after placing it on a plane, looks like a face in the Viewer/Workbench and can be extruded into a solid.
• A shell can be created by makeOffset(face). But an offset of a solid remains a solid.

The following code shows some examples of what I described above. The commented lines resulted in an error. There are very strange errors, such as that extruding a line fails because the line is non planar?

const { draw, 
drawCircle, makeOffset, makeCircle, 
makeNonPlanarFace,assembleWire, makeFace, 
drawRectangle, makePolygon} = replicad;

const main = () => {

let line = draw().hLine(100).close().sketchOnPlane("XY")
// not really a line but a closed edge due to .close()
// when line is ended using .done() it cannot be extruded
let face = line.extrude(40,{extrusionDirection: [0,0,1]})
console.log(face) // reported as solid
//let solid = face.extrude(20,{extrusionDirection: [0,1,0]})
let edges = face.edges
console.log(edges) // reported as array with 6 items
let wire = assembleWire(edges)
console.log(wire)  // reported as wire
// let block = wire.extrude(20)  
let rectangle=drawRectangle(100,40)
console.log(rectangle)  // reported as innerShape
let rectangleEdge = rectangle.sketchOnPlane("XY")
console.log(rectangleEdge) // reported as wire
let block = rectangleEdge.extrude(40)
console.log(block)  // reported as solid

let edgeDraw = draw().hLine(100).vLine(40).hLine(-100).close()
console.log(edgeDraw)  // innerShape
let edgeLine = edgeDraw.translate([0,20]).sketchOnPlane("XY")
console.log(edgeLine)  // wire, but is visible as a face ??? 
//let edgeOffset = makeOffset(edgeLine,5)
let edgeSolid = edgeLine.clone().extrude(20) 
console.log(edgeSolid) // solid, extruding a wire should yield a shell ??? 
let bigSolid = makeOffset(edgeSolid,5)
let smallSolid = makeOffset(bigSolid,-4.99)
console.log(bigSolid)
console.log(smallSolid)

let circleWire = makeCircle(10)
console.log(circleWire) // Edge, cannot be extruded ???
let circleWire2 = makeCircle(40).translate([0,0,50])

//let circle = makeFace(circleWire)  // cannot be turned into face
let bulge = makeNonPlanarFace(circleWire)
console.log(bulge)
// let cylinder = circleWire.extrude(40)
let definedFace = makePolygon([[0,0,0],[100,0,0],[100,40,0],[0,40,0]])
console.log(definedFace)   // face
let offsetFromFace = makeOffset(definedFace,10)
console.log(offsetFromFace) // shell ! 

return [
{shape: block}, 
{shape: edgeDraw},  // drawing = innershape
{shape: edgeLine},  // drawing on plane = wire
//{shape: edgeFace},
{shape: edgeSolid}, // extruded drawing = extruded wire = solid ? 
{shape: bigSolid},  // offset of solid is solid
{shape: circleWire}, // edge
{shape: bulge},      // face
{shape: definedFace}, // face
{shape: offsetFromFace} //shell
]
}

[paulftw]

What I think is going on with non-closed (unclosed? open?) line is replicad always implicitly creates a face for you, then extrudes that face. non-planar error is most likely thrown before the extrusion call.

OCCT itself can extrude a line, and the result will be a surface. It can also extrude a square not converted into a face, the result will be a square "pipe".

Closed line works (most likely) because it can produce an enclosed face with zero area. Without a debugging session I don't have an explanation why extruding a circle fails in your example, and a bit surprised by that. However, there's more than one way to create a circle in OCCT, and some of them can be extruded.

Overall, Replicad is not a one-to-one mapping of OCCT concepts to JavaScript. It's rather an abstraction layer above OCCT (either approach has its pros and cons, only the authors know why specific decisions were made).

Where OCCT documentation really helps is in explaining why replicad code works the way it works. However, blueprints, 2d drawing API, and some other 2d logic are purely Replicad concepts.

I'd say if it's documented and works - fine, if it's documented but doesn't work - it's a bug, if it's undocumented but works - you found a case of loose type checking, file a feature request to make it an official API, otherwise you're reinforcing the Hyrum's Law 😃