public IImmagine applicaCorrezione(IImmagine immaginePartenza, Correzione correzione) { Correttore correttore = gestoreImmaginiSrv.getCorrettore(correzione); _giornale.Debug("applico correzione: " + correttore); return(correttore.applica(immaginePartenza, correzione)); }
public CorrezioniList converteInCorrezioni(IEnumerable <Object> effetti) { if (effetti == null) { return(null); } CorrezioniList correzioni = new CorrezioniList(); foreach (var effettoTrasformazione in effetti) { Correttore correttore = this.getCorrettore(effettoTrasformazione); if (correttore == null) { continue; } if (correttore.CanConvertFrom(effettoTrasformazione.GetType())) { correzioni.Add((Correzione)correttore.ConvertFrom(effettoTrasformazione)); } } return(correzioni); }
/// <summary> /// Prendo le correzioni xml di una foto, /// e le converto nei rispettivi "Effetti" e/o "Trasformazioni" /// </summary> /// <typeparam name="T">Può essere un ShaderEffect oppure un Transform</typeparam> /// <param name="fotografia"></param> /// <returns> /// Se ho delle correzioni, allora ritorno La lista degli oggetti trasformati. <br/> /// Se invece non ho correzioni, allora ritorno null. /// </returns> public IList <T> converteCorrezioni <T>(CorrezioniList correzioni) { if (correzioni == null) { return(null); } // ok ho qualcosa da fare. Istanzio la lista da ritornare IList <T> convertiti = new List <T>(); foreach (Correzione correzione in correzioni) { Correttore correttore = gestoreImmaginiSrv.getCorrettore(correzione); if (correttore.CanConvertTo(typeof(T))) { convertiti.Add((T)correttore.ConvertTo(correzione, typeof(T))); } else { // non do errore, perché è la prassi che venga chiamato questo metodo per estrarre soltanto i tipi gestiti // _giornale.Error( "Impossibile convertire " + typeof( T ) + " in una correzione" ); } } return(convertiti); }
public Correttore creaCorrettore(Type tipoCorrezione) { Correttore correttore = null; // In base al tipo di correzione, istanzio il giusto correttore if (tipoCorrezione.Equals(typeof(BiancoNeroCorrezione))) { correttore = new BiancoNeroCorrettore(); } return(correttore); }
public GestoreImmagineSrvImpl() { // Questa è la definizione per provinare. _correzioneProvino = new Resize { latoMax = Configurazione.infoFissa.pixelProvino }; _correttoreFactory = ImagingFactory.Instance.creaCorrettoreFactory(); // Questo è il provinatore. // TODO vedere se si può fare con un generics _provinatore = _correttoreFactory.creaCorrettore(typeof(Resize)); }
public IImmagine applicaCorrezioni(IImmagine immaginePartenza, ICollection <Correzione> correzioni) { CorrettoreFactory factory = new CorrettoreFactory(); IImmagine modificata = immaginePartenza; foreach (Correzione correzione in correzioni) { Correttore correttore = factory.creaCorrettore(correzione.GetType()); modificata = correttore.applica(modificata, correzione); } return(modificata); }
public Correzione converteInCorrezione(TipoCorrezione tipoDest, Object trasformazione) { Correzione correzione = null; if (trasformazione != null) { Correttore correttore = gestoreImmaginiSrv.getCorrettore(tipoDest); if (correttore != null) { if (correttore.CanConvertFrom(trasformazione.GetType())) { correzione = (Correzione)correttore.ConvertFrom(trasformazione); } } } return(correzione); }
public Correttore creaCorrettore(Type tipo) { Correttore correttore = null; // Prima controllo in cache if (_cache.ContainsKey(tipo)) { correttore = _cache[tipo]; } else { // In base al tipo di correzione, istanzio il giusto correttore // In base al tipo di correzione, istanzio il giusto correttore if (tipo == typeof(BiancoNero)) { correttore = new BiancoNeroCorrettore(); } else if (tipo == typeof(Resize)) { correttore = new ResizeCorrettore(); } else if (tipo == typeof(Sepia)) { correttore = new SepiaCorrettore(); } else if (tipo == typeof(OldMovie)) { correttore = new OldMovieCorrettore(); } else if (tipo == typeof(Ruota)) { correttore = new RuotaCorrettore(); } else if (tipo == typeof(Specchio)) { correttore = new SpecchioCorrettore(); } else if (tipo == typeof(Luce)) { correttore = new LuminositaContrastoCorrettore(); } else if (tipo == typeof(Crop)) { correttore = new CropCorrettore(); } else if (tipo == typeof(Gimp)) { correttore = new GimpCorrettore(); } else if (tipo == typeof(Dominante)) { correttore = new DominantiCorrettore(); } else if (tipo == typeof(Zoom)) { correttore = new ZoomCorrettore(); } else if (tipo == typeof(Trasla)) { correttore = new TraslaCorrettore(); } else if (tipo == typeof(Mascheratura)) { correttore = new MascheraturaCorrettore(); } else if (tipo == typeof(MascheraturaOrientabile)) { correttore = new MascheraturaCorrettore(); } else if (tipo == typeof(Logo)) { correttore = new LogoCorrettore(); } else if (tipo == typeof(AreaRispetto)) { correttore = new AreaRispettoCorrettore(); } else if (tipo == typeof(Scritta)) { correttore = new ScrittaCorrettore(); } if (correttore != null) { _cache.Add(tipo, correttore); // Metto in cache } else { throw new NotSupportedException("tipo correzione = " + tipo); } } return(correttore); }
/// <summary> /// Devo gestire le correzioni complicate /// </summary> /// <param name="immaginePartenza"></param> /// <param name="correzioni"></param> /// <returns></returns> private IImmagine rigeneraImmagineConCorrezioniComplicate(IImmagine immaginePartenza, CorrezioniList correzioni, IdrataTarget qualeTarget) { double wwDest = 0, hhDest = 0; BitmapSource bmpFoto = null; // Questa è la foto BitmapSource bmpMaschera = null; // Questa è la maschera (eventuale) bmpFoto = ((ImmagineWic)immaginePartenza).bitmapSource; // ::: Per prima cosa calcolo la dimensione che deve avere l'immagine di uscita (il canvas) // Verifico quindi se c'è una maschera. In tal caso comanda lei Imaging.Correzioni.Mascheratura mascheratura = (Imaging.Correzioni.Mascheratura)correzioni.FirstOrDefault(c => c is Imaging.Correzioni.Mascheratura); // La mascheratura potrebbe essere anche indicata come orientabile if (mascheratura == null) { Imaging.Correzioni.MascheraturaOrientabile mascheraturaOrientabile = (Imaging.Correzioni.MascheraturaOrientabile)correzioni.FirstOrDefault(c => c is Imaging.Correzioni.MascheraturaOrientabile); if (mascheraturaOrientabile != null) { // Ora estraggo la mascheratura giusta per questa foto if (immaginePartenza.orientamento == Orientamento.Verticale) { mascheratura = mascheraturaOrientabile.mascheraturaV; } if (immaginePartenza.orientamento == Orientamento.Orizzontale) { mascheratura = mascheraturaOrientabile.mascheraturaH; } } } // // Ora che ho scoperto se esiste una mascheratura, la applico // if (mascheratura != null) { ImmagineWic immagineMaschera = new ImmagineWic(Path.Combine(getCartellaMaschera(FiltroMask.MskSingole), mascheratura.nome)); bmpMaschera = immagineMaschera.bitmapSource; // Carico la maschera per avere le dimensioni reali definitive if (qualeTarget == IdrataTarget.Provino) { IImmagine imgMascheraPiccola = gestoreImmaginiSrv.creaProvino(immagineMaschera); bmpMaschera = ((ImmagineWic)imgMascheraPiccola).bitmapSource; } wwDest = bmpMaschera.PixelWidth; hhDest = bmpMaschera.PixelHeight; } else { // Cerco di intercettare un eventuale rotazione del quadro (non della foto) Zoom zzz = (Zoom)correzioni.FirstOrDefault(c => c is Zoom); bool rovesciare = zzz != null ? zzz.quadroRuotato : false; if (rovesciare) { wwDest = bmpFoto.PixelHeight; hhDest = bmpFoto.PixelWidth; } else { wwDest = bmpFoto.PixelWidth; hhDest = bmpFoto.PixelHeight; } } // ::: Il canvas Canvas canvas = new Canvas(); canvas.Background = new SolidColorBrush(Colors.White); canvas.Width = wwDest; canvas.Height = hhDest; canvas.HorizontalAlignment = HorizontalAlignment.Left; canvas.VerticalAlignment = VerticalAlignment.Top; #region Correzioni // ::: Gestisco le correzioni TransformGroup traGroup = new TransformGroup(); IList <ShaderEffect> effetti = null; // bool quadroRuotato = false; foreach (Correzione correzione in correzioni) { Correttore correttore = gestoreImmaginiSrv.getCorrettore(correzione); if (correttore.CanConvertTo(typeof(Transform))) { // ::: Trasformazioni Transform trasformazione = (Transform)correttore.ConvertTo(correzione, typeof(Transform)); // La trasformazione di spostamento, (Trasla) fa una eccezione perché dipende dalla grandezza del target. // Devo sistemarla al volo if (trasformazione is TranslateTransform) { TranslateTransform tt = (TranslateTransform)trasformazione; // TODO riproporzionare TranslateTransform tt2 = new TranslateTransform(); // Devo riproporzionare X e Y alla dimensione giusta finale. // posx:300=x:finalW -> x = posx * finalW / 300 tt2.X = ((TranslateTransform)tt).X * canvas.Width / ((Trasla)correzione).rifW; tt2.Y = ((TranslateTransform)tt).Y * canvas.Height / ((Trasla)correzione).rifH; traGroup.Children.Add(tt2); } else { traGroup.Children.Add(trasformazione); } } else if (correttore.CanConvertTo(typeof(ShaderEffectBase))) { // ::: Effetti li sommo poi li faccio tutti in una volta per essere più veloce if (effetti == null) { effetti = new List <ShaderEffect>(); } effetti.Add((ShaderEffect)correttore.ConvertTo(correzione, typeof(ShaderEffectBase))); } } #endregion Correzioni if (effetti != null && effetti.Count > 0) { bmpFoto = EffectsUtil.RenderImageWithEffectsToBitmap(bmpFoto, effetti); } // ::: La foto Image fotona = new Image(); fotona.BeginInit(); fotona.Source = bmpFoto; // bmpFoto; fotona.Stretch = Stretch.Uniform; fotona.HorizontalAlignment = HorizontalAlignment.Center; fotona.VerticalAlignment = VerticalAlignment.Center; fotona.Width = wwDest; fotona.Height = hhDest; fotona.EndInit(); // Assegno tutte le trasformazioni if (traGroup != null && traGroup.Children.Count > 0) { fotona.RenderTransform = traGroup; fotona.RenderTransformOrigin = new Point(0.5, 0.5); // centrate } canvas.Children.Add(fotona); // ::: La Maschera - per concludere, aggiungo anche la maschera che deve ricoprire tutto. Image imageMaschera; if (bmpMaschera != null) { imageMaschera = new Image(); imageMaschera.BeginInit(); imageMaschera.Stretch = Stretch.Uniform; imageMaschera.HorizontalAlignment = HorizontalAlignment.Left; imageMaschera.VerticalAlignment = VerticalAlignment.Top; imageMaschera.Source = bmpMaschera; imageMaschera.Width = wwDest; imageMaschera.Height = hhDest; imageMaschera.EndInit(); canvas.Children.Add(imageMaschera); } // Devo "Arrangiare" il canvas altrimenti non ha dimensione (e la foto viene nera) var size = new Size(wwDest, hhDest); canvas.Measure(size); canvas.Arrange(new Rect(size)); IImmagine immagineMod = null; // Creo la bitmap di ritorno RenderTargetBitmap rtb = new RenderTargetBitmap((int)canvas.Width, (int)canvas.Height, 96d, 96d, PixelFormats.Pbgra32); rtb.Render(canvas); if (rtb.CanFreeze) { rtb.Freeze(); } immagineMod = new ImmagineWic(rtb); // Come penultima cosa, mi rimane da gestire le Scritte (in realtà una sola) foreach (var scritta in correzioni.OfType <Scritta>()) { Correttore correttore = gestoreImmaginiSrv.getCorrettore(scritta); immagineMod = correttore.applica(immagineMod, scritta); } // Per ultima cosa, mi rimane fuori un evenuale logo ... Logo correzioneLogo = (Logo)correzioni.FirstOrDefault(c => c is Logo); if (correzioneLogo != null) { Correttore correttore = gestoreImmaginiSrv.getCorrettore(correzioneLogo); immagineMod = correttore.applica(immagineMod, correzioneLogo); } // Questa forzatura anche se filosoficamente non è bella, ma mi serve per essere più veloce a creare le correzioni complesse sulla foto da stampare. // .. oppure una eventuale area di rispetto (solo sul provino) if (qualeTarget == IdrataTarget.Provino) { AreaRispetto correzioneAreaRispetto = (AreaRispetto)correzioni.FirstOrDefault(c => c is AreaRispetto); if (correzioneAreaRispetto != null) { Correttore correttore = gestoreImmaginiSrv.getCorrettore(correzioneAreaRispetto); immagineMod = correttore.applica(immagineMod, correzioneAreaRispetto); } } return(immagineMod); }