Model of forked lever

[raydeleu]

Example of a forked lever, created in Replicad. This is a translation of a model that I built earlier in CascadeStudio. However, I had to rethink the modeling approach as some functions in Replicad are different from those in CascadeStudio. For example:

• In CascadeStudio I used an offset inwards to create the cutout between the two bearings. Although Replicad seems to contain an offset function, this seems only to work on faces. It is not clear how to use this function.
• In CascadeStudio I used a fillet in the sketch of the sideview (the Y shape). In Replicad there seems to be no fillet function in the Sketcher class, so I filleted the 3D shape after extruding the sideview.

The code is shown below:

// Replicad Code to create a forked lever 
// inspired by ModelMania shape 2010 and 
// exercise created by JokoEngineering 

function main({Sketcher, sketchCircle})
{
// Parameters

let t1                  = 8;
let t2                  = 10;
let t3                  = 5;
let sep                 = 40 ;

let radius_1            = 30;
let radius_2            = 12;
let distance            = 120;
let wall_thickness      = 5;
let lever_height        = 2*sep + (4*t1); 
let fillet_cutout       = 5;
let fillet_outer        = 1;
let fillet_arms         = 5;
let depth               = lever_height + fillet_cutout;
let chamfer             = 1;
let angle               = Math.atan((sep/2+t1-t2/2)/(distance - radius_1 - radius_2 - 2*t3))*180/Math.PI; 

// function Polar(currentPoint,distance,angleDegToX)
// {
//     let newPoint = [];
//     angleRad = angleDegToX * Math.PI/180;
//     newPoint[0]  = currentPoint[0] + distance * Math.cos(angleRad);
//     newPoint[1]  = currentPoint[1] + distance * Math.sin(angleRad);
//     return newPoint
// }

// function PolarX(currentPoint,xdistance,angleDegToX)
// {
//     let newPoint = [];
//     let angleRad = angleDegToX * Math.PI/180;
//     newPoint[0]  = currentPoint[0] + xdistance;
//     newPoint[1]  = currentPoint[1] + xdistance * Math.tan(angleRad);
//     return newPoint
// }

function PolarY(currentPoint,ydistance,angleDegToX)
{
    let newPoint = [];
    let angleRad = angleDegToX * Math.PI/180;
    newPoint[0]  = currentPoint[0] + ydistance/Math.tan(angleRad);
    newPoint[1]  = currentPoint[1] + ydistance;
    return newPoint
}

function Lever(radius1, radius2, distance, leverheight, wall_thickness)
{
    let sinus_angle = (radius1 - radius2) / distance
    let angle = Math.asin(sinus_angle);

    // points of outer contour of the lever
    let p1 = [radius1 * Math.sin(angle), radius1 * Math.cos(angle)];
    let p2 = [distance + radius2 * Math.sin(angle), radius2 * Math.cos(angle)];
    let p3 = [distance + radius2, 0];
    let p4 = [distance + radius2 * Math.sin(angle), - radius2 * Math.cos(angle)];
    let p5 = [radius1 * Math.sin(angle), - radius1 * Math.cos(angle)];
    let p6 = [- radius1, 0 ];

    let sketchLever = new Sketcher("XY").movePointerTo(p1).lineTo(p2)
    sketchLever = sketchLever.threePointsArcTo(p4,p3)
    sketchLever = sketchLever.lineTo(p5)
    sketchLever = sketchLever.threePointsArcTo(p1,p6)
    sketchLever = sketchLever.close();
              
    let leverbody = sketchLever.extrude(leverheight);
   
    let big_hole = sketchCircle(radius1-wall_thickness).extrude(leverheight + 10);
    let small_hole =  sketchCircle(radius2-wall_thickness).extrude(leverheight + 10).translate([distance,0,0]);
    let lever   = leverbody.cut(big_hole)
    lever       = lever.cut(small_hole);
    
    return lever
}

function Cutout(radius1, radius2, distance, leverheight, wall_t,innerRadius1,innerRadius2)
{
    let sinus_angle = (radius1 - radius2) / distance
    let angle = Math.asin(sinus_angle);

    radius1 = radius1 - wall_t
    radius2 = radius2 - wall_t

    // points of outer contour of the lever
    let p1 = [radius1 * Math.sin(angle), radius1 * Math.cos(angle)];
    let p2 = [distance + radius2 * Math.sin(angle), radius2 * Math.cos(angle)];
    let p3 = [distance + radius2, 0];
    let p4 = [distance + radius2 * Math.sin(angle), - radius2 * Math.cos(angle)];
    let p5 = [radius1 * Math.sin(angle), - radius1 * Math.cos(angle)];
    let p6 = [- radius1, 0 ];

    let innerLever = new Sketcher("XY").movePointerTo(p1).lineTo(p2)
    innerLever = innerLever.threePointsArcTo(p4,p3)
    innerLever = innerLever.lineTo(p5)
    innerLever = innerLever.threePointsArcTo(p1,p6)
    innerLever = innerLever.close();
              
    let innerLeverBody = innerLever.extrude(leverheight);

    let big_hole = sketchCircle(innerRadius1).extrude(leverheight + 10);
    let small_hole =  sketchCircle(innerRadius2).extrude(leverheight + 10).translate([distance,0,0]);
    let cutout   = innerLeverBody.cut(big_hole)
    cutout       = cutout.cut(small_hole);
   
    return cutout;    
}


function SideView(radius1,radius2,distance,sep,t1,t2,t3)
{
    // sketch of sideview
    let p1 =  [-radius1-t3,sep/2];
    let p2 =  [-radius1-t3,sep/2+t1];
    let p3 =  [radius1+t3,sep/2+t1];
    let p4 =  [distance-radius2-t3,t2/2];
    let p5 =  [distance+radius2+t3,t2/2];
    let p6 =  [distance+radius2+t3,-t2/2]; 
    let p7 =  [distance-radius2-t3,-t2/2];
    let p8 =  [radius1+t3,-sep/2-t1];
    let p9 =  [-radius1-t3,-sep/2-t1];
    let p10 = [-radius1-t3,-sep/2];
    let p11 = [radius1+t3,-sep/2];
    let p12 = PolarY(p11,sep/2,angle);
    let p13 = [radius1+t3,sep/2];
    let p14 = [-radius1-t3,sep/2];
    
    
    let sideShape = new Sketcher("XZ").movePointerTo(p1)
    sideShape = sideShape.lineTo(p2)
    sideShape = sideShape.lineTo(p3)
    sideShape = sideShape.lineTo(p4)
    sideShape = sideShape.lineTo(p5)
    sideShape = sideShape.lineTo(p6)
    sideShape = sideShape.lineTo(p7)
    sideShape = sideShape.lineTo(p8)
    sideShape = sideShape.lineTo(p9)
    sideShape = sideShape.lineTo(p10)
    sideShape = sideShape.lineTo(p11)
    sideShape = sideShape.lineTo(p12)
    sideShape = sideShape.lineTo(p13)
    sideShape = sideShape.lineTo(p14)
    sideShape = sideShape.close()
  
    return sideShape
}


// // Rollback stack
let myLever             = Lever(radius_1,radius_2,distance,lever_height,wall_thickness);
let cutoutShape         = Cutout(radius_1, radius_2, distance, lever_height, wall_thickness,radius_1,radius_2);
cutoutShape             = cutoutShape.fillet(fillet_cutout, (e)=>e.inDirection("Z"))
myLever                 = myLever.cut(cutoutShape)   
let sideview            = SideView(radius_1,radius_2,distance,sep,t1,t2,t3);
sideview                = sideview.extrude(radius_1*2).translate([0,radius_1,lever_height/2])
sideview                = sideview.fillet(fillet_arms,(e)=>e.inDirection("Y").inBox([0,-radius_1,0],[distance,radius_1,lever_height]))
let fork                = myLever.intersect(sideview);
fork                    = fork.fillet(fillet_outer);

return fork
}

[sgenoud]

This looks great, I have a couple of questions and remarks!

First, I will look into how to improve the missing features! The fillet in the sketcher class would be an especially good addition!

I have seen that you do not use chaining like this:

    let innerLever = new Sketcher("XY")
      .movePointerTo(p1)
      .lineTo(p2)
      .threePointsArcTo(p4, p3)
      .lineTo(p5)
      .threePointsArcTo(p1, p6)
      .close();

Any reason?

Also you could probably benefit from some helper functions like polarLine, hLine or even closeWithMirror as your sketches are symmetrical. Also when you call close, it automatically closes the sketch if the last point is not on the end. Generally I like to use the version of the methods that are relative to the current point instead of the absolute coordinates (i.e. use line instead of lineTo).

Just to play with the concept I have recreated this part of the model:

    const sideShape = new Sketcher("XZ")
      .movePointerTo([distance + radius2 + t3, 0])
      .vLine(t2 / 2)
      .hLine(-(radius2 + t3) * 2)
      .lineTo([radius1 + t3, sep / 2 + t1])
      .hLine(-(radius1 + t3) * 2)
      .vLine(-t1)
      .hLine((radius1 + t3) * 2)
      .polarLine(sep / 2 / Math.sin(DEG2RAD * angle), -angle)
      .closeWithMirror();

I personally find it easier to read, but this is perhaps because I am more used to it!

[raydeleu]

I agree that I could have created this shape more efficiently. It was more or less a lazy hack of code that I created for CascadeStudio. I wanted to write it exactly the way you showed, but couldn't get the word wrapping to work. I tried it again today and it indeed works. I like that the instructions are not in one long line but on new lines. It helps me to understand the code.

This an example of my code for CascadeStudio:

let halfUpper = new Sketch(p1)
    .LineTo(p2)
    .LineTo(p3).Fillet(fillet_arms)
    .LineTo(p4).Fillet(fillet_arms)
    .LineTo(p5)
    .LineTo(p6)
    .LineTo(p7).Fillet(fillet_arms)
    .LineTo(p8).Fillet(fillet_arms)
    .LineTo(p9)
    .LineTo(p10)
    .LineTo(p11).Fillet(fillet_arms)
    .LineTo(p12).Fillet(fillet_cutout)
    .LineTo(p13).Fillet(fillet_arms)
    .LineTo(p14)
    .End(false)
    .Face(true);
    return halfUpper

For CascadeStudio I added the functions you mention, stealing the idea from CadQuery. See https://github.com/raydeleu/CascadeStudioManual#114-extensions-to-sketch-functions. I agree that using relative distances in sketches is often easier. On the other hand, knowing the absolute coordinate could help in a later stage to identify the edge for filleting or chamfering. That is why the functions I derived for CascadeStudio are practical: you can define each (absolute) point by using the previous point and a relative position. You can then reference this point without calculating its coordinates beforehand.

A different thing I missed in sketching is creating an offset to a wire or sketch. I tried to create something like the base of this Mollino coffee table.

I started with sketching the curved shape of the sideview.

let p0 = [0,0]
let p1 = [50,100]
let p2 = [60,-95]
let p3 = [80,30]
let p4 = [100,25]
let points = [p1,p2,p3,p4]

let testBezier = new Sketcher("XZ")
        .movePointerTo(p0)
        .bezierCurveTo(p4,points)
        .done()

I tried sweeping a rectangular cross-section along this wire with sweepSketch but was not succesful. A more intuitive approach would be to create a face by using an offset to this wire and then extruding this face, or to extrude the wire to create a surface and then use an offset to the surface.

[raydeleu]

I tried to achieve the same curved shell in CascadeStudio and it seems not easy at all.

It looks as if this works, but as soon as I rotate the shape (uncommenting the last line in the code) I get an error. Perhaps this is a limitation of Opencascade?

[raydeleu]

In FreeCad it is possible:

The approach is to use a curve, apply a 2D offset and filling the result. Then you have to apply a shapebinder, after which it is possible to pad/extrude the resulting face.

[raydeleu]

Finally I worked out a solution in CascadeStudio, so it should be possible with OpenCascade.js.

Here is the code (note that I added a second hole):

// define points of wavy curve
let p0 = [0,0]
let p1 = [50,45]
let p2 = [100,0]
let p3 = [150,60]
let p4 = [170,40]
let points = [p1,p2,p3,p4]

// create sketch of wavy curve and rotate it to XZ-plane
let sideView = new Sketch(p0)
.BSplineTo(points)
.End().Wire()
sideView = Rotate([1,0,0],90,sideView)

// extrude the curve, create a copy and offset this copy
let base = Extrude(sideView,[0,60,0])
let base1 = base;
base1 = Offset(base1,1);

// to create a solid, make wires out of the two surfaces and loft 
// between them 
let baseComplete = Loft([GetWire(base),GetWire(base1)])

// create to random cylinders to cut holes in the shape
let cyl = Translate([12,55,0],Rotate([1,0,0],30,Cylinder(8,80,false)))
let cyl2 =  Translate([120,5,0],Rotate([1,0,0],-50,Cylinder(8,80,false)))
baseComplete = Difference(baseComplete,[cyl,cyl2])

[sgenoud]

I derived for CascadeStudio are practical: you can define each (absolute) point by using the previous point and a relative position

You could access a certain position while building something with the sketcher.

  function SideView(radius1, radius2, distance, sep, t1, t2, t3) {
    const sideShapeMaker = new Sketcher("XZ")
      .movePointerTo([distance + radius2 + t3, 0])
      .vLine(t2 / 2)
      .hLine(-(radius2 + t3) * 2)
      .lineTo([radius1 + t3, sep / 2 + t1])
      .hLine(-(radius1 + t3) * 2)
      .vLine(-t1)
      .hLine((radius1 + t3) * 2)
      .polarLine(sep / 2 / Math.sin(DEG2RAD * angle), -angle);

    const centerPoint = sideShapeMaker.pointer;
    console.log(centerPoint);

    const sideShape = sideShapeMaker.closeWithMirror();

    return sideShape;
  }

The pointer value is not exposed - I should probably create a method to save these points for later.

[raydeleu]

I am clearly not an experienced programmer :-). I hoped to be able to access the points in a kind of array, but I really could not make sense of the contents of the centerPoint that was logged to the console.

[raydeleu]

From a user perspective I would he happy using the method based on defining the points first and creating the sketch with these shapes later. I tried to complete the code snippet you included to create the complete "tuning fork". Making a small mistake completely ruined the shape. If I had used points first I could have written the calculated points with the console.log() function to the debugger, making it easier to spot my mistakes. (My mistake was that I was confused by using angles in degrees and radians. The geometric functions in the Math library all use radians, whereas the polarLine uses degrees).