void wxHtmlImageCell::SetImage(const wxImage& img)
{
#if !defined(__WXMSW__) || wxUSE_WXDIB
if ( img.IsOk() )
{
delete m_bitmap;
int ww, hh;
ww = img.GetWidth();
hh = img.GetHeight();
if ( m_bmpW == wxDefaultCoord)
m_bmpW = ww;
if ( m_bmpH == wxDefaultCoord)
m_bmpH = hh;
// Only scale the bitmap at the rendering stage,
// so we don't lose quality twice
/*
if ((m_bmpW != ww) || (m_bmpH != hh))
{
wxImage img2 = img.Scale(m_bmpW, m_bmpH);
m_bitmap = new wxBitmap(img2);
}
else
*/
m_bitmap = new wxBitmap(img);
}
#endif
}
void FrameRenderer::setBodyRightImage(const wxImage &image)
{
OS_ASSERT(image.IsOk());
m_imageBodyRight = image;
if(m_imageBodyRight.HasAlpha())
m_imageBodyRight.ConvertAlphaToMask();
}
void FrameRenderer::setTopImage(const wxImage &image)
{
OS_ASSERT(image.IsOk());
m_imageTop = image;
if(m_imageTop.HasAlpha())
m_imageTop.ConvertAlphaToMask();
}
bool wxCreateGreyedImage(const wxImage& in, wxImage& out)
{
#if wxUSE_IMAGE
out = in.ConvertToGreyscale();
if ( out.IsOk() )
return true;
#endif // wxUSE_IMAGE
return false;
}
void AffineTransformTestCase::setUp()
{
#if wxUSE_DC_TRANSFORM_MATRIX
m_imgOrig.LoadFile("horse.jpg");
CPPUNIT_ASSERT( m_imgOrig.IsOk() );
m_bmpOrig = wxBitmap(m_imgOrig);
#endif // wxUSE_DC_TRANSFORM_MATRIX
}
static void addMipMap(GLuint* texture, const wxImage &l_Image, int &level) {
if (l_Image.IsOk() == true)
{
glTexImage2D(GL_TEXTURE_2D, level, GL_RGB, (GLsizei)l_Image.GetWidth(), (GLsizei)l_Image.GetHeight(),
0, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid*)l_Image.GetData());
int err = glGetError();
if (err == GL_NO_ERROR) {
level++;
}
}
}
void wxLEDPanel::SetImage(const wxImage img)
{
if(!img.IsOk()) return;
m_text.Empty();
m_content_mo.Init(img);
m_aniFrameNr=-1;
// Find the place for the bitmap
ResetPos();
// Set in field
m_field.Clear();
m_field.SetDatesAt(m_pos,m_content_mo);
}
void InfoPanel::LoadBannerImage()
{
const wxImage banner_image = WxUtils::ToWxImage(m_game_list_item.GetBannerImage());
const wxSize banner_min_size = m_banner->GetMinSize();
if (banner_image.IsOk())
{
m_banner->SetBitmap(WxUtils::ScaleImageToBitmap(banner_image, this, banner_min_size));
m_banner->Bind(wxEVT_RIGHT_DOWN, &InfoPanel::OnRightClickBanner, this);
}
else
{
m_banner->SetBitmap(WxUtils::LoadScaledResourceBitmap("nobanner", this, banner_min_size));
}
}
wxImage BorderInvariantResizeImage(const wxImage& image, int width, int height)
{
if (!image.IsOk() || (width == image.GetWidth() && height == image.GetHeight()))
return image;
wxImage ret(width, height);
Resizer data_resize(ret, image, false);
data_resize();
if (image.HasAlpha()) {
ret.InitAlpha();
Resizer alpha_resize(ret, image, true);
alpha_resize();
}
return ret;
}
wxBitmap::wxBitmap(const wxImage& imageOrig, int depth)
{
wxCHECK_RET( imageOrig.IsOk(), wxT("invalid image") );
wxImage image(imageOrig);
// convert mask to alpha channel, because wxMask isn't implemented yet
// FIXME: don't do this, implement proper wxMask support
if ( image.HasMask() )
image.InitAlpha();
DFBSurfacePixelFormat format = DepthToFormat(depth);
if ( format == DSPF_UNKNOWN && image.HasAlpha() )
format = DSPF_ARGB;
// create surface in screen's format (unless we need alpha channel,
// in which case use ARGB):
if ( !CreateWithFormat(image.GetWidth(), image.GetHeight(), format) )
return;
// then copy the image to it:
wxIDirectFBSurfacePtr dst = M_BITMAP->m_surface;
switch ( dst->GetPixelFormat() )
{
case DSPF_RGB24:
case DSPF_RGB32:
case DSPF_ARGB:
CopyImageToSurface(image, dst);
break;
default:
{
// wxBitmap uses different pixel format, so we have to use a
// temporary surface and blit to the bitmap via it:
wxIDirectFBSurfacePtr src(CreateSurfaceForImage(image));
CopyImageToSurface(image, src);
if ( !dst->SetBlittingFlags(DSBLIT_NOFX) )
return;
if ( !dst->Blit(src->GetRaw(), NULL, 0, 0) )
return;
}
}
}
// Add any additional bitmaps/icons to the internal image list
void wxAdvancedListCtrl::AddImageSmall(wxImage Image)
{
if (GetImageList(wxIMAGE_LIST_SMALL) == NULL)
{
// Art provider images are 16x15, WTF?! Kept for compatibility :'(
wxImageList *ImageList = new wxImageList(16, 15, true, FIRST_IMAGE);
AssignImageList(ImageList, wxIMAGE_LIST_SMALL);
// Add our sort icons by default.
GetImageList(wxIMAGE_LIST_SMALL)->Add(wxImage(SortArrowAscending));
GetImageList(wxIMAGE_LIST_SMALL)->Add(wxImage(SortArrowDescending));
}
if (Image.IsOk())
{
GetImageList(wxIMAGE_LIST_SMALL)->Add(Image);
}
}
// Add any additional bitmaps/icons to the internal image list
int wxAdvancedListCtrl::AddImageSmall(wxImage Image)
{
if (GetImageList(wxIMAGE_LIST_SMALL) == NULL)
{
wxImageList *ImageList = new wxImageList(16, 16, true);
AssignImageList(ImageList, wxIMAGE_LIST_SMALL);
// Add our sort icons by default.
ImageList_SortArrowUp = GetImageList(wxIMAGE_LIST_SMALL)->Add(wxImage(SortArrowAscending));
ImageList_SortArrowDown = GetImageList(wxIMAGE_LIST_SMALL)->Add(wxImage(SortArrowDescending));
}
if (Image.IsOk())
{
return GetImageList(wxIMAGE_LIST_SMALL)->Add(Image);
}
return -1;
}
/**< set the iamge to dispaly */
bool ImagePanel::SetImg(wxImage& img)
{
// whether the new image can be used
if (!img.IsOk())
return false;
// reference the image used to display.
if (m_img.IsOk())
m_img.Destroy();
m_img = img;
// calculate display params
m_szClient = GetClientSize();
wxSize szImg = m_img.GetSize();
// if wnd's size greate then img's size, image disp as its actual size
if (m_szClient.GetWidth() > szImg.GetWidth() && m_szClient.GetHeight() > szImg.GetHeight() )
ImgZoomActual();
else
ImgZoomFit();
return true;
}
// Add any additional bitmaps/icons to the internal image list
int wxAdvancedListCtrl::AddImageSmall(wxImage Image)
{
if (GetImageList(wxIMAGE_LIST_SMALL) == NULL)
{
wxImageList *ImageList = new wxImageList(16, 16, true);
AssignImageList(ImageList, wxIMAGE_LIST_SMALL);
wxBitmap sort_up(16, 16), sort_down(16, 16);
wxColour Mask = wxColour(255,255,255);
// Draw sort arrows using the native renderer
{
wxMemoryDC renderer_dc;
// sort arrow up
renderer_dc.SelectObject(sort_up);
renderer_dc.SetBackground(*wxTheBrushList->FindOrCreateBrush(Mask, wxSOLID));
renderer_dc.Clear();
wxRendererNative::Get().DrawHeaderButtonContents(this, renderer_dc, wxRect(0, 0, 16, 16), 0, wxHDR_SORT_ICON_UP);
// sort arrow down
renderer_dc.SelectObject(sort_down);
renderer_dc.SetBackground(*wxTheBrushList->FindOrCreateBrush(Mask, wxSOLID));
renderer_dc.Clear();
wxRendererNative::Get().DrawHeaderButtonContents(this, renderer_dc, wxRect(0, 0, 16, 16), 0, wxHDR_SORT_ICON_DOWN);
}
// Add our sort icons to the image list
ImageList_SortArrowDown = GetImageList(wxIMAGE_LIST_SMALL)->Add(sort_down, Mask);
ImageList_SortArrowUp = GetImageList(wxIMAGE_LIST_SMALL)->Add(sort_up, Mask);
}
if (Image.IsOk())
{
return GetImageList(wxIMAGE_LIST_SMALL)->Add(Image);
}
return -1;
}
/*static*/ void
wxMemoryFSHandler::AddFile(const wxString& filename,
const wxImage& image,
wxBitmapType type)
{
if ( !CheckDoesntExist(filename) )
return;
wxMemoryOutputStream mems;
if ( image.IsOk() && image.SaveFile(mems, type) )
{
m_Hash[filename] = new wxMemoryFSFile
(
mems,
wxImage::FindHandler(type)->GetMimeType()
);
}
else
{
wxLogError(_("Failed to store image '%s' to memory VFS!"), filename);
}
}
wxBitmap gcThemeManager::getSprite(wxImage& img, const char* spriteId, const char* spriteName)
{
SpriteRectI* rect = getSpriteRect(spriteId, spriteName);
if (!rect || !img.IsOk())
return wxBitmap();
int w = rect->getW();
int h = rect->getH();
int x = rect->getX();
int y = rect->getY();
if (w < 0)
w = img.GetWidth();
if (h < 0)
h = img.GetHeight();
if (w > img.GetWidth())
w = img.GetWidth();
if (h > img.GetHeight())
h = img.GetHeight();
if (x < 0)
x = 0;
if (x > img.GetWidth() - w)
x = 0;
if (y < 0)
y = 0;
if (y > img.GetHeight() - h)
y = 0;
return wxBitmap( img.GetSubImage( wxRect(x,y,w,h) ) );
}
void Map::AssignImgData(ImgData *imgdata, wxImage &img)
{
if(imgdata == NULL) return;
if(img.IsOk())
{
unsigned char *pixdata, *alphadata;
int width, height;
long datasize;
if(!img.HasAlpha()) img.SetAlpha();
width = img.GetWidth();
height = img.GetHeight();
pixdata = img.GetData();
alphadata = img.GetAlpha();
datasize = (long) 4 * width * height;
(*imgdata).width = (long)width;
(*imgdata).height = (long)height;
(*imgdata).data = (unsigned char*)malloc(datasize);
if((*imgdata).data == NULL) return;
int pi = 0, ai = 0;
for(int di = 0; di < datasize;)
{
(*imgdata).data[di++] = pixdata[pi++];
(*imgdata).data[di++] = pixdata[pi++];
(*imgdata).data[di++] = pixdata[pi++];
(*imgdata).data[di++] = alphadata[ai++];
}
}
else
{
(*imgdata).width = 0;
(*imgdata).height = 0;
(*imgdata).data = NULL;
}
}
//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
}
void OpenCVHelper::convertCVMatToWxImage(const cv::Mat &cvimg, wxImage &img)
{
if(!img.IsOk()
|| img.GetWidth() != cvimg.cols
|| img.GetHeight() != cvimg.rows)
{
img.Create(cvimg.cols, cvimg.rows, false);
}
const cv::Vec3b *cvPtr = cvimg.ptr<cv::Vec3b>(0);
unsigned char *wxPtr = img.GetData();
for(int y = 0; y < img.GetHeight(); y++)
{
for(int x = 0; x < img.GetWidth(); x++)
{
/* localPreviewImage.SetRGB(x, y, img_outcv.at<cv::Vec3b>(y, x)[2],
img_outcv.at<cv::Vec3b>(y, x)[1],
img_outcv.at<cv::Vec3b>(y, x)[0]);*/
*(wxPtr++) = (*cvPtr)[2];
*(wxPtr++) = (*cvPtr)[1];
*(wxPtr++) = (*cvPtr)[0];
cvPtr++;
}
}
}
wxImage ScaleImage(wxImage image, double source_scale_factor, double content_scale_factor,
wxSize output_size, wxRect usable_rect, LSIFlags flags,
const wxColour& fill_color)
{
if (!image.IsOk())
{
wxFAIL_MSG("WxUtils::ScaleImage expects a valid image.");
return image;
}
if (content_scale_factor != 1.0)
{
output_size *= content_scale_factor;
usable_rect.SetPosition(usable_rect.GetPosition() * content_scale_factor);
usable_rect.SetSize(usable_rect.GetSize() * content_scale_factor);
}
// Fix the output size if it's unset.
wxSize img_size = image.GetSize();
if (output_size.GetWidth() < 1)
output_size.SetWidth(
static_cast<int>(img_size.GetWidth() * (content_scale_factor / source_scale_factor)));
if (output_size.GetHeight() < 1)
output_size.SetHeight(
static_cast<int>(img_size.GetHeight() * (content_scale_factor / source_scale_factor)));
// Fix the usable rect. If it's empty then the whole canvas is usable.
if (usable_rect.IsEmpty())
{
// Constructs a temp wxRect 0,0->output_size then move assigns it.
usable_rect = output_size;
}
else if (!usable_rect.Intersects(output_size))
{
wxFAIL_MSG("Usable Zone Rectangle is not inside the canvas. Check the output size is correct.");
image.Create(1, 1, false);
image.SetRGB(0, 0, fill_color.Red(), fill_color.Green(), fill_color.Blue());
if (fill_color.Alpha() == wxALPHA_TRANSPARENT)
image.SetMaskColour(fill_color.Red(), fill_color.Green(), fill_color.Blue());
usable_rect = output_size;
}
// Step 1: Scale the image
if ((flags & LSI_SCALE) != LSI_SCALE_NONE)
{
if (flags & LSI_SCALE_NO_ASPECT)
{
// Stretch scale without preserving the aspect ratio.
bool scale_width = (img_size.GetWidth() > usable_rect.GetWidth() && flags & LSI_SCALE_DOWN) ||
(img_size.GetWidth() < usable_rect.GetWidth() && flags & LSI_SCALE_UP);
bool scale_height =
(img_size.GetHeight() > usable_rect.GetHeight() && flags & LSI_SCALE_DOWN) ||
(img_size.GetHeight() < usable_rect.GetHeight() && flags & LSI_SCALE_UP);
if (scale_width || scale_height)
{
// NOTE: Using BICUBIC instead of HIGH because it's the same internally
// except that downscaling uses a box filter with awful obvious aliasing
// for non-integral scale factors.
image.Rescale(scale_width ? usable_rect.GetWidth() : img_size.GetWidth(),
scale_height ? usable_rect.GetHeight() : img_size.GetHeight(),
wxIMAGE_QUALITY_BICUBIC);
}
}
else
{
// Scale while preserving the aspect ratio.
double scale = std::min(static_cast<double>(usable_rect.GetWidth()) / img_size.GetWidth(),
static_cast<double>(usable_rect.GetHeight()) / img_size.GetHeight());
int target_width = static_cast<int>(img_size.GetWidth() * scale);
int target_height = static_cast<int>(img_size.GetHeight() * scale);
// Bilinear produces sharper images when upscaling, bicubic tends to smear/blur sharp edges.
if (scale > 1.0 && flags & LSI_SCALE_UP)
image.Rescale(target_width, target_height, wxIMAGE_QUALITY_BILINEAR);
else if (scale < 1.0 && flags & LSI_SCALE_DOWN)
image.Rescale(target_width, target_height, wxIMAGE_QUALITY_BICUBIC);
}
img_size = image.GetSize();
}
// Step 2: Resize the canvas to match the output size.
// NOTE: If NOT using LSI_SCALE_DOWN then this will implicitly crop the image
if (img_size != output_size || usable_rect.GetPosition() != wxPoint())
{
wxPoint base = usable_rect.GetPosition();
if (flags & LSI_ALIGN_HCENTER)
base.x += (usable_rect.GetWidth() - img_size.GetWidth()) / 2;
else if (flags & LSI_ALIGN_RIGHT)
base.x += usable_rect.GetWidth() - img_size.GetWidth();
if (flags & LSI_ALIGN_VCENTER)
base.y += (usable_rect.GetHeight() - img_size.GetHeight()) / 2;
else if (flags & LSI_ALIGN_BOTTOM)
base.y += usable_rect.GetHeight() - img_size.GetHeight();
int r = -1, g = -1, b = -1;
if (fill_color.Alpha() != wxALPHA_TRANSPARENT)
{
r = fill_color.Red();
g = fill_color.Green();
b = fill_color.Blue();
}
image.Resize(output_size, base, r, g, b);
}
return image;
}
bool MyVideoCaptureWindow::OnProcessFrame(wxImage& wximg)
{
// This function is only called with a valid wxImage, but for this sample we'll verify that.
wxCHECK_MSG(wximg.IsOk(), false, wxT("Invalid image to process"));
bool refresh = true; // return value
int i, j, jj;
const int width = wximg.GetWidth();
const int height = wximg.GetHeight();
const int width_x3 = width*3;
const int imgdata_size = width*height*3;
unsigned char *imgdata = wximg.GetData();
static wxImage lastimage(width, height); // for motion detector
// Invert the image - negative
if (m_frame->m_processMenu->IsChecked(ID_IMGPROCESS_NEGATIVE))
{
for (i = 0; i < imgdata_size; ++i) imgdata[i] = 255 - imgdata[i];
}
// Very basic edge detector
if (m_frame->m_processMenu->IsChecked(ID_IMGPROCESS_EDGE))
{
unsigned char *imgrow = new unsigned char[width_x3];
if (imgrow)
{
unsigned char *rowptr = wximg.GetData();
for (j = 0; j < height; ++j)
{
int jj = j*width_x3;
memcpy(imgrow, rowptr, width_x3);
for (i = 3; i < width_x3; i += 3)
{
imgdata[i + jj] = abs((int)imgrow[i ] - imgrow[i-3])*4;
imgdata[i+1 + jj] = abs((int)imgrow[i+1] - imgrow[i-2])*4;
imgdata[i+2 + jj] = abs((int)imgrow[i+2] - imgrow[i-1])*4;
}
rowptr += width_x3;
}
delete []imgrow;
}
}
// Very basic motion detector,
// tweak pixel_threshold, pixels_changed_threshold
if (m_frame->m_processMenu->IsChecked(ID_IMGPROCESS_MOTION))
{
// is the last image still good?
if (!lastimage.Ok() ||
(lastimage.GetWidth() != width) ||
(lastimage.GetHeight() != height))
{
lastimage.Create(width,height);
}
unsigned char *lastdata = lastimage.GetData();
int pixel_threshold = 64; // each pixel checked has to differ by this
int pixels_changed_threshold = 10; // this many pixels must change
int pixels_changed = 0; // # of pixels changed by threshold
int skip_rows = 3; // horiz rows to skip
int skip_cols = 13; // vert cols to skip
for (j = 0; j < height; j += skip_rows)
{
jj = j*width_x3;
for (i = 0; i < width_x3; i += skip_cols)
{
if(abs((int)imgdata[i+jj] - lastdata[i+jj]) > pixel_threshold)
pixels_changed++;
}
}
if (pixels_changed < pixels_changed_threshold) refresh = false;
memcpy(lastdata, imgdata, sizeof(unsigned char)*imgdata_size);
}
return refresh;
}
bool wxDIB::Create(const wxImage& image, PixelFormat pf)
{
wxCHECK_MSG( image.IsOk(), false, wxT("invalid wxImage in wxDIB ctor") );
const int h = image.GetHeight();
const int w = image.GetWidth();
// if we have alpha channel, we need to create a 32bpp RGBA DIB, otherwise
// a 24bpp RGB is sufficient
const bool hasAlpha = image.HasAlpha();
const int bpp = hasAlpha ? 32 : 24;
if ( !Create(w, h, bpp) )
return false;
// DIBs are stored in bottom to top order (see also the comment above in
// Create()) so we need to copy bits line by line and starting from the end
const int srcBytesPerLine = w * 3;
const int dstBytesPerLine = GetLineSize(w, bpp);
const unsigned char *src = image.GetData() + ((h - 1) * srcBytesPerLine);
const unsigned char *alpha = hasAlpha ? image.GetAlpha() + (h - 1)*w
: NULL;
unsigned char *dstLineStart = (unsigned char *)m_data;
for ( int y = 0; y < h; y++ )
{
// Copy one DIB line. Note that RGB components order is reversed in
// Windows bitmaps compared to wxImage and is actually BGR.
unsigned char *dst = dstLineStart;
if ( alpha )
{
int x;
switch ( pf )
{
case PixelFormat_PreMultiplied:
// Pre-multiply pixel values so that the DIB could be used
// with ::AlphaBlend().
for ( x = 0; x < w; x++ )
{
const unsigned char a = *alpha++;
*dst++ = (unsigned char)((src[2] * a + 127) / 255);
*dst++ = (unsigned char)((src[1] * a + 127) / 255);
*dst++ = (unsigned char)((src[0] * a + 127) / 255);
*dst++ = a;
src += 3;
}
break;
case PixelFormat_NotPreMultiplied:
// Just copy pixel data without changing it.
for ( x = 0; x < w; x++ )
{
*dst++ = src[2];
*dst++ = src[1];
*dst++ = src[0];
*dst++ = *alpha++;
src += 3;
}
break;
}
}
else // no alpha channel
{
for ( int x = 0; x < w; x++ )
{
*dst++ = src[2];
*dst++ = src[1];
*dst++ = src[0];
src += 3;
}
}
// pass to the previous line in the image
src -= 2*srcBytesPerLine;
if ( alpha )
alpha -= 2*w;
// and to the next one in the DIB
dstLineStart += dstBytesPerLine;
}
return true;
}