def __transform_base_polygon__(self, path, polyline3D_contur):
        """
        Transforms the base polygon3D

        Args:
            path:               only the first segment is needed
            polyline3D_contur:  will be transformed to placed perpendicular on the first segment of the path

        Returns:
            transformed polyline3D_contur

        """

        pnt1 = path.GetPoint(0)
        pnt2 = path.GetPoint(1)

        diff_x = pnt2.X - pnt1.X
        diff_y = pnt2.Y - pnt1.Y
        diff_z = pnt2.Z - pnt1.Z

        tmp_plane = AllplanGeo.Plane3D(
            AllplanGeo.Point3D(0, 0, 0),
            AllplanGeo.Vector3D(diff_x, diff_y, diff_z))

        matrix = AllplanGeo.Matrix3D()
        matrix = tmp_plane.GetTransformationMatrix()
        result = AllplanGeo.Transform(polyline3D_contur, matrix)
        matrix2 = AllplanGeo.Matrix3D()
        matrix2.SetTranslation(AllplanGeo.Vector3D(pnt1.X, pnt1.Y, pnt1.Z))
        result = AllplanGeo.Transform(result, matrix2)
        return result
Beispiel #2
0
    def add_windows(self, build_ele, com_prop_stroke, wall_length, wall_width,
                    wall_thickness):
        p_x = build_ele.win_x.value
        p_y = 0
        p_z = build_ele.win_z.value

        void_length = build_ele.win_length.value
        void_width = build_ele.win_width.value
        void_thickness = wall_thickness

        void = AllplanGeo.Polyhedron3D.CreateCuboid(void_length,
                                                    void_thickness, void_width)
        trans_to_ref_point_2 = AllplanGeo.Matrix3D()
        trans_to_ref_point_2.Translate(AllplanGeo.Vector3D(p_x, p_y, p_z))
        void = AllplanGeo.Transform(void, trans_to_ref_point_2)

        self.model_ele_list.append(
            AllplanBasisElements.ModelElement3D(com_prop_stroke, void))

        #--------------------------------------------------------------------------------------#
        #----------------------------------Void Handle-----------------------------------------#
        #--------------------------------------------------------------------------------------#
        origin = AllplanGeo.Point3D(0, 0, 0)

        originwin = AllplanGeo.Point3D(p_x, 0, p_z)
        win_plength = AllplanGeo.Point3D(p_x + void_length, 0, p_z)
        win_pwidth = AllplanGeo.Point3D(p_x, 0, p_z + void_width)
        win_pointx = AllplanGeo.Point3D(p_x + void_length / 2, 0, p_z)
        win_pointz = AllplanGeo.Point3D(p_x, 0, p_z + void_width / 2)

        handle_winlength = HandleProperties(
            "windowsMoveLength", win_plength, originwin,
            [("win_length", HandleDirection.x_dir)], HandleDirection.x_dir,
            True)
        self.handle_list.append(handle_winlength)

        handle_winwidth = HandleProperties(
            "windowsMoveWidth", win_pwidth, originwin,
            [("win_width", HandleDirection.z_dir)], HandleDirection.z_dir,
            True)
        self.handle_list.append(handle_winwidth)

        handle_winx = HandleProperties("windowsMoveX", win_pointx, originwin,
                                       [("win_x", HandleDirection.x_dir)],
                                       HandleDirection.x_dir, False)
        self.handle_list.append(handle_winx)

        handle_winz = HandleProperties("windowsMoveZ", win_pointz, origin,
                                       [("win_z", HandleDirection.z_dir)],
                                       HandleDirection.z_dir, False)
        self.handle_list.append(handle_winz)

        return void
    def create_element(self):
        """
        Create the element

        Args:
            point_list:  Point list
        """
        dmmy_pnt = AllplanGeo.Point3D()
        self.b_use_input_pnt = False
        self.__create_model_element__(dmmy_pnt)
        AllplanBaseElements.CreateElements(
            self.coord_input.GetInputViewDocument(), AllplanGeo.Matrix3D(),
            self.model_ele_list, [], None)

        self.polyline_lenght = 0.0  #reset value
Beispiel #4
0
    def add_door(self, build_ele, com_prop_stroke, wall_length, wall_width,
                 wall_thickness):
        d_x = build_ele.door_x.value
        d_y = 0
        d_z = 0

        door_length = build_ele.door_length.value
        door_width = build_ele.door_width.value
        door_thickness = wall_thickness

        door = AllplanGeo.Polyhedron3D.CreateCuboid(door_length,
                                                    door_thickness, door_width)
        trans_to_ref_point_3 = AllplanGeo.Matrix3D()
        trans_to_ref_point_3.Translate(AllplanGeo.Vector3D(d_x, d_y, d_z))
        door = AllplanGeo.Transform(door, trans_to_ref_point_3)

        self.model_ele_list.append(
            AllplanBasisElements.ModelElement3D(com_prop_stroke, door))

        #--------------------------------------------------------------------------------------#
        #----------------------------------Door Handle-----------------------------------------#
        #--------------------------------------------------------------------------------------#

        origin = AllplanGeo.Point3D(0, 0, 0)
        door_plength = AllplanGeo.Point3D(d_x + door_length, 0, 0)
        door_pwidth = AllplanGeo.Point3D(d_x, 0, door_width)
        door_pointx = AllplanGeo.Point3D(d_x, 0, 0)

        handle_doorlength = HandleProperties(
            "DoorMoveLength", door_plength, door_pointx,
            [("door_length", HandleDirection.x_dir)], HandleDirection.x_dir,
            True)
        self.handle_list.append(handle_doorlength)

        handle_doorwidth = HandleProperties(
            "DoorMoveWidth", door_pwidth, door_pointx,
            [("door_width", HandleDirection.z_dir)], HandleDirection.z_dir,
            True)
        self.handle_list.append(handle_doorwidth)
        handle_doorx = HandleProperties("doorMoveX", door_pointx, origin,
                                        [("door_x", HandleDirection.x_dir)],
                                        HandleDirection.x_dir, False)
        self.handle_list.append(handle_doorx)

        return door
    def draw_preview(self, input_pnt, b_use_input_pnt):
        """
        Draw the preview

        Args:
            input_pnt:  Input point
        """
        if len(self.points) < 1:
            return

        if b_use_input_pnt == True:
            self.b_use_input_pnt = True
        else:
            self.b_use_input_pnt = False

        self.__create_model_element__(input_pnt)
        if not self.model_ele_list:
            return

        AllplanBaseElements.DrawElementPreview(
            self.coord_input.GetInputViewDocument(), AllplanGeo.Matrix3D(),
            self.model_ele_list, False, None)
Beispiel #6
0
    def create_geometry(self, build_ele):
        """
        Create the element geometries

        Args:
            build_ele:  the building element.
        """

        #----------------- Extract palette parameter values

        wall_length = build_ele.Length1_1.value
        wall_width = build_ele.Width1_1.value
        wall_thickness = build_ele.Thickness1_1.value

        void_active = build_ele.chkb_win.value
        door_active = build_ele.chkb_door.value

        join1_type_added = build_ele.join1_type_active.value
        join1_type_select = build_ele.join1_type.value

        join2_type_added = build_ele.join2_type_active.value
        join2_type_select = build_ele.join2_type.value

        #------------------------------------ Create wall------------------------------------------#

        wall = AllplanGeo.Polyhedron3D.CreateCuboid(wall_length,
                                                    wall_thickness, wall_width)
        trans_to_ref_point_1 = AllplanGeo.Matrix3D()
        trans_to_ref_point_1.Translate(AllplanGeo.Vector3D(0, 0, 0))
        wall = AllplanGeo.Transform(wall, trans_to_ref_point_1)

        #----------------------------Create Component Property--------------------------------------#
        com_prop_base_bodies = AllplanBaseElements.CommonProperties()
        com_prop_base_bodies.GetGlobalProperties()
        com_prop_base_bodies.Color = 1

        com_prop_stroke = AllplanBaseElements.CommonProperties()
        com_prop_stroke.GetGlobalProperties()
        com_prop_stroke.Stroke = 9  # dots
        com_prop_stroke.HelpConstruction = True

        self.model_ele_list.append(
            AllplanBasisElements.ModelElement3D(com_prop_stroke, wall))

        #------------------ Append Element to Wall -------------------------------------------------#
        if (void_active):
            void = self.add_windows(build_ele, com_prop_stroke, wall_length,
                                    wall_width, wall_thickness)
            err, wall = AllplanGeo.MakeSubtraction(wall, void)

        if (door_active):
            door = self.add_door(build_ele, com_prop_stroke, wall_length,
                                 wall_width, wall_thickness)
            err, wall = AllplanGeo.MakeSubtraction(wall, door)

        if (join1_type_added):
            join1 = self.add_joins_left(build_ele,
                                        com_prop_stroke,
                                        type=join1_type_select)
            err, wall = AllplanGeo.MakeSubtraction(wall, join1)

        if (join2_type_added):
            join2 = self.add_joins_right(build_ele,
                                         com_prop_stroke,
                                         type=join2_type_select)
            err, wall = AllplanGeo.MakeSubtraction(wall, join2)

        #---------------------------------------Add Wall Element----------------------------------------#
        self.model_ele_list.append(
            AllplanBasisElements.ModelElement3D(com_prop_base_bodies, wall))

        #-----------------------------------------------------------------------------------------------#
        #-----------------------------------------wall handle-------------------------------------------#
        #-----------------------------------------------------------------------------------------------#

        origin = AllplanGeo.Point3D(0, 0, 0)
        wall_plength = AllplanGeo.Point3D(wall_length, 0, 0)
        wall_pwidth = AllplanGeo.Point3D(0, 0, wall_width)
        wall_pthickness = AllplanGeo.Point3D(0, wall_thickness, 0)

        handle_walllength = HandleProperties(
            "WallMoveLength", wall_plength, origin,
            [("Length1_1", HandleDirection.x_dir)], HandleDirection.x_dir,
            True)
        self.handle_list.append(handle_walllength)

        handle_wallwidth = HandleProperties(
            "WallMoveWidth", wall_pwidth, origin,
            [("Width1_1", HandleDirection.z_dir)], HandleDirection.z_dir, True)
        self.handle_list.append(handle_wallwidth)

        handle_wallthickness = HandleProperties(
            "WallMoveThickness", wall_pthickness, origin,
            [("Thickness1_1", HandleDirection.y_dir)], HandleDirection.y_dir,
            True)
        self.handle_list.append(handle_wallthickness)