eights.py

# This is file eights.py

# This is a Python module intended for use with the open-source 3D
# computer-aided design package FreeCAD.  This module automates the
# construction of a sheet of 2D axonometric drawings in first angle
# projection, in a style consistent (to the best of the module
# author's ability) with the BS 8888:2011 standard.

# eights.py was written by Dr. Daniel C. Hatton

# Material up to and including release 0.2 copyright (C) 2015-2018
# University of Plymouth Higher Education Corporation

# Changes since release 0.2 copyright (C) 2020-2021 Dr. Daniel C.
# Hatton

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as
# published by the Free Software Foundation: version 3 of the
# License.

# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License, and the GNU General Public License
# which it incorporates, for more details.

# You should have received a copy of the GNU Lesser General Public
# License [in file LICENSE] along with this program.  If not, see
# <https://www.gnu.org/licenses/>.

# Daniel Hatton thanks Dr. Justin E. Rigden, Specialist Intellectual
# Property Advisor, for authorizing, on behalf of the University of
# Plymouth Higher Education Corporation, the release of this program
# under the licence terms stated above.

# Daniel Hatton can be contacted on <dan.hatton@physics.org>

import sys
import FreeCAD
import Part

# As of FreeCAD version 0.16, the Drawing toolbox has been deprecated,
# and replaced by a toolbox called TechDraw.  However, it's not until
# FreeCAD version 0.19 that TechDraw::DrawPage objects have an
# assignable ViewObject.ShowFrames property, which is essential for BS
# 8888:2011 compliance.  Anywhere this script tests whether the
# FreeCAD version number is less than 0.19, it's in order to decide
# whether to use the Drawing toolbox or the TechDraw toolbox.

versionnumber = float(FreeCAD.Version()[0])\
        +0.01*float(FreeCAD.Version()[1])
if(versionnumber < 0.19):
        import Drawing
else:
        import TechDraw

class create_eights_drawing_sheet:

        # The purpose of this class is to provide the method
        # "create_it", which adds, to an existing FreeCAD document, a
        # TechDraw::DrawPage or Drawing::FeaturePage object ("the
        # sheet") whose formatting is intended to be consistent with
        # the BS 8888:2011 standard for a drawing sheet, and populates
        # the title block of the sheet, again in a way intended to be
        # consistent with BS 8888:2011.

        def __init__(self, document_in, shorttitle_in, pagesize_in,
                     orientation_in, creator_in, longtitle_in, legalowner_in,
                     approver_in, doctype_in, docstatus_in, sheetnum_in,
                     totalsheets_in, inverse_scale_in, partlist_in,
                     drawingnum_in, year_in, month_in, day_in, revision_in):
               self.document = document_in
               self.shorttitle = shorttitle_in
               self.pagesize = pagesize_in
               self.orientation = orientation_in
               self.creator = creator_in
               self.longtitle = longtitle_in
               self.legalowner = legalowner_in
               self.approver = approver_in
               self.doctype = doctype_in
               self.docstatus = docstatus_in
               self.sheetnum = sheetnum_in
               self.totalsheets = totalsheets_in
               self.inverse_scale = inverse_scale_in
               self.partlist = partlist_in
               self.drawingnum = drawingnum_in
               self.year = year_in
               self.month = month_in
               self.day = day_in
               self.revision = revision_in 

        def create_it(self,dummy):
                versionnumber = float(FreeCAD.Version()[0])\
                        +0.01*float(FreeCAD.Version()[1])
                if (versionnumber < 0.19):
                        thesheet =\
                                self.document.addObject("Drawing::FeaturePage",
                                                        self.shorttitle)
                        # BS 8888:2011 inherits most of its style
                        # requirements for drawing sheets from
                        # ISO7200, so FreeCAD's built-in ISO7200
                        # templates are a good starting point.
                        thesheet.Template = FreeCAD.getResourceDir()\
                                +"Mod/Drawing/Templates/"+self.pagesize\
                                +"_"+self.orientation+"_ISO7200.svg"
                else:
                        thesheet =\
                                self.document.addObject("TechDraw::DrawPage",
                                                        self.shorttitle)
                        thetemplate =\
                                self.document.addObject\
                                ("TechDraw::DrawSVGTemplate","Standard")
                        # BS 8888:2011 inherits most of its style
                        # requirements for drawing sheets from
                        # ISO7200, so FreeCAD's built-in ISO7200
                        # templates are a good starting point.  The
                        # "TD" version of the TechDraw template has a
                        # title block that better matches the examples
                        # in BS 8888:2011 than the "Pep" version.
                        thetemplate.Template = FreeCAD.getResourceDir()\
                                +"Mod/TechDraw/Templates/"+self.pagesize\
                                +"_"+self.orientation+"_ISO7200TD.svg"
                        thesheet.Template = self.document.Standard
                        # TechDraw's view frames are incompatible with
                        # BS 8888:2011
                        thesheet.ViewObject.ShowFrames = False
                
                # However, there are several fields listed in BS
                # 8888:2011 as "mandatory" for inclusion in a title
                # block, which are not present by default in the
                # FreeCAD ISO7200 title block template.  This method
                # includes them using three of the the six
                # "supplementary information" fields in the FreeCAD
                # template.

                # Unfortunately, the mapping of actual title block
                # fields to array element numbers in the
                # "EditableTexts" property of a Drawing::FeaturePage
                # object is different between different versions of
                # FreeCAD, so it's necessary to do things differently
                # depending on the FreeCAD version number here.  In
                # addition, the TechDraw::DrawPage class doesn't
                # directly have an "EditableTexts" property, it only
                # has it as a sub-property of the "Templates"
                # property, and treats it as a hash, not a
                # straightforward list.  Not only that, the Python
                # "unicode" function has been renamed to "str" as of
                # Python 3, so it's necessary to detect the (major
                # part of the) Python version number as well.

                pythonversionnumber = float(sys.version_info.major)

                if (pythonversionnumber > 2.5):
                        def unicode(firstarg,secondarg):
                                return str(firstarg)
                
                if (versionnumber < 0.155):
                        thesheet.EditableTexts\
                                = [unicode(self.creator, 'utf-8'),
                                   unicode(self.longtitle, 'utf-8'),
                                   unicode('Legal owner: '+self.legalowner,
                                           'utf-8'),
                                   unicode('To be approved by: '+self.approver,
                                           'utf-8'),
                                   unicode('Document type: '+self.doctype,
                                           'utf-8'),
                                   unicode('Document status: '
                                           +self.docstatus, 'utf-8'),
                                   unicode(self.pagesize, 'utf-8'),
                                   unicode('%d' % (self.sheetnum)+' / '
                                           +'%d' % (self.totalsheets),
                                           'utf-8'),
                                   unicode('1 : '+'%d' % (self.inverse_scale),
                                           'utf-8'),
                                   unicode(self.partlist, 'utf-8'),
                                   unicode(self.drawingnum, 'utf-8'),
                                   unicode('%04d' % (self.year)+'-'
                                           +'%02d' % (self.month)
                                           +'-'+'%02d' % (self.day), 'utf-8'),
                                   unicode(self.revision, 'utf-8'),]
                elif(versionnumber < 0.19):
                        thesheet.EditableTexts\
                                = [unicode(self.creator, 'utf-8'),
                                   unicode(self.longtitle, 'utf-8'),
                                   unicode('Legal owner: '+self.legalowner,
                                           'utf-8'),
                                   unicode('To be approved by: '+self.approver,
                                           'utf-8'),
                                   unicode('Document type: '+self.doctype,
                                           'utf-8'),
                                   unicode('Document status: '
                                           +self.docstatus, 'utf-8'),
                                   unicode(' ', 'utf-8'),
                                   unicode(' ', 'utf-8'),
                                   unicode(self.pagesize, 'utf-8'),
                                   unicode('%d' % (self.sheetnum)+' / '
                                           +'%d' % (self.totalsheets),
                                           'utf-8'),
                                   unicode('1 : '+'%d' % (self.inverse_scale),
                                           'utf-8'),
                                   unicode(self.partlist, 'utf-8'),
                                   unicode(self.drawingnum, 'utf-8'),
                                   unicode('%04d' % (self.year)+'-'
                                           +'%02d' % (self.month)
                                           +'-'+'%02d' % (self.day), 'utf-8'),
                                   unicode(self.revision, 'utf-8'),]
                else:
                        texts = thesheet.Template.EditableTexts
                        texts["AUTHOR_NAME"]\
                                = unicode(self.creator, 'utf-8')
                        texts["DRAWING_TITLE"]\
                                = unicode(self.longtitle, 'utf-8')
                        texts["SI-1"]\
                                = unicode('Legal owner: '+self.legalowner,
                                          'utf-8')
                        texts["SI-2"]\
                                = unicode('To be approved by: '+self.approver,
                                          'utf-8')
                        texts["FreeCAD_DRAWING"]\
                                = unicode('Document type: '+self.doctype,
                                          'utf-8')
                        texts["SI-4"]\
                                = unicode('Document status: '
                                          +self.docstatus, 'utf-8')
                        texts["FC-SI"]\
                                = unicode(self.pagesize, 'utf-8')
                        texts["FC-SH"]\
                                = unicode('%d' % (self.sheetnum)+' / '
                                          +'%d' % (self.totalsheets),
                                          'utf-8')
                        texts["FC-SC"]\
                                = unicode('1 : '+'%d' % (self.inverse_scale),
                                          'utf-8')
                        texts["PN"]\
                                = unicode(self.partlist, 'utf-8')
                        texts["DN"]\
                                = unicode(self.drawingnum, 'utf-8')
                        texts["FC-DATE"]\
                                = unicode('%04d' % (self.year)+'-'
                                          +'%02d' % (self.month)
                                          +'-'+'%02d' % (self.day), 'utf-8')
                        texts["FC-REV"]\
                                = unicode(self.revision, 'utf-8')
                        thesheet.Template.EditableTexts =  texts
                self.document.recompute()

class eitherone:

        # A parent class defining a method that's needed in both
        # the add_first_angle_projection_symbol class and the
        # first_angle_projection class.

        def __init__():

                pass

        def addsingleview(self,versionnumber,legend,featurepart,viewdirection,
                          width,depth,height,imgcountxdo,imgcountxwo,
                          gapcountxo,imgcountydo,imgcountyho,gapcounty,
                          imgcountxdn,imgcountxwn,gapcountxn,imgcountydn,
                          imgcountyhn,rotationo,rotationn,thick,thin):
                
                if(versionnumber < 0.19):
                        theview\
                                = self.drawing_page.Document.addObject("Drawing::FeatureViewPart",
                                                                       self.title
                                                                       +legend)
                else:
                        theview\
                                = self.drawing_page.Document.addObject("TechDraw::DrawViewPart",
                                                                       self.title
                                                                       +legend) 
                theview.Source = featurepart
                theview.Direction = viewdirection

                # BS 8888:2011 does not specify the exact spacing
                # between the individual views, so that spacing is
                # taken from user input; similarly for the position on
                # the sheet of the overall set of views.

                if(versionnumber < 0.19):
                        
                        # The "addView" method of a TechDraw::DrawPage
                        # object appears to change the "X" and "Y"
                        # properties of the TechDraw::DrawViewPart
                        # object that's being added, so it's only when
                        # the Drawing toolbox, rather than the
                        # TechDraw toolbox, is being used that there's
                        # any point setting the "X" and "Y" properties
                        # (of the Drawing::FeatureViewPart object) here.
                        # In any case, the "X" and "Y" properties have
                        # to take different values when the TechDraw
                        # toolbox is in use, since the TechDraw toolbox
                        # measures Y in the opposite direction from the
                        # Drawing toolbox, and the TechDraw toolbox
                        # measures X and Y at the centre of a
                        # DrawViewPart object, whereas the Drawing
                        # toolbox measures X and Y at one corner of a
                        # FeatureViewPart object.
                        theview.X = self.xpos+imgcountxdo*depth\
                                +imgcountxwo*width+gapcountxo*self.spacing
                        theview.Y = self.ypos\
                                +imgcountydo*depth+imgcountyho*height\
                                +gapcounty*self.spacing
                else:
                        theview.ScaleType = u"Custom"
                theview.Scale = self.scale
                if(versionnumber < 0.19):
                        theview.Rotation = rotationo
                        theview.ShowHiddenLines = True
                        theview.LineWidth = thick
                        theview.HiddenWidth = thin
                        self.drawing_page.addObject(theview)
                else:
                        theview.Rotation = rotationn
                        theview.HardHidden = True
                        theview.ViewObject.LineWidth = thick
                        theview.ViewObject.HiddenWidth = thin
                        theview.Label = ""
                        self.drawing_page.addView(theview)
                        theview.X = self.xpos+imgcountxdn*depth\
                                +imgcountxwn*width+gapcountxn*self.spacing
                        theview.Y = float(self.drawing_page.Template.Height)\
                                -self.ypos-(imgcountydn*depth
                                            +imgcountyhn*height)\
                                -gapcounty*self.spacing
                return theview

class add_first_angle_projection_symbol(eitherone):

        # The purpose of this class is to provide the method
        # "put_it_in", which adds the standard BS 8888:2011 symbol,
        # indicating that a set of drawings are in first angle
        # projection ("the symbol"), to an existing TechDraw::DrawPage
        # or Drawing::FeaturePage object ("the sheet").  The method
        # put_it_in also creates a new FreeCAD Document ("the dummy
        # document"), containing various objects that are created as
        # intermediate steps on the way to adding the symbol to the
        # sheet, but which do not need to exist in the same document
        # as the sheet.  The method put_it_in also modifies the parent
        # document of the sheet, by adding to it two
        # TechDraw::DrawViewPart or Drawing::FeatureViewPart objects,
        # which are intermediate steps on the way to adding the symbol
        # to the sheet, and which have to exist _in the same document
        # as the sheet_ in order to add the symbol to the sheet.

        def __init__(self, H_in, h_in, d_in, xpos_in, ypos_in,
                     drawing_page_in):
                self.H = H_in
                self.h = h_in
                self.d = d_in
                self.xpos = xpos_in
                self.ypos = ypos_in
                self.drawing_page = drawing_page_in

        def put_it_in(self,dummy):
                self.title = "first_angle_projection_symbol"
                thick = 0.7 # The wider of the two line widths suggested in\
                             # BS 8888:2011
                thin = 0.35 # The narrower of the two line widths suggested\
                            # in BS 8888:2011

                # BS 8888:2011 does not specify the exact dimensions
                # of the truncated cone, axonometric projections of
                # which form the symbol, so those dimensions are taken
                # from user input.

                base_radius = 0.5*self.h
                top_radius = 0.5*self.H
                self.spacing = 3.0*self.d
                depth = self.H
                height = self.H
                width = self.H
                top_centre = FreeCAD.Vector(top_radius,0.0,top_radius)
                depth_wise_direction = FreeCAD.Vector(0.0,1.0,0.0)
                part = Part.makeCone(base_radius,top_radius,self.H,
                                     top_centre,depth_wise_direction)
                dummydoc = FreeCAD.newDocument("Dummy")
                part_in_tree = dummydoc.addObject("Part::Feature",
                                                  self.title)
                part_in_tree.Shape = part
                featurepart = dummydoc.getObject(self.title)
                versionnumber = float(FreeCAD.Version()[0])\
                        +0.01*float(FreeCAD.Version()[1])
                self.scale = 1.0
                
                plusxview = self.addsingleview(versionnumber,
                                               " from positive x",
                                               featurepart,
                                               FreeCAD.Vector(1.0,0.0,0.0),
                                               width,depth,height,0.0,0.0,
                                               0.0,0.0,0.0,0.0,0.5,
                                               0.0,0.0,0.0,0.0,270.0,0.0,thick,
                                               thin)
                minusyview = self.addsingleview(versionnumber,
                                                " from negative y",
                                                featurepart,
                                                FreeCAD.Vector(0.0,-1.0,0.0),
                                                width,depth,height,1.0,0.0,
                                                1.0,0.0,0.0,0.0,1.0,
                                                0.5,1.0,0.0,0.0,90.0,0.0,thick,
                                                thin)
                self.drawing_page.Document.recompute()

                # Leaving the dummy document open is a waste of RAM
                # and clutters up the GUI, so ideally, one would like
                # to close it.  Unfortunately, attempting to close the
                # dummy document causes a segfault, at least under
                # FreeCAD 0.16 on Scientific Linux 7.3 and FreeCAD
                # 0.16 on Fedora 28, so the following command operates
                # only if the FreeCAD version is 0.18.4 or later.
                # (I've checked, and the segfault doesn't happen under
                # FreeCAD 0.18.4 on Ubuntu 20.04.)

                if (versionnumber >= 0.184):
                        FreeCAD.closeDocument("Dummy")

class add_third_angle_projection_symbol(eitherone):

        # The purpose of this class is to provide the method
        # "put_it_in", which adds the standard BS 8888:2011 symbol,
        # indicating that a set of drawings are in third angle
        # projection ("the symbol"), to an existing TechDraw::DrawPage
        # or Drawing::FeaturePage object ("the sheet").  The method
        # put_it_in also creates a new FreeCAD Document ("the dummy
        # document"), containing various objects that are created as
        # intermediate steps on the way to adding the symbol to the
        # sheet, but which do not need to exist in the same document
        # as the sheet.  The method put_it_in also modifies the parent
        # document of the sheet, by adding to it two
        # TechDraw::DrawViewPart or Drawing::FeatureViewPart objects,
        # which are intermediate steps on the way to adding the symbol
        # to the sheet, and which have to exist _in the same document
        # as the sheet_ in order to add the symbol to the sheet.

        def __init__(self, H_in, h_in, d_in, xpos_in, ypos_in,
                     drawing_page_in):
                self.H = H_in
                self.h = h_in
                self.d = d_in
                self.xpos = xpos_in
                self.ypos = ypos_in
                self.drawing_page = drawing_page_in

        def put_it_in(self,dummy):
                self.title = "third_angle_projection_symbol"
                thick = 0.7 # The wider of the two line widths suggested in\
                             # BS 8888:2011
                thin = 0.35 # The narrower of the two line widths suggested\
                            # in BS 8888:2011

                # BS 8888:2011 does not specify the exact dimensions
                # of the truncated cone, axonometric projections of
                # which form the symbol, so those dimensions are taken
                # from user input.

                base_radius = 0.5*self.h
                top_radius = 0.5*self.H
                self.spacing = 3.0*self.d
                depth = self.H
                height = self.H
                width = self.H
                top_centre = FreeCAD.Vector(top_radius,0.0,top_radius)
                depth_wise_direction = FreeCAD.Vector(0.0,1.0,0.0)
                part = Part.makeCone(base_radius,top_radius,self.H,
                                     top_centre,depth_wise_direction)
                dummydoc = FreeCAD.newDocument("Dummy")
                part_in_tree = dummydoc.addObject("Part::Feature",
                                                  self.title)
                part_in_tree.Shape = part
                featurepart = dummydoc.getObject(self.title)
                versionnumber = float(FreeCAD.Version()[0])\
                        +0.01*float(FreeCAD.Version()[1])
                self.scale = 1.0
                
                plusxview = self.addsingleview(versionnumber,
                                               " from positive x",
                                               featurepart,
                                               FreeCAD.Vector(1.0,0.0,0.0),
                                               width,depth,height,1.0,0.0,
                                               1.0,0.0,0.0,0.0,0.5,
                                               1.0,1.0,0.0,0.0,270.0,0.0,thick,
                                               thin)
                minusyview = self.addsingleview(versionnumber,
                                                " from negative y",
                                                featurepart,
                                                FreeCAD.Vector(0.0,-1.0,0.0),
                                                width,depth,height,0.0,0.0,
                                                0.0,0.0,0.0,0.0,0.0,
                                                0.5,0.0,0.0,0.0,90.0,0.0,thick,
                                                thin)
                self.drawing_page.Document.recompute()

                # Leaving the dummy document open is a waste of RAM
                # and clutters up the GUI, so ideally, one would like
                # to close it.  Unfortunately, attempting to close the
                # dummy document causes a segfault, at least under
                # FreeCAD 0.16 on Scientific Linux 7.3 and FreeCAD
                # 0.16 on Fedora 28, so the following command operates
                # only if the FreeCAD version is 0.18.4 or later.
                # (I've checked, and the segfault doesn't happen under
                # FreeCAD 0.18.4 on Ubuntu 20.04.)

                if (versionnumber >= 0.184):
                        FreeCAD.closeDocument("Dummy")

class first_angle_projection(eitherone):

        # The purpose of this class is to provide the method "fap",
        # which takes any object ("the shape") which can be assigned
        # to the "Shape" property of a Part::Feature object, and adds
        # a set of axonometric drawings ("the views") of the shape in
        # first angle projection to an existing TechDraw::DrawPage or
        # Drawing::FeaturePage object ("the sheet"), following the
        # conventions in BS 8888:2011.  The method fap also creates a
        # new FreeCAD Document ("the dummy document"), containing
        # various objects that are created as intermediate steps on
        # the way to adding the views to the sheet, but which do not
        # need to exist in the same document as the sheet.  The method
        # fap also modifies the parent document of the sheet, by
        # adding to it six TechDraw::DrawViewPart or
        # Drawing::FeatureViewPart objects, which are intermediate
        # steps on the way to adding the views to the sheet, and which
        # have to exist _in the same document as the sheet_ in order
        # to add the views to the sheet.

        def __init__(self, title_in, part_in, spacing_in, xpos_in, ypos_in,
                     scale_in, drawing_page_in):
            self.title = title_in
            self.part = part_in
            self.spacing = spacing_in
            self.xpos = xpos_in
            self.ypos = ypos_in
            self.scale = scale_in
            self.drawing_page = drawing_page_in

        def fap(self,dummy):
                thick = 0.7 # The wider of the two line widths suggested in\
                            # BS 8888:2011
                thin = 0.35 # The narrower of the two line widths suggested\
                            # in BS 8888:2011

                # Measure the dimensions of the shape, in order to know how
                # much space is needed on the sheet for the views.

                width = self.part.BoundBox.XLength
                depth = self.part.BoundBox.YLength
                height = self.part.BoundBox.ZLength
                dummydoc = FreeCAD.newDocument("Dummy")
                part_in_tree = dummydoc.addObject("Part::Feature",
                                                  self.title)
                part_in_tree.Shape = self.part
                featurepart = dummydoc.getObject(self.title)
                versionnumber = float(FreeCAD.Version()[0])\
                        +0.01*float(FreeCAD.Version()[1])
                minuszview = self.addsingleview(versionnumber,
                                                " from negative z",
                                                featurepart,
                                                FreeCAD.Vector(0.0,0.0,-1.0),
                                                width,depth,height,
                                                1.0*self.scale,0.0*self.scale,
                                                1.0,0.0*self.scale,
                                                0.0*self.scale,0.0,
                                                1.0*self.scale,
                                                0.5*self.scale,1.0,
                                                0.5*self.scale,
                                                0.0*self.scale,180.0,0.0,thick,
                                                thin)
                minusxview = self.addsingleview(versionnumber,
                                                " from negative x",
                                                featurepart,
                                                FreeCAD.Vector(-1.0,0.0,0.0),
                                                width,depth,height,
                                                2.0*self.scale,1.0*self.scale,
                                                2.0,1.0*self.scale,
                                                1.0*self.scale,1.0,
                                                1.5*self.scale,
                                                1.0*self.scale,2.0,
                                                1.0*self.scale,
                                                0.5*self.scale,90.0,0.0,thick,
                                                thin)
                minusyview = self.addsingleview(versionnumber,
                                                " from negative y",
                                                featurepart,
                                                FreeCAD.Vector(0.0,-1.0,0.0),
                                                width,depth,height,
                                                1.0*self.scale,0.0*self.scale,
                                                1.0,1.0*self.scale,
                                                1.0*self.scale,1.0,
                                                1.0*self.scale,
                                                0.5*self.scale,1.0,
                                                1.0*self.scale,
                                                0.5*self.scale,90.0,0.0,thick,
                                                thin)
                plusxview = self.addsingleview(versionnumber,
                                               " from positive x",
                                               featurepart,
                                               FreeCAD.Vector(1.0,0.0,0.0),
                                               width,depth,height,
                                               0.0*self.scale,0.0*self.scale,
                                               0.0,1.0*self.scale,
                                               1.0*self.scale,1.0,
                                               0.5*self.scale,
                                               0.0*self.scale,0.0,
                                               1.0*self.scale,
                                               0.5*self.scale,270.0,0.0,thick,
                                               thin)
                plusyview = self.addsingleview(versionnumber,
                                               " from positive y",
                                               featurepart,
                                               FreeCAD.Vector(0.0,1.0,0.0),
                                               width,depth,height,
                                               2.0*self.scale,2.0*self.scale,
                                               3.0,1.0*self.scale,
                                               1.0*self.scale,1.0,
                                               2.0*self.scale,
                                               1.5*self.scale,3.0,
                                               1.0*self.scale,
                                               0.5*self.scale,270.0,0.0,thick,
                                               thin)
                pluszview = self.addsingleview(versionnumber,
                                               " from positive z",
                                               featurepart,
                                               FreeCAD.Vector(0.0,0.0,1.0),
                                               width,depth,height,
                                               1.0*self.scale,0.0*self.scale,
                                               1.0,2.0*self.scale,
                                               1.0*self.scale,2.0,
                                               1.0*self.scale,
                                               0.5*self.scale,1.0,
                                               1.5*self.scale,
                                               1.0*self.scale,0.0,0.0,thick,
                                               thin)
                                               
                                               
                self.drawing_page.Document.recompute()

                # Leaving the dummy document open is a waste of RAM
                # and clutters up the GUI, so ideally, one would like
                # to close it.  Unfortunately, when this method is
                # being used to add views of a second shape to a sheet
                # that already contains views of one shape, attempting
                # to close the dummy document causes a segfault, at
                # least under FreeCAD 0.16 on Scientific Linux 7.3, so
                # the following command operates only if the FreeCAD
                # version is 0.18.4 or later.  (I've checked, and the
                # segfault doesn't happen under FreeCAD 0.18.4 on
                # Ubuntu 20.04.)

                if (versionnumber >= 0.184):
                        FreeCAD.closeDocument("Dummy")


class third_angle_projection(eitherone):

        # The purpose of this class is to provide the method "tap",
        # which takes any object ("the shape") which can be assigned
        # to the "Shape" property of a Part::Feature object, and adds
        # a set of axonometric drawings ("the views") of the shape in
        # third angle projection to an existing TechDraw::DrawPage or
        # Drawing::FeaturePage object ("the sheet"), following the
        # conventions in BS 8888:2011.  The method tap also creates a
        # new FreeCAD Document ("the dummy document"), containing
        # various objects that are created as intermediate steps on
        # the way to adding the views to the sheet, but which do not
        # need to exist in the same document as the sheet.  The method
        # fap also modifies the parent document of the sheet, by
        # adding to it six TechDraw::DrawViewPart or
        # Drawing::FeatureViewPart objects, which are intermediate
        # steps on the way to adding the views to the sheet, and which
        # have to exist _in the same document as the sheet_ in order
        # to add the views to the sheet.

        def __init__(self, title_in, part_in, spacing_in, xpos_in, ypos_in,
                     scale_in, drawing_page_in):
            self.title = title_in
            self.part = part_in
            self.spacing = spacing_in
            self.xpos = xpos_in
            self.ypos = ypos_in
            self.scale = scale_in
            self.drawing_page = drawing_page_in

        def tap(self,dummy):
                thick = 0.7 # The wider of the two line widths suggested in\
                            # BS 8888:2011
                thin = 0.35 # The narrower of the two line widths suggested\
                            # in BS 8888:2011

                # Measure the dimensions of the shape, in order to know how
                # much space is needed on the sheet for the views.

                width = self.part.BoundBox.XLength
                depth = self.part.BoundBox.YLength
                height = self.part.BoundBox.ZLength
                dummydoc = FreeCAD.newDocument("Dummy")
                part_in_tree = dummydoc.addObject("Part::Feature",
                                                  self.title)
                part_in_tree.Shape = self.part
                featurepart = dummydoc.getObject(self.title)
                versionnumber = float(FreeCAD.Version()[0])\
                        +0.01*float(FreeCAD.Version()[1])
                minuszview = self.addsingleview(versionnumber,
                                                " from negative z",
                                                featurepart,
                                                FreeCAD.Vector(0.0,0.0,-1.0),
                                                width,depth,height,
                                                1.0*self.scale,0.0*self.scale,
                                                1.0,1.0*self.scale,
                                                1.0*self.scale,2.0,
                                                1.0*self.scale,
                                                0.5*self.scale,1.0,
                                                1.5*self.scale,
                                                1.0*self.scale,180.0,0.0,thick,
                                                thin)
                minusxview = self.addsingleview(versionnumber,
                                                " from negative x",
                                                featurepart,
                                                FreeCAD.Vector(-1.0,0.0,0.0),
                                                width,depth,height,
                                                1.0*self.scale,0.0*self.scale,
                                                0.0,1.0*self.scale,
                                                1.0*self.scale,1.0,
                                                0.5*self.scale,
                                                0.0*self.scale,0.0,
                                                1.0*self.scale,
                                                0.5*self.scale,
                                                90.0,0.0,thick,
                                                thin)
                minusyview = self.addsingleview(versionnumber,
                                                " from negative y",
                                                featurepart,
                                                FreeCAD.Vector(0.0,-1.0,0.0),
                                                width,depth,height,
                                                1.0*self.scale,0.0*self.scale,
                                                1.0,1.0*self.scale,
                                                1.0*self.scale,1.0,
                                                1.0*self.scale,
                                                0.5*self.scale,1.0,
                                                1.0*self.scale,
                                                0.5*self.scale,90.0,0.0,thick,
                                                thin)
                plusxview = self.addsingleview(versionnumber,
                                               " from positive x",
                                               featurepart,
                                               FreeCAD.Vector(1.0,0.0,0.0),
                                               width,depth,height,
                                               1.0*self.scale,1.0*self.scale,
                                               2.0,1.0*self.scale,
                                               1.0*self.scale,1.0,
                                               1.5*self.scale,
                                               1.0*self.scale,2.0,
                                               1.0*self.scale,
                                               0.5*self.scale,
                                               270.0,0.0,thick,
                                               thin)
                plusyview = self.addsingleview(versionnumber,
                                               " from positive y",
                                               featurepart,
                                               FreeCAD.Vector(0.0,1.0,0.0),
                                               width,depth,height,
                                               2.0*self.scale,2.0*self.scale,
                                               3.0,1.0*self.scale,
                                               1.0*self.scale,1.0,
                                               2.0*self.scale,
                                               1.5*self.scale,3.0,
                                               1.0*self.scale,
                                               0.5*self.scale,270.0,0.0,thick,
                                               thin)
                pluszview = self.addsingleview(versionnumber,
                                               " from positive z",
                                               featurepart,
                                               FreeCAD.Vector(0.0,0.0,1.0),
                                               width,depth,height,
                                               1.0*self.scale,0.0*self.scale,
                                               1.0,1.0*self.scale,
                                               0.0*self.scale,0.0,
                                               1.0*self.scale,
                                               0.5*self.scale,1.0,
                                               0.5*self.scale,
                                               0.0*self.scale,
                                               0.0,0.0,thick,
                                               thin)
                                               
                                               
                self.drawing_page.Document.recompute()

                # Leaving the dummy document open is a waste of RAM
                # and clutters up the GUI, so ideally, one would like
                # to close it.  Unfortunately, when this method is
                # being used to add views of a second shape to a sheet
                # that already contains views of one shape, attempting
                # to close the dummy document causes a segfault, at
                # least under FreeCAD 0.16 on Scientific Linux 7.3, so
                # the following command operates only if the FreeCAD
                # version is 0.18.4 or later.  (I've checked, and the
                # segfault doesn't happen under FreeCAD 0.18.4 on
                # Ubuntu 20.04.)

                if (versionnumber >= 0.184):
                        FreeCAD.closeDocument("Dummy")