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);
}
/// <summary>
/// Creo il Provino, e/o la Risultante di una foto e scrivo l'immagine su disco nel file indicato
/// </summary>
/// <param name="nomeFileSorgente">E' il nome del file della foto vera, grande</param>
/// <param name="foto"></param>
private static void creaCacheFotoSuDisco(Fotografia foto, IdrataTarget quale, string nomeFileOriginale)
{
_giornale.Debug("Creo provino foto n." + foto.numero + " target=" + quale);
Debug.Assert(quale == IdrataTarget.Provino || quale == IdrataTarget.Risultante);
IGestoreImmagineSrv gis = LumenApplication.Instance.getServizioAvviato <IGestoreImmagineSrv>();
IFotoRitoccoSrv fr = LumenApplication.Instance.getServizioAvviato <IFotoRitoccoSrv>();
// Carico l'immagine grande originale (solo la prima volta)
bool caricataOrig = false;
if (foto.imgOrig == null)
{
_giornale.Debug("carico immagine originale da disco: " + nomeFileOriginale);
foto.imgOrig = gis.load(nomeFileOriginale);
caricataOrig = true;
}
// carico eventuali correzioni
CorrezioniList correzioni = null;
if (foto.correzioniXml != null)
{
try {
correzioni = SerializzaUtil.stringToObject <CorrezioniList>(foto.correzioniXml);
} catch (Exception ee) {
// Se ci fossero inciampi con le correzioni, preferisco perderle che far saltare tutto.
// Non dovrebbe mai capitare.
_giornale.Error("Deserializza correzioni foto = " + foto.id, ee);
}
}
// Se devo crere il provino ma la foto contiene la correzione di Zoom,
// devo passare dalla foto grande, altrimenti perde di qualità
bool devoPassareDallaGrande = false;
if (quale == IdrataTarget.Risultante)
{
devoPassareDallaGrande = true;
}
if (correzioni != null && correzioni.Contains(typeof(Zoom)))
{
devoPassareDallaGrande = true;
}
// Se richiesto nella configurazione, scrivo direttamente sul provino le righe tratteggiate di rispetto area stampabile
bool aggiungiCorrezioneAreaRispetto = false;
if (Configurazione.UserConfigLumen.imprimereAreaDiRispetto)
{
if (quale == IdrataTarget.Provino)
{
if (correzioni == null)
{
correzioni = new CorrezioniList();
}
if (!correzioni.Contains(typeof(AreaRispetto)))
{
aggiungiCorrezioneAreaRispetto = true;
}
}
}
// Cancello il file Risultante da disco perchè tanto sta per cambiare.
IImmagine immagineDestinazione = null;
foto.imgRisultante = null;
string nomeFileRisultante = PathUtil.nomeCompletoFile(foto, IdrataTarget.Risultante);
if (File.Exists(nomeFileRisultante))
{
File.Delete(nomeFileRisultante);
}
// Eventuale creazione delle cartelle di destinazione (potrebbero non esistere)
PathUtil.creaCartellaProvini(foto);
PathUtil.creaCartellaRisultanti(foto);
// OK partiamo!
if (devoPassareDallaGrande)
{
immagineDestinazione = (IImmagine)foto.imgOrig.Clone(); // creo un duplicato della Originale per poi lavorarci
}
else
{
immagineDestinazione = gis.creaProvino(foto.imgOrig); // creo una immagine più piccola
}
// applico eventuali correzioni
if (correzioni != null)
{
IdrataTarget tempQuale = quale;
if (devoPassareDallaGrande && quale == IdrataTarget.Provino)
{
tempQuale = IdrataTarget.Risultante;
}
if (aggiungiCorrezioneAreaRispetto && tempQuale == IdrataTarget.Provino)
{
correzioni.Add(areaRispetto);
}
immagineDestinazione = fr.applicaCorrezioni(immagineDestinazione, correzioni, tempQuale);
// NO : non funziona sempre bene.
// Se sto facendo un provino che prevede lo zoom, devo passare dalla immagine grande,
// quindi sono obbligato a ricalcolare la Risultante e quindi rimpicciolirla.
// quindi per essere efficiente, salvo la Risultante che ho già pronta (cosi risparmio tempo dopo)
if (devoPassareDallaGrande && quale == IdrataTarget.Provino)
{
gis.save(immagineDestinazione, nomeFileRisultante);
foto.imgRisultante = immagineDestinazione;
// Poi la ritaglio per fare il provino buono.
immagineDestinazione = gis.creaProvino(immagineDestinazione);
// Aggiungo l'area di rispetto al provino
if (aggiungiCorrezioneAreaRispetto)
{
immagineDestinazione = fr.applicaCorrezione(immagineDestinazione, areaRispetto);
}
}
}
// Salvo su disco l'immagine di destinazione
string nomeFileDest = PathUtil.nomeCompletoFile(foto, quale);
gis.save(immagineDestinazione, nomeFileDest);
_giornale.Debug("Ho ricreato il file immagine di cache: " + nomeFileDest);
// Eventualmente chiudo l'immagine grande se l'avevo aperta io.
// Il provino, invece lo lascio aperto (non so se mi causerà problemi di memoria)
if (caricataOrig)
{
AiutanteFoto.disposeImmagini(foto, IdrataTarget.Originale);
}
// Modifico la foto che mi è stata passata.
if (quale == IdrataTarget.Provino)
{
foto.imgProvino = immagineDestinazione;
}
if (quale == IdrataTarget.Risultante)
{
foto.imgRisultante = immagineDestinazione;
}
}