Newsgroup: it.comp.lang.visual-basic
Titolo: ruotare immagine

Come si fa a ruotare un immagine di 90°.
o al meglio ruotare in una direzione qualsiasi.
Grazie Alberto.

 Come si fa a ruotare un immagine in visual basic 6?
Ti riposto un commento che avevo scritto qualche messagio fa in merito:
Se ti accontenti di essere compatibile solo con Win NT da 3.1 in su (quindi
anche Win 2000, ma nè Win 95 nè Win 98), c'è l'API SetWorldTransform che
applica il giusto calcolo matriciale ad ogni punto del device context che
contiene la tua immagine.
Se invece hai mire di massima compatibilità, devi fare i calcoli a manina.
Posto che l'angolo sia A, devi applicare le seguenti trasformazioni alla
coordinata X e Y di ciascun punto della tua bitmap:
x' = (x * cos A) - (y * sin A)
y' = (x * sin A) + (y * cos A)
Altrimenti usi le DirectX che hanno il metodo SetRotation. Ma in questo caso
è tutto un altro paio di maniche (e non è neppure il mio campo).
Ciao
*Roby*
Il trucco sta nel passare valori negativi a PaintPicture.
Ti do un frammento di codice di esempio come spunto per successivi prove ed esperimenti.
In un form metti due picture box, una grande ed una piccola da una parte (verra' nascosta).
Quella piccola chiamala picHidden.
Option Explicit
Const strPicFileName = "C:\MiaImmagine.jpg"   ' sostituire con il path di una picture esistente sul proprio pc
Private Sub Form_DblClick()
    ' capovolge l' immagine
    Picture1.PaintPicture picHidden.Picture, 0, picHidden.Height, picHidden.Width, -picHidden.Height
End Sub
Private Sub Form_Load()
    picHidden.Visible = False
    picHidden.AutoSize = True
    picHidden.Picture = LoadPicture(strPicFileName)
    Picture1.AutoRedraw = True
    Picture1.PaintPicture picHidden.Picture, 0, 0
End Sub
ciao, hal

 ha scritto


se continua a non leggere la rispost, il post sara' ripost parecchie volt...
porca putt...
alla prossima lo floodo :->
ciao, hal

y' = (x * sin A) + (y * cos A)
lo chef consiglia: siccome seno e coseno sono operazioni pesantucce, 
conviene costruirsi all'avvio del programma una tabella usando due 
array:
sinTable(0) = sin(0)
sinTable(1) = sin(1)
...
eccetera, sino a sin(359), di più non serve perchè il periodo della 
funzione è di 360°. Velocizzerebbe notevolmente le operazioni (anzichè 
delle complesse operazioni matematiche si tratterà solo di leggere un 
valore da un'area di memoria)

 effettuabile tramite ciclo for...next.
Per velocizzare anche quello, basta calcolare il seno solo fino a 90 gradi.
Da 91 a 180 si riprendono i valori calcolati prima, ma ribaltati (91 = 89,
92 = 88, etc). Invece da 181 gradi in poi, si possono riprendere gli stessi
valori da 0 a 179, con segno opposto (181 = -1, 182 = -2, etc).
Volevo solo ricordare che la funziona Sin accetta solo angoli in radianti.
Se si lavora in gradi, bisogna moltiplicare il proprio valore per pi e
dividerlo per 180.
Ah, la trigonometria. 8-)
Ciao
*Roby*

 ha scritto nel messaggio
news:9al142$5p45a$1...@ID-56381.news.dfncis.de...

Ma no, dai.
Al momento mi sono limitato a mandargli il tuo messaggio riepilogativo via
e-mail dicendogli di leggere le risposte quando fa le domande.
Grazie comunque per avermi citato. Rileggersi nei messaggi degli altri è una
bella sensazione.  8-)
Ciao
*Roby*

 ha scritto nel messaggio
news:0Vmz6.10220$wG3.8...@news.infostrada.it...


anzi è l'unica cosa che so.
Se ti basta ruotare di 90', ti puoi accontentare dell' uso schietto di PaintPicture, gia'
citato nelle risposte precedenti.
ciao, hal

ne so molto e, per la mia salute mentale, preferisco ignorarlo :-)
Visto che il thread sta prendendo una piega esoterica e 
siccome non ho piu' salute mentale da perdere, sono andato a riguardarmi
la struttura SAFEARRAY che vb usa per descrivere gli array e la ricopio paro paro
(legge sull' editoria permettendo :-> )
struct SAFEARRAY
   {
      WORD cDims; // number of dimensions
      WORD fFeatures; // bitfield indicating attributes of a particular
                      // array
      DWORD cbElements; // size of an element of the array
      DWORD cLocks; // lock counter
      Void * pvData; // pointer to the array's elements (use only if
                     // cLocks>0)
      SAFEARRAYBOUND rgsabound[1]; // structure containing information for
                                   // each dimension
   }; 
Aggiungo anche:
struct SAFEARRAYBOUND
   {
      DWORD cElements; // number of elements on a given dimension
      long lLbound; // lower boundary on a given dimension
   }; 
Mi pare quindi che, ragionando su array monodimensionali, 
per accedere ad un preciso elemento, vb moltiplichi l' indice per la DWORD cbElements.
ciao, hal

 ha scritto nel messaggio
news:9anks4$67ssi$1...@ID-56381.news.dfncis.de...


 Cosi' si fanno 1/4 di chiamate a Sin(). Adoro le ottimizzazioni :-)
Lascia stare.Mi ricordo quando in assembler si tenevano nel sorgente le
tabelle di seno e coseno in valori interi moltiplicati per 256 e
arrotondati, così moltiplicavi e shiftavi il risultato di 8 bit, ottenendo
un risultato con approssimazione accettabile (almeno per i 320*200 del video
sotto Dos) senza dover utilizzare i calcoli in virgola mobile, visto che
all'epoca il coprocessore ce l'avevano solo i ricchi.
E' una roba che faceva anche Doom, ma loro per girare richiedevano
specificatamente un 386, quindi potevano lavorare a 32bit. Potevano
addirittura sprecare 16bit per il valore di seno e coseno, e la precisione
ne guadagnava parecchio.
Per velocizzare, si creavano tabelle anche per gli offset di inizio delle
righe video, così risparmiavi la moltiplicazione di X e Y per trovare la
locazione giusta del pixel. Doom era multirisoluzione e le tabelle di offset
se le ricalcolava in partenza in base alla risoluzione scelta.
Allora valeva la regola che dice che la velocità del codice è inversamente
proporzionale alla sua compattezza. I maniaci evitavano anche le chiamate a
funzioni e preferivano usare delle macro di compilazione per ripetere il
codice tale e quale in diverse parti del programma, così si risparmiava il
salto di andata, il salvataggio dei parametri sullo stack e il salto di
ritorno. Però dovevi stare attento che il  codice non superasse i 64K di
dimensione.
Ad esempio per moltiplicare per 10, si shiftava di 3 bit e si risommava il
valore 2 volte. Considerato quanto ci metteva la moltiplicazione negli 8088,
conveniva decisamente.
Se penso che adesso lavoro in Visual Basic...vabbè, vado a ripettinarmi la
barba bianca... 8-)
Ciao
*Roby*

 passi a verticale.
Usa 2 PictureBox. Setta lo scalemode in Pixel che è + comodo e mettile
entrambe autorefresh così non sbagli.
Cicla su X e Y della prima con 2 for uno dentro l'altro utilizzando
scalewidth e scaleheight per sapere quanti pixel  è larga e alta.
Leggi il valore del Pixel (che poi è il colore) utilizzando il metodo point
della picturebox
Riscrivi il valore del pixel sulla seconda picturebox, alla posizione
calcolata modificando X e Y in base alle formule di rotazione, usando il
metodo PSet.
Se proprio non ci riesci, vedrai che qualcuno che ti scrive il codice lo
trovi.
Ma prima fai qualche esperimento, che è pure divertente. 8-)
Ciao
*Roby*

 *Roby*
Da Roby a Ruby c'e` solo lo shift di una vocale.
--
Ciao.
Maurizio
--------
?SPQR(C)
 X
--------

 Da Roby a Ruby c'e` solo lo shift di una vocale.
Cos'è Ruby, a parte un linguaggio tipo il Perl molto object oriented?
http://www.ruby-lang.org/en/whats.html
Ciao
*Roby*

 
http://www.ruby-lang.org/en/whats.html
"Ruby, il prototipo del componente visivo di cio` che e` ora Visual Basic."
Kurata, Deborah _Oggetti e Microsoft(R) Visual Basic_. (A pag. 43 dell'ed.
per vb4)
Di piu`... non so.


 ha scritto nel messaggio
news:Ia0A6.6068$r67.1...@news2.tin.it...


 che sorpresa >:-]
Quanti URL vuoi sulle invenzioni Microsoft stavolta? ;-)
Ciao
*Roby*
P.S:
Centra poco, ma M$ ha finalmente deciso di uccidere la graffetta in Office
XP e l'ha fatto con molto stile, aprendo un sito satirico che mi ha fatto
ridere di gusto:
http://www.officeclippy.com