Can I get some code review up in here?

classic Classic list List threaded Threaded
17 messages Options
Reply | Threaded
Open this post in threaded view
|

Can I get some code review up in here?

linkreincarnate
So I just finished my first major project in openscad thanks to all of you who helped out with my questions.  That said I am sure the code could be optimized for readability and maintainability.  Would anyone in here be so kind as to look over my code and offer me some suggestions or examples of how I could make it better and more easily parametric.  

I am specifically interested in creating better encapsulation, reducing code duplication, and optimizing for Thingiverse's customizer.



Giant text dump follows.

//3d printable cigarette rolling machine
//Created By LinkReincarnate
//CC Share Alike Attribution Non-Commercial
//*************VARIABLE DECLARATION SECTION******** all values are in mm

   
//make sure to change the hingeSlotXOffset when you change the box length.    
boxLength = 90.4;        
boxWidth = 81.25;
boxHeight = 19.2;
boxBottomThickness = 2;
boxWallThickness = .67;
boxArcHeight = 3.5;
boxArcRadius=1;
boxControlArmHoleZOffset = 3.5;
boxControlArmHoleYOffset = 3;
boxHingePinDiameter = 3;
boxHingeDiameter= 5;
boxHingeZOffset = -5;
boxHingeYOffset = 0;
boxHingeTolerance = .1;
boxHingeSupportZOffset= 0;
boxHingeSupportYOffset = -4.5;
boxHingeNumberOfSplits = 7;
boxHingeClearance=1;
//the following variables determine the details of the cylinder (or sphere) used for minkowski sums
boxCornerRoundness = 7;
boxCornerSmoothness = 16;

controlArmLength = 38.5;
controlArmHeight = 7;
controlArmThickness = 5;
controlArmPinDiameter = 2;
controlArmHoleZOffset = 0;
controlArmHoleYOffset = 0;
controlArmPinTolerance = .1;

lidLipHeight = 5;
lidThickness = 5;
lidTolerance = 1;
lidHingeZOffset = 0;
lidHingeYOffset = 1;
lidHingeXOffset =.4;
lidHingeTolerance = 1;
lidOverlap = 2;

//moves hinge slot cutouts left and right
hingeSlotXOffset = 0;
hingeSlotYOffset = 0;
hingeSlotZOffset = 0;

dispenserHoleLength = 71.5; //also used for dist between tracks
dispenserHoleWidth = 11.5;
dispenserHoleXOffset = 0;
dispenserHoleYOffset = 0;

trackPanelLength = 76;
trackPanelWidth = 19;
trackPanelThickness = 3;
trackWidth = 2.5;
trackLength = 61;
trackHeight = 14;
trackTolerance = 1;
trackControlPoint1X = 3;
trackControlPoint1Y = 3;
trackControlPoint1Z = 0;
trackControlPoint2X = 9;
trackControlPoint2Y = 9;
trackControlPoint2Z = 0;
trackControlPoint3X = 45;
trackControlPoint3Y = 8;
trackControlPoint3Z = 0;
trackControlPoint4X = 57;
trackControlPoint4Y = 14;
trackControlPoint4Z = 0;


rollerDiameter = 7;
rollerLength = 71;

rollerPinDiameter = 2;
hingePinDiameter = 1.6;
pinLength= 71;

pinTolerance = 1;
cigaretteDiameter = 7.75;
cigaretteLength = 70;

booleanOverlap = .01; //to ensure that the faces used to difference() dont line up
lowRollingClearance = 5; //the distance from the center of the rolling pin to the lid at the lowest point.
hightRollingClearance = 12.6;

boxRoundCorners = true;
arched = true;
//uses math to determin the arc radius of the curve of the box and creates the appropriate cylinder

//*************MODULE DECLARATION SECTION***************************
module CreateArc(            arcLength,
                             arcHeight,
                             cylinderHeight){
    carveRadius = ((arcHeight/2)+((arcLength * arcLength)/arcHeight * 8)/(53));
    rotate(a=[90,180,90]){
        translate([0,-carveRadius + arcHeight - (boxHeight/2),0]){
            cylinder(r=carveRadius, h=cylinderHeight+booleanOverlap, $fn=1024, center=true);
        }
         
    }
}//end of module
                                                     

module CreateNonArchedBody(  boxLength,
                             boxWidth,
                             boxHeight,
                             boxBottomThickness,
                             boxWallThickness,
                             boxRoundCorners,
                             boxCornerRoundness,
                             boxCornerSmoothness,
                             boxHingeDiameter,
                             boxHingePinDiameter,  
                             boxHingeZOffset,
                             boxHingeYOffset,
                             boxHingeTolerance,
                             boxHingeClearance,
                             boxHingeNumberOfSplits,
                             pinTolerance,
                             controlArmPinDiameter,
                             boxControlArmHoleZOffset,  
                             boxControlArmHoleYOffset,
                             controlArmPinTolerance,
                             boxHingeSupportZOffset,
                             boxHingeSupportYOffset,
                             booleanOverlap){
 //union joins the difference of the outer and inner bodies with a pinhole for the arms and the hinge parts
    union(){
        //create body
         if (boxRoundCorners){
           difference(){    
                $fn=boxCornerSmoothness;
                minkowski(){
                 cube([boxLength-(2*boxCornerRoundness),boxWidth - (2*boxCornerRoundness),boxHeight/2],
                     center = true);
                 cylinder(r=boxCornerRoundness,h=boxHeight/2, center=true);
                }
                translate([0,0,(boxBottomThickness/2) + booleanOverlap]) {
                    $fn=boxCornerSmoothness;
                    minkowski()
                    {
                     cube([boxLength - boxWallThickness-(2*boxCornerRoundness),
                              boxWidth - boxWallThickness -(2*boxCornerRoundness),
                              ((boxHeight/2) - (boxBottomThickness/2))],
                              center = true);
                     cylinder(r=boxCornerRoundness,h=((boxHeight/2) - (boxBottomThickness/2)), center=true);
                    }
                }
                //create pinholes to connect control arms
                rotate(a=[0, -90, 0]){
                    translate([boxControlArmHoleZOffset,boxControlArmHoleYOffset,0]){
                        cylinder(d= (controlArmPinDiameter + controlArmPinTolerance),
                                     boxLength + booleanOverlap,
                                     center=true );
                    }
                }
               
            } //end of difference
         } else {
              difference(){
                    cube([boxLength,boxWidth,boxHeight],
                         center = true);
                    translate([0,0,(boxBottomThickness/2) +booleanOverlap]) {
                        cube([boxLength - boxWallThickness,
                              boxWidth - boxWallThickness,
                              (boxHeight - boxBottomThickness)],
                              center = true);
                    }
                    //create pinholes to connect control arms
                    rotate(a=[0, -90, 0]){
                        translate([boxControlArmHoleZOffset,boxControlArmHoleYOffset,0]){
                            cylinder(d= (controlArmPinDiameter + controlArmPinTolerance),
                                         boxLength + booleanOverlap,
                                         center=true );
                        }
                    }
                   
              }  
         }
         CreateHinge(boxRoundCorners,
                     boxWidth,
                     boxLength,
                     boxHeight,
                     boxHingeDiameter,
                     boxHingePinDiameter,  
                     boxHingeZOffset,
                     boxHingeYOffset,
                     boxHingeTolerance,
                     boxHingeClearance,
                     boxHingeNumberOfSplits,
                     pinTolerance,
                     boxHingeSupportZOffset,
                     boxHingeSupportYOffset,
                     lidHingeZOffset,
                     lidHingeYOffset,
                     lidHingeTolerance,
                     booleanOverlap);
     }// end of union body and hinge
}//end of module
module CreateArchedBody(     boxLength,
                             boxWidth,
                             boxHeight,
                             boxBottomThickness,
                             boxWallThickness,
                             boxRoundCorners,
                             boxCornerRoundness,
                             boxCornerSmoothness,
                             boxHingeDiameter,
                             boxHingePinDiameter,  
                             boxHingeZOffset,
                             boxHingeYOffset,
                             boxHingeTolerance,
                             boxHingeClearance,
                             boxHingeNumberOfSplits,
                             pinTolerance,
                             controlArmPinDiameter,
                             boxControlArmHoleZOffset,  
                             boxControlArmHoleYOffset,
                             controlArmPinTolerance,
                             boxHingeSupportZOffset,
                             boxHingeSupportYOffset,
                             booleanOverlap,
                             boxArcHeight,
                             boxArcRadius
                             ){
    union(){
    //create body
      if (boxRoundCorners){
         translate([0,0,boxHingeSupportZOffset+boxArcHeight+1])
             difference(){  
                intersection(){
                    $fn=boxCornerSmoothness;
                    minkowski(){
                     cube([boxLength-(2*boxCornerRoundness),
                           boxWidth - (2*boxCornerRoundness),
                           boxHeight+boxArcHeight/2],
                         center = true);
                     cylinder(r=boxCornerRoundness,h=boxHeight + boxArcHeight/2);
                    }
                    translate([0,0,-boxHeight+boxArcHeight])
                        CreateArc(boxWidth, boxArcHeight, boxLength);
                 }  
                translate([0,0,(boxBottomThickness/2)]){
                   intersection(){
                         $fn=boxCornerSmoothness;
                         minkowski(){
                             cube([boxLength - boxWallThickness-(2*boxCornerRoundness),
                                   boxWidth - boxWallThickness -(2*boxCornerRoundness),
                                   (((boxHeight+boxArcHeight/2) - boxBottomThickness) + booleanOverlap)],
                                   center = true);
                             cylinder(r=boxCornerRoundness,h=boxHeight/2);
                        }
                        translate([0,0,-boxHeight+boxArcHeight])
                            CreateArc(boxWidth, boxArcHeight, boxLength);
                    }  
                }
                //create pinholes to connect control arms
                rotate(a=[0, -90, 0]){
                    translate([boxControlArmHoleZOffset,boxControlArmHoleYOffset,0]){
                        cylinder(d= (controlArmPinDiameter +                                                                
                                     controlArmPinTolerance),
                                     boxLength + booleanOverlap,
                                     center=true );
                    }
                }
               
                CreateArc(boxWidth, boxArcHeight, boxLength+booleanOverlap);
              //insert objects here to difference them from the main body  
      }
      } else {
          difference(){
              intersection(){
                cube([boxLength,boxWidth,boxHeight+boxArcHeight],
                     center = true);
                translate([0,0,-boxHeight+boxArcHeight]){
                    CreateArc(boxWidth, boxArcHeight, boxLength);
                }
                 
              }
              intersection(){
                    translate([0,0,(boxBottomThickness/2)]){
                        cube([boxLength - boxWallThickness,
                              boxWidth - boxWallThickness,
                              ((boxHeight +boxArcHeight - boxBottomThickness) + booleanOverlap)],
                              center = true);
                    }
                    translate([0,0,-boxHeight+boxArcHeight]){
                         CreateArc(boxWidth, boxArcHeight, boxLength);
                    }
                }
                //create pinholes to connect control arms
                rotate(a=[0, -90, 0]){
                   translate([boxControlArmHoleZOffset,boxControlArmHoleYOffset,0]){
                       cylinder(d= (controlArmPinDiameter +                                                        
                                    controlArmPinTolerance),
                                    boxLength + booleanOverlap,
                                    center=true );
                   }
                }
                CreateArc(boxWidth,boxArcHeight,boxLength + booleanOverlap);
                //insert here to difference with body
            }  
      }
    //Create Hinge and hinge support
    CreateHinge( boxRoundCorners,
                 boxWidth,
                 boxLength,
                 boxHeight,
                 boxHingeDiameter,
                 boxHingePinDiameter,  
                 boxHingeZOffset,
                 boxHingeYOffset,
                 boxHingeTolerance,
                 boxHingeClearance,
                 boxHingeNumberOfSplits,
                 pinTolerance,
                 boxHingeSupportZOffset,
                 boxHingeSupportYOffset,
                 lidHingeZOffset,
                 lidHingeYOffset,
                 lidHingeTolerance,
                 booleanOverlap);
    //insert new parts to be added to the body here
    }
}//end of module
module CreateNonArchedLid(          lidLipHeight,
                                    lidThickness,
                                    lidTolerance,
                                    lidHingeZOffset,
                                    lidHingeYOffset,
                            //add lidHingeXOffset and hingeSlotXOffset
                                    lidHingeTolerance,
                                    lidOverlap,
                                    hingeSlotXOffset,
                                    hingeSlotYOffset,
                                    hingeSlotZOffset,
                                    boxLength,
                                    boxWidth,
                                    boxHeight,
                                    boxRoundCorners,
                                    boxCornerRoundness,
                                    boxCornerSmoothness,
                                    boxHingeDiameter,
                                    boxHingePinDiameter,
                                    boxHingeNumberOfSplits,
                                    dispenserHoleLength,
                                    dispenserHoleWidth,
                                    dispenserHoleXOffset,
                                    dispenserHoleYOffset,
                                    rollerLength,
                                    trackPanelThickness,
                                    booleanOverlap){
  if (boxRoundCorners){
             difference(){    
                    $fn=boxCornerSmoothness;
                    //this is the exterior of the lid
                    minkowski(){
                     cube([lidOverlap + boxLength + lidTolerance - (2 * boxCornerRoundness),
                           lidOverlap + boxWidth + lidTolerance - (2 * boxCornerRoundness),
                           ((lidThickness + lidLipHeight)/2)]);
                     cylinder(r=boxCornerRoundness,h=((lidThickness + lidLipHeight)/2));
                    }
                    //this is the interior cutout
                    translate([lidOverlap/2,lidOverlap/2,-booleanOverlap ]){
                        $fn=boxCornerSmoothness;
                        minkowski()
                        {
                         cube([boxLength + lidTolerance - (2 * boxCornerRoundness) ,
                               boxWidth + lidTolerance - (2 * boxCornerRoundness),
                               lidLipHeight/2]);
                         cylinder(r=boxCornerRoundness,h=lidLipHeight/2);
                        }
                    }
                    //this is the hinge lip cutout
                    {
                    translate([-((boxCornerRoundness/2) + (lidTolerance/2) + ((lidOverlap/2))),0,-booleanOverlap])
                    cube([boxLength - lidTolerance,
                               boxWidth + lidTolerance,
                               lidLipHeight +booleanOverlap]);
                    }
                    //hingeslots
                    //this splits the hinge cylinder into individual pieces, also cuts clearance slots into the lid
                    difference(){
                        //change this rotate to 90 to invert the hinge slot cut over one hingelength
                      rotate(a=[0,270,0])
                       translate([lidLipHeight,
                                  boxWidth + lidOverlap - (boxCornerRoundness),
                                  -((boxCornerRoundness/2)) -boxLength]){
                          translate([0,0,hingeSlotXOffset + lidOverlap/2 + lidTolerance])
                          {
                               for ( i = [0 : boxHingeNumberOfSplits/2] )
                                    {
                                        //LOOK HERE TO TRY TO FIX HINGE SLOT MISALIGNMENT
                                        translate([0, 0, boxLength/boxHingeNumberOfSplits * i *2])
                                        cylinder(d=boxHingeDiameter+boxHingeTolerance+booleanOverlap + boxHingeClearance,
                                                (boxLength/boxHingeNumberOfSplits) + boxHingeTolerance + lidHingeTolerance);
                                     }
                          }
                               
                        }
                        //this cube acts as an endstop precenting the hinge from being cut past the point it needs to be cut
                        translate([-boxCornerRoundness + boxLength -(boxCornerRoundness/2) +lidTolerance/2 - (lidOverlap/2),
                                   0,
                                   lidLipHeight -boxHingeDiameter - boxHingeTolerance - boxHingeClearance,]){
                            cube([boxCornerRoundness,
                                  boxWidth+10,
                                  boxHeight]);
                        }
                        //same as above but on the other side! exciting...
                        translate([-boxCornerRoundness,
                                   0,
                                   lidLipHeight -boxHingeDiameter - boxHingeTolerance - boxHingeClearance]){
                            cube([boxCornerRoundness,
                                  boxWidth+10,
                                  boxHeight]);
                        }
                    }//end of hinge slot subtration
                    //dispenser hole
                    translate([boxCornerRoundness/2 +lidTolerance/2 ,0,lidThickness-2])
                    cube([dispenserHoleLength,dispenserHoleWidth,lidThickness+10 +booleanOverlap]);
                    //trackPanelMountingHoles
  //***********Get the thickness out of the module somehow so i can arrange the track panels outside the dispenser hole                  
                    translate([boxCornerRoundness/2 +lidTolerance/2,0,lidThickness+booleanOverlap]){
                     rotate([270,0,90]){
                     #CreateControlTrack(
                            controlArmLength,
                            controlArmHeight,
                            controlArmThickness,
                            controlArmPinDiameter,
                            controlArmHoleZOffset,
                            controlArmHoleYOffset,
                            controlArmPinTolerance,
                            lidLipHeight,
                            lidThickness,
                            lidTolerance,
                            boxLength,
                            boxWidth,
                            boxHeight,
                            boxRoundCorners,
                            boxCornerRoundness,
                            boxHingePinDiameter,
                            trackPanelLength,
                            trackPanelWidth,
                            trackPanelThickness,
                            trackWidth,
                            trackLength,
                            trackHeight,
                            trackTolerance,
                            trackControlPoint1X,
                            trackControlPoint1Y,
                            trackControlPoint1Z,
                            trackControlPoint2X,
                            trackControlPoint2Y,
                            trackControlPoint2Z,
                            trackControlPoint3X,
                            trackControlPoint3Y,
                            trackControlPoint3Z,
                            trackControlPoint4X,
                            trackControlPoint4Y,
                            trackControlPoint4Z);
                      translate([0,0,-dispenserHoleLength -trackPanelThickness])
                     #CreateControlTrack(
                            controlArmLength,
                            controlArmHeight,
                            controlArmThickness,
                            controlArmPinDiameter,
                            controlArmHoleZOffset,
                            controlArmHoleYOffset,
                            controlArmPinTolerance,
                            lidLipHeight,
                            lidThickness,
                            lidTolerance,
                            boxLength,
                            boxWidth,
                            boxHeight,
                            boxRoundCorners,
                            boxCornerRoundness,
                            boxHingePinDiameter,
                            trackPanelLength,
                            trackPanelWidth,
                            trackPanelThickness,
                            trackWidth,
                            trackLength,
                            trackHeight,
                            trackTolerance,
                            trackControlPoint1X,
                            trackControlPoint1Y,
                            trackControlPoint1Z,
                            trackControlPoint2X,
                            trackControlPoint2Y,
                            trackControlPoint2Z,
                            trackControlPoint3X,
                            trackControlPoint3Y,
                            trackControlPoint3Z,
                            trackControlPoint4X,
                            trackControlPoint4Y,
                            trackControlPoint4Z);
                        }
                    }
             } // end of difference
         } else {
              difference(){    
                   //this is the exterior of the lid
                   cube([lidOverlap + boxLength + lidTolerance,
                           lidOverlap + boxWidth + lidTolerance,
                           ((lidThickness + lidLipHeight))]);
                    //this is the interior cutout
                    translate([lidOverlap/2,lidOverlap + booleanOverlap,-booleanOverlap]){
                        cube([boxLength + lidTolerance,
                               boxWidth + lidTolerance,
                               lidLipHeight]);
                    }
                    //this is the hinge lip cutout
                    translate([lidOverlap/2,lidOverlap/2,-booleanOverlap]){
                        cube([boxLength + lidTolerance,
                                   boxWidth + lidTolerance,
                                   lidLipHeight]);
                    }
                    //hingeslots
                    //this splits the hinge cylinder into individual pieces, also cuts clearance slots into the lid
                    rotate(a=[0,90,0])
                       translate([-lidLipHeight,+boxWidth + boxHingeDiameter/2,lidOverlap/2]){
                            for ( i = [0 : boxHingeNumberOfSplits] ){
                                    translate([0, 0, boxLength/boxHingeNumberOfSplits * i *2])
                                    cylinder(d=boxHingeDiameter+boxHingeTolerance+booleanOverlap + boxHingeClearance,
                                            (boxLength/boxHingeNumberOfSplits) + boxHingeTolerance + lidHingeTolerance);
                            }
                        }
              } // end of difference  
         }//end of else
         

 }//end of Lid Module
module CreateArchedLid(             lidLipHeight,
                                    lidThickness,
                                    lidTolerance,
                                    lidHingeZOffset,
                                    lidHingeYOffset,
                                    lidHingeTolerance,
                                    boxLength,
                                    boxWidth,
                                    boxHeight,
                                    boxRoundCorners,
                                    boxCornerRoundness,
                                    boxCornerSmoothness,
                                    boxHingeDiameter,
                                    boxHingePinDiameter,
                                    dispenserHoleLength,
                                    dispenserHoleWidth,
                                    dispenserHoleXOffset,
                                    dispenserHoleYOffset,
                                    rollerLength,
                                    boxArcHeight,
                                    boxArcRadius,
                                    booleanOverlap)
                                    {}
                                   
                                   
module CreateControlArm(            controlArmLength,
                                    controlArmHeight,
                                    controlArmThickness,
                                    controlArmPinDiameter,
                                    controlArmHoleZOffset,
                                    controlArmHoleYOffset,
                                    controlArmPinTolerance){

    difference(){
        hull(){
            translate()
                cylinder(d=controlArmHeight, h=controlArmThickness);
            translate([controlArmLength,0,0])
                cylinder(d=controlArmHeight, h=controlArmThickness);
        }//end of hull
        translate([0,0,-controlArmThickness/2])
                #cylinder(d=controlArmPinDiameter, h=controlArmThickness*2, $fn=32);
            translate([controlArmLength,0,-controlArmThickness/2])
                #cylinder(d=controlArmPinDiameter, h=controlArmThickness*2, $fn=32);
    }//end of difference
}//end of module
module CreateControlTrack(          controlArmLength,
                                    controlArmHeight,
                                    controlArmThickness,
                                    controlArmPinDiameter,
                                    controlArmHoleZOffset,
                                    controlArmHoleYOffset,
                                    controlArmPinTolerance,
                                    lidLipHeight,
                                    lidThickness,
                                    lidTolerance,
                                    boxLength,
                                    boxWidth,
                                    boxHeight,
                                    boxRoundCorners,
                                    boxCornerRoundness,
                                    boxHingePinDiameter,
                                    trackPanelLength,
                                    trackPanelWidth,
                                    trackPanelThickness,
                                    trackWidth,
                                    trackLength,
                                    trackHeight,
                                    trackTolerance,
                                    trackControlPoint1X,
                                    trackControlPoint1Y,
                                    trackControlPoint1Z,
                                    trackControlPoint2X,
                                    trackControlPoint2Y,
                                    trackControlPoint2Z,
                                    trackControlPoint3X,
                                    trackControlPoint3Y,
                                    trackControlPoint3Z,
                                    trackControlPoint4X,
                                    trackControlPoint4Y,
                                    trackControlPoint4Z){
    union(){                                    
        difference(){
            //Track Panel
            cube([trackPanelLength,trackPanelWidth, trackPanelThickness]);
            //Track
            hull(){
                translate([trackControlPoint1X,trackControlPoint1Y,trackControlPoint1Z - booleanOverlap])
                    cylinder(d=trackWidth+trackTolerance,h = trackPanelThickness + booleanOverlap*2, $fn=32);
               
                translate([trackControlPoint2X,trackControlPoint2Y,trackControlPoint2Z - booleanOverlap])
                    cylinder(d=trackWidth+trackTolerance,h = trackPanelThickness + booleanOverlap*2, $fn=64);
            }
            hull(){
                translate([trackControlPoint2X,trackControlPoint2Y,trackControlPoint2Z - booleanOverlap])
                    cylinder(d=trackWidth+trackTolerance,h = trackPanelThickness + booleanOverlap*2, $fn=64);
               
                translate([trackControlPoint3X,trackControlPoint3Y,trackControlPoint3Z - booleanOverlap])
                    cylinder(d=trackWidth+trackTolerance,h = trackPanelThickness + booleanOverlap*2, $fn=64);
            }
            hull(){
                translate([trackControlPoint3X,trackControlPoint3Y,trackControlPoint3Z - booleanOverlap])
                    cylinder(d=trackWidth+trackTolerance,h = trackPanelThickness + booleanOverlap*2, $fn=64);
               
                translate([trackControlPoint4X,trackControlPoint4Y,trackControlPoint4Z - booleanOverlap])
                    cylinder(d=trackWidth+trackTolerance,h = trackPanelThickness + booleanOverlap*2, $fn=64);
            }
            //rollerflap pin holes
            translate([trackPanelLength*.14,trackPanelWidth *.07,-booleanOverlap])
                cylinder(d= boxHingePinDiameter, h= trackPanelThickness + booleanOverlap*2, $fn=64);
            translate([trackPanelLength*.9,trackPanelWidth *.14,-booleanOverlap])
                cylinder(d= boxHingePinDiameter, h= trackPanelThickness + booleanOverlap*2, $fn=64);
           
            //Right Side Angle Cut
            translate([trackPanelLength,0,-booleanOverlap]){
                rotate([0,0,45]){
                    cube([trackPanelLength/4,sqrt(pow(trackPanelWidth,2)+pow(trackPanelWidth,2)),trackPanelThickness+booleanOverlap*2]);
                }
            }
           
            //bottom-left corner rounding
           difference(){
                translate([-booleanOverlap,-booleanOverlap,-booleanOverlap])
                cube([trackWidth*2+booleanOverlap*2,trackWidth*2+booleanOverlap*2,trackPanelThickness + booleanOverlap*2]);
                translate([trackWidth,trackWidth,-booleanOverlap])
                    cylinder(r=trackWidth,h=trackPanelThickness + booleanOverlap*2);
                translate([trackWidth*2,-trackWidth,0])
                    rotate([0,0,45])
                        cube([trackWidth*4,trackWidth*4,trackPanelThickness + booleanOverlap*2]);
           }
           //top-left corner cuttoff
           translate([-booleanOverlap,(trackPanelWidth/2) - booleanOverlap, - booleanOverlap])
               rotate([0,0,45])
                   cube([trackPanelWidth + booleanOverlap*2, trackPanelWidth + booleanOverlap*2, trackPanelThickness + booleanOverlap*2]);
           //Top angle cutoff
           translate([-booleanOverlap, (trackPanelWidth * .75) - booleanOverlap, - booleanOverlap])
               rotate([0,0,3])
                   cube([trackPanelLength + booleanOverlap*2, trackPanelWidth + booleanOverlap*2, trackPanelThickness + booleanOverlap*2]);
           //Bottom-right corner rounding
           translate([trackPanelLength-lidTolerance, -booleanOverlap,-booleanOverlap])
                   rotate([0,0,0])
                   cube([trackPanelWidth, trackPanelWidth, trackPanelThickness + booleanOverlap*2]);
           
           
        }//end of difference
    //Connecting tabs
    translate([trackPanelLength*.66,-lidThickness, 0])    
        cube([trackPanelThickness,lidThickness+1,trackPanelThickness]);
    translate([trackPanelLength*.22, -lidThickness, 0])    
        cube([trackPanelThickness,lidThickness+1,trackPanelThickness]);    
    }//end of union    
}// end of CreateControlTrack module
module CreateRoller(                rollerDiameter,
                                    rollerLength,
                                    rollerPinDiameter){
difference(){
   
    cylinder(d=rollerDiameter, h=rollerLength);                        
    }
    translate([0,0,-2.5])
    cylinder(d=rollerPinDiameter, h=rollerLength +5);
}

module CreateLidHinge(              boxRoundCorners,
                                    boxWidth,
                                    boxLength,
                                    boxHeight,
                                    boxHingeDiameter,
                                    boxHingePinDiameter,  
                                    boxHingeZOffset,
                                    boxHingeYOffset,
                                    boxHingeTolerance,
                                    boxHingeClearance,
                                    boxHingeNumberOfSplits,
                                    pinTolerance,
                                    boxHingeSupportZOffset,
                                    boxHingeSupportYOffset,
                                    lidHingeZOffset,
                                    lidHingeYOffset,
                                    lidHingeXOffset,
                                    lidHingeTolerance,
                                    lidOverlap,
                                    booleanOverlap){
difference(){
    union(){
        //hingepart is created here
        if (boxRoundCorners){
           
            translate([boxLength + lidOverlap/2 + lidTolerance/2 - (boxCornerRoundness*2) + lidHingeXOffset,
                       boxWidth +lidHingeYOffset -(boxCornerRoundness/2) - lidOverlap/2 + lidTolerance/2,
                       (lidThickness)+lidHingeZOffset]){
                //remember rotation is counterclockwise
                rotate(a=[0,270,0]){
                      cylinder(d=boxHingeDiameter, boxLength - (boxCornerRoundness * 2));
                }
            }
        } else {
               translate([lidOverlap/2 + lidTolerance/2 +lidHingeXOffset,
                       (boxWidth + lidHingeYOffset + boxHingeDiameter/2),
                       (lidThickness)+lidHingeZOffset ]){
                //remember rotation is counterclockwise
                    rotate(a=[0,90,0])
                    {
                          cylinder(d=boxHingeDiameter, boxLength);
                    }
                }  
        }
        //add geometry to the hinge here
     }
     
     //hingehole
     if(boxRoundCorners){
         translate([boxLength + lidOverlap/2 + lidTolerance/2 - (boxCornerRoundness*2) + lidHingeXOffset,
                           boxWidth +lidHingeYOffset -(boxCornerRoundness/2) - lidOverlap/2 + lidTolerance/2,
                           (lidThickness)+lidHingeZOffset]){
                    //remember rotation is counterclockwise
                    rotate(a=[0,270,0]){
                          cylinder(d=boxHingePinDiameter, boxLength*2 +booleanOverlap,center=true);    
                    }
         }
     }else{
          translate([lidOverlap/2 + lidTolerance/2 +lidHingeXOffset +booleanOverlap,
                       (boxWidth + lidHingeYOffset + boxHingeDiameter/2),
                       (lidThickness)+lidHingeZOffset ]){
                //remember rotation is counterclockwise
                    rotate(a=[0,90,0]){
                          cylinder(d=boxHingePinDiameter, boxLength*2 +booleanOverlap,center=true);    
                    }
         }  
     }
         
       
      //hingeslots
      //here the part to be subtracted from the hinge is created
        if(boxRoundCorners){
                translate([lidOverlap/2 -lidTolerance + lidHingeXOffset,
                               boxWidth +lidHingeYOffset -(boxCornerRoundness/2) - lidOverlap/2 + lidTolerance/2,
                               (lidThickness)+lidHingeZOffset]){
                    rotate(a=[0,90,0])
                       {
                                            for ( i = [0 : boxHingeNumberOfSplits/2] )
                                                {
                                                   
                                                    translate([0, 0, boxLength/boxHingeNumberOfSplits * i *2])
                                                    cylinder(d=boxHingeDiameter+boxHingeTolerance+booleanOverlap + boxHingeClearance,
                                                            (boxLength/boxHingeNumberOfSplits) + boxHingeTolerance + lidHingeTolerance);
                                                }
                       }
                       
                }
        }else{
                translate([lidOverlap/2 -lidTolerance + lidHingeXOffset,
                                       boxWidth +lidHingeYOffset  + lidOverlap + lidTolerance,
                                       (lidThickness)+lidHingeZOffset]){
                            rotate(a=[0,90,0])
                               {
                                                    for ( i = [0 : boxHingeNumberOfSplits/2] )
                                                        {
                                                           
                                                            translate([0, 0, boxLength/boxHingeNumberOfSplits * i *2])
                                                            cylinder(d=boxHingeDiameter+boxHingeTolerance+booleanOverlap + boxHingeClearance,
                                                                    (boxLength/boxHingeNumberOfSplits) + boxHingeTolerance + lidHingeTolerance);
                                                        }
                               }
                               
                }    
        }//end of hinge slots
     
     }//end of difference (hinge, hingehole, hingeslots trackPanelSlots)    
 }//end of module
module CreateHinge(                 boxRoundCorners,
                                    boxWidth,
                                    boxLength,
                                    boxHeight,
                                    boxHingeDiameter,
                                    boxHingePinDiameter,  
                                    boxHingeZOffset,
                                    boxHingeYOffset,
                                    boxHingeTolerance,
                                    boxHingeClearance,
                                    boxHingeNumberOfSplits,
                                    pinTolerance,
                                    boxHingeSupportZOffset,
                                    boxHingeSupportYOffset,
                                    lidHingeZOffset,
                                    lidHingeYOffset,
                                    lidHingeTolerance,
                                    booleanOverlap){
   
 //Create Hinge and hinge support
    //difference to create hole in hinge and hinge slots
   
    difference(){
       union(){
        //hingepart is created here
        if (boxRoundCorners){
            translate([0,
                       ((boxWidth / 2)+(boxHingeYOffset + (boxHingeDiameter/2))),
                       (boxHeight/2) ]){
                //remember rotation is counterclockwise
                rotate(a=[0,270,0]){
                      cylinder(d=boxHingeDiameter, boxLength - (boxCornerRoundness * 2),center=true);
                }
            }
        } else {
               translate([0,
                       ((boxWidth / 2)+(boxHingeYOffset + (boxHingeDiameter/2))),
                       (boxHeight/2) ]){
                //remember rotation is counterclockwise
                rotate(a=[0,270,0])
                {
                      cylinder(d=boxHingeDiameter, boxLength - (boxCornerRoundness * 2),center=true);
                }
            }  
        }
        //support part is created here, also this part is unioned to the hingepart
        if(boxRoundCorners){
             difference(){
                 translate([0,((boxWidth / 2)+(boxHingeYOffset+boxHingeSupportYOffset)),((boxHeight/2)+boxHingeZOffset)]){
                     rotate(a=[0,270,0]){
                        rotate(a=[0,0,-25]){
                            cylinder(d=boxHingeDiameter*4, (boxLength-(boxCornerRoundness * 2)), $fn=4,center=true);                                  
                        }
                     }
                 }
                 translate([0,boxWidth/4,boxHeight-(boxHeight/4) - booleanOverlap]){
                     //cut for top of hinge support
                     cube([boxLength +booleanOverlap, boxWidth/2, boxHeight/2], ,center=true);
                 }
                 //cut for removing hinge support from inside box
                 cube([boxLength-(booleanOverlap), boxWidth-(booleanOverlap), boxHeight- booleanOverlap],center=true);
             }
         }else{
             difference(){
                 translate([0,((boxWidth / 2)+(boxHingeYOffset+boxHingeSupportYOffset)),((boxHeight/2)+boxHingeZOffset)]){
                     rotate(a=[0,270,0]){
                        rotate(a=[0,0,-25]){
                            cylinder(d=boxHingeDiameter*4, (boxLength), $fn=4,center=true);                                  
                        }
                     }
                 }
                 translate([0,boxWidth/4,boxHeight-(boxHeight/4) - booleanOverlap]){
                     //cut for top of hinge support
                     cube([boxLength +booleanOverlap, boxWidth/2, boxHeight/2], ,center=true);
                 }
                 //cut for removing hinge support from inside box
                 cube([boxLength-booleanOverlap, boxWidth-booleanOverlap, boxHeight-booleanOverlap],center=true);
             }
         }//end of else  end of addition of geomotry
     }
      //hingehole
      translate([0, ((boxWidth / 2) + (boxHingeYOffset+boxHingeDiameter/2)), ((boxHeight/2))]){
                                            rotate(a=[0,-90,0]){
                                               cylinder(d=boxHingePinDiameter, boxLength + booleanOverlap,center=true);    
                                            }
                                        }  
       //hingeslots
       //here the part to be subtracted from the hinge is created
        translate([0,
                   ((boxWidth / 2)+(boxHingeYOffset + (boxHingeDiameter/2))),
                   ((boxHeight/2))]){
            rotate(a=[0,90,0])
               translate([0,0,(-boxLength/2) ]){
                    for ( i = [0 : boxHingeNumberOfSplits/2] ){
                           
                            translate([0, 0, boxLength/boxHingeNumberOfSplits * i *2])
                            cylinder(d=boxHingeDiameter+boxHingeTolerance+booleanOverlap + boxHingeClearance,
                                      (boxLength/boxHingeNumberOfSplits) + boxHingeTolerance,
                                       center=true);
                    }
               }
        } //end of hinge slots                                
     }//end of difference (hinge, hingehole, hingeslots)
     
     
   
     
     
   
}//end of Hinge Module
                           
                           
//**********************END OF DECLARATIONS***********************************

if(arched){
    CreateArchedBody(         boxLength,
                             boxWidth,
                             boxHeight,
                             boxBottomThickness,
                             boxWallThickness,
                             boxRoundCorners,
                             boxCornerRoundness,
                             boxCornerSmoothness,
                             boxHingeDiameter,
                             boxHingePinDiameter,  
                             boxHingeZOffset,
                             boxHingeYOffset,
                             boxHingeTolerance,
                             boxHingeClearance,
                             boxHingeNumberOfSplits,
                             pinTolerance,
                             controlArmPinDiameter,
                             boxControlArmHoleZOffset,  
                             boxControlArmHoleYOffset,
                             controlArmPinTolerance,
                             boxHingeSupportZOffset,
                             boxHingeSupportYOffset,
                             booleanOverlap,
                             boxArcHeight,
                             boxArcRadius
                             );
}else{                        
   CreateNonArchedBody(          boxLength,
                                 boxWidth,
                                 boxHeight,
                                 boxBottomThickness,
                                 boxWallThickness,
                                 boxRoundCorners,
                                 boxCornerRoundness,
                                 boxCornerSmoothness,
                                 boxHingeDiameter,
                                 boxHingePinDiameter,  
                                 boxHingeZOffset,
                                 boxHingeYOffset,
                                 boxHingeTolerance,
                                 boxHingeClearance,
                                 boxHingeNumberOfSplits,
                                 pinTolerance,
                                 controlArmPinDiameter,
                                 boxControlArmHoleZOffset,  
                                 boxControlArmHoleYOffset,
                                 controlArmPinTolerance,
                                 boxHingeSupportZOffset,
                                 boxHingeSupportYOffset,
                                 booleanOverlap,
                                 boxArcHeight,
                                 boxArcRadius);
}    


 if(boxRoundCorners){
     rotate([270,0,0])
      union(){
        translate([-boxLength/2 - lidTolerance/2 - lidOverlap/2 + boxCornerRoundness,
                   -boxWidth/2  - lidTolerance/2 - lidOverlap/2 + boxCornerRoundness -52.7,
                   (boxHeight/2)+ booleanOverlap-lidLipHeight+33.5]){
            CreateLidHinge(  boxRoundCorners,
                     boxWidth,
                     boxLength,
                     boxHeight,
                     boxHingeDiameter,
                     boxHingePinDiameter,  
                     boxHingeZOffset,
                     boxHingeYOffset,
                     boxHingeTolerance,
                     boxHingeClearance,
                     boxHingeNumberOfSplits,
                     pinTolerance,
                     boxHingeSupportZOffset,
                     boxHingeSupportYOffset,
                     lidHingeZOffset,
                     lidHingeYOffset,
                     lidHingeXOffset,
                     lidHingeTolerance,
                     lidOverlap,
                     booleanOverlap);  
                 
        CreateNonArchedLid( lidLipHeight,
                        lidThickness,
                        lidTolerance,
                        lidHingeZOffset,
                        lidHingeYOffset,
                        lidHingeTolerance,
                        lidOverlap,
                        hingeSlotXOffset,
                        hingeSlotYOffset,
                        hingeSlotZOffset,
                        boxLength,
                        boxWidth,
                        boxHeight,
                        boxRoundCorners,
                        boxCornerRoundness,
                        boxCornerSmoothness,
                        boxHingeDiameter,
                        boxHingePinDiameter,
                        boxHingeNumberOfSplits,
                        dispenserHoleLength,
                        dispenserHoleWidth,
                        dispenserHoleXOffset,
                        dispenserHoleYOffset,
                        rollerLength,
                        trackPanelThickness,
                        booleanOverlap);    
                    }//end of Translate
                }//end of union

 }else{
    translate([-boxLength/2 - lidTolerance/2 - lidOverlap/2,
               -boxWidth/2  - lidTolerance/2 - lidOverlap/2,
               (boxHeight/2)+ booleanOverlap-lidLipHeight]){
           
           
CreateNonArchedLid( lidLipHeight,
                    lidThickness,
                    lidTolerance,
                    lidHingeZOffset,
                    lidHingeYOffset,
                    lidHingeTolerance,
                    lidOverlap,
                    hingeSlotXOffset,
                    hingeSlotYOffset,
                    hingeSlotZOffset,
                    boxLength,
                    boxWidth,
                    boxHeight,
                    boxRoundCorners,
                    boxCornerRoundness,
                    boxCornerSmoothness,
                    boxHingeDiameter,
                    boxHingePinDiameter,
                    boxHingeNumberOfSplits,
                    dispenserHoleLength,
                    dispenserHoleWidth,
                    dispenserHoleXOffset,
                    dispenserHoleYOffset,
                    rollerLength,
                    trackPanelThickness,
                    booleanOverlap);  
               }
     }                                  
   
 

translate([-39.25,3,3.5])
    rotate([0,270,0])
        rotate([0,0,44])
        CreateControlArm(                   controlArmLength,
                                            controlArmHeight,
                                            controlArmThickness,
                                            controlArmPinDiameter,
                                            controlArmHoleZOffset,
                                            controlArmHoleYOffset,
                                            controlArmPinTolerance);
translate([44.25,3,3.5])
    rotate([0,270,0])
        rotate([0,0,44])
        CreateControlArm(                   controlArmLength,
                                            controlArmHeight,
                                            controlArmThickness,
                                            controlArmPinDiameter,
                                            controlArmHoleZOffset,
                                            controlArmHoleYOffset,
                                            controlArmPinTolerance);  
rotate([0,90,0])
translate([-31,29,-rollerLength/2])
CreateRoller(rollerDiameter,
                                    rollerLength,
                                    rollerPinDiameter);

Reply | Threaded
Open this post in threaded view
|

Re: Can I get some code review up in here?

Peter Falke
There is an error with the triangular piece below the hinge, it extends below the box.

2015-04-11 1:03 GMT+02:00 linkreincarnate <[hidden email]>:
So I just finished my first major project in openscad thanks to all of you
who helped out with my questions.  That said I am sure the code could be
optimized for readability and maintainability.  Would anyone in here be so
kind as to look over my code and offer me some suggestions or examples of
how I could make it better and more easily parametric.

I am specifically interested in creating better encapsulation, reducing code
duplication, and optimizing for Thingiverse's customizer.



Giant text dump follows.

//3d printable cigarette rolling machine
//Created By LinkReincarnate
//CC Share Alike Attribution Non-Commercial
//*************VARIABLE DECLARATION SECTION******** all values are in mm


//make sure to change the hingeSlotXOffset when you change the box length.
boxLength = 90.4;
boxWidth = 81.25;
boxHeight = 19.2;
boxBottomThickness = 2;
boxWallThickness = .67;
boxArcHeight = 3.5;
boxArcRadius=1;
boxControlArmHoleZOffset = 3.5;
boxControlArmHoleYOffset = 3;
boxHingePinDiameter = 3;
boxHingeDiameter= 5;
boxHingeZOffset = -5;
boxHingeYOffset = 0;
boxHingeTolerance = .1;
boxHingeSupportZOffset= 0;
boxHingeSupportYOffset = -4.5;
boxHingeNumberOfSplits = 7;
boxHingeClearance=1;
//the following variables determine the details of the cylinder (or sphere)
used for minkowski sums
boxCornerRoundness = 7;
boxCornerSmoothness = 16;

controlArmLength = 38.5;
controlArmHeight = 7;
controlArmThickness = 5;
controlArmPinDiameter = 2;
controlArmHoleZOffset = 0;
controlArmHoleYOffset = 0;
controlArmPinTolerance = .1;

lidLipHeight = 5;
lidThickness = 5;
lidTolerance = 1;
lidHingeZOffset = 0;
lidHingeYOffset = 1;
lidHingeXOffset =.4;
lidHingeTolerance = 1;
lidOverlap = 2;

//moves hinge slot cutouts left and right
hingeSlotXOffset = 0;
hingeSlotYOffset = 0;
hingeSlotZOffset = 0;

dispenserHoleLength = 71.5; //also used for dist between tracks
dispenserHoleWidth = 11.5;
dispenserHoleXOffset = 0;
dispenserHoleYOffset = 0;

trackPanelLength = 76;
trackPanelWidth = 19;
trackPanelThickness = 3;
trackWidth = 2.5;
trackLength = 61;
trackHeight = 14;
trackTolerance = 1;
trackControlPoint1X = 3;
trackControlPoint1Y = 3;
trackControlPoint1Z = 0;
trackControlPoint2X = 9;
trackControlPoint2Y = 9;
trackControlPoint2Z = 0;
trackControlPoint3X = 45;
trackControlPoint3Y = 8;
trackControlPoint3Z = 0;
trackControlPoint4X = 57;
trackControlPoint4Y = 14;
trackControlPoint4Z = 0;


rollerDiameter = 7;
rollerLength = 71;

rollerPinDiameter = 2;
hingePinDiameter = 1.6;
pinLength= 71;

pinTolerance = 1;
cigaretteDiameter = 7.75;
cigaretteLength = 70;

booleanOverlap = .01; //to ensure that the faces used to difference() dont
line up
lowRollingClearance = 5; //the distance from the center of the rolling pin
to the lid at the lowest point.
hightRollingClearance = 12.6;

boxRoundCorners = true;
arched = true;
//uses math to determin the arc radius of the curve of the box and creates
the appropriate cylinder

//*************MODULE DECLARATION SECTION***************************
module CreateArc(            arcLength,
                             arcHeight,
                             cylinderHeight){
    carveRadius = ((arcHeight/2)+((arcLength * arcLength)/arcHeight *
8)/(53));
    rotate(a=[90,180,90]){
        translate([0,-carveRadius + arcHeight - (boxHeight/2),0]){
            cylinder(r=carveRadius, h=cylinderHeight+booleanOverlap,
$fn=1024, center=true);
        }

    }
}//end of module


module CreateNonArchedBody(  boxLength,
                             boxWidth,
                             boxHeight,
                             boxBottomThickness,
                             boxWallThickness,
                             boxRoundCorners,
                             boxCornerRoundness,
                             boxCornerSmoothness,
                             boxHingeDiameter,
                             boxHingePinDiameter,
                             boxHingeZOffset,
                             boxHingeYOffset,
                             boxHingeTolerance,
                             boxHingeClearance,
                             boxHingeNumberOfSplits,
                             pinTolerance,
                             controlArmPinDiameter,
                             boxControlArmHoleZOffset,
                             boxControlArmHoleYOffset,
                             controlArmPinTolerance,
                             boxHingeSupportZOffset,
                             boxHingeSupportYOffset,
                             booleanOverlap){
 //union joins the difference of the outer and inner bodies with a pinhole
for the arms and the hinge parts
    union(){
        //create body
         if (boxRoundCorners){
           difference(){
                $fn=boxCornerSmoothness;
                minkowski(){
                 cube([boxLength-(2*boxCornerRoundness),boxWidth -
(2*boxCornerRoundness),boxHeight/2],
                     center = true);
                 cylinder(r=boxCornerRoundness,h=boxHeight/2, center=true);
                }
                translate([0,0,(boxBottomThickness/2) + booleanOverlap]) {
                    $fn=boxCornerSmoothness;
                    minkowski()
                    {
                     cube([boxLength -
boxWallThickness-(2*boxCornerRoundness),
                              boxWidth - boxWallThickness
-(2*boxCornerRoundness),
                              ((boxHeight/2) - (boxBottomThickness/2))],
                              center = true);
                     cylinder(r=boxCornerRoundness,h=((boxHeight/2) -
(boxBottomThickness/2)), center=true);
                    }
                }
                //create pinholes to connect control arms
                rotate(a=[0, -90, 0]){

translate([boxControlArmHoleZOffset,boxControlArmHoleYOffset,0]){
                        cylinder(d= (controlArmPinDiameter +
controlArmPinTolerance),
                                     boxLength + booleanOverlap,
                                     center=true );
                    }
                }

            } //end of difference
         } else {
              difference(){
                    cube([boxLength,boxWidth,boxHeight],
                         center = true);
                    translate([0,0,(boxBottomThickness/2) +booleanOverlap])
{
                        cube([boxLength - boxWallThickness,
                              boxWidth - boxWallThickness,
                              (boxHeight - boxBottomThickness)],
                              center = true);
                    }
                    //create pinholes to connect control arms
                    rotate(a=[0, -90, 0]){

translate([boxControlArmHoleZOffset,boxControlArmHoleYOffset,0]){
                            cylinder(d= (controlArmPinDiameter +
controlArmPinTolerance),
                                         boxLength + booleanOverlap,
                                         center=true );
                        }
                    }

              }
         }
         CreateHinge(boxRoundCorners,
                     boxWidth,
                     boxLength,
                     boxHeight,
                     boxHingeDiameter,
                     boxHingePinDiameter,
                     boxHingeZOffset,
                     boxHingeYOffset,
                     boxHingeTolerance,
                     boxHingeClearance,
                     boxHingeNumberOfSplits,
                     pinTolerance,
                     boxHingeSupportZOffset,
                     boxHingeSupportYOffset,
                     lidHingeZOffset,
                     lidHingeYOffset,
                     lidHingeTolerance,
                     booleanOverlap);
     }// end of union body and hinge
}//end of module
module CreateArchedBody(     boxLength,
                             boxWidth,
                             boxHeight,
                             boxBottomThickness,
                             boxWallThickness,
                             boxRoundCorners,
                             boxCornerRoundness,
                             boxCornerSmoothness,
                             boxHingeDiameter,
                             boxHingePinDiameter,
                             boxHingeZOffset,
                             boxHingeYOffset,
                             boxHingeTolerance,
                             boxHingeClearance,
                             boxHingeNumberOfSplits,
                             pinTolerance,
                             controlArmPinDiameter,
                             boxControlArmHoleZOffset,
                             boxControlArmHoleYOffset,
                             controlArmPinTolerance,
                             boxHingeSupportZOffset,
                             boxHingeSupportYOffset,
                             booleanOverlap,
                             boxArcHeight,
                             boxArcRadius
                             ){
    union(){
    //create body
      if (boxRoundCorners){
         translate([0,0,boxHingeSupportZOffset+boxArcHeight+1])
             difference(){
                intersection(){
                    $fn=boxCornerSmoothness;
                    minkowski(){
                     cube([boxLength-(2*boxCornerRoundness),
                           boxWidth - (2*boxCornerRoundness),
                           boxHeight+boxArcHeight/2],
                         center = true);
                     cylinder(r=boxCornerRoundness,h=boxHeight +
boxArcHeight/2);
                    }
                    translate([0,0,-boxHeight+boxArcHeight])
                        CreateArc(boxWidth, boxArcHeight, boxLength);
                 }
                translate([0,0,(boxBottomThickness/2)]){
                   intersection(){
                         $fn=boxCornerSmoothness;
                         minkowski(){
                             cube([boxLength -
boxWallThickness-(2*boxCornerRoundness),
                                   boxWidth - boxWallThickness
-(2*boxCornerRoundness),
                                   (((boxHeight+boxArcHeight/2) -
boxBottomThickness) + booleanOverlap)],
                                   center = true);
                             cylinder(r=boxCornerRoundness,h=boxHeight/2);
                        }
                        translate([0,0,-boxHeight+boxArcHeight])
                            CreateArc(boxWidth, boxArcHeight, boxLength);
                    }
                }
                //create pinholes to connect control arms
                rotate(a=[0, -90, 0]){

translate([boxControlArmHoleZOffset,boxControlArmHoleYOffset,0]){
                        cylinder(d= (controlArmPinDiameter +
                                     controlArmPinTolerance),
                                     boxLength + booleanOverlap,
                                     center=true );
                    }
                }

                CreateArc(boxWidth, boxArcHeight, boxLength+booleanOverlap);
              //insert objects here to difference them from the main body
      }
      } else {
          difference(){
              intersection(){
                cube([boxLength,boxWidth,boxHeight+boxArcHeight],
                     center = true);
                translate([0,0,-boxHeight+boxArcHeight]){
                    CreateArc(boxWidth, boxArcHeight, boxLength);
                }

              }
              intersection(){
                    translate([0,0,(boxBottomThickness/2)]){
                        cube([boxLength - boxWallThickness,
                              boxWidth - boxWallThickness,
                              ((boxHeight +boxArcHeight -
boxBottomThickness) + booleanOverlap)],
                              center = true);
                    }
                    translate([0,0,-boxHeight+boxArcHeight]){
                         CreateArc(boxWidth, boxArcHeight, boxLength);
                    }
                }
                //create pinholes to connect control arms
                rotate(a=[0, -90, 0]){

translate([boxControlArmHoleZOffset,boxControlArmHoleYOffset,0]){
                       cylinder(d= (controlArmPinDiameter +
                                    controlArmPinTolerance),
                                    boxLength + booleanOverlap,
                                    center=true );
                   }
                }
                CreateArc(boxWidth,boxArcHeight,boxLength + booleanOverlap);
                //insert here to difference with body
            }
      }
    //Create Hinge and hinge support
    CreateHinge( boxRoundCorners,
                 boxWidth,
                 boxLength,
                 boxHeight,
                 boxHingeDiameter,
                 boxHingePinDiameter,
                 boxHingeZOffset,
                 boxHingeYOffset,
                 boxHingeTolerance,
                 boxHingeClearance,
                 boxHingeNumberOfSplits,
                 pinTolerance,
                 boxHingeSupportZOffset,
                 boxHingeSupportYOffset,
                 lidHingeZOffset,
                 lidHingeYOffset,
                 lidHingeTolerance,
                 booleanOverlap);
    //insert new parts to be added to the body here
    }
}//end of module
module CreateNonArchedLid(          lidLipHeight,
                                    lidThickness,
                                    lidTolerance,
                                    lidHingeZOffset,
                                    lidHingeYOffset,
                            //add lidHingeXOffset and hingeSlotXOffset
                                    lidHingeTolerance,
                                    lidOverlap,
                                    hingeSlotXOffset,
                                    hingeSlotYOffset,
                                    hingeSlotZOffset,
                                    boxLength,
                                    boxWidth,
                                    boxHeight,
                                    boxRoundCorners,
                                    boxCornerRoundness,
                                    boxCornerSmoothness,
                                    boxHingeDiameter,
                                    boxHingePinDiameter,
                                    boxHingeNumberOfSplits,
                                    dispenserHoleLength,
                                    dispenserHoleWidth,
                                    dispenserHoleXOffset,
                                    dispenserHoleYOffset,
                                    rollerLength,
                                    trackPanelThickness,
                                    booleanOverlap){
  if (boxRoundCorners){
             difference(){
                    $fn=boxCornerSmoothness;
                    //this is the exterior of the lid
                    minkowski(){
                     cube([lidOverlap + boxLength + lidTolerance - (2 *
boxCornerRoundness),
                           lidOverlap + boxWidth + lidTolerance - (2 *
boxCornerRoundness),
                           ((lidThickness + lidLipHeight)/2)]);
                     cylinder(r=boxCornerRoundness,h=((lidThickness +
lidLipHeight)/2));
                    }
                    //this is the interior cutout
                    translate([lidOverlap/2,lidOverlap/2,-booleanOverlap ]){
                        $fn=boxCornerSmoothness;
                        minkowski()
                        {
                         cube([boxLength + lidTolerance - (2 *
boxCornerRoundness) ,
                               boxWidth + lidTolerance - (2 *
boxCornerRoundness),
                               lidLipHeight/2]);
                         cylinder(r=boxCornerRoundness,h=lidLipHeight/2);
                        }
                    }
                    //this is the hinge lip cutout
                    {
                    translate([-((boxCornerRoundness/2) + (lidTolerance/2) +
((lidOverlap/2))),0,-booleanOverlap])
                    cube([boxLength - lidTolerance,
                               boxWidth + lidTolerance,
                               lidLipHeight +booleanOverlap]);
                    }
                    //hingeslots
                    //this splits the hinge cylinder into individual pieces,
also cuts clearance slots into the lid
                    difference(){
                        //change this rotate to 90 to invert the hinge slot
cut over one hingelength
                      rotate(a=[0,270,0])
                       translate([lidLipHeight,
                                  boxWidth + lidOverlap -
(boxCornerRoundness),
                                  -((boxCornerRoundness/2)) -boxLength]){
                          translate([0,0,hingeSlotXOffset + lidOverlap/2 +
lidTolerance])
                          {
                               for ( i = [0 : boxHingeNumberOfSplits/2] )
                                    {
                                        //LOOK HERE TO TRY TO FIX HINGE SLOT
MISALIGNMENT
                                        translate([0, 0,
boxLength/boxHingeNumberOfSplits * i *2])

cylinder(d=boxHingeDiameter+boxHingeTolerance+booleanOverlap +
boxHingeClearance,

(boxLength/boxHingeNumberOfSplits) + boxHingeTolerance + lidHingeTolerance);
                                     }
                          }

                        }
                        //this cube acts as an endstop precenting the hinge
from being cut past the point it needs to be cut
                        translate([-boxCornerRoundness + boxLength
-(boxCornerRoundness/2) +lidTolerance/2 - (lidOverlap/2),
                                   0,
                                   lidLipHeight -boxHingeDiameter -
boxHingeTolerance - boxHingeClearance,]){
                            cube([boxCornerRoundness,
                                  boxWidth+10,
                                  boxHeight]);
                        }
                        //same as above but on the other side! exciting...
                        translate([-boxCornerRoundness,
                                   0,
                                   lidLipHeight -boxHingeDiameter -
boxHingeTolerance - boxHingeClearance]){
                            cube([boxCornerRoundness,
                                  boxWidth+10,
                                  boxHeight]);
                        }
                    }//end of hinge slot subtration
                    //dispenser hole
                    translate([boxCornerRoundness/2 +lidTolerance/2
,0,lidThickness-2])

cube([dispenserHoleLength,dispenserHoleWidth,lidThickness+10
+booleanOverlap]);
                    //trackPanelMountingHoles
  //***********Get the thickness out of the module somehow so i can arrange
the track panels outside the dispenser hole
                    translate([boxCornerRoundness/2
+lidTolerance/2,0,lidThickness+booleanOverlap]){
                     rotate([270,0,90]){
                     #CreateControlTrack(
                            controlArmLength,
                            controlArmHeight,
                            controlArmThickness,
                            controlArmPinDiameter,
                            controlArmHoleZOffset,
                            controlArmHoleYOffset,
                            controlArmPinTolerance,
                            lidLipHeight,
                            lidThickness,
                            lidTolerance,
                            boxLength,
                            boxWidth,
                            boxHeight,
                            boxRoundCorners,
                            boxCornerRoundness,
                            boxHingePinDiameter,
                            trackPanelLength,
                            trackPanelWidth,
                            trackPanelThickness,
                            trackWidth,
                            trackLength,
                            trackHeight,
                            trackTolerance,
                            trackControlPoint1X,
                            trackControlPoint1Y,
                            trackControlPoint1Z,
                            trackControlPoint2X,
                            trackControlPoint2Y,
                            trackControlPoint2Z,
                            trackControlPoint3X,
                            trackControlPoint3Y,
                            trackControlPoint3Z,
                            trackControlPoint4X,
                            trackControlPoint4Y,
                            trackControlPoint4Z);
                      translate([0,0,-dispenserHoleLength
-trackPanelThickness])
                     #CreateControlTrack(
                            controlArmLength,
                            controlArmHeight,
                            controlArmThickness,
                            controlArmPinDiameter,
                            controlArmHoleZOffset,
                            controlArmHoleYOffset,
                            controlArmPinTolerance,
                            lidLipHeight,
                            lidThickness,
                            lidTolerance,
                            boxLength,
                            boxWidth,
                            boxHeight,
                            boxRoundCorners,
                            boxCornerRoundness,
                            boxHingePinDiameter,
                            trackPanelLength,
                            trackPanelWidth,
                            trackPanelThickness,
                            trackWidth,
                            trackLength,
                            trackHeight,
                            trackTolerance,
                            trackControlPoint1X,
                            trackControlPoint1Y,
                            trackControlPoint1Z,
                            trackControlPoint2X,
                            trackControlPoint2Y,
                            trackControlPoint2Z,
                            trackControlPoint3X,
                            trackControlPoint3Y,
                            trackControlPoint3Z,
                            trackControlPoint4X,
                            trackControlPoint4Y,
                            trackControlPoint4Z);
                        }
                    }
             } // end of difference
         } else {
              difference(){
                   //this is the exterior of the lid
                   cube([lidOverlap + boxLength + lidTolerance,
                           lidOverlap + boxWidth + lidTolerance,
                           ((lidThickness + lidLipHeight))]);
                    //this is the interior cutout
                    translate([lidOverlap/2,lidOverlap +
booleanOverlap,-booleanOverlap]){
                        cube([boxLength + lidTolerance,
                               boxWidth + lidTolerance,
                               lidLipHeight]);
                    }
                    //this is the hinge lip cutout
                    translate([lidOverlap/2,lidOverlap/2,-booleanOverlap]){
                        cube([boxLength + lidTolerance,
                                   boxWidth + lidTolerance,
                                   lidLipHeight]);
                    }
                    //hingeslots
                    //this splits the hinge cylinder into individual pieces,
also cuts clearance slots into the lid
                    rotate(a=[0,90,0])
                       translate([-lidLipHeight,+boxWidth +
boxHingeDiameter/2,lidOverlap/2]){
                            for ( i = [0 : boxHingeNumberOfSplits] ){
                                    translate([0, 0,
boxLength/boxHingeNumberOfSplits * i *2])

cylinder(d=boxHingeDiameter+boxHingeTolerance+booleanOverlap +
boxHingeClearance,

(boxLength/boxHingeNumberOfSplits) + boxHingeTolerance + lidHingeTolerance);
                            }
                        }
              } // end of difference
         }//end of else


 }//end of Lid Module
module CreateArchedLid(             lidLipHeight,
                                    lidThickness,
                                    lidTolerance,
                                    lidHingeZOffset,
                                    lidHingeYOffset,
                                    lidHingeTolerance,
                                    boxLength,
                                    boxWidth,
                                    boxHeight,
                                    boxRoundCorners,
                                    boxCornerRoundness,
                                    boxCornerSmoothness,
                                    boxHingeDiameter,
                                    boxHingePinDiameter,
                                    dispenserHoleLength,
                                    dispenserHoleWidth,
                                    dispenserHoleXOffset,
                                    dispenserHoleYOffset,
                                    rollerLength,
                                    boxArcHeight,
                                    boxArcRadius,
                                    booleanOverlap)
                                    {}


module CreateControlArm(            controlArmLength,
                                    controlArmHeight,
                                    controlArmThickness,
                                    controlArmPinDiameter,
                                    controlArmHoleZOffset,
                                    controlArmHoleYOffset,
                                    controlArmPinTolerance){

    difference(){
        hull(){
            translate()
                cylinder(d=controlArmHeight, h=controlArmThickness);
            translate([controlArmLength,0,0])
                cylinder(d=controlArmHeight, h=controlArmThickness);
        }//end of hull
        translate([0,0,-controlArmThickness/2])
                #cylinder(d=controlArmPinDiameter, h=controlArmThickness*2,
$fn=32);
            translate([controlArmLength,0,-controlArmThickness/2])
                #cylinder(d=controlArmPinDiameter, h=controlArmThickness*2,
$fn=32);
    }//end of difference
}//end of module
module CreateControlTrack(          controlArmLength,
                                    controlArmHeight,
                                    controlArmThickness,
                                    controlArmPinDiameter,
                                    controlArmHoleZOffset,
                                    controlArmHoleYOffset,
                                    controlArmPinTolerance,
                                    lidLipHeight,
                                    lidThickness,
                                    lidTolerance,
                                    boxLength,
                                    boxWidth,
                                    boxHeight,
                                    boxRoundCorners,
                                    boxCornerRoundness,
                                    boxHingePinDiameter,
                                    trackPanelLength,
                                    trackPanelWidth,
                                    trackPanelThickness,
                                    trackWidth,
                                    trackLength,
                                    trackHeight,
                                    trackTolerance,
                                    trackControlPoint1X,
                                    trackControlPoint1Y,
                                    trackControlPoint1Z,
                                    trackControlPoint2X,
                                    trackControlPoint2Y,
                                    trackControlPoint2Z,
                                    trackControlPoint3X,
                                    trackControlPoint3Y,
                                    trackControlPoint3Z,
                                    trackControlPoint4X,
                                    trackControlPoint4Y,
                                    trackControlPoint4Z){
    union(){
        difference(){
            //Track Panel
            cube([trackPanelLength,trackPanelWidth, trackPanelThickness]);
            //Track
            hull(){

translate([trackControlPoint1X,trackControlPoint1Y,trackControlPoint1Z -
booleanOverlap])
                    cylinder(d=trackWidth+trackTolerance,h =
trackPanelThickness + booleanOverlap*2, $fn=32);


translate([trackControlPoint2X,trackControlPoint2Y,trackControlPoint2Z -
booleanOverlap])
                    cylinder(d=trackWidth+trackTolerance,h =
trackPanelThickness + booleanOverlap*2, $fn=64);
            }
            hull(){

translate([trackControlPoint2X,trackControlPoint2Y,trackControlPoint2Z -
booleanOverlap])
                    cylinder(d=trackWidth+trackTolerance,h =
trackPanelThickness + booleanOverlap*2, $fn=64);


translate([trackControlPoint3X,trackControlPoint3Y,trackControlPoint3Z -
booleanOverlap])
                    cylinder(d=trackWidth+trackTolerance,h =
trackPanelThickness + booleanOverlap*2, $fn=64);
            }
            hull(){

translate([trackControlPoint3X,trackControlPoint3Y,trackControlPoint3Z -
booleanOverlap])
                    cylinder(d=trackWidth+trackTolerance,h =
trackPanelThickness + booleanOverlap*2, $fn=64);


translate([trackControlPoint4X,trackControlPoint4Y,trackControlPoint4Z -
booleanOverlap])
                    cylinder(d=trackWidth+trackTolerance,h =
trackPanelThickness + booleanOverlap*2, $fn=64);
            }
            //rollerflap pin holes
            translate([trackPanelLength*.14,trackPanelWidth
*.07,-booleanOverlap])
                cylinder(d= boxHingePinDiameter, h= trackPanelThickness +
booleanOverlap*2, $fn=64);
            translate([trackPanelLength*.9,trackPanelWidth
*.14,-booleanOverlap])
                cylinder(d= boxHingePinDiameter, h= trackPanelThickness +
booleanOverlap*2, $fn=64);

            //Right Side Angle Cut
            translate([trackPanelLength,0,-booleanOverlap]){
                rotate([0,0,45]){

cube([trackPanelLength/4,sqrt(pow(trackPanelWidth,2)+pow(trackPanelWidth,2)),trackPanelThickness+booleanOverlap*2]);
                }
            }

            //bottom-left corner rounding
           difference(){
                translate([-booleanOverlap,-booleanOverlap,-booleanOverlap])

cube([trackWidth*2+booleanOverlap*2,trackWidth*2+booleanOverlap*2,trackPanelThickness
+ booleanOverlap*2]);
                translate([trackWidth,trackWidth,-booleanOverlap])
                    cylinder(r=trackWidth,h=trackPanelThickness +
booleanOverlap*2);
                translate([trackWidth*2,-trackWidth,0])
                    rotate([0,0,45])
                        cube([trackWidth*4,trackWidth*4,trackPanelThickness
+ booleanOverlap*2]);
           }
           //top-left corner cuttoff
           translate([-booleanOverlap,(trackPanelWidth/2) - booleanOverlap,
- booleanOverlap])
               rotate([0,0,45])
                   cube([trackPanelWidth + booleanOverlap*2, trackPanelWidth
+ booleanOverlap*2, trackPanelThickness + booleanOverlap*2]);
           //Top angle cutoff
           translate([-booleanOverlap, (trackPanelWidth * .75) -
booleanOverlap, - booleanOverlap])
               rotate([0,0,3])
                   cube([trackPanelLength + booleanOverlap*2,
trackPanelWidth + booleanOverlap*2, trackPanelThickness +
booleanOverlap*2]);
           //Bottom-right corner rounding
           translate([trackPanelLength-lidTolerance,
-booleanOverlap,-booleanOverlap])
                   rotate([0,0,0])
                   cube([trackPanelWidth, trackPanelWidth,
trackPanelThickness + booleanOverlap*2]);


        }//end of difference
    //Connecting tabs
    translate([trackPanelLength*.66,-lidThickness, 0])
        cube([trackPanelThickness,lidThickness+1,trackPanelThickness]);
    translate([trackPanelLength*.22, -lidThickness, 0])
        cube([trackPanelThickness,lidThickness+1,trackPanelThickness]);
    }//end of union
}// end of CreateControlTrack module
module CreateRoller(                rollerDiameter,
                                    rollerLength,
                                    rollerPinDiameter){
difference(){

    cylinder(d=rollerDiameter, h=rollerLength);
    }
    translate([0,0,-2.5])
    cylinder(d=rollerPinDiameter, h=rollerLength +5);
}

module CreateLidHinge(              boxRoundCorners,
                                    boxWidth,
                                    boxLength,
                                    boxHeight,
                                    boxHingeDiameter,
                                    boxHingePinDiameter,
                                    boxHingeZOffset,
                                    boxHingeYOffset,
                                    boxHingeTolerance,
                                    boxHingeClearance,
                                    boxHingeNumberOfSplits,
                                    pinTolerance,
                                    boxHingeSupportZOffset,
                                    boxHingeSupportYOffset,
                                    lidHingeZOffset,
                                    lidHingeYOffset,
                                    lidHingeXOffset,
                                    lidHingeTolerance,
                                    lidOverlap,
                                    booleanOverlap){
difference(){
    union(){
        //hingepart is created here
        if (boxRoundCorners){

            translate([boxLength + lidOverlap/2 + lidTolerance/2 -
(boxCornerRoundness*2) + lidHingeXOffset,
                       boxWidth +lidHingeYOffset -(boxCornerRoundness/2) -
lidOverlap/2 + lidTolerance/2,
                       (lidThickness)+lidHingeZOffset]){
                //remember rotation is counterclockwise
                rotate(a=[0,270,0]){
                      cylinder(d=boxHingeDiameter, boxLength -
(boxCornerRoundness * 2));
                }
            }
        } else {
               translate([lidOverlap/2 + lidTolerance/2 +lidHingeXOffset,
                       (boxWidth + lidHingeYOffset + boxHingeDiameter/2),
                       (lidThickness)+lidHingeZOffset ]){
                //remember rotation is counterclockwise
                    rotate(a=[0,90,0])
                    {
                          cylinder(d=boxHingeDiameter, boxLength);
                    }
                }
        }
        //add geometry to the hinge here
     }

     //hingehole
     if(boxRoundCorners){
         translate([boxLength + lidOverlap/2 + lidTolerance/2 -
(boxCornerRoundness*2) + lidHingeXOffset,
                           boxWidth +lidHingeYOffset -(boxCornerRoundness/2)
- lidOverlap/2 + lidTolerance/2,
                           (lidThickness)+lidHingeZOffset]){
                    //remember rotation is counterclockwise
                    rotate(a=[0,270,0]){
                          cylinder(d=boxHingePinDiameter, boxLength*2
+booleanOverlap,center=true);
                    }
         }
     }else{
          translate([lidOverlap/2 + lidTolerance/2 +lidHingeXOffset
+booleanOverlap,
                       (boxWidth + lidHingeYOffset + boxHingeDiameter/2),
                       (lidThickness)+lidHingeZOffset ]){
                //remember rotation is counterclockwise
                    rotate(a=[0,90,0]){
                          cylinder(d=boxHingePinDiameter, boxLength*2
+booleanOverlap,center=true);
                    }
         }
     }


      //hingeslots
      //here the part to be subtracted from the hinge is created
        if(boxRoundCorners){
                translate([lidOverlap/2 -lidTolerance + lidHingeXOffset,
                               boxWidth +lidHingeYOffset
-(boxCornerRoundness/2) - lidOverlap/2 + lidTolerance/2,
                               (lidThickness)+lidHingeZOffset]){
                    rotate(a=[0,90,0])
                       {
                                            for ( i = [0 :
boxHingeNumberOfSplits/2] )
                                                {

                                                    translate([0, 0,
boxLength/boxHingeNumberOfSplits * i *2])

cylinder(d=boxHingeDiameter+boxHingeTolerance+booleanOverlap +
boxHingeClearance,

(boxLength/boxHingeNumberOfSplits) + boxHingeTolerance + lidHingeTolerance);
                                                }
                       }

                }
        }else{
                translate([lidOverlap/2 -lidTolerance + lidHingeXOffset,
                                       boxWidth +lidHingeYOffset  +
lidOverlap + lidTolerance,
                                       (lidThickness)+lidHingeZOffset]){
                            rotate(a=[0,90,0])
                               {
                                                    for ( i = [0 :
boxHingeNumberOfSplits/2] )
                                                        {

                                                            translate([0, 0,
boxLength/boxHingeNumberOfSplits * i *2])

cylinder(d=boxHingeDiameter+boxHingeTolerance+booleanOverlap +
boxHingeClearance,

(boxLength/boxHingeNumberOfSplits) + boxHingeTolerance + lidHingeTolerance);
                                                        }
                               }

                }
        }//end of hinge slots

     }//end of difference (hinge, hingehole, hingeslots trackPanelSlots)
 }//end of module
module CreateHinge(                 boxRoundCorners,
                                    boxWidth,
                                    boxLength,
                                    boxHeight,
                                    boxHingeDiameter,
                                    boxHingePinDiameter,
                                    boxHingeZOffset,
                                    boxHingeYOffset,
                                    boxHingeTolerance,
                                    boxHingeClearance,
                                    boxHingeNumberOfSplits,
                                    pinTolerance,
                                    boxHingeSupportZOffset,
                                    boxHingeSupportYOffset,
                                    lidHingeZOffset,
                                    lidHingeYOffset,
                                    lidHingeTolerance,
                                    booleanOverlap){

 //Create Hinge and hinge support
    //difference to create hole in hinge and hinge slots

    difference(){
       union(){
        //hingepart is created here
        if (boxRoundCorners){
            translate([0,
                       ((boxWidth / 2)+(boxHingeYOffset +
(boxHingeDiameter/2))),
                       (boxHeight/2) ]){
                //remember rotation is counterclockwise
                rotate(a=[0,270,0]){
                      cylinder(d=boxHingeDiameter, boxLength -
(boxCornerRoundness * 2),center=true);
                }
            }
        } else {
               translate([0,
                       ((boxWidth / 2)+(boxHingeYOffset +
(boxHingeDiameter/2))),
                       (boxHeight/2) ]){
                //remember rotation is counterclockwise
                rotate(a=[0,270,0])
                {
                      cylinder(d=boxHingeDiameter, boxLength -
(boxCornerRoundness * 2),center=true);
                }
            }
        }
        //support part is created here, also this part is unioned to the
hingepart
        if(boxRoundCorners){
             difference(){
                 translate([0,((boxWidth /
2)+(boxHingeYOffset+boxHingeSupportYOffset)),((boxHeight/2)+boxHingeZOffset)]){
                     rotate(a=[0,270,0]){
                        rotate(a=[0,0,-25]){
                            cylinder(d=boxHingeDiameter*4,
(boxLength-(boxCornerRoundness * 2)), $fn=4,center=true);
                        }
                     }
                 }
                 translate([0,boxWidth/4,boxHeight-(boxHeight/4) -
booleanOverlap]){
                     //cut for top of hinge support
                     cube([boxLength +booleanOverlap, boxWidth/2,
boxHeight/2], ,center=true);
                 }
                 //cut for removing hinge support from inside box
                 cube([boxLength-(booleanOverlap),
boxWidth-(booleanOverlap), boxHeight- booleanOverlap],center=true);
             }
         }else{
             difference(){
                 translate([0,((boxWidth /
2)+(boxHingeYOffset+boxHingeSupportYOffset)),((boxHeight/2)+boxHingeZOffset)]){
                     rotate(a=[0,270,0]){
                        rotate(a=[0,0,-25]){
                            cylinder(d=boxHingeDiameter*4, (boxLength),
$fn=4,center=true);
                        }
                     }
                 }
                 translate([0,boxWidth/4,boxHeight-(boxHeight/4) -
booleanOverlap]){
                     //cut for top of hinge support
                     cube([boxLength +booleanOverlap, boxWidth/2,
boxHeight/2], ,center=true);
                 }
                 //cut for removing hinge support from inside box
                 cube([boxLength-booleanOverlap, boxWidth-booleanOverlap,
boxHeight-booleanOverlap],center=true);
             }
         }//end of else  end of addition of geomotry
     }
      //hingehole
      translate([0, ((boxWidth / 2) + (boxHingeYOffset+boxHingeDiameter/2)),
((boxHeight/2))]){
                                            rotate(a=[0,-90,0]){

cylinder(d=boxHingePinDiameter, boxLength + booleanOverlap,center=true);
                                            }
                                        }
       //hingeslots
       //here the part to be subtracted from the hinge is created
        translate([0,
                   ((boxWidth / 2)+(boxHingeYOffset +
(boxHingeDiameter/2))),
                   ((boxHeight/2))]){
            rotate(a=[0,90,0])
               translate([0,0,(-boxLength/2) ]){
                    for ( i = [0 : boxHingeNumberOfSplits/2] ){

                            translate([0, 0,
boxLength/boxHingeNumberOfSplits * i *2])

cylinder(d=boxHingeDiameter+boxHingeTolerance+booleanOverlap +
boxHingeClearance,
                                      (boxLength/boxHingeNumberOfSplits) +
boxHingeTolerance,
                                       center=true);
                    }
               }
        } //end of hinge slots
     }//end of difference (hinge, hingehole, hingeslots)






}//end of Hinge Module


//**********************END OF
DECLARATIONS***********************************

if(arched){
    CreateArchedBody(         boxLength,
                             boxWidth,
                             boxHeight,
                             boxBottomThickness,
                             boxWallThickness,
                             boxRoundCorners,
                             boxCornerRoundness,
                             boxCornerSmoothness,
                             boxHingeDiameter,
                             boxHingePinDiameter,
                             boxHingeZOffset,
                             boxHingeYOffset,
                             boxHingeTolerance,
                             boxHingeClearance,
                             boxHingeNumberOfSplits,
                             pinTolerance,
                             controlArmPinDiameter,
                             boxControlArmHoleZOffset,
                             boxControlArmHoleYOffset,
                             controlArmPinTolerance,
                             boxHingeSupportZOffset,
                             boxHingeSupportYOffset,
                             booleanOverlap,
                             boxArcHeight,
                             boxArcRadius
                             );
}else{
   CreateNonArchedBody(          boxLength,
                                 boxWidth,
                                 boxHeight,
                                 boxBottomThickness,
                                 boxWallThickness,
                                 boxRoundCorners,
                                 boxCornerRoundness,
                                 boxCornerSmoothness,
                                 boxHingeDiameter,
                                 boxHingePinDiameter,
                                 boxHingeZOffset,
                                 boxHingeYOffset,
                                 boxHingeTolerance,
                                 boxHingeClearance,
                                 boxHingeNumberOfSplits,
                                 pinTolerance,
                                 controlArmPinDiameter,
                                 boxControlArmHoleZOffset,
                                 boxControlArmHoleYOffset,
                                 controlArmPinTolerance,
                                 boxHingeSupportZOffset,
                                 boxHingeSupportYOffset,
                                 booleanOverlap,
                                 boxArcHeight,
                                 boxArcRadius);
}


 if(boxRoundCorners){
     rotate([270,0,0])
      union(){
        translate([-boxLength/2 - lidTolerance/2 - lidOverlap/2 +
boxCornerRoundness,
                   -boxWidth/2  - lidTolerance/2 - lidOverlap/2 +
boxCornerRoundness -52.7,
                   (boxHeight/2)+ booleanOverlap-lidLipHeight+33.5]){
            CreateLidHinge(  boxRoundCorners,
                     boxWidth,
                     boxLength,
                     boxHeight,
                     boxHingeDiameter,
                     boxHingePinDiameter,
                     boxHingeZOffset,
                     boxHingeYOffset,
                     boxHingeTolerance,
                     boxHingeClearance,
                     boxHingeNumberOfSplits,
                     pinTolerance,
                     boxHingeSupportZOffset,
                     boxHingeSupportYOffset,
                     lidHingeZOffset,
                     lidHingeYOffset,
                     lidHingeXOffset,
                     lidHingeTolerance,
                     lidOverlap,
                     booleanOverlap);

        CreateNonArchedLid( lidLipHeight,
                        lidThickness,
                        lidTolerance,
                        lidHingeZOffset,
                        lidHingeYOffset,
                        lidHingeTolerance,
                        lidOverlap,
                        hingeSlotXOffset,
                        hingeSlotYOffset,
                        hingeSlotZOffset,
                        boxLength,
                        boxWidth,
                        boxHeight,
                        boxRoundCorners,
                        boxCornerRoundness,
                        boxCornerSmoothness,
                        boxHingeDiameter,
                        boxHingePinDiameter,
                        boxHingeNumberOfSplits,
                        dispenserHoleLength,
                        dispenserHoleWidth,
                        dispenserHoleXOffset,
                        dispenserHoleYOffset,
                        rollerLength,
                        trackPanelThickness,
                        booleanOverlap);
                    }//end of Translate
                }//end of union

 }else{
    translate([-boxLength/2 - lidTolerance/2 - lidOverlap/2,
               -boxWidth/2  - lidTolerance/2 - lidOverlap/2,
               (boxHeight/2)+ booleanOverlap-lidLipHeight]){


CreateNonArchedLid( lidLipHeight,
                    lidThickness,
                    lidTolerance,
                    lidHingeZOffset,
                    lidHingeYOffset,
                    lidHingeTolerance,
                    lidOverlap,
                    hingeSlotXOffset,
                    hingeSlotYOffset,
                    hingeSlotZOffset,
                    boxLength,
                    boxWidth,
                    boxHeight,
                    boxRoundCorners,
                    boxCornerRoundness,
                    boxCornerSmoothness,
                    boxHingeDiameter,
                    boxHingePinDiameter,
                    boxHingeNumberOfSplits,
                    dispenserHoleLength,
                    dispenserHoleWidth,
                    dispenserHoleXOffset,
                    dispenserHoleYOffset,
                    rollerLength,
                    trackPanelThickness,
                    booleanOverlap);
               }
     }



translate([-39.25,3,3.5])
    rotate([0,270,0])
        rotate([0,0,44])
        CreateControlArm(                   controlArmLength,
                                            controlArmHeight,
                                            controlArmThickness,
                                            controlArmPinDiameter,
                                            controlArmHoleZOffset,
                                            controlArmHoleYOffset,
                                            controlArmPinTolerance);
translate([44.25,3,3.5])
    rotate([0,270,0])
        rotate([0,0,44])
        CreateControlArm(                   controlArmLength,
                                            controlArmHeight,
                                            controlArmThickness,
                                            controlArmPinDiameter,
                                            controlArmHoleZOffset,
                                            controlArmHoleYOffset,
                                            controlArmPinTolerance);
rotate([0,90,0])
translate([-31,29,-rollerLength/2])
CreateRoller(rollerDiameter,
                                    rollerLength,
                                    rollerPinDiameter);





--
View this message in context: http://forum.openscad.org/Can-I-get-some-code-review-up-in-here-tp12341.html
Sent from the OpenSCAD mailing list archive at Nabble.com.

_______________________________________________
OpenSCAD mailing list
[hidden email]
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org



--
[hidden email]

P.S. Falls meine E-Mail kürzer ausfällt als Dir angenehm ist:
Ich probiere gerade aus kurze Antworten statt gar keine Antworten zu schreiben.
Wenn Du gerne mehr lesen möchtest, dann lass es mich bitte wissen.

P.S. In case my e-mail is shorter than you enjoy:
I am currently trying short replies instead of no replies at all.
Please let me know, if you like to read more.

Enjoy!

_______________________________________________
OpenSCAD mailing list
[hidden email]
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
Reply | Threaded
Open this post in threaded view
|

Re: Can I get some code review up in here?

linkreincarnate
Thanks, I'll take a look and fix it.
Reply | Threaded
Open this post in threaded view
|

Re: Can I get some code review up in here?

nophead
Rather than passing dozens of parameters to each module I would represent objects like the box and hinge with lists of values and write a function to get each value from the list. Then the modules would only have two or three parameters.

On 12 April 2015 at 00:25, linkreincarnate <[hidden email]> wrote:
Thanks, I'll take a look and fix it.



--
View this message in context: http://forum.openscad.org/Can-I-get-some-code-review-up-in-here-tp12341p12345.html
Sent from the OpenSCAD mailing list archive at Nabble.com.

_______________________________________________
OpenSCAD mailing list
[hidden email]
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org


_______________________________________________
OpenSCAD mailing list
[hidden email]
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
Reply | Threaded
Open this post in threaded view
|

Re: Can I get some code review up in here?

linkreincarnate
Ok I am unfamiliar with lists in openscad I'll have to look into it.
Reply | Threaded
Open this post in threaded view
|

Re: Can I get some code review up in here?

nophead
Here is an example of how to use a named list to represent an object: https://github.com/nophead/Mendel90/blob/master/scad/vitamins/fans.scad

On 13 April 2015 at 11:44, linkreincarnate <[hidden email]> wrote:
Ok I am unfamiliar with lists in openscad I'll have to look into it.



--
View this message in context: http://forum.openscad.org/Can-I-get-some-code-review-up-in-here-tp12341p12353.html
Sent from the OpenSCAD mailing list archive at Nabble.com.

_______________________________________________
OpenSCAD mailing list
[hidden email]
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org


_______________________________________________
OpenSCAD mailing list
[hidden email]
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
Reply | Threaded
Open this post in threaded view
|

Re: Can I get some code review up in here?

runsun
This post was updated on .
In reply to this post by linkreincarnate
Or you can try a little more OOP-ish approach using a hash, in which parameters are encapsulated in a list, described in details here : http://forum.openscad.org/parameterized-models-tp8303p8306.html

(1) 

    default = ["Height", 7, "Thickness", 5, "PinDiameter", 2 ... ];

(2)
 
    Retrieve value: hash( default, "Height") ==> 7 // Need function hash()

(3) 

Expand default as needed:

    boxHinge_opt = default;
    controlArm_opt = update( default, [ "Height", 8, "ArmColor", "gray" ... ] );  // Need function update()
...

(4) 

In the module:

    module boxHinge( user_opt=[ ] ){

       opt = update( boxHinge_opt, user_opt ); // User can change them
       h = hash( opt, "Height");
       ...
    }

    module controlArm( user_opt=[ ] ){

       opt = update( controlArm_opt, user_opt );
       h = hash( opt, "Height");
       ...
    }

The hash-like structure is the main parameter model in my own code. With that I can pack parameters and throw them around all together, reuse them easily, or update them when needed. It makes complicated model codes much easier to handle, especially when dealing with objects with multiple level sub-objects ( like Human.Arms.leftArms.Fingers .... )
$ Runsun Pan, PhD
$ libs: scadx, doctest, faces(git), offline doc(git), runscad.py(2,git), editor of choice: CudaText ( OpenSCAD lexer); $ Tips; $ Snippets
Reply | Threaded
Open this post in threaded view
|

Re: Can I get some code review up in here?

clothbot
As it relates to your hash() function, see search():  http://en.wikibooks.org/wiki/OpenSCAD_User_Manual/The_OpenSCAD_Language#Search

For a flat list structure, you’d code your hash() function to filter off any odd-index return value(s) before returning the first index+1 result.

Andrew.


On Apr 13, 2015, at 9:51 AM, runsun <[hidden email]> wrote:

Or you can try a little more OOP-ish approach using a hash, in which parameters are encapsulated in a list, described in details here : http://forum.openscad.org/parameterized-models-tp8303p8306.html

(1) 

    default = ["Height", 7, "Thickness", 5, "PinDiameter", 2 ... ];

Retrieve value: hash( default, "Height") ==> 7 // Need function hash()

(2) 

Then expand default as needed:

    boxHinge_opt = default;
    controlArm_opt = update( default, [ "Height", 8, "ArmColor", "gray" ... ] );  // Need function update()
...

(3) 

In the module:

    module boxHinge( user_opt=[ ] ){

       opt = update( boxHinge_opt, user_opt ); // User can change them
       h = hash( opt, "Height");
       ...
    }

    module controlArm( user_opt=[ ] ){

       opt = update( controlArm_opt, user_opt );
       h = hash( opt, "Height");
       ...
    }

The hash-like structure is the main parameter model in my own code. With that I can pack parameters and throw them around all together, reuse them easily, or update them when needed. It makes complicated model codes much easier to handle, especially when dealing with objects with multiple level sub-objects ( like Human.Arms.leftArms.Fingers .... )
$ Runsun Pan, PhD
$ -- OpenScad_DocTest: doc and unit test ( Github, Thingiverse )
$ -- Linux Mint 17.1 Rebecca x64 + OpenSCAD 2015.03.15
$ -- Linux Mint 17.1 Rebecca x64 + OpenSCAD 2015.04.01.nightly


View this message in context: Re: Can I get some code review up in here?
Sent from the OpenSCAD mailing list archive at Nabble.com.
_______________________________________________
OpenSCAD mailing list
[hidden email]
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org


_______________________________________________
OpenSCAD mailing list
[hidden email]
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
Reply | Threaded
Open this post in threaded view
|

Re: Can I get some code review up in here?

runsun
Many thx, Andrew. Embarrassingly, I didn't even know there's a search(). Only knew about lookup. With search(), the hash() function becomes ridiculously simple:
function hash(h,k, notfound=undef)= 
(
    let( rtn= search([k],h) )
    len(rtn)>0? h[rtn[0]+1]: notfound    
);

opt = ["Height", 7, "Thickness", 5, "PinDiameter", 2];

echo( hash(opt,"Height") ); // 7
echo( hash(opt,"Thickness") ); //5
echo( hash(opt,"New") ); // undef ==> This also generates a warning.

I notice that there's a little "hiccup" (for me) when using search():

//Search a str in a string: 
search( "b","abcd" ) //==> [1]

//Search a str in a list: 
search( "b",["a","b","c"] ) //==> error 

// Search a str in a list:  NOTE: argument one has to be a list
search( ["b"],["a","b","c"] ) //==> [1]   

//Search a string in a list of str: 
search("b", [ ["a",10], ["b",11],["c",12] ] ) ) //==> [1]
But, it's not a big issue. It seems that search() is a great tool and there are lots more to dig into.
$ Runsun Pan, PhD
$ libs: scadx, doctest, faces(git), offline doc(git), runscad.py(2,git), editor of choice: CudaText ( OpenSCAD lexer); $ Tips; $ Snippets
Reply | Threaded
Open this post in threaded view
|

Re: Can I get some code review up in here?

clothbot
Yeah, when I wrote search() the two primary use modes I focused on were basic character(s)-in-string and searching for matches in list-of-lists.

Have a look at my old example23.scad (see https://github.com/openscad/openscad/blob/master/examples/Old/example023.scad) and how I structured MCAD/fonts.scad (see https://github.com/openscad/MCAD/blob/master/fonts.scad)  to get some insight into how I wanted to (ab)use it.

Andrew.


On Apr 13, 2015, at 5:20 PM, runsun <[hidden email]> wrote:

Many thx, Andrew. Embarrassingly, I didn't even know there's a search(). Only knew about lookup. With search(), the hash() function becomes ridiculously simple:
function hash(h,k, notfound=undef)= 
(
    let( rtn= search([k],h) )
    len(rtn)>0? h[rtn[0]+1]: notfound    
);

opt = ["Height", 7, "Thickness", 5, "PinDiameter", 2];

echo( hash(opt,"Height") ); // 7
echo( hash(opt,"Thickness") ); //5
echo( hash(opt,"New") ); // undef ==> This also generates a warning.

I notice that there's a little "hiccup" (for me) when using search():

//Search a str in a string: 
search( "b","abcd" ) //==> [1]

//Search a str in a list: 
search( "b",["a","b","c"] ) //==> error 

// Search a str in a list:  NOTE: argument one has to be a list
search( ["b"],["a","b","c"] ) //==> [1]   

//Search a string in a list of str: 
search("b", [ ["a",10], ["b",11],["c",12] ] ) ) //==> [1]
But, it's not a big issue. It seems that search() is a great tool and there are lots more to dig into.
$ Runsun Pan, PhD
$ -- OpenScad_DocTest: doc and unit test ( Github, Thingiverse )
$ -- hash parameter model: here, here
$ -- Linux Mint 17.1 Rebecca x64 + OpenSCAD 2015.03.15/2015.04.01.nightly


View this message in context: Re: Can I get some code review up in here?
Sent from the OpenSCAD mailing list archive at Nabble.com.
_______________________________________________
OpenSCAD mailing list
[hidden email]
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org


_______________________________________________
OpenSCAD mailing list
[hidden email]
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
Reply | Threaded
Open this post in threaded view
|

Re: Can I get some code review up in here?

runsun
Thx. Looking at fonts.scad and example023.scad, I can see why search() is needed :)

clothbot wrote
Yeah, when I wrote search() the two primary use modes I focused on were basic character(s)-in-string and searching for matches in list-of-lists.

Have a look at my old example23.scad (see https://github.com/openscad/openscad/blob/master/examples/Old/example023.scad <https://github.com/openscad/openscad/blob/master/examples/Old/example023.scad>) and how I structured MCAD/fonts.scad (see https://github.com/openscad/MCAD/blob/master/fonts.scad <https://github.com/openscad/MCAD/blob/master/fonts.scad>)  to get some insight into how I wanted to (ab)use it.

Andrew.
$ Runsun Pan, PhD
$ libs: scadx, doctest, faces(git), offline doc(git), runscad.py(2,git), editor of choice: CudaText ( OpenSCAD lexer); $ Tips; $ Snippets
Reply | Threaded
Open this post in threaded view
|

Re: Can I get some code review up in here?

MichaelAtOz
Administrator
This post was updated on .
Also see my Fan Lib Thing for further examples.
Admin - email* me if you need anything,
or if I've done something stupid...
* click on my MichaelAtOz label, there is a link to email me.

Unless specifically shown otherwise above, my contribution is in the Public Domain; to the extent possible under law, I have waived all copyright and related or neighbouring rights to this work.
Obviously inclusion of works of previous authors is not included in the above.


The TPP is no simple “trade agreement.” Fight it! http://www.ourfairdeal.org/ time is running out!
Reply | Threaded
Open this post in threaded view
|

Re: Can I get some code review up in here?

runsun
Cool. Very similar to my approach. I suppose your Fan Lib (matching integers using lookup) will run faster than my hash model (matching string via recursive scanning).

MichaelAtOz wrote
Also see my Fan Lib Thing for further examples.
$ Runsun Pan, PhD
$ libs: scadx, doctest, faces(git), offline doc(git), runscad.py(2,git), editor of choice: CudaText ( OpenSCAD lexer); $ Tips; $ Snippets
Reply | Threaded
Open this post in threaded view
|

Re: Can I get some code review up in here?

clothbot
In reply to this post by runsun
Marius has pulled my fixes to search and my updates to example023.scad (removing the deprecated use of assign()).  Anything built from today (April 16th) onward should be good to go!

Andrew.

> On Apr 14, 2015, at 12:25 AM, runsun <[hidden email]> wrote:
>
> Thx. Looking at fonts.scad and example023.scad, I can see why search() is
> needed :)
>
>
> clothbot wrote
>> Yeah, when I wrote search() the two primary use modes I focused on were
>> basic character(s)-in-string and searching for matches in list-of-lists.
>>
>> Have a look at my old example23.scad (see
>> https://github.com/openscad/openscad/blob/master/examples/Old/example023.scad
>> &lt;https://github.com/openscad/openscad/blob/master/examples/Old/example023.scad&gt;)
>> and how I structured MCAD/fonts.scad (see
>> https://github.com/openscad/MCAD/blob/master/fonts.scad
>> &lt;https://github.com/openscad/MCAD/blob/master/fonts.scad&gt;)  to get
>> some insight into how I wanted to (ab)use it.
>>
>> Andrew.
>
>
>
>
>
> -----
>
> $  Runsun Pan, PhD
>
> $ -- OpenScad_DocTest: doc and unit test ( Github , Thingiverse  )
>
> $ -- hash parameter model: here , here
>
> $ -- Linux Mint 17.1 Rebecca x64  + OpenSCAD 2015.03.15/2015.04.01.nightly
>
>
>
>
> --
> View this message in context: http://forum.openscad.org/Can-I-get-some-code-review-up-in-here-tp12341p12363.html
> Sent from the OpenSCAD mailing list archive at Nabble.com.
>
> _______________________________________________
> OpenSCAD mailing list
> [hidden email]
> http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org


_______________________________________________
OpenSCAD mailing list
[hidden email]
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
Reply | Threaded
Open this post in threaded view
|

Ramp Symbol

yvette
In reply to this post by Peter Falke
hi all,

hey, does anyone know where a "ramp" symbol could be found?

the "ramp" symbol is whatcha see on euro volume controls, you know, it's
a "triangle" that's thin on the left, the top slopes up and to the
right, and it's thick on the right.

it's for a dimmer, and i'm trying to be "language independent".  so i'm
trying to write() the symbol on the dimmer cover.

can we write() bitmaps?

thanks!
yvette

_______________________________________________
OpenSCAD mailing list
[hidden email]
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
Reply | Threaded
Open this post in threaded view
|

Re: Ramp Symbol

shadowwynd
polygon (points=[[0,0],[10,0],[10,3]]);

Sent from my iPhone

> On Apr 17, 2015, at 10:50 AM, "Yvette S. Hirth, CCP, CDP" <[hidden email]> wrote:
>
> hi all,
>
> hey, does anyone know where a "ramp" symbol could be found?
>
> the "ramp" symbol is whatcha see on euro volume controls, you know, it's a "triangle" that's thin on the left, the top slopes up and to the right, and it's thick on the right.
>
> it's for a dimmer, and i'm trying to be "language independent".  so i'm trying to write() the symbol on the dimmer cover.
>
> can we write() bitmaps?
>
> thanks!
> yvette
>
> _______________________________________________
> OpenSCAD mailing list
> [hidden email]
> http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org

_______________________________________________
OpenSCAD mailing list
[hidden email]
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org
Reply | Threaded
Open this post in threaded view
|

Re: Ramp Symbol

yvette
On 04/17/2015 09:24 AM, Ezra Reynolds wrote:

> polygon (points=[[0,0],[10,0],[10,3]]);

thanks!
yvette

_______________________________________________
OpenSCAD mailing list
[hidden email]
http://lists.openscad.org/mailman/listinfo/discuss_lists.openscad.org