io_import_gimp_image_to_scene.py

# ##### BEGIN GPL LICENSE BLOCK #####
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License
#  as published by the Free Software Foundation; either version 2
#  of the License, or (at your option) any later version.
#
#  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 General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software Foundation,
#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####

bl_info = {
    "name": "Import GIMP Image to Scene (.xcf/.xjt)",
    "author": "Daniel Salazar (ZanQdo)",
    "version": (2, 0, 1),
    "blender": (2, 73, 0),
    "location": "File > Import > GIMP Image to Scene(.xcf/.xjt)",
    "description": "Imports GIMP multilayer image files as a series of multiple planes",
    "warning": "XCF import requires xcftools installed",
    "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/"
                "Scripts/Import-Export/GIMPImageToScene",
    "category": "Import-Export",
}

"""
This script imports GIMP layered image files into 3D Scenes (.xcf, .xjt)
"""

def main(report, File, Path, LayerViewers, MixerViewers, LayerOffset,
         LayerScale, OpacityMode, AlphaMode, ShadelessMats,
         SetCamera, SetupCompo, GroupUntagged, Ext):
    
    #-------------------------------------------------
    
    #Folder = '['+File.rstrip(Ext)+']'+'_images/'
    Folder = 'images_'+'['+File.rstrip(Ext)+']/'
    
    if not bpy.data.is_saved:
        PathSaveRaw = Path+Folder
        PathSave = PathSaveRaw.replace(' ', '\ ')
        try: os.mkdir(PathSaveRaw)
        except: pass
    else:
        PathSave = bpy.data.filepath
        RSlash = PathSave.rfind('/')
        PathSaveRaw = PathSave[:RSlash+1]+Folder
        PathSave = PathSaveRaw.replace(' ', '\ ')
        try: os.mkdir(PathSaveRaw)
        except: pass
        PathSaveRaw = bpy.path.relpath(PathSaveRaw)+'/'
    
    PathRaw = Path
    Path = Path.replace(' ', '\ ')
    if Ext == '.xjt':
        ExtSave = '.jpg'
        #-------------------------------------------------
        # EXTRACT XJT
        import tarfile
        
        IMG = tarfile.open ('%s%s' % (PathRaw, File))
        PRP = IMG.extractfile('PRP')
        
        Members = IMG.getmembers()
        
        for Member in Members:
            Name = Member.name
            if Name.startswith('l') and Name.endswith('.jpg'):
                IMG.extract(Name, path=PathSaveRaw)
        
        #-------------------------------------------------
        # INFO XJT
        IMGs = []
        for Line in PRP.readlines():
            Line = str(Line)
            
            if Line.startswith("b'GIMP_XJ_IMAGE"):
                for Segment in Line.split():
                    if Segment.startswith('w/h:'):
                        ResX, ResY = map (int, Segment[4:].split(','))
            if Line.startswith(("b'L", "b'l")):
                
                """The "nice" method to check if layer has alpha channel
                sadly GIMP sometimes decides not to export an alpha channel
                if it's pure white so we are not completly sure here yet"""
                if Line.startswith("b'L"): HasAlpha = True
                else: HasAlpha = False
                
                md = None
                op = 1
                ox, oy = 0,0
                
                for Segment in Line.split():
                    
                    if Segment.startswith("b'"):
                        imageFile = 'l' + Segment[3:] + '.jpg'
                        imageFileAlpha ='la'+Segment[3:]+'.jpg'
                        
                        """Phisically double checking if alpha image exists
                        now we can be sure! (damn GIMP)"""
                        if HasAlpha:
                            if not os.path.isfile(PathSaveRaw+imageFileAlpha): HasAlpha = False
                        
                        # Get Widht and Height from images
                        data = open(PathSaveRaw+imageFile, "rb").read()
                        
                        hexList = []
                        for ch in data:
                            byt = "%02X" % ch
                            hexList.append(byt)
                        
                        for k in range(len(hexList)-1):
                            if hexList[k] == 'FF' and (hexList[k+1] == 'C0' or hexList[k+1] == 'C2'):
                                ow = int(hexList[k+7],16)*256 + int(hexList[k+8],16)
                                oh = int(hexList[k+5],16)*256 + int(hexList[k+6],16)
                    
                    elif Segment.startswith('md:'): # mode
                        md = Segment[3:]
                        
                    elif Segment.startswith('op:'): # opacity
                        op = float(Segment[3:])*.01
                    
                    elif Segment.startswith('o:'): # origin
                        ox, oy = map(int, Segment[2:].split(','))
                    
                    elif Segment.startswith('n:'): # name
                        n = Segment[3:-4]
                        OpenBracket = n.find ('[')
                        CloseBracket = n.find (']')
                        
                        if OpenBracket != -1 and CloseBracket != -1:
                            RenderLayer = n[OpenBracket+1:CloseBracket]
                            NameShort = n[:OpenBracket]
                            
                        else:
                            RenderLayer = n
                            NameShort = n
                        
                        os.rename(PathSaveRaw+imageFile, PathSaveRaw+NameShort+'.jpg')
                        if HasAlpha: os.rename(PathSaveRaw+imageFileAlpha, PathSaveRaw+NameShort+'_A'+'.jpg')
                        
                IMGs.append({'LayerMode':md, 'LayerOpacity':op,
                            'LayerName':n, 'LayerNameShort':NameShort,
                            'RenderLayer':RenderLayer, 'LayerCoords':[ow, oh, ox, oy], 'HasAlpha':HasAlpha})
    
    else: # Ext == '.xcf':
        ExtSave = '.png'
        #-------------------------------------------------
        # CONFIG
        XCFInfo = 'xcfinfo'
        XCF2PNG = 'xcf2png'
        #-------------------------------------------------
        # INFO XCF

        try:
            Info = subprocess.check_output((XCFInfo, Path+File))
        except FileNotFoundError as e:
            if XCFInfo in str(e):
                report({'ERROR'}, "Please install xcftools, xcfinfo seems to be missing (%s)" % str(e))
                return False
            else:
                raise e

        Info = Info.decode()
        IMGs = []
        for Line in Info.split('\n'):
            if Line.startswith ('+'):
                
                Line = Line.split(' ', 4)
                
                RenderLayer = Line[4]
                
                OpenBracket = RenderLayer.find ('[')
                CloseBracket = RenderLayer.find (']')
                
                if OpenBracket != -1 and CloseBracket != -1:
                    RenderLayer = RenderLayer[OpenBracket+1:CloseBracket]
                    NameShort = Line[4][:OpenBracket]
                else:
                    NameShort = Line[4].rstrip()
                    if GroupUntagged:
                        RenderLayer = '__Undefined__'
                    else:
                        RenderLayer = NameShort
                
                LineThree = Line[3]
                Slash = LineThree.find('/')
                if Slash == -1:
                    Mode = LineThree
                    Opacity = 1
                else:
                    Mode = LineThree[:Slash]
                    Opacity = float(LineThree[Slash+1:LineThree.find('%')])*.01
                
                IMGs.append ({
                    'LayerMode': Mode,
                    'LayerOpacity': Opacity,
                    'LayerName': Line[4].rstrip(),
                    'LayerNameShort': NameShort,
                    'LayerCoords': list(map(int, Line[1].replace('x', ' ').replace('+', ' +').replace('-', ' -').split())),
                    'RenderLayer': RenderLayer,
                    'HasAlpha': True,
                    })
            elif Line.startswith('Version'):
                ResX, ResY = map (int, Line.split()[2].split('x'))
        
        #-------------------------------------------------
        # EXTRACT XCF
        if OpacityMode == 'BAKE':
            Opacity = ()
        else:
            Opacity = ("--percent", "100")
        xcf_path = Path + File
        for Layer in IMGs:
            png_path = "%s%s.png" % (PathSave, Layer['LayerName'].replace(' ', '_'))
            subprocess.call((XCF2PNG, "-C", xcf_path, "-o", png_path, Layer['LayerName']) + Opacity)
    
    #-------------------------------------------------
    Scene = bpy.context.scene
    #-------------------------------------------------
    # CAMERA
    
    if SetCamera:
        bpy.ops.object.camera_add(location=(0, 0, 10))
        
        Camera = bpy.context.active_object.data
        
        Camera.type = 'ORTHO'
        Camera.ortho_scale = ResX * .01
    
    #-------------------------------------------------
    # RENDER SETTINGS
    
    Render = Scene.render
    
    if SetCamera:
        Render.resolution_x = ResX
        Render.resolution_y = ResY
        Render.resolution_percentage = 100
    Render.alpha_mode = 'TRANSPARENT'
    
    #-------------------------------------------------
    # 3D VIEW SETTINGS
    
    Scene.game_settings.material_mode = 'GLSL'
    
    Areas = bpy.context.screen.areas
    
    for Area in Areas:
        if Area.type == 'VIEW_3D':
            Area.spaces.active.viewport_shade = 'TEXTURED'
            Area.spaces.active.show_textured_solid = True
            Area.spaces.active.show_floor = False
    
    #-------------------------------------------------
    # 3D LAYERS
    
    def Make3DLayer (Name, NameShort, Z, Coords, RenderLayer, LayerMode, LayerOpacity, HasAlpha):
        
        # RenderLayer
        
        if SetupCompo:
            if not bpy.context.scene.render.layers.get(RenderLayer):
                
                bpy.ops.scene.render_layer_add()
                
                LayerActive = bpy.context.scene.render.layers.active
                LayerActive.name = RenderLayer
                LayerActive.use_pass_vector = True
                LayerActive.use_sky = False
                LayerActive.use_edge_enhance = False
                LayerActive.use_strand = False
                LayerActive.use_halo = False
                
                global LayerNum
                for i in range (0,20):
                    if not i == LayerNum:
                        LayerActive.layers[i] = False
                
                bpy.context.scene.layers[LayerNum] = True
                
                LayerFlags[RenderLayer] = bpy.context.scene.render.layers.active.layers
                
                LayerList.append([RenderLayer, LayerMode, LayerOpacity])
                
                LayerNum += 1

        # Object
        bpy.ops.mesh.primitive_plane_add(view_align=False,
                                         enter_editmode=False,
                                         rotation=(0, 0, 0))

        bpy.ops.object.transform_apply(location=False, rotation=True, scale=False)

        
        Active = bpy.context.active_object
        
        if SetupCompo:
            Active.layers = LayerFlags[RenderLayer]
        
        Active.location = (
            (float(Coords[2])-(ResX*0.5))*LayerScale,
            (-float(Coords[3])+(ResY*0.5))*LayerScale, Z)
        
        for Vert in Active.data.vertices:
            Vert.co[0] += 1
            Vert.co[1] += -1
            
        Active.dimensions = float(Coords[0])*LayerScale, float(Coords[1])*LayerScale, 0
        
        bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)
        
        bpy.ops.object.origin_set(type='ORIGIN_GEOMETRY', center='MEDIAN')
        
        Active.show_wire = True
        
        Active.name = NameShort
        bpy.ops.mesh.uv_texture_add()
        
        # Material
        
        '''if bpy.data.materials.get(NameShort):
            Mat = bpy.data.materials[NameShort]
            if not Active.material_slots:
                bpy.ops.object.material_slot_add()
            Active.material_slots[0].material = Mat
        else:'''
        
        Mat = bpy.data.materials.new(NameShort)
        Mat.diffuse_color = (1,1,1)
        Mat.use_raytrace = False
        Mat.use_shadows = False
        Mat.use_cast_buffer_shadows = False
        Mat.use_cast_approximate = False
        if HasAlpha:
            Mat.use_transparency = True
            if OpacityMode == 'MAT': Mat.alpha = LayerOpacity
            else: Mat.alpha = 0
        if ShadelessMats: Mat.use_shadeless = True
        
        if Ext == '.xcf':
            # Color & Alpha PNG
            Tex = bpy.data.textures.new(NameShort, 'IMAGE')
            Tex.extension = 'CLIP'
            Tex.use_preview_alpha = True
            
            Img = bpy.data.images.new(NameShort, 128, 128)
            Img.source = 'FILE'
            Img.alpha_mode = AlphaMode
            Img.filepath = '%s%s%s' % (PathSaveRaw, Name, ExtSave)
            
            UVFace = Active.data.uv_textures[0].data[0]
            UVFace.image = Img
            
            Tex.image = Img
            
            Mat.texture_slots.add()
            TexSlot = Mat.texture_slots[0]
            TexSlot.texture = Tex
            TexSlot.use_map_alpha = True
            TexSlot.texture_coords = 'UV'
            if OpacityMode == 'TEX': TexSlot.alpha_factor = LayerOpacity
            elif OpacityMode == 'MAT': TexSlot.blend_type = 'MULTIPLY'
        
        else: # Ext == '.xjt'
            # Color JPG
            Tex = bpy.data.textures.new(NameShort, 'IMAGE')
            Tex.extension = 'CLIP'
            
            Img = bpy.data.images.new(NameShort, 128, 128)
            Img.source = 'FILE'
            Img.filepath = '%s%s%s' % (PathSaveRaw, Name, ExtSave)
            
            UVFace = Active.data.uv_textures[0].data[0]
            UVFace.image = Img
            
            Tex.image = Img
            
            Mat.texture_slots.add()
            TexSlot = Mat.texture_slots[0]
            TexSlot.texture = Tex
            TexSlot.texture_coords = 'UV'
            
            if HasAlpha:
                # Alpha JPG
                Tex = bpy.data.textures.new(NameShort+'_A', 'IMAGE')
                Tex.extension = 'CLIP'
                Tex.use_preview_alpha = True
                
                Img = bpy.data.images.new(NameShort+'_A', 128, 128)
                Img.source = 'FILE'
                Img.alpha_mode = AlphaMode
                Img.filepath = '%s%s_A%s' % (PathSaveRaw, Name, ExtSave)
                Img.use_alpha = False
                
                Tex.image = Img
                
                Mat.texture_slots.add()
                TexSlot = Mat.texture_slots[1]
                TexSlot.texture = Tex
                TexSlot.use_map_alpha = True
                TexSlot.use_map_color_diffuse = False
                TexSlot.texture_coords = 'UV'
                if OpacityMode == 'TEX': TexSlot.alpha_factor = LayerOpacity
                elif OpacityMode == 'MAT': TexSlot.blend_type = 'MULTIPLY'
        
        if not Active.material_slots:
            bpy.ops.object.material_slot_add()
        
        Active.material_slots[0].material = Mat


    Z = 0
    global LayerNum
    LayerNum = 0
    LayerFlags = {}
    LayerList = []
    
    for Layer in IMGs:
        Make3DLayer(Layer['LayerName'].replace(' ', '_'),
                    Layer['LayerNameShort'].replace(' ', '_'),
                    Z,
                    Layer['LayerCoords'],
                    Layer['RenderLayer'],
                    Layer['LayerMode'],
                    Layer['LayerOpacity'],
                    Layer['HasAlpha'],
                    )
        
        Z -= LayerOffset
    
    if SetupCompo:
        #-------------------------------------------------
        # COMPO NODES
        
        Scene.use_nodes = True
        
        Tree = Scene.node_tree
        
        for i in Tree.nodes:
            Tree.nodes.remove(i)
        
        LayerList.reverse()
        
        Offset = 0
        LayerLen = len(LayerList)
        
        for Layer in LayerList:
            
            Offset += 1
            
            X_Offset = (500*Offset)
            Y_Offset = (-300*Offset)
            
            Node = Tree.nodes.new('CompositorNodeRLayers')
            Node.location = (-500+X_Offset, 300+Y_Offset)
            Node.name = 'R_'+ str(Offset)
            Node.scene = Scene
            Node.layer = Layer[0]
            
            if LayerViewers:
                Node_V = Tree.nodes.new('CompositorNodeViewer')
                Node_V.name = Layer[0]
                Node_V.location = (-200+X_Offset, 200+Y_Offset)
                
                Tree.links.new(Node.outputs[0], Node_V.inputs[0])
            
            if LayerLen > Offset:
                
                Mode = LayerList[Offset][1] # has to go one step further
                LayerOpacity = LayerList[Offset][2]
                
                if not Mode in {'Normal', '-1'}:
                    
                    Node = Tree.nodes.new('CompositorNodeMixRGB')
                    if OpacityMode == 'COMPO': Node.inputs['Fac'].default_value = LayerOpacity
                    else: Node.inputs['Fac'].default_value = 1
                    Node.use_alpha = True
                    
                    if Mode in {'Addition', '7'}: Node.blend_type = 'ADD'
                    elif Mode in {'Subtract', '8'}: Node.blend_type = 'SUBTRACT'
                    elif Mode in {'Multiply', '3'}: Node.blend_type = 'MULTIPLY'
                    elif Mode in {'DarkenOnly', '9'}: Node.blend_type = 'DARKEN'
                    elif Mode in {'Dodge', '16'}: Node.blend_type = 'DODGE'
                    elif Mode in {'LightenOnly', '10'}: Node.blend_type = 'LIGHTEN'
                    elif Mode in {'Difference', '6'}: Node.blend_type = 'DIFFERENCE'
                    elif Mode in {'Divide', '15'}: Node.blend_type = 'DIVIDE'
                    elif Mode in {'Overlay', '5'}: Node.blend_type = 'OVERLAY'
                    elif Mode in {'Screen', '4'}: Node.blend_type = 'SCREEN'
                    elif Mode in {'Burn', '17'}: Node.blend_type = 'BURN'
                    elif Mode in {'Color', '13'}: Node.blend_type = 'COLOR'
                    elif Mode in {'Value', '14'}: Node.blend_type = 'VALUE'
                    elif Mode in {'Saturation', '12'}: Node.blend_type = 'SATURATION'
                    elif Mode in {'Hue', '11'}: Node.blend_type = 'HUE'
                    elif Mode in {'Softlight', '19'}: Node.blend_type = 'SOFT_LIGHT'
                    else: pass
                    
                else:
                    Node = Tree.nodes.new('CompositorNodeAlphaOver')
                    if OpacityMode == 'COMPO': Node.inputs['Fac'].default_value = LayerOpacity
                Node.name = 'M_' + str(Offset)
                Node.location = (300+X_Offset, 250+Y_Offset)
                
                if MixerViewers:
                    Node_V = Tree.nodes.new('CompositorNodeViewer')
                    Node_V.name = Layer[0]
                    Node_V.location = (500+X_Offset, 350+Y_Offset)
                    
                    Tree.links.new(Node.outputs[0], Node_V.inputs[0])
                
            else:
                Node = Tree.nodes.new('CompositorNodeComposite')
                Node.name = 'Composite'
                Node.location = (400+X_Offset, 350+Y_Offset)
                
        Nodes = bpy.context.scene.node_tree.nodes
        
        if LayerLen > 1:
            for i in range (1, LayerLen + 1):
                if i == 1:
                    Tree.links.new(Nodes['R_'+str(i)].outputs[0], Nodes['M_'+str(i)].inputs[1])
                if 1 < i < LayerLen:
                    Tree.links.new(Nodes['M_'+str(i-1)].outputs[0], Nodes['M_'+str(i)].inputs[1])
                if 1 < i < LayerLen+1:
                    Tree.links.new(Nodes['R_'+str(i)].outputs[0], Nodes['M_'+str(i-1)].inputs[2])
                if i == LayerLen:
                    Tree.links.new(Nodes['M_'+str(i-1)].outputs[0], Nodes['Composite'].inputs[0])
        else:
            Tree.links.new(Nodes['R_1'].outputs[0], Nodes['Composite'].inputs[0])
        
        for i in Tree.nodes:
            i.location[0] += -250*Offset
            i.location[1] += 150*Offset

    return True

#------------------------------------------------------------------------
import os, subprocess
import bpy
from bpy.props import *
from math import pi

# Operator
class GIMPImageToScene(bpy.types.Operator):
    """"""
    bl_idname = "import.gimp_image_to_scene"
    bl_label = "GIMP Image to Scene"
    bl_description = "Imports GIMP multilayer image files into 3D Scenes"
    bl_options = {'REGISTER', 'UNDO'}
    
    filename = StringProperty(name="File Name",
        description="Name of the file")
    directory = StringProperty(name="Directory",
        description="Directory of the file")
    
    LayerViewers = BoolProperty(name="Layer Viewers",
        description="Add Viewer nodes to each Render Layer node",
        default=True)
    
    MixerViewers = BoolProperty(name="Mixer Viewers",
        description="Add Viewer nodes to each Mix node",
        default=True)
    
    AlphaMode = EnumProperty(name="Alpha Mode",
        description="Representation of alpha information in the RGBA pixels",
        items=(
            ('STRAIGHT', 'Texture Alpha Factor', 'Transparent RGB and alpha pixels are unmodified'),
            ('PREMUL', 'Material Alpha Value', 'Transparent RGB pixels are multiplied by the alpha channel')),
        default='STRAIGHT')

    ShadelessMats = BoolProperty(name="Shadeless Material",
        description="Set Materials as Shadeless",
        default=True)
    
    OpacityMode = EnumProperty(name="Opacity Mode",
        description="Layer Opacity management",
        items=(
            ('TEX', 'Texture Alpha Factor', ''),
            ('MAT', 'Material Alpha Value', ''),
            ('COMPO', 'Mixer Node Factor', ''),
            ('BAKE', 'Baked in Image Alpha', '')),
        default='TEX')
    
    SetCamera = BoolProperty(name="Set Camera",
        description="Create an Ortho Camera matching image resolution",
        default=True)
        
    SetupCompo = BoolProperty(name="Setup Node Compositing",
        description="Create a compositing node setup (will delete existing nodes)",
        default=False)
    
    GroupUntagged = BoolProperty(name="Group Untagged",
        description="Layers with no tag go to a single Render Layer",
        default=False)
    
    LayerOffset = FloatProperty(name="Layer Separation",
        description="Distance between each 3D Layer in the Z axis",
        min=0,
        default=0.50)
    
    LayerScale = FloatProperty(name="Layer Scale",
        description="Scale pixel resolution by Blender units",
        min=0,
        default=0.01)
    
    def draw(self, context):
        layout = self.layout
        
        box = layout.box()
        box.label('3D Layers:', icon='SORTSIZE')
        box.prop(self, 'SetCamera', icon='OUTLINER_DATA_CAMERA')
        box.prop(self, 'OpacityMode', icon='GHOST')
        if self.OpacityMode == 'COMPO' and self.SetupCompo == False:
            box.label('Tip: Enable Node Compositing', icon='INFO')
        box.prop(self, 'AlphaMode', icon='IMAGE_RGB_ALPHA')
        box.prop(self, 'ShadelessMats', icon='SOLID')
        box.prop(self, 'LayerOffset')
        box.prop(self, 'LayerScale')
        
        box = layout.box()
        box.label('Compositing:', icon='RENDERLAYERS')
        box.prop(self, 'SetupCompo', icon='NODETREE')
        if self.SetupCompo:
            box.prop(self, 'GroupUntagged', icon='IMAGE_ZDEPTH')
            box.prop(self, 'LayerViewers', icon='NODE')
            box.prop(self, 'MixerViewers', icon='NODE')
    
    def execute(self, context):
        # File Path
        filename = self.filename
        directory = self.directory
        
        # Settings
        LayerViewers = self.LayerViewers
        MixerViewers = self.MixerViewers
        OpacityMode = self.OpacityMode
        AlphaMode = self.AlphaMode
        ShadelessMats = self.ShadelessMats
        SetCamera = self.SetCamera
        SetupCompo = self.SetupCompo
        GroupUntagged = self.GroupUntagged
        LayerOffset = self.LayerOffset
        LayerScale = self.LayerScale
        
        Ext = None
        if filename.endswith('.xcf'): Ext = '.xcf'
        elif filename.endswith('.xjt'): Ext = '.xjt'
        
        # Call Main Function
        if Ext:
            ret = main(self.report, filename, directory, LayerViewers, MixerViewers, LayerOffset,
                       LayerScale, OpacityMode, AlphaMode, ShadelessMats,
                       SetCamera, SetupCompo, GroupUntagged, Ext)
            if not ret:
                return {'CANCELLED'}
        else:
            self.report({'ERROR'},"Selected file wasn't valid, try .xcf or .xjt")
            return {'CANCELLED'}
        
        return {'FINISHED'}

    def invoke(self, context, event):
        wm = bpy.context.window_manager
        wm.fileselect_add(self)

        return {'RUNNING_MODAL'}


# Registering / Unregister
def menu_func(self, context):
    self.layout.operator(GIMPImageToScene.bl_idname, text="GIMP Image to Scene (.xcf, .xjt)", icon='PLUGIN')


def register():
    bpy.utils.register_module(__name__)

    bpy.types.INFO_MT_file_import.append(menu_func)


def unregister():
    bpy.utils.unregister_module(__name__)

    bpy.types.INFO_MT_file_import.remove(menu_func)


if __name__ == "__main__":
    register()