Sizing Units

The Advanced Toolpath Utility uses different size units for 2D and 3D operations. This may confuse buildstyle developers. Let’s explore the reason for this behavior.

An important task of additive build processes is to slice 3D objects and optimize the data on each layer.

The thickness of each layer is a variable value, and theoretically it can have any value. The number of layers is the model’s height divided by the layer thickness. For example, layer number 5 would be the layer at position:

'Lowest z-position' + (5 * 'layer thickness')

Since every layer operation uses layer indices (working on layer 5 is more convenient than working on layer with position -55,666664) instead of positions, operations on the z-axis have to be transformed from position to index values and vice versa. These operations are not 100% accurate all the time. That’s why the z-axis operations can be done with different size units, that are more friendly for the floating point processing unit of the personal computer. The current z-axis’s unit can be queried at the bsModelData object:

bsModelData.getZUnit()

Layer operations are mostly one-way operations. So the size unit can be set to mm.

Layer Indices

In some situations, it is required to convert from layer number to layer position and vice versa. Here are some examples:

Converting from layer number to layer position at makeExposureLayer

This is required to get the current model’s layer object.

exports.makeExposureLayer =  function(modelData, 
																	                     resultHatch, 
                                      layerNo,
                                      attrDefaultPrinterSettings, 
                                      attrPrinterSettings, 
                                      runTests,
                                      doLogging)
{
     var layerThickness = modelData.getLayerThickness();
     var minZVal = modelData.getZeroPosZ();
     for(var mIdx=0; mIdx < modelData.getModelCount(); mIdx++)
     {
        var currentModel =  modelData.getModel(mIdx);
        var layerZPos =  minZVal +  (layerNo * layerThickness);
        var layer =  currentModel.getModelLayer(layerZPos);
}
}

Iterating over all layers at the export

This is necessary to iterate over layer objects at the export.

exports.exportToFile =  function(file, 
                                 filter, 
                                 modelData, 
                                 progress,
                                 attrDefaultPrinterSettings, 
                                 attrPrinterSettings, 
                                 runTests,
                                 doLogging)
{
   var z_range = {};
   var zStrep = modelData.getLayerThickness();
   var layerNo	= 0;

   getExportZRange(modelData, z_range);

   for(var  z_current =  zRange.min; 
            z_current <=  zRange.max; 
            z_current +=  zStrep)
   {
    // Iterate  over all models
    for(var  mIdx=0; mIdx < modelCount; mIdx++)
    {
      var currentModel = modelData.getModel(mIdx);
      var layer = currentModel.getModelLayer(z_current);
     }
     layerNo++;
    }
   }

var   getExportZRange =  function(modelData, 
                                  range)
{
    // get layer  thickness and  minimum  z
    var   layer_thickness =  modelData.getLayerThickness();
    range.min =  modelData.getZeroPosZ() +  layer_thickness;
    range.max =  range.min;
    var   modelCount =  modelData.getModelCount();
    for(var  model_index =  0;  model_index <  modelCount; model_index++)
    {
     var   z_extends =  {};
     if (modelData.getModel(model_index).getMinMaxLayerIntZ(z_extends))
     {
      if(z_extends.max_layer_z  >  range.max)
      range.max =  z_extends.max_layer_z;
      }
     }
}