public IImmagine applicaCorrezione(IImmagine immaginePartenza, Correzione correzione)
{
Correttore correttore = gestoreImmaginiSrv.getCorrettore(correzione);
_giornale.Debug("applico correzione: " + correttore);
return(correttore.applica(immaginePartenza, correzione));
}
public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
{
// Non spostare da qui questo vettore. Deve essere istanziato ogni volta, altrimenti romper il cavolo con i thread diversi
ShaderEffect [] localEffetcs = new ShaderEffect[] { new GrayscaleEffect() };
ImmagineWic iw = (ImmagineWic)immagineSorgente;
BitmapSource modificata = EffectsUtil.RenderImageWithEffectsToBitmap(iw.bitmapSource, localEffetcs);
return(new ImmagineWic(modificata));
}
public override Correzione somma(Correzione altra)
{
Dominante dAltra = altra as Dominante;
Dominante ris = new Dominante {
rosso = this.rosso + dAltra.rosso,
verde = this.verde + dAltra.verde,
blu = this.blu + dAltra.blu
};
return(ris);
}
public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
{
// Purtroppo devo creare un array con un solo elemento. TODO migliorare
ShaderEffect lce = (ShaderEffect)ConvertTo(correzione, typeof(ShaderEffect));
ShaderEffect [] _effetti = new ShaderEffect [] { lce };
ImmagineWic iw = (ImmagineWic)immagineSorgente;
BitmapSource modificata = EffectsUtil.RenderImageWithEffectsToBitmap(iw.bitmapSource, _effetti);
return(new ImmagineWic(modificata));
}
public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
{
BitmapSource bitmapSource = ((ImmagineWic)immagineSorgente).bitmapSource;
Crop cropCorrezione = (Crop)correzione;
Int32Rect rect = calcolaRettangolo(cropCorrezione, bitmapSource.PixelWidth, bitmapSource.PixelHeight);
var croppedImage = new CroppedBitmap(bitmapSource, rect);
BitmapSource newBitmap = (BitmapSource)croppedImage;
return(new ImmagineWic(newBitmap));
}
public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
{
ImmagineWic imgSorgente = (ImmagineWic)immagineSorgente;
BitmapSource bitmapSource = imgSorgente.bitmapSource;
ScaleTransform scaleTransform = new ScaleTransform();
scaleTransform.ScaleX = -1;
// Create the TransformedBitmap to use as the Image source.
TransformedBitmap tb = new TransformedBitmap(bitmapSource, scaleTransform);
ImmagineWic modificata = new ImmagineWic(tb);
return(modificata);
}
public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
{
// Purtroppo devo creare un array con un solo elemento. TODO migliorare
DominantiEffect de = new DominantiEffect();
de.Red = ((Dominante)correzione).rosso;
de.Green = ((Dominante)correzione).verde;
de.Blue = ((Dominante)correzione).blu;
ShaderEffect [] _effetti = new ShaderEffect [] { de };
ImmagineWic iw = (ImmagineWic)immagineSorgente;
BitmapSource modificata = EffectsUtil.RenderImageWithEffectsToBitmap(iw.bitmapSource, _effetti);
return(new ImmagineWic(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 override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
{
BitmapSource bmpsource = ((ImmagineWic)immagineSorgente).bitmapSource;
Ruota ruotaCorrezione = (Ruota)correzione;
BitmapSource newBmp;
if (ruotaCorrezione.isAngoloRetto)
{
newBmp = rotazioneSemplice(bmpsource, ruotaCorrezione.gradi);
}
else
{
newBmp = rotazioneSulPosto(bmpsource, ruotaCorrezione.gradi);
}
// newBmp = rotazioneComplessa( bmpsource, ruotaCorrezione.gradi );
return(new ImmagineWic(newBmp));
}
public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
{
Image imageSorgente = ((ImmagineNet)immagineSorgente).image;
ImageAttributes ia = new ImageAttributes();
ia.SetColorMatrix(_colorMatrix);
Image imageDest = new Bitmap(imageSorgente.Width, imageSorgente.Height);
using (Graphics g = Graphics.FromImage(imageDest)) {
// Definisco l'area di destinazione (è uguale a quella sorgente)
Rectangle rr = new Rectangle(0, 0, imageSorgente.Width, imageSorgente.Height);
g.DrawImage(imageSorgente, rr,
0, 0, imageSorgente.Width, imageSorgente.Height,
GraphicsUnit.Pixel, ia);
}
return(new ImmagineNet(imageDest));
}
public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
{
throw new NotImplementedException("occorre un container per traslare");
// TODO da capire.
// Concettualmente non ha senso traslare una immagine su se stessa.
// Occorre avere un riferimento, un contenitore esterno su cui agire.
// Una immagine con appiccicata una traslazione ha senso, ma l'immagine risultante da sola che senso ha ?
#if CONCETTUALMENTE_NON_VALIDO
ImmagineWic imgSorgente = (ImmagineWic)immagineSorgente;
BitmapSource bitmapSource = imgSorgente.bitmapSource;
TranslateTransform tt = (TranslateTransform)this.ConvertTo(correzione, typeof(TranslateTransform));
// Create the TransformedBitmap to use as the Image source.
TransformedBitmap tb = new TransformedBitmap(bitmapSource, tt);
ImmagineWic modificata = new ImmagineWic(tb);
return(modificata);
#endif
}
/// <summary>
/// Aggiungo una correzione ad una lista di correzione.
/// Se la correzione esiste già, gestisco eventuale somma, oppure rimozione in caso che sia inutile (ininfluente)
/// </summary>
/// <param name="correzioni"></param>
/// <param name="correzioneNuova"></param>
public void addCorrezione(ref CorrezioniList correzioni, Correzione correzioneNuova)
{
// 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);
}
}
}
public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
{
_giornale.Debug("Richiesta correzione: " + correzione.GetType().Name);
long calcW, calcH;
Resize resizeCorrezione = (Resize)correzione;
ResizeCorrettore.calcolaEsattaWeH(immagineSorgente, resizeCorrezione.latoMax, out calcW, out calcH);
BitmapSource bitmapSource = ((ImmagineWic)immagineSorgente).bitmapSource;
/* I dpi sono una indicazione per la stampa.
* Non impattano sui dati dell'immagine.
* Non impattano sulla dimensione dell'immagine.
* Non impattano sulla qualità dell'immagine.
* In pratica è solo un "consiglio" per la stampa.
*
* Siccome credo che le stampanti termiche/sublimazione se ne fregano di questo parametro (per ovvi motivi)
* allora me ne sbatto.
* Occorrebbe fare una prova con una laser o con una InkJet per vedere se il risultato stampato cambia.
*
* int quantiDpi;
* quantiDpi = (int) Math.Max( bitmapSource.DpiX, bitmapSource.DpiY );
* quantiDpi = (int) Math.Max( quantiDpi, DPI_PROVINO );
*/
BitmapSource bitmapFrame = Resize(bitmapSource, calcW, calcH, DPI_PROVINO);
// _giornale.Debug( "effettuato resize" );
if (bitmapFrame.CanFreeze)
{
bitmapFrame.Freeze();
}
ImmagineWic immagine = new ImmagineWic(bitmapFrame);
return(immagine);
}
public override bool isSommabile(Correzione altra)
{
return(altra is Dominante);
}
public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
{
Logo logoCorrezione = (Logo)correzione;
// Questo è il nome del file completo su disco della immagine del logo
string nomeCompletoLogo = PathUtil.nomeCompletoLogo(logoCorrezione);
if (!File.Exists(nomeCompletoLogo))
{
throw new FileNotFoundException(nomeCompletoLogo);
}
// Costruisco l'immagine di overlay
ImmagineWic imgLogo = new ImmagineWic(nomeCompletoLogo);
// Ricavo la bitmap sorgente
BitmapSource bmpSorgente = ((ImmagineWic)immagineSorgente).bitmapSource;
// -- inizio ad applicare le trasformazioni al logo
IImmagine immagineLogoModificato = imgLogo;
//
// :: rotazione
//
if (logoCorrezione.rotazione != null)
{
RuotaCorrettore ruotaCorrettore = new RuotaCorrettore();
immagineLogoModificato = ruotaCorrettore.applica(immagineLogoModificato, logoCorrezione.rotazione);
}
//
// :: zoom
//
if (logoCorrezione.zoom != null)
{
ZoomCorrettore zoomCorrettore = new ZoomCorrettore();
immagineLogoModificato = zoomCorrettore.applica(immagineLogoModificato, logoCorrezione.zoom);
}
BitmapSource bitmapSourceLogoModificato = ((ImmagineWic)immagineLogoModificato).bitmapSource;
//
// :: traslazione
//
// Queste sono le coordinate su cui disegnare il logo
Rect posiz = calcolaCoordinateLogo(bmpSorgente.PixelWidth, bmpSorgente.PixelHeight, immagineLogoModificato.ww, immagineLogoModificato.hh, logoCorrezione);
// Creo due immagini disegnabili con i rettangoli delle immagini interessate
// 1. Tutta la foto di sfondo
Rect rectSotto = new Rect(0, 0, bmpSorgente.PixelWidth, bmpSorgente.PixelHeight);
ImageDrawing drawingSotto = new ImageDrawing(bmpSorgente, rectSotto);
// 2. Il riquando ricalcolato del logo
Rect rectSopra = new Rect(posiz.Left, posiz.Top, posiz.Width, posiz.Height);
ImageDrawing drawingSopra = new ImageDrawing(bitmapSourceLogoModificato, rectSopra);
// Adesso ho entrambe le immagini. Le sovrappongo usando un gruppo.
DrawingGroup myDrawingGroup = new DrawingGroup();
myDrawingGroup.Children.Add(drawingSotto);
myDrawingGroup.Children.Add(drawingSopra);
// Disegno il gruppo in una nuova immagine.
Image myImage = new Image();
myImage.Source = new DrawingImage(myDrawingGroup);
int w = (int)rectSotto.Width;
int h = (int)rectSotto.Height;
// Renderizzo l'immagine finita, in una bitmap in modo da poterla ritornare.
RenderTargetBitmap rtb = new RenderTargetBitmap(w, h, 96d, 96d, PixelFormats.Default);
DrawingVisual dv = new DrawingVisual();
using (DrawingContext ctx = dv.RenderOpen()) {
ctx.DrawDrawing(myDrawingGroup);
}
rtb.Render(dv);
return(new ImmagineWic(rtb));
}
public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
{
throw new NotImplementedException();
}
public override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
{
// Ricavo la bitmap sorgente
BitmapSource bmpSorgente = ((ImmagineWic)immagineSorgente).bitmapSource;
AreaRispetto areaRispetto = (AreaRispetto)correzione;
CalcolatoreAreeRispetto.Geo imageGeo = new CalcolatoreAreeRispetto.Geo();
// Calcolo la fascia A
imageGeo.w = immagineSorgente.ww;
imageGeo.h = immagineSorgente.hh;
Rect rettangoloA = CalcolatoreAreeRispetto.calcolaDimensioni(CalcolatoreAreeRispetto.Fascia.FasciaA, areaRispetto.ratio, imageGeo);
CalcolatoreAreeRispetto.Bordi bordiA = CalcolatoreAreeRispetto.calcolcaLatiBordo(CalcolatoreAreeRispetto.Fascia.FasciaA, areaRispetto.ratio, imageGeo, imageGeo);
// Calcolo la fascia B
imageGeo.w = immagineSorgente.ww;
imageGeo.h = immagineSorgente.hh;
Rect rettangoloB = CalcolatoreAreeRispetto.calcolaDimensioni(CalcolatoreAreeRispetto.Fascia.FasciaB, areaRispetto.ratio, imageGeo);
CalcolatoreAreeRispetto.Bordi bordiB = CalcolatoreAreeRispetto.calcolcaLatiBordo(CalcolatoreAreeRispetto.Fascia.FasciaB, areaRispetto.ratio, imageGeo, imageGeo);
BitmapSource bmpFinale = null;
if (areaRispetto.costringi)
{
int w = 0, h = 0;
// Devo fare un resize che preservi il canale alpha (ovviamente l'immagine potrà risultare distorta, perché non devo preservare le proporzioni
if (bordiA.right || bordiA.left || bordiB.right || bordiB.left)
{
// Taglio verticale: la foto è orizzontale
w = immagineSorgente.ww - (int)rettangoloA.Width - (int)rettangoloB.Width;
h = immagineSorgente.hh;
}
if (bordiA.top || bordiA.bottom || bordiB.top || bordiB.bottom)
{
// Tagli orizzontali: la foto è verticale
h = immagineSorgente.hh - (int)rettangoloA.Height - (int)rettangoloB.Height;
w = immagineSorgente.ww;
}
bmpFinale = ResizeCorrettore.Resize(bmpSorgente, w, h, (int)bmpSorgente.DpiX);
}
else
{
// Create a DrawingVisual/Context to render with
DrawingVisual drawingVisual = new DrawingVisual();
Rect rect = new Rect(0, 0, immagineSorgente.ww, immagineSorgente.hh);
RenderTargetBitmap renderTargetBitmap = null;
Pen pennaRossa = new Pen(Brushes.Red, 2);
pennaRossa.DashStyle = DashStyles.Dash; // tratteggio
using (DrawingContext drawingContext = drawingVisual.RenderOpen()) {
drawingContext.DrawImage(bmpSorgente, rect);
// Prima linea di rispetto : calcolo i due punti
Point p1, p2, p3, p4;
calcolaPunti(bordiA, rettangoloA, out p1, out p2);
calcolaPunti(bordiB, rettangoloB, out p3, out p4);
// Disegno le due linee di rispetto
drawingContext.DrawLine(pennaRossa, p1, p2);
drawingContext.DrawLine(pennaRossa, p3, p4);
}
renderTargetBitmap = new RenderTargetBitmap((int)rect.Width, (int)rect.Height, 96, 96, PixelFormats.Default);
renderTargetBitmap.Render(drawingVisual);
bmpFinale = renderTargetBitmap;
}
if (bmpFinale.CanFreeze)
{
bmpFinale.Freeze();
}
return(new ImmagineWic(bmpFinale));
}
public Correttore getCorrettore(Correzione correzione)
{
// Se non ce l'ho in cache, allora lo creo.
return(_correttoreFactory.creaCorrettore(correzione.GetType()));
}
public void addCorrezione(Fotografia fotografia, Correzione correzione)
{
addCorrezione(fotografia, correzione, false);
}
/// <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 override IImmagine applica(IImmagine immagineSorgente, Correzione correzione)
{
Scritta scritta = (Scritta)correzione;
// Ricavo la bitmap sorgente
BitmapSource bmpSorgente = ((ImmagineWic)immagineSorgente).bitmapSource;
var ww = bmpSorgente.PixelWidth;
var hh = bmpSorgente.PixelHeight;
// -- creo un contenitore che mi permette di avere il controllo completo del posizionamento
Panel contenitore = new Grid();
contenitore.Width = ww;
contenitore.Height = hh;
// contenitore.VerticalAlignment = VerticalAlignment.Center;
// contenitore.HorizontalAlignment = HorizontalAlignment.Center;
Image image = new Image();
image.BeginInit();
image.Source = bmpSorgente;
image.EndInit();
contenitore.Children.Add(image);
/*
* Rect rectContenitore = new Rect( 0, 0, scritta.rifContenitoreW, scritta.rifContenitoreH );
* Rect rectScrittaOrig = new Rect( scritta.left, scritta.top, scritta.width, scritta.height );
*
* Size nuovaSizeFoto = new Size( ww, hh );
*
* Rect newRect = Geometrie.proporziona( rectScrittaOrig, rectContenitore, nuovaSizeFoto );
*/
TextPath textPath = new TextPath();
textPath.Text = scritta.testo;
textPath.FontFamily = new FontFamily(scritta.fontFamily);
textPath.FontSize = scritta.fontSize;
if (scritta.fillImage == null)
{
textPath.Fill = (SolidColorBrush) new BrushConverter().ConvertFromString(scritta.fillColor);
}
textPath.Stroke = (SolidColorBrush) new BrushConverter().ConvertFromString(scritta.strokeColor);
textPath.StrokeThickness = scritta.strokeThickness;
Viewbox viewBox = new Viewbox();
viewBox.Child = textPath;
Canvas.SetZIndex(viewBox, 10);
contenitore.Children.Add(viewBox);
var size = new Size(ww, hh);
contenitore.Measure(size);
contenitore.Arrange(new Rect(size));
TransformGroup gruppo = new TransformGroup();
// ROTAZIONE
if (scritta.rotazione != null)
{
RotateTransform rot = new RotateTransform(scritta.rotazione.gradi);
// La rotazione avviene sempre nel centro dell'elemento
var l = Double.IsNaN(Canvas.GetLeft(viewBox)) ? 0 : Canvas.GetLeft(viewBox);
var t = Double.IsNaN(Canvas.GetTop(viewBox)) ? 0 : Canvas.GetTop(viewBox);
rot.CenterX = l + (viewBox.ActualWidth / 2);
rot.CenterY = t + (viewBox.ActualHeight / 2);
// TransformGroup tg = new TransformGroup();
// tg.Children.Add( rot );
gruppo.Children.Add(rot);
}
// TRASLAZIONE (move)
if (scritta.traslazione != null)
{
// devo riproporzionare le coordinate di origine a quelle attuali.
// spostaX : oldW = newSpostaH : newW
//
var newOffsetX = contenitore.ActualWidth * scritta.traslazione.offsetX / scritta.traslazione.rifW;
var newOffsetY = contenitore.ActualHeight * scritta.traslazione.offsetY / scritta.traslazione.rifH;
TranslateTransform tre = new TranslateTransform(newOffsetX, newOffsetY);
gruppo.Children.Add(tre);
}
if (scritta.zoom != null)
{
ScaleTransform stx = new ScaleTransform(scritta.zoom.fattore, scritta.zoom.fattore);
gruppo.Children.Add(stx);
stx.CenterX = (viewBox.RenderSize.Width / 2);
stx.CenterY = (viewBox.RenderSize.Height / 2);
}
if (gruppo.Children.Count > 0)
{
viewBox.RenderTransform = gruppo;
}
contenitore.InvalidateMeasure();
contenitore.InvalidateArrange();
contenitore.Measure(size);
contenitore.Arrange(new Rect(size));
/*
* Rect rectSotto = new Rect( 0, 0, bmpSorgente.PixelWidth, bmpSorgente.PixelHeight );
* ImageDrawing drawingSotto = new ImageDrawing( bmpSorgente, rectSotto );
*/
RenderTargetBitmap bmp = new RenderTargetBitmap(ww, hh, 96, 96, PixelFormats.Pbgra32);
bmp.Render(contenitore);
BmpBitmapEncoder enc = new BmpBitmapEncoder();
enc.Frames.Add(BitmapFrame.Create(bmp));
byte[] imagebit; //You can save your copy data in byte[].
using (MemoryStream stream = new MemoryStream()) {
enc.Save(stream);
imagebit = stream.ToArray();
stream.Close();
}
var bitmap = new BitmapImage();
using (var stream = new MemoryStream(imagebit)) {
bitmap.BeginInit();
bitmap.StreamSource = stream;
bitmap.CacheOption = BitmapCacheOption.OnLoad;
bitmap.EndInit();
bitmap.Freeze();
}
return(new ImmagineWic(bitmap));
}
