blender/release/scripts/import_obj.py
Campbell Barton 2dcf23c327 added Jiri as a contributer to the obj importer
Added a new script - 'Dump All Images to Path'

This script copies all the images used by 1 blend to a spesified path and references the new images from Blender
Usefull for moving projects between computers or when you reference many images. naming collisions and multiple images using the same image path are delt with properly only creating new image names when needed.

Blender images will reference the newly copied files - So be mindfull when you save your blend after running the script.

Notes, images with the path "Untitled will be ignored"

Image path collisions are managed by enumerating the path names so images will never be overwritten at the target path.
2006-11-03 20:04:56 +00:00

834 lines
25 KiB
Python

#!BPY
"""
Name: 'Wavefront (.obj)...'
Blender: 242
Group: 'Import'
Tooltip: 'Load a Wavefront OBJ File, Shift: batch import all dir.'
"""
__author__= "Campbell Barton", "Jiri Hnidek"
__url__= ["blender.org", "blenderartists.org"]
__version__= "2.0"
__bpydoc__= """\
This script imports a Wavefront OBJ files to Blender.
Usage:
Run this script from "File->Import" menu and then load the desired OBJ file.
Note, This loads mesh objects and materials only, nurbs and curves are not supported.
"""
from Blender import *
import BPyMesh
import BPyImage
import BPyMessages
try: import os
except: os= False
# Generic path functions
def stripFile(path):
'''Return directory, where the file is'''
lastSlash= max(path.rfind('\\'), path.rfind('/'))
if lastSlash != -1:
path= path[:lastSlash]
return '%s%s' % (path, sys.sep)
def stripPath(path):
'''Strips the slashes from the back of a string'''
return path.split('/')[-1].split('\\')[-1]
def stripExt(name): # name is a string
'''Strips the prefix off the name before writing'''
index= name.rfind('.')
if index != -1:
return name[ : index ]
else:
return name
# end path funcs
def line_value(line_split):
'''
Returns 1 string represneting the value for this line
None will be returned if theres only 1 word
'''
length= len(line_split)
if length == 1:
return None
elif length == 2:
return line_split[1]
elif length > 2:
return ' '.join( line_split[1:] )
def obj_image_load(imagepath, DIR, IMAGE_SEARCH):
'''
Mainly uses comprehensiveImageLoad
but tries to replace '_' with ' ' for Max's exporter replaces spaces with underscores.
'''
if '_' in imagepath:
image= BPyImage.comprehensiveImageLoad(imagepath, DIR, PLACE_HOLDER= False, RECURSIVE= IMAGE_SEARCH)
if image: return image
# Did the exporter rename the image?
image= BPyImage.comprehensiveImageLoad(imagepath.replace('_', ' '), DIR, PLACE_HOLDER= False, RECURSIVE= IMAGE_SEARCH)
if image: return image
# Return an image, placeholder if it dosnt exist
image= BPyImage.comprehensiveImageLoad(imagepath, DIR, PLACE_HOLDER= True, RECURSIVE= IMAGE_SEARCH)
return image
def create_materials(filepath, material_libs, unique_materials, unique_material_images, IMAGE_SEARCH):
'''
Create all the used materials in this obj,
assign colors and images to the materials from all referenced material libs
'''
DIR= stripFile(filepath)
#==================================================================================#
# This function sets textures defined in .mtl file #
#==================================================================================#
def load_material_image(blender_material, context_material_name, imagepath, type):
texture= Texture.New(type)
texture.setType('Image')
# Absolute path - c:\.. etc would work here
image= obj_image_load(imagepath, DIR, IMAGE_SEARCH)
texture.image = image
# Adds textures for materials (rendering)
if type == 'Kd':
if image.depth == 32:
# Image has alpha
blender_material.setTexture(0, texture, Texture.TexCo.UV, Texture.MapTo.COL | Texture.MapTo.ALPHA)
texture.setImageFlags('MipMap', 'InterPol', 'UseAlpha')
blender_material.mode |= Material.Modes.ZTRANSP
blender_material.alpha = 0.0
else:
blender_material.setTexture(0, texture, Texture.TexCo.UV, Texture.MapTo.COL)
# adds textures to faces (Textured/Alt-Z mode)
# Only apply the diffuse texture to the face if the image has not been set with the inline usemat func.
unique_material_images[context_material_name]= image # set the texface image
elif type == 'Ka':
blender_material.setTexture(1, texture, Texture.TexCo.UV, Texture.MapTo.CMIR) # TODO- Add AMB to BPY API
elif type == 'Ks':
blender_material.setTexture(2, texture, Texture.TexCo.UV, Texture.MapTo.SPEC)
elif type == 'Bump':
blender_material.setTexture(3, texture, Texture.TexCo.UV, Texture.MapTo.NOR)
elif type == 'D':
blender_material.setTexture(4, texture, Texture.TexCo.UV, Texture.MapTo.ALPHA)
blender_material.mode |= Material.Modes.ZTRANSP
blender_material.alpha = 0.0
# Todo, unset deffuse material alpha if it has an alpha channel
elif type == 'refl':
blender_material.setTexture(5, texture, Texture.TexCo.UV, Texture.MapTo.REF)
# Add an MTL with the same name as the obj if no MTLs are spesified.
temp_mtl= stripExt(stripPath(filepath))+ '.mtl'
if sys.exists(DIR + temp_mtl) and temp_mtl not in material_libs:
material_libs.append( temp_mtl )
del temp_mtl
#Create new materials
for name in unique_materials.iterkeys():
unique_materials[name]= Material.New(name)
unique_material_images[name]= None # assign None to all material images to start with, add to later.
unique_materials[None]= None
for libname in material_libs:
mtlpath= DIR + libname
if not sys.exists(mtlpath):
#print '\tError Missing MTL: "%s"' % mtlpath
pass
else:
#print '\t\tloading mtl: "%s"' % mtlpath
context_material= None
mtl= open(mtlpath)
for line in mtl.xreadlines():
if line.startswith('newmtl'):
context_material_name= line_value(line.split())
if unique_materials.has_key(context_material_name):
context_material = unique_materials[ context_material_name ]
else:
context_material = None
elif context_material:
# we need to make a material to assign properties to it.
line_split= line.split()
line_lower= line.lower()
if line_lower.startswith('ka'):
context_material.setMirCol((float(line_split[1]), float(line_split[2]), float(line_split[3])))
elif line_lower.startswith('kd'):
context_material.setRGBCol((float(line_split[1]), float(line_split[2]), float(line_split[3])))
elif line_lower.startswith('ks'):
context_material.setSpecCol((float(line_split[1]), float(line_split[2]), float(line_split[3])))
elif line_lower.startswith('ns'):
context_material.setHardness( int((float(line_split[1])*0.51)) )
elif line_lower.startswith('ni'): # Refraction index
context_material.setIOR( max(1, min(float(line_split[1]), 3))) # Between 1 and 3
elif line_lower.startswith('d') or line_lower.startswith('tr'):
context_material.setAlpha(float(line_split[1]))
elif line_lower.startswith('map_ka'):
img_filepath= line_value(line.split())
load_material_image(context_material, context_material_name, img_filepath, 'Ka')
elif line_lower.startswith('map_ks'):
img_filepath= line_value(line.split())
load_material_image(context_material, context_material_name, img_filepath, 'Ks')
elif line_lower.startswith('map_kd'):
img_filepath= line_value(line.split())
load_material_image(context_material, context_material_name, img_filepath, 'Kd')
elif line_lower.startswith('map_bump'):
img_filepath= line_value(line.split())
load_material_image(context_material, context_material_name, img_filepath, 'Bump')
elif line_lower.startswith('map_d') or line_lower.startswith('map_tr'): # Alpha map - Dissolve
img_filepath= line_value(line.split())
load_material_image(context_material, context_material_name, img_filepath, 'D')
elif line_lower.startswith('refl'): # Reflectionmap
img_filepath= line_value(line.split())
load_material_image(context_material, context_material_name, img_filepath, 'refl')
mtl.close()
def split_mesh(verts_loc, faces, unique_materials, SPLIT_OBJECTS, SPLIT_MATERIALS):
'''
Takes vert_loc and faces, and seperates into multiple sets of
(verts_loc, faces, unique_materials)
This is done so objects do not overload the 16 material limit.
'''
if not SPLIT_OBJECTS and not SPLIT_MATERIALS:
return [(verts_loc, faces, unique_materials)]
# Return a key that makes the faces unique.
if SPLIT_OBJECTS and not SPLIT_MATERIALS:
def face_key(face):
return face[4] # object
if not SPLIT_OBJECTS and SPLIT_MATERIALS:
def face_key(face):
return face[2] # material
else: # Both
def face_key(face):
return face[2], face[4] # material
face_split_dict= {}
oldkey= -1 # initialize to a value what will never match the key
for face in faces:
key= face_key(face)
if oldkey != key:
# Check the key has changed.
try:
faces_split, verts_split, unique_materials_split, vert_remap= face_split_dict[key]
except KeyError:
faces_split= []
verts_split= []
unique_materials_split= {}
vert_remap= [-1]*len(verts_loc)
face_split_dict[key]= (faces_split, verts_split, unique_materials_split, vert_remap)
oldkey= key
face_vert_loc_indicies= face[0]
# Remap verts to new vert list and add where needed
for enum, i in enumerate(face_vert_loc_indicies):
if vert_remap[i] == -1:
new_index= len(verts_split)
vert_remap[i]= new_index # set the new remapped index so we only add once and can reference next time.
face_vert_loc_indicies[enum] = new_index # remap to the local index
verts_split.append( verts_loc[i] ) # add the vert to the local verts
else:
face_vert_loc_indicies[enum] = vert_remap[i] # remap to the local index
matname= face[2]
if matname and not unique_materials_split.has_key(matname):
unique_materials_split[matname] = unique_materials[matname]
faces_split.append(face)
# remove one of the itemas and reorder
return [(verts_split, faces_split, unique_materials_split) for faces_split, verts_split, unique_materials_split, vert_remap in face_split_dict.itervalues()]
def create_mesh(new_objects, has_ngons, CREATE_FGONS, CREATE_EDGES, verts_loc, verts_tex, faces, unique_materials, unique_material_images, unique_smooth_groups):
'''
Takes all the data gathered and generates a mesh, adding the new object to new_objects
deals with fgons, sharp edges and assigning materials
'''
if not has_ngons:
CREATE_FGONS= False
if unique_smooth_groups:
sharp_edges= {}
smooth_group_users= dict([ (context_smooth_group, {}) for context_smooth_group in unique_smooth_groups.iterkeys() ])
context_smooth_group_old= -1
# Split fgons into tri's
fgon_edges= {} # Used for storing fgon keys
if CREATE_EDGES:
edges= []
context_object= None
# reverse loop through face indicies
for f_idx in xrange(len(faces)-1, -1, -1):
face_vert_loc_indicies,\
face_vert_tex_indicies,\
context_material,\
context_smooth_group,\
context_object= faces[f_idx]
len_face_vert_loc_indicies = len(face_vert_loc_indicies)
if len_face_vert_loc_indicies==1:
faces.pop(f_idx)# cant add single vert faces
elif not face_vert_tex_indicies: # images that are -1 are lines, a bit obscure but works.
if CREATE_EDGES:
try: # python 2.4+
edges.extend( (face_vert_loc_indicies[i], face_vert_loc_indicies[i+1]) for i in xrange(len_face_vert_loc_indicies-1) )
except: # python 2.3
edges.extend( [(face_vert_loc_indicies[i], face_vert_loc_indicies[i+1]) for i in xrange(len_face_vert_loc_indicies-1)] )
faces.pop(f_idx)
else:
# Smooth Group
if unique_smooth_groups and context_smooth_group and len_face_vert_loc_indicies > 3:
# Is a part of of a smooth group and is a face
if context_smooth_group_old is not context_smooth_group:
edge_dict= smooth_group_users[context_smooth_group]
context_smooth_group_old= context_smooth_group
for i in xrange(len_face_vert_loc_indicies):
i1= face_vert_loc_indicies[i]
i2= face_vert_loc_indicies[i-1]
if i1>i2: i1,i2= i2,i1
try:
edge_dict[i1,i2]+= 1
except KeyError:
edge_dict[i1,i2]= 1
# FGons into triangles
if has_ngons and len_face_vert_loc_indicies > 4:
ngon_face_indices= BPyMesh.ngon(verts_loc, face_vert_loc_indicies)
faces.extend(\
[(\
[face_vert_loc_indicies[ngon[0]], face_vert_loc_indicies[ngon[1]], face_vert_loc_indicies[ngon[2]] ],\
[face_vert_tex_indicies[ngon[0]], face_vert_tex_indicies[ngon[1]], face_vert_tex_indicies[ngon[2]] ],\
context_material,\
context_smooth_group,\
context_object)\
for ngon in ngon_face_indices]\
)
# edges to make fgons
if CREATE_FGONS:
edge_users= {}
for ngon in ngon_face_indices:
for i in (0,1,2):
i1= face_vert_loc_indicies[ngon[i ]]
i2= face_vert_loc_indicies[ngon[i-1]]
if i1>i2: i1,i2= i2,i1
try:
edge_users[i1,i2]+=1
except KeyError:
edge_users[i1,i2]= 1
for key, users in edge_users.iteritems():
if users>1:
fgon_edges[key]= None
# remove all after 3, means we dont have to pop this one.
faces.pop(f_idx)
# Build sharp edges
if unique_smooth_groups:
for edge_dict in smooth_group_users.itervalues():
for key, users in edge_dict.iteritems():
if users==1: # This edge is on the boundry of a group
sharp_edges[key]= None
# mat the material names to an index
material_mapping= dict([(name, i) for i, name in enumerate(unique_materials.keys())])
materials= [None] * len(unique_materials)
for name, index in material_mapping.iteritems():
materials[index]= unique_materials[name]
try:
me= Mesh.New(faces[0][5]) # object name from first face
except:
me= Mesh.New()
me.materials= materials[0:16] # make sure the list isnt too big.
#me.verts.extend([(0,0,0)]) # dummy vert
me.verts.extend(verts_loc)
face_mapping= me.faces.extend([f[0] for f in faces], indexList=True)
if verts_tex and me.faces:
me.faceUV= 1
# TEXMODE= Mesh.FaceModes['TEX']
context_material_old= -1 # avoid a dict lookup
mat= 0 # rare case it may be un-initialized.
me_faces= me.faces
ALPHA= Mesh.FaceTranspModes.ALPHA
for i, face in enumerate(faces):
if len(face[0])==2:
if CREATE_EDGES:
edges.append(face[0])
else:
face_index_map= face_mapping[i]
if face_index_map!=None: # None means the face wasnt added
blender_face= me.faces[face_index_map]
face_vert_loc_indicies,\
face_vert_tex_indicies,\
context_material,\
context_smooth_group,\
context_object= face
if context_smooth_group:
blender_face.smooth= True
if context_material:
if context_material_old is not context_material:
mat= material_mapping[context_material]
if mat>15:
mat= 15
context_material_old= context_material
blender_face.mat= mat
if verts_tex:
if context_material:
image= unique_material_images[context_material]
if image: # Can be none if the material dosnt have an image.
blender_face.image= image
if image.depth == 32:
blender_face.transp |= ALPHA
# BUG - Evil eekadoodle problem where faces that have vert index 0 location at 3 or 4 are shuffled.
if len(face_vert_loc_indicies)==4:
if face_vert_loc_indicies[2]==0 or face_vert_loc_indicies[3]==0:
face_vert_tex_indicies= face_vert_tex_indicies[2], face_vert_tex_indicies[3], face_vert_tex_indicies[0], face_vert_tex_indicies[1]
else: # length of 3
if face_vert_loc_indicies[2]==0:
face_vert_tex_indicies= face_vert_tex_indicies[1], face_vert_tex_indicies[2], face_vert_tex_indicies[0]
# END EEEKADOODLE FIX
# assign material, uv's and image
for ii, uv in enumerate(blender_face.uv):
uv.x, uv.y= verts_tex[face_vert_tex_indicies[ii]]
del me_faces
del ALPHA
# Add edge faces.
me_edges= me.edges
if CREATE_FGONS and fgon_edges:
FGON= Mesh.EdgeFlags.FGON
for ed in me.findEdges( fgon_edges.keys() ):
if ed!=None:
me_edges[ed].flag |= FGON
del FGON
if unique_smooth_groups and sharp_edges:
SHARP= Mesh.EdgeFlags.SHARP
for ed in me.findEdges( sharp_edges.keys() ):
if ed!=None:
me_edges[ed].flag |= SHARP
del SHARP
del me_edges
if CREATE_EDGES:
me.edges.extend( edges )
scn= Scene.GetCurrent()
ob= scn.objects.new(me)
new_objects.append(ob)
#ob= Object.New('Mesh')
#ob.link(me)
#scn.link(ob)
ob.sel= 1
# ob.makeDisplayList()
# me.update()
# print ob.getBoundBox()
def get_float_func(filepath):
'''
find the float function for this obj file
- weather to replace commas or not
'''
file= open(filepath, 'r')
for line in file.xreadlines():
if line.startswith('v'): # vn vt v
if ',' in line:
return lambda f: float(f.replace(',', '.'))
elif '.' in line:
return float
def load_obj(filepath, CLAMP_SIZE= 0.0, CREATE_FGONS= True, CREATE_SMOOTH_GROUPS= True, CREATE_EDGES= True, SPLIT_OBJECTS= True, SPLIT_GROUPS= True, SPLIT_MATERIALS= True, IMAGE_SEARCH=True):
'''
Called by the user interface or another script.
load_obj(path) - should give acceptable results.
This function passes the file and sends the data off
to be split into objects and then converted into mesh objects
'''
print '\nimporting obj "%s"' % filepath
time_main= sys.time()
verts_loc= []
verts_tex= []
faces= [] # tuples of the faces
material_libs= [] # filanems to material libs this uses
# Get the string to float conversion func for this file- is 'float' for almost all files.
float_func= get_float_func(filepath)
# Context variables
context_material= None
context_smooth_group= None
context_object= None
has_ngons= False
# has_smoothgroups= False - is explicit with len(unique_smooth_groups) being > 0
# Until we can use sets
unique_materials= {}
unique_material_images= {}
unique_smooth_groups= {}
# unique_obects= {} - no use for this variable since the objects are stored in the face.
# when there are faces that end with \
# it means they are multiline-
# since we use xreadline we cant skip to the next line
# so we need to know weather
multi_line_face= False
print '\tpassing obj file "%s"...' % filepath,
time_sub= sys.time()
file= open(filepath, 'r')
for line in file.xreadlines():
if line.startswith('v '):
line_split= line.split()
# rotate X90: (x,-z,y)
verts_loc.append( (float_func(line_split[1]), -float_func(line_split[3]), float_func(line_split[2])) )
elif line.startswith('vn '):
pass
elif line.startswith('vt '):
line_split= line.split()
verts_tex.append( (float_func(line_split[1]), float_func(line_split[2])) )
# Handel faces lines (as faces) and the second+ lines of fa multiline face here
# use 'f' not 'f ' because some objs (very rare have 'fo ' for faces)
elif line.startswith('f') or (line.startswith('l ') and CREATE_EDGES) or multi_line_face:
if multi_line_face:
# use face_vert_loc_indicies and face_vert_tex_indicies previously defined and used the obj_face
line_split= line.split()
multi_line_face= False
else:
line_split= line[2:].split()
face_vert_loc_indicies= []
face_vert_tex_indicies= []
# Instance a face
faces.append((\
face_vert_loc_indicies,\
face_vert_tex_indicies,\
context_material,\
context_smooth_group,\
context_object\
))
if line_split[-1][-1]== '\\':
multi_line_face= True
if len(line_split[-1])==1:
line_split.pop() # remove the \ item
else:
line_split[-1]= line_split[-1][:-1] # remove the \ from the end last number
isline= line.startswith('l')
for v in line_split:
obj_vert= v.split('/')
vert_loc_index= int(obj_vert[0])-1
# Make relative negative vert indicies absolute
if vert_loc_index < 0:
vert_loc_index= len(verts_loc) + vert_loc_index + 1
face_vert_loc_indicies.append(vert_loc_index)
if not isline:
if len(obj_vert)>1 and obj_vert[1]:
# formatting for faces with normals and textures us
# loc_index/tex_index/nor_index
vert_tex_index= int(obj_vert[1])-1
# Make relative negative vert indicies absolute
if vert_tex_index < 0:
vert_tex_index= len(verts_tex) + vert_tex_index + 1
face_vert_tex_indicies.append(vert_tex_index)
else:
# dummy
face_vert_tex_indicies.append(0)
if len(face_vert_loc_indicies) > 4:
has_ngons= True
elif line.startswith('s'):
if CREATE_SMOOTH_GROUPS:
context_smooth_group= line_value(line.split())
if context_smooth_group=='off':
context_smooth_group= None
elif context_smooth_group: # is not None
unique_smooth_groups[context_smooth_group]= None
elif line.startswith('o'):
if SPLIT_OBJECTS:
context_object= line_value(line.split())
# unique_obects[context_object]= None
elif line.startswith('g'):
if SPLIT_GROUPS:
context_object= line_value(line.split())
# print 'context_object', context_object
# unique_obects[context_object]= None
elif line.startswith('usemtl'):
context_material= line_value(line.split())
unique_materials[context_material]= None
elif line.startswith('mtllib'): # usemap or usemat
material_libs.extend( line.split()[1:] ) # can have multiple mtllib filenames per line
''' # How to use usemap? depricated?
elif line.startswith('usema'): # usemap or usemat
context_image= line_value(line.split())
'''
file.close()
time_new= sys.time()
print '%.4f sec' % (time_new-time_sub)
time_sub= time_new
print '\tloading materials and images...',
create_materials(filepath, material_libs, unique_materials, unique_material_images, IMAGE_SEARCH)
time_new= sys.time()
print '%.4f sec' % (time_new-time_sub)
time_sub= time_new
# deselect all
for ob in Scene.GetCurrent().objects: ob.sel= False
new_objects= [] # put new objects here
print '\tbuilding geometry;\n\tverts:%i faces:%i materials: %i smoothgroups:%i ...' % ( len(verts_loc), len(faces), len(unique_materials), len(unique_smooth_groups) ),
# Split the mesh by objects/materials, may
for verts_loc_split, faces_split, unique_materials_split in split_mesh(verts_loc, faces, unique_materials, SPLIT_OBJECTS, SPLIT_MATERIALS):
# Create meshes from the data
create_mesh(new_objects, has_ngons, CREATE_FGONS, CREATE_EDGES, verts_loc_split, verts_tex, faces_split, unique_materials_split, unique_material_images, unique_smooth_groups)
axis_min= [ 1000000000]*3
axis_max= [-1000000000]*3
if CLAMP_SIZE:
# Get all object bounds
for ob in new_objects:
for v in ob.getBoundBox():
for axis, value in enumerate(v):
if axis_min[axis] > value: axis_min[axis]= value
if axis_max[axis] < value: axis_max[axis]= value
# Scale objects
max_axis= max(axis_max[0]-axis_min[0], axis_max[1]-axis_min[1], axis_max[2]-axis_min[2])
scale= 1.0
while CLAMP_SIZE < max_axis * scale:
scale= scale/10.0
for ob in new_objects:
ob.setSize(scale, scale, scale)
time_new= sys.time()
print '%.4f sec' % (time_new-time_sub)
print 'finished importing: "%s" in %.4f sec.' % (filepath, (time_new-time_main))
DEBUG= True
def load_obj_ui(filepath, BATCH_LOAD= False):
if BPyMessages.Error_NoFile(filepath):
return
CREATE_SMOOTH_GROUPS= Draw.Create(0)
CREATE_FGONS= Draw.Create(1)
CREATE_EDGES= Draw.Create(1)
SPLIT_OBJECTS= Draw.Create(1)
SPLIT_GROUPS= Draw.Create(1)
SPLIT_MATERIALS= Draw.Create(1)
CLAMP_SIZE= Draw.Create(10.0)
IMAGE_SEARCH= Draw.Create(1)
# Get USER Options
pup_block= [\
('Smooth Groups', CREATE_SMOOTH_GROUPS, 'Surround smooth groups by sharp edges'),\
('Create FGons', CREATE_FGONS, 'Import faces with more then 4 verts as fgons.'),\
('Lines', CREATE_EDGES, 'Import lines and faces with 2 verts as edges'),\
('Split by Object', SPLIT_OBJECTS, 'Import OBJ Objects into Blender Objects'),\
('Split by Groups', SPLIT_GROUPS, 'Import OBJ Groups into Blender Objects'),\
('Split by Material', SPLIT_MATERIALS, 'Import each material into a seperate mesh (Avoids > 16 per mesh error)'),\
('Clamp Scale:', CLAMP_SIZE, 0.0, 1000.0, 'Clamp the size to this maximum (Zero to Disable)'),\
'',\
('Image Search', IMAGE_SEARCH, 'Search subdirs for any assosiated images (Warning, may be slow)'),\
]
if not Draw.PupBlock('Import OBJ...', pup_block):
return
Window.WaitCursor(1)
if BATCH_LOAD: # load the dir
try:
files= [ f for f in os.listdir(filepath) if f.lower().endswith('.obj') ]
except:
Draw.PupMenu('Error%t|Could not open path ' + filepath)
return
if not files:
Draw.PupMenu('Error%t|No files at path ' + filepath)
return
for f in files:
scn= Scene.New( stripExt(f) )
scn.makeCurrent()
load_obj(sys.join(filepath, f),\
CLAMP_SIZE.val,\
CREATE_FGONS.val,\
CREATE_SMOOTH_GROUPS.val,\
CREATE_EDGES.val,\
SPLIT_OBJECTS.val,\
SPLIT_GROUPS.val,\
SPLIT_MATERIALS.val,\
IMAGE_SEARCH.val,\
)
else: # Normal load
load_obj(filepath,\
CLAMP_SIZE.val,\
CREATE_FGONS.val,\
CREATE_SMOOTH_GROUPS.val,\
CREATE_EDGES.val,\
SPLIT_OBJECTS.val,\
SPLIT_GROUPS.val,\
SPLIT_MATERIALS.val,\
IMAGE_SEARCH.val,\
)
Window.WaitCursor(0)
def load_obj_ui_batch(file):
load_obj_ui(file, True)
DEBUG= False
if __name__=='__main__' and not DEBUG:
if os and Window.GetKeyQualifiers() & Window.Qual.SHIFT:
Window.FileSelector(load_obj_ui_batch, 'Import OBJ Dir', '')
else:
Window.FileSelector(load_obj_ui, 'Import a Wavefront OBJ', '*.obj')
'''
# For testing compatibility
else:
# DEBUG ONLY
TIME= sys.time()
import os
print 'Searching for files'
os.system('find /fe/obj -iname "*.obj" > /tmp/temp3ds_list')
print '...Done'
file= open('/tmp/temp3ds_list', 'r')
lines= file.readlines()
file.close()
def between(v,a,b):
if v <= max(a,b) and v >= min(a,b):
return True
return False
for i, _obj in enumerate(lines):
if between(i, 440,600):
_obj= _obj[:-1]
print 'Importing', _obj, '\nNUMBER', i, 'of', len(lines)
_obj_file= _obj.split('/')[-1].split('\\')[-1]
newScn= Scene.New(_obj_file)
newScn.makeCurrent()
load_obj(_obj, False)
print 'TOTAL TIME: %.6f' % (sys.time() - TIME)
'''
#load_obj('/test.obj')
#load_obj('/fe/obj/mba1.obj')