OpenGl 16-Bit-Anzeige über Tao / C #

Question

Ich habe einige wissenschaftlichen Bilddaten, die in einem 16-Bit-Bereich aus einer Detektoreinrichtung kommen, die dann in einem Bild gerendert werden. Um diese Daten anzuzeigen, ich bin mit OpenGL, weil es ushorts als Teil der Bibliothek unterstützen sollte. Ich habe es geschafft, diese Daten in Texturen erhalten Rendering auf einer OpenGL-1.4-Plattform, eine Einschränkung, die eine Voraussetzung für dieses Projekt ist.

Leider sind die resultierenden Texturen schauen, wie sie auf 8 Bit reduziert sind zu werden, anstatt 16 Bit. I testen dies durch ein Gradientenbild Erzeugen und Anzeigen es; andere zeigen sich als gleiche Werte nächsten, während das Bild sich um jedes Pixel verschieden von seinen Nachbarn hat, wird der angezeigte Textur Streifenmuster zeigt, in dem alle Pixel eins ist.

Ich habe versucht, dies zu tun mit glDrawPixels, und das resultierende Bild sieht tatsächlich aus wie es wirklich alle 16-Bit-Rendering.

Wie kann ich diese Texturen zwingen korrekt angezeigt werden?

mehr Hintergrund zu geben, die LUT (Lookup-Tabelle) wird durch den folgenden Code bestimmt wird:

        String str = "!!ARBfp1.0\n" +
            "ATTRIB tex = fragment.texcoord[0];\n" +
            "PARAM cbias = program.local[0];\n" +
            "PARAM cscale = program.local[1];\n" +
            "OUTPUT cout = result.color;\n" +

            "TEMP tmp;\n" +
            "TXP tmp, tex, texture[0], 2D;\n" +
            "SUB tmp, tmp, cbias;\n" +
            "MUL cout, tmp, cscale;\n" +
            "END";

        Gl.glEnable(Gl.GL_FRAGMENT_PROGRAM_ARB);
        Gl.glGenProgramsARB(1, out mFragProg);
        Gl.glBindProgramARB(Gl.GL_FRAGMENT_PROGRAM_ARB, mFragProg);

        System.Text.Encoding ascii = System.Text.Encoding.ASCII;
        Byte[] encodedBytes = ascii.GetBytes(str);
        Gl.glProgramStringARB(Gl.GL_FRAGMENT_PROGRAM_ARB, Gl.GL_PROGRAM_FORMAT_ASCII_ARB, 
            count, encodedBytes);

        GetGLError("Shader");
        Gl.glDisable(Gl.GL_FRAGMENT_PROGRAM_ARB);

Wo CBIAS und CSCALE sind zwischen 0 und 1.

Danke!

EDIT: um einige der anderen Fragen, die Zeile mit glTexImage zu beantworten:

        Gl.glBindTexture(Gl.GL_TEXTURE_2D, inTexData.TexName);

        Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_LUMINANCE, inTexData.TexWidth, inTexData.TexHeight,
            0, Gl.GL_LUMINANCE, Gl.GL_UNSIGNED_SHORT, theTexBuffer);

        Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR);   // Linear Filtering
        Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR);   // Linear Filtering

        theTexBuffer = null;
        GC.Collect();
        GC.WaitForPendingFinalizers();

Das Pixelformat wird gesetzt, wenn der Kontext initialisiert wird:

        Gdi.PIXELFORMATDESCRIPTOR pfd = new Gdi.PIXELFORMATDESCRIPTOR();// The pixel format descriptor
        pfd.nSize = (short)Marshal.SizeOf(pfd);                        // Size of the pixel format descriptor
        pfd.nVersion = 1;                                               // Version number (always 1)
        pfd.dwFlags = Gdi.PFD_DRAW_TO_WINDOW |                          // Format must support windowed mode
                    Gdi.PFD_SUPPORT_OPENGL |                            // Format must support OpenGL
                    Gdi.PFD_DOUBLEBUFFER;                               // Must support double buffering
        pfd.iPixelType = (byte)Gdi.PFD_TYPE_RGBA;                      // Request an RGBA format
        pfd.cColorBits = (byte)colorBits;                              // Select our color depth
        pfd.cRedBits = 0;                                               // Individual color bits ignored
        pfd.cRedShift = 0;
        pfd.cGreenBits = 0;
        pfd.cGreenShift = 0;
        pfd.cBlueBits = 0;
        pfd.cBlueShift = 0;
        pfd.cAlphaBits = 0;                                             // No alpha buffer
        pfd.cAlphaShift = 0;                                            // Alpha shift bit ignored
        pfd.cAccumBits = 0;                                     // Accumulation buffer
        pfd.cAccumRedBits = 0;                                          // Individual accumulation bits ignored
        pfd.cAccumGreenBits = 0;
        pfd.cAccumBlueBits = 0;
        pfd.cAccumAlphaBits = 0;
        pfd.cDepthBits = 16;                                     // Z-buffer (depth buffer)
        pfd.cStencilBits = 0;                                 // No stencil buffer
        pfd.cAuxBuffers = 0;                                            // No auxiliary buffer
        pfd.iLayerType = (byte)Gdi.PFD_MAIN_PLANE;                     // Main drawing layer
        pfd.bReserved = 0;                                              // Reserved
        pfd.dwLayerMask = 0;                                            // Layer masks ignored
        pfd.dwVisibleMask = 0;
        pfd.dwDamageMask = 0;

        pixelFormat = Gdi.ChoosePixelFormat(mDC, ref pfd);    // Attempt to find an appropriate pixel format

        if (!Gdi.SetPixelFormat(mDC, pixelFormat, ref pfd))
        {  // Are we not able to set the pixel format?
            BigMessageBox.ShowMessage("Can not set the chosen PixelFormat.  Chosen PixelFormat was " + pixelFormat + ".");
            Environment.Exit(-1);
        }

Answer 1

Wenn Sie eine Textur erstellen die ‚Typ‘ Parameter von glTexImage ist nur die Daten geben Sie Ihre Texturdaten in ist, bevor es von OpenGL in ein eigenes Format konvertiert wird. Um eine Textur zu erstellen mit 16 Bit pro Kanal, den Sie so etwas wie GL_LUMINANCE16 als Format benötigen (internes Format bleibt GL_LUMINANCE). Wenn es keine GL_LUMINANCE16 für OpenGL 1.4 zu überprüfen, ob GL_EXT_texture verfügbar ist, und versuchen Sie es mit GL_LUMINANCE16_EXT.

Eine davon sollte funktionieren. Wenn es jedoch nicht, Sie können Ihre 16-Bit-Werte als zwei 8-Bit-Paare mit GL_LUMINANCE_ALPHA kodieren und dekodieren sie wieder in einem Shader.

Answer 2

Ich habe nie gearbeitet höher in Tiefen (tiefer) als 8bit pro Kanal, aber hier ist, was ich würde versuchen, zuerst:

Schalten Sie Filterung auf die Textur und sehen, wie er den Ausgang beeinflusst.

Set Texturierung glHints zu bester Qualität.

Answer 3

Sie könnten erwägen, einen einzelnen Kanal mit Floating-Point-Textur durch eine der GL_ARB_texture_float, GL_ATI_texture_float oder GL_NV_float_buffer Erweiterungen, wenn die Hardware dies unterstützt, kann ich mich nicht erinnern, ob GL 1.4 hat Punkt Texturen schwimmend oder nicht though.