/// <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);
}
