本文整理汇总了C++中wxImage::GetRed方法的典型用法代码示例。如果您正苦于以下问题:C++ wxImage::GetRed方法的具体用法?C++ wxImage::GetRed怎么用?C++ wxImage::GetRed使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类wxImage
的用法示例。
在下文中一共展示了wxImage::GetRed方法的11个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1:
/* static */
String
XFace::ConvertImgToXFaceData(wxImage &img)
{
int l, n, i;
int value;
String dataString;
String tmp;
for(l = 0; l < 48; l++)
{
for(n = 0; n <= 32; n+= 16)
{
value = 0;
for(i = 0; i < 16; i++)
{
if(img.GetRed(n+i,l) != 0)
value += 1;
if(i != 15)
value <<= 1;
}
value = value ^ 0xffff;
tmp.Printf(_T("0x%04lX"), (unsigned long)value);
dataString += tmp;
dataString += _T(',');
}
dataString += _T('\n');
}
return dataString;
}
示例2: tintImage
wxImage tintImage( wxImage to_colorize, wxColour col)
{
wxImage highlightIcon(to_colorize.GetWidth(),to_colorize.GetHeight());
bool do_alpha = false;
if(to_colorize.HasAlpha())
{
highlightIcon.InitAlpha();
do_alpha = true;
}
else if(to_colorize.HasMask())
{
highlightIcon.SetMaskFromImage(to_colorize,to_colorize.GetMaskRed(),to_colorize.GetMaskGreen(),to_colorize.GetMaskBlue());
}
for(int x = 0; x < highlightIcon.GetWidth(); x++)
{
for(int y = 0; y < highlightIcon.GetHeight(); y++)
{
to_colorize.GetData();
unsigned char srcR = to_colorize.GetRed(x,y);
unsigned char srcG = to_colorize.GetGreen(x,y);
unsigned char srcB = to_colorize.GetBlue(x,y);
highlightIcon.SetRGB(x,y,(srcR + col.Red())/2,(srcG + col.Green())/2, (srcB + col.Blue())/2);
if(do_alpha)
highlightIcon.SetAlpha(x,y,to_colorize.GetAlpha(x,y));
}
}
return highlightIcon;
}
示例3: IsImagePixelOfColor
/**
* Predicate to check an image pixel matches color and alpha
*
* @param aImage the image to check
* @param aX pixel x-coordinate
* @param aY pixel y-coordinate
* @param aColor expected color (alpha is 1.0 if image doesn't support alpha)
* @return true if colour match
*/
bool IsImagePixelOfColor( const wxImage& aImage, int aX, int aY, const KIGFX::COLOR4D& aColor )
{
const wxSize imageSize = aImage.GetSize();
if( imageSize.x < aX || imageSize.y < aY )
{
BOOST_TEST_INFO( "Pixel (" << aX << ", " << aY << "is not in image of size (" << imageSize.x
<< ", " << imageSize.y << ")" );
return false;
}
const int r = aImage.GetRed( aX, aY );
const int g = aImage.GetGreen( aX, aY );
const int b = aImage.GetBlue( aX, aY );
const int a = aImage.HasAlpha() ? aImage.GetAlpha( aX, aY ) : 255;
if( !KI_TEST::IsColorNearHex( aColor, r, g, b, a ) )
{
BOOST_TEST_INFO( "Colour doesn't match: got rgba(" << r << ", " << g << ", " << b << ", "
<< a << "), expected " << aColor );
return false;
}
return true;
}
示例4: wxAntiAlias2
// Suggestion by Carlos Moreno
wxImage wxAntiAlias2(const wxImage& image)
{
wxImage anti(image.GetWidth(), image.GetHeight());
/* This is quite slow, but safe. Use wxImage::GetData() for speed instead. */
for (int y = 1; y < image.GetHeight() - 1; y++)
for (int x = 1; x < image.GetWidth() - 1; x++)
{
long red =
((int) image.GetRed( x-1, y-1 )) * 1 +
((int) image.GetRed( x, y-1 )) * 4 +
((int) image.GetRed( x+1, y-1 )) * 1 +
((int) image.GetRed( x+1, y )) * 4 +
((int) image.GetRed( x+1, y+1 )) * 1 +
((int) image.GetRed( x, y+1 )) * 4 +
((int) image.GetRed( x-1, y+1 )) * 1 +
((int) image.GetRed( x-1, y )) * 4 +
((int) image.GetRed( x, y )) * 20 ;
red = red/40;
long green =
((int) image.GetGreen( x-1, y-1 )) * 1 +
((int) image.GetGreen( x, y-1 )) * 4 +
((int) image.GetGreen( x+1, y-1 )) * 1 +
((int) image.GetGreen( x+1, y )) * 4 +
((int) image.GetGreen( x+1, y+1 )) * 1 +
((int) image.GetGreen( x, y+1 )) * 4 +
((int) image.GetGreen( x-1, y+1 )) * 1 +
((int) image.GetGreen( x-1, y )) * 4 +
((int) image.GetGreen( x, y )) * 20 ;
green = green/40;
long blue =
((int) image.GetBlue( x-1, y-1 )) * 1 +
((int) image.GetBlue( x, y-1 )) * 4 +
((int) image.GetBlue( x+1, y-1 )) * 1 +
((int) image.GetBlue( x+1, y )) * 4 +
((int) image.GetBlue( x+1, y+1 )) * 1 +
((int) image.GetBlue( x, y+1 )) * 4 +
((int) image.GetBlue( x-1, y+1 )) * 1 +
((int) image.GetBlue( x-1, y )) * 4 +
((int) image.GetBlue( x, y )) * 20 ;
blue = blue/40;
anti.SetRGB( x, y, (wxChar) red, (wxChar) green, (wxChar) blue );
}
return anti;
}
示例5: wxAntiAlias
wxImage wxAntiAlias(const wxImage& image)
{
wxImage anti(image.GetWidth(), image.GetHeight());
/* This is quite slow, but safe. Use wxImage::GetData() for speed instead. */
for (int y = 0; y < image.GetHeight(); y++)
{
for (int x = 0; x < image.GetWidth(); x++)
{
if (y == 0 || x == 0 ||
x == (image.GetWidth() - 1) ||
y == (image.GetHeight() - 1))
{
anti.SetRGB(x, y, image.GetRed(x, y), image.GetGreen(x, y), image.GetBlue(x, y));
}
else
{
int red = (int) image.GetRed( x, y ) +
(int) image.GetRed( x-1, y ) +
(int) image.GetRed( x, y+1 ) +
(int) image.GetRed( x+1, y+1 );
red = red/4;
int green = (int) image.GetGreen( x, y ) +
(int) image.GetGreen( x-1, y ) +
(int) image.GetGreen( x, y+1 ) +
(int) image.GetGreen( x+1, y+1 );
green = green/4;
int blue = (int) image.GetBlue( x, y ) +
(int) image.GetBlue( x-1, y ) +
(int) image.GetBlue( x, y+1 ) +
(int) image.GetBlue( x+1, y+1 );
blue = blue/4;
anti.SetRGB( x, y, red, green, blue );
}
}
}
return anti;
}
示例6: DoRegionUnion
static bool DoRegionUnion(wxRegion& region,
const wxImage& image,
unsigned char loR,
unsigned char loG,
unsigned char loB,
int tolerance)
{
unsigned char hiR, hiG, hiB;
hiR = (unsigned char)wxMin(0xFF, loR + tolerance);
hiG = (unsigned char)wxMin(0xFF, loG + tolerance);
hiB = (unsigned char)wxMin(0xFF, loB + tolerance);
// Loop through the image row by row, pixel by pixel, building up
// rectangles to add to the region.
int width = image.GetWidth();
int height = image.GetHeight();
for (int y=0; y < height; y++)
{
wxRect rect;
rect.y = y;
rect.height = 1;
for (int x=0; x < width; x++)
{
// search for a continuous range of non-transparent pixels
int x0 = x;
while ( x < width)
{
unsigned char R = image.GetRed(x,y);
unsigned char G = image.GetGreen(x,y);
unsigned char B = image.GetBlue(x,y);
if (( R >= loR && R <= hiR) &&
( G >= loG && G <= hiG) &&
( B >= loB && B <= hiB)) // It's transparent
break;
x++;
}
// Add the run of non-transparent pixels (if any) to the region
if (x > x0) {
rect.x = x0;
rect.width = x - x0;
region.Union(rect);
}
}
}
return true;
}
示例7: find_color
//find first color in sprite:
static xlColor find_color(wxImage& Shapes, std::hash_map</*xlColor*/ wxUint32, xlColor>& ColorMap, wxPoint xy, wxSize wh, const char* which)
{
xlColor color;
for (int y = xy.y; y < xy.y + wh.y; ++y) //bottom->top
for (int x = xy.x; x < xy.x + wh.x; ++x) //left->right
{
if (Shapes.IsTransparent(x, y)) continue;
color.Set(Shapes.GetRed(x, y), Shapes.GetGreen(x, y), Shapes.GetBlue(x, y));
if (ColorMap.find(color.GetRGB()) != ColorMap.end()) color = ColorMap[color.GetRGB()];
debug_more(10, ", %s 0x%x", which, color.GetRGB());
return color;
}
//if (!strcasecmp("on", which)) color.Set(255, 255, 255);
//else color.Set(64, 64, 64); //dim, not still visible
debug_more(10, ", %s (0x%x)", which, color.GetRGB());
return color;
}
示例8: Piano_load_shapes
//all shapes are loaded from same image file to reduce file I/O and caching
//thiss also allows animated images to be self-contained
void PianoRenderCache::Piano_load_shapes(RenderBuffer &buffer, const wxString& filename)
{
debug_function(10); //Debug debug("load_shapes('%s')", (const char*)filename.c_str());
debug(1, "load shapes file '%s'", (const char*)filename.c_str());
//reload shapes even if file name hasn't changed; color map might be different now
// if (!CachedShapeFilename.CmpNoCase(filename)) { debug_more(2, ", no change"); return; } //no change
if (!wxFileExists(filename)) return;
Piano_flush_shapes(); //invalidate cached data
if (!Shapes.LoadFile(filename, wxBITMAP_TYPE_ANY, 0) || !Shapes.IsOk())
{
//wxMessageBox("Error loading image file: "+NewPictureName);
Shapes.Clear();
return;
}
if (buffer.GetColorCount() < 2) return; //use colors from shapes file if no user-selected colors
// int imgwidth=image.GetWidth();
// int imght =image.GetHeight();
// std::hash_map<WXCOLORREF, int> palcounts;
//TODO: use wxImage.GetData for better performance?
//TODO: use multiple images within same file?
for (int y = Shapes.GetHeight() - 1; y >= 0; --y) //bottom->top
for (int x = 0; x < Shapes.GetWidth(); ++x) //left->right
if (!Shapes.IsTransparent(x, y))
{
xlColor color, mapped;
color.Set(Shapes.GetRed(x, y), Shapes.GetGreen(x, y), Shapes.GetBlue(x, y));
if (ColorMap.find(color.GetRGB()) != ColorMap.end()) continue; //already saw this color
buffer.palette.GetColor(ColorMap.size() % buffer.GetColorCount(), mapped); //assign user-selected colors to shape palette sequentially, loop if run out of colors
debug(10, "shape color[%d] 0x%x => user-selected color [%d] 0x%x", ColorMap.size(), color.GetRGB(), ColorMap.size() % GetColorCount(), mapped.GetRGB());
ColorMap[color.GetRGB()] = mapped; //.GetRGB();
// ShapePalette.push_back(c.GetRGB()); //keep a list of unique colors in order of occurrence from origin L-R, B-T
}
debug(2, "w %d, h %d, #colors %d", Shapes.GetWidth(), Shapes.GetHeight(), ColorMap.size());
CachedShapeFilename = filename; //don't load same file again
}
示例9: Piano_RenderKey
bool PianoRenderCache::Piano_RenderKey(RenderBuffer &buffer, Sprite* sprite, std::hash_map<wxPoint_, int>& drawn,
int style, wxSize& canvas, wxSize& keywh, const wxString &placement, bool clip)
//bool RgbEffects::Sprite::render(wxSize& keywh, wxSize& BufferWH_int, int yscroll, bool Clipping)
{
debug_function(9);
//hash_map<pair<wxPoint, wxSize>, int>& drawn)
//PIANO_STYLE_KEYS sprites have 2 states: on (down) and off (up); draw all sprites; top view or edge view
int drawstate = sprite->ani_state++; //bump to next active (animation) state
if (!drawstate) sprite->ani_state = 0; //stay in inactive state
else
// if ((xy.size() == 1) && (drawstate == -1)) return false; //inactive on/off sprite; don't need tp draw anything
if (drawstate >= sprite->xy.size()) //end of animation
// if (it->repeat > 0) drawstate = 0; //loop immediately
// else if (it->repeat < 0) drawstate = -rnd(); //loop with delay
/*else*/ drawstate = sprite->xy.size() - 1; //stay at last state; don't loop
// wxPoint realxy = sprite->destxy;
// realxy.y += yscroll; //scrolling
debug_more(30, ", dest (%d => %d, %d), #drawn %d", sprite->destxy.x, (clip? sprite->destxy.x: sprite->destxy.x % canvas.x), sprite->destxy.y, drawn.size());
if (clip)
if ((sprite->destxy.x >= buffer.BufferWi) || (sprite->destxy.y >= buffer.BufferHt) || (sprite->destxy.x + keywh.x < 0) || (sprite->destxy.y + keywh.y < 0)) return false; //outside of visible rect
// debug_more(30, ", here1");
wxPoint_ where = sprite->destxy.y * 65536 + (clip? sprite->destxy.x: sprite->destxy.x % canvas.x); //wrap on even key boundary
// debug_more(30, ", here2");
if ((style != PIANO_STYLE_ANIMAGE) && (drawn.find(where) != drawn.end()) && (drawstate <= drawn[where])) { debug_more(30, ", already drawn[0x%x]=%d vs %d", where, drawn[where], drawstate); return false; } //do not redraw older states in same location
drawn[where] = drawstate; //remember highest state drawn in this location
//don't draw overlapping regions more than once
// SetPixel(x-xoffset,(state % ((imght+BufferHt)*speedfactor)) / speedfactor-y,c); //moving up
// SetPixel(x-xoffset,BufferHt+imght-y-(state % ((imght+BufferHt)*speedfactor)) / speedfactor,c); //moving down
//copy sprite image to pixel buffer, scale up/down:
//iterate thru target pixels and pull from sprite in case sizes don't match (need to set all target pixels, but okay to skip some source pixels)
float xscale = (float)sprite->wh.x / keywh.x, yscale = (float)sprite->wh.y / keywh.y; //src -> dest scale factor
// debug_more(30, ", here3");
//TODO: use wxImage.GetData for better performance?
int xofs = !clip? (buffer.BufferWi % (7 * keywh.x)) / 2: 0; //center keys if not clipped
if (WantHistory(style)) debug(20, "draw sprite '%s': set x/y %d/%d + %d/%d to 0x%x", (const char*)sprite->name.ToStdString().c_str(), sprite->destxy.x, sprite->destxy.y, keywh.x, keywh.y, drawstate? sprite->on.GetRGB(): sprite->off.GetRGB()); //.Flush(true);
else debug(20, "draw sprite '%s': copy from x/y[%d/%d] %d/%d + %d/%d => x/y %d/%d + %d/%d, x/y scale = %f/%f", (const char*)sprite->name.ToStdString().c_str(), drawstate, sprite->xy.size(), sprite->xy[drawstate].x, sprite->xy[drawstate].y, sprite->wh.x, sprite->wh.y, sprite->destxy.x, sprite->destxy.y, keywh.x, keywh.y, 1.0 / xscale, 1.0 / yscale); //.Flush(true);
for (int x = 0; x < keywh.x; ++x) //copying to it->w columns in dest
for (int y = 0; y < keywh.y; ++y) //copying to it->h rows in dest; vert scaling is more likely, so make Y the inner loop for better pixel caching
{
// static xlColor cached_rgb; //cached mapped pixel color
// static wxPoint cached_xy(-1, -1);
wxPoint src_xy(sprite->xy[drawstate].x + x * xscale, sprite->xy[drawstate].y + y * yscale);
//TODO: scale doesn't make sense for all cases
src_xy.y = Shapes.GetHeight() - src_xy.y - 1; //whoops, origin is top left but wanted bottom left
bool transparent = 0;
if (WantHistory(style)) cached_rgb = drawstate? sprite->on: sprite->off; //kludge: fill rect with same color to avoid losing pixels due to scaling
else if ((src_xy.x != cached_xy.x) || (src_xy.y != cached_xy.y)) //update cached pixel info
{
cached_xy = src_xy; //prev_xy.x = src_xy.x; prev_y = srcy; //not sure how expensive wx pixel functions are, so cache current pixel info just in case; aliasing/averaging and color mapping also makes thiss more expensive
if (Shapes.IsTransparent(src_xy.x, src_xy.y)) transparent = 1; //-1; //-1 matches white, so use + instead
else
{
// xlColor c;
//TODO: tile, center, anti-aliasing
cached_rgb.Set(Shapes.GetRed(src_xy.x, src_xy.y), Shapes.GetGreen(src_xy.x, src_xy.y), Shapes.GetBlue(src_xy.x, src_xy.y)); //NOTE: need to do pixel merging if scale is not 1:1
if (!ColorMap.empty()) cached_rgb = ColorMap[cached_rgb.GetRGB()]; //map to user-selected colors
}
debug_more(20, ", LK(%d,%d)", cached_xy.x, cached_xy.y);
}
if (transparent == 1 /*-1*/) continue; //don't need to draw pixel
int wrapx = sprite->destxy.x + x, scrolly = sprite->destxy.y;
// if (style == PIANO_STYLE_ANIMAGE) { wrapx *= xscale; scrolly *= yscale; }
if (!clip) wrapx %= canvas.x; //wrap on even key boundary
// if ((style == PIANO_STYLE_ICICLES) || (style == PIANO_STYLE_EQBARS)) scrolly += canvas.y - keywh.y; //draw at top instead of bottom
if (style == PIANO_STYLE_ICICLES) scrolly += canvas.y - keywh.y; //draw at top instead of bottom
// debug_more(20, ", %d+%d vs. %d-%d? %d", xofs, wrapx, BufferWi, xofs, xofs + wrapx < BufferWi - xofs);
// if (!clip) wrapx = (wrapx + 2 * xofs) % BufferWi - 2 * xofs; //wrap within reduced area, not expanded area
debug_more(20, ", (%d,%d)<-0x%x", wrapx, sprite->destxy.y + y, cached_rgb.GetRGB());
if (xofs + wrapx < buffer.BufferWi - xofs) buffer.SetPixel(xofs + wrapx, sprite->destxy.y + y, cached_rgb); //no vertical wrap, only horizontal wrap
}
// debug.Flush(true);
return true;
}
示例10: PlotImage
/**
* PDF images are handles as inline, not XObject streams...
*/
void PDF_PLOTTER::PlotImage( const wxImage & aImage, const wxPoint& aPos,
double aScaleFactor )
{
wxASSERT( workFile );
wxSize pix_size( aImage.GetWidth(), aImage.GetHeight() );
// Requested size (in IUs)
DPOINT drawsize( aScaleFactor * pix_size.x,
aScaleFactor * pix_size.y );
// calculate the bitmap start position
wxPoint start( aPos.x - drawsize.x / 2,
aPos.y + drawsize.y / 2);
DPOINT dev_start = userToDeviceCoordinates( start );
/* PDF has an uhm... simplified coordinate system handling. There is
*one* operator to do everything (the PS concat equivalent). At least
they kept the matrix stack to save restore environments. Also images
are always emitted at the origin with a size of 1x1 user units.
What we need to do is:
1) save the CTM end estabilish the new one
2) plot the image
3) restore the CTM
4) profit
*/
fprintf( workFile, "q %g 0 0 %g %g %g cm\n", // Step 1
userToDeviceSize( drawsize.x ),
userToDeviceSize( drawsize.y ),
dev_start.x, dev_start.y );
/* An inline image is a cross between a dictionary and a stream.
A real ugly construct (compared with the elegance of the PDF
format). Also it accepts some 'abbreviations', which is stupid
since the content stream is usually compressed anyway... */
fprintf( workFile,
"BI\n"
" /BPC 8\n"
" /CS %s\n"
" /W %d\n"
" /H %d\n"
"ID\n", colorMode ? "/RGB" : "/G", pix_size.x, pix_size.y );
/* Here comes the stream (in binary!). I *could* have hex or ascii84
encoded it, but who cares? I'll go through zlib anyway */
for( int y = 0; y < pix_size.y; y++ )
{
for( int x = 0; x < pix_size.x; x++ )
{
unsigned char r = aImage.GetRed( x, y ) & 0xFF;
unsigned char g = aImage.GetGreen( x, y ) & 0xFF;
unsigned char b = aImage.GetBlue( x, y ) & 0xFF;
// As usual these days, stdio buffering has to suffeeeeerrrr
if( colorMode )
{
putc( r, workFile );
putc( g, workFile );
putc( b, workFile );
}
else
{
// Grayscale conversion
putc( (r + g + b) / 3, workFile );
}
}
}
fputs( "EI Q\n", workFile ); // Finish step 2 and do step 3
}
示例11: PlotImage
/**
* Postscript-likes at the moment are the only plot engines supporting bitmaps...
*/
void PS_PLOTTER::PlotImage( const wxImage & aImage, const wxPoint& aPos,
double aScaleFactor )
{
wxSize pix_size; // size of the bitmap in pixels
pix_size.x = aImage.GetWidth();
pix_size.y = aImage.GetHeight();
DPOINT drawsize( aScaleFactor * pix_size.x,
aScaleFactor * pix_size.y ); // requested size of image
// calculate the bottom left corner position of bitmap
wxPoint start = aPos;
start.x -= drawsize.x / 2; // left
start.y += drawsize.y / 2; // bottom (Y axis reversed)
// calculate the top right corner position of bitmap
wxPoint end;
end.x = start.x + drawsize.x;
end.y = start.y - drawsize.y;
fprintf( outputFile, "/origstate save def\n" );
fprintf( outputFile, "/pix %d string def\n", pix_size.x );
// Locate lower-left corner of image
DPOINT start_dev = userToDeviceCoordinates( start );
fprintf( outputFile, "%g %g translate\n", start_dev.x, start_dev.y );
// Map image size to device
DPOINT end_dev = userToDeviceCoordinates( end );
fprintf( outputFile, "%g %g scale\n",
std::abs(end_dev.x - start_dev.x), std::abs(end_dev.y - start_dev.y));
// Dimensions of source image (in pixels
fprintf( outputFile, "%d %d 8", pix_size.x, pix_size.y );
// Map unit square to source
fprintf( outputFile, " [%d 0 0 %d 0 %d]\n", pix_size.x, -pix_size.y , pix_size.y);
// include image data in ps file
fprintf( outputFile, "{currentfile pix readhexstring pop}\n" );
if( colorMode )
fputs( "false 3 colorimage\n", outputFile );
else
fputs( "image\n", outputFile );
// Single data source, 3 colors, Output RGB data (hexadecimal)
// (or the same downscaled to gray)
int jj = 0;
for( int yy = 0; yy < pix_size.y; yy ++ )
{
for( int xx = 0; xx < pix_size.x; xx++, jj++ )
{
if( jj >= 16 )
{
jj = 0;
fprintf( outputFile, "\n");
}
int red, green, blue;
red = aImage.GetRed( xx, yy) & 0xFF;
green = aImage.GetGreen( xx, yy) & 0xFF;
blue = aImage.GetBlue( xx, yy) & 0xFF;
if( colorMode )
fprintf( outputFile, "%2.2X%2.2X%2.2X", red, green, blue );
else
fprintf( outputFile, "%2.2X", (red + green + blue) / 3 );
}
}
fprintf( outputFile, "\n");
fprintf( outputFile, "origstate restore\n" );
}