Bielefeld Augmented Reality Tracker

bl_info = {

    "author": "Jonas Diekmann",

    "name": "Marker Tracker Plugin",

    "description": "Tools for BA-Thesis",

    "warning": "",

    "version": (0, 11, 3),

    "blender": (2, 72, 0),

    "support": "TESTING",

    "category": "Add Mesh"

}

# Dies ist die Hauptdatei des Plugins

# Sie wird geladen, wenn das Plugin geladen wird.

# Normalerweise geschieht dies beim Start von Blender

# Es ist aber auch möglich diese datei direkt zu laden.

# Aufgabe dieser Datei ist es alle anderen teile des 

# Plugins nachzuladen.

### Der untestehende Code (bis ###) basiert auf [3].

# Lädt die Dateien neu, wenn das Plugin aufgefrischt werden soll.

if "bpy" in locals():

    import imp

    if "view" in locals():

        imp.reload(view)

    else:

        print("Datei view.py fehlt!");

    if "adjust" in locals():

        imp.reload(adjust)

    else:

        print("Datei adjust.py fehlt!");

    if "controller" in locals():

        imp.reload(controller)

    else:

        print("Datei controller.py fehlt!");

    if "model" in locals():

        imp.reload(model)

    else:

        print("Datei model.py fehlt!");

    if "switch_texture" in locals():

        imp.reload(switch_texture)

    else:

        print("Datei switch_texture.py fehlt!");

    if "tools" in locals():

        imp.reload(tools)

    else:

        print("Datei tools.py fehlt!");

    print("Pakete aufgefrischt")

else:

    # Importiert die übrigen Module, wenn das Plugin (oder eigentlich bpy)

    # noch nicht geladen war.

    from .view           import GraphischeOberflaeche

    from .adjust         import KameraJustieren, FormatEinstellen, EinheitenEinstellen

    from .controller     import PositionenAusgeben, MarkerHinzufuegen, MarkerRandomisieren #,EulerwinkelAusgeben

    from .model          import Plugineigenschaften

    from .switch         import WechsleBibliothek, WechsleZuBART, WechsleZuALVAR

    from .tools          import Import1, Import2

    print("Pakete importiert")

###

import bpy

# Registriert alle Klassen des Plugins

def register():

    bpy.utils.register_class(Plugineigenschaften)

    bpy.types.Scene.markerRender = bpy.props.PointerProperty(type=Plugineigenschaften)

    bpy.types.Object.marker_id = bpy.props.IntProperty(default=-1,min=-1)

    bpy.types.ImageTexture.library = bpy.props.StringProperty(name="library",default='BART',maxlen=100)

    bpy.types.ImageTexture.marker_id = bpy.props.IntProperty(default=-1,min=-1)

    bpy.utils.register_class(PositionenAusgeben)

    bpy.utils.register_class(MarkerHinzufuegen)

    #bpy.utils.register_class(EulerwinkelAusgeben)

    bpy.utils.register_class(MarkerRandomisieren)

    bpy.utils.register_class(WechsleBibliothek)

    bpy.utils.register_class(WechsleZuBART)

    bpy.utils.register_class(WechsleZuALVAR)

    bpy.utils.register_class(EinheitenEinstellen)

    bpy.utils.register_class(KameraJustieren)

    bpy.utils.register_class(FormatEinstellen)

    bpy.utils.register_class(GraphischeOberflaeche)

    bpy.utils.register_class(Import1)

    bpy.utils.register_class(Import2)

# Macht die Registrierung aller Klassen des Plugins rückgängig.

def unregister():

    bpy.utils.unregister_class(Import2)

    bpy.utils.unregister_class(Import1)

    bpy.utils.unregister_class(GraphischeOberflaeche)

    bpy.utils.unregister_class(MarkerRandomisieren)  

    bpy.utils.unregister_class(FormatEinstellen)

    bpy.utils.unregister_class(KameraJustieren)

    bpy.utils.unregister_class(EinheitenEinstellen)

    bpy.utils.unregister_class(WechsleZuALVAR)

    bpy.utils.unregister_class(WechsleZuBART)

    bpy.utils.unregister_class(WechsleBibliothek)

    #bpy.utils.unregister_class(EulerwinkelAusgeben)

    bpy.utils.unregister_class(MarkerHinzufuegen)

    bpy.utils.unregister_class(PositionenAusgeben)  

    bpy.utils.unregister_class(Plugineigenschaften) 

# Dies ist der Einsprungspunkt, falls das Skript über

# die entsprechende Schaltfläche in Blender ausgeführt wird.

if __name__ == "__main__":

    register()

# Quellen:

#  0  API: http://www.blender.org/api/blender_python_api_2_72_release

#  1  PYTHON kurz & gut:

#  2  Quickstart: http://www.blender.org/api/blender_python_api_2_72_release/info_quickstart.html

#  3  Multi-file packages: http://wiki.blender.org/index.php/Dev:2.5/Py/Scripts/Cookbook/Code_snippets/Multi-File_packages

#

# Tipp: Der Tooltip der meisten Felder nennt den Pfad der Eigenschaft.

#       Operatoren werden zudem im Infofenster protokolliert.

#       Dadurch kann man manchmal die gewünschten Aktionen über die GUI durchführen und die Befehle kopieren. (vgl. auch http://www.blender.org/api/blender_python_api_2_72_release/info_api_reference.html#copy-data-path)

import bpy

class KameraJustieren(bpy.types.Operator):

    """Stellt die Kamera auf die für die Kalibrierung verwendeten Werte ein """

    bl_idname = "camera.adjust_camera"

    bl_label = "Kamera justieren"

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

    @classmethod

    def poll(cls, context):

        return (bpy.context.scene.markerRender.kameraDatenID in bpy.data.cameras.keys())

    # Stellt die Kamera auf die für die Kalibrierung verwendeten Werte ein

    def execute(self, context):

        kameraID = bpy.context.scene.markerRender.kameraDatenID

        bpy.data.cameras[kameraID].angle_x = 0.8575560450553894

        bpy.data.cameras[kameraID].angle_y = 0.5033799409866333

        bpy.data.cameras[kameraID].clip_end = 20.0

        bpy.data.cameras[kameraID].clip_start = 0.10000000149011612

        bpy.data.cameras[kameraID].sensor_fit = 'AUTO'

        bpy.data.cameras[kameraID].sensor_height = 18.0

        bpy.data.cameras[kameraID].sensor_width = 32.0

        bpy.data.cameras[kameraID].shift_x = 0.0

        bpy.data.cameras[kameraID].shift_y = 0.0

        bpy.data.cameras[kameraID].dof_distance = 7.929999828338623

        return {'FINISHED'}

class EinheitenEinstellen(bpy.types.Operator):

    """Stellt das Einheitensystem ein"""

    bl_idname = "scene.adjust_units"

    bl_label = "Einheiten einstellen"

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

    @classmethod

    def poll(cls, context):

        return True

    # Stellt das Einheitensystem ein

    def execute(self, context):

        bpy.context.scene.unit_settings.system = "METRIC"

        return {'FINISHED'}

class FormatEinstellen(bpy.types.Operator):

    """Stellt das Ausgabeformat ein (Auflösung, Dateiformat etc.)"""

    bl_idname = "render.adjust_dimensions"

    bl_label = "Format einstellen"

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

    @classmethod

    def poll(cls, context):

        return True

    # Stellt das Ausgabeformat ein (Auflösung, Dateiformat etc.)

    def execute(self, context):

        ### Der folgende Codeabschnitt (bis zum nächsten ### ) wurde mit bpy.ops.render.preset_add() erzeugt

        szene = bpy.context.scene

        szene.render.field_order = 'EVEN_FIRST'

        szene.render.fps = 48

        szene.render.fps_base = 1.0

        szene.render.pixel_aspect_x = 1.0

        szene.render.pixel_aspect_y = 1.0

        szene.render.resolution_percentage = 100

        szene.render.resolution_x = 1920

        szene.render.resolution_y = 1080

        szene.render.use_fields = False

        szene.render.use_fields_still = False

        ###

        bpy.data.scenes['Scene'].render.image_settings.file_format = "JPEG"

        bpy.data.scenes['Scene'].render.image_settings.quality = 100

        return {'FINISHED'}

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)

import bpy

class Plugineigenschaften(bpy.types.PropertyGroup):

    """Enthält die von diesem Plugin verwendeten Daten"""

    kameraID             = bpy.props.StringProperty(name="kameraID",description="Die ID der zu verwendenden Kamera")

    kameraDatenID        = bpy.props.StringProperty(name="kameraDatenID",description="Die ID des zu der Kamera gehörenden Datenblockes")

    markerID             = bpy.props.StringProperty(name="markerID",description="Die (Blender-)ID des zu trackenden Markers. Bei einem leeren Feld werden alle Marker verwendet.")

    dateipfad             = bpy.props.StringProperty(subtype="FILE_PATH")

    newMarkerID          = bpy.props.IntProperty(min=0,soft_min=0,max=1000)

    incrementNewMarkerID = bpy.props.BoolProperty(description="Markernummer nach der Erzeugung erhöhen")

    kontrastErhoehen     = bpy.props.BoolProperty(description="Kontrast und Helligkeit des Markers erhöhen")

    markerIDs            = bpy.props.CollectionProperty(type=bpy.types.NodeSetting)

import bpy

class WechsleBibliothek(bpy.types.Operator):

    """Oberklasse aller Klassen für Texturwechsel"""

    bl_idname = "texture.to_library"

    bl_label  = "LIBRARY"

    # 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 die Textur zu wechseln

    def execute(self,context):

        model = bpy.context.scene.markerRender

        zaehler = 0

        zuEntfernen = []

        #Schleife über alle Marker

        for id in model.markerIDs:

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

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

                self.markerVerarbeiten(context,marker,model)

                zaehler += 1

            else:

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

                zuEntfernen.append(zaehler)

        # Überflüssige Schlüssel entfernen

        for schluessel in zuEntfernen:   

            model.markerIDs.remove(schluessel)

        return {'FINISHED'}

    # Platzhalter soll überschrieben werden

    def markerVerarbeiten(self,context,marker,model):

        #Texturen usw. packen

        bpy.ops.file.pack_all()

        print("pack_all")

class WechsleZuBART(WechsleBibliothek):

    """Aktiviert die Texturen von BART"""

    bl_idname = "texture.to_bart"

    bl_label  = "BART"

    # Aktiviert die Textur von BART

    def markerVerarbeiten(self,context,marker,model):

        #Texturen usw. packen

        bpy.ops.file.pack_all()

        #Erstelle Wörterbücher, die einem Marker die id des Texturschachtes mit der entsprechenden Textur zuordnen

        texturenBART = { marker.material_slots[0].material.texture_slots[i].texture.marker_id:i for i in range(0,18) if marker.material_slots[0].material.texture_slots[i] != None and marker.material_slots[0].material.texture_slots[i].texture.library == 'BART'}

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

        for bild in range(context.scene.frame_start,context.scene.frame_end):

            bpy.context.scene.frame_set(bild)

            #Die passende Textur von BART aktivieren

            for schluessel in texturenBART:

                if((schluessel in texturenALVAR and marker.material_slots[0].material.use_textures[texturenALVAR[schluessel]]) or marker.material_slots[0].material.use_textures[texturenBART[schluessel]]):

                    print(bild,":",schluessel)

                    marker.material_slots[0].material.use_textures[texturenBART[schluessel]] = True

                    marker.material_slots[0].material.keyframe_insert("use_textures",index=texturenBART[schluessel],frame=bild,options={'INSERTKEY_NEEDED'})

            #Die Textur von ALVAR ggf. deaktivieren

            for index in texturenALVAR:

                marker.material_slots[0].material.use_textures[texturenALVAR[index]] = False

                marker.material_slots[0].material.keyframe_insert("use_textures",index=texturenALVAR[index],frame=bild,options={'INSERTKEY_NEEDED'})

class WechsleZuALVAR(WechsleBibliothek):

    """Aktiviert die Texturen von ALVAR"""

    bl_idname = "texture.to_alvar"

    bl_label  = "ALVAR"

    #  Aktiviert die Textur von ALVAR

    def markerVerarbeiten(self,context,marker,model):

        #Texturen usw. packen

        bpy.ops.file.pack_all()

        #Erstelle Wörterbücher, die einem Marker die id des Texturschachtes mit der entsprechenden Textur zuordnen

        texturenBART = { marker.material_slots[0].material.texture_slots[i].texture.marker_id:i for i in range(0,18) if marker.material_slots[0].material.texture_slots[i] != None and marker.material_slots[0].material.texture_slots[i].texture.library == 'BART'}

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

        print("texturenBART",texturenBART)

        print("texturenALVAR",texturenALVAR)

        for bild in range(context.scene.frame_start,context.scene.frame_end):

            bpy.context.scene.frame_set(bild)

            #Die passende Textur von ALVAR aktivieren

            for schluessel in texturenALVAR:

                if((schluessel in texturenBART and marker.material_slots[0].material.use_textures[texturenBART[schluessel]]) or marker.material_slots[0].material.use_textures[texturenALVAR[schluessel]]):

                    marker.material_slots[0].material.use_textures[texturenALVAR[schluessel]] = True

                    marker.material_slots[0].material.keyframe_insert("use_textures",index=texturenALVAR[schluessel],frame=bild,options={'INSERTKEY_NEEDED'})

            #Die Textur von BART ggf. deaktivieren

            for index in texturenBART:

                marker.material_slots[0].material.use_textures[texturenBART[index]] = False

                marker.material_slots[0].material.keyframe_insert("use_textures",index=texturenBART[index],frame=bild,options={'INSERTKEY_NEEDED'})

import bpy

class Import1(bpy.types.Operator):

    """Fügt evtl. fehlende Schlüssel hinzu"""

    bl_idname = "tools.import1"

    bl_label  = "Import 1"

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

    @classmethod

    def poll(self, context):

        return True

    # Fügt evtl. fehlende Schlüssel hinzu

    def execute(self, context):

        #Ergänzt das Schlüsselattribut:

        for schluessel in bpy.data.objects.keys():

            if (schluessel[-2] == '_'):

                print(schluessel)

                bpy.data.objects[schluessel].marker_id = int(schluessel[-1])

            elif (schluessel[-3] == '_'):

                print(schluessel)

                bpy.data.objects[schluessel].marker_id = int(schluessel[-2:])

            elif (schluessel[-4] == '_'):

                print(schluessel)

                bpy.data.objects[schluessel].marker_id = int(schluessel[-3:])

        return{'FINISHED'}

class Import2(bpy.types.Operator):

    """Fügt neuere Schlüssel zu den Texturen hinzu"""

    bl_idname = "tools.import2"

    bl_label  = "Import 2"

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

    @classmethod

    def poll(self, context):

        return True

    # Fügt neuere Schlüssel zu den Texturen hinzu

    def execute(self, context):

        #Ergänzt die Schlüsselattribute:

        for schluessel in bpy.data.textures.keys():

            if(bpy.data.textures[schluessel].type == 'IMAGE'):

                if (schluessel[-2] == '_'):

                    print(schluessel)

                    bpy.data.textures[schluessel].marker_id = int(schluessel[-1])

                elif (schluessel[-3] == '_'):

                    print(schluessel)

                    bpy.data.textures[schluessel].marker_id = int(schluessel[-2:])

                elif (schluessel[-4] == '_'):

                    print(schluessel)

                    bpy.data.textures[schluessel].marker_id = int(schluessel[-3:])

              #      

                if(schluessel[0:5] == "ALVAR"):

                    print("Lib: ALVAR")

                    bpy.data.textures[schluessel].library = "ALVAR"

                elif(schluessel[0:4] == "BART"):

                    print("Lib: BART")

                    bpy.data.textures[schluessel].library = "BART"

        return{'FINISHED'}

import bpy

class GraphischeOberflaeche(bpy.types.Panel):

    """Zeigt die graphische Oberfläche an"""

    bl_idname = "RENDER_PT_select"

    bl_label = "Teste für Markertracking"

    bl_space_type = 'PROPERTIES'

    bl_region_type = 'WINDOW'

    bl_context = "render"

    bl_options = {'DEFAULT_CLOSED'}

    @classmethod

    def poll(cls, context):

        return True

    def draw_header(self, context):

        pass

    def draw(self, context):

        #Eigenschaften der obersten Ebene

        layout = self.layout

        layout.prop(bpy.context.scene.markerRender,"kameraID",text="Kamera")

        layout.prop(bpy.context.scene.markerRender,"kameraDatenID",text="Kam.datenblock")

        #Kästen erzeugen 

        kasten1 = layout.box()

        kasten1.label("Erzeugung")

        kasten2 = layout.box()

        kasten2.label("Anpassung")

        kasten3 = layout.box()

        kasten3.label("Positionsdaten ausgeben")

        kasten4 = layout.box()

        kasten4.label("Texturen")

        # 1. Kasten füllen (Erzeugung)

        zeile1 = kasten1.row()

        zeile1.prop(bpy.context.scene.markerRender,"newMarkerID",text="nächste Nummer")

        zeile1.prop(bpy.context.scene.markerRender,"incrementNewMarkerID",text="autom. Erhöhen")

        zeile2 = kasten1.row()

        zeile2.prop(bpy.context.scene.markerRender,"kontrastErhoehen",text="hoher Kontrast")

        kasten1.operator("mesh.primitive_marker_add")

        # 2. Kasten füllen (Anpassung)

        kasten2.operator("scene.adjust_units",icon="SCENE_DATA")

        kasten2.operator("camera.adjust_camera",icon="CAMERA_DATA")

        kasten2.operator("render.adjust_dimensions",icon="RENDER_REGION")

        # 3. Kasten füllen (Positionsdaten ausgeben)

        k3_zeile1 = kasten3.row()

        k3_zeile1.prop(bpy.context.scene.markerRender,"markerID",text="Marker")

        k3_zeile2 = kasten3.row()

        k3_zeile2.prop(bpy.context.scene.markerRender,"dateipfad",text="")

        kasten3.operator("print_object.position",text="Ausgeben",icon="FILE_TEXT")

        # 4. Kasten füllen (Texturen)

        k4_zeile1 = kasten4.row()

        k4_zeile1.operator("texture.to_bart",icon="TEXTURE")

        k4_zeile1.operator("texture.to_alvar",icon="TEXTURE")