Comment communiquer entre dm-script et python dans Digital Micrograph

Question

Comment puis-je communiquer entre le dm-scriptcode et le pythoncode, tous deux exécutés dans Digital Micrograph?

---

Dans mon cas particulier, j'ai des dialogues compliqués. Sice les dialogues ne sont pas pris en charge dans pythonmais dans dm-script, j'ai écrit mes dialogues dans dm-script. Le problème maintenant est de passer du dialogue au code python.

Prenons l'exemple suivant:

import DigitalMicrograph as DM

script = """string field_value = "";

class ButtonDialog : UIFrame{
    void field_changed(object self, TagGroup field){
        field_value = field.DLGGetStringValue();
    }
    
    object init(object self){
        TagGroup dlg, dlg_items, field;
        
        dlg = DLGCreateDialog("Type in a number", dlg_items);
        
        dlg.DLGAddElement(DLGCreateLabel("Number:"));
        
        field = DLGCreateIntegerField(0, 10, "field_changed");
        dlg.DLGAddElement(field);
        
        self.super.init(dlg);
        return self;
    }
}

object dialog = alloc(ButtonDialog).init();
dialog.pose();
"""

DM.ExecuteScriptString(script)

# how do I get this?
field_value = ""

Answer 1

DM-scripts appelant des scripts Python

Cette réponse montre une certaine communication entre Python et DM-script mais forme le côté opposé. Il utilise également le tagGroup persistant comme proxy de transfert.

Passer des valeurs simples dans et hors de Python à partir d'un script DM

// //////////////////////////////////////////////////
// Helper methods 
// Build the DM-String representing the PythonScript
// which is then called
// //////////////////////////////////////////////////
string AddPythonValueIN( number val, string valName, string valType )
{
    string py
    py += "\n#Get value DM->Python via global tags" + "\n"
    py += "success, " + valName + " = DM.GetPersistentTagGroup().GetTagAs" + valType + "('Python_temp:in:" + valName + "')" + "\n"
    py += "if False == success:" + "\n"
    py += "    print( 'Error. No value passed in by DM-script sucessfully.' )" + "\n"
    py += "    exit(0)" + "\n"
    return py
}

string AddPythonValueIN( string val, string valName, string valType )
{
    string py
    py += "\n#Get value DM->Python via global tags" + "\n"
    py += "success, " + valName + " = DM.GetPersistentTagGroup().GetTagAs" + valType + "('Python_temp:in:" + valName + "')" + "\n"
    py += "if False == success:" + "\n"
    py += "    print( 'Error. No value passed in by DM-script sucessfully.' )" + "\n"
    py += "    exit(0)" + "\n"
    return py
}

string AddPythonValueOut( string valName, string valType )
{
    string py
    py += "\n#Get value Python->DM via global tags" + "\n"
    py += "DM.GetPersistentTagGroup().SetTagAs" + valType + "('Python_temp:out:" + valName + "'," + valName + ")" + "\n"
    return py
}

string AddPythonPrintModifyPrint()
{
    string py
    py += "\n#Print InValue, modify, print OutValue" + "\n"
    py += "print('InValue',InValue)"+ "\n"
    py += "OutValue = InValue * 2" + "\n"
    py += "print('OutValue',OutValue)"+ "\n"
    return py
}

// //////////////////////////////////////////////////
// Example calls 
// Demonstrating value passing from DM script to a 
// called Python snippet. TagTypes need to be 
// explicit in Python.
// //////////////////////////////////////////////////
void PythonValueInAndOut_Float()
{
    number value = 13.2
    GetPersistentTagGroup().TagGroupSetTagAsFloat("Python_temp:in:InValue",value)
    
    Result( " DM-Script passed value in: " + value + "\n")
    
    string py = "#Script to demonstrate value passing in Hybrid scripts. DM calling Python." + "\n"
    py += AddPythonValueIN( value, "InValue", "Float" )
    py += AddPythonPrintModifyPrint() 
    py += AddPythonValueOut( "OutValue", "Float" )
    
    Result( "\n PYTHON CODE EXECUTES\n --------------------- \n\n" )
    ExecutePythonScriptString( py, 1 )
    Result( "\n --------------------- \n PYTHON CODE FINISHED \n\n" )
    
    if ( !GetPersistentTagGroup().TagGroupGetTagAsFloat("Python_temp:out:OutValue",value))
        Throw("Python value passed out not found.")
        
    Result( "DM-Script received value: " + value + "\n")
    
    GetPersistentTagGroup().TagGroupDeleteTagWithLabel("Python_temp")
}

void PythonValueInAndOut_Double()
{
    number value = 13.2
    GetPersistentTagGroup().TagGroupSetTagAsDouble("Python_temp:in:InValue",value)
    
    Result( " DM-Script passed value in: " + value + "\n")
    
    string py = "#Script to demonstrate value passing in Hybrid scripts. DM calling Python." + "\n"
    py += AddPythonValueIN( value, "InValue", "Double" )
    py += AddPythonPrintModifyPrint() 
    py += AddPythonValueOut( "OutValue", "Double" )
    
    Result( "\n PYTHON CODE EXECUTES\n --------------------- \n\n" )
    ExecutePythonScriptString( py, 1 )
    Result( "\n --------------------- \n PYTHON CODE FINISHED \n\n" )
    
    if ( !GetPersistentTagGroup().TagGroupGetTagAsDouble("Python_temp:out:OutValue",value))
        Throw("Python value passed out not found.")
        
    Result( "DM-Script received value: " + value + "\n")
    
    GetPersistentTagGroup().TagGroupDeleteTagWithLabel("Python_temp")
}

void PythonValueInAndOut_String()
{
    string value = "hallo"
    GetPersistentTagGroup().TagGroupSetTagAsString("Python_temp:in:InValue",value)
    
    Result( " DM-Script passed value in: " + value + "\n")
    
    string py = "#Script to demonstrate value passing in Hybrid scripts. DM calling Python." + "\n"
    py += AddPythonValueIN( value, "InValue", "String" )
    py += AddPythonPrintModifyPrint() 
    py += AddPythonValueOut( "OutValue", "String" )
    
    Result( "\n PYTHON CODE EXECUTES\n --------------------- \n\n" )
    ExecutePythonScriptString( py, 1 )
    Result( "\n --------------------- \n PYTHON CODE FINISHED \n\n" )
    
    if ( !GetPersistentTagGroup().TagGroupGetTagAsString("Python_temp:out:OutValue",value))
        Throw("Python value passed out not found.")
        
    Result( "DM-Script received value: " + value + "\n")
    
    GetPersistentTagGroup().TagGroupDeleteTagWithLabel("Python_temp")
}

ClearResults()
PythonValueInAndOut_float()
PythonValueInAndOut_double()
PythonValueInAndOut_string()

Passer des données d'image dans et hors de Python à partir d'un script DM

// Images and other objects which are in memory can be most easily passed
// by passing their ID value and then finding them by ID.
// However, this does not work if the object would go out of scope at the 
// end of a script (like an image which is not displayed)
//
// To pass a NumpyArray out of Python without showing an image, one can
// instead write the array to the global tags directly, together with the
// information needed to read the tags out into a DM-image
void PythonImageInOut( )
{
    image img := RealImage("test",4,5,5)
    img = icol
    
    Result( " DM-Script passed image ["+img.ImageGetLabel()+"] in.\n")
        
    string py
    py += "\n#Get image DM->Python via imageLabel" + "\n"
    py += "img = DM.FindImageByID("+ img.ImageGetID()+")" + "\n"
    py += "if None == img:" + "\n"
    py += "    print( 'Error.No image passed in by DM-script sucessfully.' )" + "\n"
    py += "    exit(0)" + "\n"
    py += "\n"
    py += "print('Image from DM: Label = ', img.GetLabel())" + "\n"
    py += "print('Image from DM: Name  = ', img.GetName())" + "\n"
    py += "print('Image from DM: Value = \\n', img.GetNumArray())" + "\n"
    py += "del img #ALWAYS delete DM objects in Python scripts" + "\n"
    py += "\n"
    py += "\n#Create DM image in Python and pass out as ID via global tags" + "\n"
    py += "import numpy as np" + "\n"
    py += "data = np.arange(48).reshape(6,8)" + "\n"
    py += "outImg = DM.CreateImage(data.copy(order='C'))" + "\n"
    py += "DM.GetPersistentTagGroup().SetTagAsLong('Python_temp:out:ID',outImg.GetID())" + "\n"
    py += "print('Create new image with ID:',outImg.GetID())"+"\n"
    py += "outImg.ShowImage()    #Image needs to be shown or it will not stay in memory" + "\n"
    py += "del outImg #ALWAYS delete DM objects in Python scripts" + "\n"
    
    Result( "\n PYTHON CODE EXECUTES\n --------------------- \n\n" )
    ExecutePythonScriptString( py, 1 )
    Result( "\n --------------------- \n PYTHON CODE FINISHED \n\n" )
    
    number imgID
    if ( !GetPersistentTagGroup().TagGroupGetTagAsLong("Python_temp:out:ID",imgID))
        Throw("Python imageID value passed out not found.")
        
    image outImg := FindImageByID(imgID)
    if ( !outImg.ImageIsValid()  )
        Throw("Python imageID value passed out but no matching image found.")
        
        
    Result( "DM-Script received image: " + outImg.ImageGetLabel()+ "\n")
    
    GetPersistentTagGroup().TagGroupDeleteTagWithLabel("Python_temp")
    
}


void PythonArrayOut( )
{
    string py
    py += "#Passing Numpy array values via global tags" + "\n"
    py += "import numpy as np" + "\n"
    py += "data = np.arange(6*8*3).reshape(6,8,3)" + "\n"
    py += "outImg = DM.CreateImage(data.copy(order='C'))" + "\n"
    py += "DM.GetPersistentTagGroup().SetTagAsArray('Python_temp:out:array',outImg)" + "\n"
    py += "DM.GetPersistentTagGroup().SetTagAsLong('Python_temp:out:type',outImg.GetDataType())" + "\n"
    py += "for i in range(data.ndim,0,-1):" + "\n"
    py += "    DM.GetPersistentTagGroup().SetTagAsLong('Python_temp:out:dim:' + str(i-1),data.shape[i-1])" + "\n"   
    py += "\n"
    py += "del outImg #ALWAYS delete DM objects in Python scripts" + "\n"
    
    Result( "\n PYTHON CODE EXECUTES\n --------------------- \n\n" )
    ExecutePythonScriptString( py, 1 )
    Result( "\n --------------------- \n PYTHON CODE FINISHED \n\n" )

    number dataType
    if ( !GetPersistentTagGroup().TagGroupGetTagAsLong("Python_temp:out:type",dataType))
        Throw("Python dataType value passed out not found.")
    
    TagGroup dimTG
    if ( !GetPersistentTagGroup().TagGroupGetTagAsTagGroup("Python_temp:out:dim",dimTG))
        Throw("Python dimensions passed out not found.")
    
    number nDim = dimTG.TagGroupCountTags()
    number n0, n1, n2, n3, n4
    dimTG.TagGroupGetIndexedTagAsLong(0,n0) 
    dimTG.TagGroupGetIndexedTagAsLong(1,n1)
    dimTG.TagGroupGetIndexedTagAsLong(2,n2)
    dimTG.TagGroupGetIndexedTagAsLong(3,n3)
    dimTG.TagGroupGetIndexedTagAsLong(4,n4)
    
    image outImg 
    if ( 1 == nDim  )
        outImg := NewImage("Test", dataType, n0 )
    else if ( 2 == nDim  )
        outImg := NewImage("Test", dataType, n0, n1 )
    else if ( 3 == nDim  )
        outImg := NewImage("Test", dataType, n0, n1, n2 )
    else if ( 4 == nDim  )
        outImg := NewImage("Test", dataType, n0, n1, n2, n3 )
    else if ( 5 == nDim  )
        outImg := NewImage("Test", dataType, n0, n1, n2, n3, n4 )
        
    if ( !GetPersistentTagGroup().TagGroupGetTagAsArray("Python_temp:out:array",outImg))
        Throw("Python array data passed out not found.")
    
    Result("\n DM recreated image from array values: " + outImg.ImageGetLabel()+ "\n")
        
    GetPersistentTagGroup().TagGroupDeleteTagWithLabel("Python_temp")
}

clearresults()
Result("\n\nEXAMPLE Python<->DM image passing\n")
PythonImageInOut()
Result("\n\nEXAMPLE Python-->DM array passing\n")
PythonArrayOut( )

Answer 2

Pour synchroniser les données entre dm-scriptet pythonpendant que les deux s'exécutent dans la même instance (et le thread dans cet exemple peut également être modifié pour différents threads), on peut utiliser les balises persistantes .

Le dm-scriptdéfinit les balises persistantes. pythonpeut alors relire les balises persistantes.

---

Mise à jour: module Python

En raison des limitations mentionnées ci-dessous et du code incroyablement croissant et illisible, j'ai décidé d'écrire mon propre module python pour cela. Avec execdmscripton peut exécuter très facilement du code dm-script avec une synchronisation variable à partir de Digital Micrograph.

Consultez l'exemple suivant:

from execdmscript import exec_dmscript

# some script to execute
dmscript = """
number input;
number s = GetNumber("Enter a number between " + min + " and " + max + ".", init, input);"
"""

# variables that will be defined for the dm-scripts (and readable later on in python)
sv = {"min": 1, "max": 10, "init": 2}
# variables the dm-script defines and that should be readable in the python file
rv = {"input": "number", "s": "number"}

with exec_dmscript(dmscript, readvars=rv, setvars=sv) as script:
    if script["s"]:
        print(script["input"])
    else:
        print("User pressed cancel.")

Cela masque toutes les sauvegardes et problèmes liés au script dm (mentionnés ci-dessous). Il permet d'utiliser listet dicts et les types de base comme bool, str, intet float. Tous les types et valeurs peuvent être utilisés de manière pythonique sans avoir à se soucier des types dm-script. Le dm-script peut être déplacé vers un fichier séparé pour nettoyer encore plus le code.

Notez que pour le débogage, il existe un exec_dmscript(debug=True, debug_file="path/to/file")commutateur qui enregistrera le code dans le fichier donné debug_file. Ce fichier peut ensuite être exécuté manuellement dans GMS qui montre les erreurs.

Avertissement : Comme mentionné, je suis l'auteur du execdmscriptmodule. Pourtant, je pense que c'est la meilleure solution pour ce cas. En fait, cette question était la raison pour laquelle j'ai écrit le module.

---

Types de données de base

Pour les types de données de base comme string, et numberon peut créer et ajouter le code à la main. L'exemple suivant montre l'idée:

import DigitalMicrograph as DM
import time

sync_id = "sync-{}".format(int(time.time() * 100))

dmscript = """
number input;
number s = GetNumber("Enter a number between {min} and {max}.", {init}, input);

TagGroup p = GetPersistentTagGroup();
p.TagGroupSetTagAsBoolean("{id}-success", s);
p.TagGroupSetTagAsLong("{id}-input", input);
"""

DM.ExecuteScriptString(dmscript.format(min=1, max=10, init=2, id=sync_id))

# cannot save TagGroups to variables, check below
s, success = DM.GetPersistentTagGroup().GetTagAsBoolean("{}-success".format(sync_id))

if s and success:
    # cannot save TagGroups to variables, check below
    s, input = DM.GetPersistentTagGroup().GetTagAsLong("{}-input".format(sync_id))
    
    if s:
        print(input)
    else:
        print("Did not find 'input' in persistent tags.")
elif not s:
    print("Did not find 'success' in persistent tags.")
else:
    print("User clicked cancel.")

# cannot save TagGroups to variables, check below
# delete tag, otherwise the persistent tags gets filled with garbage
DM.GetPersistentTagGroup().DeleteTagWithLabel("{}-success".format(sync_id))
DM.GetPersistentTagGroup().DeleteTagWithLabel("{}-input".format(sync_id))

Comme on peut le voir, il y a quelques inconvénients de cette méthode. Il y a beaucoup de code créant la configuration et la synchronisation pour n'entrer qu'un seul numéro. Cela rend le code désordonné. On peut également vouloir enregistrer le code dm-script dans un fichier séparé qui ajoute l'ouverture du fichier python. Le débogage du code dm-script est également difficile dans ce code. Et enfin, il y a des limitations sur TagGroup voyageant du côté python (voir ci-dessous).

---

Limites

Mise à jour : Le module python mentionné ci-dessous peut traiter les TagGrous et les TagLists car il les enregistre linéarisés et avec des clés et des types séparés.

Notez que les TagGroups sont très difficiles à synchroniser. TagGroups ne doit pas être affecté à des variables. Dès qu'ils le sont, ils ne sont plus utilisables. Cela peut être illustré par le code très simple suivant:

import DigitalMicrograph as DM

# create group for the example
group1 = DM.NewTagGroup()
group1.SetTagAsString("test-string", "test content")
print("Group 1 valid:", group1.IsValid(), "(type:", type(group1), ")")

# save to persistent tags
DM.GetPersistentTagGroup().SetTagAsTagGroup("test", group1)

# get the group without assigning to a variable, works
s, group2 = DM.GetPersistentTagGroup().GetTagAsTagGroup("test")
print("Group 2 success:", s, ", valid:", group2.IsValid(), "(type:", type(group2), ")")

# assign one parent group to a variable, doesn't work
tags = DM.GetPersistentTagGroup()
s, group3 = tags.GetTagAsTagGroup("test")
print("Group 3 success:", s, ", valid:", group3.IsValid(), "(type:", type(group3), ")")

Ce code produira la sortie

Group 1 valid: True (type: <class 'DigitalMicrograph.Py_TagGroup'> )
Group 2 success: True , valid: True (type: <class 'DigitalMicrograph.Py_TagGroup'> )
Group 3 success: True , valid: False (type: <class 'DigitalMicrograph.Py_TagGroup'> )

Cela montre que vous ne pouvez pas affecter de TagGroups aux variables python.

---

Idées asynchrones

Cela peut être étendu pour les applications asynchrones. Le dm-scriptet la pythonmise en œuvre peut définir des fils qui les balises persistantes respectent. (Notez que vous pouvez marquer TagGroups comme modifiés en utilisant TagGroupMarkAsChanged()), des balises nettement différentes. Ensuite, les deux peuvent ajouter des commandes et / ou des données à la balise. L'autre «instance» peut les lire et les traiter.

Cela doit être codé manuellement. Ceci n'est (actuellement) pas inclus dans le execdmscriptmodule.