private static ImageSource caricaMascheraDaCorrezioneXml(string correzioneXml)
        {
            ImageSource    imageSource = caricaImmagineDefault();
            CorrezioniList correzioni  = SerializzaUtil.stringToObject <CorrezioniList>((String)correzioneXml);

            ImmagineWic  immagineMaschera = null;
            Mascheratura mascheratura     = null;

            if (correzioni != null && correzioni.Contains(typeof(Mascheratura)))
            {
                mascheratura = (Mascheratura)correzioni.FirstOrDefault(c => c is Mascheratura);
            }
            if (correzioni != null && correzioni.Contains(typeof(MascheraturaOrientabile)))
            {
                MascheraturaOrientabile mo = (MascheraturaOrientabile)correzioni.FirstOrDefault(c => c is MascheraturaOrientabile);
                mascheratura = mo.mascheraturaH ?? mo.mascheraturaV;
            }


            if (mascheratura != null)
            {
                immagineMaschera = new ImmagineWic(Path.Combine(PathUtil.getCartellaMaschera(FiltroMask.MskSingole), mascheratura.nome));
            }

            if (immagineMaschera != null)
            {
                imageSource = ((ImmagineWic)immagineMaschera).bitmapSource as ImageSource;
            }

            return(imageSource);
        }
예제 #2
0
        public void outOfMemoryTest()
        {
            const int quante  = 1000;
            string    nomeImg = Costanti.getNomeImmagineRandom();

            GestoreImmagineSrvImpl impl = (GestoreImmagineSrvImpl)(LumenApplication.Instance.getServizioAvviato <IGestoreImmagineSrv>());
            BitmapSource           bmp2 = new BitmapImage(new Uri(nomeImg));
            IImmagine immagine          = new ImmagineWic(bmp2);

            // Ricavo la memoria libera prima del test
            GC.Collect();
            long memoryPrima = Process.GetCurrentProcess().WorkingSet64;

            for (int ii = 0; ii < quante; ii++)
            {
                string tmpFile = System.IO.Path.GetTempFileName();

                if (1 == 1)
                {
                    impl.save(immagine, tmpFile);
                }
#if FALSO
                if (1 == 0)
                {
                    // cosi funziona
                    impl.save2(bmp2, tmpFile);
                }
                else
                {
#endif
                using (FileStream fileStream = new FileStream(tmpFile, FileMode.Create)) {
                    JpegBitmapEncoder encoder = new JpegBitmapEncoder();
                    encoder.Frames.Add(BitmapFrame.Create(((ImmagineWic)immagine).bitmapSource));
                    encoder.Save(fileStream);
                    fileStream.Close();
                }
#if FALSO
            }
#endif
                System.IO.File.Delete(tmpFile);

                long memoryDurante = Process.GetCurrentProcess().WorkingSet64;

                long diffDurante = (memoryDurante - memoryPrima);

                if ((ii % 10) == 0)
                {
                    Console.WriteLine("consumo = " + (diffDurante / 1024));
                }

                // Se supero il massimo impostato, probabilmente il gc non sta pulendo.
                if (diffDurante > maxMem)
                {
                    Assert.Fail("Probabilmente si sta consumando troppa memoria: diff(MB)=" + diffDurante / 1024);
                }
            }

            immagine.Dispose();
        }
예제 #3
0
        public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
        {
            // Non spostare da qui questo vettore. Deve essere istanziato ogni volta, altrimenti romper il cavolo con i thread diversi
            ShaderEffect [] localEffetcs = new ShaderEffect[] { new GrayscaleEffect() };

            ImmagineWic iw = (ImmagineWic)immagineSorgente;

            BitmapSource modificata = EffectsUtil.RenderImageWithEffectsToBitmap(iw.bitmapSource, localEffetcs);

            return(new ImmagineWic(modificata));
        }
        public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
        {
            // Purtroppo devo creare un array con un solo elemento. TODO migliorare
            ShaderEffect lce = (ShaderEffect)ConvertTo(correzione, typeof(ShaderEffect));

            ShaderEffect [] _effetti = new ShaderEffect [] { lce };

            ImmagineWic iw = (ImmagineWic)immagineSorgente;

            BitmapSource modificata = EffectsUtil.RenderImageWithEffectsToBitmap(iw.bitmapSource, _effetti);

            return(new ImmagineWic(modificata));
        }
예제 #5
0
        public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
        {
            ImmagineWic  imgSorgente  = (ImmagineWic)immagineSorgente;
            BitmapSource bitmapSource = imgSorgente.bitmapSource;

            ScaleTransform scaleTransform = new ScaleTransform();

            scaleTransform.ScaleX = -1;

            // Create the TransformedBitmap to use as the Image source.
            TransformedBitmap tb = new TransformedBitmap(bitmapSource, scaleTransform);

            ImmagineWic modificata = new ImmagineWic(tb);

            return(modificata);
        }
예제 #6
0
        public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
        {
            // Purtroppo devo creare un array con un solo elemento. TODO migliorare
            DominantiEffect de = new DominantiEffect();

            de.Red   = ((Dominante)correzione).rosso;
            de.Green = ((Dominante)correzione).verde;
            de.Blue  = ((Dominante)correzione).blu;
            ShaderEffect [] _effetti = new ShaderEffect [] { de };

            ImmagineWic iw = (ImmagineWic)immagineSorgente;

            BitmapSource modificata = EffectsUtil.RenderImageWithEffectsToBitmap(iw.bitmapSource, _effetti);

            return(new ImmagineWic(modificata));
        }
예제 #7
0
        public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
        {
            throw new NotImplementedException("occorre un container per traslare");

            // TODO da capire.
            // Concettualmente non ha senso traslare una immagine su se stessa.
            // Occorre avere un riferimento, un contenitore esterno su cui agire.
            // Una immagine con appiccicata una traslazione ha senso, ma l'immagine risultante da sola che senso ha ?
#if CONCETTUALMENTE_NON_VALIDO
            ImmagineWic  imgSorgente  = (ImmagineWic)immagineSorgente;
            BitmapSource bitmapSource = imgSorgente.bitmapSource;

            TranslateTransform tt = (TranslateTransform)this.ConvertTo(correzione, typeof(TranslateTransform));

            // Create the TransformedBitmap to use as the Image source.
            TransformedBitmap tb = new TransformedBitmap(bitmapSource, tt);

            ImmagineWic modificata = new ImmagineWic(tb);
            return(modificata);
#endif
        }
예제 #8
0
        public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
        {
            _giornale.Debug("Richiesta correzione: " + correzione.GetType().Name);

            long   calcW, calcH;
            Resize resizeCorrezione = (Resize)correzione;

            ResizeCorrettore.calcolaEsattaWeH(immagineSorgente, resizeCorrezione.latoMax, out calcW, out calcH);

            BitmapSource bitmapSource = ((ImmagineWic)immagineSorgente).bitmapSource;


            /* I dpi sono una indicazione per la stampa.
             * Non impattano sui dati dell'immagine.
             * Non impattano sulla dimensione dell'immagine.
             * Non impattano sulla qualità dell'immagine.
             * In pratica è solo un "consiglio" per la stampa.
             *
             * Siccome credo che le stampanti termiche/sublimazione se ne fregano di questo parametro (per ovvi motivi)
             * allora me ne sbatto.
             * Occorrebbe fare una prova con una laser o con una InkJet per vedere se il risultato stampato cambia.
             *
             * int quantiDpi;
             * quantiDpi = (int) Math.Max( bitmapSource.DpiX, bitmapSource.DpiY );
             * quantiDpi = (int) Math.Max( quantiDpi, DPI_PROVINO );
             */

            BitmapSource bitmapFrame = Resize(bitmapSource, calcW, calcH, DPI_PROVINO);

            // _giornale.Debug( "effettuato resize" );
            if (bitmapFrame.CanFreeze)
            {
                bitmapFrame.Freeze();
            }
            ImmagineWic immagine = new ImmagineWic(bitmapFrame);

            return(immagine);
        }
예제 #9
0
        public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
        {
            Logo logoCorrezione = (Logo)correzione;

            // Questo è il nome del file completo su disco della immagine del logo
            string nomeCompletoLogo = PathUtil.nomeCompletoLogo(logoCorrezione);

            if (!File.Exists(nomeCompletoLogo))
            {
                throw new FileNotFoundException(nomeCompletoLogo);
            }

            // Costruisco l'immagine di overlay
            ImmagineWic imgLogo = new ImmagineWic(nomeCompletoLogo);

            // Ricavo la bitmap sorgente
            BitmapSource bmpSorgente = ((ImmagineWic)immagineSorgente).bitmapSource;

            // -- inizio ad applicare le trasformazioni al logo
            IImmagine immagineLogoModificato = imgLogo;

            //
            // :: rotazione
            //

            if (logoCorrezione.rotazione != null)
            {
                RuotaCorrettore ruotaCorrettore = new RuotaCorrettore();
                immagineLogoModificato = ruotaCorrettore.applica(immagineLogoModificato, logoCorrezione.rotazione);
            }

            //
            // :: zoom
            //

            if (logoCorrezione.zoom != null)
            {
                ZoomCorrettore zoomCorrettore = new ZoomCorrettore();
                immagineLogoModificato = zoomCorrettore.applica(immagineLogoModificato, logoCorrezione.zoom);
            }

            BitmapSource bitmapSourceLogoModificato = ((ImmagineWic)immagineLogoModificato).bitmapSource;

            //
            // :: traslazione
            //

            // Queste sono le coordinate su cui disegnare il logo
            Rect posiz = calcolaCoordinateLogo(bmpSorgente.PixelWidth, bmpSorgente.PixelHeight, immagineLogoModificato.ww, immagineLogoModificato.hh, logoCorrezione);

            // Creo due immagini disegnabili con i rettangoli delle immagini interessate
            // 1. Tutta la foto di sfondo
            Rect         rectSotto    = new Rect(0, 0, bmpSorgente.PixelWidth, bmpSorgente.PixelHeight);
            ImageDrawing drawingSotto = new ImageDrawing(bmpSorgente, rectSotto);

            // 2. Il riquando ricalcolato del logo
            Rect         rectSopra    = new Rect(posiz.Left, posiz.Top, posiz.Width, posiz.Height);
            ImageDrawing drawingSopra = new ImageDrawing(bitmapSourceLogoModificato, rectSopra);

            // Adesso ho entrambe le immagini. Le sovrappongo usando un gruppo.
            DrawingGroup myDrawingGroup = new DrawingGroup();

            myDrawingGroup.Children.Add(drawingSotto);
            myDrawingGroup.Children.Add(drawingSopra);
            // Disegno il gruppo in una nuova immagine.
            Image myImage = new Image();

            myImage.Source = new DrawingImage(myDrawingGroup);

            int w = (int)rectSotto.Width;
            int h = (int)rectSotto.Height;
            // Renderizzo l'immagine finita, in una bitmap in modo da poterla ritornare.
            RenderTargetBitmap rtb = new RenderTargetBitmap(w, h, 96d, 96d, PixelFormats.Default);

            DrawingVisual dv = new DrawingVisual();

            using (DrawingContext ctx = dv.RenderOpen()) {
                ctx.DrawDrawing(myDrawingGroup);
            }
            rtb.Render(dv);

            return(new ImmagineWic(rtb));
        }
예제 #10
0
        public void outOfMemoryStampa()
        {
            long memoryPrima = Process.GetCurrentProcess().WorkingSet64;

            string[] nomiFilesImmagine = Costanti.NomiFileImmagini;

            // 10 foto x 50 giri = 500 foto
            foreach (string nomeFileImmagine in nomiFilesImmagine)
            {
                for (int giri = 1; giri <= 50; giri++)
                {
                    using (PrintServer ps1 = new PrintServer()) {
                        using (PrintQueue coda = ps1.GetPrintQueue(Costanti.NomeStampante)) {
                            PrintDialog dialog = new PrintDialog();
                            dialog.PrintQueue = coda;

                            Size areaStampabile = new Size(dialog.PrintableAreaWidth, dialog.PrintableAreaHeight);
                            // Ora creo il documento che andrò a stampare.
                            // L'uso di un FixedDocument, mi permetterà di interagire con misure, dimensioni e margini
                            FixedDocument document = new FixedDocument();
                            document.DocumentPaginator.PageSize = new Size(dialog.PrintableAreaWidth, dialog.PrintableAreaHeight);

                            // Creo una pagina della grandezza massima
                            FixedPage page1 = new FixedPage();
                            page1.Width               = document.DocumentPaginator.PageSize.Width;
                            page1.Height              = document.DocumentPaginator.PageSize.Height;
                            page1.VerticalAlignment   = VerticalAlignment.Center;
                            page1.HorizontalAlignment = HorizontalAlignment.Center;


                            // Per fare in modo che l'immagine venga centrata bene automaticamente, e non venga tagliata solo da una parte ma nel centro,
                            // non devo mettere le dimensioni al componente Image, ma devo creare
                            // una Grid più esterna con le dimensioni precise.
                            Grid grid = new Grid();
                            grid.Height = page1.Height;
                            grid.Width  = page1.Width;


                            // Creo una immagine che contiene la bitmap da stampare
                            Image image = new Image();
                            image.VerticalAlignment   = VerticalAlignment.Center;
                            image.HorizontalAlignment = HorizontalAlignment.Center;

                            // E' importante fare la dispose dell'oggetto Immagine
                            using (ImmagineWic qq = new ImmagineWic(nomeFileImmagine)) {
                                image.Source = qq.bitmapSource;

                                image.Stretch          = Stretch.UniformToFill;
                                image.StretchDirection = StretchDirection.Both;
                                grid.Children.Add(image);
                                page1.Children.Add(grid);


                                // add the page to the document
                                PageContent page1Content = new PageContent();
                                page1Content.Child = page1;
                                document.Pages.Add(page1Content);

                                //
                                // ----- STAMPA per davvero
                                //
                                dialog.PrintDocument(document.DocumentPaginator, "test" + giri.ToString());

                                foreach (var fixedPage in document.Pages.Select(pageContent => pageContent.Child))
                                {
                                    fixedPage.Children.Clear();
                                }
                            }

                            // ATTENZIONE: IMPORTANTE.
                            // Se non metto questa formula magica,
                            // il GC non pulisce la memoria occupata dalla bitmap (inspiegabilmente)
                            FormuleMagiche.rilasciaMemoria();
                        }
                    }

                    long memoryDopo = Process.GetCurrentProcess().WorkingSet64;
                    long consumata  = (memoryDopo - memoryPrima);

                    // Se supero il massimo impostato, probabilmente il gc non sta pulendo.
                    if (consumata > maxMem)
                    {
                        Assert.Fail("Probabilmente si sta consumando troppa memoria: diff(MB)=" + consumata / 1024);
                    }
                }
            }
        }