iPath

Find below the Bar Stool, easy in flatpack and convenient popped up. You are free to modify all parameters in the model, including the thickness of your plywood sheet. So you can make this template fit on any piece of plywood. The photo is a bar stool created from wasted concrete plywood collected out of the bins on a buildingspot in Amsterdam. Use this link to view the 2D model of the barstool.

The idea is stolen from this kickstarter campaign and is scripted in iPath so the design files are online and customizable.

view it in stretchsketch

Every software library should have a testsuite attached and iPath is not different. Being written in Javascript a few options are available for a Test framework, and I have chosen Jasmin.

A test suite consists of a tests which will compare the outcome of a function on a certain input against a reference value. When your testsuite is in place and covers enough of your code, you can refactor and extend your code with far more confidence than without a proper testsuite.

A very simple javascript function which doubles a numeric value, can look like:

function double (v) {
      return 2*v;
}

  it ("tests the double function",function () {
      var b = 5;
      expect(double(b)).toEqual(2*b);
  });

  it ("tests a bezier in dxf",function () {
      var b = new Bezier2Poly(0.5),pb = new PathBuilder(3);
      	  var array = [{x:20, y:0}, {x:0,y:20}, {x:20, y:20}];
	  expect(JSON.stringify(b.convert(array), signy))
            .toEqual('[{"x":5.781,"y":0.859},{"x":2.969,"y":2.266},{"x":1.094,"y":3.203},{"x":0.156,"y":3.672},{"x":0.156,"y":3.672},{"x":1.094,"y":3.203},{"x":2.969,"y":2.266},{"x":5.781,"y":0.859}]');
  });

In the previous blog I showed the possibilities of the fillet function: "arcing" the sharp junction of two lines. When milling this fillet comes for free (the radius is equal to the radius of the milling bit) in particular for inside pockets and these fillets may be unwanted, especially when creating a peg-hole connection. Toolpath software like vCarve provide a solution for this, known as the overcut or dogbone.

(see here for a detailed description in vCarve)

And iPath also offers this solution, comparable to the fillet:

var dogBone = new iPath().line(15,0).overcut(1.5).line(0,7).overcut(1.5).line(-15,0).overcut(1.5).line(0,-7).overcut(1.5);

   dogbone.pts = [{x:dogbone.length/2, y:0},{br: dogbone.bitradius},{y:dogbone.width, x:0},{br: dogbone.bitradius}
     , {x:-dogbone.length, y:0},{br: dogbone.bitradius},{y:-dogbone.width, x:0},{br: dogbone.bitradius}
     , {x:dogbone.length/2, y:0}];
   dogbone.path = arcPath(dogbone.pts);

This feature eliminates the need for adding the dogbones junction in your toolpath software, and reduces the risk of forgetting one or more junctions and a faster time to materialisation.

The blackline indicates the wanted form to be milled, the redline indicates, the milling result without the overcut and finally the green line is the result with the overcut. As you can see a little bit extra is removed at the corners, but the corners are now ready for the square peg.

Below a picture to show how the materialize result looks like on a sheet of concreteplex, because of the irregularites in the material the chosen thickness includes a margin which is also visible.

In the previous log I described how iPath was extended (with helper functions) to provide for functionality to complete the traincross.

This short log will display show how the train cross is realized:

tc.pts=[{x:3, y:0},{x:5,y:3},{fr:6}, {x:0, y:9},{fr:6}
   , {x:tc.gutter/2-8, y:2}, {x:0, y: tc.boneLength-14}
   , {x:(tc.width-tc.gutter)/2, y:0}
   , {x:0, y:-tc.length}, {fr:tc.length*tc.filletratio}];
tc.path = arcPath(reflectPath(reflectPath(reflectPath(tc.pts
   , {x:1, y:1}), {x:1,y:0}), {x:0,y:1}));
tc.rails = new iPath().move(0,tc.boneLength).move(tc.railsWidth/2,0)
   .line(0,-tc.totalLength).move(-tc.railsWidth,0).line(0,tc.totalLength)
   .move(tc.railsWidth/2-tc.length-tc.width/2
         ,-tc.railsWidth/2-tc.length-tc.width/2)

The variables tc.width, tc.boneLength etc must be declared upfront or can be made user-customizable. The {x:.., y:..} indicate relative points, they are connected with straight lines.. The {fr: ..} objects indicates the fillet, the arc between two lines. Note that the fillet will effectively modify (shorten) the surrounding lines. The arcPath function returns an iPath which can be materialized into an SVG path-d attribute or DXF file.

It would have been possible to concat the tc.path and tc.rails into one object. But when exporting to DXF one can only assign one layer per object. The rails are different from the outside boundary: the cutting depth is different. CNC operators normally want one layer per cutting action and this is possible by constructing 2 iPaths.

The complete jsvg file can be downloaded from this project's file section. The result can be viewed in StretchSketch

As a first challenge I'm targeting http://www.instructables.com/id/Custom-Wooden-Train-Track-X-crossing/.

It would be nice If you can do something like:

var part = new iPath().line(3,0).line(4,4).fillet(4).line(4,0)....
part.reflect({x:1,y:1}).reflect({x:1}).reflect({y:1})

Unfortunately I have not been able to implement reflect and fillet reliable in iPath. As an alternative for now I use an array with line points, these will all be rendered in visible line, or arc segments. This array can passed as arguments to the functions reflectPath and arcPath.