Bielefeld Augmented Reality Tracker

import bpy

from math import sqrt 

import random       

class PositionenAusgeben(bpy.types.Operator):

    """Gibt die Distanz, Orientierung und Position im Koordinatensystem der Kamera aus"""

    bl_idname = "print_object.position"

    bl_label = "Position ausgeben"

    # Wird ausgeführt um zu testen, ob die Operation des Operators möglich ist.

    @classmethod

    def poll(cls, context):

        return ((bpy.context.scene.markerRender.kameraID in bpy.context.scene.objects.keys()) and (bpy.context.scene.markerRender.markerID in bpy.context.scene.objects.keys() or bpy.context.scene.markerRender.markerID == "") and (bpy.context.scene.markerRender.dateipfad != ""))

    # Gibt die Distanz, Orientierung und Position im Koordinatensystem der Kamera aus

    def execute(self, context):

        model = bpy.context.scene.markerRender

        dateipfad = bpy.path.abspath(model.dateipfad)

        ausgabedatei= open(bpy.path.ensure_ext(dateipfad,".txt"),mode='w')

        csvAusgabe= open(bpy.path.ensure_ext(dateipfad,".csv"),mode='w')

        bildnummer = 0

        bpy.context.scene.frame_current = bpy.context.scene.frame_start

        while(bildnummer <=  (bpy.context.scene.frame_end/bpy.context.scene.frame_step)):

            bpy.context.scene.frame_set(bpy.context.scene.frame_start + bildnummer * bpy.context.scene.frame_step)

            self.bildVerarbeiten(context,csvAusgabe,ausgabedatei,(bildnummer+1))

            bildnummer += 1

        ausgabedatei.flush()

        ausgabedatei.close()

        csvAusgabe.flush()

        csvAusgabe.close()

        print("Positionen nach",bpy.path.ensure_ext(dateipfad,".txt"),"und",bpy.path.ensure_ext(dateipfad,".csv"),"ausgegeben")

        return {'FINISHED'}

    # Wird für jedes Bild einmal ausgeführt    

    def bildVerarbeiten(self, context, csvAusgabe, ausgabedatei, bildnummer):

        model = bpy.context.scene.markerRender

        kamera = context.scene.objects[model.kameraID]

        print("Bild",(bildnummer-1),file=ausgabedatei)

        print(" Kamera Position: (",end="",file=ausgabedatei)

        print(kamera.location.x, kamera.location.y, kamera.location.z,sep=",",end="",file=ausgabedatei)

        print(")",file=ausgabedatei)

        if(model.markerID == ""):

            zaehler = 0

            zuEntfernen = []

            for id in model.markerIDs:

                if(id.value in context.scene.objects.keys()):    

                    object = context.scene.objects[id.value]

                    if(not object.hide_render):

                        self.markerVerarbeiten(object,kamera,ausgabedatei,csvAusgabe,model,bildnummer)

                        zaehler += 1

                else:

                    print("INFO: Vermisse "+id.value+" in "+str(context.scene.objects.keys()))

                    zuEntfernen.append(zaehler)

            # Überflüssige Schlüssel entfernen

            for schluessel in zuEntfernen:   

                model.markerIDs.remove(schluessel)

        else: 

            object = context.scene.objects[model.markerID]

            self.markerVerarbeiten(object,kamera,ausgabedatei,csvAusgabe,model)

    def achsendatenAusgeben(self, dist,object,csvAusgabe):

        print(dist,sep=",",file=csvAusgabe)

    # wird für jeden Marker ausgeführt

    def markerVerarbeiten(self, object, kamera, ausgabedatei, csvAusgabe, model, bildnummer):

        dist = distanz(object.location.x,object.location.y,object.location.z,kamera.location.x,kamera.location.y,kamera.location.z)

        print(" ",object.name,"Position: (",end="",file=ausgabedatei)

        print(object.location.x, object.location.y, object.location.z,sep=",",end="",file=ausgabedatei)

        print(")",file=ausgabedatei)

        print(" ",object.name,"Distanz:",end=" ",file=ausgabedatei)

        print(dist,sep=",",file=ausgabedatei)

        #Testet, ob es einen einfachen Weg gibt an die Transformationsmatrix zwischen kamera und Objekt zu gelangen

        if(object.parent != None and object.parent == kamera):

            matrix = object.matrix_local 

        elif(object.parent != None and object.parent.parent != None and object.parent.parent == kamera):

            matrix = object.parent.matrix_local*object.matrix_local

        else:

            #Es gibt keinen einfachen Weg :(

            print("Warnung: Invertierte globale Matritzen verwendet. Das ist weniger genau. Überlege, ob die Marker Kinder der Kamera oder eines ihrer direkten Kinder werden können.")

            print("Warnung: Invertierte globale Matritzen verwendet. Das ist weniger genau. Überlege, ob die Marker Kinder der Kamera oder eines ihrer direkten Kinder werden können.",file=ausgabedatei)

            matrix = kamera.matrix_world.inverted_safe()*object.matrix_world

        #An diesem Punkt enthält matrix die Transformationsmatrix zwischen Marker und Kamera

        # Gibt nach und nach die Bildnummer, die Markerid, die Rotationsmatrix, den Translationsvektor usw. aus

        if(matrix != None):    

            print(" ",object.name,"Transformation bezüglich der Kamera:",file=ausgabedatei)

            if(object.marker_id != None):

                print(bildnummer,object.marker_id,sep=",",end=",",file=csvAusgabe)

            else:

                print(bildnummer,-1.0,sep=",",file=csvAusgabe)

            spalte = 0

            while(spalte < len(matrix[0])):

               line = 0

               print("   ",end="",file=ausgabedatei)

               while(line < len(matrix)):

                   print(matrix[line][spalte],end=", ",file=ausgabedatei)

                   if(not ((line%4) == 3)):

                       print(matrix[line][spalte],end=",",file=csvAusgabe)

                   line += 1

               print("",file=ausgabedatei)

               spalte += 1

            print("",file=ausgabedatei)

            print(matrix[3][3],end=",",file=csvAusgabe)

            self.achsendatenAusgeben(dist, object, csvAusgabe)

#class EulerwinkelAusgeben(PositionenAusgeben):

 #   """Gibt auch die Eulerwinkel für Achsenbeschriftungen aus"""

  #  bl_idname = "print_object.rotation"

   # bl_label = "Include Rotation"

    #

    #def achsendatenAusgeben(self,dist,object,csvAusgabe):

     #   euler = object.rotation_euler

      #  print(dist,euler.x,euler.y,euler.z,sep=",",file=csvAusgabe)

class MarkerHinzufuegen(bpy.types.Operator):

    """Erzeugt ein neues flaches Objekt fügt es der Szene hinzu und versieht es mit entsprechenden Texturen und Attributen"""

    bl_idname = "mesh.primitive_marker_add"

    bl_label  = "Marker hinzufügen"

    # Wird ausgeführt um zu testen, ob die Operation des Operators möglich ist.

    @classmethod

    def poll(cls, context):

        return context.mode == "OBJECT"

    # Wird ausgeführt, um einen neuen Marker hinzuzufügen

    def execute(self, context):

        markerID = str (bpy.context.scene.markerRender.newMarkerID)

        bpy.ops.object.select_all(action="DESELECT")

        markerIDSuffix = ""

        zaehler = 1

        while("Marker_"+markerID+markerIDSuffix in bpy.data.objects.keys()):

            markerIDSuffix = ".0"+str (zaehler)

            zaehler += 1

        #Erstellt Mesh

        bpy.ops.mesh.primitive_cube_add(radius=0.5)

        context.selected_objects[0].name = "Marker_"+markerID+markerIDSuffix

        bildschirm = context.screen

        gliederungGefunden = False

        for bereich in bildschirm.areas:

            if bereich.type == 'OUTLINER':

                gliederungGefunden = True

                kontextUeberschreiben = {'screen': bildschirm, 'area': bereich}

                bpy.ops.outliner.parent_drop(kontextUeberschreiben,child=context.selected_objects[0].name, parent=bpy.context.scene.markerRender.kameraID)

                break 

        if(not gliederungGefunden):

            print("Skipped reparenting. Please activate Outliner!")

        context.selected_objects[0].scale[2] = 0.005

        plane = context.selected_objects[0].data

        bpy.data.objects["Marker_"+markerID+markerIDSuffix].marker_id = bpy.context.scene.markerRender.newMarkerID

        #Erstellt Material

        bpy.ops.material.new()

        material = bpy.data.materials[-1]

        bpy.data.materials[-1].name = "Marker_"+markerID+markerIDSuffix

        #Erstellt Texturen

        material = createTexture(markerID,bpy.context.scene.markerRender.kontrastErhoehen,"//BART_Marker/","Marker","BART_Marker_",'BART',material)

        material = createTexture(markerID,bpy.context.scene.markerRender.kontrastErhoehen,"//ALVAR_Marker/","MarkerData_","ALVAR_Marker_",'ALVAR',material)

        #Weist Material zu

        plane.materials.append(material)

        #In Liste einhängen

        knoten       = bpy.context.scene.markerRender.markerIDs.add()

        knoten.value = "Marker_"+markerID+markerIDSuffix

        #Unwrap (nur der obenliegenden Seite)

        bpy.ops.object.editmode_toggle()

        bpy.ops.mesh.select_all(action="DESELECT")

        bpy.ops.object.editmode_toggle() 

        bpy.data.objects["Marker_"+markerID+markerIDSuffix].data.polygons[5].select = True

        bpy.ops.object.editmode_toggle() 

        bpy.ops.uv.unwrap()

        bpy.ops.object.editmode_toggle() 

        if(bpy.context.scene.markerRender.incrementNewMarkerID):

            bpy.context.scene.markerRender.newMarkerID+=1

        return {'FINISHED'}

class MarkerRandomisieren(bpy.types.Operator):

    """Randomisiert die Markerid des ausgewählten Markers"""

    bl_idname = "mesh.randomize_marker"

    bl_label  = "Marker randomisieren"

    # Wird ausgeführt um zu testen, ob die Operation des Operators möglich ist.

    @classmethod

    def poll(self,context):

        return True #context.object.marker_id > -1

    def execute(self, context):

        ursprungsbild = context.scene.frame_current

        #Fange beim ersten Frame an

        context.scene.frame_current = 1

        #Suche nach einem geeigneten Material

        object = context.object

        original_id = object.marker_id

        object.keyframe_insert("marker_id",frame=1)

        material_index = object.material_slots.find("Marker_"+str(original_id))

        if(material_index == -1):

            # Die ID wurde leider verändert! Suche Material.

            # Da der Marker nur wenige Materialien enthalten dürften, sollte dieser Test schnell sein.

            material = None

            for material_slot in object.material_slots:

                for texture_slot in material_slot.material.texture_slots:

                    if (texture_slot != None and texture_slot.texture.marker_id > -1):

                        material = material_slot.material

                        print("Warning: Using",material.name)

                        break

            if(material == None):

                print("Could not randomise marker. Unable to find appropriate material.")

                return {'CANCELLED'} 

        else:

            material = object.material_slots[material_index].material

        material.keyframe_insert("use_textures",options={'INSERTKEY_NEEDED'})

        #Finde einen unbenutzten Slot

        material.active_texture_index = len(context.object.active_material.texture_slots.keys())

        id = -1

        usedids = []

        while (context.scene.frame_current < context.scene.frame_end and material.active_texture_index < 17) :

            id = random.randint(original_id-50,original_id+50)

            if(id < 0):

                id += 50

            elif(id > 1000):

                id %= 1000

            if(id in usedids):

                #Die ids sollen einmalig sein, um die Streuung möglichst groß zu halten

                #und den Programmieraufwand beim Wechseln der Texturen zu verringern

                continue

            usedids.append(id)

            object.marker_id = id

            object.keyframe_insert("marker_id")

            #Workaround um zu verhindern, dass zwischen den IDs interpoliert wird

            object.keyframe_insert("marker_id",frame=context.scene.frame_current+1)

            object.keyframe_insert("marker_id",frame=context.scene.frame_current+2)

            object.keyframe_insert("marker_id",frame=context.scene.frame_current+3)

            #XXX Mit den Schlüsseln arbeiten, da Werte sonst nicht übernommen werden (keine reguläre Liste)

            for schluessel in range(0,len(material.use_textures)):

                material.use_textures[schluessel] = False

            # Die Textur für BART erstellen

            material = createTexture(str(id),False,"//BART_Marker/","Marker","BART_Marker_",'BART',material)

            material.use_textures[material.active_texture_index-1] = True 

            # Die Textur für ALVAR erstellen

            material = createTexture(str(id),False,"//ALVAR_Marker/","MarkerData_","ALVAR_Marker_",'ALVAR',material)

            material.use_textures[material.active_texture_index-1] = True 

            #Nach Erreichen von 17 wird nicht weiter hochgezählt, wir haben also erneut die Textur an Position 16 aktiviert und müssen das für 17 noch einmal erledigen.

            if(material.active_texture_index == 17):

                material.use_textures[17] = True

            material.keyframe_insert("use_textures",frame=context.scene.frame_current,options={'INSERTKEY_NEEDED'})

            context.scene.frame_current += 4

            print(id)

        #Mehr Texturen sind leider nicht erlaubt. Mische zwischen den vorhandenen Texturen.

        while(context.scene.frame_current < context.scene.frame_end):

            # Finde die Indizes für BART und erstelle ein Wörterbuch, das den Markernummern die Indizes von ALVAR zuordnet

            texturenBART = [ i for i in range(0,17) if material.texture_slots[i].texture.library == 'BART' and material.texture_slots[i].texture.marker_id != id]

            texturenALVAR = { material.texture_slots[i].texture.marker_id:i for i in range(0,17) if material.texture_slots[i].texture.library == 'ALVAR' and material.texture_slots[i].texture.marker_id != id}

            #Zufällige Reihenfolge herstellen

            random.shuffle(texturenBART)

            index = 0

            while (context.scene.frame_current < context.scene.frame_end and index < len(texturenBART) and index < len(texturenALVAR)) :

                #XXX Mit den Schlüsseln arbeiten, da Werte sonst nicht übernommen werden (keine reguläre Liste)

                # Nicht benötigte Texturen deaktivieren

                for schluessel in range(0,len(material.use_textures)):

                    material.use_textures[schluessel] = False

                slot_index = texturenBART[index]

                # Die ausgeloste Textur beider Bibliotheken aktivieren 

                id =  material.texture_slots[ slot_index ].texture.marker_id

                if(id in texturenALVAR):

                    material.use_textures[ slot_index ] = True 

                    material.use_textures[ texturenALVAR[id] ] = True

                    object.marker_id = id

                    object.keyframe_insert("marker_id",frame=context.scene.frame_current)

                    # Workaround um zu verhindern, dass zwischen den IDs der Schlüsselbilder Interpoliert wird

                    object.keyframe_insert("marker_id",frame=context.scene.frame_current+1)

                    object.keyframe_insert("marker_id",frame=context.scene.frame_current+2)

                    object.keyframe_insert("marker_id",frame=context.scene.frame_current+3)

                    material.keyframe_insert("use_textures",frame=context.scene.frame_current,options={'INSERTKEY_NEEDED'})

                    print(context.scene.frame_current,object.marker_id,material.texture_slots[ slot_index ].texture.name, material.texture_slots[ slot_index ].name)

                else:

                    print("Warnung: Id",id,"wurde nicht für BART und ALVAR gefunden. Ich wähle eine andere.")

                    index += 1

                    continue

                # Springe zum nächsten Schlüsselbild

                context.scene.frame_current += 4

                index += 1

        context.scene.frame_current = ursprungsbild    

        return {'FINISHED'}

# Hilfsfunktionen

# Erzeugt eine Textur, für einen Marker mit der übergebenen markerID und den übergebenen Eigenschaften

def createTexture(markerID,kontrastErhoehen,dateipfad,dateiPrefix,idPrefix,bibliotheksID,material):

    if(kontrastErhoehen):

        idSuffix = "hC"

    else:

        idSuffix = ""

    if(not (idPrefix+markerID+idSuffix in bpy.data.textures.keys())):

        # Erstellt Textur

        bpy.ops.texture.new()

        bpy.data.textures[-1].name = idPrefix+markerID+idSuffix

        bpy.data.textures[idPrefix+markerID+idSuffix].type = 'IMAGE'

        bpy.ops.image.open(filepath=dateipfad+dateiPrefix+markerID+".png")

        # Sorgt für eindeutige Identifikation, für den Fall das der Benutzer bzw. die Benutzerin Texturen und Bilder verschiebt und/oder umbenennt

        bpy.data.textures[idPrefix+markerID+idSuffix].library = bibliotheksID

        bpy.data.textures[idPrefix+markerID+idSuffix].marker_id = int(markerID)

        bpy.data.textures[idPrefix+markerID+idSuffix].image = bpy.data.images[dateiPrefix+markerID+".png"]

        if(kontrastErhoehen):

            # Erhöht den Kontrast

            bpy.data.textures[idPrefix+markerID+idSuffix].intensity = 2

            bpy.data.textures[idPrefix+markerID+idSuffix].contrast = 3

    # Weist die Standard-UV-Map zu        

    material.active_texture   = bpy.data.textures[idPrefix+markerID+idSuffix]

    material.texture_slots[material.active_texture_index].texture_coords   = 'UV'

    material.texture_slots[material.active_texture_index].uv_layer = 'UVMap'

    material.active_texture_index+=1

    return material

# Berechnet den Abstand zweier Punkte 1 und 2 

def distanz(x1,y1,z1,x2,y2,z2):

    return laenge(x1-x2,y1-y2,z1-z2)

# Berechnet die Länge eines Vektors

def laenge(x,y,z):

    return sqrt(x*x+y*y+z*z)