public async Task <IActionResult> Get(int chiave, Dimensione dimensione)
        {
            var fotografia = await _context.Fotografie.FirstOrDefaultAsync(x => x.Chiave == chiave && x.Dimensione == dimensione);

            if (fotografia == null)
            {
                return(NotFound());
            }

            switch (Enum.Parse <StorageType>(_config["Files:Storage"].Default("database"), true))
            {
            case StorageType.Database:
                var stream = new MemoryStream(fotografia.Content);

                return(new FileStreamResult(stream, fotografia.ContentType));

            case StorageType.File:
                if (!System.IO.File.Exists(fotografia.Path))
                {
                    return(NotFound());
                }

                var memory = new MemoryStream();
                using (var fileStream = new FileStream(fotografia.Path, FileMode.Open))
                {
                    await fileStream.CopyToAsync(memory);
                }
                memory.Position = 0;
                return(File(memory, fotografia.ContentType, fotografia.FileName));

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
示例#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);
        }