GLPixelCanvasColorTable.h

Go to the documentation of this file.

//# GLPixelCanvasColorTable.h: color table provision for X11 devices
//# Copyright (C) 2001
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//#        Internet email: aips2-request@nrao.edu.
//#        Postal address: AIPS++ Project Office
//#                        National Radio Astronomy Observatory
//#                        520 Edgemont Road
//#                        Charlottesville, VA 22903-2475 USA
//#
//# $Id$

#ifndef TRIALDISPLAY_GLPIXELCANVASCOLORTABLE_H
#define TRIALDISPLAY_GLPIXELCANVASCOLORTABLE_H

#include <casa/aips.h>
#include <graphics/X11/X11Util.h>

#include <graphics/X11/X_enter.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <graphics/X11/X_exit.h>

#include <casa/Arrays/Vector.h>
#include <display/Display/DisplayEnums.h>
#include <display/Display/PixelCanvasColorTable.h>


namespace casa { //# NAMESPACE CASA - BEGIN

// <summary>
// Implementation of PixelCanvasColorTable for OpenGL.
// </summary>
// <synopsis>
// GLPixelCanvasColorTable is an X11PixelCanvasColorTable that has been
// modified to work within the constraints of the GLPixelCanvas. (e.g. Not
// assuming the default visual).
//
// Colormap values are written to a virtual colortable (an internal array).
// For Indexed (PseudoColor) windows, the values are sent to the hardware
// colormap. For RGB (TrueColor) windows, the virtual colortable is used
// to emulate a hardware lookup table.
// </synopsis>
//
// <prerequisite>
// <li> <linkto class="PixelCanvasColorTable">PixelCanvasColorTable</linkto>
// <li> How to get the X Screen pointer.
// </prerequisite>
//
// <etymology>
// </etymology>
//
// <thrown>
//    AipsError
// </thrown>
// <use visibility=export>

// Colormap entry for the virtual colormap.
        class GLVColorTableEntry {
        public:
                GLVColorTableEntry();

                void operator=(const GLVColorTableEntry &);

                // Store/get the values.
                void put(const float red, const float green, const float blue) {
                        red_ = red;
                        green_ = green;
                        blue_ = blue;
                }

                void get(float &red, float &green, float &blue)const {
                        red = red_;
                        green = green_;
                        blue = blue_;
                }

                uInt    getIndex()const {
                        return index_;
                }
                void    setIndex(const uInt i) {
                        index_ = i;
                }

                uLong getPixel()const {
                        return pixel_;
                }
                void setPixel(const unsigned long p) {
                        pixel_ = p;
                }

                friend ostream &operator<<(ostream &s, const GLVColorTableEntry &x);

        private:
                uInt    index_;                 // Index into map for this entry.
                uLong   pixel_;                 // Real index or color value.
                float   red_, green_, blue_;    // Color component values. (0..1).
        };

        class GLPixelCanvasColorTable : public PixelCanvasColorTable {
        public:

                // <group>
                GLPixelCanvasColorTable();

                ~GLPixelCanvasColorTable();

                GLPixelCanvasColorTable(::XDisplay *dpy,
                                        Display::ColorModel mapType = Display::RGB,
                                        Float percent=90.0,
                                        XVisualInfo *visInfo=NULL);
                // </group>

                // allocate cells for colormaps
                Bool allocCells(uInt nCells);

                // deallocate cells for colormaps
                Bool deallocCells();

                // Allocate the best color cube given the map
                Bool allocColorCube();
                // Allocate a color cube of a specific size
                Bool allocColorCube(uInt n1, uInt n2, uInt n3);
                // Allocate a color cube within the ranges of sizes
                Bool allocColorCubeMinMax(uInt n1min, uInt n2min, uInt n3min,
                                          uInt n1max, uInt n2max, uInt n3max);
                // Copy color cube info from the mapRef
                void copyColorCube(const GLPixelCanvasColorTable & mapRef);
                // Fill a color cube with an RGB spectrum
                void fillColorCubeRGB();
                enum FILLMODE {FILLRGB, FILLRBG, FILLGRB, FILLGBR, FILLBRG, FILLBGR};
                static void colorFillRGB(
                    Vector<Float> &r, Vector<Float> &g, Vector<Float> &b,
                    uInt nr, uInt ng, uInt nb,
                    FILLMODE mode = FILLRGB);

                static void colorFillRGB(
                    Vector<Float> &r, Vector<Float> &g, Vector<Float> &b,
                    uInt ncolors, FILLMODE mode= FILLRGB);
                // Fill a color cube with an HSV spectrum
                void fillColorCubeHSV();

                // Merge separate channel data into an output image.
                // This function maps floating values between 0 and 1
                // into a output image suitable for PixelCanvas::drawImage().
                // <group>
                void mapToColor3(Array<uLong> & out,
                                 const Array<Float> & chan1in,
                                 const Array<Float> & chan2in,
                                 const Array<Float> & chan3in);
                void mapToColor3(Array<uLong> & out,
                                 const Array<Double> & chan1in,
                                 const Array<Double> & chan2in,
                                 const Array<Double> & chan3in);
                // </group>

                // This one maps values between 0 and the integer
                // maximum value for each channel into a single
                // output image suitable for PixelCanvas::drawImage().
                // <group>
                void mapToColor3(Array<uLong> & out,
                                 const Array<uShort> & chan1in,
                                 const Array<uShort> & chan2in,
                                 const Array<uShort> & chan3in);
                void mapToColor3(Array<uLong> & out,
                                 const Array<uInt> & chan1in,
                                 const Array<uInt> & chan2in,
                                 const Array<uInt> & chan3in);
                // </group>

                // (Multichannel Color)
                // Transform arrays from the passed color model into
                // the colormodel of the XPCCT.
                // Does nothing if colorModel is Display::Index.
                // It is assumed that input arrays are in the range of [0,1]
                Bool colorSpaceMap(Display::ColorModel,
                                   const Array<Float> & chan1in,
                                   const Array<Float> & chan2in,
                                   const Array<Float> & chan3in,
                                   Array<Float> & chan1out,
                                   Array<Float> & chan2out,
                                   Array<Float> & chan3out);

                // map [0,N-1] into colorpixels, where N is the current colormap size
                // The values are returned as unsigned integers in their respective
                // array.
                // <note role="warning">uChar type may not have enough bits
                // to hold the pixel index on some high-end graphics systems </note>
                // <note role="warning">uShort type may not have enough bits
                // to hold the pixel index on some high-end graphics systems </note>
                // <group>
                void mapToColor(const Colormap * map, Array<uChar> & outArray,
                                const Array<uChar> & inArray, Bool rangeCheck = True) const;
                void mapToColor(const Colormap * map, Array<uShort> & outArray,
                                const Array<uShort> & inArray, Bool rangeCheck = True) const;
                void mapToColor(const Colormap * map, Array<uInt> & outArray,
                                const Array<uInt> & inArray, Bool rangeCheck = True) const;
                void mapToColor(const Colormap * map, Array<uLong> & outArray,
                                const Array<uLong> & inArray, Bool rangeCheck = True) const;
                // </group>

                // same as above except the matrix is operated on in place.  Only unsigned
                // values make sense here.
                // <group>
                void mapToColor(const Colormap * map, Array<uChar> & inOutArray,
                                Bool rangeCheck = True) const;
                void mapToColor(const Colormap * map, Array<uShort> & inOutArray,
                                Bool rangeCheck = True) const;
                void mapToColor(const Colormap * map, Array<uInt> & inOutArray,
                                Bool rangeCheck = True) const;
                void mapToColor(const Colormap * map, Array<uLong> & inOutArray,
                                Bool rangeCheck = True) const;
                // </group>

                // print details of class to ostream
                friend ostream & operator << (ostream & os, const GLPixelCanvasColorTable & pcc);

                // Is the hardware colormap resizeable?  ie. is it write-only?
                virtual Bool staticSize() {
                        return (readOnly_ && decomposedIndex_);
                }

                // resize the map if allowed.  Returns True if resize was accepted
                // <group>
                Bool resize(uInt newSize);
                Bool resize(uInt nReds, uInt nGreens, uInt nBlues);
                // </group>

                // Install colors into the color table. Offset is zero-based. Colors
                // are installed into the PixelCanvasColorTable until the Arrays run out
                // or until the end of the colortable is reached.  This only has an
                // effect if the ColorModel is Index.  Values are clamped to [0.0,1.0].
                Bool installRGBColors(const Vector<Float> & r, const Vector<Float> & g,
                                      const Vector<Float> & b, uInt offset = 0);

                // Return the total number of RW colors currently in use.
                uInt nColors() const;

                // Return the number of colors per component in the map.  Throws
                // an exception if this is not an HSV or RGB ColorTable.
                virtual void nColors(uInt &n1, uInt &n2, uInt &n3) const;

                // Return the depth in bits of the colors
                uInt depth() const;

                // Return the number of colors that are still unallocated
                uInt nSpareColors() const;

                // Return pointer to display that is being used
                ::XDisplay * display() const;
                // Return pointer to screen that is being used
                Screen * screen() const;
                // Return pointer to visual that is being used
                Visual * visual() const;
                // Return pointer to visual info that is being used
                XVisualInfo *visualInfo() const {
                        return visualInfo_;
                }
                // Return XID of X "virtual colormap" being used
                XColormap xcmap() const;

                // Return True if the table is in colorIndex mode
                Bool indexMode() const {
                        return (colorModel_ == Display::Index);
                }
                // Return True if the table is in RGB mode
                Bool rgbMode() const {
                        return (colorModel_ == Display::RGB);
                }
                // Return True if the table is in HSV mode
                Bool hsvMode() const {
                        return (colorModel_ == Display::HSV);
                }

                // Return True if the colortable can be resized.
                Bool rigid() const {
                        return rigid_;
                }

                // Return the color model for multichannel color
                Display::ColorModel colorModel() const {
                        return colorModel_;
                }
                Bool readOnly()const {
                        return readOnly_;
                }
                Bool decomposedIndex()const {
                        return decomposedIndex_;
                }
                // Return the number of currently unallocated cells that can be allocated RW.
                uInt QueryColorsAvailable(const Bool contig)const;
                virtual uInt QueryHWColorsAvailable(const Bool contig)const;
                // Convert a virtual index to a physical pixel.
                Bool virtualToPhysical(const unsigned long vindex,
                                       unsigned long &pindex)const;
                // Store an RGB value at index. For RGV visuals, only the virtual colormap
                // is updated.
                void storeColor(const uInt index,
                                const float r, const float g, const float b);
                // Convert a pixel to color components. If decomposed index (eg TC),
                // the pixel contains the color information. Otherwise, (eg. PseudoColor),
                // The information is looked up in the virtual colormap.
                void pixelToComponents(const uLong pixel, Float &r, Float &g, Float &b);
                // Return a GL capable visual that supports the colormodel or NULL.
                static XVisualInfo *getVisualInfo(::XDisplay *dpy,
                                                  const Display::ColorModel colormodel);
                // Returns the color values for the index. (Inverse of installRGBColors()).
                void indexToRGB(const uInt index, float &r, float &g, float &b);
        private:

                // Return the log power 2 of n and return True if n is
                // a power of two.  Otherwise return false.
                Bool isPow2(uInt n, uInt & log2n);

                // (Multi-Channel)
                void setupColorCube(uLong n1, uLong n2, uLong n3,
                                    uLong n1m, uLong n2m, uLong n3m);
                // (Multi-Channel)
                void setupStandardMapping(const XStandardColormap * mapInfo);

                Bool initVisual(XVisualInfo *vi=NULL);
                // A pointer to the XDisplay
                ::XDisplay * display_;
                // A pointer the the X Screen
                Screen * screen_;
                // A pointer to the X Visual
                Visual * visual_;
                XVisualInfo *visualInfo_;
                // A pointer to the XColormap (X Hardware colormap)
                XColormap xcmap_;

                // (Valid Always) number of bits of depth
                uInt depth_;
                // (Valid Always) number of total colors available for RW.
                uInt nColors_;
                // (Valid only when implementation uses a PseudoColor or a
                // StaticColor visual).  Table of color indices available.
                uLong * colors_;        // converts pixel index into vcmap index. Always valid.
                uShort vcmapLength_;    // Length of virtual colormap.
                // (& HW map if it exists)
                GLVColorTableEntry *vcmap_;
                // (Valid Always)
                // True if the table may not be resized, such as when a
                // standard XColormap is used.  Generally this is set to True
                // unless the visual is PseudoColor/StaticColor and the color
                // model is Display::Index.
                Bool rigid_;
                // True if the colormap is read only.
                Bool    readOnly_;
                // True if TrueColor or DirectColor.
                Bool  decomposedIndex_;
                void checkVisual();
                // Write an RGB value to hardware colormap at physical index.
                // (Called by storeColor()).
                virtual void storeHWColor(const uLong pindex,
                                          const float r, const float g, const float b);
                // Shift counts, masks, and max values used to build pixels for
                // decomposed index colormaps.
                unsigned short red_shift_, green_shift_, blue_shift_;
                unsigned short red_max_, green_max_, blue_max_;
                unsigned long red_mask_, green_mask_, blue_mask_;
                // Convert from integer HSV components to RGB pixel components.
                void HSV2RGB(const uLong H, const uLong S, const uLong V,
                             uLong &R, uLong &G, uLong &B);
                uInt HSV2Index(float h, float s, float v);

                // (Valid only for multi-channel color modes (RGB, HSV, etc))
                // If true, then the color cube's sides are powers of two,
                // making indexing possible with shift/add using the values of
                // <nBits1_, nBits2_, nBits3_>.  If not true, indexing
                // using <n1_,n2_,n3_> and multiplication is required.
                Bool pow2Mapping_;

                // (Valid Always)
                // The colormodel that this GLPixelCanvasColorTable has been
                // configured as.
                Display::ColorModel colorModel_;

                // (Valid only for multi-channel color modes (RGB, HSV, etc))
                // Represents the first cell used for the color cube.
                // baseColor_ is zero for PseudoColor/StaticColor implementations
                // because they use a table.
                uLong baseColor_;

                // (Valid only for multi-channel color modes (RGB, HSV, etc))
                // Specifies the color resolution for each side of the
                // color cube.
                // index = n1Mult_*R + n2Mult_*G + n3Mult_*B for RGB in
                // the range of <[0,n1_-1],[0,n2_-1],[0,n3_-1]>
                // <group>
                uInt n1_;
                uInt n2_;
                uInt n3_;

                uInt n1Mult_;
                uInt n2Mult_;
                uInt n3Mult_;
                // </group>

                // (Valid only for multi-channel color modes (RGB, HSV, etc))
                // and when pow2Mapping is true.
                // index = (R << n1Shift_) | (G << n2Shift_) | (B << n3Shift_)
                // for RGB the range of <[0,n1_-1],[0,n2_-1],[0,n3_-1]>
                // <group>
                uInt n1Shift_;
                uInt n2Shift_;
                uInt n3Shift_;
                // </group>
        };


} //# NAMESPACE CASA - END
#ifndef AIPS_NO_TEMPLATE_SRC
#include <display/Display/GLPCColTblTemplates.tcc>
#endif
#endif