Python script error problem


(flapzucht) #1

I’ve inserted a import/export python script into blender and tried to run it with alt-p. But now it says: python script error, check console and marks the following pieces from the script: Import OS, and when i delete this it also marks: Import Blender210.

I have python version 2.1 so this can’t be the problem.

I have the following script:
#=========================================================================

Wavefront OBJ Importer/Exporter v1.2

This is a complete OBJ importer and exporter script

All Rights Reserved

[email protected]

#=========================================================================

DESCRIPTION: This script allows for full importing and exporting of

.obj files. uv texture coordinates and normals can be exported and

imported. .obj groups and materials can also be converted to and

from material indexes in Blender.

INSTALLATION:

You need the FULL python installation to run this script. You can

down load the latest version of PYTHON from http://www.python.org.

INSTRUCTIONS (You definitely want to read this!):

Once the script is loaded in Blender, hit alt-p. This will bring up

the main interface panel. You will have a choise of exporting or

importing an .obj module. If you are exporting you must have at least

one mesh selected in Blender, or you will get an error.

You can change the export filename by entering the path and filename

in the dialog. If you do not enter a path, the path will default to

your blender directory. You can change the default path in the script <==== NOTE

itself by modifying the variable ‘Filename’ at the top of the script.

EXPORTING:

There are 4 different export options: Default, Groups, Material Layers,

and Standard. “Default” will export your mesh using Material Layers if

the mesh has material indexes. “Groups” and “Material Layers” are

logically equivalent, but are a different .obj format. If you are

exporting a Poser morph target, you must select “Material Layers”. <===== NOTE

“Standard” will ignore grouping information, even if your mesh has

material indexes.

There is also a choice between export using “mesh coordinates” or

“object coordinates”. “Object coordinates” are any location, rotation,

or scaling values created outside of mesh edit. They belong to the object

rather than the mesh. If you export using mesh coordinates (the default)

the center of the object will always be at 0, 0, 0. Export using "mesh

coordinates is definintely what you want to use if you are working with

a Poser morph target. If you are exporting a group of objects, you will

automatically be placed in “object coordinate” mode.

IMPORTING:

If your OBJ model has uv mapping coordinates, and you want to use them <===== NOTE

in Blender, you can access them in two ways. The best way is through Blender’s

realtime UV coordinates which you enable simply by selecting the UV option in

the material edit window. This gives you an exact version of the uv coordinates.

An older method is to select the “stick” option in the material edit window. I

really don’t know why anyone would want to use this option since it cannot handle

seams and texture overlap, but I left it in just in case someone could use it for

something.

If your OBJ contains groups, once it has been imported, it may still appear

to lack any material indexes. If this happens, it can be remedied <=== NOTE

by going to the mesh editor window, clicking on the mesh selection button, and

reselecting the mesh you have just imported. You will now have as many

materials attached to your object as there are groups. You can then select

different groups by doing a material select when you are in edit mode.

Finally, you might have problems with certain parts of the object not displaying

after you go in and out of edit mode the first time. To fix this, simply go into

edit mode again, and select the “remove doubles” option.

HISTORY:

Nov 13, 2001: Initial Release

Nov 16, 2001: Version 1.1 - no longer need to pre-define dummy materials

Dec 13, 2001: Version 1.2 - now imports into realtime UV (the UV button in the material edit window), and

exports realtime UV. This format is more compatible with the native .OBJ uv format. Should eliminate

texture misalignments and seams. Simply press the UV button in the material edit window after importing.

#================================

===============================

Setup our runtime constants

===============================

DEBUG=1 # Set this to “1” to see extra messages
MESHVERSION=3 # If the export file doesn’t work,
FILEVERSION=3 # try changing these to “2”

EVENT_PATHCHANGE= 1
EVENT_IMPORT= 2
EVENT_IMPORT_CONT= 3
EVENT_OPTIONS= 4
EVENT_EXPORT= 7
EVENT_EXPORT_CHK= 5
EVENT_EXPORT_CANCEL= 6
EVENT_QUIT= 8
EVENT_EXPORT_ERR= 9
EVENT_TYPE= 10
EVENT_DONE= 11

===============================

Import our libraries

===============================

import string
import os
import struct
import math
import Blender210
from Blender import *
from Blender import NMesh
from Blender.Draw import *
from Blender.BGL import *

===============================

Input Variables

===============================

Filename = “C:\My Documents\Data\Objects\armchair.obj”
#Filename = “C:\Data\Objects\VickiHead.obj”
gFilename=Create(Filename)
gAlert = 0
type = 1
exporttype = 1
returncode = 0
operation = “Export”
center = [0,0,0]
rotation = [0,0,0]
Transform = []
multiflag = 0

#================================
def ExitGUI ():
#================================
Exit()

#================================
def EventGUI (event):
#================================
global gFilename
global ExportOptions
global ExportType
global type
global exporttype
global operation
global gAlert

  if (event==EVENT_IMPORT):
     ImportFunction(gFilename.val, type)
     operation = "Import"
  if (event==EVENT_IMPORT_CONT):
     gAlert = 0
     operation = "Import"
     Draw ()
  if (event==EVENT_EXPORT):
     ExportFunction(gFilename.val, type)
     operation = "Export"
  if (event==EVENT_EXPORT_CHK):
     ExportFunctionOK(gFilename.val, type) 
     Draw ()
  if (event==EVENT_EXPORT_CANCEL):
     gAlert = 0
     Draw ()
  if (event==EVENT_OPTIONS):
     type = ExportOptions.val 
     Draw ()
  if (event==EVENT_TYPE):
     exporttype = ExportType.val 
     Draw ()
  if (event==EVENT_EXPORT_ERR):  
     gAlert = 0       
     Draw ()
  if (event==EVENT_DONE):  
     gAlert = 0
     Draw ()
  if (event==EVENT_QUIT):
     ExitGUI()

#================================
def DrawGUI():
#================================
global type
global exporttype
global operation

  glClearColor (0.6,0.6,0.6,0)
  glClear (GL_COLOR_BUFFER_BIT)

  global gFilename
  global gAlert
  global ExportOptions
  global ExportType

  if (gAlert==0):
     # Add in the copyright notice and title
     glRasterPos2d(32, 380)
     Text("Wavefront OBJ Importer/Exporter")
     glRasterPos2d(32, 350)
     Text("Copyright (C) Chris Lynch 2001")

     gFilename=String ("Filename: ",EVENT_PATHCHANGE,32,250,320,32,gFilename.val,255,"Full pathname and filename")
     Button ("Export",EVENT_EXPORT,32,200,100,32)
     Button ("Import",EVENT_IMPORT,252,200,100,32)
     glRasterPos2d(32, 165)
     Text("Select Export Options:")
     options = "Export Options %t| Default %x1| Material Layers %x2| Obj Groups %x3| Standard %x4"
     ExportOptions = Menu (options,EVENT_OPTIONS,200,150,150,32, type)
     Button ("Done",EVENT_QUIT,142,50,100,32)
     glRasterPos2d(32, 115)
     Text("Export using ")
     options = "Export Type %t| Mesh Coordinates %x1| Object Coordinates %x2"
     ExportType = Menu (options,EVENT_TYPE,170,100,180,32, exporttype)
     Button ("Done",EVENT_QUIT,142,50,100,32)

  elif (gAlert==1):
     glRasterPos2i (32,250)
     Text (gFilename.val+ " already exists. Save anyway?")	
     Button ("Save",EVENT_EXPORT_CHK,150,200,50,32)
     Button ("Cancel",EVENT_EXPORT_CANCEL,250,200,50,32)
     gAlert = 0
  elif (gAlert==2):
     glRasterPos2i (32,250)
     Text (gFilename.val+ " cannot be found. Check directory and filename.")	
     Button ("Continue",EVENT_IMPORT_CONT,32,190,70,32) 
     gAlert = 0
  elif gAlert == 3:
     glRasterPos2i (32,250)
     Text ("No objects selected to export. You must select one or more objects.")	
     Button ("Continue",EVENT_EXPORT_ERR,192,200,70,32)
     gAlert = 0
  elif gAlert == 5:
     glRasterPos2i (32,250)
     Text ("Invalid directory path.")	
     Button ("Continue",EVENT_EXPORT_ERR,192,200,70,32)
     gAlert = 0
  else:
     glRasterPos2i (32,250)
     Text (str(operation)+ " of " +str(gFilename.val)+ " done.")	
     Button ("Continue",EVENT_DONE,192,200,70,32)

#================================
def RegisterGUI ():
#================================
Register (DrawGUI,None,EventGUI)

#================================

MAIN SCRIPT

#================================

Opens a file, writes data in it

and closes it up.

#================================
RegisterGUI()

#================================
def ImportFunction (importName, type):
#================================
global gFilename
global gAlert

  try:
     FILE=open (importName,"r")
     directory, Name = os.path.split(gFilename.val)
     words = string.split(Name,".")
     Name = words[0]
     ObjImport(FILE, Name, gFilename.val) 
     FILE.close()
     gAlert = 4
     Draw ()
  except IOError:
     gAlert=2
     Draw ()

#================================
def ExportFunction (exportName, type):
#================================
global gFilename
global gAlert

  try:
     FILE=open (exportName,"r")
     FILE.close()
     gAlert = 1
     Draw ()
  except IOError:
     directory, Name = os.path.split(gFilename.val)
     if os.path.isdir(directory):
        ExportFunctionOK(exportName, type)
        Draw ()
     else:
        gAlert = 5
        Draw ()

#================================
def ExportFunctionOK (exportName, type):
#================================
global gFilename
global gAlert
global returncode

  FILE=open (exportName,"w")
  directory, Name = os.path.split(gFilename.val)
  words = string.split(Name,".")
  Name = words[0]
  ObjExport(FILE, Name, type)
  if returncode &gt; 0:
     gAlert = 3
  else:
     gAlert = 4
  FILE.flush()
  FILE.close()

#=========================
def ObjImport(file, Name, filename):
#=========================
vcount = 0
vncount = 0
vtcount = 0
fcount = 0
gcount = 0
setcount = 0
groupflag = 0
objectflag = 0
mtlflag = 0
baseindex = 0
basevtcount = 0
basevncount = 0
matindex = 0

pointList    = []
uvList       = []
normalList   = []
faceList     = []
materialList = []
uv = [] 
lines = file.readlines()
linenumber = 1

for line in lines:
    words = string.split(line)
    if words and words[0] == "#":
        pass # ignore comments
    elif words and words[0] == "v":
        vcount = vcount + 1
        x = float(words[1])
        y = float(words[2])
        z = float(words[3])
        pointList.append([x, y, z])

    elif words and words[0] == "vt":
        vtcount = vtcount + 1
        u = float(words[1])
        v = float(words[2])
        uvList.append([u, v])

    elif words and words[0] == "vn":
        vncount = vncount + 1
        i = float(words[1])
        j = float(words[2])
        k = float(words[3])
        normalList.append([i, j, k])

    elif words and words[0] == "f":
        fcount = fcount + 1
        vi = [] # vertex  indices
        ti = [] # texture indices
        ni = [] # normal  indices
        words = words[1:]
        lcount = len(words)
        for index in (xrange(lcount)):
           if string.find(words[index], "/") == -1:
                 vindex = int(words[index])
                 if vindex &lt; 0: vindex = baseindex + vindex + 1  
                 vi.append(vindex)
           else:
               vtn = string.split(words[index], "/")
               vindex = int(vtn[0])
               if vindex &lt; 0: vindex = baseindex + vindex + 1 
               vi.append(vindex) 
        
               if len(vtn) &gt; 1 and vtn[1]:
                  tindex = int(vtn[1])
                  if tindex &lt; 0: tindex = basevtcount +tindex + 1
                  ti.append(tindex)

               if len(vtn) &gt; 2 and vtn[2]:
                  nindex = int(vtn[2])
                  if nindex &lt; 0: nindex = basevncount +nindex + 1
                  ni.append(nindex)                
        faceList.append([vi, ti, ni, matindex])

    elif words and words[0] == "o":
        ObjectName = words[1]
        objectflag = 1
        #print "Name is %s" % ObjectName

    elif words and words[0] == "g":
        groupflag = 1
        index = len(words)
        if objectflag == 0:
           objectflag = 1
           if index &gt; 1:
              ObjectName = string.join(words[1:],"_")
              GroupName = string.join(words[1:],"_") 
           else:
              ObjectName = "Default" 
              GroupName = "Default" 
           #print "Object name is %s" % ObjectName
           #print "Group name is %s" % GroupName
        else:
           if index &gt; 1:
              GroupName = string.join(words[1:],"_") 
           else:
              GroupName = "Default" 
           #print "Group name is %s" % GroupName

        if mtlflag == 0:
           matindex = AddMeshMaterial(GroupName,materialList, matindex)
        gcount = gcount + 1 

        if fcount &gt; 0: 
           baseindex = vcount
           basevncount = vncount
           basevtcount = vtcount

    elif words and words[0] == "mtllib":
        # try to export materials
        directory, dummy = os.path.split(filename)
        filename = os.path.join(directory, words[1])
        try:
            file = open(filename, "r")
        except:
            print "no material file %s" % filename
        else:
            mtlflag = 1
            file = open(filename, "r")
            line = file.readline()
            while line:
                words = string.split(line)
                if words and words[0] == "newmtl":
                  name = words[1]
                  line = file.readline()  # Ns ?
                  words = string.split(line)
                  while (words[0] != "Ka" and words[0] != "Kd" and words[0] != "Ks"): 
                      line = file.readline()  # Ka
                      words = string.split(line)
                  if words[0] == "Ka":
                    Ka = [float(words[1]),
                          float(words[2]),
                          float(words[3])]
                    line = file.readline()  # Kd
                    words = string.split(line)
                  if words[0] == "Kd":
                    Kd = [float(words[1]),
                          float(words[2]),
                          float(words[3])]
                    line = file.readline()  # Ks 
                    words = string.split(line)
                  if words[0] == "Ks":
                    Ks = [float(words[1]),
                          float(words[2]),
                          float(words[3])]

                  matindex = AddGlobalMaterial(name, matindex) 
                  matlist = Material.Get() 
                  if len(matlist) &gt; 0:
                     material = matlist[matindex]
                     material.R = Kd[0]
                     material.G = Kd[1]
                     material.B = Kd[2]
                     material.SpecR = Ks[0]
                     material.SpecG = Ks[1]
                     material.SpecB = Ks[2]
                     alpha = 1 - ((Ka[0]+Ka[1]+Ka[2])/3)
                     material.Alpha = alpha
                  else:
                     mtlflag = 0

                line = file.readline()
            file.close()

    elif words and words[0] == "usemtl":
        #if mtlflag == 1:
           name = words[1]
           matindex = AddMeshMaterial(name, materialList, matindex) 

elif words:

print “%s: %s” % (linenumber, words)

    linenumber = linenumber + 1
file.close()

# import in Blender

print "import into Blender ..."   
mesh   = NMesh.GetRaw ()

i = 0
while i &lt; vcount:	
  x, y, z = pointList[i] 
  vert=NMesh.Vert(x, y, z)
  mesh.verts.append(vert)
  i=i+1

if vtcount &gt; 0:
   mesh.has_uvco = 1
   print ("Object has uv coordinates")

if len(materialList) &gt; 0:
   mesh.mats = materialList 

total = len(faceList)
i = 0

for f in faceList:
    if i%1000 == 0:
      print ("Progress = "+ str(i)+"/"+ str(total))

    i = i + 1
    vi, ti, ni, matindex = f
    face=NMesh.Face()
    if len(materialList) &gt; 0:
       face.mat = matindex

    limit = len(vi)
    setcount = setcount + len(vi)
    c = 0    

    while c &lt; limit:                
      m = vi[c]-1
      if vtcount &gt; 0 and len(ti) &gt; c:
         n = ti[c]-1
      if vncount &gt; 0 and len(ni) &gt; c:
         p = ni[c]-1

      if vtcount &gt; 0:
         u, v = uvList[n] 
    #  multiply uv coordinates by 2 and add 1. Apparently blender uses uv range of 1 to 3 (not 0 to 1). 
         mesh.verts[m].uvco[0] = (u*2)+1
         mesh.verts[m].uvco[1] = (v*2)+1

      if vncount &gt; 0:
         if p &gt; len(normalList):
            print("normal len = " +str(len(normalList))+ " vector len = " +str(len(pointList)))
            print("p = " +str(p))
         x, y, z = normalList[p]  
         mesh.verts[m].no[0] = x
         mesh.verts[m].no[1] = y
         mesh.verts[m].no[2] = z
      c = c+1  
  
    if len(vi) &lt; 5:
      for index in vi:              
        face.v.append (mesh.verts[index-1])

      if vtcount &gt; 0:  
        for index in ti:
           u, v = uvList[index-1]
           face.uv.append((u,v))

      mesh.faces.append(face) 

print "all other (general) polygons ..."
for f in faceList:
    vi, ti, ni, matindex = f 
    if len(vi) &gt; 4:
        # export the polygon as edges
        print ("Odd face, vertices = "+ str(len(vi)))
        for i in range(len(vi)-2):
           face = NMesh.Face()
           if len(materialList) &gt; 0:
              face.mat = matindex
           face.v.append(mesh.verts[vi[0]-1])
           face.v.append(mesh.verts[vi[i+1]-1])
           face.v.append(mesh.verts[vi[i+2]-1])

           if vtcount &gt; 0: 
              if len(ti) &gt; i+2:
                 u, v = uvList[ti[0]-1]
                 face.uv.append((u,v))
                 u, v = uvList[ti[i+1]-1]
                 face.uv.append((u,v))
                 u, v = uvList[ti[i+2]-1]
                 face.uv.append((u,v))

           mesh.faces.append(face)
  
NMesh.PutRaw(mesh, Name,1)

print ("Total number of vertices is "+ str(vcount))
print ("Total number of faces is "+ str(len(faceList)))
print ("Total number of sets is "+ str(setcount))


print("Finished importing " +str(Name)+ ".obj")

#=========================================
def AddMeshMaterial(name, materialList, matindex):
#=========================================

index = 0
found = 0
limit = len(materialList)

while index < limit:
if materialList[index] == name:
matindex = index
found = 1
index = limit
index = index + 1

if found == 0:
materialList.append(name)
matindex = len(materialList)-1

return matindex

#=========================================
def AddGlobalMaterial (name, matindex):
#=========================================

index = 0
found = 0
matindex = 0
MatList = Material.Get()
limit = len(MatList)

while index < limit:
if MatList[index].name == name:
matindex = index
found = 1
index = limit
index = index + 1

if found == 0:
material = Blender210.Material(name)
matindex = index

return matindex

#================================
def ObjExport(FILE, Name, type):
#================================
global returncode
global vertexcount
global uvcount
global Transform
global multiflag
global exporttype

vertexcount = 0
uvcount = 0
returncode = 0
print(“Writing %s…” % Name)
FILE.write("# Wavefront OBJ (1.0) exported by lynx’s OBJ import/export script

")

Objects = Object.GetSelected()
if Objects == []:
print(“You have not selected an object!”)
returncode = 4
else:
for object in Objects:
MtlList = []
if len(Objects) > 1 or exporttype > 1:
Transform = CreateMatrix(object, Transform)
multiflag = 1
mesh = object.data
ObjName = mesh.name
has_uvco = mesh.has_uvco

    FILE.write("# Meshname:	%s

" % ObjName)

    faces = mesh.faces
    materials = mesh.mats
    Vertices = mesh.verts
    GlobalMaterials = Material.Get()

    if len(materials) &gt; 1 and len(GlobalMaterials) &gt; 0 and type &lt; 4:
       CreateMtlFile(Name, materials, MtlList)

    # Total Vertices and faces; comment if not useful
    FILE.write("# Total number of Faces:	%s

" % len(faces))
FILE.write("# Total number of Vertices: %s
" % len(Vertices))

    FILE.write("

")

    # print first image map for uvcoords to use
    # to be updated when we get access to other textures
    if mesh.has_uvco: FILE.write("# UV Texture:	%s

" % mesh.has_uvco)

    if len(materials) &gt; 1 and len(GlobalMaterials) &gt; 0 and type &lt; 3:
       UseLayers(faces, Vertices, MtlList, has_uvco, FILE, ObjName, Name)
    elif len(materials) &gt; 1 and len(GlobalMaterials) &gt; 0 and type == 3:
       UseMtl(faces, Vertices, MtlList, has_uvco, FILE, ObjName, Name)
    else:  
       Standard(faces, Vertices, has_uvco, FILE, ObjName)

#================================================
def CreateMtlFile (name, MeshMaterials, MtlList):
#================================================
global gFilename

# try to export materials
  directory, mtlname = os.path.split(gFilename.val)
  mtlname = name + ".mtl"
  filename = os.path.join(directory, mtlname)
  file = open(filename, "w")

  file.write("# Materials for %s.

" % (name + “.obj”))
file.write("# Created by Blender.
“)
file.write(”# These files must be in the same directory for the materials to be read correctly.

")

  MatList = Material.Get()

  counter = 1
  found = 0  

  for material in MeshMaterials:
     for mtl in MtlList:
        if material == mtl:
            found = 1

     MtlList.append(material) 
                  
     if found == 0: 
        file.write("newmtl %s 

" % material)
index = 0
while index < len(MatList):
if material == MatList[index].name:
mtl = MatList[index]
index = len(MatList)
found = 1
index = index + 1

        if found == 1:
           alpha = mtl.Alpha
           file.write("       Ka %s %s %s 

" % (1-alpha, 1-alpha, 1-alpha))
file.write(" Kd %s %s %s
" % (mtl.R, mtl.G, mtl.B))
file.write(" Ks %s %s %s
" % (mtl.SpecR, mtl.SpecG, mtl.SpecB))
file.write(" illum 1
“)
else:
file.write(” Ka %s %s %s
" % (0, 0, 0))
file.write(" Kd %s %s %s
" % (1, 1, 1))
file.write(" Ks %s %s %s
" % (1, 1, 1))
file.write(" illum 1
")

     found = 0

  file.flush()
  file.close()

#===========================================================
def Standard(faces, Vertices, has_uvco, FILE, ObjName):
#===========================================================
global vertexcount
global uvcount
global multiflag

   uvPtrs = []
   uvList = []

   FILE.write("o %s

" % (ObjName))
FILE.write("g %s

" % (ObjName))

   for v in Vertices: 
      vert = v.co 
      if multiflag  == 1:
         vert = Alter(vert, Transform) 
      x, y, z = vert
           
      FILE.write("v %s %s %s

" % (x, y, z))

   uv_flag = 0
   for face in faces:
     for uv in face.uv:            
        found = 0
        index = len(uvList)
        limit = 0
        if len(uvList)-200 &gt; 0:
           limit = len(uvList)-200
        while index &gt; limit and found == 0:
           uv_value = uvList[index-1]
           if uv[0] == uv_value[0] and uv[1] == uv_value[1]:
              uvPtrs.append(index+uvcount)
              found = 1
           index = index - 1
        if found == 0:
           uvList.append(uv)
           index = len(uvList)
           uvPtrs.append(index+uvcount)
           u, v = uv
           FILE.write("vt %s %s

" % (u, v))
uv_flag = 1

   if has_uvco and uv_flag == 0:
     for v in Vertices:  
        u, v, z = v.uvco 
        u = (u-1)/2
        v = (v-1)/2        
        FILE.write("vt %s %s

" % (u, v))

   for v in Vertices: 
      x, y, z = v.no         
      FILE.write("vn %s %s %s

" % (x, y, z))

   p = 0
   uvindex = 0
   total = len(faces)

   for face in faces:
      p = p+1
      if (p%1000) == 0:
          print ("Progress = "+ str(p)+ " of "+ str(total) +" faces")

      FILE.write("f ")
      for index in range(len(face.v)):
         v = face.v[index].index + vertexcount
         if len(face.uv) &gt; 0:
            FILE.write("%s/%s/%s " % (v+1, uvPtrs[uvindex], v+1))
            uvindex = uvindex+1
         elif has_uvco:
            FILE.write("%s/%s/%s " % (v+1, v+1, v+1))
         else:                     
            FILE.write("%s//%s " % (v+1, v+1))
      FILE.write("

")

   vertexcount = vertexcount + len(Vertices)
   uvcount = uvcount + len(uvList)

   print("Export of " +str(ObjName)+ ".obj finished.

")

#=====================================================================
def UseLayers(faces, Vertices, MtlList, has_uvco, FILE, ObjName, Name):
#=====================================================================
global vertexcount
global uvcount
global multiflag

   uvPtrs = []
   uvList = []

   FILE.write("mtllib %s

" % (Name + “.mtl”))
FILE.write("g %s

" % (ObjName))

   for v in Vertices: 
      vert = v.co 
      if multiflag  == 1:
         vert = Alter(vert, Transform)   
      x, y, z = vert
      FILE.write("v %s %s %s

" % (x, y, z))

   uv_flag = 0
   for m in range(len(MtlList)):         
      for face in faces:
          if face.mat == m:
             for uv in face.uv:
                found = 0
                index = len(uvList)
                limit = 0
                if len(uvList)-200 &gt; 0:
                   limit = len(uvList)-200
                while index &gt; limit and found == 0:
                   uv_value = uvList[index-1]
                   if uv[0] == uv_value[0] and uv[1] == uv_value[1]:
                      uvPtrs.append(index+uvcount)
                      found = 1
                   index = index - 1
                if found == 0:
                   uvList.append(uv)
                   index = len(uvList)
                   uvPtrs.append(index+uvcount)
                   u, v = uv
                   FILE.write("vt %s %s

" % (u, v))
uv_flag = 1

   if has_uvco and uv_flag == 0:
     for v in Vertices:  
        u, v, z = v.uvco  
        u = (u-1)/2
        v = (v-1)/2               
        FILE.write("vt %s %s

" % (u, v))

   for v in Vertices: 
      x, y, z = v.no         
      FILE.write("vn %s %s %s

" % (x, y, z))

   total = len(faces)
   p = 0
   uvindex = 0
   for m in range(len(MtlList)):         
      FILE.write("usemtl %s

" % (MtlList[m]))
for face in faces:
if face.mat == m:
p = p+1
if (p%1000) == 0:
print ("Progress = “+ str§+ " of “+ str(total) +” faces”)

            FILE.write("f ")
            for index in range(len(face.v)):
               v = face.v[index].index + vertexcount 
               if len(face.uv) &gt; 0:
                  FILE.write("%s/%s/%s " % (v+1, uvPtrs[uvindex], v+1))
                  uvindex = uvindex+1
               elif has_uvco:
                  FILE.write("%s/%s/%s " % (v+1, v+1, v+1))
               else:                     
                  FILE.write("%s//%s " % (v+1, v+1))
            FILE.write("

")

   vertexcount = vertexcount + len(Vertices) 
   print("Export of " +str(ObjName)+ ".obj using material layers finished.

")

#==================================================================
def UseMtl(faces, Vertices, MtlList, has_uvco, FILE, ObjName, Name):
#==================================================================
global vertexcount
global multiflag

   FILE.write("mtllib %s

" % (Name + “.mtl”))
FILE.write("o %s

" % (ObjName))

   index = 0
   VertexList = []
   for vertex in Vertices:
      VertexList.append(-1)
      index = index + 1
   print("number of vertices is " +str(len(VertexList)))

   Totalindex = 0
   ix = 0
   NewVertexList = []
   NewVertexCo = []
   for m in range(len(MtlList)):           
       # Group name is the name of the mesh 
       if MtlList[m]:          
          FILE.write("g %s

" % (MtlList[m]+str(m+1)))
else:
FILE.write("g %s
" % (“Null”+str(m+1)))
FILE.write("s off

")

       FILE.write("usemtl %s

" % (MtlList[m]))

       for face in faces:
          if face.mat == m:
             for vertex in face.v:
                v = vertex.index 
                if VertexList[v] &lt; 0:
                   VertexList[v] = Totalindex
                   NewVertexList.append(v)
                   Totalindex = Totalindex + 1

       for v_old in NewVertexList:    
          vert = Vertices[v_old].co 
          if multiflag  == 1:
            vert = Alter(vert, Transform) 
          x, y, z = vert         
          FILE.write("v %s %s %s

" % (x, y, z))
NewVertexCo.append([x,y,z])

       if has_uvco:
          for v_old in NewVertexList:
             u, v, z = Vertices[v_old].uvco   
             u = (u-1)/2
             v = (v-1)/2              
             FILE.write("vt %s %s

" % (u, v))

       for v_old in NewVertexList: 
          x, y, z = Vertices[v_old].no         
          FILE.write("vn %s %s %s

" % (x, y, z))

       for face in faces:
         if face.mat == m:
            FILE.write("f ")
            for index in range(len(face.v)):
               v = face.v[index].index
               v_new = VertexList[v] 
               if has_uvco:                     
                  FILE.write("%s/%s/%s " % (v_new+1, v_new+1, v_new+1))
               else:                     
                  FILE.write("%s//%s " % (v_new+1, v_new+1))
            FILE.write("

")

       FILE.write("

")

       NewVertexList = []
       print("Group " +str(m+1)+ " of " +str(len(MtlList))+ " finished.")

   print("Export of " +str(ObjName)+ ".obj using groups finished.

")

#========================================
def CreateMatrix(object, Transform):
#========================================
Mx = []
My = []
Mz = []
T1 = []
Transform = []

angle = object.RotX
Mx.append([1, 0, 0])
y = math.cos(angle)
z = -math.sin(angle)
Mx.append([0, y, z])
y = math.sin(angle)
z = math.cos(angle)
Mx.append([0, y, z])

angle = object.RotY
x = math.cos(angle)
z = math.sin(angle)
My.append([x, 0, z])
My.append([0, 1, 0])
x = -math.sin(angle)
z = math.cos(angle)
My.append([x, 0, z])

angle = object.RotZ
x = math.cos(angle)
y = -math.sin(angle)
Mz.append([x, y, 0])
x = math.sin(angle)
y = math.cos(angle)
Mz.append([x, y, 0])
Mz.append([0, 0, 1])

m0 = Mx[0]
m1 = Mx[1]
m2 = Mx[2]
for row in My:
x, y, z = row
nx = xm0[0] + ym1[0] + zm2[0]
ny = x
m0[1] + ym1[1] + zm2[1]
nz = xm0[2] + ym1[2] + z*m2[2]
T1.append([nx, ny, nz])

m0 = T1[0]
m1 = T1[1]
m2 = T1[2]
for row in Mz:
x, y, z = row
nx = xm0[0] + ym1[0] + zm2[0]
ny = x
m0[1] + ym1[1] + zm2[1]
nz = xm0[2] + ym1[2] + z*m2[2]
Transform.append([nx, ny, nz])

Transform.append([object.SizeX, object.SizeY, object.SizeZ])
Transform.append([object.LocX, object.LocY, object.LocZ])

return Transform

#======================================
def Alter(vect, Transform):
#======================================
v2 = []
nv = []

x, y, z = vect
sx, sy, sz = Transform[3]
lx, ly, lz = Transform[4]

v2.append(xsx)
v2.append(y
sy)
v2.append(z*sz)

for index in range(len(vect)):
t = Transform[index]
nv.append(v2[0]*t[0] + v2[1]*t[1] +v2[2]*t[2])

nv[0] = nv[0]+lx
nv[1] = nv[1]+ly
nv[2] = nv[2]+lz

return nv


(Schlops) #2
  1. Do a search on the forum how to set your Pythonpath (damn, we really need a sticky Python-FAQ). This will solve your os-problem
  2. Don’t user publisher 2.25 for this script, use an older version (2.23) instead. This will solve the blender210-problem.
  3. Please don’t post the whole script. It’s better to post the name (and author and possibly a link) and the complete error-message.