Help with sweepSketch

[raydeleu]

In the example of the "gridfinity boxes" you use the function sweepSketch. It seems to be a function where you can extrude a profile along a wire. I tried to use this in a similar way as the Pipe function in CascadeStudio, but had no success. Could you offer some explanation how to use this function and/or how you could model a tube-like structure in Replicad?

As an alternative I thought I investigate whether it would be possible to loft between some wires. In CascadeStudio the loft creates a smooth transition between the wires.

When I analysed the example on your website I noticed that the loftWith function does not smooth between the wires but creates a sharp transition.

Would it be possible to smooth this by adapting the parameters of the loftWith function?

[raydeleu]

I found out that the loft can be made smooth by adding the parameter {ruled: false} to the call, like let loft = s1.loftWith([s2,s3],{ruled:false}).

const main = ({ sketchCircle, sketchRectangle }) => 
{
   let s1 = sketchRectangle(5,10,{origin:[5,0,20]})
   let s2 = sketchRectangle(5,7,{origin:[10,0,10]})
   let s3 = sketchRectangle(7,10)

let loft = s1.loftWith([s2,s3],{ruled:false})

return loft
  
};

I have still no solution for the sweepSketch and stumbled upon the question how to rotate the wires for a loft over angles other than 90 degrees. The .rotate() function obviously only applies to shapes, not to sketches. I tried to create a face, rotate the face and then extract the wire again, but did not succeed. It also seems a bit complicated to do it that way.

[raydeleu]

Here is an example of a loft with rotated sketches, using the complicated approach to turn the sketch into a face, rotate the face and then retrieving the wire or sketch by mis-using the sketchFaceOffset function with an offset of zero. It works, but I would hope there is a better way.

const main = ({ sketchCircle, 
               sketchRectangle,
               sketchFaceOffset,
               sketchRoundedRectangle }) => 
{
   let s1 = sketchCircle(5,{origin:[18,0,30]})
   s1 = s1.face().rotate(-30,[0,0,0],[0,1,0])
   s1 = sketchFaceOffset(s1,0)
   let s2 = sketchRoundedRectangle(5,7,2,{origin:[10,0,10]})
   let s3 = sketchRectangle(10,5,{origin:[-20,0,0],plane:"YZ"})

let loft = s1.loftWith([s2,s3],{ruled:false})

return loft
  
};

[sgenoud]

I am currently writing a new API slightly different from the sketch API that can be rotated or modified (but only works in a 2D environment). I still need to do a bit of cleanup but I will be curious of the feedback you can give me on that.

That said, there are some improvements to the Plane API that would solve is in a cleaner way (I think). For instance moving the plane first, and then drawing the sketch in this plane. But for now it would look like this:

  const circleAxis = new Vector([0, 0, 1]).rotate(-30, [0, 0, 0], [0, 1, 0]);
  const circleCenter = new Vector([18, 0, 30]).rotate(
    -30,
    [0, 0, 0],
    [0, 1, 0]
  );
  const circlePlane = new Plane(circleCenter, null, circleAxis);

  let s1 = sketchCircle(5, { plane: circlePlane });

[raydeleu]

My first impression was that the method you propose is rather complicated. But I understand that you would like to start from the concept of a plane. This allows you to sketch on a plane defined by a feature of the current shape. Just some thoughts:

• If I were to define the angle of a plane I would always start from one of the cartesian planes and rotate this around one of the cartesian axes. In that case the .rotate method could always be written as .rotate(angle,axis) or .rotate(angle,[vector]). In other words, always assume that the first point of the rotation axis is [0,0,0].
• The origin of the sketch would only be defined by a point. I do not understand why you added the rotation to the circleCenter as it defines only a point. If you would like to rotate the coordinate system of the sketching plane I would do so in the definition of the new plane.
• Why not include the definition of the angle and the origin into the new Plane() definition? Either in the function itself or by using a command like

let circlePlane = new Plane("XZ").translate([10,20,30].rotate(30,[1,0,0]).rotate(20,[0,0,1]).
let s1 = sketchRectangle(5,{plane: circlePlane})

The translate shifts the origin of the new sketch to absolute [x,y,z] coordinates. You can then add rotation along each of the main axes to achieve the required tilt of the plane. I used a rectangle in my example as I can imagine that you would like to rotate the rectangle around its origin, whereas for the circle this makes no difference.

Just to illustrate my thinking: I tried to model a watering can that has a rather complicated, organic shape. In Blender this is very easy, in a CAD tool it is much more complicated. I finally succeeded to create the shape in CascadeStudio and doing it in Replicad is on my wish list. The fill opening of the watering can was created by a loft between three circles that are rotated to different angles. The code looks like this:

let fill_hole  = Translate([-35,0,135],Rotate([0,1,0],-70,(Circle(12,true))));
let topbody = Translate([0,0,100],(Circle(8,true))); 
let bottom = Translate([0,0,80],Rotate([0,1,0],20,(Circle(9,true)))); 
let filler    = Loft([fill_hole,topbody,bottom]);

Each circle requires only a single line of code. The downside of this approach is that it is more difficult to sketch on a face of an existing shape. In this respect your approach is more versatile.

[sgenoud]

As it is defined now a plane is three "points":

• the origin - which gives us the position in the 3D space
• the normal - which gives us the tilt of the place (the point is the end of a vector starting a [0, 0, 0])
• the x direction - which corresponds to the rotation within the plane (the point is the end of a vector starting a [0, 0, 0])

For instance the "XY" plane is origin: [0, 0, 0], normal [0, 0, 1] and x dir [1, 0, 0]. You can always create a plane with new Plane(origin, xDir, normal) (I don't like the order of the last two parameters - I should do something about it).

I like your proposition of being able to define the normal as one rotation from a named plane (with a named direction I would guess). I am not 100% sure how to define it in a way that can work in an intuitive manner. Typically I think that your proposition of being able to rotate is a bit tricky (as one might expect to be able to rotate from a particular point - not always the origin). I will play with it.

Another possibility would be to offer a nicer way to define the normal from a base direction and rotations (with the xDir as an angle this could correspond to euler angles - if my memory is not too bad).

[sgenoud]

I do not understand why you added the rotation to the circleCenter as it defines only a point.

I needed to do this to make the shape the same as yours. You rotated the (created) shape, so it means that the position of the origin was also moved in a rotation around the center (and not only the plane).

The location of an object in 3D space has 6 dimensions - 3 of them correspond to the position of the origin and 3 of the tilt of the plane (and x axis). In general, if you do a rotation on the object, all dimensions are modified - so I needed to change the position of the origin as well.

[raydeleu]

Perhaps in the 6 degrees of freedom lies the solution. Shouldn't it be possible to place an object into space with [x,y,z] and [theta_x, theta_y, theta_z] (three angles with respect to the cartesian axes). So a plane could be defined by point[x,y,z] and theta[rx,ry,rz], a translation would be defined by [dx,dy,dz], a rotation by [rx,ry,rz]. If you prefer the definition of a normal and the rotation around the normal you could use a conversion function. I don't know about you, but for me it is always easier to imagine something in angles of degrees (roll,pitch,yaw) instead of a normal vector.

[sgenoud]

sweepSketch takes a function with the start plane as a parameter. I though I had written something here, but it looks like I forgot to send.

const main = (
  { Sketcher, sketchRectangle, revolution, sketchCircle, Plane, EdgeFinder },
  {}
) => {
  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];

  return new Sketcher("XZ")
    .movePointerTo(p0)
    .bezierCurveTo(p4, points)
    .done()
    .sweepSketch((plane, origin) => sketchRectangle(3, 30, { plane, origin }));
};

[raydeleu]

Thanks. I just published a How To with an additional example how to use the function. I wondered how to achieve a cross section defined by a sketch instead of using one of the "pre-baked" sketches. I think I solved this by defining a function with plane and origin as parameters.