Clipboard to Texture?

Ok I found a solution to the problem, but I almost instantly got another one :) (as usual)

I need to do the following,
I have to implement this:
Context Preserving Visual Links - PDF

I use a WPF UI to draw all elements of the user-interface.
I already (almost) created the functionality to display different views of one of the hard-drives in the computer, I only need to implement the OpenGL-part of the paper linked above.

So I created a WinFormsHost object and inserted my "CustomGLControl" as described in the GraphicsContext - Class description. It "lies" above the other user-interface - elements (zIndex = 2 for the WinFormsHost)
How is it possible to add the (Custom)GLControl without "visually" interfering with my program-user-interface?
I tried this (and in the designer it is not shown at all, but the whole program is "grey", if I start it):

        <WindowsFormsHost Grid.Column="0" Grid.ColumnSpan="3" Grid.Row="0" Grid.RowSpan="2" Name="overlayHost" Panel.ZIndex="2" IsHitTestVisible="False" Background="Transparent">
            <gl:CustomGLControl x:Name="overlayCanvas" BackColor="Transparent" ForeColor="Transparent"></gl:CustomGLControl>
        </WindowsFormsHost>

Or maybe is it the wrong approch all along?
If you don't want to read the paper, this is, what i try to do:

I have some parts of the screen that should be "highlighted" and connected through links (lines on the screen).
The algorithm is image-based, so I need to get a Screenshot of the monitor/program window (whatever) and do some pomputations based on that screenshot.
One thing is to calculate a "penalty-map" based on color differences for eample!

Using this penalty-map i need to compute the links between the highlighted positions on the screen.

So I though I would use OpenGL for those computations.... Or do you think there's an easier way to do just that??? (using a WPF-Canvas element for example???)

Thank's for the help!!
Iluvatar

I've taken the liberty to correct the link to the PDF in your post above, it didn't show.

There is no need to show the OpenGL window in order to render to it, but there must be a context present (need framebuffer and function pointers etc.). Also PBO and FBO Extensions can be used for offscreen rendering.

Another method to get the picture from WPF to OpenGL may simply be write it on the harddisk or some globally accessible public static Queue<Image> RawInput;

I haven't said anything to this yet, because I don't really see why they use OpenGL (besides speed) you can also implement this on the CPU with .Net 4 parallelism, it will probably be not as fast as the GPU version but it will be easier to tweak/adjust/improve (and most of all debug) the technique until it becomes what you want. When you are done with all features you want to add, then you can still port it to OpenGL or CL.

If you want to change it in some way, like drawing proper splines or allow the user to load some kind of layout texture which is used to further protect regions of the image, using GL is already an optimization and will make changing/debug things alot harder. (may break some assumptions the optimization is based on)
If it is exactly what you want and you don't need to change a bit, implement it with OpenGL/CL (for the benefit of speed).

From http://msdn.microsoft.com/en-us/library/system.windows.media.imaging.wri...

1. Call the Lock method to reserve the back buffer for updates.
2. Obtain a pointer to the back buffer by accessing the BackBuffer property.
3. Write changes to the back buffer. Other threads may write changes to the back buffer when the WriteableBitmap is locked.
4. Call the AddDirtyRect method to indicate areas that have changed.
5. Call the Unlock method to release the back buffer and allow presentation to the screen.

Ignore step 3&4, the IntPtr from BackBuffer can be fed to GL.TexImage2D. (examine Format property for other params)

Ok, I tried it out now,

I am able to create a Texture now, but I think my Pixel-Format was not right (was it??)!
When I saved the WriteableBitmap and the Bitmap to Disc I found out, that the Texture was in fact... black!
What I did, was exactly what you mentioned:

1. Locked the WriteableBitmap
2. Used the BackBuffer - Pointer and several other Properties from the WriteableBitmap to Set the Values of my BitmapData Object (which is used to Create the GLTexture2D)
3. Unlocke the WriteableBitmap again
4. Default .... MipMaps... Clamping....

Is it possible, that my Code for Reading the Pixels is not ok? I mean, I it is there, to just read Pixels from the actually bound FrameBuffer right (THEN I understand, why I only get black Images :) )?

Here is the Code for creating a Bitmap and for saving to a File (or is not working this way at all?)

        /// <summary>
        /// Returns a Bitmap with the contents of the current FrameBuffer
        /// </summary>
        /// <returns>The Bitmap containing the Data</returns>
        private Bitmap GetGLBitmapData()
        {
            ///Create the Bitmap
            m_bitmap = new Bitmap(Width, Height);
            m_data = m_bitmap.LockBits(new Rectangle(0, 0, Width, Height), ImageLockMode.WriteOnly, m_data.PixelFormat);
            GL.ReadPixels(0, 0, Width, Height, m_pixelFormat, PixelType.UnsignedByte, m_data.Scan0);
            m_bitmap.UnlockBits(m_data);
 
            ///Return the Bitmap
            return m_bitmap;
        }
        /// <summary>
        /// Save the Content of the FrameBuffer to a File
        /// </summary>
        public void SaveGLImage(String filename = "E:\\textureImage.png")
        {
            GetGLBitmapData().Save(filename, ImageFormat.Png);
        }

BUT: I found a way to create a System.Drawing.Bitmap out of a WriteableBitmap! It's only a hack, but for now it works :)

Here is the Code (implemented as an Extension and using a MemoryStream):

using System.Drawing;
using System.Windows.Media.Imaging;
using System.IO;
 
namespace Helper
{
    public static class ExtensionsHelper
    {
        /// <summary>
        /// Create Bitmap from a WriteableBitmap
        /// </summary>
        /// <param name="wrBitmap">The System.Media.Imaging.WriteableBitmap</param>
        /// <returns>The System.Drawing.Bitmap</returns>
        public static Bitmap GetBitmap(this WriteableBitmap wrBitmap)
        {
            using (MemoryStream mS = new MemoryStream())
            {
                PngBitmapEncoder encoder = new PngBitmapEncoder();
                encoder.Frames.Add(BitmapFrame.Create(wrBitmap));
                encoder.Save(mS);
                Bitmap result = new Bitmap(mS);
                mS.Close();
                return result;
            }
        }
    }
}

When I try to create a Bitmap using my "GetGLBitmapData()" , it doesn't show anything (only a black Image), but I think my Texture is well, because I just call my (well working and tested ) Constructor....
And if I save the converted System.Drawing.Bitmap to the Disc, the Image looks ok :)

I will continue, to tell you, if the Texture is ok :)