Your First Part : Hello Cube

Getting Started

In the following, we will show how to use the Foundation library to create a simple cube in Python. By default when creating a new file on BuildR, the cube example is loaded. This example is a good starting point to understand how to use the library.

# initialize the component
    cube = Part()

First, we create a new component using the Part() function. This function returns a Part object that we can use to create operations on.

# Create a Sketch from XY Plane
    s = Sketch(cube.xy())

Next, we create a new sketch on the XY plane using the xy() function, similarly you could also use the YZ or XZ planes using the yz() and xz() functions respectively.

# Create Points on the Sketch
    p1 = Point(s, 0, 0)
    p2 = Point(s, cube_size, 0)
    p3 = Point(s, cube_size, cube_size)
    p4 = Point(s, 0, cube_size)

    l1 = Line(p1, p2)
    l2 = Line(p2, p3)
    l3 = Line(p3, p4)
    l4 = Line(p4, p1)

Next, we can create four points on the sketch and join them with lines. On a sketch you can draw points, lines, circles, polygons and more geometrical shapes.

# Create a Polygon from the Lines and extrude it
    square = Polygon([l1, l2, l3, l4])
    e = Extrusion(square, cube_size)
    cube.add_operation(e)

Finally, we can extrude the sketch to create a 3D object. The extrude() function takes the created shape and the height.

To show the the component on the screen and generate the resulting 3D model, we can use the show() function and pass it the cube component.

Improving on our cube example

We can improve our cube example by using inheritance and leveraging some of the built-in methods from the Foundation library. Here’s an improved version of the cube:

from cadbuildr.foundation import *


class Cube(Part):
    def __init__(self, size=20):
        self.size = size
        self.create_main_extrusion()

    def create_main_extrusion(self):
        s = Sketch(self.xy())
        square = Square.from_center_and_side(s.origin, self.size)
        e = Extrusion(square, -self.size / 2, self.size / 2)
        self.add_operation(e)


# Create and show the cube
cube = Cube(size=30)
show(cube)

Let’s break down the improvements and explain why this version is cleaner:

1. Inheritance: We recommend using inheritance for creating a Part or Assembly. You can that way simplify the different operations into their own functions and have parameters in the constructor. (Not you don’t need to call the super().init() method)

2. Initialization: The size parameter is now part of the __init__ method. This allows users to specify the cube size when creating an instance.

3. Using Square.from_center_and_side: Instead of manually creating points and lines, we use the Square.from_center_and_side method. On top of this tihs will center the cube, we also extend the sketch with an extrusion in both direction for centering on the z axis as well.

4. create_main_extusion as a method: We recommend creating methods for the different operation steps of the part. This makes it easier to iteratively build the part and makes the code more readable.

To use this improved version, you simply create an instance of the Cube class and show it:

cube = Cube(size=30)
show(cube)