blender-gdsimporter/import_gds.py

from . import gds 
from concurrent.futures import ThreadPoolExecutor

import importlib
if "gds" in locals():
    gds = importlib.reload(gds)

import pathlib
import bpy
from bpy_extras.wm_utils.progress_report import ProgressReport

class Progressor:
    def __init__(self, wm, precision = 0.0001):
        self.wm = wm
        self.report = 0
        self.precision = precision
        self.next_update = 0

    @property
    def total(self):
        return self.report
    
    @total.setter
    def total(self, t):
        if self.report >= t:
            return

        if self.report:
            self.wm.progress_end()
            self.next_update = 0

        self.wm.progress_begin(0, t)
        self.report = t

    @property
    def current(self):
        return 0

    @current.setter
    def current(self, c):
        prog = float(c)/self.total
        if prog >= self.next_update:
            self.next_update = prog + self.precision
            self.wm.progress_update(c)

    def end(self):
        if self.report:
            self.report = 0
            self.next_update = 0 

            self.wm.progress_end()

    def __call__(self, update):
        self.total = update.total
        self.current = update.current

class SceneInserter(object):   
    class Layer(object):
        def __init__(self, context, number, thickness=1, datatypes=[], ):
            self.number  = number
            self.context = context

            # stackup results
            self.thickness = thickness
            self.absolute_height = 0

            # stackup 
            self.Prev = None
            self.Next = None

            self.groups = {}
            self.materials = {}
            
            for datatype in datatypes:
                self.new_datatype(type)
        
        def name_for_layer(self, datatype):
            return "layer{}/{}".format(self.number, datatype)

        def new_datatype(self, datatype):
            name = self.name_for_layer(datatype)

            if name not in bpy.data.groups:
                # create new group
                self.groups[datatype] = bpy.data.groups.new(name)
            else:
                self.groups[datatype] = bpy.data.groups[name]

            if name not in bpy.data.materials:
                self.materials[name]  = bpy.data.materials.new(name)
            else:
                self.materials[name]  = bpy.data.materials[name]
            

        def group_for_datatype(self, dtype):
            if dtype not in self.groups:
                self.new_datatype(dtype)

            return self.groups[dtype]

        def insert_after(self, other):
            end = self
        
            while end.Next:
                end = end.Next
                
            if self.Prev:
                self.Prev.Next = None

            self.Prev = None
            
            # link own list to new list
            if other.Next:
                if other.Next.Prev:
                    other.Next.Prev = end

                end.Next = other.Next

            other.Next = self
            self.Prev = other
            
            # recalc height
            end = self
            while end:
                end.absolute_height = end.Prev.absolute_height + end.Prev.thickness
                end = end.Next

            return self
            

        def link(self, datatype, obj):
            self.group_for_datatype(datatype).objects.link(obj)
            
            mat = self.materials[self.name_for_layer(datatype)]
            obj.data.materials.append(mat)
            

    def __init__(self, context, lib, ignore_structures={}, top_cell=None):
            self.lib = lib
            self.context = context

            self.layers = {}
            self.ignore_structures = {}
            
            self.add_stackup()

            self.top_cell = top_cell
            if top_cell == "":
                self.top_cell = None
                
            if self.top_cell:
                self.top_cell = self.top_cell.strip()
                return

            for sname in ignore_structures:
                if sname in lib.structures:
                    self.ignore_structures[sname] = True

    def add_layer(self, number, thickness=1):
        self.layers[number] = SceneInserter.Layer(self.context, number, thickness)
        return self.layers[number]

    def get_layer(self, number):
        if number not in self.layers:
            return self.add_layer(number)
        
        return self.layers[number]

    def add_stackup(self):
        prev = None
        for i in range(0,200):
            l = self.add_layer(i)
            if prev:
                l.insert_after(prev)
            prev = l

        # example stackup for now
        #self.add_layer(8).insert_after(self.add_layer(6).insert_after(self.add_layer(5).insert_after(self.add_layer(4))))
        
    def new_empty(self, name):
        obj = bpy.data.objects.new(name, None)
        self.link(obj)
        return obj

    def link(self, obj):
        self.context.scene.objects.link(obj)

    def build_path_element(self, name, root, element):
        # build path profile
        widthcurve = bpy.data.curves.new("profile-" + name , "CURVE")
        bevelobj   = bpy.data.objects.new("profile-" + name , widthcurve)
        bevelobj.parent = root

        # hide the bevel object
        self.link(bevelobj)
        
        bevelobj.hide = True
        bevelobj.hide_render = True

        widthspline = widthcurve.splines.new("POLY")
        widthspline.use_smooth = False
        widthspline.use_cyclic_u = True
        widthspline.points.add(3)

        # create bevel profile
        width = element.width * self.lib.units_per_dbunit
        thickness = self.get_layer(element.layer).thickness
        
        widthspline.points[0].co = (-1*width/2.0,    thickness/2.0, 0,0)
        widthspline.points[1].co = (   width/2.0,    thickness/2.0, 0,0)
        widthspline.points[2].co = (   width/2.0, -1*thickness/2.0, 0,0)
        widthspline.points[3].co = (-1*width/2.0, -1*thickness/2.0, 0,0)

        # create actual path
        pathcurve = bpy.data.curves.new(name, "CURVE")
        
        pathcurve.use_fill_caps = True
        pathcurve.bevel_object = bevelobj

        pathspline = pathcurve.splines.new("POLY")
        pathspline.points.add(len(element.points)-1)
        pathspline.use_smooth = False
        
        # import path
        for i, p in enumerate(element.points):
            pos = self.lib.normalize_coord(p)
            pathspline.points[i].co = (pos[0], pos[1], 0,0)

        # setup pathobject
        pathobj = bpy.data.objects.new(name, pathcurve)
        self.link(pathobj)
        self.get_layer(element.layer).link(element.datatype, pathobj)

        pathobj.location.z = self.get_layer(element.layer).absolute_height
        pathobj.parent = root

    def build_object(self, structure, progress=None):
        # is the object already existent => return new instance
        if structure.name in bpy.data.objects:
            return self.new_instance(bpy.data.objects[structure.name])

        if progress:
            progress.total += 1 + len(structure.references)

        # for boundary elements
        class Mesh:
            def __init__(self):
                self.verts = []
                self.faces = []
        
        boundaries = {}
        
        # create control empty
        root = self.new_empty(structure.name)

        # reset name in case blender 
        # changes the object name
        # (e.g. due to duplicates)
        structure.name = root.name

        #print("structure name: {}".format(structure.name))

        # add all geometry
        for number, element in enumerate(structure.elements):
            index = (element.layer, element.datatype)
            if isinstance(element, gds.Boundary):
                # every element should be of derived of gds.Drawable
                if index not in boundaries:
                    boundaries[index] = Mesh()
                    
                indices = []
                for point in element.points[:-1]:
                    pos = self.lib.normalize_coord(point)
                    boundaries[index].verts.append((pos[0], pos[1], 0))
                    indices.append(len(boundaries[index].verts)-1)

                boundaries[index].faces.append(tuple(indices))

            elif isinstance(element, gds.Path):
                cname = "{}-{}[{}]".format(structure.name, number, element.layer)
                self.build_path_element(cname, root, element)

            else:
                print("import of {} not implemented".format(type(element)))

        with ThreadPoolExecutor(max_workers=5) as executor:
            # build structure mesh for boundary elements
            for ident, template in boundaries.items():
                def do_boundary(layerident, meshtemplate):
                    layer = self.get_layer(layerident[0])
                    meshname = "{}[{}]".format(structure.name, layerident)

                    mesh = bpy.data.meshes.new(meshname)
                    mesh.from_pydata(meshtemplate.verts, [], meshtemplate.faces)
                    mesh.update()

                    obj = bpy.data.objects.new(meshname, mesh)
                    self.link(obj)
                    layer.link(layerident[1], obj)
                    obj.parent = root

                    # create solifiy modifier
                    mod = obj.modifiers.new("Solidify", 'SOLIDIFY')
                    mod.thickness = 1 # probaly meters ?
                    mod.use_even_offset = True
                    mod.offset = 0
                    obj.location.z = layer.absolute_height

                executor.submit(do_boundary, ident, template)                

        if progress:
            progress.inc()

        # handle all references
        # build tree depth first
        for reference in structure.references:
            if isinstance(reference.structure, str):
                if reference.structure not in self.lib.structures:
                    progress.inc()
                    continue

                # resolve structure
                reference.structure = self.lib.structures[reference.structure]

            obj = self.build_object(reference.structure, progress=progress)
                
            if hasattr(reference, "size"):
                # this is an Array reference
                def add(a,b):
                    return (a[0] + b[0], a[1] + b[1])
                def inv(a):
                    return (-a[0], -a[1])

                def sub(a, b):
                    return add(inv(a), b)
                def scale(a, f):
                    return (a[0] * f, a[1] * f)

                vx = sub(reference.bounds[0], reference.position)
                vy = sub(reference.bounds[1], reference.position)
                
                xspace = scale(vx, 1.0/reference.size[0] * self.lib.units_per_dbunit)
                yspace = scale(vy, 1.0/reference.size[1] * self.lib.units_per_dbunit)

                # use array modifiers to create the aref array
                for child in obj.children:
                    mod_x = child.modifiers.new("ax", "ARRAY")
                    
                    mod_x.use_constant_offset = True
                    mod_x.use_relative_offset = False
                    mod_x.constant_offset_displace[0] = xspace[0]
                    mod_x.constant_offset_displace[1] = xspace[1]
                    mod_x.count = reference.size[0]

                    mod_y = child.modifiers.new("ay", "ARRAY")

                    mod_y.use_constant_offset = True
                    mod_y.use_relative_offset = False
                    mod_y.constant_offset_displace[0] = yspace[0]
                    mod_y.constant_offset_displace[1] = yspace[1]
                    mod_y.count = reference.size[1]
            else:
                # this is a single reference
                # just copy the object
                pass

            # use single arrow for references
            obj.empty_draw_type = "SINGLE_ARROW"
            
            # reparent new instance
            obj.parent = root

            pos = self.lib.normalize_coord(reference.position)
            obj.location = (pos[0], pos[1], 0)

            # apply transformations
            trans = reference.transformation
            obj.rotation_euler.z = math.radians(trans.rotation)
            obj.scale = (trans.zoom, trans.zoom, 1)

            if progress:
                progress.inc()

        return root

    def new_instance(self, obj):
        root = obj.copy()
        self.link(root)

        for child in obj.children:
            if child.name.find("profile") != -1:
                # only copy path profiles
                continue

            childObj = child.copy()
            childObj.parent = root
            self.link(childObj)
            
            # relink copy to groups
            for group in child.users_group:
                group.objects.link(childObj)

            # resetup curves
            if childObj.type == "CURVE":
                for spline in childObj.data.splines:
                    spline.use_smooth = False

                
                # copy profile
                profile = bpy.data.objects["profile-" + child.name].copy()
                profile.parent = root
                self.link(profile)

                # resetup path
                childObj.data.use_fill_caps = True
                childObj.data.bevel_object = profile

        return root

    
    def __call__(self, progress=None):
        class ProgressTracker:
            def __init__(self, callback, total=0):
                self.total = total
                self.current = 0
                self.callback = callback
            
            def inc(self):
                if self.callback:
                    self.current += 1
                    self.callback(self)

        
        # build one cell only
        if self.top_cell:
            if self.top_cell not in self.lib.structures:
                return None
            s = self.lib.structures[self.top_cell]

            progressTracker = ProgressTracker(progress, 1+len(s.references))
            self.build_object(s,progress=progressTracker)

            return True

        progressTracker = ProgressTracker(progress)
        progressTracker.total = len(self.lib.structures)

        # self.link_all_refs(progressTracker)
        
        # build all structures first
        # since references could reference unknown objects otherwise
        for name, value in self.lib.structures.items():
            progressTracker.inc()
            if name in self.ignore_structures:
                continue

            self.build_object(value, progress=progressTracker)
                       
            
        return True
                
import math

def load(context,
         filepath,
         *,
         top_cell_name=""
         ):

    lib = None
    
    with ProgressReport(context.window_manager) as progress:
        progress.enter_substeps(2, "Importing GDS %r..." % filepath)
        prog = Progressor(context.window_manager)
        with open(filepath, "rb") as f:
            lib = gds.parse_file(f, progress_func=prog)
    
        progress.step("linking references")
        prog.end()

        if not SceneInserter(context=context, lib=lib, top_cell=top_cell_name)(prog):
            return {"CANCELLED"}

        progress.leave_substeps("Done")
        prog.end()

        context.scene.update()
        

    return {"FINISHED"}