---

Moin!

Ich würde gern die aktuelle Bildschirmansicht mit einem Tastendruck um einen festen Winkel drehen können, z. B. aus der achsparallelen Ansicht von vorn in die Ansicht 45° von schräg-vorn-oben (oder in 15°-Schritten inkremental immer weiter). Es gibt etwas Ähnliches als fertige Inventor-Funktion, aber die geht über ein Dialogfenster, was mir zu umständlich ist.

Daher suche ich eine Möglichkeit, mit VBA oder so die Ansichtsrichtung in der beschriebenen Weise zu steuern. Gibt es die?

------------------
Roland  
www.Das-Entwicklungsbuero.de

It's not the hammer - it's the way you hit!

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

---

Moin

Ja, Inventor bietet ein Camera Objekt mit dem man sich frei im Raum bewegen kann. Den Knoten im Hirn bekommt man immer erst, sobald man mit den Vektoren und Translations-/Rotationsmatrizen um sich wirft, die die Kamera positionieren.  
Die Kamera hat drei hierfür relevante Eigenschaften. Target ist der Punkt auf den die Kamera zielt. Eye ist die Position der Camera. UpVector ist der lotrecht nach oben zeigende Vektor (parallel zur "Bildschirmfläche").

Die Standardansichten (vorn, hinten, rechts, links, oben, unten und die ISO's) kann man direkt aufrufen. Dabei kommt es leider gern vor, dass das Teil hinterher "auf dem Kopf" steht. Formal macht Inventor es richtig, da die Definition von dem was nach "oben" zeigen soll, nicht gegeben ist. Nervig ist es trotzdem.

Die schrittweise Rotation um eine beliebig definierte Raumachse ist ein Problem. Das Koordinatensystem des Bauteiles dreht sich mit. Ist also nach der ersten Drehung nicht mehr verwendbar, um die gleiche Drehachse erneut zu definieren. Aus dem UpVector der Camera und dem Vektor zwischen Eye und Target kann man den dritten Vektor ableiten. Mit Target der Kamera hat man einen Ursprungspunkt und könnte damit die Drehachse immer wieder gleich erzeugen. Das neu erzeugen ist nötig, da in einem Makro am Ende alle Variablen verworfen werden. Deswegen läuft der Befehl im Inventor auch mit einem Dialog. Solange der offen ist, bleiben die bei Aufruf der Funktion ermittelten Drehachsen erhalten. Target bleibt bei einer Drehung nämlich nicht unbedingt am gleichen Punkt, so dass bei der nächsten Drehung die Drehachse an einer anderen Stelle im Bauteil liegt. Eine 360° Drehung aus 24x15° resultiert dann in allem, aber nicht der Ausgangsansicht.

Bleibt die Option das Bauteilzentrum oder den Schwerpunkt als unveränderlichen Punkt zu definieren und die Drehachse durch diesen zu legen. Dann müsste aber zu Beginn die Kamera entsprechend ausgerichtet werden, damit das Target diesem Punkt entspricht. Das verschiebt vor der ersten Drehung andererseits die vom Benutzer gewählte Ansicht des Bauteiles, könnte also auch zu unerwünschtem Verhalten führen.

Pest oder Cholera, was darf es sein?  

------------------
MfG
Ralf

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

---

Oh, Danke, sehr gut!

Es gibt da also etwas. Und auch wenn Du es vielleicht nicht für möglich hältst, sind Deine Ausführungen dazu für mich sehr erfreulich und positiv. Dass die Drehung im Raum auf Basis von Vektoren teilweise verwirrend ist, schreckt mich nicht.

Das Auf-dem-Kopf-Stehen oder Auf-der-Seite-Liegen kenne ich vom View-Cube, beim Space-Pilot oder der Space-Mouse passiert das jedoch nie, da ist auch der Camera.UpVector immer gleich, der ja einer Vorgabe zugänglich ist. Dass Inventor selbst da nachlässig ist, liegt vielleicht daran, dass vielen Leuten die Koordinatenrichtung egal ist. Oder hängt es einfach nur von der Einstellung "Minimum Rotation" in Anwendungsoptionen\Ansicht ab?

Die von Dir dargestellte Problematik der Drehachsenbestimmung bei beliebigen Blickrichtungen und mehrfacher Drehung verstehe ich vollkommen und bewundere, wie weit Du schon vorhersiehst, wo es schwierig würde, aber ich habe gar nicht die Erwartung, dass das Drehen in allen Situationen perfekt wird.

Z. B. wäre mir nicht so wichtig, wo Target und Drehachse genau liegen, weil ich das Bild ja ohnehin ständig mit dem Space-Knubbel verschiebe. Ursprung, Schwerpunkt, Bauteilzentrum oder der Punkt, wo der Blickvektor auf das Modell trifft, das wären IMHO alles geeignete Kandidaten.

Auch muss eine wiederholte schrittweise Drehung nicht nach 360° wieder genau die Ausgangsansicht erreichen. Spätestens bei 90° wäre es ja viel einfacher, die entsprechende Taste für achsparallele Ansichten am Space-Knubbel zu benutzen.

Ich halte es auch für eine leicht hinnehmbare Einschränkung, immer nur um die quer (hoch) liegende, b.z.w. der Bildschirm-Horizontalen (-vertikalen) am nahesten kommende Usprungsache zu drehen.

Ich wäre schon zufrieden, wenn ich einfach nur aus einer achsparallelen Ansicht kleine Drehungen um jeweils eine Ursprungsachse ausführen könnte.

Eine ebenfalls schon sehr nützliche Minimallösung wäre, die schrägen Kanten-Ansichten vom Viewcube auf Tasten legen zu können. Das kann doch dann nur eine feste Matrix sein, die man lediglich abschicken muss.

Wenn Du mir dafür eine Zauberformel als Ansatzpunkt verrätst, experimentiere ich mit der Vektormathematik auch gern selber weiter.

------------------
Roland  
www.Das-Entwicklungsbuero.de

It's not the hammer - it's the way you hit!

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

---

Moin

Ich denke nicht weit voraus, ich hab nur mit der Kamera schon etliche Male herumgespielt. Deswegen weiß ich, dass es da ein paar Fallstricke gibt.
Die Anwendungsoption steuert das Drehen wenn eine Skizze erzeugt bzw. bearbeitet wird. Im Standard dreht Inventor die Skizze nur auf kürzestem Weg parallel zur Bildschirmebene. Mit der alternativen Option dreht Inventor so, dass die X-Achse nach rechts und die Y-Achse nach oben zeigt. Warum das nicht der Standard ist verstehe ich auch nicht.
Man kann ein Stück weiter unten noch die Option "Nächsten Modellpunkt für Orbit verwenden" deaktivieren. Dann wird als Drehzentrum der Mittelpunkt der RangeBox der Baugruppe/des Bauteiles verwendet. In der Totalen die meiner Meinung bessere Wahl. Wenn man aber in einer Baugruppe nah an ein Bauteil zoomt und dort drehen will, ist die Option wiederrum Grütze. Verschiebt man während aktivem Orbit die Ansicht oder zoomt, wird der Drehpunkt neu gesetzt.
Ich hab mal in der Reservekiste gekramt und ein paar Beispiele herausgesammelt, die die Grundlagen hoffentlich verständlich zeigen. Theoretisch lässt sich damit ein kompletter Kameraflug erstellen. Wenn man schmerzfrei genug ist. Mit den Transformationsmatrizen sind auch kombinierte Translations- und Rotationsbewegungen möglich.

Code:

---

Option Explicit

' Deklarieren der Sleppfunktion, mit der zwischen den Rotationen kurze Pausen erzeugt werden
Public Declare PtrSafe Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As LongPtr) 'For 64-Bit versions of Excel

Private Const iWait As Integer = 200 ' Wartezeit in Millisekunden
Private Const iAngle As Integer = 30 ' Drehwinkel in Grad

Public Sub DemoStandardViews()

' Aufrufen aller vordefinierten Standardausrichtungen

Dim oApp As Inventor.Application
Set oApp = ThisApplication

Dim oDoc As Document
Set oDoc = oApp.ActiveDocument

If Not oDoc.DocumentType = kAssemblyDocumentObject And Not oDoc.DocumentType = kPartDocumentObject Then
    Call MsgBox("Funktion nur in 3D-Modellen verfügbar", vbCritical, "Demo Kamerasteuerung")
    Exit Sub
End If

Dim oView As View
Set oView = oApp.ActiveView

Dim oCam As Camera
Set oCam = oView.Camera

oCam.ViewOrientationType = kFrontViewOrientation
oCam.Fit
oCam.Apply
Sleep (iWait)

oCam.ViewOrientationType = kTopViewOrientation
oCam.Fit
oCam.Apply
Sleep (iWait)

oCam.ViewOrientationType = kRightViewOrientation
oCam.Fit
oCam.Apply
Sleep (iWait)

oCam.ViewOrientationType = kBackViewOrientation
oCam.Fit
oCam.Apply
Sleep (iWait)

oCam.ViewOrientationType = kLeftViewOrientation
oCam.Fit
oCam.Apply
Sleep (iWait)

oCam.ViewOrientationType = kIsoTopRightViewOrientation
oCam.Fit
oCam.Apply
Sleep (iWait)

oCam.ViewOrientationType = kIsoTopLeftViewOrientation
oCam.Fit
oCam.Apply
Sleep (iWait)

oCam.ViewOrientationType = kIsoBottomRightViewOrientation
oCam.Fit
oCam.Apply
Sleep (iWait)

oCam.ViewOrientationType = kIsoBottomLeftViewOrientation
oCam.Fit
oCam.Apply
Sleep (iWait)

' Aktivieren der Home-Ansicht
oView.GoHome
End Sub

Public Sub DemoViewZoom()

' die Änderung der Ansichtsgröße bewirkt einen Zoom

Dim oApp As Inventor.Application
Set oApp = ThisApplication

Dim oDoc As Document
Set oDoc = oApp.ActiveDocument

If Not oDoc.DocumentType = kAssemblyDocumentObject And Not oDoc.DocumentType = kPartDocumentObject Then
    Call MsgBox("Funktion nur in 3D-Modellen verfügbar", vbCritical, "Demo Kamerasteuerung")
    Exit Sub
End If

'Ermittlung der RangeBox
Dim oBox As Box
Set oBox = oDoc.ComponentDefinition.RangeBox

Dim dCenterX As Double
dCenterX = (oBox.MinPoint.X + oBox.MaxPoint.X) / 2

Dim dCenterY As Double
dCenterY = (oBox.MinPoint.Y + oBox.MaxPoint.Y) / 2

Dim dCenterZ As Double
dCenterZ = (oBox.MinPoint.Z + oBox.MaxPoint.Z) / 2

' Zentrum der RangeBox
Dim oCenterPoint As Point
Set oCenterPoint = oApp.TransientGeometry.CreatePoint(dCenterX, dCenterY, dCenterZ)

Dim oView As View
Set oView = oApp.ActiveView

Dim oCam As Camera
Set oCam = oView.Camera

' Zentrum der RangeBox als Drehzentrum
Dim oTarget As Point
Set oTarget = oCenterPoint
oCam.Apply

' die "Größe" der Ansicht/des Ansichtsfensters
' durch verändern wird gezoomt
Dim dViewHeight As Double
Dim dViewWidth As Double
Call oCam.GetExtents(dViewWidth, dViewHeight)

Call oCam.SetExtents(dViewWidth / 5, dViewHeight / 5)
oCam.Apply

Sleep (iWait)

Call oCam.SetExtents(dViewWidth * 2, dViewHeight * 2)
oCam.Apply

Sleep (iWait)

' Zoomen auf Größe der RangeBox
' liefert bei Ansichten, die nicht planparallel zur RangeBox liegen logischerweise wenig sinnvolles
Call oCam.SetExtents(oBox.MaxPoint.X - oBox.MinPoint.X, oBox.MaxPoint.Y - oBox.MinPoint.Y)
oCam.Apply

End Sub

Public Sub DemoViewPan()

' die parallele Änderung von KameraEye UND KameraTarget bewirkt einen Pan
' vereinfacht vorba Frontansicht aktivieren

Dim oApp As Inventor.Application
Set oApp = ThisApplication

Dim oDoc As Document
Set oDoc = oApp.ActiveDocument

If Not oDoc.DocumentType = kAssemblyDocumentObject And Not oDoc.DocumentType = kPartDocumentObject Then
    Call MsgBox("Funktion nur in 3D-Modellen verfügbar", vbCritical, "Demo Kamerasteuerung")
    Exit Sub
End If

Dim oTG As TransientGeometry
Set oTG = ThisApplication.TransientGeometry

Dim oView As View
Set oView = oApp.ActiveView

Dim oCam As Camera
Set oCam = oView.Camera

oCam.ViewOrientationType = kFrontViewOrientation
Dim dViewHeight As Double
Dim dViewWidth As Double
Call oCam.GetExtents(dViewWidth, dViewHeight)
Call oCam.SetExtents(dViewWidth * 1.5, dViewHeight * 1.5)
oCam.Apply

Dim oTarget As Point
Set oTarget = oCam.Target

Dim oEye As Point
Set oEye = oCam.Eye

Dim oVector As Vector
Set oVector = oTG.CreateVector(-10, 0, 0)

Call oEye.TranslateBy(oVector)
oCam.Eye = oEye
Call oTarget.TranslateBy(oVector)
oCam.Target = oTarget
oCam.Apply
Sleep (iWait)

oVector.X = 0
oVector.Y = 10
Call oEye.TranslateBy(oVector)
oCam.Eye = oEye
Call oTarget.TranslateBy(oVector)
oCam.Target = oTarget
oCam.Apply
Sleep (iWait)

oVector.X = 10
oVector.Y = 0
Call oEye.TranslateBy(oVector)
oCam.Eye = oEye
Call oTarget.TranslateBy(oVector)
oCam.Target = oTarget
oCam.Apply
Sleep (iWait)

oVector.X = 0
oVector.Y = -10
Call oEye.TranslateBy(oVector)
oCam.Eye = oEye
Call oTarget.TranslateBy(oVector)
oCam.Target = oTarget
oCam.Apply
Sleep (iWait)

End Sub

Public Sub DemoRotateCameraUpVector()

' Rotiert die Camera in Schritten um den aktuellen UpVector

Dim oApp As Inventor.Application
Set oApp = ThisApplication

Dim oDoc As Document
Set oDoc = oApp.ActiveDocument

If Not oDoc.DocumentType = kAssemblyDocumentObject And Not oDoc.DocumentType = kPartDocumentObject Then
    Call MsgBox("Funktion nur in 3D-Modellen verfügbar", vbCritical, "Demo Kamerasteuerung")
    Exit Sub
End If

Dim oTG As TransientGeometry
Set oTG = ThisApplication.TransientGeometry

Dim oView As View
Set oView = oApp.ActiveView

Dim oCam As Camera
Set oCam = oView.Camera

Dim iSteps As Integer
iSteps = 360 / iAngle

Dim oMatrix As Matrix
Set oMatrix = oTG.CreateMatrix

Call oMatrix.SetToRotation(iAngle * 3.14159 / 180, oCam.UpVector.AsVector, oCam.Target)

Dim oNewEye As Point
Set oNewEye = oCam.Eye

Dim i As Integer
For i = 1 To iSteps
    Call oNewEye.TransformBy(oMatrix)
    oCam.Eye = oNewEye
    oCam.Apply '.ApplyWithoutTransition
    Sleep (iWait)
Next

End Sub

Public Sub DemoRotateCameraXAxis()

' Rotiert die Camera in Schritten um die X-Achse
' Kamera rotieren funktioniert nur in der Front-/Rück/Oben- und Untenansicht
' für Rechts-/Linksansicht muss stattdessen der UpVector gedreht werden
' Unterscheidung durch ist-Parallel-Vergleich von Kamerasichtachse und X-Achse
' ISO-Ansichten und freie Position erzeugt Murks

Dim oApp As Inventor.Application
Set oApp = ThisApplication

Dim oDoc As Document
Set oDoc = oApp.ActiveDocument

If Not oDoc.DocumentType = kAssemblyDocumentObject And Not oDoc.DocumentType = kPartDocumentObject Then
    Call MsgBox("Funktion nur in 3D-Modellen verfügbar", vbCritical, "Demo Kamerasteuerung")
    Exit Sub
End If

Dim oTG As TransientGeometry
Set oTG = ThisApplication.TransientGeometry

Dim oView As View
Set oView = oApp.ActiveView

Dim oCam As Camera
Set oCam = oView.Camera

Dim iSteps As Integer
iSteps = 360 / iAngle

Dim oMatrix As Matrix
Set oMatrix = oTG.CreateMatrix

Dim oVector As Vector
'komplizierte Variante
'Set oVector = oDoc.ComponentDefinition.WorkAxes.Item(1).Definition.Axis.AsVector
'einfachere Variante Drehachse X
Set oVector = oTG.CreateVector(1, 0, 0)

' Drehachse Y
'Set oVector = oTG.CreateVector(0, 1, 0)

' Drehachse Z
'Set oVector = oTG.CreateVector(0, 0, 1)

Call oMatrix.SetToRotation(iAngle * 3.14159 / 180, oVector, oCam.Target)

Dim oNewEye As Point
Set oNewEye = oCam.Eye

Dim oNewUp As UnitVector
Set oNewUp = oCam.UpVector

Dim oVector2 As Vector
Set oVector2 = oCam.Eye.VectorTo(oCam.Target)

Dim i As Integer
For i = 1 To iSteps
    If oVector.IsParallelTo(oVector2) Then
        Call oNewUp.TransformBy(oMatrix)
        oCam.UpVector = oNewUp
    Else
        Call oNewEye.TransformBy(oMatrix)
        oCam.Eye = oNewEye
    End If
    oCam.Apply '.ApplyWithoutTransition
    Sleep (iWait)
Next

End Sub

Public Sub DemoRotateCameraAxis()

' Rotiert die Camera in Schritten um die horizontale Achse
' rotieren um die Vertikalachse --> siehe rotieren um den Upvector ;-)
' Drehzentrum im Mittelpunkt

Dim oApp As Inventor.Application
Set oApp = ThisApplication

Dim oDoc As Document
Set oDoc = oApp.ActiveDocument

If Not oDoc.DocumentType = kAssemblyDocumentObject And Not oDoc.DocumentType = kPartDocumentObject Then
    Call MsgBox("Funktion nur in 3D-Modellen verfügbar", vbCritical, "Demo Kamerasteuerung")
    Exit Sub
End If

Dim oTG As TransientGeometry
Set oTG = ThisApplication.TransientGeometry

Dim oView As View
Set oView = oApp.ActiveView

Dim oCam As Camera
Set oCam = oView.Camera

' der Y-Vector ist die "Sichtlinie" vom Target zum Kameraauge
Dim oVectorY As Vector
Set oVectorY = oCam.Target.VectorTo(oCam.Eye)

' der Z-Vector ist der UpVector der Kamera
Dim oVectorZ As Vector
Set oVectorZ = oCam.UpVector.AsVector

Dim oMatrix As Matrix
Set oMatrix = oTG.CreateMatrix

Call oMatrix.SetToRotation(3.14159 / 2, oVectorY, oCam.Target)

' Erzeugen des X-Vektors als Kopie des Z-Vectors und drehen um 90°
Dim oVectorX As Vector
Set oVectorX = oVectorZ.Copy()

Call oVectorX.TransformBy(oMatrix)

Dim iSteps As Integer
iSteps = 360 / iAngle

' neue Werte für die Rotationsmatrix festlegen
Call oMatrix.SetToRotation(iAngle * 3.14159 / 180, oVectorX, oCam.Target)

Dim oNewEye As Point
Set oNewEye = oCam.Eye

Dim i As Integer
For i = 1 To iSteps
    Call oNewEye.TransformBy(oMatrix)
    oCam.Eye = oNewEye
    oCam.Apply '.ApplyWithoutTransition
    Sleep (iWait)
Next

End Sub

---

------------------
MfG
Ralf

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

---

Servus,

dazu hatte ich auch mal etwas gebastelt und gepostet - wusste nicht mehr genau was das konnte. Bringt vmtl. keine weiteren Erkenntnisse, aber da ich es nun schon mal gefunden hab...
Camera - Drehung um die z-Achse

------------------
Gruß KraBBy

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

---

Zitat:

---

Original erstellt von KraBBy:
...auch mal etwas gebastelt und gepostet

---

Oh, Danke! Das macht ja schon fast genau das, was ich mir wünsche.

------------------
Roland  
www.Das-Entwicklungsbuero.de

It's not the hammer - it's the way you hit!

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

---

Moin!

Ich hab mir jetzt mal was ganz Primitives draus gebastelt (s.u.), das, egal aus welcher Richtung die Ansicht grad ist, das Gewünschte tut.
- Ist es egal, dass der neue Eye-Vektor durch meine Art der Berechnung länger wird?
- Wie lang sind diese Vektoren überhaupt?
- (Wo) Gibt es eine Dokumentation zu dem cam-Objekt?

Was ich auch noch nicht verstehe ist das tg. Warum kann ich nicht einfach schreiben
"cam.Eye = (cam.Eye.x + cam.UpVector.x, cam.Eye.y + cam.UpVector.y, cam.Eye.z + cam.UpVector.z)?

PS:
Es zeigt sich, dass der eye-Vektor verschieden lang sein kann. Die Drehung wird um so geringer, je "weiter weg die Kamera ist".
Ich habe mir dann auch im Watch-Fenste die Eigenschaften von cam angesehen. Up ist immer 1 lang, Eye ist immer verschieden lang, je nach Zoom-Zustand.
-> Wie lautet denn die Funktion für "Länge von Vektor"?
-> Gibt es überhaupt Vektor-Operationen in VBA? ("cam.Eye = cam.Eye + cam.UpVector" gilt z. B. nicht).

Code:

---

Sub CameraRotateUp()

    ' Get the active camera.
    Dim cam As Camera
    Set cam = ThisApplication.ActiveView.Camera
  
    Dim tg As TransientGeometry
    Set tg = ThisApplication.TransientGeometry
  
    cam.Eye = tg.CreatePoint(cam.Eye.x + cam.UpVector.x, cam.Eye.y + cam.UpVector.y, cam.Eye.z + cam.UpVector.z)
     
    cam.ApplyWithoutTransition
      
End Sub

Sub CameraRotateDown()

    ' Get the active camera.
    Dim cam As Camera
    Set cam = ThisApplication.ActiveView.Camera
  
    Dim tg As TransientGeometry
    Set tg = ThisApplication.TransientGeometry
  
    cam.Eye = tg.CreatePoint(cam.Eye.x - cam.UpVector.x, cam.Eye.y - cam.UpVector.y, cam.Eye.z - cam.UpVector.z)
     
    cam.ApplyWithoutTransition
      
End Sub

---

------------------
Roland  
www.Das-Entwicklungsbuero.de

It's not the hammer - it's the way you hit!

[Diese Nachricht wurde von Roland Schröder am 01. Apr. 2025 editiert.]

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

---

Moin

Das liegt daran, dass du dich nicht orbital um das Zielobjekt bewegst, sondern linear davon weg. Ist wie im Zug sitzen und einen Punkt draußen fixieren. Durch Kopfdrehung behälst du den Punkt im Blick, aber der Zug fährt mit dir linear davon weg.

Hier noch zwei Links (englisch), die es erklären:
Working with Cameras Part 1
Working with Cameras Part 2
Und der Link zur API-Hilfe des Cameraobjektes:
Inventor API Help

In der Inventor API können manche Objekteigenschaften nicht separat oder Objekte nicht direkt manipuliert werden. Dann ist es erforderlich ein neues Objekt zu erstellen und gegen das alte auszutauschen. Mir ist keine Aufstellung bekannt, wann das erforderlich ist. Ist eher so, wenn es direkt nicht funktioniert, einfach mal auf dem Umweg versuchen.

Der UpVector ist ein sogenannter UnitVector. Der ist immer exakt 1 lang. Die Einheit sind die von Inventor intern benutzten Zentimeter, auch wenn das nirgend explizit so steht.
Der Vector zwischen Eye und Target gibt mit seiner Länge die Entfernung vom Zielobjekt an. Bei perspektivischen Ansichten fällt das dann richtig deutlich auf. Das "Gegenstück" zu dieser Entfernung ist der CameraExtent, mit dem quasi der Zoom der Kamera gesteuert werden kann.

Operationen mit zwei Vektoren laufen eher als Methode des einen Vektors mit Angabe das anderen Vektors als Argument.
Vector1.AddVector(Vector2)
Vector1.DotProduct(Vector2)
Vector1.CrossProduct(Vector2)
usw.

------------------
MfG
Ralf

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

---

Die Rechnerei mit Vektoren funktioniert schon, aber leider nicht so intuitiv.
API help - vector object
Z.b.die Methode vector.AddVector() oder die Eigenschaft .Length.
Wenn es um die Länge geht, so kannst du einen vector erst mit .Normalize und dann mit .ScaleBy auf die gewünschte Länge bringen.

------------------
Gruß KraBBy

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

---

Zitat:

---

Original erstellt von rkauskh:
...nicht orbital um das Zielobjekt ...

---

Ja, die vektorielle Addition von Eye und Up ergibt eine größere Entfernung, das hatte ich noch nicht bedacht. Aber die davon erwartbare Auswirkung ist bei der Anwendung meines Codes nicht sichtbar; die Größe des Modells auf dem Bildschirm bleibt beim Drehen, auch nach mehreren vollen Umdrehungen, genau gleich.

Ansonsten auch tausend Dank an alle Beteiligten für die vielen Hinweise und Links zu Dokumentationen; da hab ich ordentlich was zum Studieren. Wobei mir mein auch primitiver Zweizeiler jetzt schon sehr viel nützt.

------------------
Roland  
www.Das-Entwicklungsbuero.de

It's not the hammer - it's the way you hit!

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

---

Moin

So ganz blicke ich bei den Kameras auch nicht durch. Es könnte sein, dass bei der Vergrößerung der Entfernung zwischen Eye und Target implizit der Zoom gegensteuert, da die ViewExtent-Werte gleich bleiben. Normalerweise würde ja der sichtbare Bildbereich größer werden, wenn man sich vom Objekt entfernt. Bleibt der Bildbereich aber konstant, muss ein Zoom stattfinden.

------------------
MfG
Ralf

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

---

Zitat:

---

Original erstellt von rkauskh:
... ViewExtent-Werte ... ...muss ein Zoom stattfinden.

---

Was das angeht, lügt sich die Software ja ohnehin irgendwas zusammen, denn aus einer endlichen Entfernung kann es keine parallele Ansicht geben.

Meine Beobachtung, dass die Darstellungsgröße gleich bleibt, erfolgte bei paralleler Ansicht.

Später:
Ja, bei perspektivischer Ansicht tritt der erwartete Effekt ein, dass die Entfernung mit jeder Anwendung der Drehung ein Stück zunimmt und die Darstellung des Modells immer kleiner wird. Stört mich aber jetzt erst mal nicht so sehr.

Schöner fände ich es schon, mit einer sauberen Vektor-Operation (Kreuzprodukt) den Eye-Punkt exakt orbital zu bewegen. Ich denke nämlich auch an eine Drehung um eine Achse parallel zum Up-Vektor.

Aber das führt jetzt erst mal zu weit. Wir müssen ja auch Geld verdienen, und wie nützlich solche Hilfsmittel auch sein mögen, die Zeit für deren Erstellung bezahlt mir keiner.

Um so mehr Danke noch mal für Eure Hilfe!

------------------
Roland  
www.Das-Entwicklungsbuero.de

It's not the hammer - it's the way you hit!

[Diese Nachricht wurde von Roland Schröder am 01. Apr. 2025 editiert.]

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

---

Moin

Als Fehler würde ich das nicht bezeichnen. Es ist eine mögliche Art der Projektion. Die Parallelansicht projeziert die Ansicht eines 3-dimensionalen Körpers auf die 2-dimensionale Fläche des Bildschirms, indem jeder Punkt lotrecht auf die Bildschirmfläche projeziert wird. Die perspektivische Ansicht verwendet Strahlen, die vom Bildzentrum durch den Modellpunkt bis zur Bildschirmfläche gehen.
Bei der Parallelansicht kann man dadurch beliebig weit weg gehen, ohne das sich am sichtbaren Bild irgendetwas verändert. Da hatte ich mit meinem gleichzeitigen Zoom einen Denkfehler. Der ist gar nicht nötig.

------------------
MfG
Ralf

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

---

20250401_IVCamera.png 20250401_IVCamera_Skizze.png

Mahlzeit,

meine Erkenntnisse aus Spielereien mit der IV-Camera decken sich mit euren.

• bei orthogonaler Ansicht ist die Entfernung Eye-Target egal
  
• für den Zoom geben die Extents den Ausschlag und selbst da nur einer von beiden (der größere, auch je nach Seitenverhältnis des View - es wird mindestens das mit den Maßen angegebene Rechteck dargestellt
  
• bei perspektivischer Darstellung könnte man noch mit dem PerspectiveAngle spielen vmtl. wirkt sich der wieder auf die Koordinaten vom Eye aus

Falls es hilft, ein bischen mehr Code zum Spielen. Mir gefällt für eine derartige Anwendung zwei Varianten durch Drücken der Shift-Taste zu unterscheiden. Der Code biegt dann an einer bestimmten Stelle anders ab - hier: 'nach oben' bzw. mit Shift 'nach unten'. Dann braucht es auch nur einen Befehl auf der Oberfläche oder Shortcut.

Code:

---

Option Explicit

Declare PtrSafe Function GetKeyState Lib "user32" (ByVal vKey As Integer) As Integer
'vmtl. muss bei der älteren IV-Version das PtrSafe weg

Function ShiftPressed() As Boolean
'Returns True if shift key is pressed
    ShiftPressed = GetKeyState(vbKeyShift) < 0          ' 16 = vbKeyShift
End Function

Sub Test_RotUp()

Dim bReverse As Boolean
bReverse = ShiftPressed()   'gedrückte Shift-Taste erkennen
'weiter unten wird dadurch der UpVector umgekehrt
bReverse = True 'f. Test

Dim oCam As Camera
Set oCam = ThisApplication.ActiveView.Camera

'Dim oEye As Point   'im weiteren vermieden, deshalb auskommentiert
'Set oEye = oCam.Eye
'Dim oTarget As Point
'oTarget = oCam.Target

Dim oUp As Vector
Set oUp = oCam.UpVector.AsVector.Copy    '.AsVector um aus UnitVector einen Vector zu machen
If bReverse Then Call oUp.ScaleBy(-1) 'hier greift die Shift-Taste

Dim TE As Vector    'Vector von Target nach Eye
Set TE = oCam.Target.VectorTo(oCam.Eye)
Dim TE_len As Double    'Länge des Vectors = Abstand Target - Eye
TE_len = TE.Length

' da TE und Up senkrecht zueinander stehen
' könnte man auch einen konstanten Winkel benutzen für die Drehung
' dh. konstantes Längenverhältnis
' 1/10 entspricht ca 5,7°
Call oUp.ScaleBy(TE_len / 10)

Dim oEyeNeu As Point
Set oEyeNeu = oCam.Eye.Copy '.Copy um einen unabhängigen Punkt zu erhalten
Call oEyeNeu.TranslateBy(oUp)

Dim TEn As Vector   'Vector von Target zu EyeNeu
Set TEn = oCam.Target.VectorTo(oEyeNeu)
Call TEn.Normalize  'Vector mit Länge 1
Call TEn.ScaleBy(TE_len)    'Vector wieder verlängert auf alten Abstand
Set oEyeNeu = oCam.Target.Copy
Call oEyeNeu.TranslateBy(TEn)  'EyeNeu = Target + TEn
'jetzt ist der Abstand zw. Target und Eye wieder wie vorher

oCam.Eye = oEyeNeu
Call oCam.Apply

End Sub

---

Außerdem ist Rechnen mit Punkt und Vector in etwas anderer Form enthalten: Punkt.TraslatedBy(Vector)
dabei wird der Punkt um den Vector verschoben

Edit / Ergänzung:
es ist wichtig zu verhindern, dass der Code in einer Zeichnung ausgeführt wird. Da kommt Quatsch raus, der auf der Benutzeroberfläche nicht mehr zu beheben ist. Zum Beispiel zu Beginn diese Zeile hinzu:

Code:

---

If TypeOf ThisApplication.ActiveDocument Is DrawingDocument Then Exit Sub

---

------------------
Gruß KraBBy

[Diese Nachricht wurde von KraBBy am 01. Apr. 2025 editiert.]

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