Blender.Object.New(Blender.Object.Types['LAMP'])
L=Blender.Object.GetSelected()[0]
lampe=Blender.Lamp.Get(L.data.name)

# test de validation de la création
print lampe.name

# Il ne reste plus qu''a modifier ce qui est modifiable
# avec le module Lamp...
#...
 

for X in range(10):
  for  Y in range(10):

   Blender.Object.New(Blender.Object.Types['LAMP'])
   L=Blender.Object.GetSelected()[0]
   lampe=Blender.Lamp.Get(L.data.name)

   L.LocX=X 
   L.LocY=Y

   print lampe.name
Blender.Redraw()

import Blender
import math
from math import *
from Blender import Object,NMesh

def multmat(M,x,y,z):

    x1 = (x * M[0][0]) + (y * M[1][0]) + (z * M[2][0]) + M[3][0]
    y1 = (x * M[0][1]) + (y * M[1][1]) + (z * M[2][1]) + M[3][1]
    z1 = (x * M[0][2]) + (y * M[1][2]) + (z * M[2][2]) + M[3][2]
    return x1,y1,z1

Me=Object.GetSelected()
if len(Me)>=0:
       me=NMesh.GetRaw(Me[0].data.name)

       for s in me.verts:
         Blender.Object.New(Blender.Object.Types['LAMP'])

         L=Blender.Object.GetSelected()[0] 
         # ------------------------------
         #  le dernier objet 
         # crée est toujours selectionné,
         #  plus facile pour recuperer . Il est aussi 
         #  possible de lier l'objet à la scene . Cette
         # methose étant plus sure pour identifier 
         # l'objet dans la base de données de 
         # Blender .
         # ------------------------------
         lampe=Blender.Lamp.Get(L.data.name) 
         # ------------------------------
         #...nom, qui donnera 
         # acces a l'objet lui-même.
         # ------------------------------

         lampe.type=2           # type spot
         lampe.Dist=15.0       # distance sur  laquelle le spot projette sa lumière
         lampe.Energ=0.05    # énergie, plutôt basse pour ne pas saturer
         lampe.SpoSi=120.0  # angle d'ouverture du cone lumineux
         lampe.SpoBl=0.7      # largeur de la frange de pénombre

         # commencer à modifier l'emplacement de l'objet
         L=Blender.Object.Get(L.name)

         # replacer les coordonnées du sommet dans l'espace de la scène
         x,y,z=multmat(Me[0].mat,s.co[0],s.co[1],s.co[2]) # pour resituer la position
                                                                                     # réelle du point
         # positionner l'objet lampe sur le 
         L.LocX=x
         L.LocY=y
         L.LocZ=z

         # positionner la normale sur le sommet
         xa=s.no[0]+s.co[0]
         da=s.no[1]+s.co[1]
         wi=s.no[2]+s.co[2]

         # recalculer la position de la normale par rapport à l'espace de la scène
         al,be,ga=multmat(Me[0].mat,xa,da,wi)

         # renvoyer la normale vers l'origine
         s.no[0]=al-x
         s.no[1]=be-y
         s.no[2]=ga-z

         # calculer la longueur du vecteur 
         norm=sqrt(s.no[0]**2+s.no[1]**2+s.no[2]**2)

         # normaliser
         s.no[0]=s.no[0]/norm
         s.no[1]=s.no[1]/norm
         s.no[2]=s.no[2]/norm

         # print s.no[0], s.no[1], s.no[2]

         if abs(s.no[1])<0.0001:
          s.no[1]=0.0
         L.RotX=0
         teta=-acos(s.no[2])
         L.RotY=-pi+teta

         if s.no[1]!=0:
          L.RotZ=-acos(s.no[0]/sin(teta))*s.no[1]/abs(s.no[1])
         else:
          L.RotZ=0
          if s.no[0]>0:
           L.RotY=-L.RotY

Blender.Redraw()

import Blender
from Blender import *

#--------------------------
#  distance a laquelle seront placees les lampes
#--------------------------
rayon=15.0

#--------------------------
# controle du numero de version
#--------------------------
version=Blender.Get('version')

#--------------------------
# adresse du fichier
#--------------------------
filename="G:/stock_logiciel_et_plugin/hdrshop/test.txt"

if version>=225: 
   #--------------------------
   #  recuperation de la scene
   #--------------------------
   scene=Scene.getCurrent()

f=open(filename,"r")
tableau=f.readlines()
f.close()

for n in range(len(tableau)):
    if tableau[n].find('Color:')!=-1:
       c=tableau[n].split(' ')
       print c
       if version>=225:
          #--------------------------
          # creation de l'objet
          #--------------------------
          objet=Object.New(Object.Types['LAMP'])
          # -->  utilisation des champs de couleurs RVB
          if tableau[n+1].find('Direction:')!=-1:
             d=tableau[n+1].split(' ')
             objet.loc=(float(d[1])*rayon,float(d[2])*rayon,float(d[3])*rayon)

          #--------------------------
          # creation des donnes
          #--------------------------
          lampe=Lamp.New('Lamp')
          # -->  utilisation des champs de couleurs RVB
          lampe.R=float(c[2])/256.0
          lampe.G=float(c[3])/256.0
          lampe.B=float(c[4])/256.0

          #--------------------------
          # connexion des donnes a l'objet
          #-------------------------- 
          objet.link(lampe)
          #
          #--------------------------
          # connexion de l'objet a la scene
          #-------------------------- 
          scene.link(objet) 

import Blender
from math import *

def oriente(s,ori):
                  xyz=Blender.Mathutils.Vector(ori.mat*s)
                  xadawi=Blender.Mathutils.Vector(s+s) 
                  albega=Blender.Mathutils.Vector(ori.mat*xadawi)
                  s= albega-xyz
                  s.normalize()
                  if abs(s[1])<0.0001:
                   s[1]=0.0
                  RotX=0
                  teta=-acos(s[2])
                  RotY=-pi+teta
                  if s[1]!=0:
                   RotZ=-acos(s[0]/sin(teta))*s[1]/abs(s[1])
                  else:
                   RotZ=0
                   if s[0]>0:
                    RotY=-RotY
                  return [RotX, RotY, RotZ] 

def cree_objet(ob,col,pos, rad, ori , energy, cmax):
     O = Blender.Object.New (ob)
     obj= O.getData()
     O.link (obj)
     if ob=='Lamp':
                  obj.setType('Spot') 
                  obj.type=2 
                  # type spot
                  obj.dist=rad*2.5
                  # ------------------------------
                  # distance sur  laquelle le spot projette sa lumière
                  # ------------------------------
                  obj.energy=energy 
                  # ------------------------------
                  # energie, plutôt basse pour ne pas saturer
                  # ------------------------------
                  obj.spotSize=120.0 
                  # ------------------------------
                  # angle d'ouverture du cone lumineux
                  # ------------------------------
                  obj.spotBlend=0.7 
                  # ------------------------------
                  # largeur de la frange de penombre
                  # ------------------------------
                  obj.setMode('Shadows') 
                  # ------------------------------
                  # utilisation des ombres 
                  # ------------------------------
                  for m in [0,1,2]:
                      col[m]/=cmax
                  # ------------
                  #  Champs de reglage des couleurs
                  # -------------
                  obj.col=col[:]

                  print col[0], obj.col[0] 

     O.setEuler(oriente(Blender.Mathutils.Vector([-pos[0],-pos[1],-pos[2]]),ori))
     for m in [0,1,2]:
        pos[m]*=rad
     O.setLocation(pos)

     return O

#--------------------------
#  distance a laquelle seront placees les lampes
#--------------------------
rayon=30.0

#--------------------------
# controle du numero de version
#--------------------------
version=Blender.Get('version')
 

def cree_leslampes(filename):

    f=open(filename,"r")
    tableau=f.readlines()
    f.close()

    c=[[],[]]
    cmax=[0.0,0.0,0.0]

    for n in range(len(tableau)):

        if tableau[n].find('Color:')!=-1:
           c[0].append(tableau[n].split(' '))
           C=c[0][-1]
           print 'C   :  ', C 
           C[-1]=C[-1][:-1] 
           del C[0:2]
           print 'C   :  ', C 
           for m in [0,1,2]:
              C[m]=round(float(C[m]),8)
              print 'm :',m,' , ',C[m] 
              if C[m]>cmax[m]:
                 cmax[m]=C[m]

           if tableau[n+1].find('Direction:')!=-1:
               c[1].append(tableau[n+1].split(' '))
               D=c[1][-1]
               D[-1]=D[-1][:-1] 
               del D[0:1]
               D[-1]=D[-1][:-1]
               for m in [0,1,2]:
                   D[m]=round(float(D[m]),5)

           print c[0][-1],c[1][-1]

    cmax.sort()
    print cmax
    energy=1.0
    intensite=1.0

    energy=1000.0/cmax[2]*intensite

    n=0
    scene = Blender.Scene.getCurrent ()

    try:
      ori=Blender.Object.Get('origine')
    except:
      object=Blender.Object.New('Empty','origine')
      object.LocX=0.0
      object.LocZ=0.0
      object.LocY=0.0
      object.RotX=0.0
      object.RotZ=0.0
      object.RotY=0.0
      scene.link (object)
      ori=Blender.Object.Get('origine')

    for L in c[0]:
        scene.link (cree_objet('Lamp',
                   L,
                   c[1][n],
                   rayon, 
                   ori, 
                   energy, cmax[2]) )
        n+=1 
    Blender.Redraw()

Blender.Window.FileSelector(cree_leslampes,'SELECT LIGHTS FILE')

import Blender
import math
from math import *
from Blender import Object,NMesh

def multmat(M,x,y,z):

    x1 = (x * M[0][0]) + (y * M[1][0]) + (z * M[2][0]) + M[3][0]
    y1 = (x * M[0][1]) + (y * M[1][1]) + (z * M[2][1]) + M[3][1]
    z1 = (x * M[0][2]) + (y * M[1][2]) + (z * M[2][2]) + M[3][2]
    return x1,y1,z1

Me=Object.GetSelected()
 

scene = Blender.Scene.getCurrent ()

if len(Me)>0:
       me=NMesh.GetRawFromObject(Me[0].name)

       for s in me.verts:
         L=Blender.Object.New('Lamp')
         scene.link (L)

         lampe = Blender.Lamp.New ('Spot')
         L.link (lampe) 

         # ------------
         # type spot
         # ------------
         lampe.type=2 
         # ------------
         #distance sur  laquelle le spot projette sa lumière
         # ------------
         lampe.dist=15.0
         # ------------ 
         # energie, plutôt basse pour ne pas saturer 
         # ------------
         lampe.energy=0.05 
         # ------------
         # angle d'ouverture du cone lumineux 
         # ------------
         lampe.spotSize=120.0 
         # ------------
         # largeur de la frange de penombre
         # ------------
         lampe.spotBlend=0.7
         # ------------
         # pour resituer la position reelle du point
         # il est aussi possible d'utiliser la fonction transform
         # ------------
         x,y,z=multmat(Me[0].mat,s.co[0],s.co[1],s.co[2])
 

         L.LocX=x
         L.LocY=y
         L.LocZ=z

         xa=s.no[0]+s.co[0]
         da=s.no[1]+s.co[1]
         wi=s.no[2]+s.co[2]

         al,be,ga=multmat(Me[0].mat,xa,da,wi)

         s.no[0]=al-x
         s.no[1]=be-y
         s.no[2]=ga-z

         norm=sqrt(s.no[0]**2+s.no[1]**2+s.no[2]**2)

         s.no[0]=s.no[0]/norm
         s.no[1]=s.no[1]/norm
         s.no[2]=s.no[2]/norm

         #print s.no[0], s.no[1], s.no[2]

         if abs(s.no[1])<0.0001:
          s.no[1]=0.0
         L.RotX=0
         teta=-acos(s.no[2])
         L.RotY=-pi+teta

         if s.no[1]!=0:
           if s.no[0]/sin(teta)>1.0 :
             AC= acos(1.0)
           elif s.no[0]/sin(teta)<1.0 :
             AC= acos(-1.0)
           else :
             AC= acos(s.no[0]/sin(teta)) 
           L.RotZ=-AC*s.no[1]/abs(s.no[1])
         else:
          L.RotZ=0
          if s.no[0]>0:
           L.RotY=-L.RotY
 
 

Blender.Redraw()

""" Registration info for Blender menus: <- these words are ignored
Name: 'Dupli Object'
Blender: 242
Group: 'Object'
Tip: 'Duplicate Object on mesh vertices with various options'
"""
#----------------------------------------------
# jm soler  05/2004 :   'Dupli Object' v0.8
# last update 09/04/2007
#----------------------------------------------
# Page officielle :
#   http://jmsoler.free.fr/didacticiel/blender/tutor/cpl_b223new.htm#duplicopy232
# Communiquer les problemes et erreurs sur:
#   http://www.zoo-logique.org/3D.Blender/newsportal/thread.php?group=3D.Blender
#--------------------------------------------- 
import Blender
import math
from math import *
from Blender import Object, NMesh, Noise
from Blender.Draw import *
from Blender.BGL import *

#  -------------------
#   Definitions par defaut 
#  -------------------
# default definitions
#  -------------------

#  -------------------
#  duplique les donnees du second objet selectionne 
#  sur la position de chaque sommet du premier
#  si c'est un mesh . Ne fait rien si c'est un 
#  autre type d'objet. 
#  -------------------
#  dupli data of the second selected object
#  on vert pos of the first one if it is
#  a real mesh, otherwize nothing
#  -------------------
DUPLI=1

#  -------------------
#  Cree completement l'objet et les donnees
#  -------------------
#   create complete object with data 
#  -------------------
NEW=0
NONE=-1
#  -------------------
#  gere la valeur de NEW et DUPLI
#  -------------------
#  NEW et DUPLI value
#  -------------------
Type=[DUPLI,NEW,NONE]
TYPE=Type[0]

#  -------------------
#  modifier aussi les valeurs de taillle
#  -------------------
#  change size too
#  -------------------
SIZE=0

# Choisir MODE in ['random','normal','none', 'color']
mode=['normal','random', 'color','none']
MODE=mode[0]

objettype=['Armature', 'Camera', 'Curve', 'Lamp', 'Mesh','Empty']
OBJET=objettype[3]

Ob=None
 

def multmat(M,x,y,z):
 x1 = (x * M[0][0]) + (y * M[1][0]) + (z * M[2][0]) + M[3][0]
 y1 = (x * M[0][1]) + (y * M[1][1]) + (z * M[2][1]) + M[3][1]
 z1 = (x * M[0][2]) + (y * M[1][2]) + (z * M[2][2]) + M[3][2]
 return x1,y1,z1

def dupli_objet(TYPE,obj,Ob):
      global SELMenu
      scene = Blender.Scene.getCurrent() 

      if TYPE==DUPLI and Ob!=None:
         O = Blender.Object.New (obj)
         scene = Blender.Scene.getCurrent() 
         scene.link (O)
         O.shareFrom(Ob)
         objet=Ob.getData()

      elif TYPE==NEW and Ob!=None: 
         if obj in objettype and obj!='Empty' and obj!='Mesh':
            O = Blender.Object.New (obj)
            scene.link (O)
            objet=Ob.getData()
            O.link (objet)
            if SELMenu.val==2 and obj=='Lamp': 
               O.getData().setType('Spot') 
            #exec "objet = Blender.%s.New ('%s')"%(obj,obj)
         elif  obj!='Mesh' :
               O = Blender.Object.New (obj)
               scene.link (O)
               O.link (objet)
         elif  obj=='Mesh':
               O = Blender.Object.New (obj)
               scene.link (O)
               objet=Blender.NMesh.GetRaw(Ob.data.name)
               O.link (objet)
         else:
            objet=None

      elif TYPE==NEW:
         O = Blender.Object.New ('Lamp')
         objet = Blender.Lamp.New ('Spot')
         O.link (objet)
      else:
          O=None
          objet=None

      if O!=None:
         O.Layer = 2**(CAMenu.val-1) 
         #scene.link (O)

      return O,objet
 
 

def obj2mesh():
    global MODE,ob,Ob,TYPE, SELvert,SELMenu 
 

    Me=Object.GetSelected()

    if len(Me)>=0:
      if Me[0].getType()=='Mesh':
        me=NMesh.GetRaw(Me[0].getData().name)

        if TYPE==DUPLI and len(Me)>1:
            Ob=Me[1]
            ob=Ob.getType()

        elif TYPE==NEW and len(Me)>1:
            Ob=Me[1]
            ob=Ob.getType()
        else:
            Ob=None
            ob=None

        if Ob!=None and ob!=None:
          for s in me.verts:
            numb=-1 
            while numb==-1 or numb==0 or numb==len(Me):
                 numb=int( round(Noise.random()*len(Me)))
            print numb 

            Ob=Me[numb]
            ob=Ob.getType()

            ok=1

            if SELvert.val :
              if s.sel==1:
                 ok=1
              else:
                 ok=0

            if ok==1: 
              O,obj=dupli_objet(TYPE,ob,Ob) 
              if ob=='Lamp':
                  obj.type=2       # type spot
                  obj.dist=15.0    # distance sur  laquelle le spot projette sa lumière
                  obj.energy=0.5   # energie, plutôt basse pour ne pas saturer
                  obj.spotSize=120.0  # angle d'ouverture du cone lumineux
                  obj.spotBlend=0.7    # largeur de la frange de penombre
                  obj.mode=9
                  #try:
                  if me.hasVertexColours()==1:
                     for d in me.faces:
                       if s in d.v:
                          print d.col[d.v.index(s)].r/255.0
                          obj.R=d.col[d.v.index(s)].r/255.0 
                          obj.G=d.col[d.v.index(s)].g/255.0
                          obj.B=d.col[d.v.index(s)].b/255.0
                          break

              #except:
              #     pass 

              if MODE!='none': 
                  x,y,z=multmat(Me[0].mat,s.co[0],s.co[1],s.co[2])
                  # pour resituer la position
                  # reelle du point

                  O.LocX=x
                  O.LocY=y
                  O.LocZ=z

                  xa=s.no[0]+s.co[0]
                  da=s.no[1]+s.co[1]
                  wi=s.no[2]+s.co[2]

                  al,be,ga=multmat(Me[0].mat,xa,da,wi)

                  s.no[0]=al-x
                  s.no[1]=be-y
                  s.no[2]=ga-z

                  norm=sqrt(s.no[0]**2+s.no[1]**2+s.no[2]**2)

                  s.no[0]=s.no[0]/norm
                  s.no[1]=s.no[1]/norm
                  s.no[2]=s.no[2]/norm

                  #print s.no[0], s.no[1], s.no[2]

                  if abs(s.no[1])<0.0001:
                   s.no[1]=0.0
                  O.RotX=0
                  teta=-acos(s.no[2])
                  O.RotY=-pi+teta

                  if s.no[1]!=0:
                     if s.no[0]/sin(teta)>1.0 :
                       AC=acos(1.0)
                     elif s.no[0]/sin(teta)<1.0 :
                       AC=acos(-1.0)
                     else :
                       AC=acos(s.no[0]/sin(teta))

                     O.RotZ=-acos(s.no[0]/sin(teta))*s.no[1]/abs(s.no[1])
                  else:
                   O.RotZ=0
                   if s.no[0]>0:
                    O.RotY=-O.RotY

                  if MODE=='random':
                     #print O.RotY 
                     O.RotX=Noise.random()*2*math.pi
                     O.RotY=Noise.random()*2*math.pi
                     O.RotZ=Noise.random()*2*math.pi

                  if MODE=='color':
                     if me.hasVertexColours()==1:
                        for d in me.faces:
                          if s in d.v:
                            #print d.col[d.v.index(s)].r/255.0*2*math.pi
                            O.RotX=d.col[d.v.index(s)].r/255.0*2*math.pi
                            O.RotY=d.col[d.v.index(s)].g/255.0*2*math.pi
                            O.RotZ=d.col[d.v.index(s)].b/255.0*2*math.pi
                            break
MOname = "MODE MENU %t|Normal %x1|Random %x2|color %x3|None %x4"

CAname="LAYER %t"
for n in range(20):
    CAname=CAname+"|%s %%x%s"%(n,n+1)

SELname="OBJET %t|Selected %x1|STND LAMP %x2|NOTHING %x3"

MODEMenu = Create(1)
CAMenu = Create(1)
SELMenu = Create(1)

SELvert = Create(0)
TTYPE  =  Create(1)
TSIZE  =  Create(0)

def draw():
    global MODEMenu, TSIZE, TTYPE,CAMenu ,MOMenu ,SELMenu, SELvert

    size=Buffer(GL_FLOAT, 4)
    glGetFloatv(GL_SCISSOR_BOX, size)
    size= size.list
    for s in [0,1,2,3]: size[s]=int(size[s])

    glClear(GL_COLOR_BUFFER_BIT)

    glColor3f(0.0,0.0,0.0)
    glRectf(4,size[3],534,size[3]-32 )
    glColor3f(1.0,1.0,1.0)

    glRasterPos2f(20, size[3]-15)
    Text("Script Python de duplication d'objet")
    glRasterPos2f(20, size[3]-28)
    Text("Jean-michel Soler, avril 2004")
 

    n0=78
    n1=55

    Button("Exit"                  ,1  ,140  ,size[3]-n0 ,60 ,20) 
    Button("Action"                ,16  ,200  ,size[3]-n0 ,60 ,20) 

    MODEMenu= Menu(MOname,            2  ,20  ,size[3]-n0-20 ,100,20, MODEMenu.val, "MODE menu.")
    CAMenu= Menu(CAname,              2  ,150  ,size[3]-n0-20 ,40,20, CAMenu.val, "LAYER menu.")
    SELMenu= Menu(SELname,            2  ,220  ,size[3]-n0-20 ,100,20, SELMenu.val, "SELECTED OBJECT menu.")

    if TTYPE.val==1:
        ttname='Dupli'
    else:
        ttname='New'

    TTYPE= Toggle(ttname,           3, 20, size[3]-n0+20 ,120  ,20, TTYPE.val, "Type de Copie")

    if SELvert.val==1:
        tvname='Sel Verts'
    else:
        tvname='All Verts'

    SELvert= Toggle(tvname,           4, 200, size[3]-n0+20 ,120  ,20, SELvert.val, "Type de Copie")
 

def event(evt, val): 
    if (evt== QKEY and not val): Exit()

def bevent(evt):
    global MODEMenu, TSIZE, TTYPE, MODE, TYPE

    if   (evt== 1):
        Exit()

    elif (evt== 2):
        MODE=mode[MODEMenu.val-1]
        #print MODE

    elif (evt== 3):
       if TTYPE.val==1:
            TYPE=DUPLI
       else:
            TYPE=NEW

    elif   (evt== 16):
       MODE=mode[MODEMenu.val-1]
       if TTYPE.val==1:
            TYPE=DUPLI
       else:
            TYPE=NEW
       obj2mesh()

    Blender.Redraw()

Register(draw, event, bevent)

# -------------------------
# on doit avoir acces a la scene courante 
# -------------------------
scn=Scene.GetCurrent()

# -------------------------
# On se branche sur la liste des objets selectionnes
# -------------------------
ob = Object.GetSelected()[0]

# -------------------------
# On doit recupérer la forme du mesh après modifications et
# animations diverses et pour cela on doit effectuer les operations 
# suivantes :
# 1/ creation d'un nouveau mesh
# -------------------------
me0 = Mesh.New() 

# -------------------------
# 2/ copie sur ce mesh de l'etat de l'objet mesh a cet instant
# -------------------------
me0.getFromObject(ob.name)

# -------------------------
# 3/ les sommets étants situes dans l'espace local 
#   il faut les transfere dans lespace global de la scene
# ------------------------- 
me0.transform(ob.matrix)

ob2 = Object.GetSelected()[1]
me2 = ob2.getData(name_only=False, mesh=True)

objects=[]
for v in me0.verts :
    ob3 = Object.New('Mesh', "result")
    me3 = me2.__copy__() 
    ob3.link(me3)
    ob3.setLocation (v.co[0],v.co[1],v.co[2])
    scn.objects.link(ob3)
    objects.append(ob3)

ob3.join(objects) 
for o in objects[:-1]:
    scn.objects.unlink(o)

Redraw()