+ wxFAIL_MSG( wxT("Image conversion failed. Unknown visual type.") );
+ }
+
+ if (gdk_image_mask)
+ {
+ int mask_pixel = gdk_image_get_pixel( gdk_image_mask, i, j );
+ if (mask_pixel == 0)
+ {
+ data[pos] = 16;
+ data[pos+1] = 16;
+ data[pos+2] = 16;
+ }
+ }
+
+ pos += 3;
+ }
+ }
+
+ gdk_image_destroy( gdk_image );
+ if (gdk_image_mask) gdk_image_destroy( gdk_image_mask );
+}
+
+#endif
+
+//-----------------------------------------------------------------------------
+// Motif conversion routines
+//-----------------------------------------------------------------------------
+
+#ifdef __WXMOTIF__
+#ifdef __VMS__
+#pragma message disable nosimpint
+#endif
+#include <Xm/Xm.h>
+#ifdef __VMS__
+#pragma message enable nosimpint
+#endif
+#include "wx/utils.h"
+#include <math.h>
+
+/*
+
+Date: Wed, 05 Jan 2000 11:45:40 +0100
+From: Frits Boel <boel@niob.knaw.nl>
+To: julian.smart@ukonline.co.uk
+Subject: Patch for Motif ConvertToBitmap
+
+Hi Julian,
+
+I've been working on a wxWin application for image processing. From the
+beginning, I was surprised by the (lack of) speed of ConvertToBitmap,
+till I looked in the source code of image.cpp. I saw that converting a
+wxImage to a bitmap with 8-bit pixels is done with comparing every pixel
+to the 256 colors of the palet. A very time-consuming piece of code!
+
+Because I wanted a faster application, I've made a 'patch' for this. In
+short: every pixel of the image is compared to a sorted list with
+colors. If the color is found in the list, the palette entry is
+returned; if the color is not found, the color palette is searched and
+then the palette entry is returned and the color added to the sorted
+list.
+
+Maybe there is another method for this, namely changing the palette
+itself (if the colors are known, as is the case with tiffs with a
+colormap). I did not look at this, maybe someone else did?
+
+The code of the patch is attached, have a look on it, and maybe you will
+ship it with the next release of wxMotif?
+
+Regards,
+
+Frits Boel
+Software engineer at Hubrecht Laboratory, The Netherlands.
+
+*/
+
+class wxSearchColor
+{
+public:
+ wxSearchColor( void );
+ wxSearchColor( int size, XColor *colors );
+ ~wxSearchColor( void );
+
+ int SearchColor( int r, int g, int b );
+private:
+ int AddColor( unsigned int value, int pos );
+
+ int size;
+ XColor *colors;
+ unsigned int *color;
+ int *entry;
+
+ int bottom;
+ int top;
+};
+
+wxSearchColor::wxSearchColor( void )
+{
+ this->size = 0;
+ this->colors = (XColor*) NULL;
+ this->color = (unsigned int *) NULL;
+ this->entry = (int*) NULL;
+
+ this->bottom = 0;
+ this->top = 0;
+}
+
+wxSearchColor::wxSearchColor( int size, XColor *colors )
+{
+ int i;
+ this->size = size;
+ this->colors = colors;
+ this->color = new unsigned int[size];
+ this->entry = new int [size];
+
+ for (i = 0; i < this->size; i++ ) {
+ this->entry[i] = -1;
+ }
+
+ this->bottom = this->top = ( size >> 1 );
+}
+
+wxSearchColor::~wxSearchColor( void )
+{
+ if ( this->color ) delete this->color;
+ if ( this->entry ) delete this->entry;
+}
+
+int wxSearchColor::SearchColor( int r, int g, int b )
+{
+ unsigned int value = ( ( ( r * 256 ) + g ) * 256 ) + b;
+ int begin = this->bottom;
+ int end = this->top;
+ int middle;
+
+ while ( begin <= end ) {
+
+ middle = ( begin + end ) >> 1;
+
+ if ( value == this->color[middle] ) {
+ return( this->entry[middle] );
+ } else if ( value < this->color[middle] ) {
+ end = middle - 1;
+ } else {
+ begin = middle + 1;
+ }
+
+ }
+
+ return AddColor( value, middle );
+}
+
+int wxSearchColor::AddColor( unsigned int value, int pos )
+{
+ int i;
+ int pixel = -1;
+ int max = 3 * (65536);
+ for ( i = 0; i < 256; i++ ) {
+ int rdiff = ((value >> 8) & 0xFF00 ) - colors[i].red;
+ int gdiff = ((value ) & 0xFF00 ) - colors[i].green;
+ int bdiff = ((value << 8) & 0xFF00 ) - colors[i].blue;
+ int sum = abs (rdiff) + abs (gdiff) + abs (bdiff);
+ if (sum < max) { pixel = i; max = sum; }
+ }
+
+ if ( this->entry[pos] < 0 ) {
+ this->color[pos] = value;
+ this->entry[pos] = pixel;
+ } else if ( value < this->color[pos] ) {
+
+ if ( this->bottom > 0 ) {
+ for ( i = this->bottom; i < pos; i++ ) {
+ this->color[i-1] = this->color[i];
+ this->entry[i-1] = this->entry[i];
+ }
+ this->bottom--;
+ this->color[pos-1] = value;
+ this->entry[pos-1] = pixel;
+ } else if ( this->top < this->size-1 ) {
+ for ( i = this->top; i >= pos; i-- ) {
+ this->color[i+1] = this->color[i];
+ this->entry[i+1] = this->entry[i];
+ }
+ this->top++;
+ this->color[pos] = value;
+ this->entry[pos] = pixel;
+ }
+
+ } else {
+
+ if ( this->top < this->size-1 ) {
+ for ( i = this->top; i > pos; i-- ) {
+ this->color[i+1] = this->color[i];
+ this->entry[i+1] = this->entry[i];
+ }
+ this->top++;
+ this->color[pos+1] = value;
+ this->entry[pos+1] = pixel;
+ } else if ( this->bottom > 0 ) {
+ for ( i = this->bottom; i < pos; i++ ) {
+ this->color[i-1] = this->color[i];
+ this->entry[i-1] = this->entry[i];
+ }
+ this->bottom--;
+ this->color[pos] = value;
+ this->entry[pos] = pixel;
+ }
+
+ }
+
+ return( pixel );
+}
+
+wxBitmap wxImage::ConvertToBitmap() const
+{
+ wxBitmap bitmap;
+
+ wxCHECK_MSG( Ok(), bitmap, wxT("invalid image") );
+
+ int width = GetWidth();
+ int height = GetHeight();
+
+ bitmap.SetHeight( height );
+ bitmap.SetWidth( width );
+
+ Display *dpy = (Display*) wxGetDisplay();
+ Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
+ int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
+
+ // Create image
+
+ XImage *data_image = XCreateImage( dpy, vis, bpp, ZPixmap, 0, 0, width, height, 32, 0 );
+ data_image->data = (char*) malloc( data_image->bytes_per_line * data_image->height );
+
+ bitmap.Create( width, height, bpp );
+
+ /*
+ // Create mask
+
+ GdkImage *mask_image = (GdkImage*) NULL;
+
+ if (HasMask())
+ {
+ unsigned char *mask_data = (unsigned char*)malloc( ((width >> 3)+8) * height );
+
+ mask_image = gdk_image_new_bitmap( gdk_visual_get_system(), mask_data, width, height );
+
+ wxMask *mask = new wxMask();
+ mask->m_bitmap = gdk_pixmap_new( (GdkWindow*)&gdk_root_parent, width, height, 1 );
+
+ bitmap.SetMask( mask );
+ }
+ */
+
+ // Retrieve depth info
+
+ XVisualInfo vinfo_template;
+ XVisualInfo *vi;
+
+ vinfo_template.visual = vis;
+ vinfo_template.visualid = XVisualIDFromVisual( vis );
+ vinfo_template.depth = bpp;
+ int nitem = 0;
+
+ vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
+
+ wxCHECK_MSG( vi, wxNullBitmap, wxT("no visual") );
+
+ XFree( vi );
+
+ if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
+ if (bpp < 8) bpp = 8;
+
+ // Render
+
+ enum byte_order { RGB, RBG, BRG, BGR, GRB, GBR };
+ byte_order b_o = RGB;
+
+ if (bpp >= 24)
+ {
+ if ((vi->red_mask > vi->green_mask) && (vi->green_mask > vi->blue_mask)) b_o = RGB;
+ else if ((vi->red_mask > vi->blue_mask) && (vi->blue_mask > vi->green_mask)) b_o = RGB;
+ else if ((vi->blue_mask > vi->red_mask) && (vi->red_mask > vi->green_mask)) b_o = BRG;
+ else if ((vi->blue_mask > vi->green_mask) && (vi->green_mask > vi->red_mask)) b_o = BGR;
+ else if ((vi->green_mask > vi->red_mask) && (vi->red_mask > vi->blue_mask)) b_o = GRB;
+ else if ((vi->green_mask > vi->blue_mask) && (vi->blue_mask > vi->red_mask)) b_o = GBR;
+ }
+
+ /*
+ int r_mask = GetMaskRed();
+ int g_mask = GetMaskGreen();
+ int b_mask = GetMaskBlue();
+ */
+
+ XColor colors[256];
+ if (bpp == 8)
+ {
+ Colormap cmap = (Colormap) wxTheApp->GetMainColormap( dpy );
+
+ for (int i = 0; i < 256; i++) colors[i].pixel = i;
+ XQueryColors( dpy, cmap, colors, 256 );
+ }
+
+ wxSearchColor scolor( 256, colors );
+ unsigned char* data = GetData();
+
+ int index = 0;
+ for (int y = 0; y < height; y++)
+ {
+ for (int x = 0; x < width; x++)
+ {
+ int r = data[index];
+ index++;
+ int g = data[index];
+ index++;
+ int b = data[index];
+ index++;
+
+ /*
+ if (HasMask())
+ {
+ if ((r == r_mask) && (b == b_mask) && (g == g_mask))
+ gdk_image_put_pixel( mask_image, x, y, 1 );
+ else
+ gdk_image_put_pixel( mask_image, x, y, 0 );
+ }
+ */
+
+ switch (bpp)
+ {
+ case 8:
+ {
+#if 0 // Old, slower code
+ int pixel = -1;
+ /*
+ if (wxTheApp->m_colorCube)
+ {
+ pixel = wxTheApp->m_colorCube
+ [ ((r & 0xf8) << 7) + ((g & 0xf8) << 2) + ((b & 0xf8) >> 3) ];
+ }
+ else
+ {
+ */
+ int max = 3 * (65536);
+ for (int i = 0; i < 256; i++)
+ {
+ int rdiff = (r << 8) - colors[i].red;
+ int gdiff = (g << 8) - colors[i].green;
+ int bdiff = (b << 8) - colors[i].blue;
+ int sum = abs (rdiff) + abs (gdiff) + abs (bdiff);
+ if (sum < max) { pixel = i; max = sum; }
+ }
+ /*
+ }
+ */
+#endif
+
+ // And this is all to get the 'right' color...
+ int pixel = scolor.SearchColor( r, g, b );
+ XPutPixel( data_image, x, y, pixel );
+ break;
+ }
+ case 15:
+ {
+ int pixel = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
+ XPutPixel( data_image, x, y, pixel );
+ break;
+ }
+ case 16:
+ {
+ int pixel = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
+ XPutPixel( data_image, x, y, pixel );
+ break;
+ }
+ case 32:
+ case 24:
+ {
+ int pixel = 0;
+ switch (b_o)
+ {
+ case RGB: pixel = (r << 16) | (g << 8) | b; break;
+ case RBG: pixel = (r << 16) | (b << 8) | g; break;
+ case BRG: pixel = (b << 16) | (r << 8) | g; break;
+ case BGR: pixel = (b << 16) | (g << 8) | r; break;
+ case GRB: pixel = (g << 16) | (r << 8) | b; break;
+ case GBR: pixel = (g << 16) | (b << 8) | r; break;
+ }
+ XPutPixel( data_image, x, y, pixel );
+ }
+ default: break;
+ }
+ } // for
+ } // for
+
+ // Blit picture
+
+ XGCValues gcvalues;
+ gcvalues.foreground = BlackPixel( dpy, DefaultScreen( dpy ) );
+ GC gc = XCreateGC( dpy, RootWindow ( dpy, DefaultScreen(dpy) ), GCForeground, &gcvalues );
+ XPutImage( dpy, (Drawable)bitmap.GetPixmap(), gc, data_image, 0, 0, 0, 0, width, height );
+
+ XDestroyImage( data_image );
+ XFreeGC( dpy, gc );
+
+ /*
+ // Blit mask
+
+ if (HasMask())
+ {
+ GdkGC *mask_gc = gdk_gc_new( bitmap.GetMask()->GetBitmap() );
+
+ gdk_draw_image( bitmap.GetMask()->GetBitmap(), mask_gc, mask_image, 0, 0, 0, 0, width, height );
+
+ gdk_image_destroy( mask_image );
+ gdk_gc_unref( mask_gc );
+ }
+ */
+
+ return bitmap;
+}
+
+wxImage::wxImage( const wxBitmap &bitmap )
+{
+ wxCHECK_RET( bitmap.Ok(), wxT("invalid bitmap") );
+
+ Display *dpy = (Display*) wxGetDisplay();
+ Visual* vis = DefaultVisual( dpy, DefaultScreen( dpy ) );
+ int bpp = DefaultDepth( dpy, DefaultScreen( dpy ) );
+
+ XImage *ximage = XGetImage( dpy,
+ (Drawable)bitmap.GetPixmap(),
+ 0, 0,
+ bitmap.GetWidth(), bitmap.GetHeight(),
+ AllPlanes, ZPixmap );
+
+ wxCHECK_RET( ximage, wxT("couldn't create image") );
+
+ Create( bitmap.GetWidth(), bitmap.GetHeight() );
+ char unsigned *data = GetData();
+
+ if (!data)
+ {
+ XDestroyImage( ximage );
+ wxFAIL_MSG( wxT("couldn't create image") );
+ return;
+ }
+
+ /*
+ GdkImage *gdk_image_mask = (GdkImage*) NULL;
+ if (bitmap.GetMask())
+ {
+ gdk_image_mask = gdk_image_get( bitmap.GetMask()->GetBitmap(),
+ 0, 0,
+ bitmap.GetWidth(), bitmap.GetHeight() );
+
+ SetMaskColour( 16, 16, 16 ); // anything unlikely and dividable
+ }
+ */
+
+ // Retrieve depth info
+
+ XVisualInfo vinfo_template;
+ XVisualInfo *vi;
+
+ vinfo_template.visual = vis;
+ vinfo_template.visualid = XVisualIDFromVisual( vis );
+ vinfo_template.depth = bpp;
+ int nitem = 0;
+
+ vi = XGetVisualInfo( dpy, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
+
+ wxCHECK_RET( vi, wxT("no visual") );
+
+ if ((bpp == 16) && (vi->red_mask != 0xf800)) bpp = 15;
+
+ XFree( vi );
+
+ XColor colors[256];
+ if (bpp == 8)
+ {
+ Colormap cmap = (Colormap)wxTheApp->GetMainColormap( dpy );
+
+ for (int i = 0; i < 256; i++) colors[i].pixel = i;
+ XQueryColors( dpy, cmap, colors, 256 );
+ }
+
+ long pos = 0;
+ for (int j = 0; j < bitmap.GetHeight(); j++)
+ {
+ for (int i = 0; i < bitmap.GetWidth(); i++)
+ {
+ int pixel = XGetPixel( ximage, i, j );
+ if (bpp <= 8)
+ {
+ data[pos] = colors[pixel].red >> 8;
+ data[pos+1] = colors[pixel].green >> 8;
+ data[pos+2] = colors[pixel].blue >> 8;
+ } else if (bpp == 15)
+ {
+ data[pos] = (pixel >> 7) & 0xf8;
+ data[pos+1] = (pixel >> 2) & 0xf8;
+ data[pos+2] = (pixel << 3) & 0xf8;
+ } else if (bpp == 16)
+ {
+ data[pos] = (pixel >> 8) & 0xf8;
+ data[pos+1] = (pixel >> 3) & 0xfc;
+ data[pos+2] = (pixel << 3) & 0xf8;
projects / wxWidgets.git / blobdiff