public void proiettaTest30()
{
Int32Rect foto1 = new Int32Rect(0, 0, 90, 100);
Int32Rect stampante1 = new Int32Rect(0, 0, 20, 15);
float rf = (float)Math.Round(ratio(foto1), 3);
float rs = (float)Math.Round(1 / ratio(stampante1), 3);
Assert.IsTrue(rf > rs);
ProiettoreArea proiettore1 = new ProiettoreArea(stampante1);
proiettore1.autoRotate = true;
proiettore1.autoZoomToFit = true;
Proiezione esito1 = proiettore1.calcola(foto1);
Int32Rect atteso1 = new Int32Rect(7, 0, 75, 100);
Assert.AreEqual(esito1.dest, stampante1);
Assert.AreEqual(esito1.sorg, atteso1);
Assert.IsTrue(esito1.effettuataRotazione);
// Controllo che il ratio finale sia giusto (arrotondando a 3 decimali)
float vr1 = (float)Math.Round(ratio(atteso1), 3);
float vr2 = (float)Math.Round(1 / ratio(stampante1), 3);
Assert.IsTrue(vr1 == vr2);
}
public void proiettaTest31()
{
Int32Rect foto = new Int32Rect(0, 0, 100, 80);
Int32Rect stampante = new Int32Rect(0, 0, 6, 10);
float rf = (float)Math.Round(ratio(foto), 3);
float rs = (float)Math.Round(1 / ratio(stampante), 3);
Assert.IsTrue(rf < rs);
ProiettoreArea proiettore = new ProiettoreArea(stampante);
proiettore.autoZoomToFit = true;
proiettore.autoRotate = true;
Proiezione esito = proiettore.calcola(foto);
Int32Rect atteso = new Int32Rect(0, 10, 100, 60);
Assert.AreEqual(esito.sorg, atteso);
Assert.AreEqual(esito.dest, stampante);
Assert.IsTrue(esito.effettuataRotazione);
// Controllo che il ratio finale sia giusto (arrotondando a 3 decimali)
float vr1 = (float)Math.Round(ratio(esito.sorg), 3);
float vr2 = (float)Math.Round(1 / ratio(stampante), 3);
Assert.IsTrue(vr1 == vr2);
}
public void proiettaTest03()
{
Int32Rect foto = new Int32Rect(0, 0, 50, 100);
Int32Rect stampante = new Int32Rect(0, 0, 5, 12);
ProiettoreArea proiettore = new ProiettoreArea(stampante);
Proiezione esito = proiettore.calcola(foto);
Int32Rect atteso = new Int32Rect(0, 1, 5, 10);
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, atteso);
Assert.IsFalse(esito.effettuataRotazione);
// Altra prova identica deve dare lo stesso risultato
Int32Rect foto2 = new Int32Rect(0, 0, 2, 4);
Proiezione esito2 = proiettore.calcola(foto2);
Assert.AreEqual(esito.dest, atteso);
}
/**
* Evento che viene rilanciato per stampare tutte le pagine
*/
void mioPrintPageEventHandler(object sender, PrintPageEventArgs e)
{
try {
// Ricavo l'immagine da stampare
IImmagine immagineDaStampare = _lavoroDiStampa.fotografia.imgOrig;
// Ricavo tutta l'area stampabile
RectangleF areaStampabile = e.PageSettings.PrintableArea;
// Non so perchè, ma quando giro la stampante, non mi si girano anche le dimensioni. Ci penso da solo.
if (_ruotareStampante)
{
areaStampabile = ProiettoreArea.ruota(areaStampabile);
}
//
// ----- Calcolo le aree di proiezione
//
ProiettoreArea proiettore = new ProiettoreArea(areaStampabile);
proiettore.autoCentra = true; // Questo lo decido io d'ufficio. Non avrebbe senso altrimenti.
proiettore.autoZoomToFit = _lavoroDiStampa.param.autoZoomToFit;
proiettore.autoRotate = _lavoroDiStampa.param.autoRuota;
Proiezione proiezione = proiettore.calcola(immagineDaStampare);
//
// ----- Inizio a stampare
//
// la rotazione non dovrebbe mai avvenire perchè ho già girato la stampante in anticipo
Debug.Assert(!proiezione.effettuataRotazione);
Graphics grpx = e.Graphics;
//set graphics attributes.
grpx.SmoothingMode = SmoothingMode.AntiAlias;
grpx.InterpolationMode = InterpolationMode.HighQualityBicubic;
grpx.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
grpx.PixelOffsetMode = PixelOffsetMode.HighQuality;
Image image = ((ImmagineNet)immagineDaStampare).image;
grpx.DrawImage(image, proiezione.dest, proiezione.sorg, GraphicsUnit.Pixel);
_esito = EsitoStampa.Ok;
} catch (Exception ee) {
_giornale.Error("Lavoro di stampa fallito: " + _lavoroDiStampa, ee);
_esito = EsitoStampa.Errore;
}
}
public void proiettaTest02()
{
Int32Rect foto = creaVert();
Int32Rect stampante = creaVert();
ProiettoreArea proiettore = new ProiettoreArea(stampante);
Proiezione esito = proiettore.calcola(foto);
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, stampante);
Assert.IsFalse(esito.effettuataRotazione);
}
public void proiettaTest20()
{
Int32Rect foto = creaOriz();
Int32Rect stampante = creaVert();
ProiettoreArea proiettore = new ProiettoreArea(stampante);
proiettore.autoRotate = true;
Proiezione esito = proiettore.calcola(foto);
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, stampante);
Assert.IsTrue(esito.effettuataRotazione);
}
public void proiettaTest05()
{
Int32Rect foto = creaVert();
Int32Rect stampante = creaOriz();
ProiettoreArea proiettore = new ProiettoreArea(stampante);
Proiezione esito = proiettore.calcola(foto);
Int32Rect atteso = new Int32Rect(607, 0, 3056, L1);
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, atteso);
Assert.IsFalse(esito.effettuataRotazione);
}
public void proiettaTest11()
{
Int32Rect stampante = creaOriz();
Int32Rect foto = creaOriz();
ProiettoreArea proiettore = new ProiettoreArea(stampante);
proiettore.autoZoomToFit = false;
Proiezione esito = proiettore.calcola(foto);
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, stampante);
Assert.IsFalse(esito.effettuataRotazione);
}
public void proiettaTest29()
{
Int32Rect stampante = new Int32Rect(0, 0, 50, 45);
Int32Rect foto = new Int32Rect(0, 0, 90, 100);
ProiettoreArea proiettore = new ProiettoreArea(stampante);
proiettore.autoRotate = true;
proiettore.autoZoomToFit = true;
Proiezione esito1 = proiettore.calcola(foto);
Assert.AreEqual(esito1.dest, stampante);
Assert.AreEqual(esito1.sorg, foto);
Assert.IsTrue(esito1.effettuataRotazione);
}
public void proiettaTest06()
{
Int32Rect foto = new Int32Rect(0, 0, 47, 67);
Int32Rect stampante = new Int32Rect(0, 0, 311, 187);
Assert.IsTrue(ratio(foto) > (1 / ratio(stampante)));
ProiettoreArea proiettore = new ProiettoreArea(stampante);
Proiezione esito = proiettore.calcola(foto);
Int32Rect atteso = new Int32Rect(90, 0, 131, 187);
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, atteso);
Assert.IsFalse(esito.effettuataRotazione);
}
public void proiettaTest10()
{
Int32Rect stampante = new Int32Rect(0, 0, 901, 607);
Int32Rect foto = new Int32Rect(0, 0, 407, 399);
Assert.IsTrue(ratio(foto) < ratio(stampante));
ProiettoreArea proiettore = new ProiettoreArea(stampante);
Proiezione esito = proiettore.calcola(foto);
Int32Rect atteso = new Int32Rect(141, 0, 619, 607); // Rimane uguale l'altezza. Cambia la larghezza
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, atteso);
Assert.IsFalse(esito.effettuataRotazione);
}
public void proiettaTest12()
{
Int32Rect stampante = new Int32Rect(0, 0, 193, 155);
Int32Rect foto = new Int32Rect(0, 0, 12355, 8997);
Assert.IsTrue(ratio(foto) > ratio(stampante));
ProiettoreArea proiettore = new ProiettoreArea(stampante);
Proiezione esito = proiettore.calcola(foto);
Int32Rect atteso = new Int32Rect(0, 7, 193, 140); // Rimane uguale la larghezza. Cambia l'altezza
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, atteso);
Assert.IsFalse(esito.effettuataRotazione);
}
public void proiettaTest26()
{
Int32Rect foto = new Int32Rect(0, 0, 80, 100);
Int32Rect stampante = new Int32Rect(0, 0, 16, 20);
Assert.IsTrue(ratio(foto) == ratio(stampante));
ProiettoreArea proiettore = new ProiettoreArea(stampante);
proiettore.autoZoomToFit = true;
proiettore.autoRotate = true;
Proiezione esito = proiettore.calcola(foto);
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, stampante);
Assert.IsFalse(esito.effettuataRotazione);
}
public void proiettaTest19()
{
Int32Rect foto = new Int32Rect(0, 0, 177, 111);
Int32Rect stampante = new Int32Rect(0, 0, 189, 200);
Assert.IsTrue(ratio(foto) > 1 / ratio(stampante));
ProiettoreArea proiettore = new ProiettoreArea(stampante);
proiettore.autoRotate = true;
Proiezione esito = proiettore.calcola(foto);
Int32Rect atteso = new Int32Rect(32, 0, 125, 200);
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, atteso);
Assert.IsTrue(esito.effettuataRotazione);
}
public void proiettaTest08()
{
Int32Rect stampante = creaVert();
Int32Rect foto = creaOriz();
ProiettoreArea proiettore = new ProiettoreArea(stampante);
proiettore.autoZoomToFit = false;
proiettore.autoRotate = false;
Proiezione esito = proiettore.calcola(foto);
Int32Rect risultatoAtteso = new Int32Rect(0, 607, L1, 3056);
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, risultatoAtteso);
Assert.IsFalse(esito.effettuataRotazione);
}
public void proiettaTest01()
{
Int32Rect foto = new Int32Rect(0, 0, 5, 12);
Int32Rect stampante = new Int32Rect(0, 0, 50, 100);
Assert.IsTrue(ratio(foto) < ratio(stampante));
ProiettoreArea proiettore = new ProiettoreArea(stampante);
Proiezione esito = proiettore.calcola(foto);
int neww = (int)(100 * (5f / 12f));
Assert.IsTrue(neww == 41);
Int32Rect atteso = new Int32Rect(4, 0, neww, 100);
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, atteso);
Assert.IsFalse(esito.effettuataRotazione);
}
public void proiettaTest07()
{
Int32Rect foto = new Int32Rect(0, 0, 13, 5);
Int32Rect stampante = new Int32Rect(0, 0, 50, 149);
Assert.IsTrue(ratio(foto) < 1 / ratio(stampante));
ProiettoreArea proiettore = new ProiettoreArea(stampante);
Proiezione esito = proiettore.calcola(foto);
int newh = (int)(50 / (13f / 5f));
Assert.IsTrue(newh == 19);
Int32Rect atteso = new Int32Rect(0, 65, 50, newh);
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, atteso);
Assert.IsFalse(esito.effettuataRotazione);
}
public void proiettaTest18()
{
Int32Rect foto = new Int32Rect(0, 0, 47, 67);
Int32Rect stampante = new Int32Rect(0, 0, 311, 187);
Assert.IsTrue(ratio(foto) > (1 / ratio(stampante)));
ProiettoreArea proiettore = new ProiettoreArea(stampante);
proiettore.autoRotate = true;
Proiezione esito = proiettore.calcola(foto);
Int32Rect atteso = new Int32Rect(22, 0, 266, 187);
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, atteso);
Assert.IsTrue(esito.effettuataRotazione);
Assert.IsTrue(Math.Abs(ratio(foto) - (1 / ratio(atteso))) < 0.09);
}
public void proiettaTest09()
{
Int32Rect foto = new Int32Rect(0, 0, 177, 111);
Int32Rect stampante = new Int32Rect(0, 0, 189, 200);
Assert.IsTrue(ratio(foto) > 1 / ratio(stampante));
ProiettoreArea proiettore = new ProiettoreArea(stampante);
Proiezione esito = proiettore.calcola(foto);
int newh = (int)(189f / (177f / 111f));
Assert.IsTrue(newh == 118);
Int32Rect atteso = new Int32Rect(0, 41, 189, newh);
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, atteso);
Assert.IsFalse(esito.effettuataRotazione);
}
public void proiettaTest47()
{
Int32Rect stampante = creaOriz();
Int32Rect foto = creaOriz();
float rf = (float)Math.Round(ratio(foto), 3);
float rs = (float)Math.Round(ratio(stampante), 3);
Assert.IsTrue(rf == rs);
ProiettoreArea proiettore = new ProiettoreArea(stampante);
proiettore.autoZoomToFit = true;
Proiezione esito = proiettore.calcola(foto);
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, stampante);
Assert.IsFalse(esito.effettuataRotazione);
}
public void proiettaTest32()
{
Int32Rect foto = new Int32Rect(0, 0, 100, 80);
Int32Rect stampante = new Int32Rect(0, 0, 40, 50);
float r1 = (float)Math.Round(ratio(foto), 3);
float r2 = (float)Math.Round(1 / ratio(stampante), 3);
Assert.IsTrue(r1 == r2);
ProiettoreArea proiettore = new ProiettoreArea(stampante);
proiettore.autoRotate = true;
proiettore.autoZoomToFit = true;
Proiezione esito = proiettore.calcola(foto);
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, stampante);
Assert.IsTrue(esito.effettuataRotazione);
}
public void proiettaTest36()
{
Int32Rect stampante = new Int32Rect(0, 0, 193, 155);
Int32Rect foto = new Int32Rect(0, 0, 12355, 8997);
float rf = (float)Math.Round(ratio(foto), 3);
float rs = (float)Math.Round(ratio(stampante), 3);
Assert.IsTrue(rf > rs);
ProiettoreArea proiettore = new ProiettoreArea(stampante);
proiettore.autoRotate = true;
Proiezione esito = proiettore.calcola(foto);
Int32Rect atteso = new Int32Rect(0, 7, 193, 140); // Rimane uguale la larghezza. Cambia l'altezza
Assert.AreEqual(esito.sorg, foto);
Assert.AreEqual(esito.dest, atteso);
Assert.IsFalse(esito.effettuataRotazione);
}
public void proiettaTest48()
{
Int32Rect stampante = new Int32Rect(0, 0, 193, 155);
Int32Rect foto = new Int32Rect(0, 0, 12355, 8997);
float rf = (float)Math.Round(ratio(foto), 3);
float rs = (float)Math.Round(ratio(stampante), 3);
Assert.IsTrue(rf > rs);
ProiettoreArea proiettore = new ProiettoreArea(stampante);
proiettore.autoZoomToFit = true;
Proiezione esito = proiettore.calcola(foto);
Int32Rect atteso = new Int32Rect(576, 0, 11202, 8997);
Assert.AreEqual(esito.sorg, atteso);
Assert.AreEqual(esito.dest, stampante);
Assert.IsFalse(esito.effettuataRotazione);
}
public void proiettaTest46()
{
Int32Rect stampante = new Int32Rect(0, 0, 901, 607);
Int32Rect foto = new Int32Rect(0, 0, 407, 399);
float rf = (float)Math.Round(ratio(foto), 3);
float rs = (float)Math.Round(ratio(stampante), 3);
Assert.IsTrue(rf < rs);
ProiettoreArea proiettore = new ProiettoreArea(stampante);
proiettore.autoZoomToFit = true;
Proiezione esito = proiettore.calcola(foto);
Int32Rect atteso = new Int32Rect(0, 62, 407, 274);
Assert.AreEqual(esito.sorg, atteso);
Assert.AreEqual(esito.dest, stampante);
Assert.IsFalse(esito.effettuataRotazione);
}
public void proiettaTest33()
{
Int32Rect foto = new Int32Rect(0, 0, 100, 54);
Int32Rect stampante = new Int32Rect(0, 0, 6, 10);
float rf = (float)Math.Round(ratio(foto), 3);
float rs = (float)Math.Round(1 / ratio(stampante), 3);
Assert.IsTrue(rf > rs);
ProiettoreArea proiettore = new ProiettoreArea(stampante);
proiettore.autoZoomToFit = true;
proiettore.autoRotate = true;
Proiezione esito = proiettore.calcola(foto);
Int32Rect atteso = new Int32Rect(5, 0, 89, 54);
Assert.AreEqual(esito.sorg, atteso);
Assert.AreEqual(esito.dest, stampante);
Assert.IsTrue(esito.effettuataRotazione);
}
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
double ret = Double.NaN;
WpfScreen scr = values[0] as WpfScreen;
// Grandezza della griglia dove visualizzo lo schermino blu virtuale
// Se il parametro è minuscolo, allora devo gestire
if (values.Length > 1)
{
GestoreFinestrePubbliche gfp = values[1] as GestoreFinestrePubbliche;
WpfScreen scrSS = gfp.getScreenSlideShow();
// Se lo schermo dove è presente lo ss non è quello che sto elaborando, allora esco
if (scrSS == null || scrSS.deviceEnum != scr.deviceEnum)
{
return((double)0);
}
Int32Rect dest = new Int32Rect(0, 0, 200, 200);
ProiettoreArea p = new ProiettoreArea(dest);
Int32Rect source = new Int32Rect((int)scrSS.WorkingArea.Left, (int)scrSS.WorkingArea.Top, (int)scrSS.WorkingArea.Width, (int)scrSS.WorkingArea.Height);
p.autoCentra = true;
Proiezione proiezione = p.calcola(source);
// Ora uso l'area risultante, come destinazione per la dimensione dello SS
ProiettoreArea p2 = new ProiettoreArea(proiezione.dest);
Int32Rect ssSorg = new Int32Rect(gfp.geomSS.Left, gfp.geomSS.Top, gfp.geomSS.Width, gfp.geomSS.Height);
Proiezione proiezione2 = p2.calcola(ssSorg);
if ("l".Equals(parameter))
{
ret = proiezione2.dest.X;
}
if ("T".Equals(parameter))
{
ret = proiezione2.dest.Y;
}
if ("W".Equals(parameter))
{
ret = proiezione2.dest.Width;
}
if ("H".Equals(parameter))
{
ret = proiezione2.dest.Height;
}
}
else
{
Int32Rect dest = new Int32Rect(0, 0, 200, 200);
ProiettoreArea p = new ProiettoreArea(dest);
Int32Rect source = new Int32Rect((int)scr.WorkingArea.Left, (int)scr.WorkingArea.Top, (int)scr.WorkingArea.Width, (int)scr.WorkingArea.Height);
p.autoCentra = true;
Proiezione proiezione = p.calcola(source);
if ("L".Equals(parameter))
{
ret = proiezione.dest.X;
}
if ("T".Equals(parameter))
{
ret = proiezione.dest.Y;
}
if ("W".Equals(parameter))
{
ret = proiezione.dest.Width;
}
if ("H".Equals(parameter))
{
ret = proiezione.dest.Height;
}
}
return(ret);
}
private double calcolaDimensione(string qualeFascia, string qualeDimens, object[] values)
{
// Ricavo dal vettore dei parametri delle variabili con un nome più chiaro.
float ratioCarta = (float)values[0];
if (ratioCarta == 0) // probabilmente non è indicata nemmeno una stampante
{
return(0d);
}
double imageW = (double)values [1];
double imageH = (double)values [2];
double imageActualW = (double)values [3];
double imageActualH = (double)values [4];
if (imageW == 0d || imageH == 0d)
{
return(0d);
}
if (imageActualW == 0d || imageActualH == 0d)
{
return(0d);
}
// -----
float ratioImage = (float)(imageActualW / imageActualH);
// I due rapporti mi indicano che sia la foto che l'area stampabile siano nella stesso verso (Orizzontali o Verticali entrambi)
if (ratioImage < 1 && ratioCarta >= 1 || ratioImage >= 1 && ratioCarta < 1)
{
// non sono dello stesso verso. lo giro!
ratioCarta = (1f / ratioCarta);
}
// Se la carta è più grande della foto (inteso come rapporto), allora devo tagliare sopra.
// Questo mi garantisce il corretto funzionamento indipendentemente dal verso della foto.
// Quindi le due bande colorate saranno sopra e sotto in orizzontale
// Nel caso contrario saranno a sinistra e destra in verticale.
bool eseguoTaglioOrizz = (ratioCarta > ratioImage);
// -----
// Ora creo due rettangoli per poter usare il ProiettoreArea
Int32Rect fotoSorgente = new Int32Rect(0, 0, (int)imageActualW, (int)imageActualH);
// creo un area dello stesso orientamento
int cartaW = (int)(1000 * ratioCarta);
int cartaH = (int)(cartaW / ratioCarta);
Int32Rect stampanteFinta = new Int32Rect(0, 0, cartaW, cartaH);
// Eseguo proiezione per capire dove e quanto verrà tagliata la foto originale.
ProiettoreArea proiettore = new ProiettoreArea(stampanteFinta, true);
Proiezione proiezione = proiettore.calcola(fotoSorgente);
// -----
//
// Ora finalmente calcolo il valore da ritornare
//
// -----
double ret = 0d;
// Width
if (qualeDimens == "W")
{
if (eseguoTaglioOrizz)
{
ret = (double)proiezione.sorg.Width;
}
else
{
ret = (double)proiezione.sorg.X;
}
}
// Height
if (qualeDimens == "H")
{
if (eseguoTaglioOrizz)
{
ret = (double)proiezione.sorg.Y;
}
else
{
ret = (double)proiezione.sorg.Height;
}
}
// Left (del canvas)
if (qualeDimens == "L")
{
double offsetX = (imageW - imageActualW) / 2;
if (qualeFascia == "b" && eseguoTaglioOrizz == false)
{
offsetX += (imageActualW - proiezione.sorg.X);
}
ret = offsetX;
}
// Top (del canvas)
if (qualeDimens == "T")
{
double offsetY = (imageH - imageActualH) / 2;
if (qualeFascia == "b" && eseguoTaglioOrizz == true)
{
offsetY += (imageActualH - proiezione.sorg.Y);
}
ret = offsetY;
}
return(ret);
}
