Example #1
0
    def __init__(
            self,
            filter_l=60.,
            filter_w=25.,
            filter_t=2.5,
            base_h=6.,
            hold_d=10.,
            filt_supp_in=2.,
            filt_rim=3.,
            filt_cen_d=0,
            fillet_r=1.,
            # linear guides SEBLV16 y SEBS15, y MGN12H:
            boltcol1_dist=20 / 2.,
            boltcol2_dist=12.5,  #thorlabs breadboard distance
            boltcol3_dist=25,
            boltrow1_h=0,
            boltrow1_2_dist=12.5,
            # linear guide MGN12H
            boltrow1_3_dist=20.,
            # linear guide SEBLV16 and SEBS15
            boltrow1_4_dist=25.,
            bolt_cen_mtr=4,
            bolt_linguide_mtr=3,  # linear guide bolts
            beltclamp_t=3.,  #2.8,
            beltclamp_l=12.,
            beltclamp_h=8.,
            clamp_post_dist=4.,
            sm_beltpost_r=1.,
            tol=kcomp.TOL,
            axis_d=VX,
            axis_w=VY,
            axis_h=VZ,
            pos_d=0,
            pos_w=0,
            pos_h=0,
            pos=V0):

        shp_clss.Obj3D.__init__(self, axis_d, axis_w, axis_h)

        # save the arguments as attributes:
        frame = inspect.currentframe()
        args, _, _, values = inspect.getargvalues(frame)
        for i in args:
            if not hasattr(self, i):
                setattr(self, i, values[i])

        # normal axes to print without support
        self.prnt_ax = self.axis_h

        # calculation of the dimensions:
        # hole for the filter, including tolerances:
        # Note that now the dimensions width and length are changed.
        # to depth and width
        # they are relative to the holder, not to the filter
        # no need to have the tolerances here:
        self.filt_hole_d = filter_w  # + tol # depth
        self.filt_hole_w = filter_l  # + tol # width in holder axis
        self.filt_hole_h = filter_t  # + tol/2. # 0.5 tolerance for height

        # The hole under the filter to let the light go through
        # and big enough to hold the filter
        # we could take filter_hole dimensions or filter dimensiones
        # just the tolerance difference
        self.filt_supp_d = self.filt_hole_d - 2 * filt_supp_in
        self.filt_supp_w = self.filt_hole_w - 2 * filt_supp_in

        # look for the largest bolt head in the first row:
        # dictionary of the center bolt and 2nd and 3rd column
        self.bolt_cen_dict = kcomp.D912[bolt_cen_mtr]
        self.bolt_cen_head_r_tol = self.bolt_cen_dict['head_r_tol']
        self.bolt_cen_r_tol = self.bolt_cen_dict['shank_r_tol']
        self.bolt_cen_head_l_tol = self.bolt_cen_dict['head_l_tol']

        # dictionary of the 1st column bolts (for the linear guide)
        self.bolt_linguide_dict = kcomp.D912[bolt_linguide_mtr]
        self.bolt_linguide_head_r_tol = self.bolt_linguide_dict['head_r_tol']
        self.bolt_linguide_r_tol = self.bolt_linguide_dict['shank_r_tol']
        self.bolt_linguide_head_l_tol = self.bolt_linguide_dict['head_l_tol']

        max_row1_head_r_tol = max(self.bolt_linguide_head_r_tol,
                                  self.bolt_cen_head_r_tol)

        if boltrow1_h == 0:
            self.boltrow1_h = 2 * max_row1_head_r_tol
        elif boltrow1_h < 2 * max_row1_head_r_tol:
            self.boltrow1_h = 2 * max_row1_head_r_tol
            msg1 = 'boltrow1_h smaller than bolt head diameter'
            msg2 = 'boltrow1_h will be bolt head diameter'
            logger.warning(msg1 + msg2 + str(self.boltrow1_h))
        # else # it will be as it is

        self.hold_h = (base_h + self.boltrow1_h + boltrow1_4_dist +
                       2 * self.bolt_linguide_head_r_tol)
        self.tot_h = self.hold_h + beltclamp_h

        self.beltclamp_blk_t = (hold_d - beltclamp_t) / 2.

        #self.clamp2cenpost = clamp_post_dist + s_beltclamp_r_sm

        # the large radius of the belt post
        self.lr_beltpost_r = (hold_d - 3) / 2.

        min_filt_cen_d = hold_d + filt_rim + filter_w / 2.
        if filt_cen_d == 0:
            filt_cen_d = hold_d + filt_rim + filter_w / 2.
        elif filt_cen_d < min_filt_cen_d:
            filt_cen_d = hold_d + filt_rim + filter_w / 2.
            msg = 'filt_cen_d is smaller than needed, taking: '
            logger.warning(msg + str(filt_cen_d))
        self.filt_cen_d = filt_cen_d

        self.tot_d = self.filt_cen_d + filter_w / 2. + filt_rim

        # find out if the max width if given by the filter or the holder
        base_w = filter_l + 2 * filt_rim
        hold_w = 2 * boltcol3_dist + 4 * self.bolt_cen_head_r_tol
        self.tot_w = max(base_w, hold_w)

        self.beltpost_l = (3 * self.lr_beltpost_r) + sm_beltpost_r
        self.clamp_lrbeltpostcen_dist = (self.beltpost_l - self.lr_beltpost_r +
                                         self.clamp_post_dist)

        self.d0_cen = 0
        self.w0_cen = 1  # symmetrical
        self.h0_cen = 0

        self.d_o[0] = V0
        self.d_o[1] = self.vec_d(self.beltclamp_blk_t)
        self.d_o[2] = self.vec_d(hold_d / 2.)
        self.d_o[3] = self.vec_d(hold_d - self.beltclamp_blk_t)
        # at the beginning of the bolt head hole for the central bolt
        self.d_o[4] = self.vec_d(hold_d - self.bolt_cen_head_l_tol)
        self.d_o[5] = self.vec_d(hold_d - self.bolt_linguide_head_l_tol)
        self.d_o[6] = self.vec_d(hold_d)
        # at the beginning of the hole of the porta (no tolerance):
        self.d_o[7] = self.vec_d(self.filt_cen_d - filter_w / 2.)
        # inner side of porta thruhole
        self.d_o[8] = self.d_o[7] + self.vec_d(filt_supp_in)
        # at the center of the porta:
        self.d_o[9] = self.vec_d(self.filt_cen_d)
        # outer side of porta thruhole
        self.d_o[10] = self.vec_d(self.filt_cen_d + filter_w / 2. -
                                  filt_supp_in)
        # at the end of the hole of the porta (no tolerance):
        self.d_o[11] = self.vec_d(self.filt_cen_d + filter_w / 2.)
        self.d_o[12] = self.vec_d(self.tot_d)

        # these are negative because actually the pos_w indicates a negative
        # position along axis_w

        self.w_o[0] = V0
        #1: at the first bolt column
        self.w_o[1] = self.vec_w(-boltcol1_dist)
        #2: at the second bolt column
        self.w_o[2] = self.vec_w(-boltcol2_dist)
        #3: at the third bolt column
        self.w_o[3] = self.vec_w(-boltcol3_dist)

        #7: at the end of the piece
        self.w_o[7] = self.vec_w(-self.tot_w / 2.)
        #6: at the inner side of the clamp rails
        # add belt_clamp because  w_o are negative
        self.w_o[6] = self.w_o[7] + self.vec_w(beltclamp_l)
        #5: at the outer side of the clamp post (smaller circle)
        self.w_o[5] = self.w_o[6] + self.vec_w(clamp_post_dist)
        #4: at the inner side of the clamp post (larger circle)
        self.w_o[4] = self.w_o[5] + self.vec_w(self.beltpost_l)

        #0: at the bottom (base)
        self.h_o[0] = V0
        #1: at the base for the porta
        self.h_o[1] = self.vec_h(base_h - self.filt_hole_h)
        #2: at the top of the base
        self.h_o[2] = self.vec_h(base_h)
        #3: first row of bolts
        self.h_o[3] = self.vec_h(base_h + self.boltrow1_h)
        #4: second row of bolts
        self.h_o[4] = self.h_o[3] + self.vec_h(boltrow1_2_dist)
        #5: third row of bolts, taking self.h_o[3]
        self.h_o[5] = self.h_o[3] + self.vec_h(boltrow1_3_dist)
        #6: 4th row of bolts
        self.h_o[6] = self.h_o[3] + self.vec_h(boltrow1_4_dist)
        #7: at the base of the belt clamp
        self.h_o[7] = self.vec_h(self.hold_h)
        #8: at the middle of the belt clamp
        self.h_o[8] = self.vec_h(self.hold_h + self.beltclamp_h / 2.)
        #9: at the top of the piece
        self.h_o[9] = self.vec_h(self.tot_h)

        # calculates the position of the origin, and keeps it in attribute pos_o
        self.set_pos_o()

        # -------- building of the piece
        # the base
        shp_base = fcfun.shp_box_dir(box_w=self.tot_w,
                                     box_d=self.tot_d,
                                     box_h=base_h,
                                     fc_axis_w=self.axis_w,
                                     fc_axis_d=self.axis_d,
                                     fc_axis_h=self.axis_h,
                                     cw=1,
                                     cd=0,
                                     ch=0,
                                     pos=self.pos_o)

        shp_base = fcfun.shp_filletchamfer_dir(shp_base,
                                               self.axis_h,
                                               fillet=1,
                                               radius=fillet_r)
        shp_base = shp_base.removeSplitter()

        # the holder to attach to a linear guide

        shp_holder = fcfun.shp_boxdir_fillchmfplane(
            box_w=self.tot_w,
            box_d=hold_d,
            box_h=self.hold_h,
            axis_d=self.axis_d,
            axis_h=self.axis_h,
            cw=1,
            cd=0,
            ch=0,
            fillet=1,
            radius=fillet_r,
            plane_fill=self.axis_d.negative(),
            both_planes=0,
            edge_dir=self.axis_h,
            pos=self.pos_o)

        #shp_holder = fcfun.shp_box_dir (box_w = self.tot_w,
        #box_d = hold_d,
        #box_h = self.hold_h,
        #fc_axis_w = self.axis_w,
        #fc_axis_d = self.axis_d,
        #fc_axis_h = self.axis_h,
        #cw = 1, cd = 0, ch = 1,
        #pos = self.pos_o)
        #shp_base = fcfun.shp_filletchamfer_dir (shp_base, self.axis_h,
        #fillet = 1, radius = fillet_r)
        shp_base = shp_base.removeSplitter()

        shp_l = shp_base.fuse(shp_holder)
        shp_l = shp_l.removeSplitter()
        # pos (6,0,2): position at the corner of the L
        shp_l = fcfun.shp_filletchamfer_dirpt(shp_l,
                                              fc_axis=self.axis_w,
                                              fc_pt=self.get_pos_dwh(6, 0, 2),
                                              fillet=0,
                                              radius=fillet_r)
        shp_l = shp_l.removeSplitter()
        # now we have the L shape with its chamfers and fillets

        # ------------------- Holes for the filter
        # include tolerances, along nh: only half of it, along h= 1 to make
        # the cut
        # pos (9,0,1) position at the center of the porta, at its bottom
        shp_filter_hole = fcfun.shp_box_dir_xtr(box_w=self.filt_hole_w,
                                                box_d=self.filt_hole_d,
                                                box_h=self.filt_hole_h,
                                                fc_axis_h=self.axis_h,
                                                fc_axis_d=self.axis_d,
                                                cw=1,
                                                cd=1,
                                                ch=0,
                                                xtr_h=1,
                                                xtr_nh=tol / 2.,
                                                xtr_d=tol,
                                                xtr_nd=tol,
                                                xtr_w=tol,
                                                xtr_nw=tol,
                                                pos=self.get_pos_dwh(9, 0, 1))
        # pos (9,0,0) position at the center of the porta, at the bottom of the
        # piece
        # no extra on top because it will be fused with shp_filter_hole
        shp_filter_thruhole = fcfun.shp_box_dir_xtr(box_w=self.filt_supp_w,
                                                    box_d=self.filt_supp_d,
                                                    box_h=base_h,
                                                    fc_axis_h=self.axis_h,
                                                    fc_axis_d=self.axis_d,
                                                    cw=1,
                                                    cd=1,
                                                    ch=0,
                                                    xtr_h=0,
                                                    xtr_nh=1,
                                                    xtr_d=tol,
                                                    xtr_nd=tol,
                                                    xtr_w=tol,
                                                    xtr_nw=tol,
                                                    pos=self.get_pos_dwh(
                                                        9, 0, 0))
        shp_fuse_filter_hole = shp_filter_hole.fuse(shp_filter_thruhole)
        shp_l = shp_l.cut(shp_fuse_filter_hole)
        shp_l = shp_l.removeSplitter()
        # the L with the hole in the base is done

        # ---------------- Holes for the bolts

        bolt_list = []

        shp_cen_bolt = fcfun.shp_bolt_dir(
            r_shank=self.bolt_cen_r_tol,
            l_bolt=hold_d,
            r_head=self.bolt_cen_head_r_tol,
            l_head=self.bolt_cen_head_l_tol,
            xtr_head=1,
            xtr_shank=1,
            support=0,  #not at printing directi
            fc_normal=self.axis_d.negative(),
            pos_n=2,
            pos=self.get_pos_dwh(0, 0, 3))
        bolt_list.append(shp_cen_bolt)
        # the rest of the bolts come in pairs:
        for w_side in [-1, 1]:
            # the wider bolts (although can be smaller)
            for cen_col, cen_row in zip([2, 3], [4, 3]):
                boltpos = self.get_pos_dwh(0, w_side * cen_col, cen_row)
                shp_cen_bolt = fcfun.shp_bolt_dir(
                    r_shank=self.bolt_cen_r_tol,
                    l_bolt=hold_d,
                    r_head=self.bolt_cen_head_r_tol,
                    l_head=self.bolt_cen_head_l_tol,
                    xtr_head=1,
                    xtr_shank=1,
                    support=0,  #not at printing directi
                    fc_normal=self.axis_d.negative(),
                    pos_n=2,
                    pos=boltpos)
                bolt_list.append(shp_cen_bolt)
            # the smaller bolts (although can be larger). Linear guide
            # first row:
            boltpos = self.get_pos_dwh(0, w_side * 1, 3)
            shp_lin_bolt = fcfun.shp_bolt_dir(
                r_shank=self.bolt_linguide_r_tol,
                l_bolt=hold_d,
                r_head=self.bolt_linguide_head_r_tol,
                l_head=self.bolt_linguide_head_l_tol,
                xtr_head=1,
                xtr_shank=1,
                support=0,  #not at printing directi
                fc_normal=self.axis_d.negative(),
                pos_n=2,
                pos=boltpos)
            bolt_list.append(shp_lin_bolt)
            # 3rd and 4th row. Just 2 shanks and a stadium per side
            for linrow in [5, 6]:
                boltpos = self.get_pos_dwh(0, w_side * 1, linrow)
                shp_lin_shank = fcfun.shp_cylcenxtr(
                    r=self.bolt_linguide_r_tol,
                    h=hold_d,
                    normal=self.axis_d,
                    ch=0,
                    xtr_top=0,  #no need: stadium
                    xtr_bot=1,
                    pos=boltpos)
                bolt_list.append(shp_lin_shank)
            # the stadium for both bolts head (they are too close)
            stadpos = self.get_pos_dwh(6, w_side * 1, 5)
            shp_stad = fcfun.shp_stadium_dir(
                length=boltrow1_4_dist - boltrow1_3_dist,
                radius=self.bolt_linguide_head_r_tol,
                height=self.bolt_linguide_head_l_tol,
                fc_axis_h=self.axis_d.negative(),
                fc_axis_l=self.axis_h,
                ref_l=2,
                ref_h=2,
                xtr_h=0,
                xtr_nh=1,
                pos=stadpos)
            bolt_list.append(shp_stad)

        shp_bolts = fcfun.fuseshplist(bolt_list)
        shp_l = shp_l.cut(shp_bolts)

        # ---------------- Belt clamps
        # at both sides
        clamp_list = []
        for w_side in [-1, 1]:
            clamp_pos = self.get_pos_dwh(0, w_side * 7, 7)
            if w_side == 1:
                clamp_axis_w = self.axis_w.negative()
            else:
                clamp_axis_w = self.axis_w
            shp_clamp = fcfun.shp_box_dir_xtr(box_w=beltclamp_l,
                                              box_d=self.beltclamp_blk_t,
                                              box_h=beltclamp_h,
                                              fc_axis_h=self.axis_h,
                                              fc_axis_d=self.axis_d,
                                              fc_axis_w=clamp_axis_w,
                                              cw=0,
                                              cd=0,
                                              ch=0,
                                              xtr_nh=1,
                                              pos=clamp_pos)

            # fillet the corner
            shp_clamp = fcfun.shp_filletchamfer_dirpt(shp_clamp,
                                                      self.axis_h,
                                                      fc_pt=clamp_pos,
                                                      fillet=1,
                                                      radius=fillet_r)
            shp_clamp = shp_clamp.removeSplitter()
            clamp_list.append(shp_clamp)

            # the other clamp, with no fillet
            clamp_pos = self.get_pos_dwh(6, w_side * 7, 7)
            shp_clamp = fcfun.shp_box_dir_xtr(box_w=beltclamp_l,
                                              box_d=self.beltclamp_blk_t,
                                              box_h=beltclamp_h,
                                              fc_axis_h=self.axis_h,
                                              fc_axis_d=self.axis_d.negative(),
                                              fc_axis_w=clamp_axis_w,
                                              cw=0,
                                              cd=0,
                                              ch=0,
                                              xtr_nh=1,
                                              pos=clamp_pos)
            clamp_list.append(shp_clamp)

            # the belt post
            beltpost_pos = self.get_pos_dwh(2, w_side * 5, 7)
            shp_beltpost = fcfun.shp_belt_dir(center_sep=2 *
                                              self.lr_beltpost_r,
                                              rad1=sm_beltpost_r,
                                              rad2=self.lr_beltpost_r,
                                              height=beltclamp_h,
                                              fc_axis_h=self.axis_h,
                                              fc_axis_l=clamp_axis_w,
                                              ref_l=3,
                                              ref_h=2,
                                              xtr_h=0,
                                              xtr_nh=1,
                                              pos=beltpost_pos)

            clamp_list.append(shp_beltpost)
        shp_filterholder = shp_l.multiFuse(clamp_list)
        shp_filterholder = shp_filterholder.removeSplitter()
        #Part.show (shp_filterholder)

        self.shp = shp_filterholder
    def __init__(self,
                 nema_size=17,
                 base_motor_d=6.,
                 base_d=4.,
                 base_h=16.,
                 wall_thick=4.,
                 motor_thick=4.,
                 reinf_thick=4.,
                 motor_min_h=10.,
                 motor_max_h=20.,
                 motor_xtr_space=2.,
                 bolt_wall_d=4.,
                 bolt1_wall_d=5.,
                 bolt_wall_sep=30.,
                 chmf_r=1.,
                 axis_h=VZ,
                 axis_d=VX,
                 axis_w=None,
                 pos_h=1,
                 pos_d=3,
                 pos_w=0,
                 pos=V0,
                 name=''):
        if axis_w is None or axis_w == V0:
            axis_w = axis_h.cross(axis_d)  #vector product

        default_name = 'base'
        self.set_name(name, default_name, change=0)
        Obj3D.__init__(self, axis_d, axis_w, axis_h, self.name)

        # save the arguments as attributes:
        frame = inspect.currentframe()
        args, _, _, values = inspect.getargvalues(frame)
        for i in args:
            if not hasattr(self, i):
                setattr(self, i, values[i])

        self.pos = FreeCAD.Vector(0, 0, 0)
        self.position = pos

        # normal axes to print without support
        self.prnt_ax = self.axis_h

        self.motor_w = kcomp.NEMA_W[nema_size]
        self.motor_bolt_sep = kcomp.NEMA_BOLT_SEP[nema_size]
        self.motor_bolt_d = kcomp.NEMA_BOLT_D[nema_size]

        # calculation of the bolt to hold the base to the profile
        self.boltshank_r_tol = kcomp.D912[bolt1_wall_d]['shank_r_tol']
        self.bolthead_r = kcomp.D912[bolt1_wall_d]['head_l']
        self.bolthead_r_tol = kcomp.D912[bolt1_wall_d]['head_r']
        self.bolthead_l = kcomp.D912[bolt1_wall_d]['head_l']

        # calculation of the bolt wall d
        self.boltwallhead_l = kcomp.D912[bolt_wall_d]['head_l']
        self.boltwallhead_r = kcomp.D912[bolt_wall_d]['head_r']
        self.washer_thick = kcomp.WASH_D125_T[bolt_wall_d]

        # calculation of the bolt wall separation
        self.max_bolt_wall_sep = self.motor_w - 2 * self.boltwallhead_r
        if bolt_wall_sep == 0:
            self.bolt_wall_sep = self.max_bolt_wall_sep
        elif bolt_wall_sep > self.max_bolt_wall_sep:
            logger.debug('bolt separation too large:' + str(bolt_wall_sep))
            self.bolt_wall_sep = self.max_bolt_wall_sep
            logger.debug('taking largest value:' + str(self.bolt_wall_sep))
        elif bolt_wall_sep < 4 * self.boltwallhead_r:
            logger.debug('bolt separation too short:' + str(bolt_wall_sep))
            self.bolt_wall_sep = self.self.max_bolt_wall_sep
            logger.debug('taking smallest value:' + str(self.bolt_wall_sep))

        # distance from the motor to the inner wall (in axis_d)
        self.motor_inwall_space = motor_xtr_space + self.boltwallhead_l + self.washer_thick

        # making the big box that will contain everything and will be cut
        self.tot_h = wall_thick + base_h + motor_thick + motor_max_h + 2 * bolt_wall_d
        self.tot_w = 2 * reinf_thick + self.motor_w + 2 * motor_xtr_space
        self.tot_d = base_motor_d + wall_thick + self.motor_w + self.motor_inwall_space

        # definition of which axis is symmetrical
        self.h0_cen = 0
        self.w0_cen = 1  # symmetrical
        self.d0_cen = 0

        # vectors from the origin to the points along axis_h
        self.h_o[0] = V0
        self.h_o[1] = self.vec_h(wall_thick)
        self.h_o[2] = self.vec_h(wall_thick + base_h)
        self.h_o[3] = self.vec_h(wall_thick + base_h + motor_thick)
        self.h_o[4] = self.vec_h(wall_thick + base_h + motor_thick +
                                 motor_min_h)
        self.h_o[5] = self.vec_h(wall_thick + base_h + motor_thick +
                                 motor_max_h)
        self.h_o[6] = self.vec_h(self.tot_h)

        # position along axis_d
        self.d_o[0] = V0
        self.d_o[1] = self.vec_d(base_d)
        self.d_o[2] = self.vec_d(base_motor_d)
        self.d_o[3] = self.vec_d(base_d + self.bolthead_r_tol)
        self.d_o[4] = self.vec_d(base_d + 2 * self.bolthead_r)

        # vectors from the origin to the points along axis_w
        self.w_o[0] = V0
        self.w_o[1] = self.vec_w(-self.bolt_wall_sep / 2.)
        self.w_o[2] = self.vec_w(-self.motor_bolt_sep / 2.)
        self.w_o[3] = self.vec_w(-self.tot_w / 2.)

        # calculates the position of the origin, and keeps it in attribute pos_o
        self.set_pos_o()

        # make the whole box
        shp_box = fcfun.shp_box_dir(box_w=self.tot_w,
                                    box_d=self.tot_d,
                                    box_h=self.tot_h,
                                    fc_axis_h=self.axis_h,
                                    fc_axis_d=self.axis_d,
                                    cw=1,
                                    cd=0,
                                    ch=0,
                                    pos=self.pos_o)
        super().add_child(shp_box, 1, 'shp_box')

        shp_box_int = fcfun.shp_box_dir(box_w=self.tot_w,
                                        box_d=self.tot_d,
                                        box_h=base_h,
                                        fc_axis_h=self.axis_h,
                                        fc_axis_d=self.axis_d,
                                        cw=1,
                                        cd=0,
                                        ch=0,
                                        pos=self.get_pos_dwh(1, 0, 1))
        super().add_child(shp_box_int, 0, 'shp_box_int')

        shp_box_ext = fcfun.shp_box_dir(box_w=self.tot_w,
                                        box_d=self.tot_d,
                                        box_h=motor_thick + motor_max_h +
                                        2 * bolt_wall_d,
                                        fc_axis_h=self.axis_h,
                                        fc_axis_d=self.axis_d,
                                        cw=1,
                                        cd=0,
                                        ch=0,
                                        pos=self.get_pos_dwh(2, 0, 2))
        super().add_child(shp_box_ext, 0, 'shp_box_ext')

        shp_box_init = fcfun.shp_box_dir(box_w=self.tot_w,
                                         box_d=self.tot_d,
                                         box_h=wall_thick,
                                         fc_axis_h=self.axis_h,
                                         fc_axis_d=self.axis_d,
                                         cw=1,
                                         cd=0,
                                         ch=0,
                                         pos=self.get_pos_dwh(4, 0, 0))
        super().add_child(shp_box_init, 0, 'shp_box_init')

        shp_hole1 = fcfun.shp_cylcenxtr(r=self.boltshank_r_tol,
                                        h=wall_thick,
                                        normal=self.axis_h,
                                        ch=0,
                                        xtr_top=1,
                                        xtr_bot=1,
                                        pos=self.get_pos_dwh(3, -2, 0))
        super().add_child(shp_hole1, 0, 'shp_hole1')

        shp_hole2 = fcfun.shp_cylcenxtr(r=self.boltshank_r_tol,
                                        h=wall_thick,
                                        normal=self.axis_h,
                                        ch=0,
                                        xtr_top=1,
                                        xtr_bot=1,
                                        pos=self.get_pos_dwh(3, 2, 0))
        super().add_child(shp_hole2, 0, 'shp_hole2')

        super().make_parent(name)
        chmf_reinf_r = min(base_motor_d - base_d, base_h)
        self.shp = fcfun.shp_filletchamfer_dirpt(self.shp,
                                                 self.axis_w,
                                                 fc_pt=self.get_pos_dwh(
                                                     2, 0, 2),
                                                 fillet=0,
                                                 radius=(chmf_reinf_r - TOL))

        # Then the Part
        super().create_fco(name)
        self.fco.Placement.Base = FreeCAD.Vector(0, 0, 0)
        self.fco.Placement.Base = self.position
    def __init__(self,
                 nema_size=17,
                 base_motor_d=6.,
                 base_d=4.,
                 base_h=16.,
                 wall_thick=4.,
                 motor_thick=4.,
                 reinf_thick=4.,
                 motor_min_h=10.,
                 motor_max_h=20.,
                 motor_xtr_space=2.,
                 bolt_wall_d=4.,
                 bolt1_wall_d=5.,
                 bolt_wall_sep=30.,
                 chmf_r=1.,
                 opt_sides=1,
                 axis_h=VZ,
                 axis_d=VX,
                 axis_w=None,
                 pos_h=1,
                 pos_d=3,
                 pos_w=0,
                 pos=V0,
                 name=''):
        if axis_w is None or axis_w == V0:
            axis_w = axis_h.cross(axis_d)  #vector product

        default_name = 'base'
        self.set_name(name, default_name, change=0)
        Obj3D.__init__(self, axis_d, axis_w, axis_h, self.name)

        # save the arguments as attributes:
        frame = inspect.currentframe()
        args, _, _, values = inspect.getargvalues(frame)
        for i in args:
            if not hasattr(self, i):
                setattr(self, i, values[i])

        self.pos = FreeCAD.Vector(0, 0, 0)
        self.position = pos

        # normal axes to print without support
        self.prnt_ax = self.axis_h

        self.motor_w = kcomp.NEMA_W[nema_size]
        self.motor_bolt_sep = kcomp.NEMA_BOLT_SEP[nema_size]
        self.motor_bolt_d = kcomp.NEMA_BOLT_D[nema_size]

        self.base_motor_h = motor_thick + motor_max_h + 2 * bolt_wall_d + 30.

        # calculation of the bolt to hold the base to the profile
        self.boltshank_r_tol = kcomp.D912[bolt1_wall_d]['shank_r_tol']
        self.bolthead_r = kcomp.D912[bolt1_wall_d]['head_l']
        self.bolthead_r_tol = kcomp.D912[bolt1_wall_d]['head_r']
        self.bolthead_l = kcomp.D912[bolt1_wall_d]['head_l']

        # calculation of the bolt wall d
        self.boltwallshank_r_tol = kcomp.D912[bolt_wall_d]['shank_r_tol']
        self.boltwallhead_l = kcomp.D912[bolt_wall_d]['head_l']
        self.boltwallhead_r = kcomp.D912[bolt_wall_d]['head_r']
        self.washer_thick = kcomp.WASH_D125_T[bolt_wall_d]

        # calculation of the bolt wall separation
        self.max_bolt_wall_sep = self.motor_w - 2 * self.boltwallhead_r
        if bolt_wall_sep == 0:
            self.bolt_wall_sep = self.max_bolt_wall_sep
        elif bolt_wall_sep > self.max_bolt_wall_sep:
            logger.debug('bolt separation too large:' + str(bolt_wall_sep))
            self.bolt_wall_sep = self.max_bolt_wall_sep
            logger.debug('taking largest value:' + str(self.bolt_wall_sep))
        elif bolt_wall_sep < 4 * self.boltwallhead_r:
            logger.debug('bolt separation too short:' + str(bolt_wall_sep))
            self.bolt_wall_sep = self.self.max_bolt_wall_sep
            logger.debug('taking smallest value:' + str(self.bolt_wall_sep))

        # distance from the motor to the inner wall (in axis_d)
        self.motor_inwall_space = motor_xtr_space + self.boltwallhead_l + self.washer_thick

        # making the big box that will contain everything and will be cut
        self.tot_h = wall_thick + base_h + self.base_motor_h
        self.tot_d = base_d + 2 * self.bolthead_r
        if opt_sides == 0:
            self.tot_w = 2 * reinf_thick + self.motor_w + 2 * motor_xtr_space
        else:
            self.tot_w = 2 * reinf_thick + self.motor_w + 2 * motor_xtr_space + 4 * self.bolthead_r_tol + 8.

        # definition of which axis is symmetrical
        self.h0_cen = 0
        self.w0_cen = 1  # symmetrical
        self.d0_cen = 0

        # vectors from the origin to the points along axis_h
        self.h_o[0] = V0
        self.h_o[1] = self.vec_h(wall_thick)
        self.h_o[2] = self.vec_h(wall_thick + 2 * self.bolthead_r)
        self.h_o[3] = self.vec_h(wall_thick + base_h)
        self.h_o[4] = self.vec_h(wall_thick + base_h + motor_thick)
        self.h_o[5] = self.vec_h(wall_thick + base_h + motor_thick +
                                 motor_min_h)
        self.h_o[6] = self.vec_h(wall_thick + base_h + motor_thick)
        self.h_o[7] = self.vec_h(wall_thick + base_h + motor_thick +
                                 (motor_min_h + motor_max_h) / 4.)
        self.h_o[8] = self.vec_h(wall_thick + base_h + motor_thick + 2 *
                                 (motor_min_h + motor_max_h) / 4.)
        self.h_o[9] = self.vec_h(wall_thick + base_h + motor_thick + 3 *
                                 (motor_min_h + motor_max_h) / 4.)
        self.h_o[10] = self.vec_h(wall_thick + base_h + motor_thick +
                                  (motor_min_h + motor_max_h))
        self.h_o[11] = self.vec_h(wall_thick + base_h + motor_thick + 5 *
                                  (motor_min_h + motor_max_h) / 4.)
        self.h_o[12] = self.vec_h(wall_thick + base_h + motor_thick +
                                  motor_max_h)
        self.h_o[13] = self.vec_h(self.tot_h)

        # position along axis_d
        self.d_o[0] = V0
        self.d_o[1] = self.vec_d(base_d)
        self.d_o[2] = self.vec_d(base_motor_d)
        self.d_o[3] = self.vec_d(self.tot_d / 2.)
        self.d_o[4] = self.vec_d(base_d + self.bolthead_r_tol)
        self.d_o[5] = self.vec_d(self.tot_d)

        # vectors from the origin to the points along axis_w
        if opt_sides == 0:
            self.w_o[0] = V0
            self.w_o[1] = self.vec_w(-self.bolt_wall_sep / 2.)
            self.w_o[2] = self.vec_w(-self.motor_bolt_sep / 2.)
            self.w_o[3] = self.vec_w(-self.tot_w / 2.)
        else:
            self.w_o[0] = V0
            self.w_o[1] = self.vec_w(-self.bolt_wall_sep / 2.)
            self.w_o[2] = self.vec_w(-self.motor_bolt_sep / 2.)
            self.w_o[3] = self.vec_w(
                -(2 * reinf_thick + self.motor_w + 2 * motor_xtr_space) / 2.)
            self.w_o[4] = self.vec_w(
                -(2 * reinf_thick + self.motor_w + 2 * motor_xtr_space +
                  2 * self.bolthead_r_tol + 4.) / 2.)
            self.w_o[5] = self.vec_w(-self.tot_w / 2.)

        # calculates the position of the origin, and keeps it in attribute pos_o
        self.set_pos_o()

        # make the whole box
        if opt_sides == 0:
            shp_box = fcfun.shp_box_dir(box_w=self.tot_w,
                                        box_d=self.tot_d,
                                        box_h=self.tot_h,
                                        fc_axis_h=self.axis_h,
                                        fc_axis_d=self.axis_d,
                                        cw=1,
                                        cd=0,
                                        ch=0,
                                        pos=self.pos_o)
            super().add_child(shp_box, 1, 'shp_box')

            shp_box_int = fcfun.shp_box_dir(box_w=self.tot_w,
                                            box_d=self.tot_d,
                                            box_h=base_h,
                                            fc_axis_h=self.axis_h,
                                            fc_axis_d=self.axis_d,
                                            cw=1,
                                            cd=0,
                                            ch=0,
                                            pos=self.get_pos_dwh(1, 0, 1))
            super().add_child(shp_box_int, 0, 'shp_box_int')

            shp_box_ext = fcfun.shp_box_dir(box_w=self.tot_w,
                                            box_d=self.tot_d,
                                            box_h=self.base_motor_h,
                                            fc_axis_h=self.axis_h,
                                            fc_axis_d=self.axis_d,
                                            cw=1,
                                            cd=0,
                                            ch=0,
                                            pos=self.get_pos_dwh(2, 0, 3))
            super().add_child(shp_box_ext, 0, 'shp_box_ext')

            shp_box_init = fcfun.shp_box_dir(box_w=self.tot_w +
                                             2 * self.bolthead_r_tol,
                                             box_d=self.tot_d,
                                             box_h=wall_thick,
                                             fc_axis_h=self.axis_h,
                                             fc_axis_d=self.axis_d,
                                             cw=1,
                                             cd=0,
                                             ch=0,
                                             pos=self.get_pos_dwh(5, 0, 0))
            super().add_child(shp_box_init, 0, 'shp_box_init')

            # holes to hold the profile
            shp_hole1 = fcfun.shp_cylcenxtr(r=self.boltshank_r_tol,
                                            h=wall_thick,
                                            normal=self.axis_h,
                                            ch=0,
                                            xtr_top=1,
                                            xtr_bot=1,
                                            pos=self.get_pos_dwh(4, -2, 0))
            super().add_child(shp_hole1, 0, 'shp_hole1')
            shp_hole2 = fcfun.shp_cylcenxtr(r=self.boltshank_r_tol,
                                            h=wall_thick,
                                            normal=self.axis_h,
                                            ch=0,
                                            xtr_top=1,
                                            xtr_bot=1,
                                            pos=self.get_pos_dwh(4, 2, 0))
            super().add_child(shp_hole2, 0, 'shp_hole2')

            # holes to hold the Nema Motor Holder
            shp_cen_bolt1 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, -1, 6))
            super().add_child(shp_cen_bolt1, 0, 'shp_cen_bolt1')
            shp_cen_bolt2 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, 1, 6))
            super().add_child(shp_cen_bolt2, 0, 'shp_cen_bolt2')
            shp_cen_bolt3 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, -1, 7))
            super().add_child(shp_cen_bolt3, 0, 'shp_cen_bolt3')
            shp_cen_bolt4 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, 1, 7))
            super().add_child(shp_cen_bolt4, 0, 'shp_cen_bolt4')
            shp_cen_bolt5 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, -1, 8))
            super().add_child(shp_cen_bolt5, 0, 'shp_cen_bolt5')
            shp_cen_bolt6 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, 1, 8))
            super().add_child(shp_cen_bolt6, 0, 'shp_cen_bolt6')
            shp_cen_bolt7 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, -1, 9))
            super().add_child(shp_cen_bolt7, 0, 'shp_cen_bolt7')
            shp_cen_bolt8 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, 1, 9))
            super().add_child(shp_cen_bolt8, 0, 'shp_cen_bolt8')
            shp_cen_bolt9 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, -1, 10))
            super().add_child(shp_cen_bolt9, 0, 'shp_cen_bolt9')
            shp_cen_bolt10 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, 1, 10))
            super().add_child(shp_cen_bolt10, 0, 'shp_cen_bolt10')
            shp_cen_bolt11 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, -1, 11))
            super().add_child(shp_cen_bolt11, 0, 'shp_cen_bolt11')
            shp_cen_bolt12 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, 1, 11))
            super().add_child(shp_cen_bolt12, 0, 'shp_cen_bolt12')
        else:
            shp_box = fcfun.shp_box_dir(box_w=self.tot_w,
                                        box_d=self.tot_d,
                                        box_h=self.tot_h,
                                        fc_axis_h=self.axis_h,
                                        fc_axis_d=self.axis_d,
                                        cw=1,
                                        cd=0,
                                        ch=0,
                                        pos=self.pos_o)
            super().add_child(shp_box, 1, 'shp_box')

            shp_box_int = fcfun.shp_box_dir(box_w=self.tot_w,
                                            box_d=self.tot_d,
                                            box_h=base_h,
                                            fc_axis_h=self.axis_h,
                                            fc_axis_d=self.axis_d,
                                            cw=1,
                                            cd=0,
                                            ch=0,
                                            pos=self.get_pos_dwh(1, 0, 1))
            super().add_child(shp_box_int, 0, 'shp_box_int')

            shp_box_ext = fcfun.shp_box_dir(box_w=self.tot_w,
                                            box_d=self.tot_d,
                                            box_h=self.base_motor_h,
                                            fc_axis_h=self.axis_h,
                                            fc_axis_d=self.axis_d,
                                            cw=1,
                                            cd=0,
                                            ch=0,
                                            pos=self.get_pos_dwh(2, 0, 3))
            super().add_child(shp_box_ext, 0, 'shp_box_ext')

            shp_box_init = fcfun.shp_box_dir(box_w=self.tot_w,
                                             box_d=self.tot_d,
                                             box_h=wall_thick,
                                             fc_axis_h=self.axis_h,
                                             fc_axis_d=self.axis_d,
                                             cw=1,
                                             cd=0,
                                             ch=0,
                                             pos=self.get_pos_dwh(5, 0, 0))
            super().add_child(shp_box_init, 0, 'shp_box_init')

            shp_box_lat1 = fcfun.shp_box_dir(box_w=2 * +self.bolthead_r_tol +
                                             4.,
                                             box_d=self.tot_d,
                                             box_h=self.tot_h,
                                             fc_axis_h=self.axis_h,
                                             fc_axis_d=self.axis_d,
                                             cw=1,
                                             cd=0,
                                             ch=0,
                                             pos=self.get_pos_dwh(0, -4, 1))
            super().add_child(shp_box_lat1, 0, 'shp_box_lat1')
            shp_box_lat2 = fcfun.shp_box_dir(box_w=2 * +self.bolthead_r_tol +
                                             4.,
                                             box_d=self.tot_d,
                                             box_h=self.tot_h,
                                             fc_axis_h=self.axis_h,
                                             fc_axis_d=self.axis_d,
                                             cw=1,
                                             cd=0,
                                             ch=0,
                                             pos=self.get_pos_dwh(0, 4, 1))
            super().add_child(shp_box_lat2, 0, 'shp_box_lat2')

            # holes to hold the profile # self.get_d_ab(5,4).x
            shp_hole1 = fcfun.shp_stadium_dir(
                self.tot_d - 2 * ((self.d_o[5] - self.d_o[4]).Length),
                radius=self.boltshank_r_tol,
                height=wall_thick,
                fc_axis_h=self.axis_h,
                fc_axis_l=self.axis_d.negative(),
                fc_axis_s=V0,
                ref_l=2,
                ref_s=1,
                ref_h=2,
                xtr_nh=1,
                pos=self.get_pos_dwh(4, -4, 0))
            super().add_child(shp_hole1, 0, 'shp_hole1')

            shp_hole2 = fcfun.shp_stadium_dir(
                self.tot_d - 2 * ((self.d_o[5] - self.d_o[4]).Length),
                radius=self.boltshank_r_tol,
                height=wall_thick,
                fc_axis_h=self.axis_h,
                fc_axis_l=self.axis_d.negative(),
                fc_axis_s=V0,
                ref_l=2,
                ref_s=1,
                ref_h=2,
                xtr_nh=1,
                pos=self.get_pos_dwh(4, 4, 0))
            super().add_child(shp_hole2, 0, 'shp_hole2')

            shp_hole3 = fcfun.shp_cylcenxtr(r=self.boltshank_r_tol,
                                            h=wall_thick,
                                            normal=self.axis_h,
                                            ch=0,
                                            xtr_top=1,
                                            xtr_bot=1,
                                            pos=self.get_pos_dwh(4, -2, 0))
            super().add_child(shp_hole3, 0, 'shp_hole3')
            shp_hole4 = fcfun.shp_cylcenxtr(r=self.boltshank_r_tol,
                                            h=wall_thick,
                                            normal=self.axis_h,
                                            ch=0,
                                            xtr_top=1,
                                            xtr_bot=1,
                                            pos=self.get_pos_dwh(4, 2, 0))
            super().add_child(shp_hole4, 0, 'shp_hole4')

            # holes to hold the Nema Motor Holder
            shp_cen_bolt1 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, -1, 6))
            super().add_child(shp_cen_bolt1, 0, 'shp_cen_bolt1')
            shp_cen_bolt2 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, 1, 6))
            super().add_child(shp_cen_bolt2, 0, 'shp_cen_bolt2')
            shp_cen_bolt3 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, -1, 7))
            super().add_child(shp_cen_bolt3, 0, 'shp_cen_bolt3')
            shp_cen_bolt4 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, 1, 7))
            super().add_child(shp_cen_bolt4, 0, 'shp_cen_bolt4')
            shp_cen_bolt5 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, -1, 8))
            super().add_child(shp_cen_bolt5, 0, 'shp_cen_bolt5')
            shp_cen_bolt6 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, 1, 8))
            super().add_child(shp_cen_bolt6, 0, 'shp_cen_bolt6')
            shp_cen_bolt7 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, -1, 9))
            super().add_child(shp_cen_bolt7, 0, 'shp_cen_bolt7')
            shp_cen_bolt8 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, 1, 9))
            super().add_child(shp_cen_bolt8, 0, 'shp_cen_bolt8')
            shp_cen_bolt9 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, -1, 10))
            super().add_child(shp_cen_bolt9, 0, 'shp_cen_bolt9')
            shp_cen_bolt10 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, 1, 10))
            super().add_child(shp_cen_bolt10, 0, 'shp_cen_bolt10')
            shp_cen_bolt11 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, -1, 11))
            super().add_child(shp_cen_bolt11, 0, 'shp_cen_bolt11')
            shp_cen_bolt12 = fcfun.shp_bolt_dir(
                r_shank=self.boltwallshank_r_tol,
                l_bolt=base_motor_d,
                r_head=self.boltwallhead_r,
                l_head=self.boltwallhead_l,
                xtr_head=1,
                xtr_shank=1,
                fc_normal=self.axis_d,
                pos_n=0,
                pos=self.get_pos_dwh(0, 1, 11))
            super().add_child(shp_cen_bolt12, 0, 'shp_cen_bolt12')

        super().make_parent(name)
        chmf_reinf_r = min(base_motor_d - base_d, base_h)
        self.shp = fcfun.shp_filletchamfer_dirpt(self.shp,
                                                 self.axis_w,
                                                 fc_pt=self.get_pos_dwh(
                                                     2, 0, 3),
                                                 fillet=0,
                                                 radius=(chmf_reinf_r - TOL))
        if opt_sides == 0:
            for pt_w in (-3, 3):
                for pt_h in (0, 13):
                    self.shp = fcfun.shp_filletchamfer_dirpt(
                        self.shp,
                        self.axis_d,
                        fc_pt=self.get_pos_dwh(0, pt_w, pt_h),
                        fillet=1,
                        radius=chmf_r)
                self.shp = fcfun.shp_filletchamfer_dirpt(
                    self.shp,
                    self.axis_d,
                    fc_pt=self.get_pos_dwh(5, pt_w, 1),
                    fillet=1,
                    radius=chmf_r)
        else:
            for pt_w in (-5, 5):
                for pt_h in (0, 1):
                    self.shp = fcfun.shp_filletchamfer_dirpt(
                        self.shp,
                        self.axis_d,
                        fc_pt=self.get_pos_dwh(0, pt_w, pt_h),
                        fillet=1,
                        radius=chmf_r)
            for pt_w in (-3, 3):
                for pt_h in (1, 13):
                    self.shp = fcfun.shp_filletchamfer_dirpt(
                        self.shp,
                        self.axis_d,
                        fc_pt=self.get_pos_dwh(0, pt_w, pt_h),
                        fillet=1,
                        radius=chmf_r)

        fuse = []
        fuse.append(self.shp)
        shp_box_ref = fcfun.shp_box_dir(box_w=2 * self.bolthead_r,
                                        box_d=2 * self.bolthead_r,
                                        box_h=2 * self.bolthead_r,
                                        fc_axis_w=self.axis_w,
                                        fc_axis_h=self.axis_h,
                                        fc_axis_d=self.axis_d,
                                        cw=1,
                                        cd=0,
                                        ch=0,
                                        pos=self.get_pos_dwh(1, 0, 1))
        shp_box_ref = fcfun.shp_filletchamfer_dirpt(
            shp_box_ref,
            self.axis_w,
            fc_pt=self.get_pos_dwh(5, 0, 2),
            fillet=0,
            radius=2 * self.bolthead_r - TOL)
        fuse.append(shp_box_ref)
        shp_final = fcfun.fuseshplist(fuse)
        self.shp = shp_final

        # Then the Part
        super().create_fco(name)
        self.fco.Placement.Base = FreeCAD.Vector(0, 0, 0)
        self.fco.Placement.Base = self.position
    def __init__ (self,
                  nema_size = 17,
                  wall_thick = 4.,
                  motorside_thick = 4.,
                  reinf_thick = 4.,
                  motor_min_h =10.,
                  motor_max_h =20.,
                  rail = 1, # if there is a rail or not at the profile side
                  motor_xtr_space = 2., # counting on one side
                  bolt_wall_d = 4., # Metric of the wall bolts
                  bolt_wall_sep = 0, # optional
                  chmf_r = 1.,
                  axis_h = VZ,
                  axis_d = VX,
                  axis_w = None,
                  pos_h = 1,  # 1: inner wall of the motor side
                  pos_d = 3,  # 3: motor axis
                  pos_w = 0,  # 0: center of symmetry
                  pos = V0,
                  model_type = 3, #to be printed
                  name = None):

        self.pos = FreeCAD.Vector(0,0,0)
        self.position = pos

        if name == None:
            name = 'nema' + str(nema_size) + '_motorholder'

        if axis_w is None or axis_w == V0:
            axis_w = axis_h.cross(axis_d)

        NuevaClase.Obj3D.__init__(self, axis_d, axis_w, axis_h, name)

        # save the arguments as attributes:
        frame = inspect.currentframe()
        args, _, _, values = inspect.getargvalues(frame)
        for i in args:
            if not hasattr(self,i):
                setattr(self, i, values[i])

        # normal axes to print without support
        self.prnt_ax = self.axis_h

        self.motor_w = kcomp.NEMA_W[nema_size]
        self.motor_bolt_sep = kcomp.NEMA_BOLT_SEP[nema_size]
        self.motor_bolt_d = kcomp.NEMA_BOLT_D[nema_size]

        self.boltwallshank_r_tol = kcomp.D912[bolt_wall_d]['shank_r_tol']
        self.boltwallhead_l = kcomp.D912[bolt_wall_d]['head_l']
        self.boltwallhead_r = kcomp.D912[bolt_wall_d]['head_r']
        self.washer_thick = kcomp.WASH_D125_T[bolt_wall_d]

        # calculation of the bolt wall separation
        self.max_bolt_wall_sep = self.motor_w - 2 * self.boltwallhead_r
    
        if bolt_wall_sep == 0:
            self.bolt_wall_sep = self.max_bolt_wall_sep
        elif bolt_wall_sep > self.max_bolt_wall_sep:
            logger.debug('bolt wall separtion too large: ' + str(bolt_wall_sep))
            self.bolt_wall_sep = self.max_bolt_wall_sep
            logger.debug('taking larges value: ' + str(self.bolt_wall_sep))
        elif bolt_wall_sep <  4 * self.boltwallhead_r:
            logger.debug('bolt wall separtion too short: ' + str(bolt_wall_sep))
            self.bolt_wall_sep = self.max_bolt_wall_sep
            logger.debug('taking larges value: ' + str(self.bolt_wall_sep))
        # else: the given separation is good

        # distance from the motor to the inner wall (in axis_d)
        self.motor_inwall_space = (  motor_xtr_space
                                   + self.boltwallhead_l + self.washer_thick)
        # making the big box that will contain everything and will be cut
        self.tot_h = motorside_thick + motor_max_h + 2 * bolt_wall_d
        self.tot_w = 2* reinf_thick + self.motor_w + 2 * motor_xtr_space
        self.tot_d = (   wall_thick + self.motor_w + self.motor_inwall_space)
        # distance from the motor axis to the wall (in axis_d)
        self.motax2wall = wall_thick + self.motor_inwall_space + self.motor_w/2.

        # definition of which axis is symmetrical
        self.h0_cen = 0
        self.d0_cen = 0
        self.w0_cen = 1 # symmetrical

        # vectors from the origin to the points along axis_h:
        self.h_o[0] = V0
        self.h_o[1] = self.vec_h(motorside_thick)
        self.h_o[2] = self.vec_h(motorside_thick + motor_min_h)
        self.h_o[3] = self.vec_h(motorside_thick + motor_max_h)
        self.h_o[4] = self.vec_h(self.tot_h)

        # position along axis_d
        self.d_o[0] = V0
        self.d_o[1] = self.vec_d(wall_thick) # inner wall
        # distance to the inner bolts of the motor
        self.d_o[2] = self.vec_d(self.motax2wall - self.motor_bolt_sep/2.)
        self.d_o[3] = self.vec_d(self.motax2wall)  # motor axis
        self.d_o[4] = self.vec_d(self.motax2wall + self.motor_bolt_sep/2.)
        self.d_o[5] = self.vec_d(self.tot_d)

        # vectors from the origin to the points along axis_w:
        # these are negative because actually the pos_w indicates a negative
        # position along axis_w (this happens when it is symmetrical)
        self.w_o[0] = V0
        self.w_o[1] = self.vec_w(-self.bolt_wall_sep/2.)
        self.w_o[2] = self.vec_w(-self.motor_bolt_sep/2.)
        self.w_o[3] = self.vec_w(-self.tot_w/2.)

        # calculates the position of the origin, and keeps it in attribute pos_o
        self.set_pos_o()

        # make the whole box, extra height and depth to cut all the way
        # back and down:
        shp_box = fcfun.shp_box_dir (box_w = self.tot_w,
                                     box_d = self.tot_d,
                                     box_h = self.tot_h,
                                     fc_axis_h = self.axis_h,
                                     fc_axis_d = self.axis_d,
                                     cw=1, cd=0, ch=0, pos = self.pos_o)
        # little chamfer at the corners, if fillet there are some problems
        shp_box = fcfun.shp_filletchamfer_dir(shp_box, self.axis_h,
                                              fillet=0,
                                              radius = chmf_r)
        shp_box = shp_box.removeSplitter()

        # chamfer of the box to make a 'triangular' reinforcement
        chmf_reinf_r = min(self.tot_d- wall_thick, self.tot_h-motorside_thick)
        # chamfer at the lower point (h=4), and the other end of d (d=5)
        shp_box = fcfun.shp_filletchamfer_dirpt(shp_box, self.axis_w,
                                              fc_pt =self.get_pos_dwh(5,0,4),
                                              fillet=0,
                                              radius = chmf_reinf_r)
        shp_box = shp_box.removeSplitter()

        # holes:
        holes = []
        # the space for the motor
        shp_motor = fcfun.shp_box_dir (
                                    box_w = self.motor_w + 2 * motor_xtr_space,
                                    box_d = self.tot_d + chmf_r,
                                    box_h = self.tot_h,
                                    fc_axis_h = self.axis_h,
                                    fc_axis_d = self.axis_d,
                                    cw=1, cd=0, ch=0,
                                    # at the inner walls
                                    pos = self.get_pos_dwh(1,0,1))

        shp_motor = fcfun.shp_filletchamfer_dir(shp_motor, fc_axis=self.axis_h,
                                                fillet=0, radius=chmf_r)
        holes.append(shp_motor)

        # central circle of the motor
        shp_hole = fcfun.shp_cylcenxtr(
                                 r=(self.motor_bolt_sep - self.motor_bolt_d)/2.,
                                 h = motorside_thick,
                                 normal = self.axis_h,
                                 ch = 0,
                                 xtr_top = 1,
                                 xtr_bot = 1,
                                 # position of the motor axis, at the top
                                 pos = self.get_pos_d(3))
        holes.append(shp_hole)

        # motor bolt holes
        for pt_d in (2,4):  # points of the motor holes along axis d
            for pt_w in (-2,2): # points of the motor holes along axis_w
                shp_hole = fcfun.shp_cylcenxtr( r = self.motor_bolt_d/2.+TOL,
                                            h = motorside_thick,
                                            normal = self.axis_h,
                                            ch = 0,
                                            xtr_top = 1,
                                            xtr_bot = 1,
                                            pos = self.get_pos_dwh(pt_d,pt_w,0))
                holes.append(shp_hole)
    
        # rail holes. To mount the motor holder to a profile or whatever
        for pt_w in (-1,1): # points of the holes to attach the holder
            # hole for the rails
            if rail == 1:
                shp_hole = fcfun.shp_box_dir_xtr(
                                       box_w = self.boltwallshank_r_tol * 2.,
                                       box_d = wall_thick,
                                       box_h = motor_max_h - motor_min_h,
                                       fc_axis_h = self.axis_h,
                                       fc_axis_d = self.axis_d,
                                       cw=1, cd=0, ch=0,
                                       xtr_d =1, xtr_nd=1, #to cut
                                       # h:2 the position on top of the rail
                                       pos = self.get_pos_dwh(0,pt_w,2))
                holes.append(shp_hole)
            # hole for the ending of the rails (4 semicircles)
            for pt_h in (2,3) : # both ends of the rail (along axis_h)
                shp_hole = fcfun.shp_cylcenxtr(
                                            r = self.boltwallshank_r_tol,
                                            h = wall_thick,
                                            normal = self.axis_d,
                                            ch = 0,
                                            xtr_top = 1,
                                            xtr_bot = 1,
                                            pos = self.get_pos_dwh(0,pt_w,pt_h))
                holes.append(shp_hole)

        shp_holes = fcfun.fuseshplist(holes)
        shp_motorholder = shp_box.cut(shp_holes)
        shp_bracket =shp_motorholder.removeSplitter()
        self.shp = shp_bracket
        super().create_fco()
        # Need to set first in (0,0,0) and after that set the real placement.
        # This enable to do rotations without any issue
        self.fco.Placement.Base = FreeCAD.Vector(0,0,0) 
        self.fco.Placement.Base = self.position
    def __init__(self,
                 nema_size=17,
                 base_motor_d=6.,
                 base_d=4.,
                 base_h=16.,
                 wall_thick=4.,
                 motor_thick=4.,
                 reinf_thick=4.,
                 motor_min_h=10.,
                 motor_max_h=20.,
                 motor_xtr_space=2.,
                 bolt_wall_d=4.,
                 bolt1_wall_d=5.,
                 bolt_wall_sep=30.,
                 rail=1,
                 chmf_r=1.,
                 axis_h=VZ,
                 axis_d=VX,
                 axis_w=None,
                 pos_h=1,
                 pos_d=3,
                 pos_w=0,
                 pos=V0,
                 name=''):
        if axis_w is None or axis_w == V0:
            axis_w = axis_h.cross(axis_d)  #vector product

        default_name = 'NemaMotorHolder'
        self.set_name(name, default_name, change=0)
        Obj3D.__init__(self, axis_d, axis_w, axis_h, self.name)

        self.pos = FreeCAD.Vector(0, 0, 0)
        self.position = pos

        # save the arguments as attributes
        frame = inspect.currentframe()
        args, _, _, values = inspect.getargvalues(frame)
        for i in args:
            if not hasattr(self, i):
                setattr(self, i, values[i])

        # normal axes to print without support
        self.prnt_ax = self.axis_h

        self.motor_w = kcomp.NEMA_W[nema_size]
        self.motor_bolt_sep = kcomp.NEMA_BOLT_SEP[nema_size]
        self.motor_bolt_d = kcomp.NEMA_BOLT_D[nema_size]

        # calculation of the bolt wall d
        self.boltwallshank_r_tol = kcomp.D912[bolt_wall_d]['shank_r_tol']
        self.boltwallhead_l = kcomp.D912[bolt_wall_d]['head_l']
        self.boltwallhead_r = kcomp.D912[bolt_wall_d]['head_r']
        self.washer_thick = kcomp.WASH_D125_T[bolt_wall_d]

        # calculation of the bolt wall separation
        self.max_bolt_wall_sep = self.motor_w - 2 * self.boltwallhead_r
        self.min_bolt_wall_sep = 4 * self.boltwallhead_r
        if bolt_wall_sep == 0:
            self.bolt_wall_sep = self.max_bolt_wall_sep
        elif bolt_wall_sep > self.max_bolt_wall_sep:
            logger.debug('bolt separation too large:' + str(bolt_wall_sep))
            self.bolt_wall_sep = self.max_bolt_wall_sep
            logger.debug('taking largest value:' + str(self.bolt_wall_sep))
        elif bolt_wall_sep < self.min_bolt_wall_sep:
            #elif bolt_wall_sep < 4 * self.boltwallhead_r:
            logger.debug('bolt separation too short:' + str(bolt_wall_sep))
            #self.bolt_wall_sep = self.self.max_bolt_wall_sep
            self.bolt_wall_sep = self.min_bolt_wall_sep
            logger.debug('taking smallest value:' + str(self.bolt_wall_sep))

        # distance from the motor to the inner wall (in axis_d)
        self.motor_inwall_space = motor_xtr_space + self.boltwallhead_l + self.washer_thick

        # making the big box that will contain everything and will be cut
        self.tot_h = motor_thick + motor_max_h + 2 * bolt_wall_d
        self.tot_w = 2 * reinf_thick + self.motor_w + 2 * motor_xtr_space
        self.tot_d = wall_thick + self.motor_w + self.motor_inwall_space

        # distance from the motor axis to the wall (in axis_d)
        self.motax2wall = wall_thick + self.motor_inwall_space + self.motor_w / 2.

        # definition of which axis is symmetrical
        self.h0_cen = 0
        self.w0_cen = 1  # symmetrical
        self.d0_cen = 0

        # vectors from the origin to the points along axis_h
        self.h_o[0] = V0
        self.h_o[1] = self.vec_h(motor_thick)
        self.h_o[2] = self.vec_h(motor_thick + motor_min_h)
        self.h_o[3] = self.vec_h(motor_thick + motor_max_h)
        self.h_o[4] = self.vec_h(self.tot_h)

        # position along axis_d
        self.d_o[0] = V0
        self.d_o[1] = self.vec_d(wall_thick)
        self.d_o[2] = self.vec_d(self.motax2wall - self.motor_bolt_sep / 2.)
        self.d_o[3] = self.vec_d(self.motax2wall)
        self.d_o[4] = self.vec_d(self.motax2wall + self.motor_bolt_sep / 2.)
        self.d_o[5] = self.vec_d(self.tot_d)

        # vectors from the origin to the points along axis_w
        self.w_o[0] = V0
        self.w_o[1] = self.vec_w(-self.bolt_wall_sep / 2.)
        self.w_o[2] = self.vec_w(-self.motor_bolt_sep / 2.)
        self.w_o[3] = self.vec_w(-self.tot_w / 2.)

        # calculates the position of the origin, and keeps it in attribute pos_o
        self.set_pos_o()

        # make the whole box, extra height and depth to cut all the way back and down
        shp_box1 = fcfun.shp_box_dir(box_w=self.tot_w,
                                     box_d=self.tot_d,
                                     box_h=self.tot_h,
                                     fc_axis_h=self.axis_h,
                                     fc_axis_d=self.axis_d,
                                     cw=1,
                                     cd=0,
                                     ch=0,
                                     pos=self.pos_o)
        # little chamfer at the corners, if fillet there are some problems
        shp_box2 = fcfun.shp_filletchamfer_dir(shp_box1,
                                               self.axis_h,
                                               fillet=0,
                                               radius=chmf_r)
        # chamfer of the box to make a 'triangular' reinforcement
        chmf_reinf_r = min(self.tot_d - wall_thick, self.tot_h - motor_thick)
        shp_box3 = fcfun.shp_filletchamfer_dirpt(shp_box2,
                                                 self.axis_w,
                                                 fc_pt=self.get_pos_dwh(
                                                     5, 0, 4),
                                                 fillet=0,
                                                 radius=chmf_reinf_r)
        super().add_child(shp_box3, 1, 'shp_box3')

        # holes

        # the space for the motor
        shp_motor = fcfun.shp_box_dir(box_w=self.motor_w + 2 * motor_xtr_space,
                                      box_d=self.tot_d + chmf_r,
                                      box_h=self.tot_h,
                                      fc_axis_h=self.axis_h,
                                      fc_axis_d=self.axis_d,
                                      cw=1,
                                      cd=0,
                                      ch=0,
                                      pos=self.get_pos_dwh(1, 0, 1))
        shp_motor = fcfun.shp_filletchamfer_dir(shp_motor,
                                                self.axis_h,
                                                fillet=0,
                                                radius=chmf_r)
        super().add_child(shp_motor, 0, 'shp_motor')

        # central circle of the motor
        shp_hole1 = fcfun.shp_cylcenxtr(
            r=(self.motor_bolt_sep - self.motor_bolt_d) / 2.,
            h=motor_thick,
            normal=self.axis_h,
            ch=0,
            xtr_top=1,
            xtr_bot=1,
            pos=self.get_pos_d(3))
        super().add_child(shp_hole1, 0, 'shp_hole1')

        # motor bolt holes
        shp_hole2 = fcfun.shp_cylcenxtr(r=self.motor_bolt_d / 2. + TOL,
                                        h=motor_thick,
                                        normal=self.axis_h,
                                        ch=0,
                                        xtr_top=1,
                                        xtr_bot=1,
                                        pos=self.get_pos_dwh(2, -2, 0))
        super().add_child(shp_hole2, 0, 'shp_hole2')
        shp_hole3 = fcfun.shp_cylcenxtr(r=self.motor_bolt_d / 2. + TOL,
                                        h=motor_thick,
                                        normal=self.axis_h,
                                        ch=0,
                                        xtr_top=1,
                                        xtr_bot=1,
                                        pos=self.get_pos_dwh(2, 2, 0))
        super().add_child(shp_hole3, 0, 'shp_hole3')
        shp_hole4 = fcfun.shp_cylcenxtr(r=self.motor_bolt_d / 2. + TOL,
                                        h=motor_thick,
                                        normal=self.axis_h,
                                        ch=0,
                                        xtr_top=1,
                                        xtr_bot=1,
                                        pos=self.get_pos_dwh(4, -2, 0))
        super().add_child(shp_hole4, 0, 'shp_hole4')
        shp_hole5 = fcfun.shp_cylcenxtr(r=self.motor_bolt_d / 2. + TOL,
                                        h=motor_thick,
                                        normal=self.axis_h,
                                        ch=0,
                                        xtr_top=1,
                                        xtr_bot=1,
                                        pos=self.get_pos_dwh(4, 2, 0))
        super().add_child(shp_hole5, 0, 'shp_hole5')

        # rail holes
        if rail == 1:
            shp_hole6 = fcfun.shp_box_dir_xtr(box_w=2 *
                                              self.boltwallshank_r_tol,
                                              box_d=wall_thick,
                                              box_h=motor_max_h - motor_min_h,
                                              fc_axis_h=self.axis_h,
                                              fc_axis_d=self.axis_d,
                                              cw=1,
                                              cd=0,
                                              ch=0,
                                              xtr_d=1,
                                              xtr_nd=1,
                                              pos=self.get_pos_dwh(0, -1, 2))
            super().add_child(shp_hole6, 0, 'shp_hole6')
            shp_hole7 = fcfun.shp_box_dir_xtr(box_w=2 *
                                              self.boltwallshank_r_tol,
                                              box_d=wall_thick,
                                              box_h=motor_max_h - motor_min_h,
                                              fc_axis_h=self.axis_h,
                                              fc_axis_d=self.axis_d,
                                              cw=1,
                                              cd=0,
                                              ch=0,
                                              xtr_d=1,
                                              xtr_nd=1,
                                              pos=self.get_pos_dwh(0, 1, 2))
            super().add_child(shp_hole7, 0, 'shp_hole7')

            # hole for the ending of the rails (4 semicircles)
        shp_hole8 = fcfun.shp_cylcenxtr(r=self.boltwallshank_r_tol,
                                        h=wall_thick,
                                        normal=self.axis_d,
                                        ch=0,
                                        xtr_top=1,
                                        xtr_bot=1,
                                        pos=self.get_pos_dwh(0, -1, 2))
        super().add_child(shp_hole8, 0, 'shp_hole8')
        shp_hole9 = fcfun.shp_cylcenxtr(r=self.boltwallshank_r_tol,
                                        h=wall_thick,
                                        normal=self.axis_d,
                                        ch=0,
                                        xtr_top=1,
                                        xtr_bot=1,
                                        pos=self.get_pos_dwh(0, 1, 2))
        super().add_child(shp_hole9, 0, 'shp_hole9')
        shp_hole10 = fcfun.shp_cylcenxtr(r=self.boltwallshank_r_tol,
                                         h=wall_thick,
                                         normal=self.axis_d,
                                         ch=0,
                                         xtr_top=1,
                                         xtr_bot=1,
                                         pos=self.get_pos_dwh(0, -1, 3))
        super().add_child(shp_hole10, 0, 'shp_hole10')
        shp_hole11 = fcfun.shp_cylcenxtr(r=self.boltwallshank_r_tol,
                                         h=wall_thick,
                                         normal=self.axis_d,
                                         ch=0,
                                         xtr_top=1,
                                         xtr_bot=1,
                                         pos=self.get_pos_dwh(0, 1, 3))
        super().add_child(shp_hole11, 0, 'shp_hole11')

        super().make_parent(name)

        # Then the Part
        super().create_fco(name)
        self.fco.Placement.Base = FreeCAD.Vector(0, 0, 0)
        self.fco.Placement.Base = self.position
    def __init__(self,
                 alusize_d=50.,
                 alusize_w=30.,
                 alusize_h=50.,
                 dist_alu=30.,
                 dist_hole=36.,
                 wall_thick=4.,
                 bolt_wall_d=5.,
                 chmf_r=1.,
                 axis_h=VZ,
                 axis_d=VX,
                 axis_w=None,
                 pos_h=1,
                 pos_d=3,
                 pos_w=0,
                 pos=V0,
                 name=''):
        if axis_w is None or axis_w == V0:
            axis_w = axis_h.cross(axis_d)  #vector product

        default_name = 'board'
        self.set_name(name, default_name, change=0)
        Obj3D.__init__(self, axis_d, axis_w, axis_h, self.name)

        # save the arguments as attributes:
        frame = inspect.currentframe()
        args, _, _, values = inspect.getargvalues(frame)
        for i in args:
            if not hasattr(self, i):
                setattr(self, i, values[i])

        self.pos = FreeCAD.Vector(0, 0, 0)
        self.position = pos

        # normal axes to print without support
        self.prnt_ax = self.axis_h

        # calculation of the bolt to hold the base to the profile
        self.boltshank_r_tol = kcomp.D912[bolt_wall_d]['shank_r_tol']
        self.bolthead_r = kcomp.D912[bolt_wall_d]['head_l']
        self.bolthead_r_tol = kcomp.D912[bolt_wall_d]['head_r']
        self.bolthead_l = kcomp.D912[bolt_wall_d]['head_l']
        self.bolthead_l_tol = kcomp.D912[bolt_wall_d]['head_l_tol']

        # making the big box that will contain everything and will be cut
        self.tot_w = alusize_w + 4.5
        self.tot_h = wall_thick + alusize_h / 2.
        self.tot_d = 2 * alusize_d - 20. + dist_alu + 8.5

        # definition of which axis is symmetrical
        self.h0_cen = 0
        self.d0_cen = 0  # symmetrical
        self.w0_cen = 1  # symmetrical

        # vectors from the origin to the points along axis_h
        self.h_o[0] = V0
        self.h_o[1] = self.vec_h(wall_thick)
        self.h_o[2] = self.vec_h(self.tot_h)

        # position along axis_d
        self.d_o[0] = V0
        self.d_o[1] = self.vec_d(alusize_d / 2. - 10. + 4.25)
        self.d_o[2] = self.vec_d(alusize_d - 10. + 4.25 + TOL)
        self.d_o[3] = self.vec_d(alusize_d - 10. + 4.25 + dist_alu / 2.)
        self.d_o[4] = self.vec_d(alusize_d - 10. + 4.25 + dist_alu - TOL)
        self.d_o[5] = self.vec_d(alusize_d - 10. + 4.25 + dist_alu +
                                 alusize_d / 2.)
        self.d_o[6] = self.vec_d(self.tot_d)

        # vectors from the origin to the points along axis_w
        self.w_o[0] = V0
        self.w_o[1] = self.vec_w(-(dist_hole / 2.))
        self.w_o[2] = self.vec_w(-self.tot_w / 2.)

        # calculates the position of the origin, and keeps it in attribute pos_o
        self.set_pos_o()

        # make the whole box
        shp_box = fcfun.shp_box_dir(box_w=self.tot_w,
                                    box_d=self.tot_d,
                                    box_h=self.tot_h,
                                    fc_axis_d=self.axis_d,
                                    fc_axis_h=self.axis_h,
                                    cw=1,
                                    cd=0,
                                    ch=0,
                                    pos=self.pos_o)

        # make the shape of the piece
        cut = []
        cut_box1 = fcfun.shp_box_dir(box_w=self.tot_w,
                                     box_d=alusize_d - 10. + 4.25 + TOL,
                                     box_h=alusize_h,
                                     fc_axis_d=self.axis_d,
                                     fc_axis_h=self.axis_h,
                                     cw=1,
                                     cd=0,
                                     ch=0,
                                     pos=self.get_pos_dwh(0, 0, 1))
        cut.append(cut_box1)
        cut_box2 = fcfun.shp_box_dir(box_w=self.tot_w,
                                     box_d=alusize_d - 10. + 4.25 + TOL,
                                     box_h=alusize_h,
                                     fc_axis_d=self.axis_d,
                                     fc_axis_h=self.axis_h,
                                     cw=1,
                                     cd=0,
                                     ch=0,
                                     pos=self.get_pos_dwh(4, 0, 1))
        cut.append(cut_box2)

        # holes to hold the profile
        cut_hole1 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                       l_bolt=wall_thick,
                                       r_head=self.bolthead_r_tol,
                                       l_head=wall_thick / 2.,
                                       xtr_head=1,
                                       xtr_shank=1,
                                       fc_normal=self.axis_h,
                                       pos_n=0,
                                       pos=self.get_pos_dwh(1, -1, 0))
        cut.append(cut_hole1)
        cut_hole2 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                       l_bolt=wall_thick,
                                       r_head=self.bolthead_r_tol,
                                       l_head=wall_thick / 2.,
                                       xtr_head=1,
                                       xtr_shank=1,
                                       fc_normal=self.axis_h,
                                       pos_n=0,
                                       pos=self.get_pos_dwh(1, 1, 0))
        cut.append(cut_hole2)
        cut_hole3 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                       l_bolt=wall_thick,
                                       r_head=self.bolthead_r_tol,
                                       l_head=wall_thick / 2.,
                                       xtr_head=1,
                                       xtr_shank=1,
                                       fc_normal=self.axis_h,
                                       pos_n=0,
                                       pos=self.get_pos_dwh(5, -1, 0))
        cut.append(cut_hole3)
        cut_hole4 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                       l_bolt=wall_thick,
                                       r_head=self.bolthead_r_tol,
                                       l_head=wall_thick / 2.,
                                       xtr_head=1,
                                       xtr_shank=1,
                                       fc_normal=self.axis_h,
                                       pos_n=0,
                                       pos=self.get_pos_dwh(5, 1, 0))
        cut.append(cut_hole4)

        # holes to hold de screw
        hole1 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                   l_bolt=self.tot_h,
                                   r_head=self.bolthead_r_tol,
                                   l_head=13 * self.tot_h / 20.,
                                   xtr_head=1,
                                   xtr_shank=1,
                                   fc_normal=self.axis_h.negative(),
                                   pos_n=0,
                                   pos=self.get_pos_dwh(3, -1, 2))
        cut.append(hole1)
        hole2 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                   l_bolt=self.tot_h,
                                   r_head=self.bolthead_r_tol,
                                   l_head=13 * self.tot_h / 20.,
                                   xtr_head=1,
                                   xtr_shank=1,
                                   fc_normal=self.axis_h.negative(),
                                   pos_n=0,
                                   pos=self.get_pos_dwh(3, 1, 2))
        cut.append(hole2)

        shp_cut = fcfun.fuseshplist(cut)
        shp_fuse = shp_box.cut(shp_cut)
        for pt_d in (0, 2, 4, 6):
            for pt_w in (-2, 2):
                shp_fuse = fcfun.shp_filletchamfer_dirpt(
                    shp_fuse,
                    fc_axis=self.axis_h,
                    fc_pt=self.get_pos_dwh(pt_d, pt_w, 1),
                    fillet=1,
                    radius=chmf_r)
        self.shp = shp_fuse

        # Then the Part
        super().create_fco(name)
        self.fco.Placement.Base = FreeCAD.Vector(0, 0, 0)
        self.fco.Placement.Base = self.position
    def __init__(self, xtr_lat = 5., xtr_holes = 8., h_bottom = 1., d_bottom = 2., h_rail = 2., h_base = 2., dist_holes = 49., wall_thick = 4., reinf_thick = 3., arduino_w = 53., arduino_d = 105., arduino_h = 5., sides = 10., bolt = 5., chmf_r = 1., axis_h = VZ, axis_d = VX, axis_w = None, pos_h = 1, pos_d = 3, pos_w = 0, pos = V0, name = ''):
        if axis_w is None or axis_w == V0:
           axis_w = axis_h.cross(axis_d) #vector product
        
        default_name = 'bottom_coverplate'
        self.set_name(name, default_name, change = 0)
        Obj3D.__init__(self, axis_d, axis_w, axis_h, self.name)

        # save the arguments as attributes:
        frame = inspect.currentframe()
        args, _, _, values = inspect.getargvalues(frame)
        for i in args:
            if not hasattr(self,i):
                setattr(self, i, values[i])

        self.pos = FreeCAD.Vector(0, 0, 0)
        self.position = pos

        # normal axes to print without support
        self.prnt_ax = self.axis_h

        # calculation of the bolt to hold the bottom coverplate to the wood
        self.boltshank_r_tol = kcomp.D912[bolt]['shank_r_tol']
        self.bolthead_r = kcomp.D912[bolt]['head_l']
        self.bolthead_r_tol = kcomp.D912[bolt]['head_r']
        self.bolthead_l = kcomp.D912[bolt]['head_l']

        # making the big box that will contain everything and will be cut
        self.tot_d =  2 * sides + arduino_d + d_bottom
        self.tot_w = arduino_w + 2 * wall_thick - 2. + 2 * xtr_holes
        self.tot_h = h_base + arduino_h + h_bottom

        # definition of which axis is symmetrical
        self.h0_cen = 0
        self.w0_cen = 1   # symmetrical 
        self.d0_cen = 0

        # vectors from the origin to the points along axis_h
        self.h_o[0] = V0
        self.h_o[1] = self.vec_h(h_base)
        self.h_o[2] = self.vec_h(h_base + arduino_h - h_rail)
        self.h_o[3] = self.vec_h(h_base + arduino_h)
        self.h_o[4] = self.vec_h(self.tot_h)

        # position along axis_d
        self.d_o[0] = V0
        self.d_o[1] = self.vec_d(sides/2.)
        self.d_o[2] = self.vec_d(sides)
        self.d_o[3] = self.vec_d(sides + xtr_lat)
        self.d_o[4] = self.vec_d(sides + xtr_lat + xtr_holes/2.)
        self.d_o[5] = self.vec_d(sides + xtr_lat + xtr_holes)
        self.d_o[6] = self.vec_d(sides + arduino_d - 3. - xtr_holes)
        self.d_o[7] = self.vec_d(sides + arduino_d - 3. - xtr_lat)
        self.d_o[8] = self.vec_d(sides + arduino_d - 3. - xtr_holes/2)
        self.d_o[9] = self.vec_d(sides + arduino_d + d_bottom - xtr_holes)
        self.d_o[10] = self.vec_d(sides + arduino_d + d_bottom - xtr_holes/2)
        self.d_o[11] = self.vec_d(sides + arduino_d - 3.)
        self.d_o[12] = self.vec_d(sides + arduino_d)
        self.d_o[13] = self.vec_d(sides + arduino_d + d_bottom)
        self.d_o[14] = self.vec_d(sides + arduino_d + d_bottom + sides/2.)
        self.d_o[15] = self.vec_d(self.tot_d)

        # position along axis_w
        self.w_o[0] = V0
        self.w_o[1] = self.vec_w(-(arduino_w - 2. - 2 * xtr_lat)/2.)
        self.w_o[2] = self.vec_w(-(arduino_w - 2.)/2.)
        self.w_o[3] = self.vec_w(-dist_holes/2.)
        self.w_o[4] = self.vec_w(-(arduino_w + 2 * wall_thick - 2.)/2.)
        self.w_o[5] = self.vec_w(-(arduino_w + 2 * wall_thick - 2. + xtr_holes)/2.)
        self.w_o[6] = self.vec_w(-self.tot_w/2.)

        # calculates the position of the origin, and keeps it in attribute pos_o
        self.set_pos_o()

        # make the whole box
        shp_box = fcfun.shp_box_dir(box_w = self.tot_w, box_d = self.tot_d, box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 1, cd = 0, ch = 0, pos = self.pos_o)

        cut = []

        for pt_d in (0, 11):
            shp_lat1 = fcfun.shp_box_dir(box_w = xtr_holes, box_d = sides + xtr_lat, box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 0, cd = 0, ch = 0, pos = self.get_pos_dwh(pt_d, -4, 0))
            cut.append(shp_lat1)
            shp_lat2 = fcfun.shp_box_dir(box_w = - xtr_holes, box_d = sides + xtr_lat, box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 0, cd = 0, ch = 0, pos = self.get_pos_dwh(pt_d, 4, 0))
            cut.append(shp_lat2)

        shp_cut = fcfun.fuseshplist(cut)
        shp_final = shp_box.cut(shp_cut)

        for pt_d in (0, 15):
            for pt_w in (-4, 4):
                shp_final = fcfun.shp_filletchamfer_dirpt(shp_final, self.axis_h, fc_pt = self.get_pos_dwh(pt_d, pt_w, 0), fillet = 1, radius = chmf_r)

        cut = []

        for pt_d in (3, 6):
            shp_lat3 = fcfun.shp_box_dir(box_w = xtr_holes, box_d = xtr_holes, box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 0, cd = 0, ch = 0, pos = self.get_pos_dwh(pt_d, -4, 1))
            cut.append(shp_lat3)
            shp_lat4 = fcfun.shp_box_dir(box_w = - xtr_holes, box_d = xtr_holes, box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 0, cd = 0, ch = 0, pos = self.get_pos_dwh(pt_d, 4, 1))
            cut.append(shp_lat4)

        shp_cut = fcfun.fuseshplist(cut)
        shp_final = shp_final.cut(shp_cut)

        for pt_d in (3, 11):
            for pt_w in (-6, 6):
                shp_final = fcfun.shp_filletchamfer_dirpt(shp_final, self.axis_h, fc_pt = self.get_pos_dwh(pt_d, pt_w, 0), fillet = 1, radius = chmf_r)

        cut = []

        shp_lat5 = fcfun.shp_box_dir(box_w = xtr_holes, box_d = self.tot_d - 2 * (sides + xtr_lat + xtr_holes), box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 0, cd = 0, ch = 0, pos = self.get_pos_dwh(5, -4, 0))
        cut.append(shp_lat5)
        shp_lat6 = fcfun.shp_box_dir(box_w = - xtr_holes, box_d = self.tot_d - 2 * (sides + xtr_lat + xtr_holes), box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 0, cd = 0, ch = 0, pos = self.get_pos_dwh(5, 4, 0))
        cut.append(shp_lat6)

        shp_cut = fcfun.fuseshplist(cut)
        shp_final = shp_final.cut(shp_cut)

        for pt_d in (5, 6):
            for pt_w in (-6, 6):
                shp_final = fcfun.shp_filletchamfer_dirpt(shp_final, self.axis_h, fc_pt = self.get_pos_dwh(pt_d, pt_w, 0), fillet = 1, radius = chmf_r)

        cut = []

        for pt_d in (0, 13):
            shp_sides = fcfun.shp_box_dir(box_w = self.tot_w, box_d = sides, box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 1, cd = 0, ch = 0, pos = self.get_pos_dwh(pt_d, 0, 1))
            cut.append(shp_sides)

        shp_intern = fcfun.shp_box_dir(box_w = arduino_w - 2., box_d = arduino_d - 3., box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 1, cd = 0, ch = 0, pos = self.get_pos_dwh(2, 0, 1))
        cut.append(shp_intern)

        shp_int = fcfun.shp_box_dir(box_w = arduino_w - 2., box_d = arduino_d, box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 1, cd = 0, ch = 0, pos = self.get_pos_dwh(2, 0, 2))
        cut.append(shp_int)

        shp_rail = fcfun.shp_box_dir(box_w = arduino_w + 2 * TOL, box_d = arduino_d, box_h = h_rail, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 1, cd = 0, ch = 0, pos = self.get_pos_dwh(2, 0, 2))
        cut.append(shp_rail)

        trim_mat = fcfun.shp_box_dir(box_w = arduino_w - 2. - 2 * xtr_lat, box_d = arduino_d - 3. - 2 * xtr_lat, box_h = self.tot_h, fc_axis_h = axis_h, fc_axis_d = axis_d, cw = 1, cd = 0, ch = 0, pos = self.get_pos_dwh(3, 0, 0))
        cut.append(trim_mat)

        shp_cut = fcfun.fuseshplist(cut)
        shp_final = shp_final.cut(shp_cut)

        for pt_d in (2, 13):
            for pt_w in (-4, 4):
                shp_final = fcfun.shp_filletchamfer_dirpt(shp_final, self.axis_h, fc_pt = self.get_pos_dwh(pt_d, pt_w, 0), fillet = 1, radius = chmf_r)
        
        for pt_w in (-2, 2):
            shp_final = fcfun.shp_filletchamfer_dirpt(shp_final, self.axis_h, fc_pt = self.get_pos_dwh(12, pt_w, 3), fillet = 1, radius = chmf_r)
            for pt_h in (1, 3):
                shp_final = fcfun.shp_filletchamfer_dirpt(shp_final, self.axis_h, fc_pt = self.get_pos_dwh(2, pt_w, pt_h), fillet = 1, radius = chmf_r)

        cut = []

        for pt_d in (1, 14):
            for pt_w in (-3, 3):
                shp_hole = fcfun.shp_cylcenxtr(r = self.boltshank_r_tol, h = h_base, normal = self.axis_h, ch = 0, xtr_top = 1, xtr_bot = 1, pos = self.get_pos_dwh(pt_d, pt_w, 0)) 
                cut.append(shp_hole)

        for pt_d in (4, 8):
            for pt_w in (-5, 5):
                shp_hole = fcfun.shp_cylcenxtr(r = self.boltshank_r_tol, h = h_base, normal = self.axis_h, ch = 0, xtr_top = 1, xtr_bot = 1, pos = self.get_pos_dwh(pt_d, pt_w, 0)) 
                cut.append(shp_hole)

        shp_cut = fcfun.fuseshplist(cut)
        shp_final = shp_final.cut(shp_cut)
        shp_final = shp_final.removeSplitter()

        for pt_d in (5, 6):
            for pt_w in (-4, 4):
                shp_final = fcfun.shp_filletchamfer_dirpt(shp_final, self.axis_h, fc_pt = self.get_pos_dwh(pt_d, pt_w, 0), fillet = 1, radius = chmf_r)
        
        for pt_d in (3, 7):
            for pt_w in (-1, 1):
                shp_final = fcfun.shp_filletchamfer_dirpt(shp_final, self.axis_h, fc_pt = self.get_pos_dwh(pt_d, pt_w, 0), fillet = 1, radius = 4 * chmf_r)

        for pt_d in (3, 11):
            for pt_w in (-4, 4):
                shp_final = fcfun.shp_filletchamfer_dirpt(shp_final, self.axis_h, fc_pt = self.get_pos_dwh(pt_d, pt_w, 0), fillet = 1, radius = chmf_r)
        
        doc.recompute()
        self.shp = shp_final

        # Then the Part
        super().create_fco(name)
        self.fco.Placement.Base = FreeCAD.Vector(0, 0, 0)
        self.fco.Placement.Base = self.position
Example #8
0
    def __init__(self,
                 alusize_d=50.,
                 alusize_w=30.,
                 alusize_h=50.,
                 dist_alu=30.,
                 wall_thick=4.,
                 bolt_wall_d=4.,
                 opt_sides=1,
                 chmf_r=1.,
                 axis_h=VZ,
                 axis_d=VX,
                 axis_w=None,
                 pos_h=1,
                 pos_d=3,
                 pos_w=0,
                 pos=V0,
                 name=''):
        if axis_w is None or axis_w == V0:
            axis_w = axis_h.cross(axis_d)  #vector product

        default_name = 'board'
        self.set_name(name, default_name, change=0)
        Obj3D.__init__(self, axis_d, axis_w, axis_h, self.name)

        # save the arguments as attributes:
        frame = inspect.currentframe()
        args, _, _, values = inspect.getargvalues(frame)
        for i in args:
            if not hasattr(self, i):
                setattr(self, i, values[i])

        self.pos = FreeCAD.Vector(0, 0, 0)
        self.position = pos

        # normal axes to print without support
        self.prnt_ax = self.axis_h

        # calculation of the bolt to hold the base to the profile
        self.boltshank_r_tol = kcomp.D912[bolt_wall_d]['shank_r_tol']
        self.bolthead_r = kcomp.D912[bolt_wall_d]['head_l']
        self.bolthead_r_tol = kcomp.D912[bolt_wall_d]['head_r']
        self.bolthead_l = kcomp.D912[bolt_wall_d]['head_l']
        self.bolthead_l_tol = kcomp.D912[bolt_wall_d]['head_l_tol']

        # making the big box that will contain everything and will be cut
        self.tot_w = alusize_w
        self.tot_h = wall_thick + alusize_h / 2.
        if opt_sides == 0:
            self.tot_d = 2 * alusize_d + dist_alu
        else:
            self.tot_d = 2 * wall_thick + 2 * alusize_d + dist_alu

        # definition of which axis is symmetrical
        self.h0_cen = 0
        self.d0_cen = 0  # symmetrical
        self.w0_cen = 1  # symmetrical

        # vectors from the origin to the points along axis_h
        self.h_o[0] = V0
        self.h_o[1] = self.vec_h(wall_thick)
        self.h_o[2] = self.vec_h(self.tot_h)

        # position along axis_d
        if opt_sides == 0:
            self.d_o[0] = V0
            self.d_o[1] = self.vec_d(alusize_d / 4.)
            self.d_o[2] = self.vec_d(3 * alusize_d / 4.)
            self.d_o[3] = self.vec_d(alusize_d + TOL)
            self.d_o[4] = self.vec_d(alusize_d + dist_alu / 2.)
            self.d_o[5] = self.vec_d(alusize_d + dist_alu - TOL)
            self.d_o[6] = self.vec_d(alusize_d + dist_alu + alusize_d / 4.)
            self.d_o[7] = self.vec_d(alusize_d + dist_alu + 3 * alusize_d / 4.)
            self.d_o[8] = self.vec_d(self.tot_d)
        else:
            self.d_o[0] = V0
            self.d_o[1] = self.vec_d(wall_thick - TOL)
            self.d_o[2] = self.vec_d(wall_thick + alusize_d / 4.)
            self.d_o[3] = self.vec_d(wall_thick + 3 * alusize_d / 4.)
            self.d_o[4] = self.vec_d(wall_thick + alusize_d + TOL)
            self.d_o[5] = self.vec_d(wall_thick + alusize_d + dist_alu / 2.)
            self.d_o[6] = self.vec_d(wall_thick + alusize_d + dist_alu - TOL)
            self.d_o[7] = self.vec_d(wall_thick + alusize_d + dist_alu +
                                     alusize_d / 4.)
            self.d_o[8] = self.vec_d(wall_thick + alusize_d + dist_alu +
                                     3 * alusize_d / 4.)
            self.d_o[9] = self.vec_d(wall_thick + alusize_d + dist_alu +
                                     alusize_d + TOL)
            self.d_o[10] = self.vec_d(self.tot_d)

        # vectors from the origin to the points along axis_w
        self.w_o[0] = V0
        self.w_o[1] = self.vec_w(-(alusize_w / 2. - 5.))
        self.w_o[2] = self.vec_w(-self.tot_w / 2.)

        # calculates the position of the origin, and keeps it in attribute pos_o
        self.set_pos_o()

        # make the whole box
        if opt_sides == 0:
            shp_box = fcfun.shp_box_dir(box_w=self.tot_w,
                                        box_d=self.tot_d,
                                        box_h=self.tot_h,
                                        fc_axis_d=self.axis_d,
                                        fc_axis_h=self.axis_h,
                                        cw=1,
                                        cd=0,
                                        ch=0,
                                        pos=self.pos_o)
            super().add_child(shp_box, 1, 'shp_box')

            # make the shape of the piece
            cut_box1 = fcfun.shp_box_dir(box_w=self.tot_w,
                                         box_d=alusize_d + TOL,
                                         box_h=alusize_h,
                                         fc_axis_d=self.axis_d,
                                         fc_axis_h=self.axis_h,
                                         cw=1,
                                         cd=0,
                                         ch=0,
                                         pos=self.get_pos_dwh(0, 0, 1))
            super().add_child(cut_box1, 0, 'cut_box1')
            cut_box2 = fcfun.shp_box_dir(box_w=self.tot_w,
                                         box_d=alusize_d + TOL,
                                         box_h=alusize_h,
                                         fc_axis_d=self.axis_d,
                                         fc_axis_h=self.axis_h,
                                         cw=1,
                                         cd=0,
                                         ch=0,
                                         pos=self.get_pos_dwh(5, 0, 1))
            super().add_child(cut_box2, 0, 'cut_box2')

            # holes to hold the profile
            cut_hole1 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                           l_bolt=wall_thick,
                                           r_head=self.bolthead_r_tol,
                                           l_head=wall_thick / 2.,
                                           xtr_head=1,
                                           xtr_shank=1,
                                           fc_normal=self.axis_h,
                                           pos_n=0,
                                           pos=self.get_pos_dwh(1, -1, 0))
            super().add_child(cut_hole1, 0, 'cut_hole1')
            cut_hole2 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                           l_bolt=wall_thick,
                                           r_head=self.bolthead_r_tol,
                                           l_head=wall_thick / 2.,
                                           xtr_head=1,
                                           xtr_shank=1,
                                           fc_normal=self.axis_h,
                                           pos_n=0,
                                           pos=self.get_pos_dwh(1, 1, 0))
            super().add_child(cut_hole2, 0, 'cut_hole2')
            cut_hole3 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                           l_bolt=wall_thick,
                                           r_head=self.bolthead_r_tol,
                                           l_head=wall_thick / 2.,
                                           xtr_head=1,
                                           xtr_shank=1,
                                           fc_normal=self.axis_h,
                                           pos_n=0,
                                           pos=self.get_pos_dwh(2, -1, 0))
            super().add_child(cut_hole3, 0, 'cut_hole3')
            cut_hole4 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                           l_bolt=wall_thick,
                                           r_head=self.bolthead_r_tol,
                                           l_head=wall_thick / 2.,
                                           xtr_head=1,
                                           xtr_shank=1,
                                           fc_normal=self.axis_h,
                                           pos_n=0,
                                           pos=self.get_pos_dwh(2, 1, 0))
            super().add_child(cut_hole4, 0, 'cut_hole4')
            cut_hole5 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                           l_bolt=wall_thick,
                                           r_head=self.bolthead_r_tol,
                                           l_head=wall_thick / 2.,
                                           xtr_head=1,
                                           xtr_shank=1,
                                           fc_normal=self.axis_h,
                                           pos_n=0,
                                           pos=self.get_pos_dwh(6, -1, 0))
            super().add_child(cut_hole5, 0, 'cut_hole5')
            cut_hole6 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                           l_bolt=wall_thick,
                                           r_head=self.bolthead_r_tol,
                                           l_head=wall_thick / 2.,
                                           xtr_head=1,
                                           xtr_shank=1,
                                           fc_normal=self.axis_h,
                                           pos_n=0,
                                           pos=self.get_pos_dwh(6, 1, 0))
            super().add_child(cut_hole6, 0, 'cut_hole6')
            cut_hole7 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                           l_bolt=wall_thick,
                                           r_head=self.bolthead_r_tol,
                                           l_head=wall_thick / 2.,
                                           xtr_head=1,
                                           xtr_shank=1,
                                           fc_normal=self.axis_h,
                                           pos_n=0,
                                           pos=self.get_pos_dwh(7, 1, 0))
            super().add_child(cut_hole7, 0, 'cut_hole7')
            cut_hole8 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                           l_bolt=wall_thick,
                                           r_head=self.bolthead_r_tol,
                                           l_head=wall_thick / 2.,
                                           xtr_head=1,
                                           xtr_shank=1,
                                           fc_normal=self.axis_h,
                                           pos_n=0,
                                           pos=self.get_pos_dwh(7, -1, 0))
            super().add_child(cut_hole8, 0, 'cut_hole8')

            # holes to hold de screw

            hole1 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                       l_bolt=self.tot_h,
                                       r_head=self.bolthead_r_tol,
                                       l_head=13 * self.tot_h / 20.,
                                       xtr_head=1,
                                       xtr_shank=1,
                                       fc_normal=self.axis_h.negative(),
                                       pos_n=0,
                                       pos=self.get_pos_dwh(4, -1, 2))
            super().add_child(hole1, 0, 'hole1')
            hole2 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                       l_bolt=self.tot_h,
                                       r_head=self.bolthead_r_tol,
                                       l_head=13 * self.tot_h / 20.,
                                       xtr_head=1,
                                       xtr_shank=1,
                                       fc_normal=self.axis_h.negative(),
                                       pos_n=0,
                                       pos=self.get_pos_dwh(4, 1, 2))
            super().add_child(hole2, 0, 'hole2')

        else:
            shp_box = fcfun.shp_box_dir(box_w=self.tot_w,
                                        box_d=self.tot_d,
                                        box_h=self.tot_h,
                                        fc_axis_d=self.axis_d,
                                        fc_axis_h=self.axis_h,
                                        cw=1,
                                        cd=0,
                                        ch=0,
                                        pos=self.pos_o)
            super().add_child(shp_box, 1, 'shp_box')

            # make the shape of the piece
            cut_box1 = fcfun.shp_box_dir(box_w=self.tot_w,
                                         box_d=alusize_d + 2 * TOL,
                                         box_h=alusize_h,
                                         fc_axis_d=self.axis_d,
                                         fc_axis_h=self.axis_h,
                                         cw=1,
                                         cd=0,
                                         ch=0,
                                         pos=self.get_pos_dwh(1, 0, 1))
            super().add_child(cut_box1, 0, 'cut_box1')
            cut_box2 = fcfun.shp_box_dir(box_w=self.tot_w,
                                         box_d=alusize_d + 2 * TOL,
                                         box_h=alusize_h,
                                         fc_axis_d=self.axis_d,
                                         fc_axis_h=self.axis_h,
                                         cw=1,
                                         cd=0,
                                         ch=0,
                                         pos=self.get_pos_dwh(6, 0, 1))
            super().add_child(cut_box2, 0, 'cut_box2')

            # holes to hold the profile
            cut_hole1 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                           l_bolt=wall_thick,
                                           r_head=self.bolthead_r_tol,
                                           l_head=wall_thick / 2.,
                                           xtr_head=1,
                                           xtr_shank=1,
                                           fc_normal=self.axis_h,
                                           pos_n=0,
                                           pos=self.get_pos_dwh(2, -1, 0))
            super().add_child(cut_hole1, 0, 'cut_hole1')
            cut_hole2 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                           l_bolt=wall_thick,
                                           r_head=self.bolthead_r_tol,
                                           l_head=wall_thick / 2.,
                                           xtr_head=1,
                                           xtr_shank=1,
                                           fc_normal=self.axis_h,
                                           pos_n=0,
                                           pos=self.get_pos_dwh(2, 1, 0))
            super().add_child(cut_hole2, 0, 'cut_hole2')
            cut_hole3 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                           l_bolt=wall_thick,
                                           r_head=self.bolthead_r_tol,
                                           l_head=wall_thick / 2.,
                                           xtr_head=1,
                                           xtr_shank=1,
                                           fc_normal=self.axis_h,
                                           pos_n=0,
                                           pos=self.get_pos_dwh(3, -1, 0))
            super().add_child(cut_hole3, 0, 'cut_hole3')
            cut_hole4 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                           l_bolt=wall_thick,
                                           r_head=self.bolthead_r_tol,
                                           l_head=wall_thick / 2.,
                                           xtr_head=1,
                                           xtr_shank=1,
                                           fc_normal=self.axis_h,
                                           pos_n=0,
                                           pos=self.get_pos_dwh(3, 1, 0))
            super().add_child(cut_hole4, 0, 'cut_hole4')
            cut_hole5 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                           l_bolt=wall_thick,
                                           r_head=self.bolthead_r_tol,
                                           l_head=wall_thick / 2.,
                                           xtr_head=1,
                                           xtr_shank=1,
                                           fc_normal=self.axis_h,
                                           pos_n=0,
                                           pos=self.get_pos_dwh(7, -1, 0))
            super().add_child(cut_hole5, 0, 'cut_hole5')
            cut_hole6 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                           l_bolt=wall_thick,
                                           r_head=self.bolthead_r_tol,
                                           l_head=wall_thick / 2.,
                                           xtr_head=1,
                                           xtr_shank=1,
                                           fc_normal=self.axis_h,
                                           pos_n=0,
                                           pos=self.get_pos_dwh(7, 1, 0))
            super().add_child(cut_hole6, 0, 'cut_hole6')
            cut_hole7 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                           l_bolt=wall_thick,
                                           r_head=self.bolthead_r_tol,
                                           l_head=wall_thick / 2.,
                                           xtr_head=1,
                                           xtr_shank=1,
                                           fc_normal=self.axis_h,
                                           pos_n=0,
                                           pos=self.get_pos_dwh(8, 1, 0))
            super().add_child(cut_hole7, 0, 'cut_hole7')
            cut_hole8 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                           l_bolt=wall_thick,
                                           r_head=self.bolthead_r_tol,
                                           l_head=wall_thick / 2.,
                                           xtr_head=1,
                                           xtr_shank=1,
                                           fc_normal=self.axis_h,
                                           pos_n=0,
                                           pos=self.get_pos_dwh(8, -1, 0))
            super().add_child(cut_hole8, 0, 'cut_hole8')

            # holes to hold de screw
            hole1 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                       l_bolt=self.tot_h,
                                       r_head=self.bolthead_r_tol,
                                       l_head=13 * self.tot_h / 20.,
                                       xtr_head=1,
                                       xtr_shank=1,
                                       fc_normal=self.axis_h.negative(),
                                       pos_n=0,
                                       pos=self.get_pos_dwh(5, -1, 2))
            super().add_child(hole1, 0, 'hole1')
            hole2 = fcfun.shp_bolt_dir(r_shank=self.boltshank_r_tol,
                                       l_bolt=self.tot_h,
                                       r_head=self.bolthead_r_tol,
                                       l_head=13 * self.tot_h / 20.,
                                       xtr_head=1,
                                       xtr_shank=1,
                                       fc_normal=self.axis_h.negative(),
                                       pos_n=0,
                                       pos=self.get_pos_dwh(5, 1, 2))
            super().add_child(hole2, 0, 'hole2')

        super().make_parent(name)
        if opt_sides == 0:
            for pt_d in (0, 3, 5, 8):
                for pt_w in (-2, 2):
                    self.shp = fcfun.shp_filletchamfer_dirpt(
                        self.shp,
                        fc_axis=self.axis_h,
                        fc_pt=self.get_pos_dwh(pt_d, pt_w, 1),
                        fillet=1,
                        radius=chmf_r)
        else:
            for pt_w in (-2, 2):
                for pt_d in (0, 1, 4, 6, 9, 10):
                    self.shp = fcfun.shp_filletchamfer_dirpt(
                        self.shp,
                        fc_axis=self.axis_h,
                        fc_pt=self.get_pos_dwh(pt_d, pt_w, 2),
                        fillet=1,
                        radius=chmf_r)

        # Then the Part
        super().create_fco(name)
        self.fco.Placement.Base = FreeCAD.Vector(0, 0, 0)
        self.fco.Placement.Base = self.position
    def __init__(self, nema_size = 17, wall_thick = 4., motor_thick = 4., reinf_thick = 4., motor_min_h = 10., motor_max_h = 20., motor_xtr_space = 2., xtr_diam_cir = 8., diam_cir = 28.,bolt_wall_d = 3., bolt_wall_d_rail = 4., bolt_wall_sep = 30., rail = 1, chmf_r = 1., angle = 45., axis_h = VZ, axis_d = VX, axis_w = None, pos_h = 1, pos_d = 3, pos_w = 0, pos = V0, name = ''):
        if axis_w is None or axis_w == V0:
           axis_w = axis_h.cross(axis_d) #vector product

        default_name = 'NemaMotorHolder'
        self.set_name(name, default_name, change = 0)
        Obj3D.__init__(self, axis_d, axis_w, axis_h, self.name)

        shp_clss.Obj3D.__init__(self, axis_d, axis_w, axis_h)
        
        # save the arguments as attributes
        frame = inspect.currentframe()
        args, _, _, values = inspect.getargvalues(frame)
        for i in args:
            if not hasattr(self,i):
                setattr(self, i, values[i])
        
        self.pos = FreeCAD.Vector(0, 0, 0)
        self.position = pos
        
        # normal axes to print without support
        self.prnt_ax = self.axis_h
        
        self.motor_w = kcomp.NEMA_W[nema_size]
        self.motor_bolt_sep = kcomp.NEMA_BOLT_SEP[nema_size]
        self.motor_bolt_d = kcomp.NEMA_BOLT_D[nema_size]

        # calculation of the bolt wall d
        self.boltwallshank_r_tol = kcomp.D912[bolt_wall_d]['shank_r_tol']
        self.boltwallhead_l = kcomp.D912[bolt_wall_d]['head_l']
        self.boltwallhead_r_tol = kcomp.D912[bolt_wall_d]['head_r_tol']
        self.boltwallhead_r = kcomp.D912[bolt_wall_d]['head_r']
        self.washer_thick = kcomp.WASH_D125_T[bolt_wall_d]

        # calculation of the bolt wall d rail
        self.boltwallshank_r_tol_rail = kcomp.D912[bolt_wall_d_rail]['shank_r_tol']
        self.boltwallhead_l_rail = kcomp.D912[bolt_wall_d_rail]['head_l']
        self.boltwallhead_r_rail = kcomp.D912[bolt_wall_d_rail]['head_r']
        self.washer_thick_rail = kcomp.WASH_D125_T[bolt_wall_d_rail]

        # calculation of the bolt wall separation
        self.max_bolt_wall_sep = self.motor_w - 2 * self.boltwallhead_r
        if bolt_wall_sep == 0:
            self.bolt_wall_sep = self.max_bolt_wall_sep
        elif bolt_wall_sep > self.max_bolt_wall_sep: 
            logger.debug('bolt separation too large:' + str(bolt_wall_sep))
            self.bolt_wall_sep = self.max_bolt_wall_sep
            logger.debug('taking largest value:' + str(self.bolt_wall_sep))
        elif bolt_wall_sep < 4 * self.boltwallhead_r:
            logger.debug('bolt separation too short:' + str(bolt_wall_sep))
            self.bolt_wall_sep = self.self.max_bolt_wall_sep
            logger.debug('taking smallest value:' + str(self.bolt_wall_sep))
        
        # distance from the motor to the inner wall (in axis_d)
        self.motor_inwall_space = motor_xtr_space + self.boltwallhead_l + self.washer_thick

        # making the big box that will contain everything and will be cut
        self.tot_h = motor_thick + motor_max_h + 2 * bolt_wall_d
        self.tot_w = 2 * reinf_thick + self.motor_w + 2 * motor_xtr_space
        self.tot_d = wall_thick + self.motor_w + self.motor_inwall_space

        # distance from the motor axis to the wall (in axis_d)
        self.motax2wall = wall_thick + self.motor_inwall_space + self.motor_w/2.

        #
        self.d_circle = math.sin(math.radians(angle))*(diam_cir/2.)
        self.w_circle = math.cos(math.radians(angle))*(diam_cir/2.)

        # definition of which axis is symmetrical
        self.h0_cen = 0
        self.w0_cen = 1   # symmetrical 
        self.d0_cen = 0

        # vectors from the origin to the points along axis_h
        self.h_o[0] = V0
        self.h_o[1] = self.vec_h(motor_thick)
        self.h_o[2] = self.vec_h(motor_thick + motor_min_h)
        self.h_o[3] = self.vec_h(motor_thick + motor_max_h)
        self.h_o[4] = self.vec_h(self.tot_h)

        # position along axis_d
        self.d_o[0] = V0
        self.d_o[1] = self.vec_d(wall_thick)
        self.d_o[2] = self.vec_d(self.motax2wall - self.d_circle)
        self.d_o[3] = self.vec_d(self.motax2wall)
        self.d_o[4] = self.vec_d(self.motax2wall + self.d_circle)
        self.d_o[5] = self.vec_d(self.tot_d)

        # vectors from the origin to the points along axis_w
        self.w_o[0] = V0
        self.w_o[1] = self.vec_w(-self.bolt_wall_sep/2.)
        self.w_o[2] = self.vec_w(self.w_circle + TOL)
        self.w_o[3] = self.vec_w(-self.tot_w/2.)

        # calculates the position of the origin, and keeps it in attribute pos_o
        self.set_pos_o()

        # make the whole box, extra height and depth to cut all the way back and down
        shp_box = fcfun.shp_box_dir(box_w = self.tot_w, box_d = self.tot_d, box_h = self.tot_h, fc_axis_h = self.axis_h, fc_axis_d = self.axis_d, cw = 1, cd = 0, ch = 0, pos = self.pos_o)

        # little chamfer at the corners, if fillet there are some problems
        shp_box = fcfun.shp_filletchamfer_dir(shp_box, self.axis_h, fillet = 0, radius = chmf_r)
        shp_box = shp_box.removeSplitter()

        # chamfer of the box to make a 'triangular' reinforcement
        chmf_reinf_r = min(self.tot_d - wall_thick, self.tot_h - motor_thick)
        shp_box = fcfun.shp_filletchamfer_dirpt(shp_box, self.axis_w, fc_pt = self.get_pos_dwh(5, 0, 4), fillet = 0, radius = chmf_reinf_r)
        shp_box = shp_box.removeSplitter()

        # holes
        holes = []

            # the space for the motor
        shp_motor = fcfun.shp_box_dir(box_w = self.motor_w + 2 * motor_xtr_space, box_d = self.tot_d + chmf_r, box_h = self.tot_h, fc_axis_h = self.axis_h, fc_axis_d = self.axis_d, cw = 1, cd = 0, ch = 0, pos = self.get_pos_dwh(1, 0, 1))
        shp_motor = fcfun.shp_filletchamfer_dir(shp_motor, self.axis_h, fillet = 0, radius = chmf_r)
        holes.append(shp_motor)

            # central circle of the motor 
        shp_hole = fcfun.shp_cylcenxtr(r = (self.motor_bolt_sep - self.motor_bolt_d - xtr_diam_cir + TOL)/2., h = motor_thick, normal = self.axis_h, ch = 0, xtr_top = 1, xtr_bot = 1, pos = self.get_pos_d(3))
        holes.append(shp_hole)

            # motor bolt holes
        for pt_d in (2, 4):
            for pt_w in (-2, 2):
                shp_hole = fcfun.shp_bolt_dir(r_shank = self.boltwallshank_r_tol, l_bolt = motor_thick, r_head = self.boltwallhead_r + TOL/3., l_head = 2, xtr_head = 1, xtr_shank = 1, fc_normal = self.axis_h, pos_n = 0, pos = self.get_pos_dwh(pt_d, pt_w, 0))
                #shp_hole = fcfun.shp_cylcenxtr(r = self.boltwallshank_r_tol, h = motor_thick, normal = self.axis_h, ch = 0, xtr_top = 1, xtr_bot = 1, pos = self.get_pos_dwh(pt_d, pt_w, 0))
                holes.append(shp_hole)

            # rail holes
        for pt_w in (-1, 1):
            if rail == 1:
                shp_hole = fcfun.shp_box_dir_xtr(box_w = 2 * self.boltwallshank_r_tol_rail, box_d = wall_thick, box_h = motor_max_h - motor_min_h, fc_axis_h = self.axis_h, fc_axis_d = self.axis_d, cw = 1, cd = 0, ch = 0, xtr_d = 1, xtr_nd = 1, pos = self.get_pos_dwh(0, pt_w, 2))
                holes.append(shp_hole)
            
            # hole for the ending of the rails (4 semicircles)
            for pt_h in (2, 3):
                shp_hole = fcfun.shp_cylcenxtr(r = self.boltwallshank_r_tol_rail, h = wall_thick, normal = self.axis_d, ch = 0, xtr_top = 1, xtr_bot =1, pos = self.get_pos_dwh(0, pt_w, pt_h))
                holes.append(shp_hole)
            
        shp_holes = fcfun.fuseshplist(holes)
        shp_motorholder = shp_box.cut(shp_holes)
        shp_bracket = shp_motorholder.removeSplitter()
        self.shp = shp_bracket

        # Then the Part
        super().create_fco(name)
        self.fco.Placement.Base = FreeCAD.Vector(0, 0, 0)
        self.fco.Placement.Base = self.position
    def __init__(self,
                 n_bolt=1,
                 bra_w_1=22.,
                 bra_w_2=17.,
                 bra_d_1=21.,
                 bra_d_2=51.,
                 bra_h_1=21.,
                 bra_h_2=51.,
                 bolt=5.,
                 rail=1,
                 d_rail=10.,
                 reinf_thick_1=3.,
                 reinf_thick_2=5.,
                 wall_thick=6.,
                 chmf_r=1.,
                 dist_bet_nuts=17.,
                 dist_hole=5.,
                 axis_h=VZ,
                 axis_d=VX,
                 axis_w=None,
                 pos_h=1,
                 pos_d=3,
                 pos_w=0,
                 pos=V0,
                 name=''):
        if axis_w is None or axis_w == V0:
            axis_w = axis_h.cross(axis_d)  #vector product

        default_name = 'alu_bracket'
        self.set_name(name, default_name, change=0)
        Obj3D.__init__(self, axis_d, axis_w, axis_h, self.name)

        # save the arguments as attributes:
        frame = inspect.currentframe()
        args, _, _, values = inspect.getargvalues(frame)
        for i in args:
            if not hasattr(self, i):
                setattr(self, i, values[i])

        self.pos = FreeCAD.Vector(0, 0, 0)
        self.position = pos

        # normal axes to print without support
        self.prnt_ax = self.axis_h

        # calculation of the bolt to hold the bottom coverplate to the wood
        self.boltshank_r_tol = kcomp.D912[bolt]['shank_r_tol']
        self.bolthead_r = kcomp.D912[bolt]['head_l']
        self.bolthead_r_tol = kcomp.D912[bolt]['head_r']
        self.bolthead_l = kcomp.D912[bolt]['head_l']

        # making the big box that will contain everything and will be cut
        if n_bolt == 1:
            self.tot_d = bra_d_1 + wall_thick
            self.tot_w = bra_w_1 + 2 * reinf_thick_1
            self.tot_h = bra_h_1 + wall_thick
        else:
            self.tot_d = bra_d_2 + wall_thick
            self.tot_w = bra_w_2 + 2 * reinf_thick_2
            self.tot_h = bra_h_2 + wall_thick

        # definition of which axis is symmetrical
        if n_bolt == 1:
            self.h0_cen = 0
            self.w0_cen = 1  # symmetrical
            self.d0_cen = 0
        else:
            self.h0_cen = 0
            self.w0_cen = 0
            self.d0_cen = 0

        if n_bolt == 1:
            # vectors from the origin to the points along axis_h
            self.h_o[0] = V0
            self.h_o[1] = self.vec_h(wall_thick)
            self.h_o[2] = self.vec_h(wall_thick + dist_hole)
            self.h_o[3] = self.vec_h(wall_thick + bra_h_1 / 2.)
            self.h_o[4] = self.vec_h(wall_thick + dist_hole + d_rail)
            self.h_o[5] = self.vec_h(self.tot_h)
            # position along axis_d
            self.d_o[0] = V0
            self.d_o[1] = self.vec_d(dist_hole)
            self.d_o[2] = self.vec_d(dist_hole + d_rail)
            self.d_o[3] = self.vec_d(bra_d_1 / 2.)
            self.d_o[4] = self.vec_d(bra_d_1)
            self.d_o[5] = self.vec_d(self.tot_d)
            # position along axis_w
            self.w_o[0] = V0
            self.w_o[1] = self.vec_w(-self.boltshank_r_tol)
            self.w_o[2] = self.vec_w(-bra_w_1 / 2.)
            self.w_o[3] = self.vec_w(-self.tot_w / 2.)
        else:
            # vectors from the origin to the points along axis_h
            self.h_o[0] = V0
            self.h_o[1] = self.vec_h(wall_thick)
            self.h_o[2] = self.vec_h(wall_thick + dist_hole)
            self.h_o[3] = self.vec_h(wall_thick + dist_hole + d_rail / 2.)
            self.h_o[4] = self.vec_h(wall_thick + dist_hole + d_rail)
            self.h_o[5] = self.vec_h(wall_thick + dist_hole + d_rail +
                                     dist_bet_nuts)
            self.h_o[6] = self.vec_h(wall_thick + dist_hole + d_rail +
                                     dist_bet_nuts + d_rail / 2.)
            self.h_o[7] = self.vec_h(wall_thick + dist_hole + d_rail +
                                     dist_bet_nuts + d_rail)
            self.h_o[8] = self.vec_h(self.tot_h)
            # position along axis_d
            self.d_o[0] = V0
            self.d_o[1] = self.vec_d(dist_hole)
            self.d_o[2] = self.vec_d(dist_hole + d_rail / 2.)
            self.d_o[3] = self.vec_d(dist_hole + d_rail)
            self.d_o[4] = self.vec_d(dist_hole + d_rail + dist_bet_nuts)
            self.d_o[5] = self.vec_d(dist_hole + d_rail + dist_bet_nuts +
                                     d_rail / 2.)
            self.d_o[6] = self.vec_d(dist_hole + d_rail + dist_bet_nuts +
                                     d_rail)
            self.d_o[7] = self.vec_d(bra_d_2)
            self.d_o[8] = self.vec_d(self.tot_d)
            # position along axis_w
            self.w_o[0] = V0
            self.w_o[1] = self.vec_w(-reinf_thick_2)
            self.w_o[2] = self.vec_w(-(reinf_thick_2 + dist_hole))
            self.w_o[3] = self.vec_w(-(reinf_thick_2 + dist_hole +
                                       self.boltshank_r_tol))
            self.w_o[4] = self.vec_w(-(reinf_thick_2 + dist_hole +
                                       2 * self.boltshank_r_tol))
            self.w_o[5] = self.vec_w(-(reinf_thick_2 + bra_w_2))
            self.w_o[6] = self.vec_w(-self.tot_w)

        # calculates the position of the origin, and keeps it in attribute pos_o
        self.set_pos_o()

        # make the whole box
        if n_bolt == 1:
            shp_box = fcfun.shp_box_dir(box_w=self.tot_w,
                                        box_d=self.tot_d,
                                        box_h=self.tot_h,
                                        fc_axis_h=axis_h,
                                        fc_axis_d=axis_d,
                                        cw=1,
                                        cd=0,
                                        ch=0,
                                        pos=self.pos_o)

            cut = []

            shp_box_int = fcfun.shp_box_dir(box_w=bra_w_1,
                                            box_d=bra_d_1,
                                            box_h=bra_h_1,
                                            fc_axis_h=axis_h,
                                            fc_axis_d=axis_d,
                                            cw=1,
                                            cd=0,
                                            ch=0,
                                            pos=self.get_pos_dwh(0, 0, 1))
            cut.append(shp_box_int)

            if rail == 0:
                shp_hole1 = fcfun.shp_cylcenxtr(r=self.boltshank_r_tol,
                                                h=wall_thick,
                                                normal=self.axis_h,
                                                ch=0,
                                                xtr_top=1,
                                                xtr_bot=1,
                                                pos=self.get_pos_dwh(3, 0, 0))
                cut.append(shp_hole1)
                shp_hole2 = fcfun.shp_cylcenxtr(r=self.boltshank_r_tol,
                                                h=wall_thick,
                                                normal=self.axis_d,
                                                ch=0,
                                                xtr_top=1,
                                                xtr_bot=1,
                                                pos=self.get_pos_dwh(4, 0, 3))
                cut.append(shp_hole2)
            else:
                shp_hole1 = fcfun.shp_box_dir_xtr(
                    box_w=2 * self.boltshank_r_tol,
                    box_d=d_rail,
                    box_h=wall_thick,
                    fc_axis_h=self.axis_h,
                    fc_axis_d=self.axis_d,
                    cw=1,
                    cd=0,
                    ch=0,
                    xtr_d=0,
                    xtr_nd=0,
                    pos=self.get_pos_dwh(1, 0, 0))
                cut.append(shp_hole1)
                shp_hole2 = fcfun.shp_box_dir_xtr(
                    box_w=2 * self.boltshank_r_tol,
                    box_d=wall_thick,
                    box_h=d_rail,
                    fc_axis_h=self.axis_h,
                    fc_axis_d=self.axis_d,
                    cw=1,
                    cd=0,
                    ch=0,
                    xtr_d=0,
                    xtr_nd=0,
                    pos=self.get_pos_dwh(4, 0, 2))
                cut.append(shp_hole2)

            shp_cut = fcfun.fuseshplist(cut)
            shp_final = shp_box.cut(shp_cut)

            chmf_reinf_r = min(bra_d_1, bra_h_1)
            for pt_w in (-3, 3):
                shp_final = fcfun.shp_filletchamfer_dirpt(
                    shp_final,
                    self.axis_w,
                    fc_pt=self.get_pos_dwh(0, pt_w, 5),
                    fillet=0,
                    radius=chmf_reinf_r)

            shp_final = fcfun.shp_filletchamfer_dirpt(shp_final,
                                                      self.axis_w,
                                                      fc_pt=self.get_pos_dwh(
                                                          0, 0, 0),
                                                      fillet=0,
                                                      radius=chmf_r)
            shp_final = fcfun.shp_filletchamfer_dirpt(shp_final,
                                                      self.axis_w,
                                                      fc_pt=self.get_pos_dwh(
                                                          4, 0, 1),
                                                      fillet=1,
                                                      radius=chmf_r)

            for pt_h in (0, 5):
                shp_final = fcfun.shp_filletchamfer_dirpt(
                    shp_final,
                    self.axis_w,
                    fc_pt=self.get_pos_dwh(5, 0, pt_h),
                    fillet=0,
                    radius=chmf_r)

            if rail == 1:
                for pt_w in (-1, 1):
                    for pt_d in (1, 2):
                        shp_final = fcfun.shp_filletchamfer_dirpt(
                            shp_final,
                            self.axis_h,
                            fc_pt=self.get_pos_dwh(pt_d, pt_w, 0),
                            fillet=1,
                            radius=chmf_r)
                    for pt_h in (2, 4):
                        shp_final = fcfun.shp_filletchamfer_dirpt(
                            shp_final,
                            self.axis_d,
                            fc_pt=self.get_pos_dwh(4, pt_w, pt_h),
                            fillet=1,
                            radius=chmf_r)

        else:
            shp_box = fcfun.shp_box_dir(box_w=self.tot_w,
                                        box_d=self.tot_d,
                                        box_h=self.tot_h,
                                        fc_axis_h=axis_h,
                                        fc_axis_d=axis_d,
                                        cw=0,
                                        cd=0,
                                        ch=0,
                                        pos=self.pos_o)

            cut = []

            shp_box_int = fcfun.shp_box_dir(box_w=bra_w_2 + reinf_thick_2,
                                            box_d=bra_d_2,
                                            box_h=bra_h_2,
                                            fc_axis_h=axis_h,
                                            fc_axis_d=axis_d,
                                            cw=0,
                                            cd=0,
                                            ch=0,
                                            pos=self.get_pos_dwh(0, 1, 1))
            cut.append(shp_box_int)

            if rail == 0:
                for pt_d in (2, 5):
                    shp_hole1 = fcfun.shp_cylcenxtr(r=self.boltshank_r_tol,
                                                    h=wall_thick,
                                                    normal=self.axis_h,
                                                    ch=0,
                                                    xtr_top=1,
                                                    xtr_bot=1,
                                                    pos=self.get_pos_dwh(
                                                        pt_d, 3, 0))
                    cut.append(shp_hole1)
                for pt_h in (3, 6):
                    shp_hole2 = fcfun.shp_cylcenxtr(r=self.boltshank_r_tol,
                                                    h=wall_thick,
                                                    normal=self.axis_d,
                                                    ch=0,
                                                    xtr_top=1,
                                                    xtr_bot=1,
                                                    pos=self.get_pos_dwh(
                                                        7, 3, pt_h))
                    cut.append(shp_hole2)
            else:
                for pt_d in (1, 4):
                    shp_hole1 = fcfun.shp_box_dir_xtr(
                        box_w=2 * self.boltshank_r_tol,
                        box_d=d_rail,
                        box_h=wall_thick,
                        fc_axis_h=self.axis_h,
                        fc_axis_d=self.axis_d,
                        cw=1,
                        cd=0,
                        ch=0,
                        xtr_d=0,
                        xtr_nd=0,
                        pos=self.get_pos_dwh(pt_d, 3, 0))
                    cut.append(shp_hole1)
                for pt_h in (2, 5):
                    shp_hole2 = fcfun.shp_box_dir_xtr(
                        box_w=2 * self.boltshank_r_tol,
                        box_d=wall_thick,
                        box_h=d_rail,
                        fc_axis_h=self.axis_h,
                        fc_axis_d=self.axis_d,
                        cw=1,
                        cd=0,
                        ch=0,
                        xtr_d=0,
                        xtr_nd=0,
                        pos=self.get_pos_dwh(7, 3, pt_h))
                    cut.append(shp_hole2)

            shp_cut = fcfun.fuseshplist(cut)
            shp_final = shp_box.cut(shp_cut)

            chmf_reinf_r = min(bra_d_2, bra_h_2)
            shp_final = fcfun.shp_filletchamfer_dirpt(shp_final,
                                                      self.axis_w,
                                                      fc_pt=self.get_pos_dwh(
                                                          0, 1, 8),
                                                      fillet=0,
                                                      radius=chmf_reinf_r)

            shp_final = fcfun.shp_filletchamfer_dirpt(shp_final,
                                                      self.axis_w,
                                                      fc_pt=self.get_pos_dwh(
                                                          0, 0, 0),
                                                      fillet=0,
                                                      radius=chmf_r)
            shp_final = fcfun.shp_filletchamfer_dirpt(shp_final,
                                                      self.axis_w,
                                                      fc_pt=self.get_pos_dwh(
                                                          7, 0, 1),
                                                      fillet=1,
                                                      radius=chmf_r)

            for pt_h in (0, 8):
                shp_final = fcfun.shp_filletchamfer_dirpt(
                    shp_final,
                    self.axis_w,
                    fc_pt=self.get_pos_dwh(8, 0, pt_h),
                    fillet=0,
                    radius=chmf_r)

            if rail == 1:
                for pt_w in (2, 4):
                    for pt_d in (1, 3, 4, 6):
                        shp_final = fcfun.shp_filletchamfer_dirpt(
                            shp_final,
                            self.axis_h,
                            fc_pt=self.get_pos_dwh(pt_d, pt_w, 0),
                            fillet=1,
                            radius=chmf_r)
                    for pt_h in (2, 4, 5, 7):
                        shp_final = fcfun.shp_filletchamfer_dirpt(
                            shp_final,
                            self.axis_d,
                            fc_pt=self.get_pos_dwh(7, pt_w, pt_h),
                            fillet=1,
                            radius=chmf_r)

        shp_final = shp_final.removeSplitter()

        self.shp = shp_final

        # Then the Part
        super().create_fco(name)
        self.fco.Placement.Base = FreeCAD.Vector(0, 0, 0)
        self.fco.Placement.Base = self.position