void provinatore_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
Fotografia foto = (Fotografia)e.UserState;
bool esistevaRisultante = foto.imgRisultante != null;
// Rilascio memoria
AiutanteFoto.disposeImmagini(foto, IdrataTarget.Tutte);
AiutanteFoto.creaProvinoFoto(foto);
// Le due foto grandi le rilascio per non intasare la memoria qualora questo metodo è chiamato più volte
AiutanteFoto.disposeImmagini(foto, IdrataTarget.Originale);
AiutanteFoto.disposeImmagini(foto, IdrataTarget.Risultante);
bool esisteRisultante = foto.imgRisultante != null;
// Siccome è molto probabile che venga idratata l'immagine risultante e siccome sono in un loop,
// non posso tenere in memoria tanta roba, altrimenti esplode
if (esisteRisultante && !esistevaRisultante)
{
// Significa che l'ho idratata io in questo momento
AiutanteFoto.disposeImmagini(foto, IdrataTarget.Risultante);
}
// Avviso tutti che questa foto è cambiata
FotoModificateMsg msg = new FotoModificateMsg(this, foto);
pubblicaMessaggio(msg);
}
/// <summary>
/// Elimina tutte le Correzioni da una foto e quindi ricrea il provino
/// </summary>
public void tornaOriginale(Fotografia fotografia, bool salvare)
{
fotografia.correzioniXml = null;
// Rimuovo anche eventuale file su disco
string nomeFileRis = PathUtil.nomeCompletoRisultante(fotografia);
if (File.Exists(nomeFileRis))
{
File.Delete(nomeFileRis);
}
// Rilascio memoria
AiutanteFoto.disposeImmagini(fotografia, IdrataTarget.Tutte);
AiutanteFoto.creaProvinoFoto(fotografia);
// Le due foto grandi le rilascio per non intasare la memoria qualora questo metodo è chiamato più volte
AiutanteFoto.disposeImmagini(fotografia, IdrataTarget.Originale);
AiutanteFoto.disposeImmagini(fotografia, IdrataTarget.Risultante);
if (salvare)
{
Fotografia f = fotografia;
fotografieRepositorySrv.update(ref f, true);
fotografieRepositorySrv.saveChanges(); // Persisto nel db le modifiche
// Devo informate tutti che questa foto è cambiata
FotoModificateMsg msg = new FotoModificateMsg(this, fotografia);
pubblicaMessaggio(msg);
}
}
public void addLogo(Fotografia fotografia, Logo logo, bool salvare)
{
if (logo == null)
{
// Rimuovo il logo dalle correzioni
// Deserializzo la stringa con le eventuali correzioni attuali
if (fotografia.correzioniXml != null)
{
CorrezioniList correzioni = SerializzaUtil.stringToObject <CorrezioniList>(fotografia.correzioniXml);
foreach (Correzione c in correzioni)
{
if (c is Logo)
{
correzioni.Remove(c);
break;
}
}
// Ora serializzo di nuovo
fotografia.correzioniXml = SerializzaUtil.objectToString(correzioni);
}
}
else
{
// Siccome ho reso il logo sommabile, questa operazione in realtà non aggiunge ma sostituisce.
addCorrezione(fotografia, logo, salvare);
}
// Ricalcolo il provino giusto per poterlo visualizzare
AiutanteFoto.creaProvinoFoto(fotografia);
}
public void creaProvinoANastro()
{
Fotografia f = cercaUnaFotoQuasiasi();
for (int ii = 0; ii < 100; ii++)
{
AiutanteFoto.creaProvinoFoto(f);
}
}
public void removeCorrezione(Fotografia foto, Type quale)
{
// Se non ho correzioni è impossibile che ne voglio rimuovere una
if (foto.correzioniXml == null)
{
return;
}
// Deserializzo la stringa con le eventuali correzioni attuali
CorrezioniList correzioni = SerializzaUtil.stringToObject <CorrezioniList>(foto.correzioniXml);
bool rimossa = false;
foreach (Correzione cor in correzioni)
{
if (cor.GetType().Equals(quale))
{
correzioni.Remove(cor);
rimossa = true;
break;
}
}
if (!rimossa)
{
return;
}
// Ora serializzo di nuovo in stringa tutte le correzioni
if (correzioni.Count > 0)
{
foto.correzioniXml = SerializzaUtil.objectToString(correzioni);
}
else
{
foto.correzioniXml = null;
}
AiutanteFoto.creaProvinoFoto(foto);
}
/// <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);
}
/// <summary>
/// Aggiungo una correzione a quelle già eventualmente presenti sulla foto.
/// Se la correzione esiste già, gestisco eventuale somma, oppure rimozione in caso che sia inutile (ininfluente)
/// </summary>
/// <param name="fotografia">la foto</param>
/// <param name="correzione">la correzione da aggiungere</param>
public void addCorrezione(Fotografia fotografia, Correzione correzioneNuova, bool salvare)
{
CorrezioniList correzioni;
// Deserializzo la stringa con le eventuali correzioni attuali
if (fotografia.correzioniXml == null)
{
correzioni = new CorrezioniList();
}
else
{
correzioni = SerializzaUtil.stringToObject <CorrezioniList>(fotografia.correzioniXml);
}
// Alcune correzioni, non devono andare sempre in aggiunta, ma possono sommarsi l'un l'altra.
// Per esempio la rotazione. Se ruoto 90° poi altri 90, l'effetto finale è quello di avere una sola da 180°
Correzione daSost = null;
Correzione vecchia = null;
foreach (Correzione c in correzioni)
{
if (c.isSommabile(correzioneNuova))
{
vecchia = c;
daSost = c.somma(correzioneNuova);
break;
}
}
if (daSost != null)
{
// Sostituisco la correzione con quella ricalcolata
if (daSost.isInutile)
{
correzioni.Remove(vecchia);
}
else
{
correzioni.sostituire(vecchia, daSost);
}
}
else
{
// Aggiungo in fondo (se la correzione è inutile, allora non aggiungo nulla)
if (!correzioneNuova.isInutile)
{
correzioni.Add(correzioneNuova);
}
}
// Ora serializzo di nuovo in stringa tutte le correzioni
fotografia.correzioniXml = SerializzaUtil.objectToString(correzioni);
if (salvare)
{
fotografieRepositorySrv.saveChanges(); // Persisto nel db le modifiche
AiutanteFoto.creaProvinoFoto(fotografia);
// Devo informare tutti che questa foto è cambiata
FotoModificateMsg msg = new FotoModificateMsg(this, fotografia);
pubblicaMessaggio(msg);
}
}
public void clonaImmagineIncorniciata(Fotografia fotoOrig, string nomeFileImg)
{
FileInfo fileInfoSrc = new FileInfo(fotoOrig.nomeFile);
string nomeOrig = fileInfoSrc.Name;
string nomeFotoClone = ClonaImmaginiWorker.getNomeFileClone(fotoOrig);
string nomeFileDest = Path.Combine(Config.Configurazione.cartellaRepositoryFoto, Path.GetDirectoryName(fotoOrig.nomeFile), nomeFotoClone);
//Sposto la foto nella coartellaRepository e gli attribuisco il suo nome originale.
File.Move(nomeFileImg, nomeFileDest);
Fotografia fotoMsk = null;
using (new UnitOfWorkScope(false))
{
try
{
fotoMsk = new Fotografia();
fotoMsk.id = Guid.NewGuid();
fotoMsk.dataOraAcquisizione = fotoOrig.dataOraAcquisizione;
Fotografo f = fotoOrig.fotografo;
OrmUtil.forseAttacca <Fotografo>(ref f);
fotoMsk.fotografo = f;
if (fotoOrig.evento != null)
{
Evento e = fotoOrig.evento;
OrmUtil.forseAttacca <Evento>(ref e);
fotoMsk.evento = e;
}
fotoMsk.didascalia = fotoOrig.didascalia;
fotoMsk.numero = fotoOrig.numero;
// Le correzioni non devo duplicarle perché non sono tipiche della composizione finale, ma della foto originale.
fotoMsk.faseDelGiorno = fotoOrig.faseDelGiorno;
fotoMsk.giornata = fotoOrig.giornata;
// il nome del file, lo memorizzo solamente relativo
// scarto la parte iniziale di tutto il path togliendo il nome della cartella di base delle foto.
// Questo perché le stesse foto le devono vedere altri computer della rete che
// vedono il percorso condiviso in maniera differente.
fotoMsk.nomeFile = Path.Combine(Path.GetDirectoryName(fotoOrig.nomeFile), nomeFotoClone);
fotografieRepositorySrv.addNew(fotoMsk);
fotografieRepositorySrv.saveChanges();
}
catch (Exception ee)
{
_giornale.Error("Non riesco ad inserire una foto clonata. Nel db non c'è ma nel filesystem si: " + fotoOrig.nomeFile, ee);
}
AiutanteFoto.creaProvinoFoto(nomeFileDest, fotoMsk);
// Libero la memoria occupata dalle immagini, altrimenti esplode.
AiutanteFoto.disposeImmagini(fotoMsk, IdrataTarget.Tutte);
// Notifico la lista delle foto da mandare in modifica
NuovaFotoMsg msg = new NuovaFotoMsg(this, fotoMsk);
// msg.descrizione += Configurazione.ID_FOTOGRAFO_ARTISTA;
LumenApplication.Instance.bus.Publish(msg);
}
}
/// <summary>
/// Il parametro passato "tempoScarico" deve essere ribaltato su tutte le foto, perché
/// serve a creare una relazione implicita 1-n tra lo ScaricoCard e Fotografia
/// </summary>
/// <param name="tempoScarico"></param>
public void elabora(DateTime tempoScarico)
{
_giornale.Debug("Inizio ad elaborare le foto acquisite");
// carico il fotografo che rimane uguale per tutta questa sessione di elaborazione
LumenEntities objContext = UnitOfWorkScope.currentDbContext;
_fotografo = objContext.Fotografi.Single <Fotografo>(ff => ff.id == _paramScarica.flashCardConfig.idFotografo);
// carico l'evento che rimane uguale per tutta questa sessione di elaborazione
if (_paramScarica.flashCardConfig.idEvento != null && _paramScarica.flashCardConfig.idEvento != Guid.Empty)
{
_evento = objContext.Eventi.SingleOrDefault(e => e.id == _paramScarica.flashCardConfig.idEvento);
}
_giornale.Debug("Sto per lavorare le " + _listaFiles.Count + " foto appena acquisite di " + _fotografo.id);
int ultimoNumFoto = NumeratoreFotogrammi.incrementaNumeratoreFoto(_listaFiles.Count);
contaAggiunteDb = 0;
ScaricoFotoMsg scaricoFotoMsg = new ScaricoFotoMsg(this, "Notifica progresso");
scaricoFotoMsg.fase = FaseScaricoFoto.Provinatura;
scaricoFotoMsg.esitoScarico = new EsitoScarico();
scaricoFotoMsg.esitoScarico.totFotoScaricate = _listaFiles.Count;
scaricoFotoMsg.sorgente = _paramScarica.cartellaSorgente != null ? _paramScarica.cartellaSorgente : _paramScarica.nomeFileSingolo;
scaricoFotoMsg.showInStatusBar = false;
IList <Fotografia> fotoDaEsaminare = null;
if (_paramScarica.ricercaBarCode)
{
fotoDaEsaminare = new List <Fotografia>();
}
foreach (FileInfo fileInfo in _listaFiles)
{
// Eseguo una transazione per ogni foto, in questo modo sono sicuro che tutto quello che posso buttare dentro, ci va.
using (TransactionScope transaction = new TransactionScope()) {
try {
int proxNum = 1 + contaAggiunteDb + ultimoNumFoto;
Fotografia foto = aggiungiFoto(fileInfo, proxNum, tempoScarico);
//
// --- eventuale maschera automatica
if (_paramScarica.mascheraAuto != null)
{
// Uso la maschera nella sua dimensione naturale
Imaging.Correzioni.Mascheratura mascheraratura = new Imaging.Correzioni.Mascheratura {
nome = _paramScarica.mascheraAuto.nomeFile,
width = _paramScarica.mascheraAuto.imgOriginale.ww,
height = _paramScarica.mascheraAuto.imgOriginale.hh
};
fotoRitoccoSrv.addCorrezione(foto, mascheraratura, false);
}
// Mark the transaction as complete.
transaction.Complete();
// Incremento qui il contatore perché in caso di eccezione, voglio che non si incrementi
++contaAggiunteDb;
_giornale.Debug("Inizio Provinatura immagine " + fileInfo.FullName);
AiutanteFoto.creaProvinoFoto(fileInfo.FullName, foto);
_giornale.Debug("Fine Provinatura immagine ");
// Libero la memoria occupata dalle immagini, altrimenti esplode.
AiutanteFoto.disposeImmagini(foto, IdrataTarget.Tutte);
if (_paramScarica.ricercaBarCode)
{
fotoDaEsaminare.Add(foto);
}
// Se lavoro con una singola foto, allora lancio l'evento che mi dice che è pronta.
if (String.IsNullOrEmpty(_paramScarica.nomeFileSingolo) == false)
{
// Quando sono a posto con la foto, sollevo un evento per avvisare tutti
// Siccome questa operazione è un pò onerosa, per il momento la abilito
// soltanto sulla singola foto. Se ne scarico 1000 di foto, non voglio lanciare 1000 eventi!!!
NuovaFotoMsg msg = new NuovaFotoMsg(this, foto);
LumenApplication.Instance.bus.Publish(msg);
}
_giornale.Debug("ok nuova foto provinata e inserita nel db: " + foto);
if (contaAggiunteDb % 20 == 0)
{
scaricoFotoMsg.esitoScarico.totFotoProvinateProg = contaAggiunteDb;
LumenApplication.Instance.bus.Publish(scaricoFotoMsg);
}
} catch (Exception ee) {
transaction.Dispose();
_giornale.Error("Errore elaborazione foto. Viene ignorata " + fileInfo, ee);
}
}
}
if (_paramScarica.ricercaBarCode)
{
barCodeSrv.scan(fotoDaEsaminare);
}
if (contaAggiunteDb != 0)
{
scaricoFotoMsg.esitoScarico.totFotoProvinateProg = contaAggiunteDb;
scaricoFotoMsg.esitoScarico.totFotoProvinate = contaAggiunteDb;
LumenApplication.Instance.bus.Publish(scaricoFotoMsg);
}
_giornale.Info("Terminato di lavorare " + _listaFiles.Count + " foto appena acquisite");
incrementaTotaleFotoScaricate(tempoScarico);
}