// Sample code for building a localized ApplicationBar
//private void BuildLocalizedApplicationBar()
//{
// // Set the page's ApplicationBar to a new instance of ApplicationBar.
// ApplicationBar = new ApplicationBar();
// // Create a new button and set the text value to the localized string from AppResources.
// ApplicationBarIconButton appBarButton = new ApplicationBarIconButton(new Uri("/Assets/AppBar/appbar.add.rest.png", UriKind.Relative));
// appBarButton.Text = AppResources.AppBarButtonText;
// ApplicationBar.Buttons.Add(appBarButton);
// // Create a new menu item with the localized string from AppResources.
// ApplicationBarMenuItem appBarMenuItem = new ApplicationBarMenuItem(AppResources.AppBarMenuItemText);
// ApplicationBar.MenuItems.Add(appBarMenuItem);
//}
private void ButtonBase_OnClick(object sender, RoutedEventArgs e)
{
using (var stream = typeof(MainPage).Assembly.GetManifestResourceStream("WP.CSJ2K.Test.Resources.file1.jp2"))
{
DecodedImage.Source = J2kImage.FromStream(stream).As <ImageSource>();
}
}
static void Main(string[] args)
{
// The library won't work without a license. You can get free time limited license
// at https://bitmiracle.com/jpeg2000/
LicenseManager.SetTrialLicense("contact [email protected] for a license");
string fileName = @"Sample data/p1_04.j2k";
string tileFileName = @"tile";
using (var image = new J2kImage(fileName))
{
var options = new J2kDecodingOptions
{
ForceRgbColorSpace = false
};
foreach (int i in new int[] { 5, 25, 45 })
{
var imageData = image.DecodeTile(i, options);
string outputName = string.Format("{0}_{1}.tif", tileFileName, i);
imageData.Save(outputName, J2kOutputFormat.Tiff);
Process.Start(outputName);
}
}
}
static void Main(string[] args)
{
// The library won't work without a license. You can get free time limited license
// at https://bitmiracle.com/jpeg2000/
LicenseManager.SetTrialLicense("contact [email protected] for a license");
string fileName = @"Sample data/a2_colr.j2c";
string bitmapFileName = @"output.bmp";
string tiffFileName = @"output.tiff";
using (var image = new J2kImage(fileName))
{
// there some decoding options that you can setup before you decode the image
var options = new J2kDecodingOptions
{
UpsampleComponents = true
};
var imageData = image.Decode(options);
// decoded image data can be saved as BMP or TIFF file
imageData.Save(bitmapFileName, J2kOutputFormat.Bmp);
imageData.Save(tiffFileName, J2kOutputFormat.Tiff);
}
Process.Start(bitmapFileName);
Process.Start(tiffFileName);
}
/*Converte l'array di byte codificato in jpeg2000 in una bitmap*/
public Bitmap ret_cie_bitmap()
{
BitmapImageCreator.Register();
var por = J2kImage.FromBytes(cie_jpg2k_image);
return(por.As <Bitmap>());
}
private ImageInfo GetImageInfoEx(string filePath)
{
var sw = new Stopwatch();
sw.Start();
var stream = new MemoryStream(); // MSDN: disposing is not necessary
var decodedImage = J2kImage.FromFile(filePath);
var bitmap = decodedImage.As <Bitmap>();
var size = GetOriginalSizeEx(filePath, bitmap);
if (conversionSettings.GroesseInProzent != 100 && conversionSettings.GroesseInProzent > 0)
{
var faktor = conversionSettings.GroesseInProzent / 100d;
bitmap = ResizeImage(bitmap, (int)(bitmap.Width * faktor), (int)(bitmap.Height * faktor));
}
bitmap.Save(stream, GetEncoderInfo("image/jpeg"), encoderParameters);
bitmap.Dispose();
Log.Verbose($"Took {sw.ElapsedMilliseconds} ms to create jpg from jp2 {filePath}", filePath);
return(new ImageInfo
{
Stream = stream,
PageSize = size
});
}
private ImageInfo GetImageInfoEx(string filePath)
{
var sw = new Stopwatch();
sw.Start();
var stream = new MemoryStream(); // MSDN: disposing is not necessary
var decodedImage = J2kImage.FromFile(filePath);
var bitmap = decodedImage.As <Bitmap>();
var size = GetOriginalSizeEx(filePath, bitmap);
if (settings.GroesseInProzent != 100 && settings.GroesseInProzent > 0)
{
var faktor = settings.GroesseInProzent / 100d;
bitmap = ResizeImage(bitmap, (int)(bitmap.Width * faktor), (int)(bitmap.Height * faktor));
}
// Set resolution to the resolution of the premis file (if any)
// or the resolution of the bitmap if the bitmap reports a resolution higher than 150 dpi
var res = fileResolution.GetResolution(bitmap, filePath);
bitmap.SetResolution(res, res);
bitmap.Save(stream, GetEncoderInfo("image/jpeg"), encoderParameters);
bitmap.Dispose();
Log.Verbose($"Took {sw.ElapsedMilliseconds} ms to create jpg from jp2 {filePath}", filePath);
return(new ImageInfo
{
Stream = stream,
PageSize = size
});
}
static void Main(string[] args)
{
// The library won't work without a license. You can get free time limited license
// at https://bitmiracle.com/jpeg2000/
LicenseManager.SetTrialLicense("contact [email protected] for a license");
string fileName = @"Sample data/a1_mono.j2c";
using (var image = new J2kImage(fileName))
{
Console.WriteLine("Size = {0}x{1}", image.Width, image.Height);
Console.WriteLine("Color space = {0}", image.ColorSpace);
Console.WriteLine("Component count = {0}", image.ComponentsInfo.Count);
int componentIndex = 0;
foreach (var component in image.ComponentsInfo)
{
Console.WriteLine("Component {0} offset = {1}x{2}", componentIndex, component.Left, component.Top);
Console.WriteLine("Component {0} size = {1}x{2}", componentIndex, component.Width, component.Height);
Console.WriteLine("Component {0} bytes per pixel = {1}", componentIndex, component.BitsPerPixel);
componentIndex++;
}
if (image.TileCount > 1)
{
Console.WriteLine("Tile count = {0}", image.TileCount);
Console.WriteLine("Tile size = {0}x{1}", image.TileWidth, image.TileHeight);
}
Console.WriteLine("Default tile coding style = {0}", image.DefaultTileInfo.CodingStyle);
Console.WriteLine("Default tile progression order = {0}", image.DefaultTileInfo.ProgressionOrder);
Console.WriteLine("Default tile quality layers count = {0}", image.DefaultTileInfo.QualityLayerCount);
}
}
// Encodes an image to the specified format in memory
private byte[] memEncode()
{
byte[] bytes = null;
using (MemoryStream stream = new MemoryStream())
{
switch (termExt)
{
case "bmp":
BmpBitmapEncoder bmpEncoder = new BmpBitmapEncoder();
bmpEncoder.Frames.Add(BitmapFrame.Create(backupBuffer));
bmpEncoder.Save(stream);
break;
case "jpg":
JpegBitmapEncoder jpgEncoder = new JpegBitmapEncoder();
jpgEncoder.Frames.Add(BitmapFrame.Create(backupBuffer));
jpgEncoder.Save(stream);
break;
case "gif":
GifBitmapEncoder gifEncoder = new GifBitmapEncoder();
gifEncoder.Frames.Add(BitmapFrame.Create(backupBuffer));
gifEncoder.Save(stream);
break;
case "png":
PngBitmapEncoder pngEncoder = new PngBitmapEncoder();
// pngEncoder.Interlace = PngInterlaceOption.On;
pngEncoder.Frames.Add(BitmapFrame.Create(backupBuffer));
pngEncoder.Save(stream);
break;
case "tiff":
TiffBitmapEncoder tiffEncoder = new TiffBitmapEncoder();
tiffEncoder.Frames.Add(BitmapFrame.Create(backupBuffer));
tiffEncoder.Save(stream);
break;
case "jp2":
bytes = new byte[height * stride];
backupBuffer.CopyPixels(bytes, stride, 0);
byte[] header = Encoding.ASCII.GetBytes("P6\n" + width + " " + height + "\n255\n");
stream.Write(header, 0, header.Length);
foreach (byte curByte in bytes)
{
stream.WriteByte(curByte);
}
bytes = J2kImage.ToBytes(J2kImage.CreateEncodableSource(stream));
return(bytes);
default:
break;
}
bytes = stream.ToArray();
}
return(bytes);
}
public void DrawAt(string filename, int x, int y, bool resizeIfNeeded = false)
{
try {
var j2k = J2kImage.FromFile(filename);
image.DrawImage(j2k.GetComponent(0), j2k.Width, j2k.Height, x, y, resizeIfNeeded);
} catch (Exception e) {
Console.WriteLine($"Corrupted Segment ({e.GetType().Name}): {e.Message}");
}
}
internal static MeshLOD SculptMeshToMesh(this Stream st, ObjectPart.PrimitiveShape.Decoded shape)
{
using (var im = J2kImage.FromStream(st))
{
using (var bitmap = new Bitmap(im))
{
return(bitmap.SculptMeshToMesh(shape));
}
}
}
public void AppendJ2K(string filename, bool resizeIfNeeded = false)
{
try {
var j2k = J2kImage.FromFile(filename);
image.DrawImage(j2k.GetComponent(0), j2k.Width, j2k.Height, 0, posY, resizeIfNeeded);
posY += j2k.Height;
segmentHeight = j2k.Height;
} catch (Exception e) {
Console.WriteLine($"Corrupted Segment ({e.GetType().Name}): {e.Message}");
posY += segmentHeight;
}
}
private protected override IEnumerable <float> DoEnumerateDataValues(BufferedBinaryReader reader, DataSection dataSection, long dataPointsNumber)
{
var data = reader.Read((int)dataSection.DataLength);
var img = J2kImage.FromBytes(data);
if (img.NumberOfComponents <= 0)
{
return(new float[0]);
}
var values = img.GetComponent(0);
return(Unpack(values));
}
//https://www.nuget.org/packages/CSJ2K/
public static string encodeJp2(String path)
{
try
{
BitmapImageCreator.Register();
Bitmap image = J2kImage.FromFile(path).As <Bitmap>();
return(ImageToBase64(image, System.Drawing.Imaging.ImageFormat.Jpeg));
}
catch (Exception ex)
{
Console.WriteLine("encodeJp2 '" + path + "' error: " + ex.Message);
return("");
}
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
// Perform any additional setup after loading the view, typically from a nib.
using (var stream = typeof(ViewController).Assembly.GetManifestResourceStream("CSJ2K.iOS.Test.Files.file2.jp2"))
{
var uiImage = J2kImage.FromStream(stream).As <UIImage>();
var imageView = new UIImageView(new CGRect(0, 0, 360, 480))
{
Image = uiImage
};
this.View.Add(imageView);
}
}
private void ButtonBase_OnClick(object sender, RoutedEventArgs e)
{
var dlg = new OpenFileDialog {
Filter = "JPEG 2000 files (*.jp2)|*.jp2", Multiselect = false
};
if (!dlg.ShowDialog().GetValueOrDefault())
{
return;
}
using (var stream = dlg.File.OpenRead())
{
var image = J2kImage.FromStream(stream).As <ImageSource>();
DecodedImage.Source = image;
ImageName.Text = dlg.File.Name;
}
}
public Image DecodeToImage(byte [] j2kData)
{
if (m_useCSJ2K)
{
return(J2kImage.FromBytes(j2kData));
}
// decode using OpenJpeg
ManagedImage mimage;
Image image;
if (OpenJPEG.DecodeToImage(j2kData, out mimage, out image))
{
mimage = null;
return(image);
}
return(null);
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
Bitmap bitmap;
using (var stream = new MemoryStream())
{
this.Assets.Open("file2.jp2").CopyTo(stream);
stream.Seek(0, SeekOrigin.Begin);
bitmap = J2kImage.FromStream(stream).As <Bitmap>();
}
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);
// Get our button from the layout resource,
// and attach an event to it
var imageView = FindViewById <ImageView>(Resource.Id.imageView1);
imageView.SetImageBitmap(bitmap);
}
protected override void AnalyzeFiles(string tempFolder, List <RepositoryFile> files)
{
foreach (var file in files)
{
var sourceFile = new FileInfo(Path.Combine(tempFolder, file.PhysicalName));
if (sourceFile.Exists)
{
Log.Information("FileName: {FullName}, detect and flag large dimensions", sourceFile.FullName);
switch (sourceFile.Extension.ToLower())
{
case ".pdf":
using (var pdfDocument = new Document(sourceFile.FullName))
{
if (!PdfManipulator.HasText(pdfDocument))
{
file.SkipOCR = ShouldSkipPdf(pdfDocument, sourceFile.FullName);
}
}
break;
case ".jp2":
var decodedImage = J2kImage.FromFile(sourceFile.FullName);
var jp2Bitmap = decodedImage.As <Bitmap>();
TestImageDimension(file, jp2Bitmap, sourceFile);
break;
case ".tif":
case ".tiff":
var tiffBitmap = Image.FromFile(sourceFile.FullName);
TestImageDimension(file, tiffBitmap, sourceFile);
break;
}
}
else
{
Log.Warning("Did not find file {FullName} while checking physical dimensions. ", sourceFile.FullName);
}
}
}
private async void ButtonBase_OnClick(object sender, RoutedEventArgs e)
{
var j2KExts = new[] { ".jp2", ".j2k", ".j2c" };
try
{
var files = await picker.PickMultipleFilesAsync();
if (files == null)
{
return;
}
var streams =
await
Task.WhenAll(
files.Select(async file => (await file.OpenAsync(FileAccessMode.Read)).AsStreamForRead()));
ImageSource image;
if (streams.Length == 1 &&
j2KExts.Any(ext => files[0].FileType.Equals(ext, StringComparison.OrdinalIgnoreCase)))
{
image = J2kImage.FromStream(streams[0]).As <ImageSource>();
}
else
{
// If not already encoded, encode before decoding
var bytes = J2kImage.ToBytes(J2kImage.CreateEncodableSource(streams));
image = J2kImage.FromBytes(bytes).As <ImageSource>();
}
DecodedImage.Source = image;
ImageName.Text = files[0].Path;
}
catch (Exception exc)
{
DecodedImage.Source = null;
ImageName.Text = "Could not display file, reason: " + exc.Message;
}
}
private static ParameterList ToParameterList(DicomJpeg2000Params parameters, bool decoder)
{
// These JPEG2000 codec parameters are not translated: EncodeSignedPixelValuesAsUnsigned, RateLevels,
// UpdatePhotometricInterpretation
var list =
new ParameterList(
decoder
? J2kImage.GetDefaultDecoderParameterList(null)
: J2kImage.GetDefaultEncoderParameterList(null));
var param = parameters ?? new DicomJpeg2000Params();
list["Mct"] = param.AllowMCT ? "on" : "off";
list["lossless"] = param.Irreversible ? "off" : "on";
list["verbose"] = param.IsVerbose ? "on" : "off";
if (param.Irreversible)
{
list["rate"] = param.Rate.ToString();
}
return(list);
}
public static Color4 GetAverageColor(UUID textureID, byte[] j2kData, out int width, out int height)
{
ulong r = 0;
ulong g = 0;
ulong b = 0;
ulong a = 0;
using (MemoryStream stream = new MemoryStream(j2kData))
{
try
{
int pixelBytes;
using (Bitmap bitmap = (Bitmap)J2kImage.FromStream(stream))
{
width = bitmap.Width;
height = bitmap.Height;
BitmapData bitmapData = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, bitmap.PixelFormat);
pixelBytes = (bitmap.PixelFormat == PixelFormat.Format24bppRgb) ? 3 : 4;
// Sum up the individual channels
unsafe
{
if (pixelBytes == 4)
{
for (int y = 0; y < height; y++)
{
byte *row = (byte *)bitmapData.Scan0 + (y * bitmapData.Stride);
for (int x = 0; x < width; x++)
{
b += row[x * pixelBytes + 0];
g += row[x * pixelBytes + 1];
r += row[x * pixelBytes + 2];
a += row[x * pixelBytes + 3];
}
}
}
else
{
for (int y = 0; y < height; y++)
{
byte *row = (byte *)bitmapData.Scan0 + (y * bitmapData.Stride);
for (int x = 0; x < width; x++)
{
b += row[x * pixelBytes + 0];
g += row[x * pixelBytes + 1];
r += row[x * pixelBytes + 2];
}
}
}
}
}
// Get the averages for each channel
const decimal OO_255 = 1m / 255m;
decimal totalPixels = (decimal)(width * height);
decimal rm = ((decimal)r / totalPixels) * OO_255;
decimal gm = ((decimal)g / totalPixels) * OO_255;
decimal bm = ((decimal)b / totalPixels) * OO_255;
decimal am = ((decimal)a / totalPixels) * OO_255;
if (pixelBytes == 3)
{
am = 1m;
}
return(new Color4((float)rm, (float)gm, (float)bm, (float)am));
}
catch (Exception ex)
{
m_log.WarnFormat(
"[WARP 3D IMAGE MODULE]: Error decoding JPEG2000 texture {0} ({1} bytes): {2}",
textureID, j2kData.Length, ex.Message);
width = 0;
height = 0;
return(new Color4(0.5f, 0.5f, 0.5f, 1.0f));
}
}
}
private bool DoJ2KDecode(UUID assetID, byte[] j2kData, bool useCSJ2K)
{
//int DecodeTime = 0;
//DecodeTime = Environment.TickCount;
OpenJPEG.J2KLayerInfo[] layers;
if (!TryLoadCacheForAsset(assetID, out layers))
{
if (j2kData == null || j2kData.Length == 0)
{
// Layer decoding completely failed. Guess at sane defaults for the layer boundaries
layers = CreateDefaultLayers(j2kData.Length);
// Notify Interested Parties
lock (m_notifyList)
{
if (m_notifyList.ContainsKey(assetID))
{
foreach (DecodedCallback d in m_notifyList[assetID].Where(d => d != null))
{
d.DynamicInvoke(assetID, layers);
}
m_notifyList.Remove(assetID);
}
}
return(false);
}
if (m_useCSJ2K)
{
try
{
List <int> layerStarts = J2kImage.GetLayerBoundaries(new MemoryStream(j2kData));
if (layerStarts != null && layerStarts.Count > 0)
{
layers = new OpenJPEG.J2KLayerInfo[layerStarts.Count];
for (int i = 0; i < layerStarts.Count; i++)
{
OpenJPEG.J2KLayerInfo layer = new OpenJPEG.J2KLayerInfo
{
Start = i == 0 ? 0 : layerStarts[i]
};
if (i == layerStarts.Count - 1)
{
layer.End = j2kData.Length;
}
else
{
layer.End = layerStarts[i + 1] - 1;
}
layers[i] = layer;
}
}
}
catch (Exception ex)
{
MainConsole.Instance.Warn("[J2KDecoderModule]: CSJ2K threw an exception decoding texture " +
assetID + ": " +
ex.Message);
}
}
else
{
int components;
if (!OpenJPEG.DecodeLayerBoundaries(j2kData, out layers, out components))
{
MainConsole.Instance.Warn("[J2KDecoderModule]: OpenJPEG failed to decode texture " + assetID);
}
}
if (layers == null || layers.Length == 0)
{
if (useCSJ2K == this.m_useCSJ2K)
{
MainConsole.Instance.Warn("[J2KDecoderModule]: Failed to decode layer data with (" +
(m_useCSJ2K ? "CSJ2K" : "OpenJPEG") + ") for texture " + assetID +
", length " +
j2kData.Length + " trying " + (!m_useCSJ2K ? "CSJ2K" : "OpenJPEG"));
DoJ2KDecode(assetID, j2kData, !m_useCSJ2K);
}
else
{
//Second attempt at decode with the other j2k decoder, give up
MainConsole.Instance.Warn("[J2KDecoderModule]: Failed to decode layer data (" +
(m_useCSJ2K ? "CSJ2K" : "OpenJPEG") + ") for texture " + assetID +
", length " +
j2kData.Length + " guessing sane defaults");
// Layer decoding completely failed. Guess at sane defaults for the layer boundaries
layers = CreateDefaultLayers(j2kData.Length);
// Notify Interested Parties
lock (m_notifyList)
{
if (m_notifyList.ContainsKey(assetID))
{
foreach (DecodedCallback d in m_notifyList[assetID].Where(d => d != null))
{
d.DynamicInvoke(assetID, layers);
}
m_notifyList.Remove(assetID);
}
}
return(false);
}
}
else //Don't save the corrupt texture!
{
// Cache Decoded layers
SaveFileCacheForAsset(assetID, layers);
}
}
// Notify Interested Parties
lock (m_notifyList)
{
if (m_notifyList.ContainsKey(assetID))
{
foreach (DecodedCallback d in m_notifyList[assetID].Where(d => d != null))
{
d.DynamicInvoke(assetID, layers);
}
m_notifyList.Remove(assetID);
}
}
return(true);
}
/// <summary>
/// Builds a composited terrain texture given the region texture
/// and heightmap settings
/// </summary>
/// <param name = "heightmap">Terrain heightmap</param>
/// <param name = "regionInfo">Region information including terrain texture parameters</param>
/// <returns>A composited 256x256 RGB texture ready for rendering</returns>
/// <remarks>
/// Based on the algorithm described at http://opensimulator.org/wiki/Terrain_Splatting
/// </remarks>
public static Bitmap Splat(ITerrainChannel heightmap, UUID[] textureIDs, float[] startHeights,
float[] heightRanges, Vector3d regionPosition, IAssetService assetService,
bool textureTerrain)
{
Debug.Assert(textureIDs.Length == 4);
Debug.Assert(startHeights.Length == 4);
Debug.Assert(heightRanges.Length == 4);
Bitmap[] detailTexture = new Bitmap[4];
if (textureTerrain)
{
// Swap empty terrain textureIDs with default IDs
for (int i = 0; i < textureIDs.Length; i++)
{
if (textureIDs[i] == UUID.Zero)
{
textureIDs[i] = DEFAULT_TERRAIN_DETAIL[i];
}
}
#region Texture Fetching
if (assetService != null)
{
for (int i = 0; i < 4; i++)
{
UUID cacheID = UUID.Combine(TERRAIN_CACHE_MAGIC, textureIDs[i]);
AssetBase asset = assetService.GetCached(cacheID.ToString());
if ((asset != null) && (asset.Data != null) && (asset.Data.Length != 0))
{
try
{
using (MemoryStream stream = new MemoryStream(asset.Data))
detailTexture[i] = (Bitmap)Image.FromStream(stream);
}
catch (Exception ex)
{
MainConsole.Instance.Warn("Failed to decode cached terrain texture " + cacheID +
" (textureID: " + textureIDs[i] + "): " + ex.Message);
}
}
if (detailTexture[i] == null)
{
// Try to fetch the original JPEG2000 texture, resize if needed, and cache as PNG
asset = assetService.Get(textureIDs[i].ToString());
if (asset != null)
{
try
{
detailTexture[i] = (Bitmap)J2kImage.FromBytes(asset.Data);
}
catch (Exception ex)
{
MainConsole.Instance.Warn("Failed to decode terrain texture " + asset.ID + ": " + ex.Message);
}
}
if (detailTexture[i] != null)
{
Bitmap bitmap = detailTexture[i];
// Make sure this texture is the correct size, otherwise resize
if (bitmap.Width != 256 || bitmap.Height != 256)
{
bitmap = ImageUtils.ResizeImage(bitmap, 256, 256);
}
// Save the decoded and resized texture to the cache
byte[] data;
using (MemoryStream stream = new MemoryStream())
{
bitmap.Save(stream, ImageFormat.Png);
data = stream.ToArray();
}
// Cache a PNG copy of this terrain texture
AssetBase newAsset = new AssetBase
{
Data = data,
Description = "PNG",
Flags =
AssetFlags.Collectable | AssetFlags.Temporary |
AssetFlags.Local,
ID = cacheID,
Name = String.Empty,
TypeString = "image/png"
};
newAsset.FillHash();
newAsset.ID = assetService.Store(newAsset);
}
}
}
}
#endregion Texture Fetching
}
// Fill in any missing textures with a solid color
for (int i = 0; i < 4; i++)
{
if (detailTexture[i] == null)
{
// Create a solid color texture for this layer
detailTexture[i] = new Bitmap(256, 256, PixelFormat.Format24bppRgb);
using (Graphics gfx = Graphics.FromImage(detailTexture[i]))
{
using (SolidBrush brush = new SolidBrush(DEFAULT_TERRAIN_COLOR[i]))
gfx.FillRectangle(brush, 0, 0, 256, 256);
}
}
else if (detailTexture[i].Width != 256 || detailTexture[i].Height != 256)
{
detailTexture[i] = ResizeBitmap(detailTexture[i], 256, 256);
}
}
#region Layer Map
float diff = (float)heightmap.Height / (float)Constants.RegionSize;
float[] layermap = new float[Constants.RegionSize * Constants.RegionSize];
for (float y = 0; y < heightmap.Height; y += diff)
{
for (float x = 0; x < heightmap.Height; x += diff)
{
float newX = x / diff;
float newY = y / diff;
float height = heightmap[(int)newX, (int)newY];
float pctX = newX / 255f;
float pctY = newY / 255f;
// Use bilinear interpolation between the four corners of start height and
// height range to select the current values at this position
float startHeight = ImageUtils.Bilinear(
startHeights[0],
startHeights[2],
startHeights[1],
startHeights[3],
pctX, pctY);
startHeight = Utils.Clamp(startHeight, 0f, 255f);
float heightRange = ImageUtils.Bilinear(
heightRanges[0],
heightRanges[2],
heightRanges[1],
heightRanges[3],
pctX, pctY);
heightRange = Utils.Clamp(heightRange, 0f, 255f);
// Generate two frequencies of perlin noise based on our global position
// The magic values were taken from http://opensimulator.org/wiki/Terrain_Splatting
Vector3 vec = new Vector3
(
((float)regionPosition.X + newX) * 0.20319f,
((float)regionPosition.Y + newY) * 0.20319f,
height * 0.25f
);
float lowFreq = Perlin.noise2(vec.X * 0.222222f, vec.Y * 0.222222f) * 6.5f;
float highFreq = Perlin.turbulence2(vec.X, vec.Y, 2f) * 2.25f;
float noise = (lowFreq + highFreq) * 2f;
// Combine the current height, generated noise, start height, and height range parameters, then scale all of it
float layer = ((height + noise - startHeight) / heightRange) * 4f;
if (Single.IsNaN(layer))
{
layer = 0f;
}
layermap[(int)(newY * Constants.RegionSize + newX)] = Utils.Clamp(layer, 0f, 3f);
}
}
#endregion Layer Map
#region Texture Compositing
Bitmap output = new Bitmap(256, 256, PixelFormat.Format24bppRgb);
BitmapData outputData = output.LockBits(new Rectangle(0, 0, 256, 256), ImageLockMode.WriteOnly,
PixelFormat.Format24bppRgb);
unsafe
{
// Get handles to all of the texture data arrays
BitmapData[] datas = new[]
{
detailTexture[0].LockBits(new Rectangle(0, 0, 256, 256),
ImageLockMode.ReadOnly,
detailTexture[0].PixelFormat),
detailTexture[1].LockBits(new Rectangle(0, 0, 256, 256),
ImageLockMode.ReadOnly,
detailTexture[1].PixelFormat),
detailTexture[2].LockBits(new Rectangle(0, 0, 256, 256),
ImageLockMode.ReadOnly,
detailTexture[2].PixelFormat),
detailTexture[3].LockBits(new Rectangle(0, 0, 256, 256),
ImageLockMode.ReadOnly,
detailTexture[3].PixelFormat)
};
int[] comps = new[]
{
(datas[0].PixelFormat == PixelFormat.Format32bppArgb) ? 4 : 3,
(datas[1].PixelFormat == PixelFormat.Format32bppArgb) ? 4 : 3,
(datas[2].PixelFormat == PixelFormat.Format32bppArgb) ? 4 : 3,
(datas[3].PixelFormat == PixelFormat.Format32bppArgb) ? 4 : 3
};
for (int y = 0; y < Constants.RegionSize; y++)
{
for (int x = 0; x < Constants.RegionSize; x++)
{
float layer = layermap[y * Constants.RegionSize + x];
// Select two textures
int l0 = (int)Math.Floor(layer);
int l1 = Math.Min(l0 + 1, 3);
byte *ptrA = (byte *)datas[l0].Scan0 + y * datas[l0].Stride + x * comps[l0];
byte *ptrB = (byte *)datas[l1].Scan0 + y * datas[l1].Stride + x * comps[l1];
byte *ptrO = (byte *)outputData.Scan0 + y * outputData.Stride + x * 3;
float aB = *(ptrA + 0);
float aG = *(ptrA + 1);
float aR = *(ptrA + 2);
float bB = *(ptrB + 0);
float bG = *(ptrB + 1);
float bR = *(ptrB + 2);
float layerDiff = layer - l0;
// Interpolate between the two selected textures
*(ptrO + 0) = (byte)Math.Floor(aB + layerDiff * (bB - aB));
*(ptrO + 1) = (byte)Math.Floor(aG + layerDiff * (bG - aG));
*(ptrO + 2) = (byte)Math.Floor(aR + layerDiff * (bR - aR));
}
}
for (int i = 0; i < 4; i++)
{
detailTexture[i].UnlockBits(datas[i]);
detailTexture[i].Dispose();
}
}
layermap = null;
output.UnlockBits(outputData);
// We generated the texture upside down, so flip it
output.RotateFlip(RotateFlipType.RotateNoneFlipY);
#endregion Texture Compositing
return(output);
}
public int CheckAssetFormat(ScriptInstance instance, LSLKey assetid)
{
lock (instance)
{
AssetServiceInterface assetService = instance.Part.ObjectGroup.AssetService;
AssetData asset;
if (!assetService.TryGetValue(assetid.AsUUID, out asset))
{
return(0);
}
switch (asset.Type)
{
case AssetType.Bodypart:
case AssetType.Clothing:
try
{
new Wearable(asset);
return(1);
}
catch
{
return(0);
}
case AssetType.Gesture:
try
{
new Gesture(asset);
return(1);
}
catch
{
return(0);
}
case AssetType.Landmark:
try
{
new Landmark(asset);
return(1);
}
catch
{
return(0);
}
case AssetType.Mesh:
try
{
new LLMesh(asset);
return(1);
}
catch
{
return(0);
}
case AssetType.Notecard:
try
{
new Notecard(asset);
return(1);
}
catch
{
return(0);
}
case AssetType.Object:
try
{
ObjectXML.FromXml(asset.InputStream, instance.Part.Owner);
return(1);
}
catch
{
return(0);
}
case AssetType.Texture:
try
{
using (J2kImage.FromStream(asset.InputStream))
{
}
return(1);
}
catch
{
return(0);
}
default:
m_Log.WarnFormat("Testing asset type {0} not supported", asset.Type.ToString());
return(0);
}
}
}
static void Main(string[] args)
{
// The library won't work without a license. You can get free time limited license
// at https://bitmiracle.com/jpeg2000/
LicenseManager.SetTrialLicense("contact [email protected] for a license");
const string OutputFileName = "output.tiff";
using (var image = new J2kImage(@"Sample data/map.jp2"))
{
using (Tiff outputTiff = Tiff.Open(OutputFileName, "w"))
{
// Tile size must be a multiple of 16.
int tileWidth = roundUp(Math.Min(2000, image.Width / 5), 16);
int tileHeight = roundUp(Math.Min(2000, image.Height / 5), 16);
outputTiff.SetField(TiffTag.IMAGEWIDTH, image.Width);
outputTiff.SetField(TiffTag.IMAGELENGTH, image.Height);
outputTiff.SetField(TiffTag.ORIENTATION, Orientation.TOPLEFT);
outputTiff.SetField(TiffTag.PLANARCONFIG, PlanarConfig.CONTIG);
outputTiff.SetField(TiffTag.TILEWIDTH, tileWidth);
outputTiff.SetField(TiffTag.TILELENGTH, tileHeight);
int tileStripSize = 0;
byte[] tileData = null;
var options = new J2kDecodingOptions();
for (int y = 0; y < image.Height; y += tileHeight)
{
for (int x = 0; x < image.Width; x += tileWidth)
{
const string TileFileName = "tile.tiff";
var imageData = image.DecodeArea(x, y, tileWidth, tileHeight, options);
imageData.Save(TileFileName, J2kOutputFormat.Tiff);
using (var tileTiff = Tiff.Open(TileFileName, "r"))
{
if (x == 0 && y == 0)
{
int samplesPerPixel = tileTiff.GetField(TiffTag.SAMPLESPERPIXEL)[0].ToInt();
outputTiff.SetField(TiffTag.SAMPLESPERPIXEL, samplesPerPixel);
int bitsPerSample = tileTiff.GetField(TiffTag.BITSPERSAMPLE)[0].ToInt();
outputTiff.SetField(TiffTag.BITSPERSAMPLE, bitsPerSample);
int photometric = tileTiff.GetField(TiffTag.PHOTOMETRIC)[0].ToInt();
outputTiff.SetField(TiffTag.PHOTOMETRIC, photometric);
tileStripSize = tileTiff.StripSize();
tileData = new byte[tileTiff.NumberOfStrips() * tileStripSize];
}
int offset = 0;
int stripCount = tileTiff.NumberOfStrips();
for (int i = 0; i < stripCount; ++i)
{
int bytesRead = tileTiff.ReadRawStrip(i, tileData, offset, tileData.Length - offset);
offset += bytesRead;
// pad the rightmost column of tiles if necessary
offset += (tileStripSize - bytesRead);
}
outputTiff.WriteTile(tileData, x, y, 0, 0);
}
Console.WriteLine($"Processed tile {{{x}, {y}, {imageData.Width}, {imageData.Height}}}");
}
}
}
}
Process.Start(OutputFileName);
}
internal static void Decode(
DicomPixelData oldPixelData,
DicomPixelData newPixelData,
DicomJpeg2000Params parameters)
{
var pixelCount = oldPixelData.Height * oldPixelData.Width;
if (newPixelData.PhotometricInterpretation == PhotometricInterpretation.YbrIct ||
newPixelData.PhotometricInterpretation == PhotometricInterpretation.YbrRct)
{
newPixelData.PhotometricInterpretation = PhotometricInterpretation.Rgb;
}
if (newPixelData.PhotometricInterpretation == PhotometricInterpretation.YbrFull422 ||
newPixelData.PhotometricInterpretation == PhotometricInterpretation.YbrPartial422)
{
newPixelData.PhotometricInterpretation = PhotometricInterpretation.YbrFull;
}
if (newPixelData.PhotometricInterpretation == PhotometricInterpretation.YbrFull)
{
newPixelData.PlanarConfiguration = PlanarConfiguration.Planar;
}
for (var frame = 0; frame < oldPixelData.NumberOfFrames; frame++)
{
var jpegData = oldPixelData.GetFrame(frame);
// Destination frame should be of even length
var frameSize = newPixelData.UncompressedFrameSize;
if ((frameSize & 1) == 1)
{
++frameSize;
}
var destArray = new byte[frameSize];
var image = J2kImage.FromBytes(jpegData.Data, ToParameterList(parameters, true));
if (image == null)
{
throw new InvalidOperationException("Error in JPEG 2000 code stream!");
}
for (var c = 0; c < image.NumberOfComponents; c++)
{
var comp = image.GetComponent(c);
var pos = newPixelData.PlanarConfiguration == PlanarConfiguration.Planar ? (c * pixelCount) : c;
var offset = newPixelData.PlanarConfiguration == PlanarConfiguration.Planar
? 1
: image.NumberOfComponents;
if (newPixelData.BytesAllocated == 1)
{
for (var p = 0; p < pixelCount; p++)
{
destArray[pos] = comp[p];
pos += offset;
}
}
#if SUPPORT16BIT
else if (newPixelData.BytesAllocated == 2)
{
for (var p = 0; p < pixelCount; p++)
{
destArray[2 * pos] = comp[p];
pos += offset;
}
}
#endif
else
{
throw new InvalidOperationException(
$"JPEG 2000 codec does not support Bits Allocated == {newPixelData.BitsAllocated}!");
}
}
newPixelData.AddFrame(new MemoryByteBuffer(destArray));
}
}
private static string GetLayerBoundariesHeader(UUID textureID, byte[] textureData)
{
OpenJPEG.J2KLayerInfo[] layers = null;
// Decode this texture and get layer boundaries before storing it
using (MemoryStream stream = new MemoryStream(textureData))
{
try
{
List <int> layerStarts = J2kImage.GetLayerBoundaries(stream);
if (layerStarts != null && layerStarts.Count > 0)
{
layers = new OpenJPEG.J2KLayerInfo[layerStarts.Count];
for (int i = 0; i < layerStarts.Count; i++)
{
OpenJPEG.J2KLayerInfo layer = new OpenJPEG.J2KLayerInfo();
if (i == 0)
{
layer.Start = 0;
}
else
{
layer.Start = layerStarts[i];
}
if (i == layerStarts.Count - 1)
{
layer.End = textureData.Length;
}
else
{
layer.End = layerStarts[i + 1] - 1;
}
layers[i] = layer;
}
}
}
catch (Exception ex)
{
m_log.WarnFormat("Error decoding layer boundaries from texture {0} ({1} bytes): {2}", textureID, textureData.Length, ex.Message);
layers = null;
}
}
if (layers != null)
{
StringBuilder header = new StringBuilder();
for (int i = 0; i < layers.Length; i++)
{
OpenJPEG.J2KLayerInfo layer = layers[i];
header.AppendFormat("{0}-{1};", layer.Start, layer.End);
}
return(header.ToString());
}
else
{
return(null);
}
}
// Decodes an image in memory to show it on the screen
private BitmapSource memDecode(byte[] bytes)
{
BitmapFrame frame;
WriteableBitmap output;
try
{
using (MemoryStream stream = new MemoryStream(bytes))
{
switch (termExt)
{
case "gif":
GifBitmapDecoder gifDecoder = new GifBitmapDecoder(stream,
BitmapCreateOptions.IgnoreColorProfile |
BitmapCreateOptions.PreservePixelFormat,
BitmapCacheOption.OnLoad);
frame = gifDecoder.Frames.First();
break;
case "png":
PngBitmapDecoder pngDecoder = new PngBitmapDecoder(stream,
BitmapCreateOptions.IgnoreColorProfile |
BitmapCreateOptions.PreservePixelFormat,
BitmapCacheOption.OnLoad);
frame = pngDecoder.Frames.First();
break;
case "tiff":
TiffBitmapDecoder tiffDecoder = new TiffBitmapDecoder(stream,
BitmapCreateOptions.IgnoreColorProfile |
BitmapCreateOptions.PreservePixelFormat,
BitmapCacheOption.OnLoad);
frame = tiffDecoder.Frames.First();
break;
case "jpg":
JpegBitmapDecoder jpgDecoder = new JpegBitmapDecoder(stream,
BitmapCreateOptions.IgnoreColorProfile |
BitmapCreateOptions.PreservePixelFormat,
BitmapCacheOption.OnLoad);
frame = jpgDecoder.Frames.First();
break;
case "jp2":
var j2kImg = J2kImage.FromStream(stream);
output = j2kImg.As <WriteableBitmap>();
frame = BitmapFrame.Create(output);
break;
default:
BmpBitmapDecoder bmpDecoder = new BmpBitmapDecoder(stream,
BitmapCreateOptions.IgnoreColorProfile |
BitmapCreateOptions.PreservePixelFormat,
BitmapCacheOption.OnLoad);
frame = bmpDecoder.Frames.First();
break;
}
if (bpp < 4)
{
frame = BitmapFrame.Create(new FormatConvertedBitmap(frame, PixelFormats.Rgb24, null, 0));
}
else
{
frame = BitmapFrame.Create(new FormatConvertedBitmap(frame, PixelFormats.Rgba64, null, 0));
}
frame.Freeze();
return(frame);
}
}
catch
{
output = new WriteableBitmap(400, 400, 72, 72, PixelFormats.Bgr24, null);
frame = BitmapFrame.Create(output);
return(frame);
}
}
internal static void Encode(
DicomPixelData oldPixelData,
DicomPixelData newPixelData,
DicomJpeg2000Params parameters)
{
if ((oldPixelData.PhotometricInterpretation == PhotometricInterpretation.YbrFull422) ||
(oldPixelData.PhotometricInterpretation == PhotometricInterpretation.YbrPartial422) ||
(oldPixelData.PhotometricInterpretation == PhotometricInterpretation.YbrPartial420))
{
throw new InvalidOperationException(
"Photometric Interpretation '" + oldPixelData.PhotometricInterpretation
+ "' not supported by JPEG 2000 encoder");
}
var jparams = parameters ?? new DicomJpeg2000Params();
jparams.Irreversible = newPixelData.IsLossy;
jparams.AllowMCT = oldPixelData.PhotometricInterpretation == PhotometricInterpretation.Rgb;
var pixelCount = oldPixelData.Height * oldPixelData.Width;
for (var frame = 0; frame < oldPixelData.NumberOfFrames; frame++)
{
var frameData = oldPixelData.GetFrame(frame);
var nc = oldPixelData.SamplesPerPixel;
var sgnd = oldPixelData.PixelRepresentation == PixelRepresentation.Signed &&
!jparams.EncodeSignedPixelValuesAsUnsigned;
var comps = new int[nc][];
for (var c = 0; c < nc; c++)
{
var comp = new int[pixelCount];
var pos = oldPixelData.PlanarConfiguration == PlanarConfiguration.Planar ? (c * pixelCount) : c;
var offset = oldPixelData.PlanarConfiguration == PlanarConfiguration.Planar ? 1 : nc;
if (oldPixelData.BytesAllocated == 1)
{
var data = frameData.Data;
if (sgnd)
{
if (oldPixelData.BitsStored < 8)
{
var sign = (byte)(1 << oldPixelData.HighBit);
var mask = (byte)(0xff >> (oldPixelData.BitsAllocated - oldPixelData.BitsStored));
for (var p = 0; p < pixelCount; p++)
{
var pixel = (sbyte)data[pos];
comp[p] = (pixel & sign) > 0 ? -(((-pixel) & mask) + 1) : pixel;
pos += offset;
}
}
else
{
for (var p = 0; p < pixelCount; p++)
{
comp[p] = (sbyte)data[pos];
pos += offset;
}
}
}
else
{
for (var p = 0; p < pixelCount; p++)
{
comp[p] = data[pos];
pos += offset;
}
}
}
else if (oldPixelData.BytesAllocated == 2)
{
if (sgnd)
{
if (oldPixelData.BitsStored < 16)
{
var frameData16 = new ushort[pixelCount];
Buffer.BlockCopy(frameData.Data, 0, frameData16, 0, (int)frameData.Size);
var sign = (ushort)(1 << oldPixelData.HighBit);
var mask = (ushort)(0xffff >> (oldPixelData.BitsAllocated - oldPixelData.BitsStored));
for (var p = 0; p < pixelCount; p++)
{
var pixel = frameData16[pos];
comp[p] = (pixel & sign) > 0 ? -(((-pixel) & mask) + 1) : pixel;
pos += offset;
}
}
else
{
var frameData16 = new short[pixelCount];
Buffer.BlockCopy(frameData.Data, 0, frameData16, 0, (int)frameData.Size);
for (var p = 0; p < pixelCount; p++)
{
comp[p] = frameData16[pos];
pos += offset;
}
}
}
else
{
var frameData16 = new ushort[pixelCount];
Buffer.BlockCopy(frameData.Data, 0, frameData16, 0, (int)frameData.Size);
for (var p = 0; p < pixelCount; p++)
{
comp[p] = frameData16[pos];
pos += offset;
}
}
}
else
{
throw new InvalidOperationException(
$"JPEG 2000 codec does not support Bits Allocated == {oldPixelData.BitsAllocated}");
}
comps[c] = comp;
}
var image = new PortableImageSource(
oldPixelData.Width,
oldPixelData.Height,
nc,
oldPixelData.BitsAllocated,
Enumerable.Repeat(sgnd, nc).ToArray(),
comps);
try
{
var cbuf = J2kImage.ToBytes(image, ToParameterList(jparams, false));
newPixelData.AddFrame(new MemoryByteBuffer(cbuf));
}
catch (Exception e)
{
throw new InvalidOperationException("Unable to JPEG 2000 encode image", e);
}
}
if (oldPixelData.PhotometricInterpretation == PhotometricInterpretation.Rgb)
{
newPixelData.PlanarConfiguration = PlanarConfiguration.Interleaved;
if (jparams.AllowMCT && jparams.UpdatePhotometricInterpretation)
{
if (newPixelData.IsLossy && jparams.Irreversible)
{
newPixelData.PhotometricInterpretation = PhotometricInterpretation.YbrIct;
}
else
{
newPixelData.PhotometricInterpretation = PhotometricInterpretation.YbrRct;
}
}
}
}
internal static void Decode(
DicomPixelData oldPixelData,
DicomPixelData newPixelData,
DicomJpeg2000Params parameters)
{
var pixelCount = oldPixelData.Height * oldPixelData.Width;
var bytesAllocated = newPixelData.BytesAllocated;
if (newPixelData.PhotometricInterpretation == PhotometricInterpretation.YbrIct ||
newPixelData.PhotometricInterpretation == PhotometricInterpretation.YbrRct)
{
newPixelData.PhotometricInterpretation = PhotometricInterpretation.Rgb;
}
if (newPixelData.PhotometricInterpretation == PhotometricInterpretation.YbrFull422 ||
newPixelData.PhotometricInterpretation == PhotometricInterpretation.YbrPartial422)
{
newPixelData.PhotometricInterpretation = PhotometricInterpretation.YbrFull;
}
if (newPixelData.PhotometricInterpretation == PhotometricInterpretation.YbrFull)
{
newPixelData.PlanarConfiguration = PlanarConfiguration.Planar;
}
for (var frame = 0; frame < oldPixelData.NumberOfFrames; frame++)
{
var jpegData = oldPixelData.GetFrame(frame);
// Destination frame should be of even length
var frameSize = newPixelData.UncompressedFrameSize;
if ((frameSize & 1) == 1)
{
++frameSize;
}
var destArray = new byte[frameSize];
var image = J2kImage.FromBytes(jpegData.Data, ToParameterList(parameters, true));
if (image == null)
{
throw new InvalidOperationException("Error in JPEG 2000 code stream!");
}
for (var c = 0; c < image.NumberOfComponents; c++)
{
// convert RGB BGR colorspace
var comp = image.GetComponent(image.NumberOfComponents - c - 1);
var pos = bytesAllocated * (newPixelData.PlanarConfiguration == PlanarConfiguration.Planar ? c * pixelCount : c);
var offset = bytesAllocated * (newPixelData.PlanarConfiguration == PlanarConfiguration.Planar
? 1
: image.NumberOfComponents);
if (bytesAllocated == 1)
{
if (newPixelData.PixelRepresentation == PixelRepresentation.Signed)
{
var sign = 1 << newPixelData.HighBit;
var mask = 0xff ^ sign;
for (var p = 0; p < pixelCount; p++)
{
int i = (i = comp[p] - sign) < 0 ? (i & mask) | sign : i & mask;
destArray[pos] = (byte)i;
pos += offset;
}
}
else
{
for (var p = 0; p < pixelCount; p++)
{
destArray[pos] = (byte)comp[p];
pos += offset;
}
}
}
else if (bytesAllocated == 2)
{
if (newPixelData.PixelRepresentation == PixelRepresentation.Signed)
{
var sign = 1 << newPixelData.HighBit;
var mask = 0xffff ^ sign;
for (var p = 0; p < pixelCount; p++)
{
int i = (i = comp[p] - sign) < 0 ? (i & mask) | sign : i & mask;
destArray[pos] = (byte)(i & 0xff);
destArray[pos + 1] = (byte)((i >> 8) & 0xff);
pos += offset;
}
}
else
{
for (var p = 0; p < pixelCount; p++)
{
var i = comp[p];
destArray[pos] = (byte)(i & 0xff);
destArray[pos + 1] = (byte)((i >> 8) & 0xff);
pos += offset;
}
}
}
else
{
throw new InvalidOperationException(
$"JPEG 2000 codec does not support Bits Allocated == {newPixelData.BitsAllocated}!");
}
}
newPixelData.AddFrame(new MemoryByteBuffer(destArray));
}
}
