---

Hallo zusammen
Heute habe ich dieses Forum entdeckt. Finde ich spitze ....
Ich hoffe, Ihr könnt mir weiterhelfen und sage schon mal danke.

Mein Problem:
Ich will eine komplexe Zeichnung "animieren", bzw. muss gewisse Bewegungsabläufe simulieren und testen.

Nun möchte ich mit VisualBasic die errechnte Positionen der Element plazieren. Dies sollte mit einer Frequenz von ca. 10 Bildern pro Sekunde gehen, doch .... na ja, im muss optimieren.

Wie kann ich ein Element in einem Zusammenbau direkt per Index ansprechen, ohne jedesmal die ganze Auflistung zu durchlaufen diesem Element dann den richtigen Namen geben?
Ist das Möglich?
Kann ich den Index auslesen, und wie kann das Teil wieder als aktiv setzen?

Meine "Bremse":

**************************************************
Public Sub MoveChain()
    Dim oDoc As Inventor.AssemblyDocument
    Set oDoc = ThisApplication.ActiveDocument
   
    Dim oCompDef As Inventor.ComponentDefinition
    Set oCompDef = oDoc.ComponentDefinition
   
    Dim oTransform As Matrix
    Set oTransform = oOccurrence.Transformation
   
   
    Dim oCompOcc As ComponentOccurrence
   
    For i = 1 To 200
       
        For Each oCompOcc In oCompDef.Occurrences
            If oCompOcc.Name = "Kettenglied" & i Then
                Debug.Print oCompOcc.Name
                       
                oTransform.SetTranslation ThisApplication.TransientGeometry.CreateVector(KG(i).x, KG(i).y, KG(i).z)
                oOccurrence.Transformation = oTransform
               
            End If
        Next
   
    Next i
   
End Sub
**************************************************

Vielen Dank
Roland

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Deine Bremse ist das wohl das ständige Suchen nach den Kettengliedern.
Das brauchst Du aber eigentlich nur ein einziges Mal, beim ersten Aufruf von MoveChain, zu machen. Das machr MoveChain jetzt aufgrund der statischen InitMe, die, falls der Compiler richtig arbeitet, nicht TRUE ist.
In der 'IF Not InitMe' werden für max. 200 Kettenglieder, die stehen bestimmt unsortiert in der Liste, die zugehörigen Indizes ermittelt:
KGIdxUsed[n] bestimmt, ob es ein n-tes Kettenglied gibt.
oCompOcc[n] ist das Objekt des n-ten Kettengliedes.
minIdx das kleinste n
MaxIdx das größte n

(n sollte natürlich im Bereich von 1 bis 200 liegen!)

Jetzt nur noch KG[n].x, .y und .z berechnen und MoveChain nach jeder Neuberechnung aufrufen.

Code:

---

Public Sub MoveChain()
    Static InitMe as Boolean
    Static KGIdxUsed[1 .. 200] as Boolean
    Dim idx as integer
    Static maxIdx as integer
    Static minIdx as integer

    Dim oDoc As Inventor.AssemblyDocument
    Set oDoc = ThisApplication.ActiveDocument
   
    Dim oCompDef As Inventor.ComponentDefinition
    Set oCompDef = oDoc.ComponentDefinition
   
    Dim oTransform As Matrix
    Set oTransform = oOccurrence.Transformation
   
   
    Dim oCompOccTemp As ComponentOccurrence
    Static oCompOcc[1 .. 200] As ComponentOccurrence

    Dim n AS Integer

    IF Not InitMe THEN
      maxIdx = 0
      minIdx = 9999
      For n = 1 To 200
        KGIdxUsed[n] = FALSE
      NEXT n

      For Each oCompOccTemp In oCompDef.Occurrences
          If Left$(oCompOccTemp.Name,11) = "Kettenglied" Then
            idx = CInt(Mid$(oCompOccTemp.Name,11))
            Set oCompOcc[idx] = oCompOccTemp
            KGIdxUsed[idx] = TRUE
            IF idx > maxIdx THEN
              maxIdx = idx
            ELSE
              IF idx < minIdx THEN
                minIdx = idx
              ENDIF
            ENDIF
          ENDIF
      NEXT
      InitMe = TRUE
    ENDIF
   
    For n = minIdx To maxIdx       
      IF KGIdxUsed[n] THEN
         Debug.Print oCompOcc[KGIdx[n]].Name
        oTransform.SetTranslation     ThisApplication.TransientGeometry.CreateVector(KG(n).x, KG(n).y, KG(n).z)
        oOccurrence.Transformation = oTransform
      ENDIF
    Next n
   
End Sub

---

Was ich allerdings nicht begriffen habe ist, wie oOccurrence.Transformation = oTransform sich auf das Listenelement oCompOcc beziehen kann. Hoffentlich nicht, weil vorher mit Debug.Print die 'Name'-Property ausgegeben wurde      
Wie auch immer, es bleibt für jeden weiteren Aufruf von MoveChain nur die Schleife i = minIdx TO maxIdx übrig. Ohne Suche nach den Kettengliedern.
Tipp: In den Modulen immer die Option für explizite Variablen-Deklaration verwenden!!!

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo Andreas
Das ging schnell ..... Vielen Dank

1. Mein Fehler mit oOccurence .....  Ist natürlich nur, weil ich in diesem "zusammengestellten" Beispiel etwas von extern reinkopiert habe.

Deine Lösung habe ich mir auch zusammengebaut. Doch leider ist sie nicht viel schneller.

Es ist so, dass der Rechner rechnet, aber sobald die Anzeigefrequenz > als 6 pro Sekunde ist und die Anzahl zu verschiebenden Teile > 20 wird das Bild nicht mehr neu aufgebaut. Erst am Schluss des Vorganges mit einem grossen Sprung.

Das Problem scheint folgendes zu sein:
Den Takt der Berechnung definiere ich damit einer Warteschleiffe.

************************************************************
Takt = 1 / AnzahlRefreshProSekunde
While Ablauf=True
    NextTakt = NextTakt + Takt
    Do While Timer < NextTakt
      DoEvents    ' Steuerung an andere Prozesse abgeben.
    Loop
MoveChain    'Bewegung nächster Takt
oDoc.Update  'Aufbau des Bildes
Wend
************************************************************
Dabei bleibt die Prozessorleistung voll beim Inventor (Gemäss TaskManager ...).

Anders mit folgendem Befehl:

Public Declare Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)
Call Sleep(AnzahlRefreshProSekunde * 1000)  'Versuche mit Wartezeiten zwischen 200 und 1000 Milisekunden

Dabei ist die Prozesszeit beim Leerlauf, der Inventor wird fast nicht gebraucht, und es gibt trotzdem keinen neuen Bildaufbau.

Wo bleibt die Zeit hängen? Warum wird das Bild nicht regelmässig neu aufgebaut?

Viele Grüsse
Roland

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP