scr2_cube_tri_div.py

import numpy 
import itertools

class BoxGen(SvScriptSimpleGenerator):
    inputs = [
        ("s", "Size", 1.0),
        ("s", "divx", 10),
        ("s", "divy", 10),
        ("s", "divz", 10)]                            
    outputs = [
        ("v", "verts", "make_verts"),
        ("s", "edges", "make_edges"),
        ("s", "faces", "make_faces")]

    @staticmethod
    def make_verts(size, divx, divy, divz):
        size /= 2
        sidex = numpy.linspace(-size, size, divx)
        sidey = numpy.linspace(-size, size, divy)
        sidez = numpy.linspace(-size, size, divz)
        plane = lambda z: [(x, y, z) for x in sidex[1:-1] for y in sidey[1:-1]]
        
        base = plane(-size)
        top = plane(size)
        mid = []
        add_mid = mid.append

        for z in sidez:
            # side 1 
            for y in sidey:
                add_mid(tuple((sidex[0],y,z)))
                
            # side 2
            for x in sidex[1:-1]:
                add_mid(tuple((x,sidey[-1],z)))
                
            # side 3
            for y in sidey[::-1]:
                add_mid(tuple((sidex[-1],y,z)))

            # side 4
            for x in sidex[1:-1][::-1]:
                add_mid(tuple((x,sidey[0],z)))

        return [mid + base + top]


    @staticmethod
    def make_edges(size, divx, divy, divz):
       
        edges = []
        
        return edges

    @classmethod
    def roll_around(cls, direction, outside, inside, divx, divy, num_iplanar):
        final_list = []
        final_list.append(outside[0:divy])

        stride = divy-2
        for idx, i in enumerate(range(0, num_iplanar, stride)):
            side1 = outside[-(idx+1)]
            side2 = outside[divy+idx]
            final_list.append([side1] + inside[i:i+stride] + [side2])

        opposite = divy + (divx-2)
        final_list.append(outside[opposite:opposite+divy][::-1])

        face_list = []
        for i in range(divx-1):
            for j in range(divy-1):
                top_row = final_list[i][j:j+2]
                low_row = [final_list[i+1][j+1], final_list[i+1][j]]
                storage = top_row + low_row
                if direction == 'ccw':
                    storage = storage[::-1]
                face_list.append(storage)
        return face_list

    @staticmethod
    def make_faces(size, divx, divy, divz):
        z_spread = (divx+divx+divy+divy) - 4
        faces = []
        idx = 0
        
        # per z ring, loop and closing extend
        for z_ring in range(divz-1):
            offset = z_spread * z_ring
            for idx in range(z_spread-1):
                i = idx + offset
                faces.extend([[i, i+1, i+1+z_spread, i+z_spread]])

            faces.extend([[
                z_spread - 1 + offset, 
                offset, 
                z_spread + offset, 
                z_spread + z_spread -1 + offset
                ]])

        top_max = divz * z_spread
        top_outer_ring = list(range(top_max-(z_spread), top_max))
        bottom_outer_ring = list(range(0, z_spread))

        # num internal planar
        num_iplanar = (divx-2) * (divy-2)

        # book keeping        
        num_verts_bass = divx * divy
        num_verts_ring = len(top_outer_ring)
        num_verts_ring_total = (divz - 2) * num_verts_ring
        last_vertex_idx = (num_verts_bass * 2) + num_verts_ring_total

        top_internal = list(range(last_vertex_idx-num_iplanar, last_vertex_idx))
        bottom_internal = [i-num_iplanar for i in top_internal]

        f = BoxGen.roll_around('cw',
            top_outer_ring, top_internal, divx, divy, num_iplanar)
        faces.extend(f)

        f = BoxGen.roll_around('ccw',
            bottom_outer_ring, bottom_internal, divx, divy, num_iplanar)
        faces.extend(f)
        
        return faces