Exemple #1
0
def main():
    bdf_filename = 'bay.bdf'
    bc_file = 'bc'

    bdf_filename2 = 'bay2.bdf'
    cart3d_filename = 'bay.i.tri'
    stl_filename = 'bay.stl'
    #in_format = 'nastran'
    flip_normals = True

    volume_bdfname = 'bay.vol.bdf'

    module = __import__(bc_file)
    pid_map = module.__dict__['pid_map']
    boundary_conditions = module.__dict__['boundary_conditions']

    #print dir(module)
    #e = execfile(bc_file, globals(), locals())
    #print globals()
    #print dir(e)
    
    pid_map
    boundary_conditions
    assert isinstance(pid_map, dict)
    assert isinstance(boundary_conditions, dict)
    
    get_bcs(bdf_filename, pid_map, boundary_conditions, log=None)
    #if flip_normals:
    #    bdf = BDF()
    #    bdf.read_bdf(bdf_filename, xref=False)
    #    bdf.flip_normals()
    #    bdf.write_bdf(bdf_filename2)
    #    del bdf
    #else:
    #bdf_filename2 = bdf_filename

    if 0:
        nastran_to_cart3d_filename(bdf_filename, cart3d_filename, log=log)
        cart3d_to_stl_filename(cart3d_filename, stl_filename, log=log)
    else:
        nastran_to_stl_filename(bdf_filename, stl_filename, log=log)
        stl_to_nastran_filename(stl_filename, bdf_filename2, log=log)
    print "----------"
    #nastran_to_cart3d(bdf_filename2, cart3d_filename)
    #cart3d = Cart3dReader()
    #cart3d.read_cart3d(cart3d_filename)

    stl = STLReader()
    stl.read_stl(stl_filename)

    if flip_normals:
        stl.flip_normals()
    stl.project_boundary_layer(stl.nodes, stl.elements, volume_bdfname)
Exemple #2
0
def stl_to_plot3d_filename(stl_filename, p3d_filename, log=None, ascii=True):
    model = STLReader(log=log)
    model.read_stl(stl_filename)

    #nodal_normals = model.get_normals_at_nodes(model.elements)

    p3d = open(p3d_filename, 'wb')
    nblocks = len(model.elements)
    #nblocks = 10
    p3d.write('%i\n' % nblocks)
    for iblock in range(nblocks):
        p3d.write('2 2 1\n')

    nodes = model.nodes
    elements = model.elements
    if 0:
        for i in [0, 1, 2]:
            for iblock in range(nblocks):
                (n1, n2, n3) = elements[iblock]
                p1 = nodes[n1, :]
                p2 = nodes[n2, :]
                p3 = nodes[n3, :]
                p4 = p3
                xi = [[p1[i], p2[i], p3[i], p4[i]]]
                savetxt(p3d, xi, fmt='%f')
    else:
        for iblock in range(nblocks):
            for i in [0, 1, 2]:
                (n1, n2, n3) = elements[iblock]
                p1 = nodes[n1, :]
                p2 = nodes[n2, :]
                p3 = nodes[n3, :]
                p4 = p3
                xi = [[p1[i], p2[i], p3[i], p4[i]]]
                savetxt(p3d, xi, fmt='%f')

            #p3d.write("----\n")
            #x = [[p1[0], p2[0], p3[0], p4[0]]]
            #y = [[p1[1], p2[1], p3[1], p4[1]]]
            #z = [[p1[2], p2[2], p3[2], p4[2]]]

            #savetxt(p3d, x, fmt='%f')
            #savetxt(p3d, y, fmt='%f')
            #savetxt(p3d, z, fmt='%f')

        #p3d.write('\n')
        #p3d.write(' '.join(x) + '\n')
        #p3d.write(' '.join(y) + '\n')
        #p3d.write(' '.join(z) + '\n')
        #xxxz
        #yyyz
        #zzzz
    p3d.close()
Exemple #3
0
def stl_to_nastran_filename(stl_filename,
                            bdf_filename,
                            nnodes_offset=0,
                            nelements_offset=0,
                            log=None):
    model = STLReader(log=log)
    model.read_stl(stl_filename)

    nid = nnodes_offset + 1
    cid = None
    pid = 100
    mid = 200
    load_id = 10

    nodal_normals = model.get_normals_at_nodes(model.elements)

    bdf = open(bdf_filename, 'wb')
    bdf.write('CEND\n')
    bdf.write('LOAD = %s\n' % load_id)
    bdf.write('BEGIN BULK\n')
    nid2 = 1
    magnitude = 100.
    for (x, y, z) in model.nodes:
        card = ['GRID', nid, cid, x, y, z]
        bdf.write(print_card(card))

        nx, ny, nz = nodal_normals[nid2 - 1]
        card = ['FORCE', load_id, nid, cid, magnitude, nx, ny, nz]
        bdf.write(print_card(card))
        nid += 1
        nid2 += 1

    eid = nelements_offset + 1
    for (n1, n2, n3) in (model.elements + (nnodes_offset + 1)):
        card = ['CTRIA3', eid, pid, n1, n2, n3]
        bdf.write(print_card(card))
        eid += 1

    t = 0.1
    card = ['PSHELL', pid, mid, t]
    bdf.write(print_card(card))

    E = 1e7
    G = None
    nu = 0.3
    card = ['MAT1', mid, E, G, nu]
    bdf.write(print_card(card))

    bdf.write('ENDDATA\n')
    bdf.close()
Exemple #4
0
def cart3d_to_stl(cart3d, log=None, debug=False):
    """
    Converts a Cart3DReader object to STL format.

    :param cart3d: a Cart3DReader object
    :param log:    a logger object (or None)
    :param debug:  True/False (used if log is not defined)

    :returns stl: an STLReader object
    """
    normals = cart3d.normals()
    stl = STLReader(log=log, debug=debug)
    stl.nodes = nodes
    stl.elements = elements
    stl.write_stl(stl_filename)
    return stl
Exemple #5
0
def main():
    import os
    from pyNastran.converters.stl.stl_reader import STLReader

    m1 = STLReader()
    m1.read_stl('tetgen_test.stl')
    m1.flip_normals()
    m1.write_stl('tetgen_test_flipped.stl')
    del m1

    os.system('tetgen.exe -pqcvVqY tetgen_test_flipped.stl')

    m = TetgenReader()
    base = 'tetgen_test_flipped.1'
    m.read_tetgen(base + '.node', base + '.smesh', base + '.ele', dimension_flag=3)
    m.write_nastran(base + '.bdf')
Exemple #6
0
def cart3d_to_stl_filename(cart3d_filename,
                           stl_filename,
                           log=None,
                           debug=False):
    """
    Converts a Cart3D file to STL format.
    
    :param cart3d_filename: path to the input Cart3D file
    :param stl_filename:    path to the output STL file
    :param log:             a logger object (or None)
    :param debug:           True/False (used if log is not defined)
    """
    cart3d = Cart3DReader(log=log, debug=debug)
    cart3d.read_cart3d(cart3d_filename)

    stl = STLReader()
    stl.nodes = cart3d.nodes
    stl.elements = cart3d.elements
    stl.write_stl(stl_filename)
    return
    if 0:
        normals = model.normals()

        f = open(stl_filename, 'wb')
        f.write('solid cart3d_model\n')

        i = 0
        for (n1, n2, n3) in model.elements:
            #f.write('solid cart3d_model\n')
            n = normals[i]
            f.write('loop\n')
            f.write('  facet normal %f %f %f\n' % (n[0], n[1], n[2]))
            f.write('    vertex %f %f %f\n' % (n1[0], n1[1], n1[2]))
            f.write('    vertex %f %f %f\n' % (n1[0], n1[1], n1[2]))
            f.write('    vertex %f %f %f\n' % (n1[0], n1[1], n1[2]))
            f.write('  endfacet')
            f.write('endloop\n')
            i += 1
        f.close()
Exemple #7
0
def nastran_to_stl_filename(bdf_filename, stl_filename, log=None):
    model = BDF(log=log)
    model.read_bdf(bdf_filename)
    #log.info('card_count = %s' % model.card_count)

    nnodes = len(model.nodes)
    nodes = zeros((nnodes, 3), dtype='float64')
    elements = []

    i = 0
    nodeid_to_i_map = {}
    for node_id, node in sorted(iteritems(model.nodes)):
        xyz = node.Position()
        if xyz[0] < 0.001:
            print(xyz, node_id)
        nodes[i, :] = xyz
        nodeid_to_i_map[node_id] = i
        i += 1

    for eid, element in sorted(iteritems(model.elements)):
        if element.type in ['CQUADR']:
            continue
        elif element.type in [
                'CBAR',
                'CBEAM',
                'CONM2',
                'RBE2',
                'RBE3',
                'CBUSH',
                'CBUSH1D',
                'CBUSH2D',
                'CONROD',
                'CROD',
                'CELAS1',
                'CELAS2',
                'CELAS3',
                'CELAS4',
                'CDAMP1',
                'CDAMP2',
                'CDAMP3',
                'CDAMP4',
        ]:
            continue
        elif element.type in ['CQUAD4']:
            n1, n2, n3, n4 = element.nodeIDs()
            i1, i2, i3, i4 = nodeid_to_i_map[n1], nodeid_to_i_map[
                n2], nodeid_to_i_map[n3], nodeid_to_i_map[n3]
            elements.append([i1, i2, i3])
            elements.append([i3, i4, i1])
        elif element.type in ['CTRIA3', 'CTRIAR']:
            n1, n2, n3 = element.nodeIDs()
            i1, i2, i3 = nodeid_to_i_map[n1], nodeid_to_i_map[
                n2], nodeid_to_i_map[n3]
            elements.append([i1, i2, i3])
        else:
            print(element.type)
    elements = array(elements, dtype='int32')
    stl = STLReader()
    stl.nodes = nodes
    stl.elements = elements
    stl.write_stl(stl_filename)
Exemple #8
0
    def load_stl_geometry(self, stl_filename, dirname, plot=True):
        print("load_stl_geometry...")
        skipReading = self.removeOldGeometry(stl_filename)
        if skipReading:
            return

        model = STLReader(log=self.log, debug=False)
        #self.modelType = model.modelType
        model.read_stl(stl_filename)
        nodes = model.nodes
        elements = model.elements

        if self.is_centroidal:
            normals = model.get_normals(elements)
            areas = model.get_area(elements)
        elif self.is_nodal:
            normals = None
            areas = None
            #normals = model.get_normals_at_nodes(elements)

        self.nNodes, three = nodes.shape
        self.nElements, three = elements.shape

        print("nNodes = %s" % self.nNodes)
        print("nElements = %s" % self.nElements)

        self.grid.Allocate(self.nElements, 1000)
        #self.gridResult.SetNumberOfComponents(self.nElements)
        self.grid2.Allocate(1, 1000)

        points = vtk.vtkPoints()
        points.SetNumberOfPoints(self.nNodes)
        #self.gridResult.Allocate(self.nNodes, 1000)
        #vectorReselt.SetNumberOfComponents(3)
        self.nidMap = {}
        #elem.SetNumberOfPoints(nNodes)
        if 0:
            fraction = 1. / self.nNodes  # so you can color the nodes by ID
            for nid, node in sorted(iteritems(nodes)):
                points.InsertPoint(nid - 1, *node)
                self.gridResult.InsertNextValue(nid * fraction)
                #print str(element)

                #elem = vtk.vtkVertex()
                #elem.GetPointIds().SetId(0, i)
                #self.aQuadGrid.InsertNextCell(elem.GetCellType(), elem.GetPointIds())
                #vectorResult.InsertTuple3(0, 0.0, 0.0, 1.0)

        assert nodes is not None
        nnodes, three = nodes.shape
        xmax, ymax, zmax = nodes.max(axis=0)
        xmin, ymin, zmin = nodes.min(axis=0)
        self.log.info('xmax=%s xmin=%s' % (xmax, xmin))
        self.log.info('ymax=%s ymin=%s' % (ymax, ymin))
        self.log.info('zmax=%s zmin=%s' % (zmax, zmin))
        dim_max = max(xmax - xmin, ymax - ymin, zmax - zmin)
        self.update_axes_length(dim_max)

        nid = 0
        print("nnodes=%s" % nnodes)
        for i in range(nnodes):
            points.InsertPoint(nid, nodes[i, :])
            nid += 1

        nelements, three = elements.shape
        #elements -= 1
        for eid in range(nelements):
            elem = vtkTriangle()
            node_ids = elements[eid, :]
            elem.GetPointIds().SetId(0, node_ids[0])
            elem.GetPointIds().SetId(1, node_ids[1])
            elem.GetPointIds().SetId(2, node_ids[2])
            self.grid.InsertNextCell(
                5, elem.GetPointIds())  #elem.GetCellType() = 5  # vtkTriangle

        self.grid.SetPoints(points)
        self.grid.Modified()
        self.grid.Update()
        print("updated grid")

        # loadSTLResults - regions/loads
        self.TurnTextOn()
        self.scalarBar.VisibilityOff()
        self.scalarBar.Modified()

        cases = {}
        self.iSubcaseNameMap = {}
        ID = 1

        cases = self._fill_stl_case(cases, ID, elements, nodes, normals, areas)
        self._finish_results_io(cases)
Exemple #9
0
    def load_stl_geometry(self, stl_filename, dirname):
        print "load_stl_geometry..."
        skipReading = self.removeOldGeometry(stl_filename)
        if skipReading:
            return

        model = STLReader(log=self.log, debug=False)
        #self.modelType = model.modelType
        model.read_stl(stl_filename)
        nodes = model.nodes
        elements = model.elements
        self.nNodes, three = nodes.shape
        self.nElements, three = elements.shape

        print("nNodes = ", self.nNodes)
        print("nElements = ", self.nElements)

        self.grid.Allocate(self.nElements, 1000)
        #self.gridResult.SetNumberOfComponents(self.nElements)
        self.grid2.Allocate(1, 1000)

        points = vtk.vtkPoints()
        points.SetNumberOfPoints(self.nNodes)
        #self.gridResult.Allocate(self.nNodes, 1000)
        #vectorReselt.SetNumberOfComponents(3)
        self.nidMap = {}
        #elem.SetNumberOfPoints(nNodes)
        if 0:
            fraction = 1. / self.nNodes  # so you can color the nodes by ID
            for nid, node in sorted(nodes.iteritems()):
                points.InsertPoint(nid - 1, *node)
                self.gridResult.InsertNextValue(nid * fraction)
                #print str(element)

                #elem = vtk.vtkVertex()
                #elem.GetPointIds().SetId(0, i)
                #self.aQuadGrid.InsertNextCell(elem.GetCellType(), elem.GetPointIds())
                #vectorResult.InsertTuple3(0, 0.0, 0.0, 1.0)

        assert nodes is not None
        nnodes, three = nodes.shape

        nid = 0
        print "nnodes=%s" % nnodes
        for i in xrange(nnodes):
            points.InsertPoint(nid, nodes[i, :])
            nid += 1

        nelements, three = elements.shape
        #elements -= 1
        for eid in xrange(nelements):
            elem = vtkTriangle()
            node_ids = elements[eid, :]
            elem.GetPointIds().SetId(0, node_ids[0])
            elem.GetPointIds().SetId(1, node_ids[1])
            elem.GetPointIds().SetId(2, node_ids[2])
            self.grid.InsertNextCell(
                5, elem.GetPointIds())  #elem.GetCellType() = 5  # vtkTriangle

        self.grid.SetPoints(points)
        self.grid.Modified()
        self.grid.Update()
        print("updated grid")

        # loadSTLResults - regions/loads
        self.TurnTextOn()
        self.scalarBar.VisibilityOff()
        self.scalarBar.Modified()

        cases = {}
        ID = 1

        cases = self._fill_stl_case(cases, ID, elements)
        #self.finish_io()
        self.resultCases = cases
        self.caseKeys = sorted(cases.keys())
        #print "caseKeys = ",self.caseKeys
        #print "type(caseKeys) = ",type(self.caseKeys)
        self.nCases = min(0,
                          len(self.resultCases) -
                          1)  # number of keys in dictionary
        self.iCase = 0 if self.nCases == 0 else -1
        self.cycleResults()  # start at nCase=0
Exemple #10
0
def stl_reshape(data):
    if '--xy' not in data:
        data['--xy'] = False
    if '--yz' not in data:
        data['--yz'] = False
    if '--xz' not in data:
        data['--xz'] = False
    if '--scale' not in data:
        data['--scale'] = None

    if '--xscale' not in data:
        data['--xscale'] = None
    if '--yscale' not in data:
        data['--yscale'] = None
    if '--zscale' not in data:
        data['--zscale'] = None

    if '<xshift>' not in data:
        data['<xshift>'] = None
    if '<yshift>' not in data:
        data['<yshift>'] = None
    if '<zshift>' not in data:
        data['<zshift>'] = None

    if '--stats' not in data:
        data['--stats'] = None
    if '--mirror' not in data:
        data['--mirror'] = None
    if '--flip_normals' not in data:
        data['--flip_normals'] = None

    in_stl_filename = data['<in_stl_filename>']
    out_stl_filename = data['<out_stl_filename>']
    assert in_stl_filename != out_stl_filename

    stl = STLReader()
    stl.read_stl(in_stl_filename)

    if data['<fmt>'] in ['False', False]:
        is_binary = True
        fmt = None
    else:
        fmt = data['<fmt>']
        is_binary = False
    print('is_binary=%s' % is_binary)

    if data['--xy'] or data['--yz'] or data['--xz']:
        scale = 1.
        if data['--scale'] is not None:
            scale = float(data['--scale'])

        if data['--xy']:
            assert data['--yz'] is False
            assert data['--xz'] is False
            axes = 'xy'
        elif data['--yz']:
            assert data['--xy'] is False
            assert data['--xz'] is False
            axes = 'yz'
        elif data['--xz']:
            assert data['--xy'] is False
            assert data['--yz'] is False
            axes = 'xz'
        #print('flip_axes = %r' % axes)
        #print(data)
        stl.flip_axes(axes, scale)

    elif data['--xscale'] or data['--yscale'] or data['--zscale']:
        xscale = 1.
        yscale = 1.
        zscale = 1.
        if data['--xscale'] is not None:
            xscale = float(data['--xscale'].strip("'"))
        if data['--yscale'] is not None:
            yscale = float(data['--yscale'].strip("'"))
        if data['--zscale'] is not None:
            zscale = float(data['--zscale'].strip("'"))
        x = deepcopy(stl.nodes[:, 0])
        y = deepcopy(stl.nodes[:, 1])
        z = deepcopy(stl.nodes[:, 2])
        stl.nodes[:, 0] = x * xscale
        stl.nodes[:, 1] = y * yscale
        stl.nodes[:, 2] = z * zscale
    elif data['<xshift>'] or data['<yshift>'] or data['<zshift>']:
        xshift = 1.
        yshift = 1.
        zshift = 1.
        if data['<xshift>'] is not None:
            if isinstance(xshift, basestring):
                xshift = float(data['<xshift>'].strip("'"))
            else:
                xshift = float(data['<xshift>'])

        if data['<yshift>'] is not None:
            if isinstance(xshift, basestring):
                yshift = float(data['<yshift>'].strip("'"))
            else:
                yshift = float(data['<yshift>'])

        if data['<zshift>'] is not None:
            if isinstance(xshift, basestring):
                zshift = float(data['<zshift>'].strip("'"))
            else:
                zshift = float(data['<zshift>'])

        print('delta = (%s, %s, %s)' % (xshift, yshift, zshift))
        stl.nodes[:, 0] += xshift
        stl.nodes[:, 1] += yshift
        stl.nodes[:, 2] += zshift
    elif data['--scale']:
        scale = float(data['--scale'])
        stl.nodes *= scale
    elif data['--stats']:
        xmax, ymax, zmax = stl.nodes.max(axis=0)
        xmin, ymin, zmin = stl.nodes.min(axis=0)
        print('xyz_max = (%g, %g, %g)' % (xmax, ymax, zmax))
        print('xyz_min = (%g, %g, %g)' % (xmin, ymin, zmin))
        return
    elif data['--mirror']:
        #plane = data['plane']
        #assert plane in ['xy', 'yz', 'xz'], 'plane=%r' % plane
        xyz = data['<xyz>']
        tol = float(data['<tol>'])
        stl.create_mirror_model(xyz, tol)
    elif data['--flip_normals']:
        stl.flip_normals()
    else:
        raise RuntimeError('unsupported reshape...data=%s' % data)

    stl.write_stl(out_stl_filename, is_binary=is_binary, float_fmt=fmt)