private void FetchMapLayer()
{
if (!_Client.Network.Connected)
{
return;
}
GridRegion region;
if (Client.Grid.GetGridRegion(Client.Network.CurrentSim.Name, GridLayerType.Objects, out region))
{
SetMapLayer(null);
_MapImageID = region.MapImageID;
Client.Assets.RequestImage(_MapImageID, ImageType.Baked,
delegate(TextureRequestState state, AssetTexture asset)
{
if (state == TextureRequestState.Finished)
{
using (var reader = new OpenJpegDotNet.IO.Reader(asset.AssetData))
{
if (!reader.ReadHeader())
{
return;
}
_MapLayer = reader.DecodeToBitmap();
}
}
});
}
}
public RawImage ToPng(byte[] content)
{
using var reader = new OpenJpegDotNet.IO.Reader(content);
var result = reader.ReadHeader();
using var rawBitmap = reader.ReadRawBitmap();
return(new RawImage(rawBitmap.Data.ToArray(), rawBitmap.Width, rawBitmap.Height, 3));
}
private bool LoadTexture(UUID textureID, ref Image texture, bool removeAlpha)
{
if (textureID == UUID.Zero)
{
return(false);
}
ManualResetEvent gotImage = new ManualResetEvent(false);
Image img = null;
try
{
gotImage.Reset();
instance.Client.Assets.RequestImage(textureID, (state, assetTexture) =>
{
try
{
if (state == TextureRequestState.Finished)
{
// what the fk is going on here? lol
using (var reader = new OpenJpegDotNet.IO.Reader(assetTexture.AssetData))
{
if (!reader.ReadHeader())
{
throw new Exception("Failed to decode texture header " + assetTexture.AssetID.ToString());
}
try
{
img = reader.Decode().ToBitmap(!removeAlpha);
}
catch (NotSupportedException)
{
img = null;
}
}
}
}
finally
{
gotImage.Set();
}
}
);
gotImage.WaitOne(30 * 1000, false);
if (img != null)
{
texture = img;
return(true);
}
return(false);
}
catch (Exception e)
{
Logger.Log(e.Message, Helpers.LogLevel.Error, instance.Client, e);
return(false);
}
}
private void btnSave_Click(object sender, EventArgs e)
{
SaveFileDialog dlg = new SaveFileDialog
{
AddExtension = true,
RestoreDirectory = true,
Title = "Save image as...",
Filter =
"PNG (*.png)|*.png|Targa (*.tga)|*.tga|Jpeg2000 (*.j2c)|*.j2c|Jpeg (*.jpg)|*.jpg|Bitmap (*.bmp)|*.bmp"
};
if (dlg.ShowDialog() == DialogResult.OK)
{
int type = dlg.FilterIndex;
if (type == 3)
{ // jpeg2000
File.WriteAllBytes(dlg.FileName, UploadData);
}
else if (type == 2)
{ // targa
using (var reader = new OpenJpegDotNet.IO.Reader(UploadData))
{
if (reader.ReadHeader())
{
File.WriteAllBytes(dlg.FileName, reader.Decode().ToTarga().Bytes);
}
}
}
else if (type == 1)
{ // png
pbPreview.Image.Save(dlg.FileName, ImageFormat.Png);
}
else if (type == 4)
{ // jpg
pbPreview.Image.Save(dlg.FileName, ImageFormat.Jpeg);
}
else
{ // BMP
pbPreview.Image.Save(dlg.FileName, ImageFormat.Bmp);
}
}
dlg.Dispose();
}
private async void ButtonClick(object sender, EventArgs e)
{
try
{
var webClient = new WebClient();
var content = await webClient.DownloadDataTaskAsync(new Uri(this.textBox.Text));
using (var reader = new OpenJpegDotNet.IO.Reader(content))
{
var result = reader.ReadHeader();
this.pictureBox.Image?.Dispose();
this.pictureBox.Image = reader.ReadData();
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
}
private static TextureDownloadCallback TextureDownloadCallback(Bitmap[] detailTexture, int i, AutoResetEvent textureDone)
{
return((state, assetTexture) =>
{
if (state == TextureRequestState.Finished && assetTexture?.AssetData != null)
{
using (var reader = new OpenJpegDotNet.IO.Reader(assetTexture.AssetData))
{
if (reader.ReadHeader())
{
detailTexture[i] = reader.DecodeToBitmap();
}
else
{
throw new Exception("Cannot read J2K header");
}
}
}
textureDone.Set();
});
}
/// <summary>
/// Decodes the JPEG2000 data in <code>AssetData</code> to the
/// <seealso cref="ManagedImage"/> object <seealso cref="Image"/>
/// </summary>
/// <returns>True if the decoding was successful, otherwise false</returns>
public override bool Decode()
{
if (AssetData == null || AssetData.Length <= 0)
{
return(false);
}
this.Components = 0;
using (var reader = new OpenJpegDotNet.IO.Reader(AssetData))
{
// *hack: decode from ManagedImage directly or better yet, get rid of ManagedImage entirely!
if (!reader.ReadHeader())
{
return(false);
}
Image = new ManagedImage(reader.DecodeToBitmap());
}
if ((Image.Channels & ManagedImage.ImageChannels.Color) != 0)
{
Components += 3;
}
if ((Image.Channels & ManagedImage.ImageChannels.Gray) != 0)
{
++Components;
}
if ((Image.Channels & ManagedImage.ImageChannels.Bump) != 0)
{
++Components;
}
if ((Image.Channels & ManagedImage.ImageChannels.Alpha) != 0)
{
++Components;
}
return(true);
}
bool LoadTexture(UUID textureID, ref Image texture, bool removeAlpha)
{
var gotImage = new System.Threading.ManualResetEvent(false);
Image img = null;
try
{
gotImage.Reset();
Client.Assets.RequestImage(textureID, (state, assetTexture) =>
{
if (state == TextureRequestState.Finished)
{
using (var reader = new OpenJpegDotNet.IO.Reader(assetTexture.AssetData))
{
if (reader.ReadHeader())
{
img = reader.Decode().ToBitmap(!removeAlpha);
}
}
}
gotImage.Set();
});
gotImage.WaitOne(30 * 1000, false);
if (img != null)
{
texture = img;
return(true);
}
return(false);
}
catch (Exception e)
{
Logger.Log(e.Message, Helpers.LogLevel.Error, Client, e);
return(false);
}
}
void SaveTextures()
{
OnProgress("Exporting textures...");
for (int i = 0; i < Textures.Count; i++)
{
var id = Textures[i];
if (TextureNames[i] == null)
{
OnProgress("Skipping " + id + " due to insufficient permissions");
continue;
}
string filename = TextureNames[i] + "." + ImageFormat.ToLower();
OnProgress("Fetching texture" + id);
Image wImage = null;
byte[] jpegData = null;
try
{
AutoResetEvent gotImage = new AutoResetEvent(false);
Client.Assets.RequestImage(id, ImageType.Normal, (state, asset) =>
{
if (state == TextureRequestState.Finished && asset != null)
{
jpegData = asset.AssetData;
using (var reader = new OpenJpegDotNet.IO.Reader(jpegData))
{
if (reader.ReadHeader())
{
wImage = reader.DecodeToBitmap();
}
else
{
throw new Exception("Cannot read J2K header");
}
}
gotImage.Set();
}
else if (state != TextureRequestState.Pending && state != TextureRequestState.Started && state != TextureRequestState.Progress)
{
gotImage.Set();
}
});
gotImage.WaitOne(120 * 1000, false);
if (wImage != null)
{
string fullFileName = System.IO.Path.Combine(System.IO.Path.GetDirectoryName(FileName), filename);
switch (ImageFormat)
{
case "PNG":
wImage.Save(fullFileName, System.Drawing.Imaging.ImageFormat.Png);
break;
case "JPG":
wImage.Save(fullFileName, System.Drawing.Imaging.ImageFormat.Jpeg);
break;
case "BMP":
wImage.Save(fullFileName, System.Drawing.Imaging.ImageFormat.Bmp);
break;
case "J2C":
File.WriteAllBytes(fullFileName, jpegData);
break;
case "TGA":
//File.WriteAllBytes(fullFileName, mImage.ExportTGA());
break;
default:
throw new Exception("Unsupported image format");
}
OnProgress("Saved to " + fullFileName);
}
else
{
throw new Exception("Failed to decode image");
}
}
catch (Exception ex)
{
OnProgress("Failed: " + ex);
TextureNames[i] = null;
}
}
}
public void LoadImage(string fname)
{
FileName = fname;
if (string.IsNullOrEmpty(FileName))
{
return;
}
txtStatus.AppendText("Loading..." + Environment.NewLine);
string extension = Path.GetExtension(FileName).ToLower();
try
{
Bitmap bitmap = null;
switch (extension)
{
case ".jp2":
case ".j2c":
// Upload JPEG2000 images untouched
UploadData = File.ReadAllBytes(FileName);
using (var reader = new OpenJpegDotNet.IO.Reader(UploadData))
{
if (reader.ReadHeader())
{
bitmap = reader.DecodeToBitmap();
}
}
txtStatus.AppendText("Loaded raw JPEG2000 data " + FileName + Environment.NewLine);
break;
case ".tga":
bitmap = LoadTGAClass.LoadTGA(FileName);
break;
default:
bitmap = Image.FromFile(FileName) as Bitmap;
break;
}
if (bitmap == null)
{
txtStatus.AppendText("Failed to load image " + FileName + Environment.NewLine);
return;
}
txtStatus.AppendText("Loaded image " + FileName + Environment.NewLine);
int width = bitmap.Width;
int height = bitmap.Height;
// Handle resizing to prevent excessively large images and irregular dimensions
if (!IsPowerOfTwo((uint)width) || !IsPowerOfTwo((uint)height) || width > 1024 || height > 1024)
{
txtStatus.AppendText("Image has irregular dimensions " + width + "x" + height + Environment.NewLine);
width = ClosestPowerOwTwo(width);
height = ClosestPowerOwTwo(height);
width = width > 1024 ? 1024 : width;
height = height > 1024 ? 1024 : height;
txtStatus.AppendText("Resizing to " + width + "x" + height + Environment.NewLine);
Bitmap resized = new Bitmap(width, height, bitmap.PixelFormat);
Graphics graphics = Graphics.FromImage(resized);
graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
graphics.InterpolationMode =
System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
graphics.DrawImage(bitmap, 0, 0, width, height);
bitmap.Dispose();
bitmap = resized;
}
txtStatus.AppendText("Encoding image..." + Environment.NewLine);
using (var writer = new OpenJpegDotNet.IO.Writer(bitmap))
{
var cp = new OpenJpegDotNet.CompressionParameters();
OpenJpegDotNet.OpenJpeg.SetDefaultEncoderParameters(cp);
cp.CodingParameterDistortionAllocation = 1;
if (chkLossless.Checked)
{
cp.TcpNumLayers = 1;
cp.TcpRates[0] = 0;
}
else
{
cp.TcpNumLayers = 5;
cp.TcpRates[0] = 1920;
cp.TcpRates[1] = 480;
cp.TcpRates[2] = 120;
cp.TcpRates[3] = 30;
cp.TcpRates[4] = 10;
cp.Irreversible = true;
cp.TcpMCT = 1;
}
writer.SetupEncoderParameters(cp);
UploadData = writer.Encode();
}
txtStatus.AppendText("Finished encoding." + Environment.NewLine);
ImageLoaded = true;
UpdateButtons();
txtAssetID.Text = UUID.Zero.ToString();
pbPreview.Image = bitmap;
lblSize.Text = string.Format("{0}x{1} {2} KB", bitmap.Width, bitmap.Height, Math.Round((double)UploadData.Length / 1024.0d, 2));
}
catch (Exception ex)
{
UploadData = null;
btnSave.Enabled = false;
btnUpload.Enabled = false;
txtStatus.AppendText(string.Format("Failed to load the image:" + Environment.NewLine
+ "{0}" + Environment.NewLine, ex.Message));
}
}
