/// <summary> /// Rileggo dal db la fotografia. In questo modo, ricopro la proprietà correzioniXml che /// era stata modificata dall'utente applicando delle correzioni che poi non ha confermato. /// </summary> /// <param name="fotografia"></param> public void undoCorrezioniTransienti(Fotografia fotografia) { fotografieRepositorySrv.refresh(fotografia); fotografia.imgProvino = null; // Questo forza la rilettura del provino da disco AiutanteFoto.idrataImmaginiFoto(fotografia, IdrataTarget.Provino); }
public void OnNext(FotoModificateMsg fmMsg) { if (slideShow == null) { return; } foreach (Fotografia modificata in fmMsg.fotos) { int pos = slideShow.slides.IndexOf(modificata); if (pos > 0) { AiutanteFoto.disposeImmagini(slideShow.slides[pos], IdrataTarget.Provino); // Se la foto è stata modificata, allora mi copio le correzioni. slideShow.slides[pos].correzioniXml = modificata.correzioniXml; // Se ho a disposizione l'immagine del provino, me la copio, altrimenti me la rileggo da disco. if (modificata.imgProvino != null) { slideShow.slides[pos].imgProvino = (Digiphoto.Lumen.Imaging.IImmagine)modificata.imgProvino; } else { AiutanteFoto.idrataImmaginiFoto(slideShow.slides[pos], IdrataTarget.Provino, true); } } } }
private byte[] getImage(Guid fotografiaId, IdrataTarget quale) { byte[] bytes = null; using (new UnitOfWorkScope()) { var srv = LumenApplication.Instance.getServizioAvviato <IEntityRepositorySrv <Fotografia> >(); Fotografia fotografia = srv.getById(fotografiaId); string nomeFileImg; // Qui faccio una piccola miglioria: Se l'immagine risultante ha delle correzioni non ancora applicate, le applico adesso. if (quale == IdrataTarget.Risultante) { nomeFileImg = AiutanteFoto.idrataImmagineDaStampare(fotografia); } else { nomeFileImg = AiutanteFoto.idrataImmaginiFoto(fotografia, quale); } bytes = File.ReadAllBytes(nomeFileImg); AiutanteFoto.disposeImmagini(fotografia, IdrataTarget.Tutte); } return(bytes); }
public void applicaCorrezioneLogo() { using (LumenEntities dbContext = new LumenEntities()) { Random rnd = new Random(); ImmagineWic iw; Fotografia foto; do { int num = rnd.Next(1, 1000); iw = null; // Scelgo una foto qualsiasi e prendo l'immagine originale (cosi non rischio di avere già dei loghi) foto = dbContext.Fotografie.FirstOrDefault(f => f.numero == num); if (foto != null) { AiutanteFoto.idrataImmaginiFoto(foto, IdrataTarget.Originale); iw = (ImmagineWic)foto.imgOrig; } } while(iw == null); _correttore = new LogoCorrettore(); Logo logo = LogoCorrettore.creaLogoDefault(); /* * logo.zoom = new Zoom { * fattore = 3 * }; * * logo.rotazione = new Ruota( 45 ); * * logo.traslazione = new Trasla { * offsetX = 100, * offsetY = 300, * rifW = iw.ww, * rifH = iw.hh * }; */ // logo.posiz = Logo.PosizLogo.NordEst; vediLogo(foto.imgOrig, logo); // logo.posiz = Logo.PosizLogo.NordOvest; vediLogo(foto.imgOrig, logo); // logo.posiz = Logo.PosizLogo.SudEst; vediLogo(foto.imgOrig, logo); // logo.posiz = Logo.PosizLogo.SudOvest; vediLogo(foto.imgOrig, logo); } }
/** Idrato in modo asincrono gli attributi delle immagini che ho caricato */ private void idrataImmaginiFoto() { foreach (Fotografia fotografia in fotografie) { // Per essere più veloce, idrato solo l'immagine del provino. AiutanteFoto.idrataImmaginiFoto(fotografia, IdrataTarget.Provino); // TODO forse occorre lanciare un evento di foto caricata ??? // essendo la collezione bindabile, forse non ce ne sarà bisogno..... // vedremo. Per ora risparmio fatica. } // Lancio un messaggio che dice che è stata portata a termine una nuova ricerca LumenApplication.Instance.bus.Publish(new RicercaModificataMessaggio(this)); // Mando anche un messaggio di refresh per i provini che ho liberato LumenApplication.Instance.bus.Publish(new RefreshMsg(this)); }
/// <summary> /// Lancio GIMP e gli passo l'elenco delle foto indicate /// </summary> /// <param name="fotografie"></param> public Fotografia [] modificaConProgrammaEsterno(Fotografia [] fotografie) { LanciatoreEditor lanciatore = new LanciatoreEditor(fotografie); lanciatore.lancia(); List <Fotografia> modificate = lanciatore.applicaImmaginiModificate(); Gimp correzioneGimp = new Gimp(); foreach (Fotografia foto in modificate) { // Ora idrato l'immagine risultante AiutanteFoto.idrataImmaginiFoto(foto, IdrataTarget.Risultante); addCorrezione(foto, correzioneGimp, false); } return(modificate.ToArray()); }
/// <summary> /// Faccio qualche controllo preventivo. /// </summary> /// <param name="fotografia"></param> /// <param name="ruota"></param> public void autoRuotaSuOriginale(Fotografia fotografia, Ruota ruota) { if (fotografia.correzioniXml != null) { throw new LumenException("Sulla foto " + fotografia.numero + " esistono correzioni.\nImpossibile ruotare sull'originale.\nRimuovere prima le correzioni (torna originale)"); } if (!ruota.isAngoloRetto) { throw new ArgumentException("La rotazione sull'originale funziona solo con angoli retti"); } string nomeFileOrig = PathUtil.nomeCompletoOrig(fotografia); string estensione = Path.GetExtension(nomeFileOrig); if (fotografia.imgOrig == null) { AiutanteFoto.idrataImmaginiFoto(fotografia, IdrataTarget.Originale); } IImmagine imgRuotata = applicaCorrezione(fotografia.imgOrig, ruota); string nomeFileBackup = Path.ChangeExtension(nomeFileOrig, "BACKUP" + estensione); if (!File.Exists(nomeFileBackup)) { // Salvo per sicurezza il file originale File.Move(nomeFileOrig, nomeFileBackup); } fotografia.imgOrig = imgRuotata; gestoreImmaginiSrv.save(imgRuotata, nomeFileOrig); AiutanteFoto.creaProvinoFoto(fotografia); // Libero memoria. Lascio solo il provino AiutanteFoto.disposeImmagini(fotografia, IdrataTarget.Originale); AiutanteFoto.disposeImmagini(fotografia, IdrataTarget.Risultante); }
public void outOfMemoryImmagini() { const int quante = 1000; const int ogniTotPurga = 100; List <Fotografia> ff = cercaFotoQuasiasi(5); // Ricavo la memoria libera prima del test long memoryPrima = Process.GetCurrentProcess().WorkingSet64; for (int ii = 0; ii < quante; ii++) { foreach (Fotografia f in ff) { AiutanteFoto.idrataImmaginiFoto(f, IdrataTarget.Tutte); AiutanteFoto.disposeImmagini(f, IdrataTarget.Tutte); // ogni tot iterazioni, vado a liberare la memoria che inspiegabilmente non viene pulita. if ((ii % ogniTotPurga) == 0) { // ATTENZIONE: IMPORTANTE. // Se non metto questa formula magica, // il GC non pulisce la memoria occupata dalla bitmap (inspiegabilmente) FormuleMagiche.rilasciaMemoria(); } long memoryDurante = Process.GetCurrentProcess().WorkingSet64; long consumata = (memoryDurante - 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); } } } }
private void orologio_Tick(object sender, EventArgs e) { if (eventualePubblicita() == true) { return; } // carico la collezione delle slide visibili andando avanti di una pagina if (slidesVisibili == null) { slidesVisibili = new ObservableCollection <Fotografia>(); } else { // Prima di azzerare la lista, libero la memoria delle precedenti rilasciaEdAzzeraVisibili(); } int conta = 0; do { // Se sono arrivato alla fine dello show, ricomincio da capo gestisciFineShow(); if (numSlideCorrente < slideShow.slides.Count) { this.slidesVisibili.Add(slideShow.slides [numSlideCorrente++]); } else { break; // si vede che la lista è vuota lunga zero. } ++conta; // esco se ho finito la pagina, oppure se ho finito le foto } while(conta < totSlidesPerPagina && conta < slideShow.slides.Count); OnPropertyChanged("slidesVisibili"); OnPropertyChanged("numFotoCorrente"); // Le foto ritornate dal servizio di ricerca, non sono idratate. // Quindi le idrato un pò alla volta quando passano da qui // Al primo giro sarà più lento perché le deve idratare per davvero. // Dal secondo giro, invece non ci sarà più bisogno foreach (Fotografia f in slidesVisibili) { try { AiutanteFoto.idrataImmaginiFoto(f, IdrataTarget.Provino); } catch (Exception) { // Se la foto è rovinata, oppure inaccessibile, devo proseguire } } // Dopo che ho visualizzato le foto, se mi accorgo che il numero totale di foto da visualizzare // è inferiore al numero massimo di foto che stanno nello show, // allora è inutile che lascio il timer acceso, tanto non ho altro da mostrare. if (slideShow.slides.Count <= totSlidesPerPagina) { stop(); } }
private void aggiungiImmagineAlCanvas(Canvas canvas, Fotografia foto, int riga, int col) { try { // Ricavo l'immagine da stampare IImmagine immagine; bool usoGrande = false; if (usoGrande) { AiutanteFoto.idrataImmagineDaStampare(foto); immagine = AiutanteFoto.idrataImmagineGrande(foto); immaginiPaginaPrecedente.Add(immagine); } else { AiutanteFoto.idrataImmaginiFoto(foto, IdrataTarget.Provino); immagine = foto.imgProvino; } Image img = new Image(); img.Stretch = Stretch.UniformToFill; img.StretchDirection = StretchDirection.Both; { // calcolo posizione left int tc = lavoroDiStampaTessera.paramStampaTessera.numColonne; double tuc = sizeLatoW * tc; double spaziow = (larghezzaEffettiva - tuc) / (tc + 1); double left = (spaziow * col) + (sizeLatoW * (col - 1)); img.SetValue(Canvas.LeftProperty, left); } { // calcolo posizione top int tr = lavoroDiStampaTessera.paramStampaTessera.numRighe; double tur = sizeLatoH * tr; double spazioh = (altezzaEffettiva - tur) / (tr + 1); double top = (spazioh * riga) + (sizeLatoH * (riga - 1)); img.SetValue(Canvas.TopProperty, top); } // Queste due dimensioni invece sono fisse img.Width = sizeLatoW; img.Height = sizeLatoH; img.HorizontalAlignment = HorizontalAlignment.Center; img.VerticalAlignment = VerticalAlignment.Center; if (immagine != null) { img.RenderSize = new Size(img.Width, img.Height); // TODO tento di tenere bassa la memoria img.BeginInit(); BitmapSource bs = ((ImmagineWic)immagine).bitmapSource; img.Source = bs; img.EndInit(); } canvas.Children.Add(img); } catch (Exception ee) { // Non rilancio l'eccezione perché voglio continuare a stampare _giornale.Error("Impossibile caricare immagime della foto: " + foto, ee); } }
private void aggiungiImmagineAlCanvas(Canvas canvas, Fotografia foto, double x, double y) { try { // Ricavo l'immagine da stampare IImmagine provino; if (usoGrande) { AiutanteFoto.idrataImmagineDaStampare(foto); provino = AiutanteFoto.idrataImmagineGrande(foto); if (Configurazione.UserConfigLumen.tecSogliaStampaProvini == -3) { IGestoreImmagineSrv g = LumenApplication.Instance.getServizioAvviato <IGestoreImmagineSrv>(); IImmagine provino2 = g.creaProvino(provino, 1000); provino = (IImmagine)provino2.Clone(); ((ImmagineWic)provino).bitmapSource.Freeze(); AiutanteFoto.disposeImmagini(foto, IdrataTarget.Originale); AiutanteFoto.disposeImmagini(foto, IdrataTarget.Risultante); } immaginiPaginaPrecedente.Add(provino); } else { AiutanteFoto.idrataImmaginiFoto(foto, IdrataTarget.Provino); provino = foto.imgProvino; } Image img = new Image(); img.Stretch = Stretch.Uniform; img.StretchDirection = StretchDirection.Both; img.SetValue(Canvas.TopProperty, (Double)(sizeLatoH * (y - 1)) + testataH); img.SetValue(Canvas.LeftProperty, (Double)(sizeLatoW * (x - 1) + margin / 2)); img.Width = sizeLatoW - margin; img.Height = sizeLatoH - margin; img.HorizontalAlignment = HorizontalAlignment.Center; img.VerticalAlignment = VerticalAlignment.Center; if (provino != null) { img.RenderSize = new Size(img.Width, img.Height); // TODO tento di tenere bassa la memoria img.BeginInit(); BitmapSource bs = ((ImmagineWic)provino).bitmapSource; img.Source = bs; img.EndInit(); } canvas.Children.Add(img); } catch (Exception ee) { // Non rilancio l'eccezione perché voglio continuare a stampare _giornale.Error("Impossibile caricare immagime della foto: " + foto, ee); } eventualiStampigli(canvas, x, y, foto); }