Exemplo n.º 1
0
        private static void SaveFromMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream, Bitmap.CompressFormat imageFormat)
        {
            var colors = pixelBuffers[0].GetPixels<int>();

            using (var bitmap = Bitmap.CreateBitmap(description.Width, description.Height, Bitmap.Config.Argb8888))
            {
                var pixelData = bitmap.LockPixels();
                var sizeToCopy = colors.Length * sizeof(int);

                unsafe
                {
                    fixed (int* pSrc = colors)
                    {
                        // Copy the memory
                        if (description.Format == PixelFormat.R8G8B8A8_UNorm || description.Format == PixelFormat.R8G8B8A8_UNorm_SRgb)
                        {
                            CopyMemoryBGRA(pixelData, (IntPtr)pSrc, sizeToCopy);
                        }
                        else if (description.Format == PixelFormat.B8G8R8A8_UNorm || description.Format == PixelFormat.B8G8R8A8_UNorm_SRgb)
                        {
                            Utilities.CopyMemory(pixelData, (IntPtr)pSrc, sizeToCopy);
                        }
                        else
                        {
                            throw new NotSupportedException(string.Format("Pixel format [{0}] is not supported", description.Format));
                        }
                    }
                }

                bitmap.UnlockPixels();
                bitmap.Compress(imageFormat, 100, imageStream);
            }
        }
Exemplo n.º 2
0
        public static unsafe Image LoadFromMemory(IntPtr pSource, int size, bool makeACopy, GCHandle? handle)
        {
            var stream = new BinarySerializationReader(new NativeMemoryStream((byte*)pSource, size));

            // Read and check magic code
            var magicCode = stream.ReadUInt32();
            if (magicCode != MagicCode)
                return null;

            // Read header
            var imageDescription = new ImageDescription();
            imageDescriptionSerializer.Serialize(ref imageDescription, ArchiveMode.Deserialize, stream);

            if (makeACopy)
            {
                var buffer = Utilities.AllocateMemory(size);
                Utilities.CopyMemory(buffer, pSource, size);
                pSource = buffer;
                makeACopy = false;
            }

            var image = new Image(imageDescription, pSource, 0, handle, !makeACopy);

            var totalSizeInBytes = stream.ReadInt32();
            if (totalSizeInBytes != image.TotalSizeInBytes)
                throw new InvalidOperationException("Image size is different than expected.");

            // Read image data
            stream.Serialize(image.DataPointer, image.TotalSizeInBytes);

            return image;
        }
Exemplo n.º 3
0
        private static void SaveFromMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream, ImageFormat imageFormat)
        {
            using (var bitmap = new Bitmap(description.Width, description.Height))
            {
                var sourceArea = new Rectangle(0, 0, bitmap.Width, bitmap.Height);

                // Lock System.Drawing.Bitmap
                var bitmapData = bitmap.LockBits(sourceArea, ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb);

                try
                {
                    // Copy memory
                    if (description.Format == PixelFormat.R8G8B8A8_UNorm || description.Format == PixelFormat.R8G8B8A8_UNorm_SRgb)
                        CopyMemoryBGRA(bitmapData.Scan0, pixelBuffers[0].DataPointer, pixelBuffers[0].BufferStride);
                    else if (description.Format == PixelFormat.B8G8R8A8_UNorm || description.Format == PixelFormat.B8G8R8A8_UNorm_SRgb)
                        Utilities.CopyMemory(bitmapData.Scan0, pixelBuffers[0].DataPointer, pixelBuffers[0].BufferStride);
                    else
                        throw new NotSupportedException(string.Format("Pixel format [{0}] is not supported", description.Format));
                }
                finally
                {
                    bitmap.UnlockBits(bitmapData);
                }

                // Save
                bitmap.Save(imageStream, imageFormat);
            }
        }
Exemplo n.º 4
0
        public void Read(BinaryReader reader)
        {
            TestName = reader.ReadString();
            CurrentVersion = reader.ReadString();
            Frame = reader.ReadString();

            // Read image header
            var width = reader.ReadInt32();
            var height = reader.ReadInt32();
            var format = (PixelFormat)reader.ReadInt32();
            var textureSize = reader.ReadInt32();

            // Read image data
            var imageData = new byte[textureSize];
            using (var lz4Stream = new LZ4Stream(reader.BaseStream, CompressionMode.Decompress, false, textureSize))
            {
                if (lz4Stream.Read(imageData, 0, textureSize) != textureSize)
                    throw new EndOfStreamException("Unexpected end of stream");
            }

            var pinnedImageData = GCHandle.Alloc(imageData, GCHandleType.Pinned);
            var description = new ImageDescription
            {
                Dimension = TextureDimension.Texture2D,
                Width = width,
                Height = height,
                ArraySize = 1,
                Depth = 1,
                Format = format,
                MipLevels = 1,
            };

            Image = Image.New(description, pinnedImageData.AddrOfPinnedObject(), 0, pinnedImageData, false);
        }
 private static void SaveFromMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream, Bitmap.CompressFormat imageFormat)
 {
     var colors = pixelBuffers[0].GetPixels<int>();
     using (var bitmap = Bitmap.CreateBitmap(colors, description.Width, description.Height, Bitmap.Config.Argb8888))
     {
         bitmap.Compress(imageFormat, 0, imageStream);
     }
 }
Exemplo n.º 6
0
        public static void SaveFromMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, System.IO.Stream imageStream)
        {
            var stream = new BinarySerializationWriter(imageStream);

            // Write magic code
            stream.Write(MagicCode);

            // Write image header
            imageDescriptionSerializer.Serialize(ref description, ArchiveMode.Serialize, stream);

            // Write total size
            int totalSize = 0;
            foreach (var pixelBuffer in pixelBuffers)
                totalSize += pixelBuffer.BufferStride;

            stream.Write(totalSize);

            // Write buffers contiguously
            foreach (var pixelBuffer in pixelBuffers)
            {
                stream.Serialize(pixelBuffer.DataPointer, pixelBuffer.BufferStride);
            }
        }
Exemplo n.º 7
0
        /// <summary>
        /// Determines number of image array entries and pixel size.
        /// </summary>
        /// <param name="imageDesc">Description of the image to create.</param>
        /// <param name="pitchFlags">Pitch flags.</param>
        /// <param name="bufferCount">Output number of mipmap.</param>
        /// <param name="pixelSizeInBytes">Output total size to allocate pixel buffers for all images.</param>
        private static List<int> CalculateImageArray( ImageDescription imageDesc, PitchFlags pitchFlags, out int bufferCount, out int pixelSizeInBytes)
        {
            pixelSizeInBytes = 0;
            bufferCount = 0;

            var mipmapToZIndex = new List<int>();

            for (int j = 0; j < imageDesc.ArraySize; j++)
            {
                int w = imageDesc.Width;
                int h = imageDesc.Height;
                int d = imageDesc.Depth; 
                
                for (int i = 0; i < imageDesc.MipLevels; i++)
                {
                    int rowPitch, slicePitch;
                    int widthPacked;
                    int heightPacked;
                    ComputePitch(imageDesc.Format, w, h, out rowPitch, out slicePitch, out widthPacked, out heightPacked, pitchFlags);

                    // Store the number of z-slicec per miplevels
                    if ( j == 0)
                        mipmapToZIndex.Add(bufferCount);

                    // Keep a trace of indices for the 1st array size, for each mip levels
                    pixelSizeInBytes += d * slicePitch;
                    bufferCount += d;

                    if (h > 1)
                        h >>= 1;

                    if (w > 1)
                        w >>= 1;

                    if (d > 1)
                        d >>= 1;
                }

                // For the last mipmaps, store just the number of zbuffers in total
                if (j == 0)
                    mipmapToZIndex.Add(bufferCount);
            }
            return mipmapToZIndex;
        }
Exemplo n.º 8
0
 public void SetIcon(ImageDescription icon)
 {
     // TODO
 }
Exemplo n.º 9
0
        public override object ConvertToBitmap(ImageDescription idesc, double scaleFactor, XD.ImageFormat format)
        {
            var image = (GdiImage)idesc.Backend;

            return(image.ConvertToBitmap(idesc.Size.Width, idesc.Size.Height, scaleFactor, format));
        }
Exemplo n.º 10
0
        internal static MipMapDescription[] CalculateMipMapDescription(ImageDescription metadata, PitchFlags cpFlags, out int nImages, out int pixelSize)
        {
            pixelSize = 0;
            nImages = 0;

            int w = metadata.Width;
            int h = metadata.Height;
            int d = metadata.Depth;

            var mipmaps = new MipMapDescription[metadata.MipLevels];

            for (int level = 0; level < metadata.MipLevels; ++level)
            {
                int rowPitch, slicePitch;
                int widthPacked;
                int heightPacked;
                ComputePitch(metadata.Format, w, h, out rowPitch, out slicePitch, out widthPacked, out heightPacked, PitchFlags.None);

                mipmaps[level] = new MipMapDescription(
                    w,
                    h,
                    d,
                    rowPitch,
                    slicePitch,
                    widthPacked,
                    heightPacked
                    );

                pixelSize += d * slicePitch;
                nImages += d;

                if (h > 1)
                    h >>= 1;

                if (w > 1)
                    w >>= 1;

                if (d > 1)
                    d >>= 1;
            }
            return mipmaps;
        }
Exemplo n.º 11
0
        /// <summary>
        /// Saves this instance to a stream.
        /// </summary>
        /// <param name="pixelBuffers">The buffers to save.</param>
        /// <param name="count">The number of buffers to save.</param>
        /// <param name="description">Global description of the buffer.</param>
        /// <param name="imageStream">The destination stream.</param>
        /// <param name="fileType">Specify the output format.</param>
        /// <remarks>This method support the following format: <c>dds, bmp, jpg, png, gif, tiff, wmp, tga</c>.</remarks>
        internal static void Save(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream, ImageFileType fileType)
        {
            foreach (var loadSaveDelegate in loadSaveDelegates)
            {
                if (loadSaveDelegate.FileType == fileType)
                {
                    loadSaveDelegate.Save(pixelBuffers, count, description, imageStream);
                    return;
                }

            }
            throw new NotSupportedException("This file format is not yet implemented.");
        }
Exemplo n.º 12
0
 /// <summary>
 /// Initializes a new instance of the <see cref="Image" /> class.
 /// </summary>
 /// <param name="description">The image description.</param>
 /// <param name="dataPointer">The pointer to the data buffer.</param>
 /// <param name="offset">The offset from the beginning of the data buffer.</param>
 /// <param name="handle">The handle (optionnal).</param>
 /// <param name="bufferIsDisposable">if set to <c>true</c> [buffer is disposable].</param>
 /// <exception cref="System.InvalidOperationException">If the format is invalid, or width/height/depth/arraysize is invalid with respect to the dimension.</exception>
 internal unsafe Image(ImageDescription description, IntPtr dataPointer, int offset, GCHandle? handle, bool bufferIsDisposable, PitchFlags pitchFlags = PitchFlags.None, int rowStride = 0)
 {
     Initialize(description, dataPointer, offset, handle, bufferIsDisposable, pitchFlags, rowStride);
 }
Exemplo n.º 13
0
 public static void SavePngFromMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream)
 {
     SaveFromMemory(pixelBuffers, count, description, imageStream, Bitmap.CompressFormat.Png);
 }
Exemplo n.º 14
0
 public void SetImage(ImageDescription image)
 {
     item.Image = image.ToNSImage();
 }
Exemplo n.º 15
0
 public Gdk.Pixbuf GetBestFrame(ApplicationContext actx, Gtk.Widget w, ImageDescription idesc, bool forceExactSize)
 {
     return(GetBestFrame(actx, Util.GetScaleFactor(w), idesc, forceExactSize));
 }
Exemplo n.º 16
0
        public void SetContent(string label, bool useMnemonic, ImageDescription image, ContentPosition position)
        {
            Widget.UseUnderline = useMnemonic;
            this.image          = image;

            if (label != null && label.Length == 0)
            {
                label = null;
            }

            Button b = (Button)Frontend;

            if (label != null && image.Backend == null && b.Type == ButtonType.Normal)
            {
                Widget.Label = label;
                return;
            }

            if (b.Type == ButtonType.Disclosure)
            {
                Widget.Label = null;
                Widget.Image = new Gtk.Arrow(Gtk.ArrowType.Down, Gtk.ShadowType.Out);
                Widget.Image.ShowAll();
                return;
            }

            Gtk.Widget contentWidget = null;

            Gtk.Widget imageWidget = null;
            if (image.Backend != null)
            {
                imageWidget = new ImageBox(ApplicationContext, image.WithDefaultSize(Gtk.IconSize.Button));
            }

            if (label != null && imageWidget == null)
            {
                contentWidget = new Gtk.Label(label)
                {
                    UseUnderline = useMnemonic
                };
            }
            else if (label == null && imageWidget != null)
            {
                contentWidget = imageWidget;
            }
            else if (label != null && imageWidget != null)
            {
                Gtk.Box box = position == ContentPosition.Left || position == ContentPosition.Right ? (Gtk.Box) new Gtk.HBox(false, 3) : (Gtk.Box) new Gtk.VBox(false, 3);
                var     lab = new Gtk.Label(label)
                {
                    UseUnderline = useMnemonic
                };

                if (position == ContentPosition.Left || position == ContentPosition.Top)
                {
                    box.PackStart(imageWidget, false, false, 0);
                    box.PackStart(lab, false, false, 0);
                }
                else
                {
                    box.PackStart(lab, false, false, 0);
                    box.PackStart(imageWidget, false, false, 0);
                }

                contentWidget = box;
            }
            if (b.Type == ButtonType.DropDown)
            {
                if (contentWidget != null)
                {
                    Gtk.HBox box = new Gtk.HBox(false, 3);
                    box.PackStart(contentWidget, true, true, 3);
                    box.PackStart(new Gtk.VSeparator(), true, true, 0);
                    box.PackStart(new Gtk.Arrow(Gtk.ArrowType.Down, Gtk.ShadowType.Out), false, false, 0);
                    contentWidget = box;
                }
                else
                {
                    contentWidget = new Gtk.Arrow(Gtk.ArrowType.Down, Gtk.ShadowType.Out);
                }
            }
            if (contentWidget != null)
            {
                contentWidget.ShowAll();
                Widget.Label = null;
                Widget.Image = contentWidget;
            }
            else
            {
                Widget.Label = null;
            }
        }
Exemplo n.º 17
0
        public void Draw(ApplicationContext actx, SWM.DrawingContext dc, double scaleFactor, double x, double y, ImageDescription idesc)
        {
            if (drawCallback != null)
            {
                DrawingContext c = new DrawingContext(dc, scaleFactor);
                actx.InvokeUserCode(delegate {
                    drawCallback(c, new Rectangle(x, y, idesc.Size.Width, idesc.Size.Height), idesc, actx.Toolkit);
                });
            }
            else
            {
                if (idesc.Alpha < 1)
                {
                    dc.PushOpacity(idesc.Alpha);
                }

                var f        = GetBestFrame(actx, scaleFactor, idesc.Size.Width, idesc.Size.Height, false);
                var bmpImage = f as BitmapSource;

                // When an image is a single bitmap that doesn't have the same intrinsic size as the drawing size, dc.DrawImage makes a very poor job of down/up scaling it.
                // Thus we handle this manually by using a TransformedBitmap to handle the conversion in a better way when it's needed.

                var scaledWidth  = idesc.Size.Width * scaleFactor;
                var scaledHeight = idesc.Size.Height * scaleFactor;
                if (bmpImage != null && (Math.Abs(bmpImage.PixelHeight - scaledHeight) > 0.001 || Math.Abs(bmpImage.PixelWidth - scaledWidth) > 0.001))
                {
                    f = new TransformedBitmap(bmpImage, new ScaleTransform(scaledWidth / bmpImage.PixelWidth, scaledHeight / bmpImage.PixelHeight));
                }

                dc.DrawImage(f, new Rect(x, y, idesc.Size.Width, idesc.Size.Height));

                if (idesc.Alpha < 1)
                {
                    dc.Pop();
                }
            }
        }
Exemplo n.º 18
0
        public override object ConvertToBitmap(ImageDescription idesc, double scaleFactor, Xwt.Drawing.ImageFormat format)
        {
            var wpfImage = (WpfImage)idesc.Backend;

            return(new WpfImage(wpfImage.GetBestFrame(ApplicationContext, scaleFactor, idesc, true)));
        }
        private static void SaveFromMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream, ImageFormat imageFormat)
        {
#if (SILICONSTUDIO_XENKO_UI_WINFORMS || SILICONSTUDIO_XENKO_UI_WPF)
            using (var bitmap = new Bitmap(description.Width, description.Height))
            {
                var sourceArea = new Rectangle(0, 0, bitmap.Width, bitmap.Height);

                // Lock System.Drawing.Bitmap
                var bitmapData = bitmap.LockBits(sourceArea, ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb);

                try
                {
                    // Copy memory
                    if (description.Format == PixelFormat.R8G8B8A8_UNorm || description.Format == PixelFormat.R8G8B8A8_UNorm_SRgb)
                        CopyMemoryBGRA(bitmapData.Scan0, pixelBuffers[0].DataPointer, pixelBuffers[0].BufferStride);
                    else if (description.Format == PixelFormat.B8G8R8A8_UNorm || description.Format == PixelFormat.B8G8R8A8_UNorm_SRgb)
                        Utilities.CopyMemory(bitmapData.Scan0, pixelBuffers[0].DataPointer, pixelBuffers[0].BufferStride);
                    else
                    {
                        // TODO Ideally we will want to support grayscale images, but the SpriteBatch can only render RGBA for now
                        //  so convert the grayscale image as an RGBA and save it
                        CopyMemoryRRR1(bitmapData.Scan0, pixelBuffers[0].DataPointer, pixelBuffers[0].BufferStride);
                    }
                }
                finally
                {
                    bitmap.UnlockBits(bitmapData);
                }

                // Save
                bitmap.Save(imageStream, imageFormat);
            }
#else
            // FIXME: Manu: Currently SDL can only save to BMP or PNG.
#endif
        }
Exemplo n.º 20
0
        public override object ConvertToBitmap(ImageDescription idesc, double scaleFactor, ImageFormat format)
        {
            double width       = idesc.Size.Width;
            double height      = idesc.Size.Height;
            int    pixelWidth  = (int)(width * scaleFactor);
            int    pixelHeight = (int)(height * scaleFactor);

            if (idesc.Backend is CustomImage)
            {
                var flags = CGBitmapFlags.ByteOrderDefault;
                int bytesPerRow;
                switch (format)
                {
                case ImageFormat.ARGB32:
                    bytesPerRow = pixelWidth * 4;
                    flags      |= CGBitmapFlags.PremultipliedFirst;
                    break;

                case ImageFormat.RGB24:
                    bytesPerRow = pixelWidth * 3;
                    flags      |= CGBitmapFlags.None;
                    break;

                default:
                    throw new NotImplementedException("ImageFormat: " + format.ToString());
                }

                var bmp = new CGBitmapContext(IntPtr.Zero, pixelWidth, pixelHeight, 8, bytesPerRow, Util.DeviceRGBColorSpace, flags);
                bmp.TranslateCTM(0, pixelHeight);
                bmp.ScaleCTM((float)scaleFactor, (float)-scaleFactor);

                var ctx = new CGContextBackend {
                    Context = bmp,
                    Size    = new CGSize((nfloat)width, (nfloat)height),
                    InverseViewTransform = bmp.GetCTM().Invert(),
                    ScaleFactor          = scaleFactor
                };

                var ci = (CustomImage)idesc.Backend;
                ci.DrawInContext(ctx, idesc);

                var img       = new NSImage(((CGBitmapContext)bmp).ToImage(), new CGSize(pixelWidth, pixelHeight));
                var imageData = img.AsTiff();
                var imageRep  = (NSBitmapImageRep)NSBitmapImageRep.ImageRepFromData(imageData);
                var im        = new NSImage();
                im.AddRepresentation(imageRep);
                im.Size = new CGSize((nfloat)width, (nfloat)height);
                bmp.Dispose();
                return(im);
            }
            else
            {
                NSImage          img    = (NSImage)idesc.Backend;
                NSBitmapImageRep bitmap = img.Representations().OfType <NSBitmapImageRep> ().FirstOrDefault();
                if (bitmap == null)
                {
                    var imageData = img.AsTiff();
                    var imageRep  = (NSBitmapImageRep)NSBitmapImageRep.ImageRepFromData(imageData);
                    var im        = new NSImage();
                    im.AddRepresentation(imageRep);
                    im.Size = new CGSize((nfloat)width, (nfloat)height);
                    return(im);
                }
                return(idesc.Backend);
            }
        }
Exemplo n.º 21
0
 public ImageBox(ApplicationContext actx, ImageDescription img) : this(actx)
 {
     Image = img;
 }
Exemplo n.º 22
0
        public void trainNestedAlgorithm(ContextualMemoryNestedAlgorithm nestedAlgorithm)
        {
            BlackAndWhiteConverter blackAndWhiteConverter = new BlackAndWhiteConverter(1);
            //BlackAndWhiteConverter blackAndWhiteConverter = new BlackAndWhiteConverter(63);

            List <String> fileList = new List <string>(benchmark.getTrainingFilesPathList());

            List <ContextualMemoryNestedAlgorithmLayer> layers = nestedAlgorithm.getLayers();

            for (int layerIndex = 0; layerIndex < layers.Count; layerIndex++)
            {
                ContextualMemoryNestedAlgorithmLayer layer = layers[layerIndex];
                layer.initialize();
                Console.WriteLine("Layer: " + (layerIndex + 1) + "/" + layers.Count);

                EdgeDetectionAlgorithm algorithm = layer.algorithm;

                DateTime trainingStart      = DateTime.Now;
                float    totalLoss          = 0;
                int      totalNumberOfFiles = numberOfTrainingSetPasses * fileList.Count;
                int      totalIndex         = 0;
                for (int pass = 0; pass < numberOfTrainingSetPasses; pass++)
                {
                    ListUtils.Shuffle(fileList);
                    int      index             = 1;
                    float    totalPassLoss     = 0;
                    DateTime trainingPassStart = DateTime.Now;
                    foreach (string trainingFileName in fileList)
                    {
                        DateTime start = DateTime.Now;
                        Console.WriteLine("Pass: "******"/" + numberOfTrainingSetPasses + ", " + index + "/" + fileList.Count + " Training file: " + Path.GetFileName(trainingFileName));

                        ImageDescription inputImage = ImageFileHandler.loadFromPath(trainingFileName);
                        int layerResizeFactor       = layer.resizeFactor;

                        ImageDescription computedImage = null;
                        if (layerIndex > 0)
                        {
                            List <ImageDescription> computedImages = nestedAlgorithm.computeImageForLayers(inputImage, layerIndex);
                            computedImage = computedImages[layerIndex - 1];
                        }

                        ImageDescription inputImageGroundTruth = ImageFileHandler.loadFromPath(benchmark.getTrainingFileGroundTruth(trainingFileName));
                        inputImageGroundTruth = blackAndWhiteConverter.filter(inputImageGroundTruth);

                        ImageDescription newInputImage            = null;
                        ImageDescription newInputImageGroundTruth = null;

                        ResizeFilter resizeGrayscale = new ResizeFilter(inputImage.sizeX / layerResizeFactor, inputImage.sizeY / layerResizeFactor, ImageDescriptionUtil.grayscaleChannel);
                        ResizeFilter resizeColor     = new ResizeFilter(inputImage.sizeX / layerResizeFactor, inputImage.sizeY / layerResizeFactor, ImageDescriptionUtil.colorChannels);

                        if (layerResizeFactor == 1)
                        {
                            newInputImage            = inputImage;
                            newInputImageGroundTruth = inputImageGroundTruth;
                        }
                        else
                        {
                            newInputImage            = resizeColor.filter(inputImage);
                            newInputImageGroundTruth = resizeGrayscale.filter(inputImageGroundTruth);
                        }
                        if (layerIndex > 0)
                        {
                            ImageDescription resizedComputed = resizeGrayscale.filter(computedImage);
                            newInputImage.setColorChannel(ColorChannelEnum.Layer, resizedComputed.gray);
                        }

                        float loss = algorithm.train(newInputImage, newInputImageGroundTruth);

                        totalLoss     += loss;
                        totalPassLoss += loss;
                        index++;
                        totalIndex++;

                        double timeElapsed      = (DateTime.Now - start).TotalSeconds;
                        double timeElapsedSoFar = (DateTime.Now - trainingStart).TotalSeconds;
                        double estimatedTime    = (timeElapsedSoFar / totalIndex) * (totalNumberOfFiles - totalIndex);
                        Console.WriteLine("Loss: " + loss.ToString("0.00") + " Time: " + timeElapsed.ToString("0.00") + "s Time elapsed: "
                                          + timeElapsedSoFar.ToString("0.00") + "s ETA: " + estimatedTime.ToString("0.00") + "s");
                    }
                    double tariningPassTimeElapsed = (DateTime.Now - trainingPassStart).TotalSeconds;
                    Console.WriteLine("Pass took " + tariningPassTimeElapsed.ToString("0.00") + " sec. Pass loss: " + totalPassLoss.ToString("0.00")
                                      + " Avg loss: " + (totalPassLoss / (fileList.Count)).ToString("0.00"));
                }
                double totalTimeElapsed = (DateTime.Now - trainingStart).TotalSeconds;
                Console.WriteLine("Training took " + totalTimeElapsed.ToString("0.00") + " sec. Total loss: " + totalLoss.ToString("0.00")
                                  + " Avg loss: " + (totalLoss / (totalNumberOfFiles)).ToString("0.00"));
            }

            Console.WriteLine("Training blender");

            DateTime     blenderTrainingStart      = DateTime.Now;
            float        blenderTotalLoss          = 0;
            int          blenderTotalNumberOfFiles = /* numberOfTrainingSetPasses * */ fileList.Count;
            int          blenderTotalIndex         = 0;
            ImageBlender blender = nestedAlgorithm.getImageBlender();
            //for (int pass = 0; pass < numberOfTrainingSetPasses; pass++)
            {
                ListUtils.Shuffle(fileList);
                int      index             = 1;
                float    totalPassLoss     = 0;
                DateTime trainingPassStart = DateTime.Now;
                foreach (string trainingFileName in fileList)
                {
                    DateTime start = DateTime.Now;
                    //Console.Write("Pass: "******"/" + numberOfTrainingSetPasses + ", ");
                    Console.WriteLine(index + "/" + fileList.Count + " Training file: " + Path.GetFileName(trainingFileName));

                    ImageDescription        inputImage     = ImageFileHandler.loadFromPath(trainingFileName);
                    List <ImageDescription> computedImages = nestedAlgorithm.computeImageForLayers(inputImage, layers.Count);

                    ImageDescription inputImageGroundTruth = ImageFileHandler.loadFromPath(benchmark.getTrainingFileGroundTruth(trainingFileName));
                    inputImageGroundTruth = blackAndWhiteConverter.filter(inputImageGroundTruth);

                    float blenderLoss = blender.train(computedImages, inputImageGroundTruth);

                    blenderTotalLoss += blenderLoss;
                    totalPassLoss    += blenderLoss;
                    index++;
                    blenderTotalIndex++;

                    double timeElapsed      = (DateTime.Now - start).TotalSeconds;
                    double timeElapsedSoFar = (DateTime.Now - blenderTrainingStart).TotalSeconds;
                    double estimatedTime    = (timeElapsedSoFar / blenderTotalIndex) * (blenderTotalNumberOfFiles - blenderTotalIndex);
                    Console.WriteLine("Loss: " + blenderLoss.ToString("0.00") + " Time: " + timeElapsed.ToString("0.00") + "s Time elapsed: "
                                      + timeElapsedSoFar.ToString("0.00") + "s ETA: " + estimatedTime.ToString("0.00") + "s");
                }
                //double tariningPassTimeElapsed = (DateTime.Now - trainingPassStart).TotalSeconds;
                //Console.WriteLine("Pass took " + tariningPassTimeElapsed.ToString("0.00") + " sec. Pass loss: " + totalPassLoss.ToString("0.00")
                //+ " Avg loss: " + (totalPassLoss / (fileList.Count)).ToString("0.00"));
            }
            double blenderTotalTimeElapsed = (DateTime.Now - blenderTrainingStart).TotalSeconds;

            Console.WriteLine("Training took " + blenderTotalTimeElapsed.ToString("0.00") + " sec. Total loss: " + blenderTotalLoss.ToString("0.00")
                              + " Avg loss: " + (blenderTotalLoss / (blenderTotalNumberOfFiles)).ToString("0.00"));
        }
Exemplo n.º 23
0
 public void SetIcon(ImageDescription image)
 {
     throw new NotImplementedException();
 }
Exemplo n.º 24
0
        public void test(EdgeDetectionAlgorithm algorithm)
        {
            DateTime      testingStart = DateTime.Now;
            List <String> fileList     = benchmark.getTestFilesPathList();
            int           index        = 1;

            string outputDirectory = null;

            foreach (string testFileName in fileList)
            {
                DateTime start = DateTime.Now;
                outputDirectory = Path.GetDirectoryName(benchmark.getTestFileOutputPathWithoutExtension(testFileName));
                if (!Directory.Exists(outputDirectory))
                {
                    Directory.CreateDirectory(outputDirectory);
                }
                Console.WriteLine(index + "/" + fileList.Count + " Testing file: " + Path.GetFileName(testFileName));
                ImageDescription inputImage  = ImageFileHandler.loadFromPath(testFileName);
                ImageDescription outputImage = algorithm.test(inputImage);
                ImageFileHandler.saveToPath(outputImage, benchmark.getTestFileOutputPathWithoutExtension(testFileName), outputFileExtension);


                double timeElapsed      = (DateTime.Now - start).TotalSeconds;
                double timeElapsedSoFar = (DateTime.Now - testingStart).TotalSeconds;
                double estimatedTime    = (timeElapsedSoFar / index) * (fileList.Count - index);
                Console.WriteLine(timeElapsed.ToString("0.00") + "s Time elapsed: "
                                  + timeElapsedSoFar.ToString("0.00") + "s ETA: " + estimatedTime.ToString("0.00") + "s");
                index++;
            }
            double totalTimeElapsed = (DateTime.Now - testingStart).TotalSeconds;

            Console.WriteLine("Testing took " + totalTimeElapsed.ToString("0.00") + " sec.");


            if (testOnTrainingFiles)
            {
                Console.WriteLine("Testing on training files");
                testingStart = DateTime.Now;
                index        = 0;

                // we have the outputDirectory from test, else, relative to the exe
                outputDirectory = Path.Combine(outputDirectory, trainingFilesTestOutput);
                if (!Directory.Exists(outputDirectory))
                {
                    Directory.CreateDirectory(outputDirectory);
                }

                fileList = new List <string>(benchmark.getTrainingFilesPathList());
                foreach (string trainingFileName in fileList)
                {
                    DateTime start      = DateTime.Now;
                    string   outputPath = Path.Combine(outputDirectory, Path.GetFileNameWithoutExtension(trainingFileName));
                    Console.WriteLine(index + "/" + fileList.Count + " Testing file: " + Path.GetFileName(trainingFileName));
                    ImageDescription inputImage  = ImageFileHandler.loadFromPath(trainingFileName);
                    ImageDescription outputImage = algorithm.test(inputImage);
                    ImageFileHandler.saveToPath(outputImage, outputPath, outputFileExtension);
                    index++;

                    double timeElapsed = (DateTime.Now - start).TotalSeconds;
                    Console.WriteLine(timeElapsed.ToString("0.00") + " seconds");
                }
                totalTimeElapsed = (DateTime.Now - testingStart).TotalSeconds;
                Console.WriteLine("Testing on training files took " + totalTimeElapsed.ToString("0.00") + " sec.");
            }
        }
Exemplo n.º 25
0
 /// <summary>
 /// Creates a new instance of <see cref="Image"/> from an image description.
 /// </summary>
 /// <param name="description">The image description.</param>
 /// <param name="dataPointer">Pointer to an existing buffer.</param>
 /// <returns>A new image.</returns>
 public static Image New(ImageDescription description, IntPtr dataPointer)
 {
     return new Image(description, dataPointer, 0, null, false);
 }
Exemplo n.º 26
0
        public void testNestedAlgorithm(ContextualMemoryNestedAlgorithm nestedAlgorithm)
        {
            DateTime      testingStart = DateTime.Now;
            List <String> fileList     = benchmark.getTestFilesPathList();
            int           index        = 1;

            string outputDirectory = null;

            foreach (string testFileName in fileList)
            {
                DateTime start = DateTime.Now;
                outputDirectory = Path.GetDirectoryName(benchmark.getTestFileOutputPathWithoutExtension(testFileName));
                if (!Directory.Exists(outputDirectory))
                {
                    Directory.CreateDirectory(outputDirectory);
                }
                Console.WriteLine(index + "/" + fileList.Count + " Testing file: " + Path.GetFileName(testFileName));


                ImageDescription inputImage = ImageFileHandler.loadFromPath(testFileName);
                List <ContextualMemoryNestedAlgorithmLayer> layers = nestedAlgorithm.getLayers();

                List <ImageDescription> computedImages = nestedAlgorithm.computeImageForLayers(inputImage, layers.Count);
                for (int i = 0; i < layers.Count; i++)
                {
                    if (layers[i].outputResults)
                    {
                        ImageFileHandler.saveToPath(computedImages[i], benchmark.getTestFileOutputPathWithoutExtension(testFileName) + "_layer" + i, outputFileExtension);
                    }
                }
                ImageDescription outputImage = nestedAlgorithm.getImageBlender().blendImages(computedImages);
                ImageFileHandler.saveToPath(outputImage, benchmark.getTestFileOutputPathWithoutExtension(testFileName), outputFileExtension);

                double timeElapsed      = (DateTime.Now - start).TotalSeconds;
                double timeElapsedSoFar = (DateTime.Now - testingStart).TotalSeconds;
                double estimatedTime    = (timeElapsedSoFar / index) * (fileList.Count - index);
                Console.WriteLine(timeElapsed.ToString("0.00") + "s Time elapsed: "
                                  + timeElapsedSoFar.ToString("0.00") + "s ETA: " + estimatedTime.ToString("0.00") + "s");
                index++;
            }
            double totalTimeElapsed = (DateTime.Now - testingStart).TotalSeconds;

            Console.WriteLine("Testing took " + totalTimeElapsed.ToString("0.00") + " sec.");

            if (testOnTrainingFiles)
            {
                Console.WriteLine("Testing on training files");
                testingStart = DateTime.Now;
                index        = 0;

                // we have the outputDirectory from test, else, relative to the exe
                outputDirectory = Path.Combine(outputDirectory, trainingFilesTestOutput);
                if (!Directory.Exists(outputDirectory))
                {
                    Directory.CreateDirectory(outputDirectory);
                }

                fileList = new List <string>(benchmark.getTrainingFilesPathList());
                foreach (string trainingFileName in fileList)
                {
                    DateTime start      = DateTime.Now;
                    string   outputPath = Path.Combine(outputDirectory, Path.GetFileNameWithoutExtension(trainingFileName));
                    Console.WriteLine((index + 1) + "/" + fileList.Count + " Testing file: " + Path.GetFileName(trainingFileName));
                    ImageDescription inputImage = ImageFileHandler.loadFromPath(trainingFileName);

                    List <ContextualMemoryNestedAlgorithmLayer> layers = nestedAlgorithm.getLayers();
                    List <ImageDescription> computedImages             = nestedAlgorithm.computeImageForLayers(inputImage, layers.Count);
                    for (int i = 0; i < layers.Count; i++)
                    {
                        if (layers[i].outputResults)
                        {
                            ImageFileHandler.saveToPath(computedImages[i], outputPath + "_layer" + i, outputFileExtension);
                        }
                    }
                    ImageDescription outputImage = nestedAlgorithm.getImageBlender().blendImages(computedImages);

                    ImageFileHandler.saveToPath(outputImage, outputPath, outputFileExtension);
                    index++;

                    double timeElapsed = (DateTime.Now - start).TotalSeconds;
                    Console.WriteLine(timeElapsed.ToString("0.00") + " seconds");
                }
                totalTimeElapsed = (DateTime.Now - testingStart).TotalSeconds;
                Console.WriteLine("Testing on training files took " + totalTimeElapsed.ToString("0.00") + " sec.");
            }
        }
Exemplo n.º 27
0
 internal void InitializeFrom(Image image)
 {
     // TODO: Invalidate original image?
     pixelBuffers = image.pixelBuffers;
     dataBoxArray = image.dataBoxArray;
     mipMapToZIndex = image.mipMapToZIndex;
     zBufferCountPerArraySlice = image.zBufferCountPerArraySlice;
     mipmapDescriptions = image.mipmapDescriptions;
     pixelBufferArray = image.pixelBufferArray;
     totalSizeInBytes = image.totalSizeInBytes;
     buffer = image.buffer;
     bufferIsDisposable = image.bufferIsDisposable;
     handle = image.handle;
     Description = image.Description;
 }
Exemplo n.º 28
0
        public void validate()
        {
            DateTime validateStart = DateTime.Now;

            List <String> fileList = benchmark.getTestFilesPathList();

            float totalCrossEntropy = 0;

            foreach (string testFilePath in fileList)
            {
                DateTime start           = DateTime.Now;
                string   outputFilePath  = Path.ChangeExtension(benchmark.getTestFileOutputPathWithoutExtension(testFilePath), outputFileExtension);
                string   groundTruthPath = benchmark.getTestingFileGroundTruth(testFilePath);

                ImageDescription outputImage      = ImageFileHandler.loadFromPath(outputFilePath);
                ImageDescription groundTruthImage = ImageFileHandler.loadFromPath(groundTruthPath);

                byte[,] outputGray      = outputImage.getColorChannel(ColorChannelEnum.Gray);
                byte[,] groundTruthGray = groundTruthImage.getColorChannel(ColorChannelEnum.Gray);
                // might be a bug in GDI
                if (outputGray == null)
                {
                    outputImage.computeGrayscale();
                    outputGray = outputImage.getColorChannel(ColorChannelEnum.Gray);
                }
                if (groundTruthGray == null)
                {
                    groundTruthImage.computeGrayscale();
                    groundTruthGray = groundTruthImage.getColorChannel(ColorChannelEnum.Gray);
                }

                float crossEntropy = 0;
                for (int i = 0; i < outputGray.GetLength(0); i++)
                {
                    for (int j = 0; j < outputGray.GetLength(1); j++)
                    {
                        byte output      = outputGray[i, j];
                        byte groundTruth = groundTruthGray[i, j];

                        float groundTruthProbability;
                        float outputProbability;
                        if (groundTruth != 0)
                        {
                            groundTruthProbability = 1.0f;
                        }
                        else
                        {
                            groundTruthProbability = 0;
                        }
                        //groundTruthProbability = groundTruth / 255.0f;


                        if (output == 0)
                        {
                            outputProbability = 1 / 255.0f;
                        }
                        else
                        {
                            if (output == 255)
                            {
                                outputProbability = 254 / 255.0f;
                            }
                            else
                            {
                                outputProbability = output / 255.0f;
                            }
                        }
                        float loss = LogisticHelper.computeEntropyLoss(outputProbability, groundTruthProbability);
                        crossEntropy += loss;
                    }
                }

                totalCrossEntropy += crossEntropy;
                Console.WriteLine(testFilePath);
                Console.WriteLine("Cross entropy: " + crossEntropy.ToString("0.00"));
            }
            Console.WriteLine("Total cross entropy: " + totalCrossEntropy.ToString("0.00"));
            double totalTimeElapsed = (DateTime.Now - validateStart).TotalSeconds;

            Console.WriteLine("Validation took " + totalTimeElapsed.ToString("0.00") + " sec.");
        }
        // Simple DDS loader ported from http://msdn.microsoft.com/en-us/library/windows/apps/jj651550.aspx
        static void CreateTextureFromDDS(
            SharpDX.Direct3D11.Device d3dDevice,
            ImageDescription imageDesc,
            //SharpDX.Toolkit.Graphics.DDS.Header header,
            //DDS_HEADER* header,
            IntPtr bitData,
            //_In_reads_bytes_(bitSize) const byte* bitData,
            int bitSize,
            out SharpDX.Direct3D11.Resource texture,
            //_Out_opt_ ID3D11Resource** texture,
            out ShaderResourceView textureView
            //_Out_opt_ ID3D11ShaderResourceView** textureView,
            )
        {
            int width = imageDesc.Width;
            int height = imageDesc.Height;
            int depth = imageDesc.Depth;

            int arraySize = imageDesc.ArraySize;
            Format format = imageDesc.Format;
            bool isCubeMap = imageDesc.Dimension == TextureDimension.TextureCube;

            int mipCount = imageDesc.MipLevels;// MipMapCount;
            if (0 == mipCount)
            {
                mipCount = 1;
            }

            // Create the texture
            DataBox[] initData = new DataBox[mipCount * arraySize];
            //std::unique_ptr<D3D11_SUBRESOURCE_DATA> initData(new D3D11_SUBRESOURCE_DATA[mipCount * arraySize]);

            int maxsize = 1;
            if (isCubeMap)
            {
                maxsize = SharpDX.Direct3D11.Resource.MaximumTextureCubeSize;
            }
            else
            {
                maxsize = (imageDesc.Dimension == TextureDimension.Texture3D)
                    ? SharpDX.Direct3D11.Resource.MaximumTexture3DSize
                    : SharpDX.Direct3D11.Resource.MaximumTexture2DSize;
            }

            int skipMip = 0;
            int twidth = 0;
            int theight = 0;
            int tdepth = 0;
            FillInitData(width, height, depth, mipCount, arraySize, format, maxsize, bitSize, bitData, out twidth, out theight, out tdepth, out skipMip, initData);

            CreateD3DResources(d3dDevice, imageDesc.Dimension, twidth, theight, tdepth, mipCount - skipMip, arraySize, format, isCubeMap, initData, out texture, out textureView);
        }
Exemplo n.º 30
0
        public void SetContent(string label, bool useMnemonic, ImageDescription image, ContentPosition position)
        {
            Widget.UseUnderline = useMnemonic;
            this.image          = image;

            if (label != null && label.Length == 0)
            {
                label = null;
            }

            Button b = (Button)Frontend;

            if (label != null && image.Backend == null && b.Type == ButtonType.Normal)
            {
                Widget.Label = label;
                return;
            }

            if (b.Type == ButtonType.Disclosure)
            {
                Widget.Label = null;
                Widget.Image = new Gtk.Arrow(Gtk.ArrowType.Down, Gtk.ShadowType.Out);
                Widget.Image.ShowAll();
                return;
            }

            Gtk.Widget contentWidget = null;

            Gtk.Widget imageWidget = null;
            if (image.Backend != null)
            {
                imageWidget = new ImageBox(ApplicationContext, image.WithDefaultSize(Gtk.IconSize.Button));
            }

            Gtk.Label labelWidget = null;

            if (label != null && imageWidget == null)
            {
                contentWidget = labelWidget = new Gtk.Label(label);
            }
            else if (label == null && imageWidget != null)
            {
                contentWidget = imageWidget;
            }
            else if (label != null && imageWidget != null)
            {
                Gtk.Box box = position == ContentPosition.Left || position == ContentPosition.Right ? (Gtk.Box) new Gtk.HBox(false, 3) : (Gtk.Box) new Gtk.VBox(false, 3);
                labelWidget = new Gtk.Label(label)
                {
                    UseUnderline = useMnemonic
                };

                if (position == ContentPosition.Left || position == ContentPosition.Top)
                {
                    box.PackStart(imageWidget, false, false, 0);
                    box.PackStart(labelWidget, false, false, 0);
                }
                else
                {
                    box.PackStart(labelWidget, false, false, 0);
                    box.PackStart(imageWidget, false, false, 0);
                }

                contentWidget = box;
            }
            var expandButtonContent = false;

            if (b.Type == ButtonType.DropDown)
            {
                if (contentWidget != null)
                {
                    Gtk.HBox box = new Gtk.HBox(false, 3);
                    box.PackStart(contentWidget, true, true, 3);
                    box.PackStart(new Gtk.Arrow(Gtk.ArrowType.Down, Gtk.ShadowType.Out), false, false, 0);
                    contentWidget       = box;
                    expandButtonContent = true;
                }
                else
                {
                    contentWidget = new Gtk.Arrow(Gtk.ArrowType.Down, Gtk.ShadowType.Out);
                }
            }
            if (contentWidget != null)
            {
                contentWidget.ShowAll();
                Widget.Label = null;
                Widget.Image = contentWidget;
                if (expandButtonContent)
                {
                    var alignment = Widget.Child as Gtk.Alignment;
                    if (alignment != null)
                    {
                        var box = alignment.Child as Gtk.Box;
                        if (box != null)
                        {
                            alignment.Xscale = 1;
                            box.SetChildPacking(box.Children [0], true, true, 0, Gtk.PackType.Start);
                            if (labelWidget != null)
                            {
                                labelWidget.Xalign = 0;
                            }
                        }
                    }
                }
                if (labelWidget != null)
                {
                    labelWidget.UseUnderline = useMnemonic;
                    if (customFont != null)
                    {
                        labelWidget.ModifyFont(customFont);
                    }
                }
            }
            else
            {
                Widget.Label = null;
            }
        }
Exemplo n.º 31
0
 public void SetIcon(ImageDescription icon)
 {
     Window.IconList = ((GtkImage)icon.Backend).Frames.Select(f => f.Pixbuf).ToArray();
 }
Exemplo n.º 32
0
        /// <summary>
        /// Determines metadata for image
        /// </summary>
        /// <param name="flags">The flags.</param>
        /// <param name="decoder">The decoder.</param>
        /// <param name="frame">The frame.</param>
        /// <param name="pixelFormat">The pixel format.</param>
        /// <returns></returns>
        /// <exception cref="System.InvalidOperationException">If pixel format is not supported.</exception>
        private static ImageDescription? DecodeMetadata(WICFlags flags, BitmapDecoder decoder, BitmapFrameDecode frame, out Guid pixelFormat)
        {
            var size = frame.Size;

            var metadata = new ImageDescription
                               {
                                   Dimension = TextureDimension.Texture2D,
                                   Width = size.Width,
                                   Height = size.Height,
                                   Depth = 1,
                                   MipLevels = 1,
                                   ArraySize = (flags & WICFlags.AllFrames) != 0 ? decoder.FrameCount : 1,
                                   Format = DetermineFormat(frame.PixelFormat, flags, out pixelFormat)
                               };

            if (metadata.Format == DXGI.Format.Unknown)
                return null;

            return metadata;
        }
 /// <summary>
 /// Liefert den Hashcode dieser Instanz.
 /// </summary>
 /// <returns>Der Hashcode dieser Instanz.</returns>
 public override int GetHashCode()
 {
     return(Articles.GetHashCode() ^ ArticleUrl.GetHashCode() ^ Author.GetHashCode() ^ ImageDescription.GetHashCode()
            ^ Image.GetHashCode() ^ Language.GetHashCode() ^ Published.GetHashCode()
            ^ SkipDays.GetHashCode() ^ SkipHours.GetHashCode() ^ TextInput.GetHashCode() ^ TimeToLive.GetHashCode()
            ^ Title.GetHashCode() ^ Updated.GetHashCode() ^ Version.GetHashCode() ^ WebMaster.GetHashCode());
 }
Exemplo n.º 34
0
        //-------------------------------------------------------------------------------------
        // Decodes an image array, resizing/format converting as needed
        //-------------------------------------------------------------------------------------
        private static Image DecodeMultiframe(WICFlags flags, ImageDescription metadata, BitmapDecoder decoder)
        {
            var image = Image.New(metadata);

            Guid sourceGuid;
            if (!ToWIC(metadata.Format, out sourceGuid))
                return null;

            for (int index = 0; index < metadata.ArraySize; ++index)
            {
                var pixelBuffer = image.PixelBuffer[index, 0];

                using (var frame = decoder.GetFrame(index))
                {
                    var pfGuid = frame.PixelFormat;
                    var size = frame.Size;

                    if (pfGuid == sourceGuid)
                    {
                        if (size.Width == metadata.Width && size.Height == metadata.Height)
                        {
                            // This frame does not need resized or format converted, just copy...
                            frame.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
                        }
                        else
                        {
                            // This frame needs resizing, but not format converted
                            using (var scaler = new BitmapScaler(Factory))
                            {
                                scaler.Initialize(frame, metadata.Width, metadata.Height, GetWICInterp(flags));
                                scaler.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
                            }
                        }
                    }
                    else
                    {
                        // This frame required format conversion
                        using (var converter = new FormatConverter(Factory))
                        {
                            converter.Initialize(frame, pfGuid, GetWICDither(flags), null, 0, BitmapPaletteType.Custom);

                            if (size.Width == metadata.Width && size.Height == metadata.Height)
                            {
                                converter.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
                            }
                            else
                            {
                                // This frame needs resizing, but not format converted
                                using (var scaler = new BitmapScaler(Factory))
                                {
                                    scaler.Initialize(frame, metadata.Width, metadata.Height, GetWICInterp(flags));
                                    scaler.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
                                }
                            }
                        }
                    }
                }
            }
            return image;
        }
 public static void SaveJpgFromMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream)
 {
     SaveFromMemory(pixelBuffers, count, description, imageStream, ImageFormat.Jpeg);
 }
Exemplo n.º 36
0
 public static void SaveWmpToWICMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream)
 {
     SaveToWICMemory(pixelBuffers, 1, WICFlags.None, ImageFileType.Wmp, imageStream);
 }
Exemplo n.º 37
0
 public float train(List <ImageDescription> inputImages, ImageDescription inputImageGroundTruth)
 {
     return(0);
 }
Exemplo n.º 38
0
 public void Draw(ApplicationContext actx, Cairo.Context ctx, double scaleFactor, double x, double y, ImageDescription idesc)
 {
     if (stockId != null)
     {
         ImageFrame frame = null;
         if (frames != null)
         {
             frame = frames.FirstOrDefault(f => f.Width == (int)idesc.Size.Width && f.Height == (int)idesc.Size.Height && f.Scale == scaleFactor);
         }
         if (frame == null)
         {
             frame       = new ImageFrame(ImageHandler.CreateBitmap(stockId, idesc.Size.Width, idesc.Size.Height, scaleFactor), (int)idesc.Size.Width, (int)idesc.Size.Height, false);
             frame.Scale = scaleFactor;
             AddFrame(frame);
         }
         DrawPixbuf(ctx, frame.Pixbuf, x, y, idesc);
     }
     else if (drawCallback != null)
     {
         CairoContextBackend c = new CairoContextBackend(scaleFactor)
         {
             Context = ctx
         };
         if (actx != null)
         {
             actx.InvokeUserCode(delegate {
                 drawCallback(c, new Rectangle(x, y, idesc.Size.Width, idesc.Size.Height), idesc, actx.Toolkit);
             });
         }
         else
         {
             drawCallback(c, new Rectangle(x, y, idesc.Size.Width, idesc.Size.Height), idesc, Toolkit.CurrentEngine);
         }
     }
     else
     {
         DrawPixbuf(ctx, GetBestFrame(actx, scaleFactor, idesc.Size.Width, idesc.Size.Height, false), x, y, idesc);
     }
 }
Exemplo n.º 39
0
        //-------------------------------------------------------------------------------------
        // Decodes a single frame
        //-------------------------------------------------------------------------------------
        private static Image DecodeSingleFrame(WICFlags flags, ImageDescription metadata, Guid convertGUID, BitmapFrameDecode frame)
        {
            var image = Image.New(metadata);

            var pixelBuffer = image.PixelBuffer[0];

            if (convertGUID == Guid.Empty)
            {
                frame.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
            }
            else
            {
                using (var converter = new FormatConverter(Factory))
                {
                    converter.Initialize(frame, convertGUID, GetWICDither(flags), null, 0, BitmapPaletteType.Custom);
                    converter.CopyPixels(pixelBuffer.RowStride, pixelBuffer.DataPointer, pixelBuffer.BufferStride);
                }
            }

            return image;
        }
Exemplo n.º 40
0
        //// GET api/<controller>
        //public IEnumerable<string> Get(string filter, int toId = 0)
        //{
        //    return _repository.TestGetAll().Where(s => s.ToUpper().Contains(filter.ToUpper())).Skip(toId).ToList();
        //}

        //// GET api/<controller>/5
        //public string Get(int id)
        //{
        //    return "value";
        //}

        // POST api/<controller>
        public void Post(ImageDescription value)
        {
            _repository.AddImageDescription(value.ImageId, value.Description);
        }
Exemplo n.º 41
0
 public static void SaveTiffToWICMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream)
 {
     SaveToWICMemory(pixelBuffers, count, WICFlags.AllFrames, ImageFileType.Tiff, imageStream);
 }
Exemplo n.º 42
0
 public override void DrawImage(object backend, ImageDescription img, double x, double y)
 {
 }
 public static void SavePngFromMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream)
 {
     WICHelper.SavePngToWICMemory(pixelBuffers, count, description, imageStream);
 }
Exemplo n.º 44
0
 public override void DrawImage(object backend, ImageDescription img, Rectangle srcRect, Rectangle destRect)
 {
 }
Exemplo n.º 45
0
 public static void SaveWmpFromMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream)
 {
     throw new NotImplementedException();
 }
 public override object Create(ImageDescription img)
 {
     return(new ImagePattern(ApplicationContext, img));
 }
Exemplo n.º 47
0
        /// <summary>
        /// Allocates PixelBuffers 
        /// </summary>
        /// <param name="buffer"></param>
        /// <param name="pixelSize"></param>
        /// <param name="imageDesc"></param>
        /// <param name="pitchFlags"></param>
        /// <param name="output"></param>
        private static unsafe void SetupImageArray(IntPtr buffer, int pixelSize, int rowStride, ImageDescription imageDesc, PitchFlags pitchFlags, PixelBuffer[] output)
        {
            int index = 0;
            var pixels = (byte*)buffer;
            for (uint item = 0; item < imageDesc.ArraySize; ++item)
            {
                int w = imageDesc.Width;
                int h = imageDesc.Height;
                int d = imageDesc.Depth;

                for (uint level = 0; level < imageDesc.MipLevels; ++level)
                {
                    int rowPitch, slicePitch;
                    int widthPacked;
                    int heightPacked;
                    ComputePitch(imageDesc.Format, w, h, out rowPitch, out slicePitch, out widthPacked, out heightPacked, pitchFlags);

                    if (rowStride > 0)
                    {
                        // Check that stride is ok
                        if (rowStride < rowPitch)
                            throw new InvalidOperationException(string.Format("Invalid stride [{0}]. Value can't be lower than actual stride [{1}]", rowStride, rowPitch));

                        if (widthPacked != w || heightPacked != h)
                            throw new InvalidOperationException("Custom strides is not supported with packed PixelFormats");

                        // Override row pitch
                        rowPitch = rowStride;

                        // Recalculate slice pitch
                        slicePitch = rowStride * h;
                    }

                    for (uint zSlice = 0; zSlice < d; ++zSlice)
                    {
                        // We use the same memory organization that Direct3D 11 needs for D3D11_SUBRESOURCE_DATA
                        // with all slices of a given miplevel being continuous in memory
                        output[index] = new PixelBuffer(w, h, imageDesc.Format, rowPitch, slicePitch, (IntPtr)pixels);
                        ++index;

                        pixels += slicePitch;
                    }

                    if (h > 1)
                        h >>= 1;

                    if (w > 1)
                        w >>= 1;

                    if (d > 1)
                        d >>= 1;
                }
            }
        }
 public ImagePattern(ApplicationContext actx, ImageDescription im)
 {
     this.actx  = actx;
     this.image = im;
 }
Exemplo n.º 49
0
 /// <summary>
 /// Creates a new instance of <see cref="Image"/> from an image description.
 /// </summary>
 /// <param name="description">The image description.</param>
 /// <returns>A new image.</returns>
 public static Image New(ImageDescription description)
 {
     return New(description, IntPtr.Zero);
 }
Exemplo n.º 50
0
        private static void DeserializeTexture(ContentManager contentManager, Texture texture, ref ImageDescription imageDescription, ref ContentStorageHeader storageHeader)
        {
            using (var content = new ContentStreamingService())
            {
                // Get content storage container
                var storage = content.GetStorage(ref storageHeader);
                if (storage == null)
                {
                    throw new ContentStreamingException("Missing content storage.");
                }
                storage.LockChunks();

                // Cache data
                var  fileProvider      = contentManager.FileProvider;
                var  format            = imageDescription.Format;
                bool isBlockCompressed =
                    (format >= PixelFormat.BC1_Typeless && format <= PixelFormat.BC5_SNorm) ||
                    (format >= PixelFormat.BC6H_Typeless && format <= PixelFormat.BC7_UNorm_SRgb);
                var dataBoxes    = new DataBox[imageDescription.MipLevels * imageDescription.ArraySize];
                int dataBoxIndex = 0;

                // Get data boxes data
                for (int arrayIndex = 0; arrayIndex < imageDescription.ArraySize; arrayIndex++)
                {
                    for (int mipIndex = 0; mipIndex < imageDescription.MipLevels; mipIndex++)
                    {
                        int mipWidth  = imageDescription.Width >> mipIndex;
                        int mipHeight = imageDescription.Height >> mipIndex;
                        if (isBlockCompressed && ((mipWidth % 4) != 0 || (mipHeight % 4) != 0))
                        {
                            mipWidth  = unchecked ((int)(((uint)(mipWidth + 3)) & ~3U));
                            mipHeight = unchecked ((int)(((uint)(mipHeight + 3)) & ~3U));
                        }

                        int rowPitch, slicePitch;
                        int widthPacked;
                        int heightPacked;
                        Image.ComputePitch(format, mipWidth, mipHeight, out rowPitch, out slicePitch, out widthPacked, out heightPacked);

                        var chunk = storage.GetChunk(mipIndex);
                        if (chunk == null || chunk.Size != slicePitch * imageDescription.ArraySize)
                        {
                            throw new ContentStreamingException("Data chunk is missing or has invalid size.", storage);
                        }
                        var data = chunk.GetData(fileProvider);
                        if (!chunk.IsLoaded)
                        {
                            throw new ContentStreamingException("Data chunk is not loaded.", storage);
                        }

                        dataBoxes[dataBoxIndex].DataPointer = data + slicePitch * arrayIndex;
                        dataBoxes[dataBoxIndex].RowPitch    = rowPitch;
                        dataBoxes[dataBoxIndex].SlicePitch  = slicePitch;
                        dataBoxIndex++;
                    }
                }

                // Initialize texture
                texture.InitializeFrom(imageDescription, new TextureViewDescription(), dataBoxes);

                storage.UnlockChunks();
            }
        }
Exemplo n.º 51
0
 /// <summary>
 /// Initializes a new instance of the <see cref="Image" /> class.
 /// </summary>
 /// <param name="description">The image description.</param>
 /// <param name="dataPointer">The pointer to the data buffer.</param>
 /// <param name="offset">The offset from the beginning of the data buffer.</param>
 /// <param name="handle">The handle (optionnal).</param>
 /// <param name="bufferIsDisposable">if set to <c>true</c> [buffer is disposable].</param>
 /// <exception cref="System.InvalidOperationException">If the format is invalid, or width/height/depth/arraysize is invalid with respect to the dimension.</exception>
 public static Image New(ImageDescription description, IntPtr dataPointer, int offset, GCHandle? handle, bool bufferIsDisposable)
 {
     return new Image(description, dataPointer, offset, handle, bufferIsDisposable);
 }
Exemplo n.º 52
0
        internal static void Serialize(ArchiveMode mode, SerializationStream stream, Texture texture, bool allowContentStreaming)
        {
            if (mode == ArchiveMode.Deserialize)
            {
                var services = stream.Context.Tags.Get(ServiceRegistry.ServiceRegistryKey);
                var graphicsDeviceService     = services.GetSafeServiceAs <IGraphicsDeviceService>();
                var texturesStreamingProvider = services.GetService <ITexturesStreamingProvider>();

                var isStreamable = stream.ReadBoolean();
                if (!isStreamable)
                {
                    texturesStreamingProvider?.UnregisterTexture(texture);

                    // TODO: Error handling?
                    using (var textureData = Image.Load(stream.NativeStream))
                    {
                        if (texture.GraphicsDevice != null)
                        {
                            texture.OnDestroyed(); //Allows fast reloading todo review maybe?
                        }
                        texture.AttachToGraphicsDevice(graphicsDeviceService.GraphicsDevice);
                        texture.InitializeFrom(textureData.Description, new TextureViewDescription(), textureData.ToDataBox());

                        // Setup reload callback (reload from asset manager)
                        var contentSerializerContext = stream.Context.Get(ContentSerializerContext.ContentSerializerContextProperty);
                        if (contentSerializerContext != null)
                        {
                            var assetManager = contentSerializerContext.ContentManager;
                            var url          = contentSerializerContext.Url;

                            texture.Reload = (graphicsResource) =>
                            {
                                var textureDataReloaded = assetManager.Load <Image>(url);
                                ((Texture)graphicsResource).Recreate(textureDataReloaded.ToDataBox());
                                assetManager.Unload(textureDataReloaded);
                            };
                        }
                    }
                }
                else
                {
                    if (texture.GraphicsDevice != null)
                    {
                        texture.OnDestroyed();
                    }

                    texture.AttachToGraphicsDevice(graphicsDeviceService.GraphicsDevice);
                    texture.Reload = null;

                    // Read image header
                    var imageDescription = new ImageDescription();
                    ImageHelper.ImageDescriptionSerializer.Serialize(ref imageDescription, ArchiveMode.Deserialize, stream);

                    // Read content storage header
                    ContentStorageHeader storageHeader;
                    ContentStorageHeader.Read(stream, out storageHeader);

                    // Check if streaming service is available
                    if (texturesStreamingProvider != null)
                    {
                        if (allowContentStreaming)
                        {
                            // Register texture for streaming
                            texturesStreamingProvider.RegisterTexture(texture, ref imageDescription, ref storageHeader);

                            // Note: here we don't load texture data and don't allocate GPU memory
                        }
                        else
                        {
                            // Request texture loading (should be fully loaded)
                            texturesStreamingProvider.FullyLoadTexture(texture, ref imageDescription, ref storageHeader);
                        }

                        // Load initial texture (with limited number of mipmaps)
                        using (var textureData = Image.Load(stream.NativeStream))
                        {
                            if (texture.GraphicsDevice != null)
                            {
                                texture.OnDestroyed(); //Allows fast reloading todo review maybe?
                            }
                            texture.InitializeFrom(textureData.Description, new TextureViewDescription(), textureData.ToDataBox());
                        }
                    }
                    else
                    {
                        // Load initial texture and discard it (we are going to load the full chunk texture right after)
                        using (var textureData = Image.Load(stream.NativeStream))
                        {
                        }

                        // Deserialize whole texture without streaming feature
                        var contentSerializerContext = stream.Context.Get(ContentSerializerContext.ContentSerializerContextProperty);
                        DeserializeTexture(contentSerializerContext.ContentManager, texture, ref imageDescription, ref storageHeader);
                    }
                }
            }
            else
            {
                var textureData = texture.GetSerializationData();
                if (textureData == null)
                {
                    throw new InvalidOperationException("Trying to serialize a Texture without CPU info.");
                }

                textureData.Write(stream);
            }
        }
Exemplo n.º 53
0
        internal unsafe void Initialize(ImageDescription description, IntPtr dataPointer, int offset, GCHandle? handle, bool bufferIsDisposable, PitchFlags pitchFlags = PitchFlags.None, int rowStride = 0)
        {
            if (!description.Format.IsValid() || description.Format.IsVideo())
                throw new InvalidOperationException("Unsupported DXGI Format");

            if (rowStride > 0 && description.MipLevels != 1)
                throw new InvalidOperationException("Cannot specify custom stride with mipmaps");


            this.handle = handle;

            switch (description.Dimension)
            {
                case TextureDimension.Texture1D:
                    if (description.Width <= 0 || description.Height != 1 || description.Depth != 1 || description.ArraySize == 0)
                        throw new InvalidOperationException("Invalid Width/Height/Depth/ArraySize for Image 1D");

                    // Check that miplevels are fine
                    description.MipLevels = CalculateMipLevels(description.Width, 1, description.MipLevels);
                    break;

                case TextureDimension.Texture2D:
                case TextureDimension.TextureCube:
                    if (description.Width <= 0 || description.Height <= 0 || description.Depth != 1 || description.ArraySize == 0)
                        throw new InvalidOperationException("Invalid Width/Height/Depth/ArraySize for Image 2D");

                    if (description.Dimension == TextureDimension.TextureCube)
                    {
                        if ((description.ArraySize % 6) != 0)
                            throw new InvalidOperationException("TextureCube must have an arraysize = 6");
                    }

                    // Check that miplevels are fine
                    description.MipLevels = CalculateMipLevels(description.Width, description.Height, description.MipLevels);
                    break;

                case TextureDimension.Texture3D:
                    if (description.Width <= 0 || description.Height <= 0 || description.Depth <= 0 || description.ArraySize != 1)
                        throw new InvalidOperationException("Invalid Width/Height/Depth/ArraySize for Image 3D");

                    // Check that miplevels are fine
                    description.MipLevels = CalculateMipLevels(description.Width, description.Height, description.Depth, description.MipLevels);
                    break;
            }

            // Calculate mipmaps
            int pixelBufferCount;
            this.mipMapToZIndex = CalculateImageArray(description, pitchFlags, rowStride, out pixelBufferCount, out totalSizeInBytes);
            this.mipmapDescriptions = CalculateMipMapDescription(description, pitchFlags);
            zBufferCountPerArraySlice = this.mipMapToZIndex[this.mipMapToZIndex.Count - 1];

            // Allocate all pixel buffers
            pixelBuffers = new PixelBuffer[pixelBufferCount];
            pixelBufferArray = new PixelBufferArray(this);

            // Setup all pointers
            // only release buffer that is not pinned and is asked to be disposed.
            this.bufferIsDisposable = !handle.HasValue && bufferIsDisposable;
            this.buffer = dataPointer;

            if (dataPointer == IntPtr.Zero)
            {
                buffer = Utilities.AllocateMemory(totalSizeInBytes);
                offset = 0;
                this.bufferIsDisposable = true;
            }

            SetupImageArray((IntPtr)((byte*)buffer + offset), totalSizeInBytes, rowStride, description, pitchFlags, pixelBuffers);

            Description = description;

            // PreCompute databoxes
            dataBoxArray = ComputeDataBox();
        }
Exemplo n.º 54
0
 public void SetContent(string label, bool useMnemonic, ImageDescription image, ContentPosition position)
 {
     SetContent(label, useMnemonic, image, position, false);
 }
Exemplo n.º 55
0
 internal static MipMapDescription[] CalculateMipMapDescription(ImageDescription metadata, PitchFlags cpFlags = PitchFlags.None)
 {
     int nImages;
     int pixelSize;
     return CalculateMipMapDescription(metadata, cpFlags, out nImages, out pixelSize);
 }
Exemplo n.º 56
0
        void SetContent(string label, bool useMnemonic, ImageDescription image, ContentPosition position, bool forceCustomLabel)
        {
            Widget.UseUnderline = useMnemonic;
            this.image          = image;
            contentPosition     = position;
            formattedText       = null;

            if (label != null && label.Length == 0)
            {
                label = null;
            }

            Button b = (Button)Frontend;

            if (label != null && image.Backend == null && b.Type == ButtonType.Normal && !forceCustomLabel)
            {
                Widget.Label = label;
                return;
            }

            if (b.Type == ButtonType.Disclosure)
            {
                Widget.Label = null;
                Widget.Image = new Gtk.Arrow(Gtk.ArrowType.Down, Gtk.ShadowType.Out);
                Widget.Image.ShowAll();
                return;
            }

            Gtk.Widget contentWidget = null;

            Gtk.Widget imageWidget = null;
            if (image.Backend != null)
            {
                imageWidget = new ImageBox(ApplicationContext, image.WithDefaultSize(Gtk.IconSize.Button));
            }

            if (labelWidget != null)
            {
                labelWidget.Realized -= HandleStyleUpdate;
                labelWidget.StyleSet -= HandleStyleUpdate;
                labelWidget           = null;
            }

            if (label != null && imageWidget == null)
            {
                contentWidget = labelWidget = new Gtk.Label(label);
            }
            else if (label == null && imageWidget != null)
            {
                contentWidget = imageWidget;
            }
            else if (label != null && imageWidget != null)
            {
                Gtk.Box box = position == ContentPosition.Left || position == ContentPosition.Right ? (Gtk.Box) new Gtk.HBox(false, 3) : (Gtk.Box) new Gtk.VBox(false, 3);
                labelWidget = new Gtk.Label(label)
                {
                    UseUnderline = useMnemonic
                };

                if (position == ContentPosition.Left || position == ContentPosition.Top)
                {
                    box.PackStart(imageWidget, false, false, 0);
                    box.PackStart(labelWidget, false, false, 0);
                }
                else
                {
                    box.PackStart(labelWidget, false, false, 0);
                    box.PackStart(imageWidget, false, false, 0);
                }

                contentWidget = box;
            }
            var expandButtonContent = false;

            if (b.Type == ButtonType.DropDown)
            {
                if (contentWidget != null)
                {
                    Gtk.HBox box = new Gtk.HBox(false, 3);
                    box.PackStart(contentWidget, true, true, 3);
                    box.PackStart(new Gtk.Arrow(Gtk.ArrowType.Down, Gtk.ShadowType.Out), false, false, 0);
                    contentWidget       = box;
                    expandButtonContent = true;
                }
                else
                {
                    contentWidget = new Gtk.Arrow(Gtk.ArrowType.Down, Gtk.ShadowType.Out);
                }
            }
            if (contentWidget != null)
            {
                contentWidget.ShowAll();
                Widget.Label = null;
                Widget.Image = contentWidget;
                var alignment = Widget.Child as Gtk.Alignment;
                if (alignment != null)
                {
                    if (expandButtonContent)
                    {
                        var box = alignment.Child as Gtk.Box;
                        if (box != null)
                        {
                            alignment.Xscale = 1;
                            box.SetChildPacking(box.Children [0], true, true, 0, Gtk.PackType.Start);
                            if (labelWidget != null)
                            {
                                labelWidget.Xalign = 0;
                            }
                        }
                    }
                    else if (position == ContentPosition.Left && (contentWidget is Gtk.Box))
                    {
                        // in case the button is wider than its natural size and has text and an image on the left,
                        // optimize its alignment to make the text more centered.
                        // FIXME: more sophisticated size calculation
                        alignment.Xalign = 0.475f;
                    }
                }
                if (labelWidget != null)
                {
                    labelWidget.UseUnderline = useMnemonic;
                    if (customFont != null)
                    {
                        labelWidget.ModifyFont(customFont);
                    }
                    if (customLabelColor.HasValue)
                    {
                        labelWidget.SetForegroundColor(customLabelColor.Value);
                        labelWidget.SetForegroundColor(Gtk.StateType.Prelight, customLabelColor.Value);
                    }
                }
            }
            else
            {
                Widget.Label = null;
            }
        }
Exemplo n.º 57
0
        /// <summary>
        /// Determines number of image array entries and pixel size.
        /// </summary>
        /// <param name="imageDesc">Description of the image to create.</param>
        /// <param name="pitchFlags">Pitch flags.</param>
        /// <param name="bufferCount">Output number of mipmap.</param>
        /// <param name="pixelSizeInBytes">Output total size to allocate pixel buffers for all images.</param>
        private static List<int> CalculateImageArray( ImageDescription imageDesc, PitchFlags pitchFlags, int rowStride, out int bufferCount, out int pixelSizeInBytes)
        {
            pixelSizeInBytes = 0;
            bufferCount = 0;

            var mipmapToZIndex = new List<int>();

            for (int j = 0; j < imageDesc.ArraySize; j++)
            {
                int w = imageDesc.Width;
                int h = imageDesc.Height;
                int d = imageDesc.Depth; 
                
                for (int i = 0; i < imageDesc.MipLevels; i++)
                {
                    int rowPitch, slicePitch;
                    int widthPacked;
                    int heightPacked;
                    ComputePitch(imageDesc.Format, w, h, out rowPitch, out slicePitch, out widthPacked, out heightPacked, pitchFlags);

                    if (rowStride > 0)
                    {
                        // Check that stride is ok
                        if (rowStride < rowPitch)
                            throw new InvalidOperationException(string.Format("Invalid stride [{0}]. Value can't be lower than actual stride [{1}]", rowStride, rowPitch));

                        if (widthPacked != w || heightPacked != h)
                            throw new InvalidOperationException("Custom strides is not supported with packed PixelFormats");

                        // Override row pitch
                        rowPitch = rowStride;

                        // Recalculate slice pitch
                        slicePitch = rowStride * h;
                    }

                    // Store the number of z-slicec per miplevels
                    if ( j == 0)
                        mipmapToZIndex.Add(bufferCount);

                    // Keep a trace of indices for the 1st array size, for each mip levels
                    pixelSizeInBytes += d * slicePitch;
                    bufferCount += d;

                    if (h > 1)
                        h >>= 1;

                    if (w > 1)
                        w >>= 1;

                    if (d > 1)
                        d >>= 1;
                }

                // For the last mipmaps, store just the number of zbuffers in total
                if (j == 0)
                    mipmapToZIndex.Add(bufferCount);
            }
            return mipmapToZIndex;
        }
Exemplo n.º 58
0
 public void SetImage(ImageDescription image)
 {
     image             = image.WithDefaultSize(Gtk.IconSize.Menu);
     statusItem.Pixbuf = ((GtkImage)image.Backend).GetBestFrame(context, Util.GetDefaultScaleFactor(), image.Size.Width, image.Size.Height, true);
 }
        /// <summary>
        /// Decodes DDS header including optional DX10 extended header
        /// </summary>
        /// <param name="headerPtr">Pointer to the DDS header.</param>
        /// <param name="size">Size of the DDS content.</param>
        /// <param name="flags">Flags used for decoding the DDS header.</param>
        /// <param name="description">Output texture description.</param>
        /// <param name="convFlags">Output conversion flags.</param>
        /// <exception cref="ArgumentException">If the argument headerPtr is null</exception>
        /// <exception cref="InvalidOperationException">If the DDS header contains invalid datas.</exception>
        /// <returns>True if the decoding is successfull, false if this is not a DDS header.</returns>
        private static unsafe bool DecodeDDSHeader(IntPtr headerPtr, int size, DDSFlags flags, out ImageDescription description, out ConversionFlags convFlags)
        {
            description = new ImageDescription();
            convFlags = ConversionFlags.None;

            if (headerPtr == IntPtr.Zero)
                throw new ArgumentException("Pointer to DDS header cannot be null", "headerPtr");

            if (size < (Utilities.SizeOf<DDS.Header>() + sizeof(uint)))
                return false;

            // DDS files always start with the same magic number ("DDS ")
            if (*(uint*)(headerPtr) != DDS.MagicHeader)
                return false;

            var header = *(DDS.Header*)((byte*)headerPtr + sizeof(int));

            // Verify header to validate DDS file
            if (header.Size != Utilities.SizeOf<DDS.Header>() || header.PixelFormat.Size != Utilities.SizeOf<DDS.PixelFormat>())
                return false;

            // Setup MipLevels
            description.MipLevels = header.MipMapCount;
            if (description.MipLevels == 0)
                description.MipLevels = 1;

            // Check for DX10 extension
            if ((header.PixelFormat.Flags & DDS.PixelFormatFlags.FourCC) != 0 && (new FourCC('D', 'X', '1', '0') == header.PixelFormat.FourCC))
            {
                // Buffer must be big enough for both headers and magic value
                if (size < (Utilities.SizeOf<DDS.Header>() + sizeof(uint) + Utilities.SizeOf<DDS.HeaderDXT10>()))
                    return false;

                var headerDX10 = *(DDS.HeaderDXT10*)((byte*)headerPtr + sizeof(int) + Utilities.SizeOf<DDS.Header>());
                convFlags |= ConversionFlags.DX10;

                description.ArraySize = headerDX10.ArraySize;
                if (description.ArraySize == 0)
                    throw new InvalidOperationException("Unexpected ArraySize == 0 from DDS HeaderDX10 ");

                description.Format = headerDX10.DXGIFormat;
                if (!FormatHelper.IsValid(description.Format))
                    throw new InvalidOperationException("Invalid Format from DDS HeaderDX10 ");

                switch (headerDX10.ResourceDimension)
                {
                    case ResourceDimension.Texture1D:

                        // D3DX writes 1D textures with a fixed Height of 1
                        if ((header.Flags & DDS.HeaderFlags.Height) != 0 && header.Height != 1)
                            throw new InvalidOperationException("Unexpected Height != 1 from DDS HeaderDX10 ");

                        description.Width = header.Width;
                        description.Height = 1;
                        description.Depth = 1;
                        description.Dimension = TextureDimension.Texture1D;
                        break;

                    case ResourceDimension.Texture2D:
                        if ((headerDX10.MiscFlags & ResourceOptionFlags.TextureCube) != 0)
                        {
                            description.ArraySize *= 6;
                            description.Dimension = TextureDimension.TextureCube;
                        }
                        else
                        {
                            description.Dimension = TextureDimension.Texture2D;
                        }

                        description.Width = header.Width;
                        description.Height = header.Height;
                        description.Depth = 1;
                        break;

                    case ResourceDimension.Texture3D:
                        if ((header.Flags & DDS.HeaderFlags.Volume) == 0)
                            throw new InvalidOperationException("Texture3D missing HeaderFlags.Volume from DDS HeaderDX10");

                        if (description.ArraySize > 1)
                            throw new InvalidOperationException("Unexpected ArraySize > 1 for Texture3D from DDS HeaderDX10");

                        description.Width = header.Width;
                        description.Height = header.Height;
                        description.Depth = header.Depth;
                        description.Dimension = TextureDimension.Texture3D;
                        break;

                    default:
                        throw new InvalidOperationException(string.Format("Unexpected dimension [{0}] from DDS HeaderDX10", headerDX10.ResourceDimension));
                }
            }
            else
            {
                description.ArraySize = 1;

                if ((header.Flags & DDS.HeaderFlags.Volume) != 0)
                {
                    description.Width = header.Width;
                    description.Height = header.Height;
                    description.Depth = header.Depth;
                    description.Dimension = TextureDimension.Texture3D;
                }
                else
                {
                    if ((header.CubemapFlags & DDS.CubemapFlags.CubeMap) != 0)
                    {
                        // We require all six faces to be defined
                        if ((header.CubemapFlags & DDS.CubemapFlags.AllFaces) != DDS.CubemapFlags.AllFaces)
                            throw new InvalidOperationException("Unexpected CubeMap, expecting all faces from DDS Header");

                        description.ArraySize = 6;
                        description.Dimension = TextureDimension.TextureCube;
                    }
                    else
                    {
                        description.Dimension = TextureDimension.Texture2D;
                    }

                    description.Width = header.Width;
                    description.Height = header.Height;
                    description.Depth = 1;
                    // Note there's no way for a legacy Direct3D 9 DDS to express a '1D' texture
                }

                description.Format = GetDXGIFormat(ref header.PixelFormat, flags, out convFlags);

                if (description.Format == Format.Unknown)
                    throw new InvalidOperationException("Unsupported PixelFormat from DDS Header");
            }

            // Special flag for handling BGR DXGI 1.1 formats
            if ((flags & DDSFlags.ForceRgb) != 0)
            {
                switch ((Format)description.Format)
                {
                    case Format.B8G8R8A8_UNorm:
                        description.Format = Format.R8G8B8A8_UNorm;
                        convFlags |= ConversionFlags.Swizzle;
                        break;

                    case Format.B8G8R8X8_UNorm:
                        description.Format = Format.R8G8B8A8_UNorm;
                        convFlags |= ConversionFlags.Swizzle | ConversionFlags.NoAlpha;
                        break;

                    case Format.B8G8R8A8_Typeless:
                        description.Format = Format.R8G8B8A8_Typeless;
                        convFlags |= ConversionFlags.Swizzle;
                        break;

                    case Format.B8G8R8A8_UNorm_SRgb:
                        description.Format = Format.R8G8B8A8_UNorm_SRgb;
                        convFlags |= ConversionFlags.Swizzle;
                        break;

                    case Format.B8G8R8X8_Typeless:
                        description.Format = Format.R8G8B8A8_Typeless;
                        convFlags |= ConversionFlags.Swizzle | ConversionFlags.NoAlpha;
                        break;

                    case Format.B8G8R8X8_UNorm_SRgb:
                        description.Format = Format.R8G8B8A8_UNorm_SRgb;
                        convFlags |= ConversionFlags.Swizzle | ConversionFlags.NoAlpha;
                        break;
                }
            }

            // Pass DDSFlags copy memory to the conversion flags
            if ((flags & DDSFlags.CopyMemory) != 0)
                convFlags |= ConversionFlags.CopyMemory;

            // Special flag for handling 16bpp formats
            if ((flags & DDSFlags.No16Bpp) != 0)
            {
                switch ((Format)description.Format)
                {
                    case Format.B5G6R5_UNorm:
                    case Format.B5G5R5A1_UNorm:
                    case Format.B4G4R4A4_UNorm:
                        description.Format = Format.R8G8B8A8_UNorm;
                        convFlags |= ConversionFlags.Expand;
                        if (description.Format == Format.B5G6R5_UNorm)
                            convFlags |= ConversionFlags.NoAlpha;
                        break;
                }
            }
            return true;
        }
Exemplo n.º 60
0
 public void SetIcon(ImageDescription imageBackend)
 {
     window.Icon = imageBackend.ToImageSource();
 }