public ActionResult DeleteConfirmed(int id)
{
Images images = db.ImagesSet.Find(id);
if (images == null || images.Pools.owner != User.Identity.Name)
{
return(HttpNotFound());
}
Pools thisPool = db.PoolsSet.Find(images.PoolsId);
bool writelock = false;
// Wenn der Pool ein MotivPool ist (und das Bild ein Motiv ist) gibt es einen spezifischen Writelock
if (thisPool.size == 0)
{
writelock = db.Set <Motive>().Find(id).writelock;
}
if (!thisPool.writelock && !writelock)
{
// Speichere die Änderungen in der Datenbank
db.ImagesSet.Remove(images);
db.SaveChanges();
// Entferne das Bild im FileSystem
System.IO.File.Delete(IMAGEPATH + images.path + images.filename);
return(RedirectToAction("Details", "Pools", new { id = images.PoolsId }));
}
return(RedirectToAction("Delete", "Pools", new { id = images.PoolsId }));
}
/// <summary>
/// Erstellt eine Kachel
/// </summary>
/// <param name="kachelPoolID">Der Pool in dem die Kachel gespeichert werden soll</param>
/// <param name="r">Der Rot-Anteil der Kachelfarbe</param>
/// <param name="g">Der Grün-Anteil der Kachelfarbe</param>
/// <param name="b">Der Blau-Anteil der Kachelfarbe</param>
/// <param name="nois">Es kann ein Rauschen der Farbwerte erzeugt werden</param>
/// <returns>Void</returns>
public void genKachel(int kachelPoolID, int r, int g, int b, bool nois = false)
{
int nr = r;
int ng = g;
int nb = b;
int boul;
int rand;
printToConsole("Find pool by Id: " + kachelPoolID, ConsolePrintTypes.INFO);
Pools kachelPool = db.PoolsSet.Where(p => p.Id == kachelPoolID).First();
printToConsole("R: " + r + "G: " + g + "B: " + b + "Nois: " + nois, ConsolePrintTypes.INFO);
printToConsole("Kachelsize " + kachelPool.size + "x" + kachelPool.size, ConsolePrintTypes.INFO);
int width = kachelPool.size;
int height = kachelPool.size;
Random random = new Random();
Bitmap bitmap = new Bitmap(width, height);
try {
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
if (nois)
{
boul = random.Next(0, 1);
rand = random.Next(50, 70);
if (boul == 1)
{
nr = r + rand;
ng = g + rand;
nb = b + rand;
}
else
{
nr = r - rand;
ng = g - rand;
nb = b - rand;
}
nr = minMax(nr);
ng = minMax(ng);
nb = minMax(nb);
}
bitmap.SetPixel(x, y, Color.FromArgb(nr, ng, nb));
}
}
}
catch (Exception e)
{
printToConsole(e.ToString(), ConsolePrintTypes.INFO);
}
// Generiere eine Einzigartige Bezeichnung
String UUID = Guid.NewGuid().ToString();
printToConsole("gen UUID: " + UUID, ConsolePrintTypes.INFO);
// Speichere das Bild ab
bitmap.Save(IMAGEPATH + "Kacheln\\" + UUID + ".png");
printToConsole("Save image to: " + IMAGEPATH + "Kacheln\\" + UUID + ".png", ConsolePrintTypes.INFO);
var kachel = db.Set <Kacheln>();
kachel.Add(new Kacheln
{
displayname = "Kachel",
filename = UUID + ".png",
path = "Kacheln\\",
heigth = bitmap.Size.Height,
width = bitmap.Size.Width,
hsv = "000",
PoolsId = kachelPoolID,
avgR = (int)colorValue(bitmap, ColorType.RED),
avgG = (int)colorValue(bitmap, ColorType.GREEN),
avgB = (int)colorValue(bitmap, ColorType.BLUE)
});
// Speichere die DB
db.SaveChanges();
printToConsole("Generation done!", ConsolePrintTypes.INFO);
bitmap.Dispose();
}
public Repository(DBModelContainer context)
{
_context = context;
dbSet = _context.Set <T>();
}
/// <summary>
/// Der eigentliche Mosaikgenerator. Liest Kacheln aus und fuegt diese an die passenden Stellen fuer das Originalbild ein
/// </summary>
/// <param name="basisMotivID">Die ID des Basismotivs</param>
/// <param name="kachelPoolID">Die ID des Kachelpools</param>
/// <param name="mosaikPoolID">Die ID des Mosaikpools (in dem das Bild gespeichert wird)</param>
/// <param name="kachelnMultiUseEnabled">Sollen Kacheln mehrfach genutzt werden duerfen?</param>
/// <param name="auswahlNBesteKacheln">Aus wievielen der besten Bilder soll ein zufaelliges ausgewaehlt werden?</param>
public bool mosaikGenerator(int basisMotivID, int kachelPoolID, int mosaikPoolID, Boolean kachelnMultiUseEnabled = true, int auswahlNBesteKacheln = 1)
{
printToConsole("MosaikStart! (" + basisMotivID + "--" + kachelPoolID + "--" + mosaikPoolID + "--" + auswahlNBesteKacheln + ")", ConsolePrintTypes.INFO);
// Pruefe ob alle wichtigen Parameter richtig gesetzt sind
if (basisMotivID < 1 && kachelPoolID < 1 && mosaikPoolID < 1 && auswahlNBesteKacheln < 1)
{
printToConsole("Falscher Parameter - Abbruch! (" + basisMotivID + "--" + kachelPoolID + "--" + mosaikPoolID + "--" + auswahlNBesteKacheln + ")", ConsolePrintTypes.ERROR);
return(false);
}
// Lade das Basismotiv in eine Bitmap
Bitmap basisMotiv = openImage(basisMotivID);
// Wenn basisMotiv null ist dann gab es einen Fehler beim laden des Bildes
if (basisMotiv == null)
{
printToConsole("Basismotiv nicht gefunden - Abbruch!", ConsolePrintTypes.ERROR);
return(false);
}
// Lade die Kachel-Poolinformationen aus der Datenbank
Pools kachelPool = db.PoolsSet.Find(kachelPoolID);
// Berechne die Anzahl aller Pixel
int pixel = basisMotiv.Height * basisMotiv.Width;
// Prüfe ob genug Kacheln im Pool sind
// Wenn Kacheln nur einmalig erlaubt sind, muss geprueft werden ob genug vorhanden sind
if (!kachelnMultiUseEnabled)
{
// Wenn weniger Kacheln als Pixel vorhanden sind...
if (db.ImagesSet.Count <Images>() < pixel)
{
basisMotiv.Dispose();
printToConsole("Zu wenig Kacheln im Pool!", ConsolePrintTypes.ERROR);
return(false);
}
}
// lege ein neues Bild mit der neuen Groesse an
// Berechnung in der Dokumentation
Bitmap mosaik = new Bitmap((basisMotiv.Size.Width * kachelPool.size), (basisMotiv.Size.Height * kachelPool.size));
// Falls Kacheln nur einmalig genutzt werden duerfen, muessen diese vermerkt werden
List <int> usedKacheln = new List <int>();
// Es soll eine Liste vorhanden sein die aus den N besten Bildern ein zufaelliges auswaehlt
Dictionary <int, double> nKacheln = new Dictionary <int, double>();
// Hole alle Bilder aus dem Pool
Kacheln[] poolBilder = db.ImagesSet.OfType <Kacheln>().Where(p => p.PoolsId == kachelPoolID).ToArray();
// Lege die Variablen zur Berechnung an
Color pixelFarbe;
Random rnd = new Random();
Bitmap thisKachel;
int bestfit;
int differenzRot = 0;
int differenzGruen = 0;
int differenzBlau = 0;
// gehe jeden einzelnen Pixel des Originalbildes durch
for (int i = 1; i < basisMotiv.Size.Width + 1; i++)
{
for (int j = 1; j < basisMotiv.Size.Height + 1; j++)
{
// Lade die Farbwerte des aktuellen Pixels
pixelFarbe = basisMotiv.GetPixel(i - 1, j - 1);
// Gehe jedes Bild im Pool durch und pruefe ob es gut dorthin passt
for (int k = 0; k < poolBilder.Length; k++)
{
// Wenn Kacheln Multi disabled ist & die Kachel schonmal
// genutzt wurde soll der folgende Teil ignoriert werden
if (kachelnMultiUseEnabled || (!kachelnMultiUseEnabled && !usedKacheln.Contains(poolBilder[k].Id)))
{
// Berechne die drei jeweiligen (positiven) Differenzen
if (poolBilder[k].avgR > pixelFarbe.R)
{
differenzRot = poolBilder[k].avgR - pixelFarbe.R;
}
else
{
differenzRot = pixelFarbe.R - poolBilder[k].avgR;
}
if (poolBilder[k].avgG > pixelFarbe.G)
{
differenzGruen = poolBilder[k].avgG - pixelFarbe.G;
}
else
{
differenzGruen = pixelFarbe.G - poolBilder[k].avgG;
}
if (poolBilder[k].avgB > pixelFarbe.B)
{
differenzBlau = poolBilder[k].avgB - pixelFarbe.B;
}
else
{
differenzBlau = pixelFarbe.B - poolBilder[k].avgB;
}
// Rechne den Farbabstand aus (Formel aus den Hinweisen zur Hausarbeit)
double farbAbstand = Math.Sqrt((double)(differenzRot * differenzRot) + (differenzGruen * differenzGruen) + (differenzBlau * differenzBlau));
// Wenn noch Platz in dem N-Kachel-Array ist, lege den Wert ab
if (auswahlNBesteKacheln > nKacheln.Count)
{
nKacheln.Add(poolBilder[k].Id, farbAbstand);
}
else
{
// Ermittle den schlechtesten Wert in den N-Kacheln
double schlechtesterWert = 0;
int index = -1;
// Gehe alle Elemente durch und finde den schlechtesten Wert
// Dieser muss GRÖSSER als die anderen sein, da der ABSTAND möglichst niedrig sein soll
foreach (var nKachel in nKacheln)
{
if (nKachel.Value > schlechtesterWert)
{
index = nKachel.Key;
schlechtesterWert = nKachel.Value;
}
}
// Wenn das ergebnis besser ist als der schlechteste Wert
if (farbAbstand < schlechtesterWert)
{
// Entferne das schlechteste Element
nKacheln.Remove(index);
// Fuege die neue nKachel hinzu
nKacheln.Add(poolBilder[k].Id, farbAbstand);
}
}
}
}
// Hier wurden alle Bilder im Pool für einen Pixel durchsucht
// Hole nur die Keys aus der Liste
List <int> keys = Enumerable.ToList(nKacheln.Keys);
// Waehle ein zufaelligen Key - und damit auch das einzusetzende Bild
bestfit = keys[rnd.Next(nKacheln.Count)];
// Bereinige die NKacheln damit sie beim nächsten durchlauf nicht nochmal vorkommen :D
nKacheln.Clear();
// Wenn Kacheln nur einmal genutzt werden sollen, muss diese Kachel gespeichert werden
if (!kachelnMultiUseEnabled)
{
usedKacheln.Add(bestfit);
}
// Lade die Kachel
thisKachel = openImage(bestfit);
// Wenn basisMotiv null ist dann gab es einen Fehler beim laden des Bildes
if (thisKachel == null)
{
printToConsole("Kachel (" + bestfit + ") nicht gefunden - Abbruch!", ConsolePrintTypes.ERROR);
return(false);
}
// Füge nun jeden einzelnen Pixel an seiner dafür vorgesehnen Position ein
for (int x = 0; x < kachelPool.size; x++)
{
for (int y = 0; y < kachelPool.size; y++)
{
// Lade die Farbwerte des aktuellen Pixels
pixelFarbe = thisKachel.GetPixel(x, y);
// Und Fuege in an die richtige Position im neuen Mosaikbild ein
mosaik.SetPixel((((i - 1) * kachelPool.size) + x), (((j - 1) * kachelPool.size) + y), pixelFarbe);
}
}
}
}
// Generiere eine Einzigartige Bezeichnung
String UUID = Guid.NewGuid().ToString();
// Speichere das Bild ab
mosaik.Save(IMAGEPATH + "Motive\\" + UUID + ".png");
var image = db.Set <Motive>();
image.Add(new Motive {
displayname = "Mosaik", filename = UUID + ".png", path = "Motive\\", heigth = (basisMotiv.Size.Height * kachelPool.size), width = (basisMotiv.Size.Width * kachelPool.size), hsv = "000", PoolsId = mosaikPoolID, writelock = false
});
// Speichere die DB
db.SaveChanges();
return(true);
}
public ActionResult UploadImage(IEnumerable <HttpPostedFileBase> files, int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Pools pools = db.PoolsSet.Find(id);
if (pools == null || pools.owner != User.Identity.Name)
{
return(HttpNotFound());
}
ViewBag.Poolname = pools.name;
ViewBag.isKachel = pools.size > 0;
ViewBag.id = id;
String folder = "Kacheln";
if (pools.size == 0)
{
folder = "Motive";
}
foreach (var file in files)
{
String UUID = Guid.NewGuid().ToString();
String extention = System.IO.Path.GetExtension(file.FileName);
string filename = UUID + extention;
file.SaveAs(IMAGEPATH + folder + "\\" + filename);
Bitmap bmp = new Bitmap(IMAGEPATH + folder + "\\" + filename);
String dateiname = file.FileName;
int fileExtPos = dateiname.LastIndexOf(".");
if (fileExtPos >= 0)
{
dateiname = dateiname.Substring(0, fileExtPos);
}
if (pools.size == 0)
{
db.Set <Motive>().Add(new Motive {
path = folder + "\\", filename = filename, PoolsId = pools.Id, displayname = dateiname, heigth = bmp.Height, width = bmp.Width, hsv = "0", readlock = false, writelock = false
});
}
else
{
db.Set <Kacheln>().Add(new Kacheln {
path = folder + "\\", filename = filename, PoolsId = pools.Id, displayname = dateiname, heigth = bmp.Height, width = bmp.Width, hsv = "0"
}); //, avgR = (int)red, avgG = (int)green, avgB = (int)blue });
}
db.SaveChanges();
bmp.Dispose();
// Croppen und Scalen wenn Bild eine Kachel ist
if (pools.size > 0)
{
EndpointAddress endPoint = new EndpointAddress("http://localhost:8080/mosaikgenerator/imagehandler");
ChannelFactory <IHandler> channelFactory = new ChannelFactory <IHandler>(new BasicHttpBinding(), endPoint);
IHandler proxy = null;
int imageId = db.ImagesSet.Where(p => p.filename == filename).First().Id;
try
{
proxy = channelFactory.CreateChannel();
proxy.cropRect(imageId);
proxy.scale(imageId, pools.size);
}
catch (Exception e)
{
channelFactory.Close();
Console.WriteLine(e.ToString());
}
channelFactory.Close();
}
}
var imagesSet = db.ImagesSet.Include(p => p.Pools).Where(k => k.PoolsId == pools.Id);
return(View(imagesSet.ToList()));
}
