Bild drehen ; Winkel umrechnen ?

Beitrag von **AUGE_OHR** » Di, 09. Feb 2016 10:57

ich möchte mit der API "PlgBlt" ein Bild (225x225) drehen
https://msdn.microsoft.com/de-de/librar ... 85%29.aspx

das geling mir bei jeweils 90° Winkeln

Code: Alles auswählen

   DO CASE
      CASE nDegrees = 0    ; aVertices := { {  0, 225}, {225, 225}, {  0,  0} }
      CASE nDegrees = 90   ; aVertices := { {  0,   0}, {  0, 225}, {225,  0} }
      CASE nDegrees = 180  ; aVertices := { {225,   0}, {  0,   0}, {225,225} }
      CASE nDegrees = 270  ; aVertices := { {225, 225}, {225,   0}, {  0,225} }
   ENDCASE

nun benötigt man einen binären String

Code: Alles auswählen

   cVertices := L2Bin(aVertices[1,1])+L2Bin(oDest:CurrentSize()[2]-aVertices[1,2])+;
                L2Bin(aVertices[2,1])+L2Bin(oDest:CurrentSize()[2]-aVertices[2,2])+;
                L2Bin(aVertices[3,1])+L2Bin(oDest:CurrentSize()[2]-aVertices[3,2])

um die Transformation durchzuführen

Code: Alles auswählen

   nRet := DllCall("Gdi32.dll",DLL_STDCALL,;
                              "PlgBlt"    ,;
                              hDC2        ,;
                              cVertices   ,;
                              hDC1        ,;
                              aPos2[1], aPos2[2] ,;
                              aSize[1], aSize[2] ,;
                              0, 0, 0)

: API_Rotate.jpg (50.98 KiB) 7958 mal betrachtet

Frage : wie komme ich auf die "Zwischenwerte" <> 90° ?

p.s. was für Werte Loop/Sec bekommt ihr ?

Beitrag von **Hans Zethofer** » Di, 09. Feb 2016 21:25

dxe.dll fehlt!

Herbert · Beitrag von **Herbert** » Di, 09. Feb 2016 21:56

Such hier: http://www.xbaseforum.de/viewtopic.php? ... 1&start=50

Beitrag von **Hans Zethofer** » Di, 09. Feb 2016 22:06

p.s. was für Werte Loop/Sec bekommt ihr ?

198.81 Loop/sec

Beitrag von **AUGE_OHR** » Di, 09. Feb 2016 22:36

Hans Zethofer hat geschrieben:dxe.dll fehlt!

uuuuuuuups ... sorry
ich hatte zum testen dir DXE.LIB eingebunden aber benötige die wohl gar nicht für die Demo

Code: Alles auswählen

198.81 Loop/sec

was für eine GFK ? wenn Win7 welcher "Leistungsindex" ? "Online" oder "Offline" ?

"Offline" 250, "Online" mit FF 240 aber wenn ich hier im Editor bin dann nur noch 150 ... Index 3.3
mit eine Radeon HD 6570 schaffe ich > 750, Index 6.9

Beitrag von **AUGE_OHR** » Di, 09. Feb 2016 23:29

so langsam fange ich an die API Function "PlgBlt" zu verstehen.

https://msdn.microsoft.com/de-de/librar ... 85%29.aspx

lpPoint [in]

A pointer to an array of three points in logical space that identify three corners of the destination parallelogram.

The upper-left corner of the source rectangle is mapped to the first point in this array, the upper-right corner to the second point in this array, and the lower-left corner to the third point. The lower-right corner of the source rectangle is mapped to the implicit fourth point in the parallelogram.

da ich ein Quadrat habe klappt es bei je 90°

wenn ich nun das Quadrat (grün) um 45° drehe würden die Ecken oben/unten/links/rechts (rot) "ausserhalb" der ursprünglichen Fläche sein (Kreisbogen).

: QKQ.jpg (15.4 KiB) 7924 mal betrachtet

da ich die Grösse der XbpStatic, welcher als Parent dient, nicht verändere "malt" er das ganze verkleinert.

: Kreisbogen.jpg (58.26 KiB) 7924 mal betrachtet

ich muss also mit SIN() / COS() was machen ... wie war das noch ...

Leon · Beitrag von **Leon** » Di, 09. Feb 2016 23:33

952.38 Loop/sec unter einem virtuellen Windows 10 Prof. auf einem iMac mit i7 (3.4 GHz9 und NVIDIA GeForce GTX 675MX mit 1024MB

Herbert · Beitrag von **Herbert** » Mi, 10. Feb 2016 13:06

AUGE_OHR hat geschrieben:wenn ich nun das Quadrat (grün) um 45° drehe würden die Ecken oben/unten/links/rechts (rot) "ausserhalb" der ursprünglichen Fläche sein (Kreisbogen).

Eh, nein, wenn dein Quadrat wirklich eins ist, also alle Seiten gleich lang, bleiben die Ecken immer auf dem Kreis.

Frage so nebenbei: Wieso hast du im Array nur drei Ecken und nicht alle 4?

Anderer Ansatz:
Nimmst den Mittelpunkt m, der Radius r ist die Distanz Mittelpunkt zur Ecke. Rechnest:

Punkt A besteht aus x=m+r*cos(winkel1), y=m+r*sin(Winkel1)

Punkt A' ist dann einfach x=m+r*cos(winkel1+deltaWinkel), y=m+r*sin(winkel1+deltawinkel)

Beitrag von **brandelh** » Mi, 10. Feb 2016 14:00

Herbert hat geschrieben:
AUGE_OHR hat geschrieben:wenn ich nun das Quadrat (grün) um 45° drehe würden die Ecken oben/unten/links/rechts (rot) "ausserhalb" der ursprünglichen Fläche sein (Kreisbogen).
Eh, nein, wenn dein Quadrat wirklich eins ist, also alle Seiten gleich lang, bleiben die Ecken immer auf dem Kreis.

das wäre nur so, wenn das Quatrat kleiner als der Kreis ist und die Ecken auf dem Kreisbogen liegen, ein Bild mit einem Kreis wie oben hat Jimmy schon recht, würde die "Ecke" unsichtbar werden.
Da der Hintergrund aber gleich bleibt (z.B. XbpStatic) wird sich der weiße Hintergrund auch nicht ändern, die Grafik wird gedreht gezeichnet und die "sichtbaren Ecken" bleiben wo sie sind.

Beitrag von **brandelh** » Mi, 10. Feb 2016 14:03

Ich habe für meine Druckerklasse (ohne XBTools !) eine Funktion geschrieben, die die Drehung der Schrift in 1° Schritten berechnet, zuerst der Aufruf:

Code: Alles auswählen

   if ! IsNil(nDrehen)
      aadd(aAttribNeu, { GRA_AS_ANGLE , HbGradToXppArray(nDrehen,100) } )
   endif

nDrehen ist in ° ... statt dem Array kann man natürlich auch cos() und sin() aus den Tools verwenden.

Code: Alles auswählen

*----------------------------------------------------------
function HbGradToXppArray(nDrehen,nFaktor)        
   local nX, nY, aCosSin, nDrehenInt

   DEFAULT nFaktor TO 1                            // Werte zwischen -1 und 1, für Ausgabe in Bildpunkten sind diese Werte zu klein
                                                   // über Faktor kann die Länge bestimmt werden:   1 = 1/10mm, 10 = 1 mm etc.
                                                   // Valuerange is -1 to 1, for printtext etc. are the values to low
                                                   // the length could be defined with nFaktor:   1 = 1/10mm, 10 = 1 mm etc.

   aCosSin :=  { {1.0000000000000000,0.0000000000000000} , ;   // 0 Grad -> nDrehenInt+1 -> 1. Element
                 {0.9998476951563913,0.0174524064372835} , ;   // 1 Grad -> nDrehenInt+1 -> 2. Element
                 {0.9993908270190958,0.0348994967025010} , ;
                 {0.9986295347545739,0.0523359562429438} , ;
                 {0.9975640502598243,0.0697564737441253} , ;
                 {0.9961946980917455,0.0871557427476582} , ;   // Falls jemand eine bessere Funktion weiß, bitte mitteilen.
                 {0.9945218953682733,0.1045284632676535} , ;   // if someone knows a better (fast) way, let me know.
                 {0.9925461516413220,0.1218693434051475} , ;
                 {0.9902680687415704,0.1391731009600654} , ;
                 {0.9876883405951378,0.1564344650402309} , ;
                 {0.9848077530122080,0.1736481776669303} , ;
                 {0.9816271834476640,0.1908089953765448} , ;
                 {0.9781476007338058,0.2079116908177593} , ;
                 {0.9743700647852353,0.2249510543438650} , ;
                 {0.9702957262759965,0.2419218955996677} , ;
                 {0.9659258262890683,0.2588190451025208} , ;
                 {0.9612616959383189,0.2756373558169992} , ;
                 {0.9563047559630355,0.2923717047227367} , ;
                 {0.9510565162951535,0.3090169943749474} , ;
                 {0.9455185755993169,0.3255681544571567} , ;
                 {0.9396926207859084,0.3420201433256687} , ;
                 {0.9335804264972018,0.3583679495453003} , ;
                 {0.9271838545667874,0.3746065934159120} , ;
                 {0.9205048534524404,0.3907311284892738} , ;
                 {0.9135454576426009,0.4067366430758001} , ;
                 {0.9063077870366499,0.4226182617406994} , ;
                 {0.8987940462991670,0.4383711467890774} , ;
                 {0.8910065241883679,0.4539904997395468} , ;
                 {0.8829475928589270,0.4694715627858908} , ;
                 {0.8746197071393958,0.4848096202463371} , ;
                 {0.8660254037844388,0.4999999999999999} , ;
                 {0.8571673007021124,0.5150380749100541} , ;
                 {0.8480480961564260,0.5299192642332049} , ;
                 {0.8386705679454240,0.5446390350150271} , ;
                 {0.8290375725550418,0.5591929034707468} , ;
                 {0.8191520442889918,0.5735764363510460} , ;
                 {0.8090169943749475,0.5877852522924731} , ;
                 {0.7986355100472929,0.6018150231520483} , ;
                 {0.7880107536067219,0.6156614753256583} , ;
                 {0.7771459614569709,0.6293203910498374} , ;
                 {0.7660444431189780,0.6427876096865393} , ;
                 {0.7547095802227720,0.6560590289905073} , ;
                 {0.7431448254773943,0.6691306063588583} , ;
                 {0.7313537016191706,0.6819983600624985} , ;
                 {0.7193398003386513,0.6946583704589973} , ;
                 {0.7071067811865476,0.7071067811865475} , ;
                 {0.6946583704589973,0.7193398003386511} , ;
                 {0.6819983600624985,0.7313537016191705} , ;
                 {0.6691306063588583,0.7431448254773941} , ;
                 {0.6560590289905073,0.7547095802227720} , ;
                 {0.6427876096865394,0.7660444431189780} , ;
                 {0.6293203910498375,0.7771459614569709} , ;
                 {0.6156614753256583,0.7880107536067219} , ;
                 {0.6018150231520484,0.7986355100472929} , ;
                 {0.5877852522924731,0.8090169943749475} , ;
                 {0.5735764363510461,0.8191520442889918} , ;
                 {0.5591929034707468,0.8290375725550418} , ;
                 {0.5446390350150272,0.8386705679454240} , ;
                 {0.5299192642332049,0.8480480961564260} , ;
                 {0.5150380749100544,0.8571673007021123} , ;
                 {0.5000000000000001,0.8660254037844386} , ;
                 {0.4848096202463371,0.8746197071393958} , ;
                 {0.4694715627858909,0.8829475928589269} , ;
                 {0.4539904997395468,0.8910065241883678} , ;
                 {0.4383711467890774,0.8987940462991670} , ;
                 {0.4226182617406994,0.9063077870366499} , ;
                 {0.4067366430758002,0.9135454576426009} , ;
                 {0.3907311284892737,0.9205048534524404} , ;
                 {0.3746065934159122,0.9271838545667874} , ;
                 {0.3583679495453004,0.9335804264972018} , ;
                 {0.3420201433256688,0.9396926207859084} , ;
                 {0.3255681544571568,0.9455185755993168} , ;
                 {0.3090169943749474,0.9510565162951535} , ;
                 {0.2923717047227368,0.9563047559630354} , ;
                 {0.2756373558169992,0.9612616959383189} , ;
                 {0.2588190451025208,0.9659258262890683} , ;
                 {0.2419218955996677,0.9702957262759965} , ;
                 {0.2249510543438652,0.9743700647852353} , ;
                 {0.2079116908177595,0.9781476007338056} , ;
                 {0.1908089953765449,0.9816271834476640} , ;
                 {0.1736481776669304,0.9848077530122080} , ;
                 {0.1564344650402309,0.9876883405951378} , ;
                 {0.1391731009600655,0.9902680687415704} , ;
                 {0.1218693434051475,0.9925461516413220} , ;
                 {0.1045284632676535,0.9945218953682733} , ;
                 {0.0871557427476581,0.9961946980917455} , ;
                 {0.0697564737441255,0.9975640502598243} , ;
                 {0.0523359562429440,0.9986295347545739} , ;
                 {0.0348994967025011,0.9993908270190958} , ;
                 {0.0174524064372836,0.9998476951563913} , ;
                 {0.0000000000000000,1.0000000000000000} }

   nDrehenInt  := int(nDrehen)                          // 23.123 -> aCosSin[23, X/Y ]

   do case
      case nDrehenInt >=  0 .and. nDrehenInt <= 90
           nX := aCosSin[nDrehenInt+1,1]
           nY := aCosSin[nDrehenInt+1,2]
      case nDrehenInt >  90 .and. nDrehenInt <=180
           nDrehenInt := 180-nDrehenInt
           nX := aCosSin[nDrehenInt+1,1] * -1
           nY := aCosSin[nDrehenInt+1,2]
      case nDrehenInt > 180 .and. nDrehenInt<=270
           nDrehenInt -= 180
           nX := aCosSin[nDrehenInt+1,1] * -1
           nY := aCosSin[nDrehenInt+1,2] * -1
      case nDrehenInt > 270 .and. nDrehenInt<=360
           nDrehenInt := 360-nDrehenInt
           nX := aCosSin[nDrehenInt+1,1]
           nY := aCosSin[nDrehenInt+1,2] * -1
   endcase

return {nX*nFaktor,nY*nFaktor}

Herbert · Beitrag von **Herbert** » Mi, 10. Feb 2016 14:36

brandelh hat geschrieben:wenn das Quatrat kleiner als der Kreis ist und die Ecken auf dem Kreisbogen liegen, ein Bild mit einem Kreis wie oben hat Jimmy schon recht, würde die "Ecke" unsichtbar werden.

Hmm... wenn das Quadrat kleiner ist, wird es den Kreis nie erreichen....

Wenn das Quadrat gleich gross oder grösser ist als der Kreis, dann muss der Kreis bei Drehung an den Orten des Verlassens wieder gezeichnet werden.

Hubert, gibt es keine Funktion für Sinus und Cosinus? So muss man doch nicht selber errechnete Daten in ein Array schreiben...

Beitrag von **brandelh** » Mi, 10. Feb 2016 14:47

Herbert hat geschrieben:Hubert, gibt es keine Funktion für Sinus und Cosinus?
So muss man doch nicht selber errechnete Daten in ein Array schreiben...

in den XbToolsIII gibt es diese und somit standardmäßig auch in Xbase 2.0

Meine Druckerklasse sollte aber immer unabhängig von den Tools sein, daher meine "Krücke"

Zum Quatrat im Kreis und dem Kreis im Quatrat ...

Wenn die Kantenlänge dem Durchmesser des Kreises entspricht (wie oben), berührt der Kreis die MITTE der Seitenkanten,
aber nie deren Ecken, die sind außerhalb des Kreises, da die Diagonale im Quatrat länger ist als die Kantenlänge.

Herbert · Beitrag von **Herbert** » Mi, 10. Feb 2016 19:38

brandelh hat geschrieben: Wenn die Kantenlänge dem Durchmesser des Kreises entspricht (wie oben), berührt der Kreis die MITTE der Seitenkanten,
aber nie deren Ecken, die sind außerhalb des Kreises, da die Diagonale im Quatrat länger ist als die Kantenlänge.

...was nichts an der Formel ändert..

Beitrag von **AUGE_OHR** » Mi, 17. Feb 2016 4:41

hi,

ungeachtet der Geschwindigkeit, welche bei den Demos ähnlich ist, hab ich ein optisches Problem ...

das Demo Drehbild.EXE startet mit klick auf die Static. beide drehen ein Bild 8 x 45° was zunächst langsam als Demo gezeigt wird. danach wird bei 100 Loops die Performance errechnet.

wie schon gesagt machen beide das selbe (in ca. der selben Zeit) aber optisch sieht das schnelle drehen unterschiedlich aus ... wieso ?

Beitrag von **AUGE_OHR** » Fr, 19. Feb 2016 1:47

hat jetzt nichts mit dem Bild zu tun sondern um das Verhalten von MsgBox() bei den beiden Demos in DrehBild.ZIP ( benötigt "Color.JPG" aus ROTATE.ZIP )

1.) starte 1st. Demo und warte bis die Msgbox() erscheint
2.) starte das 2nd Demo und warte wieder bis die Msgbox() erscheint.

nun klick jeweils auf das "Main" Fenster von einer Demo.

bei DrehBild.EXE fängt dann an die entsprechende Msgbox an zu blinken.
bei Rotate.EXE gelangt man zum "Main" Fenster und die Msgbox() ist im Hintergrund aktiv.

Unterschied : das eine kommt als Class aus dem Formdesigner das andere ist "von Hand" als Function.

könnt ihr das Verhalten bestätigen ?

Inoffizielles deutsches Xbase-Forum

Bild drehen ; Winkel umrechnen ?

Bild drehen ; Winkel umrechnen ?

Re: Bild drehen ; Winkel umrechnen ?

Re: Bild drehen ; Winkel umrechnen ?

Re: Bild drehen ; Winkel umrechnen ?

Re: Bild drehen ; Winkel umrechnen ?

Re: Bild drehen ; Winkel umrechnen ?

Re: Bild drehen ; Winkel umrechnen ?

Re: Bild drehen ; Winkel umrechnen ?

Re: Bild drehen ; Winkel umrechnen ?

Re: Bild drehen ; Winkel umrechnen ?

Re: Bild drehen ; Winkel umrechnen ?

Re: Bild drehen ; Winkel umrechnen ?

Re: Bild drehen ; Winkel umrechnen ?

Re: Bild drehen ; Winkel umrechnen ?

Re: Bild drehen ; Winkel umrechnen ?