public static unsafe bool Load(System.IO.Stream stream, out PyramidFileHeader header)
{
try
{
byte[] buffer = new byte[sizeof(PyramidFileHeader)];
if (stream.Read(buffer, 0, buffer.Length) != buffer.Length)
{
header = new PyramidFileHeader();
return(false);
}
header = PyramidFileHeader.FromBytes(buffer);
return(true);
}
catch
{
header = new PyramidFileHeader();
return(false);
}
}
private bool ReadPYX(string filename)
{
try
{
FileInfo fi = new FileInfo(filename);
if (!fi.Exists)
{
return(false);
}
StreamReader reader = new StreamReader(fi.FullName);
PyramidFileHeader.Load(reader.BaseStream, out _header);
_levelHeader = new List <PyramidLevelHeader>();
for (int i = 0; i < _header.Levels; i++)
{
PyramidLevelHeader levHeader;
PyramidLevelHeader.Load(reader.BaseStream, out levHeader);
_levelHeader.Add(levHeader);
}
_picHeader = new List <PyramidPictureHeader>();
foreach (PyramidLevelHeader levHeader in _levelHeader)
{
for (int i = 0; i < levHeader.numPictures; i++)
{
PyramidPictureHeader picHeader;
PyramidPictureHeader.Load(reader.BaseStream, out picHeader);
_picHeader.Add(picHeader);
}
}
reader.Close();
return(true);
}
catch
{
return(false);
}
}
public bool Create(string sourceFilename, string destinationFilename, int levels, ImageFormat format)
{
Bitmap8pbbIndexed sourceBitmap = null;
Bitmap image = null;
try
{
FileInfo fi = new FileInfo(sourceFilename);
string tfwfilename = sourceFilename.Substring(0, sourceFilename.Length - fi.Extension.Length);
if (fi.Extension.ToLower() == ".jpg" || fi.Extension.ToLower() == ".jpeg")
{
tfwfilename += ".jgw";
}
else
{
tfwfilename += ".tfw";
}
TFWFile tfw = new TFWFile(tfwfilename);
image = new Bitmap(sourceFilename); //Image.FromFile(sourceFilename);
Polygon polygon = tfw.CreatePolygon(image.Width, image.Height);
StreamWriter writer = new StreamWriter(destinationFilename + ".pyx");
double X, Y, dx1, dx2, dy1, dy2, cellX, cellY;
int width, height;
// Header schreiben
PyramidFileHeader header = new PyramidFileHeader(true);
header.iWidth = width = image.Width;
header.iHeight = height = image.Height;
header.X = X = tfw.X;
header.Y = Y = tfw.Y;
header.dx1 = dx1 = tfw.dx_X;
header.dx2 = dx2 = tfw.dx_Y;
header.dy1 = dy1 = tfw.dy_X;
header.dy2 = dy2 = tfw.dy_Y;
header.cellX = cellX = tfw.cellX;
header.cellY = cellY = tfw.cellY;
header.Levels = levels;
header.Format = format.Guid;
header.Save(writer.BaseStream);
X = X - dx1 / 2.0 - dy1 / 2.0; // Auf die linke oberere Ecke setzen
Y = Y - dx2 / 2.0 - dy2 / 2.0;
PixelFormat pixFormat = image.PixelFormat;
if (pixFormat != PixelFormat.Format8bppIndexed &&
pixFormat != PixelFormat.Format1bppIndexed)
{
pixFormat = PixelFormat.Format32bppArgb;
}
else
{
sourceBitmap = new Bitmap8pbbIndexed(image);
}
// Levelheader schreiben
for (int lev = 1; lev <= levels; lev++)
{
int tWidth = width / (int)Math.Pow(2, lev - 1), tHeight = height / (int)Math.Pow(2, lev - 1);
int iWidth = getWidth(tWidth);
int iHeight = getHeight(tHeight);
double stepX = iWidth * Math.Pow(2, lev - 1), stepY = iHeight * Math.Pow(2, lev - 1);
PyramidLevelHeader levelHeader;
levelHeader.level = lev;
levelHeader.numPictures = 0; // ????
levelHeader.cellX = cellX * Math.Pow(2, lev - 1);;
levelHeader.cellY = cellY * Math.Pow(2, lev - 1);;
for (int y = 0, yC = 0; y < tHeight; y += iHeight, yC++)
{
for (int x = 0, xC = 0; x < tWidth; x += iWidth, xC++)
{
levelHeader.numPictures++;
}
}
levelHeader.Save(writer.BaseStream);
}
// Pictureheader und Bilder schreiben
StreamWriter picWriter = new StreamWriter(destinationFilename + ".pyc");
for (int lev = 1; lev <= levels; lev++)
{
int tWidth = width / (int)Math.Pow(2, lev - 1), tHeight = height / (int)Math.Pow(2, lev - 1);
int iWidth = getWidth(tWidth);
int iHeight = getHeight(tHeight);
double stepX = iWidth * Math.Pow(2, lev - 1), stepY = iHeight * Math.Pow(2, lev - 1);
for (int y = 0, yC = 0; y < tHeight; y += iHeight, yC++)
{
for (int x = 0, xC = 0; x < tWidth; x += iWidth, xC++)
{
PyramidPictureHeader picHeader;
using (Bitmap bm = new Bitmap(Math.Min(iWidth, tWidth - x), Math.Min(iHeight, tHeight - y), image.PixelFormat))
{
if ((bm.PixelFormat == PixelFormat.Format1bppIndexed ||
bm.PixelFormat == PixelFormat.Format8bppIndexed) &&
sourceBitmap != null)
{
Bitmap8pbbIndexed destBitmap = new Bitmap8pbbIndexed(bm);
destBitmap.DrawImage(sourceBitmap,
new Rectangle(0, 0, bm.Width, bm.Height),
new Rectangle(
(int)(xC * (float)stepX), (int)(yC * (float)stepY),
(int)Math.Min(image.Width - xC * stepX, stepX),
(int)Math.Min(image.Height - yC * stepY, stepY)
));
destBitmap.Dispose(false);
bm.Palette = image.Palette;
}
else
{
using (System.Drawing.Graphics gr = System.Drawing.Graphics.FromImage(bm))
{
gr.DrawImage(image,
new Rectangle(0, 0, bm.Width, bm.Height),
xC * (float)stepX, yC * (float)stepY,
(float)Math.Min(image.Width - xC * stepX, stepX),
(float)Math.Min(image.Height - yC * stepY, stepY),
GraphicsUnit.Pixel);
}
}
MemoryStream ms = new MemoryStream();
BinaryWriter bw = new BinaryWriter(ms);
bm.Save(bw.BaseStream, format);
byte[] buffer = new byte[ms.Length];
ms.Position = 0;
ms.Read(buffer, 0, buffer.Length);
bw.Close();
ms.Close();
bm.Dispose();
picHeader.startPosition = picWriter.BaseStream.Position;
picHeader.streamLength = buffer.Length;
picWriter.BaseStream.Write(buffer, 0, buffer.Length);
}
picHeader.level = lev;
picHeader.iWidth = iWidth;
picHeader.iHeight = iHeight;
picHeader.dx1 = dx1 * Math.Pow(2, lev - 1);
picHeader.dx2 = dx2 * Math.Pow(2, lev - 1);
picHeader.dy1 = dy1 * Math.Pow(2, lev - 1);
picHeader.dy2 = dy2 * Math.Pow(2, lev - 1);
picHeader.X = X + picHeader.dx1 * x + picHeader.dy1 * y + picHeader.dx1 / 2.0 + picHeader.dy1 / 2.0;
picHeader.Y = Y + picHeader.dx2 * x + picHeader.dy2 * y + picHeader.dx2 / 2.0 + picHeader.dy2 / 2.0;
picHeader.cellX = cellX * Math.Pow(2, lev - 1);
picHeader.cellY = cellY * Math.Pow(2, lev - 1);
picHeader.Save(writer.BaseStream);
}
}
}
picWriter.Close();
writer.Close();
return(true);
}
catch (Exception ex)
{
_errMsg = ex.Message;
if (sourceBitmap != null)
{
sourceBitmap.Dispose(false);
sourceBitmap = null;
}
if (image != null)
{
image.Dispose();
image = null;
}
return(false);
}
}
