Como se comunicar entre dm-script e python na Micrografia Digital

Question

Como faço para cominucar entre dm-scriptcódigo e pythoncódigo, ambos executados em Micrografia Digital?

---

No meu caso específico, tenho diálogos complicados. Visto que os diálogos não são suportados em, pythonmas em dm-script, escrevi meus diálogos em dm-script. O problema agora é passar da caixa de diálogo para o código python.

Considere o seguinte exemplo:

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

Scripts DM chamando scripts Python

Esta resposta está mostrando alguma comunicação entre Python e DM-script, mas forma o lado oposto. Ele também usa o tagGroup persistente como proxy de transferência.

Passando valores simples dentro e fora do Python de um 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()

Passando dados de imagem dentro e fora do Python de um 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

Para sincronizar dados entre dm-scripte pythonenquanto ambos estão em execução na mesma instância (e o thread, neste exemplo, pode ser modificado para threads diferentes também), pode-se usar as tags persistentes .

O dm-scriptestá definindo as tags persistentes. pythonpode então ler as tags persistentes novamente.

---

Atualização: módulo Python

Por causa das limitações mencionadas abaixo e do código incrivelmente crescente e ilegível, decidi escrever meu próprio módulo Python para isso. Com execdmscriptele, é possível executar o código dm-script com sincronização de variáveis ​​muito facilmente a partir da Micrografia Digital.

Confira o seguinte exemplo:

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.")

Isso esconde todos os problemas e salvamentos relacionados ao dm-script (mencionados abaixo). Ele permite usar liste dictS e tipos básicos como bool, str, inte float. Todos os tipos e valores podem ser usados ​​na forma pythônica sem a necessidade de se preocupar com os tipos de dm-script. O dm-script pode ser movido para um arquivo separado para limpar o código ainda mais.

Observe que para depuração, há uma exec_dmscript(debug=True, debug_file="path/to/file")opção que salvará o código no dado debug_file. Este arquivo pode então ser executado manualmente no GMS, o que mostra os erros.

Isenção de responsabilidade : conforme mencionado, sou o autor do execdmscriptmódulo. Mesmo assim acho que essa é a melhor solução para esse caso. Na verdade, essa pergunta foi a razão pela qual escrevi o módulo.

---

Tipos de dados básicos

Para tipos de dados básicos como string, e numberpode-se criar e adicionar o código manualmente. O exemplo a seguir mostra a ideia:

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))

Como se pode ver, há algumas desvantagens desse método. Há muito código criando a configuração e a sincronização para apenas inserir um número. Isso torna o código confuso. Também pode-se querer salvar o código dm-script em um arquivo separado que adiciona a abertura do arquivo python. Depurar o código dm-script também é difícil neste código. E, por último, existem limitações no TagGroup viajando no lado do Python (confira abaixo).

---

Limitações

Atualização : O módulo python mencionado abaixo pode lidar com TagGrous e TagLists porque os salva linearizados e com chaves e tipos separados.

Observe que TagGroups são muito difíceis de sincronizar. TagGroups não deve ser atribuído a variáveis. Assim que estiverem, não serão mais utilizáveis. Isso pode ser ilustrado pelo seguinte código muito fácil:

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), ")")

Este código irá produzir a saída

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'> )

Isso mostra que você não pode atribuir TagGroups a variáveis ​​Python.

---

Ideias assíncronas

Isso pode ser estendido para aplicativos assíncronos. O dm-scripte a pythonimplementação podem definir threads que observam as tags persistentes. (Observe que você pode marcar TagGroups como modificados usando TagGroupMarkAsChanged()), tags possivelmente diferentes. Então, ambos podem adicionar comandos e / ou dados à tag. A outra "instância" pode lê-los e processá-los.

Isso deve ser codificado manualmente. Isso (atualmente) não está incluído no execdmscriptmódulo.