// 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)); } }