/**
* Data una foto recupero il percorso della foto che sara venduta.
*/
public static string nomeCompletoVendita(Fotografia foto)
{
// Ho delle correzioni che non sono ancora state applicate. Lo faccio adesso.
if (AiutanteFoto.esisteFileRisultante(foto))
{
return(nomeCompletoRisultante(foto));
}
else
{
return(nomeCompletoOrig(foto));
}
}
/// <summary>
/// Voglio ricavare l'immagine grande.
/// Se la foto in esame possiede una immagine grande risultante (quindi modificata) prendo quella.
/// Se invece non esiste l'immagine modificata, prendo quella grande originale.
/// L'immagine in questione viene anche idratata
/// </summary>
/// <param name="foto"></param>
/// <returns></returns>
public static IImmagine idrataImmagineGrande(Fotografia foto)
{
IImmagine immagine = null;
if (esisteFileRisultante(foto))
{
AiutanteFoto.idrataImmaginiFoto(foto, IdrataTarget.Risultante);
immagine = foto.imgRisultante;
}
// Se non l'ho trovata, prendo l'immagine grande originale
if (immagine == null)
{
AiutanteFoto.idrataImmaginiFoto(foto, IdrataTarget.Originale);
immagine = foto.imgOrig;
}
return(immagine);
}
/// <summary>
/// Devo stampare la foto.
/// Quindi mi serve indietro una immagine grande, che può essere l'originale, oppure quella modificata.
/// L'immagine modificata, però potrebbe ancora non essere stata calcolata. In tal caso ci penso io.
///
/// </summary>
/// <param name="foto"></param>
/// <returns>il nome del file interessato su disco</returns>
public static string idrataImmagineDaStampare(Fotografia foto)
{
IdrataTarget quale = qualeImmagineDaStampare(foto);
// Ho delle correzioni che non sono ancora state applicate. Lo faccio adesso.
if (foto.imgRisultante == null && foto.correzioniXml != null)
{
// Se il file esiste già su disco, allora uso quello.
if (!File.Exists(PathUtil.nomeCompletoRisultante(foto)))
{
creaRisultanteFoto(foto);
}
}
var nome = AiutanteFoto.idrataImmaginiFoto(foto, quale, true);
return(nome);
}
/// <summary>
/// Imposta una immagine per il fotografo (con la sua faccia)
/// </summary>
/// <param name="nomeFileImmagine">path completo. Se nullo, elimino la foto attuale</param>
/// <param name="fotografo">il fotografo da ritrarre</param>
public static void setImmagineFotografo(string nomeFileImmagine, Fotografo fotografo)
{
string nomeFileDest = AiutanteFoto.nomeFileImgFotografo(fotografo);
if (nomeFileImmagine != null)
{
DirectoryInfo dInfo = new DirectoryInfo(nomeFileDest).Parent;
if (!dInfo.Exists)
{
Directory.CreateDirectory(dInfo.FullName);
}
if (File.Exists(nomeFileDest))
{
// Potrebbe avere il flag di readonly
// Elimino gli attributi solo lettura
File.SetAttributes(nomeFileDest, File.GetAttributes(nomeFileDest) & ~(FileAttributes.ReadOnly));
}
// copio con sovrascrittura
File.Copy(nomeFileImmagine, nomeFileDest, true);
// Potrebbe avere il flag di readonly
// Elimino gli attributi solo lettura
File.SetAttributes(nomeFileDest, File.GetAttributes(nomeFileDest) & ~(FileAttributes.ReadOnly) | FileAttributes.Archive);
string msg = string.Format("Impostata immagine fotografo: {0} immagine: {1}", fotografo.cognomeNome, nomeFileImmagine);
_giornale.Info(msg);
}
else
{
if (File.Exists(nomeFileDest))
{
File.Delete(nomeFileDest);
_giornale.Info("Eliminata immagine per il fotografo " + fotografo.cognomeNome);
}
}
}
public static void setImmagineFotografo(Fotografia fotografia, Fotografo fotografo)
{
string nomeFile = AiutanteFoto.idrataImmagineDaStampare(fotografia);
setImmagineFotografo(nomeFile, fotografo);
}
/// <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;
}
}