image_to_planes.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 #####

"""
This script imports images and creates Planes with them as textures.
At the moment the naming for objects, materials, textures and meshes
is derived from the imagename.

One can either import a single image, or all images in one directory.
When imporing a directory one can either check the checkbox or leave
the filename empty.

As a bonus one can choose to import images of only one type.
Atm this is the list of possible extensions:
extList =
    ('jpeg', 'jpg', 'png', 'tga', 'tiff', 'tif', 'exr',
    'hdr', 'avi', 'mov', 'mp4', 'ogg', 'bmp', 'cin', 'dpx', 'psd')

If someone knows a better way of telling if a file is an image which
Blender can read, please tell so ;)

when importing images that are allready referenced they are not
reimported but the old ones reused as not to clutter the materials,
textures and image lists.
Instead the plane gets linked against an existing material.

If one reimports images but chooses different material/texture mapping
new materials are created.
So one doesn't has to go through everything if one decides differently
after importing 236 images.

It also has an option to translate pixeldimensions into Blenderunits.
"""

##############################################################################
##############################################################################
##############################################################################

bl_addon_info = {
    'name': 'Planes from Images',
    'author': 'Florian Meyer (testscreenings)',
    'version': '0.7',
    'blender': (2, 5, 2),
    'location': 'View3D > Add Mesh',
    'url': 'http://wiki.blender.org/index.php/Extensions:2.5/Py/Scripts/Object/Image_To_Planes',
    'description': 'Imports images and creates planes \
with the appropiate aspect ratio',
    'category': 'Object'}

##############################################################################
##############################################################################
##############################################################################

import bpy
from bpy.props import *
from os import listdir
from mathutils import Vector

# Apply view rotation to objects if "Align To" for new objects
# was set to "VIEW" in the User Preference.
def apply_view_rotation(ob):
    context = bpy.context
    align = bpy.context.user_preferences.edit.object_align

    if (context.space_data.type == 'VIEW_3D'
        and align == 'VIEW'):
            view3d = context.space_data
            region = view3d.region_3d
            viewMatrix = region.view_matrix
            rot = viewMatrix.rotation_part()
            ob.rotation_euler = rot.invert().to_euler()



######################
#### Create plane ####
######################


#### gets called from createPlane ####
def createMesh(dimension, img):
    #### x is x-aspectRatio ####
    x = img.size[0] / img.size[1]
    y = 1
    if dimension[0]:
        x = (img.size[0] * (1/dimension[1])) * 0.5
        y = (img.size[1] * (1/dimension[1])) * 0.5
    verts = []
    faces = []
    v1 = (-x, -y, 0)
    v2 = (x, -y, 0)
    v3 = (x, y, 0)
    v4 = (-x, y, 0)
    verts.append(v1)
    verts.append(v2)
    verts.append(v3)
    verts.append(v4)
    faces.append([0, 1, 2, 3])

    return verts, faces


def createPlane(img, dimension):
    scene = bpy.context.scene
    me = bpy.data.meshes.new(img.name)
    verts, faces = createMesh(dimension, img)
    me.from_pydata(verts, [], faces)
    me.update()
    plane = bpy.data.objects.new(img.name, me)
    plane.data.add_uv_texture()
    scene.objects.link(plane)
    plane.location = scene.cursor_location
    apply_view_rotation(plane)

    return plane


#######################################
#### get imagepaths from directory ####
#######################################

def getImageFilesInDirectory(directory, extension):
    import os

    extList = [
        'jpeg', 'jpg', 'png', 'tga', 'tiff',
        'tif', 'exr', 'hdr', 'avi', 'mov', 'mp4',
        'ogg', 'bmp', 'cin', 'dpx', 'psd']

    #### get all Files in the directory ####
    allFiles = listdir(directory)
    allImages = []

    # Convert to lower case
    e = extension.lower()

    if e in extList:
        extList = extension

    #### Put all ImageFiles in List and return ####
    for file in allFiles:
        # Get the file extension (includes the ".")
        e = os.path.splitext(file)[1]

        # Separate by "." and get the last list-entry.
        e = e.rpartition(".")[-1]

        # Convert to lower case
        e = e.lower()

        if e in extList:
            allImages.append(file)

    return allImages


##########################################
#### get ImageDataBlock from Filepath ####
##########################################

def getImage(path):
    img = []

    #### Check every Image if it is allready there ####
    for image in bpy.data.images:
        #### If image with same path exists take that one ####
        if image.filename == path:
            img = image

    #### Else create new Image and load from path ####
    if not img:
        name = path.rpartition('\\')[2].rpartition('.')[0]
        img = bpy.data.images.new(name)
        img.source = 'FILE'
        img.filename = path

    return img


#############################
#### Create/get Material ####
#############################
def getMaterial(tex, mapping):
    mat = []
    #### Check all existing Materials ####
    for material in bpy.data.materials:
        #### if Material with name and mapping        ####
        #### and texture with image                   ####
        #### exists take that one                     ####
        if (material.name == tex.image.name
        and tex.name in material.texture_slots
        and material.mapping == mapping):
            mat = material

    #### Else Create new one and apply mapping ####
    if not mat:
        mat = bpy.data.materials.new(name=tex.name)
        mat.add_texture(tex, texture_coordinates='UV', map_to='COLOR')
        mat.mapping = mapping
        mat.name = tex.name

    return mat


############################
#### Create/get Texture ####
############################

def getTexture(path, img):
    tex = []

    #### Check all existing Textures ####
    for texture in bpy.data.textures:
        #### if (image)texture with image exists take that one ####
        if (texture.type == 'IMAGE'
            and texture.image
            and texture.image.filename == path):
            tex = texture

    #### Else Create new one and apply mapping ####
    if not tex:
        name = path.rpartition('\\')[2].rpartition('.')[0]
        tex = bpy.data.textures.new(name=name)
        tex.type = 'IMAGE'
        tex = tex.recast_type()
        tex.image = img

    return tex


#########################################
#### Create custom Material Property ####
#########################################

def mapget(self):
    """custom property of the image_to_planes addon"""
    mapping = []
    mapping.append(self.shadeless)
    mapping.append(self.transparency)
    mapping.append(self.alpha)
    mapping.append(self.specular_alpha)
    mapping.append(self.transparency_method)
    if (self.texture_slots[0]
        and self.texture_slots[0].texture.type == 'IMAGE'
        and self.texture_slots[0].texture.image):
        mapping.append(self.texture_slots[0].texture.image.premultiply)
    else:
        mapping.append("no image")
    return mapping


def mapset(self, value):
    self.shadeless = value[0]
    self.transparency = value[1]
    self.alpha = float(value[2])
    self.specular_alpha = float(value[3])
    self.transparency_method = value[4]
    if (self.texture_slots[0]
        and self.texture_slots[0].texture.type == 'IMAGE'
        and self.texture_slots[0].texture.image):
        self.texture_slots[0].texture.image.premultiply = value[5]


bpy.types.Material.mapping = property(mapget, mapset)

#######################
#### MAIN FUNCTION ####
#######################


def main(filePath, options, mapping, dimension):
    #### Lists ####
    images = []
    scene = bpy.context.scene

    #### if Create from Directory (no filename or checkbox) ####
    if options[0] or not filePath[1]:
        imageFiles = getImageFilesInDirectory(filePath[2], options[1])
        #### Check if images are loaded and put in List ####
        for imageFile in imageFiles:
            img = getImage(str(filePath[2]) + "\\" + str(imageFile))
            images.append(img)

        # Deselect all objects.
        bpy.ops.object.select_all(action='DESELECT')

        #### Assign/get all things ####
        for img in images:

            #### Create/get Texture ####
            tex = getTexture(img.filename, img)

            #### Create/get Material ####
            mat = getMaterial(tex, mapping)

            #### Create Plane ####
            plane = createPlane(img, dimension)

            #### Assign Material ####
            plane.data.add_material(mat)

            #### put Image into  UVTextureLayer ####
            plane.data.uv_textures[0].data[0].image = img
            plane.data.uv_textures[0].data[0].tex = True
            plane.data.uv_textures[0].data[0].transp = 'ALPHA'
            plane.data.uv_textures[0].data[0].twoside = True

            plane.selected = True
            scene.objects.active = plane

    #### if Create Single Plane (filename and is image)####
    else:

        # Deselect all objects.
        bpy.ops.object.select_all(action='DESELECT')

        #### Check if Image is loaded ####
        img = getImage(filePath[0])

        #### Create/get Texture ####
        tex = getTexture(filePath[0], img)

        #### Create/get Material ####
        mat = getMaterial(tex, mapping)

        #### Create Plane ####
        plane = createPlane(img, dimension)

        #### Assign Material ####
        plane.data.add_material(mat)

        #### put Image into  UVTextureLayer ####
        plane.data.uv_textures[0].data[0].image = img
        plane.data.uv_textures[0].data[0].tex = True
        plane.data.uv_textures[0].data[0].transp = 'ALPHA'
        plane.data.uv_textures[0].data[0].twoside = True

        plane.selected = True
        scene.objects.active = plane


##############################################################################
#################       O P E R A T O R        ###############################
##############################################################################

class image_to_planes(bpy.types.Operator):
    ''''''
    bl_idname = "mesh.image_to_planes"
    bl_label = "Import Images as Planes"
    bl_description = "Create plane(s) from images"
    bl_options = {'REGISTER', 'UNDO'}

    path = StringProperty(name="File Path",
        description="File path used for importing the file",
        maxlen=1024,
        default="")
    filename = StringProperty(name="File Name",
        description="Name of the file.")
    directory = StringProperty(name="Directory",
        description="Directory of the file.")
    fromDirectory = BoolProperty(name="All in directory",
        description="Import all images in this directory",
        default=False)
    extension = StringProperty(name="Extension",
        description="Only import files with this extension " \
            "(e.g. png, jpg, ...")

    shadeless = BoolProperty(name="Shadeless",
        description="Set material to shadeless",
        default=False)
    transp = BoolProperty(name="Use alpha",
        description="Use alphachannel for transparency",
        default=False)
    premultiply = BoolProperty(name="Premultiply",
        description="Premultiply image",
        default=False)
    tEnum = [
        ('Z_TRANSPARENCY', 'Z_TRANSPARENCY', 'Z_TRANSPARENCY'),
        ('RAYTRACE', 'RAYTRACE', 'RAYTRACE')]
    transp_method = EnumProperty(items=tEnum,
        description="Transparency Method",
        name="transMethod")
    useDim = BoolProperty(name="use Image dimensions",
        description="Use the images pixels to derive the size of the plane",
        default=False)
    factor = IntProperty(name="pixels/BU",
        description="Number of pixels per Blenderunit",
        default=500,
        min=1)


#items=[(cats[i], cats[i], str(i)) for i in range(len(cats))

    def execute(self, context):
        #### File Path ####
        path = self.properties.path
        filename = self.properties.filename
        directory = self.properties.directory
        filePath = [path, filename, directory]
        #print(filePath)

        #### General Options ####
        fromDirectory = self.properties.fromDirectory
        extension = self.properties.extension
        options = [fromDirectory, extension]

        #### mapping ####
        alphavalue = 1
        shadeless = self.properties.shadeless
        transp = self.properties.transp
        if transp:
            alphavalue = 0
        transp_method = self.properties.transp_method
        premultiply = self.properties.premultiply

        mapping = ([shadeless,
                    transp,
                    alphavalue,
                    alphavalue,
                    transp_method,
                    premultiply])

        #### Use Pixelsdimensions ####
        useDim = self.properties.useDim
        factor = self.properties.factor
        dimension = (useDim, factor)

        #### Call Main Function ####
        main(filePath, options, mapping, dimension)

        return {'FINISHED'}

    def invoke(self, context, event):
        wm = bpy.context.manager
        wm.add_fileselect(self)

        return {'RUNNING_MODAL'}


#### Registering ####

menu_func = (lambda self, context: self.layout.operator(image_to_planes.bl_idname,
                                        text="Imageplanes", icon='PLUGIN'))

def register():
    bpy.types.register(image_to_planes)
    bpy.types.INFO_MT_mesh_add.append(menu_func)


def unregister():
    bpy.types.unregister(image_to_planes)
    bpy.types.INFO_MT_mesh_add.remove(menu_func)


if __name__ == "__main__":
    register()