コード例 #1
0
ファイル: ProiettoreArea.cs プロジェクト: digiPHOTO-it/lumen
        public Proiezione calcola(Int32Rect sorgente)
        {
            Proiezione proiezione = new Proiezione();

            _effettuataRotazione = false;

            if (autoZoomToFit)
            {
                // In questo caso, l'area di stampa è massima e si scarta un pezzo della foto.
                proiezione.sorg = calcolaAreaSorgente(sorgente);
                proiezione.dest = dest;
            }
            else
            {
                // In questo caso, la foto è presa sempre tutta, ma l'area di stampa è parziale.
                proiezione.sorg = sorgente;
                proiezione.dest = calcolaAreaDestinazione(sorgente);
            }

            proiezione.effettuataRotazione = _effettuataRotazione;

            return(proiezione);
        }
コード例 #2
0
        public static double calcolaDimensione(Fascia qualeFascia, Dimensione qualeDimens, float ratioCarta, Geo imageGeo, Geo imageActualGeo)
        {
            if (ratioCarta == 0)              // probabilmente non è indicata nemmeno una stampante
            {
                return(0d);
            }

            if (imageGeo.w == 0d || imageGeo.h == 0d)
            {
                return(0d);
            }

            if (imageActualGeo.w == 0d || imageActualGeo.h == 0d)
            {
                return(0d);
            }

            // -----

            float ratioImage = (float)(imageActualGeo.w / imageActualGeo.h);

            // I due rapporti mi indicano che sia la foto che l'area stampabile siano nella stesso verso (Orizzontali o Verticali entrambi)
            if (ratioImage < 1 && ratioCarta >= 1 || ratioImage >= 1 && ratioCarta < 1)
            {
                // non sono dello stesso verso. lo giro!
                ratioCarta = (1f / ratioCarta);
            }

            // Se la carta è più grande della foto (inteso come rapporto), allora devo tagliare sopra.
            // Questo mi garantisce il corretto funzionamento indipendentemente dal verso della foto.
            // Quindi le due bande colorate saranno sopra e sotto in orizzontale
            // Nel caso contrario saranno a sinistra e destra in verticale.
            bool eseguoTaglioOrizz = (ratioCarta > ratioImage);

            // -----

            // Ora creo due rettangoli per poter usare il ProiettoreArea
            Int32Rect fotoSorgente = new Int32Rect(0, 0, (int)imageActualGeo.w, (int)imageActualGeo.h);

            // creo un area dello stesso orientamento
            int       cartaW         = (int)(1000 * ratioCarta);
            int       cartaH         = (int)(cartaW / ratioCarta);
            Int32Rect stampanteFinta = new Int32Rect(0, 0, cartaW, cartaH);

            // Eseguo proiezione per capire dove e quanto verrà tagliata la foto originale.
            ProiettoreArea proiettore = new ProiettoreArea(stampanteFinta, true);
            Proiezione     proiezione = proiettore.calcola(fotoSorgente);

            // -----
            //
            // Ora finalmente calcolo il valore da ritornare
            //
            // -----
            double ret = 0d;

            // Width
            if (qualeDimens == Dimensione.Width)
            {
                if (eseguoTaglioOrizz)
                {
                    ret = (double)proiezione.sorg.Width;
                }
                else
                {
                    ret = (double)proiezione.sorg.X;
                }
            }

            // Height
            if (qualeDimens == Dimensione.Height)
            {
                if (eseguoTaglioOrizz)
                {
                    ret = (double)proiezione.sorg.Y;
                }
                else
                {
                    ret = (double)proiezione.sorg.Height;
                }
            }

            // Left (del canvas)
            if (qualeDimens == Dimensione.Left)
            {
                double offsetX = (imageGeo.w - imageActualGeo.w) / 2;
                if (qualeFascia == Fascia.FasciaB && eseguoTaglioOrizz == false)
                {
                    offsetX += (imageActualGeo.w - proiezione.sorg.X);
                }
                ret = offsetX;
            }

            // Top (del canvas)
            if (qualeDimens == Dimensione.Top)
            {
                double offsetY = (imageGeo.h - imageActualGeo.h) / 2;
                if (qualeFascia == Fascia.FasciaB && eseguoTaglioOrizz == true)
                {
                    offsetY += (imageActualGeo.h - proiezione.sorg.Y);
                }
                ret = offsetY;
            }

            return(ret);
        }