/Kitchen/CornerBin.foocad
A bin with a simple hinged lid.
The main part of the bin is printed in many sections, and therefore can be as tall as you like.
All pieces can be printed without support material.
I recommend using PETG, as it is tough and slightly flexible. However, PLA may also work.
Quality Setting
I like the faceted look, the curved part of bin has about 20 sides. YMMV. If you prefer it to be smooth,
Print Notes
The section pieces have very little contact to the build plate, and therefore a brim is needed.
However, this model almost fills my build plate, so I'm relying on internal brims.
This has the advantage of not ruining the appearance if the brim isn't removed cleanly.
I've also added a tiny thin line to lidTrim, so that it can also use an internal brim if required.
Top Assembly
Put the hinge rod into the lid. The rod could be a nail with its head cut off/reduced, or a piece of PETG filament (not PLA or other brittle plastic).
Assemble pieces 'lid', 'lidTrim' and 'top'.
Slide the hinge pins into the lidTrim using the slots in the lid. Note. The rod should still be visible in the slot (the slot is longer than the amount of travel).
Use a small dab of glue on the
hingeCovers. The pin is now trapped, but free to rotate. Fingers crossed, it should be possible to remove the cover if the rod needs replacing ;-)
import uk.co.nickthecoder.foocad.extras.v1.*
import static uk.co.nickthecoder.foocad.extras.v1.Extras.*
import uk.co.nickthecoder.foocad.compound.v1.*
import uk.co.nickthecoder.foocad.cup.v1.*
import static uk.co.nickthecoder.foocad.cup.v1.Cup.*
import uk.co.nickthecoder.foocad.smartextrusion.v1.*
import static uk.co.nickthecoder.foocad.smartextrusion.v1.SmartExtrusion.*
import static uk.co.nickthecoder.foocad.extras.v1.Extras.*
class CornerBin : ModelWithSetup {
// This is close to the max print area of a Qidi Plus 3
@Custom( about="Size of tube sections. NOTE. The top is larger than this." )
var size = Vector2( 266, 240 )
@Custom( about="Radius of the 3 rounded corners" )
var round = 18
@Custom( about="A straight side in the Y direction in the back right corner" )
val shortSide = 10
@Custom( about="Thickness of the main walls" )
var thickness = 1.8
@Custom( about="Thickness of the bottom of the bin (piece `base`" )
var baseThickness = 1.8
@Custom( about="Height of the lid" )
var lidThickness = 6
@Custom( about="Z Thickness of the lip of piece `top`" )
var topThickness = 2
@Custom( about="X dimension of piece `lidTrim`" )
var trimWidth = 12
@Custom( about="Height of piece `base`" )
var baseHeight = 100
@Custom( about="Use the Customiser to make striped patterns of verious heights" )
var sectionHeight = 100
@Custom( about="Clearance of the fit between each vertical section" )
var clearance = 0.2
@Custom( about="Size of the rounded chamfer at the bottom of the bin" )
var baseChamfer = 10
@Custom( about="Size of the connections between the vertical sections" )
var lipSize = Vector2(2, 10)
@Custom( about="Gap for the bag to loop back round" )
var bagClearance = 2
@Custom
var lidClearance = 1.0
@Custom( about="Length and diameter of the holes for the hinges' holes" )
var hingeRodSize = Vector2( 20, 2 )
@Custom( about="Additional height of the top compared to the bagTidy" )
var topExtraHeight = 10
@Custom( about="" )
var stopWidth = 3
override meth setup() {
// Uncomment for a smoother (less facetted) surface.
// Quality.increase(3)
}
meth shape() = PolygonBuilder().apply {
moveTo( round, 0 )
circularArcTo( 0, -round, round, false, true )
lineTo( 0, - size.y + round ) // Left edge
circularArcTo( round, -size.y, round, false, true )
bezierBy( // Main curve
Vector2( size.x/2, 0 ),
Vector2( 0, size.y/2 ),
Vector2( size.x - round, size.y - round - shortSide )
)
lineBy( 0, shortSide )
circularArcTo( size.x - round, 0, round, false, true )
}.build().center()
meth outsideLip() : ProfileEdge {
val profile = PolygonBuilder().apply {
moveTo( 0,0 )
lineBy( thickness + clearance, 0 )
lineBy( 0, lipSize.y - lipSize.x )
lineBy( lipSize.x, lipSize.x )
}.buildPath()
return ProfileEdge( profile )
}
meth insideLip() : ProfileEdge {
val profile = PolygonBuilder().apply {
moveTo(0,0)
lineBy( -lipSize.x, lipSize.x )
lineBy( 0, lipSize.y + lipSize.x /2 )
}.buildPath()
return ProfileEdge( profile )
}
meth bottomLip() : ProfileEdge {
val delta = lipSize.x
val profile = PolygonBuilder().apply {
moveTo(0,0)
lineBy( -delta, delta )
lineBy( 0, 1 )
lineBy( delta, delta )
lineBy( 0, lipSize.y - lipSize.x )
}.buildPath()
return ProfileEdge( profile )
}
// Position of the hinges relative to the lid on the build plate.
meth hingePosition() = Vector3(
-size.x / 2 - thickness - bagClearance + trimWidth + 0.5,
size.y/2 - round- shortSide,
lidThickness/2
)
// Removed from lidTrim and lid.
// See About for details on assmbling the hinge.
meth hingeHole() : Shape3d {
val free = Cylinder( hingeRodSize.x, hingeRodSize.y/2 ).hole().bottomTo( -trimWidth +3 )
val circle = Circle( hingeRodSize.y/2 + 1 ).hole()
val exposed = circle.hull( circle.translateX(10) )
.extrude( hingeRodSize.x )
.bottomTo( trimWidth )
return (free + exposed)
.rotateY(90)
.translate( hingePosition() )
}
@Piece
@Slice( brimWidth=3 )
meth hingeCover() : Shape3d {
val overlap = 2
val radius = hingeRodSize.y/2 + 1 - 0.1
val shape = Circle( radius ).hull( Square( lidThickness/2-0.3, radius*2 ).centerY() )
val base = hingeCoverPlain().mirrorZ().bottomTo(0)
val stop = shape
.extrude( trimWidth )
.rotateY(90)
.rightTo( base.right - overlap )
return base + stop.bottomTo( base.top )
}
@Piece
@Slice( brimWidth=3 )
meth hingeCoverRecessed() : Shape3d {
val overlap = 2
val radius = hingeRodSize.y/2 + 1 - 0.1
val shape = Circle( radius ).hull( Square( lidThickness/2-0.3, radius*2 ).centerY() )
val base = hingeCoverPlain().mirrorZ().bottomTo(0)
val extra = Square( base.size.x, radius*2-0.2 )
.center()
.roundAllCorners(0.5)
.extrude( 1 )
.bottomTo( base.top )
return base + extra
}
@Piece
meth hingeCoverPlain() : Shape3d {
val overlap = 2
val radius = hingeRodSize.y/2 + 1 - 0.1
val shape = Circle( radius ).hull( Square( lidThickness/2-0.3, radius*2 ).centerY() )
val base = Square( hingeRodSize.x+overlap*2, hingeRodSize.y + overlap*2 )
.center()
.roundAllCorners(1)
.smartExtrude( 1 )
.top( Chamfer(1) )
.margin( Vector3(-overlap, -overlap, 0) )
return base
}
@Piece
meth foot() = shape()
.offset( - baseChamfer/2 -1 )
.outline( 0, 10 )
.smartExtrude( 1.2 )
.bottom( Chamfer( 1 ) )
.mirrorZ()
.bottomTo(0)
@Piece
@Slice( brimWidth=11 )
meth base() : Shape3d {
val base = shape()
.cup( baseHeight, thickness )
.baseThickness( baseThickness )
.bottom( roundedChamfer( baseChamfer ) )
.insideTop( insideLip() )
.outsideTop( outsideLip() )
return base
}
@Piece
@Slice( brimWidthInterior=10 )
meth section60() = section( 60 )
@Piece
@Slice( brimWidthInterior=10 )
meth section80() = section( 80 )
@Piece
@Slice( brimWidthInterior=10 )
meth section160() = section( 160 )
@Piece
@Slice( brimWidthInterior=10 )
meth section200() = section( 200 )
@Piece
@Slice( brimWidthInterior=10 )
meth section() = section( sectionHeight )
meth section(height : double) : Shape3d {
return shape()
.outline( 0, thickness )
.smartExtrude( height )
.insideBottom( bottomLip() )
.insideTop( insideLip() )
.outsideTop( outsideLip() )
}
@Piece
@Slice( brimWidthInterior=10 )
meth printBagTidy() = bagTidy().rotateX(180).bottomTo(0)
// Loop the bin liner around this piece, so that the lose ends are
// hidden and out of the way.
// The ends of the liner are between the OUTSIDE of this piece,
// and the INSIDE of the bin
@Piece( print="printBagTidy" )
meth bagTidy() : Shape3d {
val height = 10
val shape = shape().offset( bagClearance/2 )
val connection = shape
.outline( 0, thickness )
.smartExtrude( bottomLip().profile.size.y )
.insideBottom( bottomLip() )
.outsideBottom( Fillet(0.8) )
.outsideTop( Chamfer(0.8) )
//.color("Orange")
val main = shape
.outline( 0, thickness*2 + bagClearance )
.smartExtrude( baseThickness + 1 )
.top( Chamfer(0.8) )
.topTo( connection.top )
//.color("Green")
return connection + main
}
/**
Hides the `bagTidy`, so that the bag isn' visible when the bin is closed.
Glue `lidTrim` to the top, with the `lid` in position
(including the screws, which form the hinge).
After gluing, `top`, `lidTrim` and `lid` will be inseperable.
*/
@Piece
@Slice( brimWidth=3.5, brimWidthInterior=10 )
meth printTop() = top().rotateX(180).bottomTo(0)
meth trimHoles() : Shape3d {
return Cylinder( lidThickness*2 - 2, 1 )
.translate( hingePosition() )
.translateX( -trimWidth/2 + 1)
.centerZ()
.translateY(10)
.translateY(-22).also()
.mirrorX().also()
}
@Piece( print="printTop" )
meth top() : Shape3d {
val lid = lid()
val outsideShape = shape().offset( thickness + bagClearance )
val insideShape = shape().offset( thickness + bagClearance - trimWidth - stopWidth - lidClearance )
val height = bagTidy().size.z + topExtraHeight // Hides the `bagTidy` piece, with extra 5mm to spare.
val cutoutFront = hingePosition().y - lidThickness/2 - lidClearance
val cutoutBack = size.y/2 + thickness + bagClearance - trimWidth
val cutoutY = cutoutBack - cutoutFront
val cutoutWidth = lid.size.x - trimWidth*2
val cutoutRadius = round - (shape().size.x - cutoutWidth )/2
val cutout = Square( cutoutWidth, cutoutY )
.roundCorner(3, cutoutRadius )
.roundCorner(2, cutoutRadius )
.centerX()
.frontTo( cutoutFront )
val top = (outsideShape - insideShape - cutout)
.smartExtrude( topThickness )
.top( roundedChamfer( baseThickness ) )
val sides = outsideShape.outline( 0, thickness )
.smartExtrude( height )
.insideTop( Chamfer(-1, 1) )
.bottom( Chamfer(0.5) )
.topTo( 0 )
val stops = Trapezium( 10, 10 )
.angle(9)
.backTo(0)
.roundCorner(1,2)
.roundCorner(0,2)
.smartExtrude( stopWidth )
.rotateX(90)
.rotateZ(90)
.backTo( cutout.front )
.leftTo( insideShape.right )
.topTo( top.bottom )
.mirrorX().also()
return top + sides + stops - trimHoles()
}
// The lid is printed upside down, so the smoothest surface is on show.
@Piece
@Slice( brimWidth=5 )
meth printLid() = lid().rotateX(180).bottomTo(0)
@Piece( print="printLid" )
@Slice( brimWidth=3 )
meth lid() : Shape3d {
val outsideShape = shape().offset( thickness + bagClearance )
val insideShape = shape().offset( thickness + bagClearance - trimWidth - lidClearance )
// The lip follows the same shape as the lid itself,
// but to make it look nicer, we use a Circle as an envelope (intersection)
// I used trial an error to get a pleasing result.
// Therefore, if you change the basic shape, you may need to tinker with the constants.
val lipDiameter = size.x * 0.6
val lipCircle = Circle( lipDiameter/2 ).translate( -size.x*0.05, -size.y*0.2 )
val lipShape = outsideShape.intersection( lipCircle )
.offset(10)
.intersection( Square(size.x, size.y*2).center() )
val outside = (outsideShape + lipShape)
.smartExtrude( lidThickness )
.outsideTop( roundedChamfer( lidThickness - 1 ) )
val inside = insideShape
.smartExtrude( lidThickness )
.top( Chamfer(1) )
val removeOutsideBack = Cube( outside.size.x + 1)
.center()
.frontTo(0)
.rotateX(-45)
.translateY( size.y/2 - round - shortSide - 30 - 1 )
val result = outside - removeOutsideBack + inside -
hingeHole().mirrorX().also()
return result // + lipCircle.extrude(10).previewOnly()
}
@Piece
@Slice( brimWidthInterior=5 )
meth printLidTrim() : Shape3d {
val trim = lidTrim().rotateX(180).bottomTo(0)
val allowInteriorBrim = Cube( trim.size.x - trimWidth, 0.4, 0.2 )
.centerX()
.backTo( trim.back - trim.size.z * 1.25 )
return trim + allowInteriorBrim
}
// Glued/screwed onto `top` piece.
@Piece( print="printLidTrim" )
@Slice( brimWidthInterior=5 )
fun lidTrim() : Shape3d {
val ledgeClearance = 0.3
val ledgeHeight = 2
val ledgeOffset = 1.5
val outsideShape = shape().offset( thickness + bagClearance )
val trim = outsideShape.outline( 0, trimWidth )
.smartExtrude( lidThickness + ledgeHeight + ledgeClearance )
.outsideTop( roundedChamfer( lidThickness - 1 ) )
.insideTop( Chamfer( ledgeHeight/2 ) )
val ledgeY = size.y/2 - round - shortSide - 30
val ledgeShape = Square( size.x + ledgeOffset*2, round + ledgeOffset*2 + 2 )
.roundCorner(3, round)
.roundCorner(2, round)
.centerX()
.backTo( size.y / 2 + ledgeOffset + 0.1 )
.intersection( outsideShape )
val ledge = ledgeShape
.smartExtrude( ledgeHeight )
.top( Chamfer( ledgeHeight/2 ) )
.topTo( trim.top )
val roundEnvelope = PolygonBuilder().apply {
moveTo( 0, ledgeY )
lineTo( 0, trim.back )
lineTo( trim.size.z, trim.back )
lineTo( trim.size.z, ledgeY + trim.size.z )
lineTo( lidThickness, ledgeY + lidThickness )
}.build()
// Comment the next line if you wish. YMMV.
// With the rounding, there is a steeper overhang (twice as steep as a chamfer),
// but a nicer rounding where the trim is higher than the lid.
.roundCorner(1, 5, 1)
.extrude(trim.size.x + 2)
.rotateY(-90).centerX()
.frontTo( ledgeY )
// To see how `roundEnvelope` works :
// return trim + roundEnvelope.previewOnly() +
return trim.intersection(roundEnvelope) +
ledge -
hingeHole().mirrorX().also() -
trimHoles()
}
@Piece( printable=false )
meth topAssembly() : Shape3d {
val lid = lid()
.translateZ(0.1)
.color("Green")
val trim = lidTrim()
.color("Orange")
val top = top().topTo( trim.bottom-0.2 ).previewOnly()
val axis = Cube( top.size.x + 2, 0.5, 0.5 )
.center()
.translate( hingePosition() ).centerX()
.color("Red")
val hingeHole = hingeHole().previewOnly()
val hingeCover = hingeCover()
.rightTo( hingeHole.right + 2 )
.translateZ(-1)
.centerYTo( hingeHole.middle.y )
.previewOnly()
val angle = 0 // 100 // 100° is fully open. 0° is fully closed.
val rotatedLid = (lid + hingeCover + hingeHole.mirrorX()).translate( -hingePosition() )
.rotateX( -angle )
.translate( hingePosition() )
return rotatedLid + trim + top + axis
}
@Piece( printable = false )
override meth build() : Shape3d {
val dark = "SteelBlue"
val light = "LightSteelBlue"
val base = base()
.color( dark )
val section1 = section(200).color( light )
.bottomTo( base.top - lipSize.y + clearance )
val section2 = section(80).color( dark )
.bottomTo( section1.top - lipSize.y + clearance )
val section3 = section(160).color( light )
.bottomTo( section2.top - lipSize.y + clearance )
val section4 = section(60).color( dark )
.bottomTo( section3.top - lipSize.y + clearance )
val bagTidy = bagTidy()
.bottomTo( section4.top - lipSize.y + clearance )
.color( dark )
val top = top()
.topTo( bagTidy.top + topThickness + bagClearance )
.color(dark)
val lid = lid()
.color(dark)
val lineOfRotation = Cube( top.size.x + 2, 0.5, 0.5 )
.center().translate( hingePosition() ).centerX()
.color("Red")
val angle = 60 // 100 // 100° is fully open. 0° is fully closed.
val rotatedLid = lid.translate( -hingePosition() )
.rotateX( -angle )
.translate( hingePosition() )
.translateZ( top.top + clearance )
val lidTrim = lidTrim()
.bottomTo( top.top + clearance )
.color(dark)
val foot = foot()
.mirrorZ()
.topTo( base.bottom )
.color( light )
return Compound().apply {
+ foot
+ base
+ section1
+ section2
+ section3
+ section4
+ bagTidy
+ top
+ lidTrim
+ rotatedLid
+ lineOfRotation
}.build()
}
}