int main(int argc, char** argv) {
fullscreen = false;
grab = false;
quit = false;
initScreen();
initFrameBuffer();
createGLContext();
createColorMap();
createWindow();
createBlankCursor();
int x = 0;
while(x<5000) {
renderFrame();
updateWindowTitle();
x++;
}
/* Cleanup
glXDestroyWindow(display, glxwindow);
xcb_destroy_window(connection, window);
glXDestroyContext(display, context);
XCloseDisplay(display);
*/
return 0;
}
int main(int argc, char **argv) {
if (argc < 6) {
printf("usage: leitura arqin.raw width height slices dslices colormap\n");
exit(1);
}
glutInit(&argc, argv);
//glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
glutInitWindowPosition(100, 100);
glutInitWindowSize(640, 640);
glutCreateWindow("Teste de Vizualizacao com textura 3D");
glutDisplayFunc(&DrawGLScene);
glutIdleFunc(&DrawGLScene);
glutReshapeFunc(&ReSizeGLScene);
glutKeyboardFunc(&keyPressed);
glutMotionFunc(MoveMouseBotaoPressionado);
glutPassiveMotionFunc(MoveMouse);
glutMouseFunc(GerenciaMouse);
raw = readRAW(argc, argv);
GLenum err = glewInit();
if (GLEW_OK != err) {
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
}
if (glewIsSupported("GL_VERSION_2_1"))
printf("Ready for OpenGL 2.1\n");
else {
printf("OpenGL 2.1 not supported\n");
exit(1);
}
if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader
&& GL_EXT_geometry_shader4)
printf("Ready for GLSL - vertex, fragment, and geometry units\n");
else {
printf("Not totally ready :( \n");
exit(1);
}
if(argc==7) colorMapRead(argv[6],cm);
else {
createColorMap(cm);
//colorMapWrite("teste.map", cm);
//colorMapRead("teste.map", cm);
}
InitGL(640, 640);
/* Start Event Processing Engine */
glutMainLoop();
return 1;
}
void PCSSShadowMap::render(DrawEnv *pEnv)
{
Window *win = pEnv->getWindow();
initialize(win);
if(!_useGLSL || !_useShadowExt)
_shadowVP->Viewport::render(pEnv->getAction());
else
{
glPushAttrib(GL_ENABLE_BIT);
if(!_initTexturesDone)
initTextures(win);
if(_useFBO)
{
if(!initFBO(pEnv))
printf("ERROR with FBOBJECT\n");
}
GLfloat globalAmbient[] =
{
0.0, 0.0, 0.0, 1.0
};
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globalAmbient);
_firstRun = 1;
#if 0
for(UInt32 i = 0;i < _shadowVP->_lights.size();i++)
{
{
_shadowVP->_texChunks[i]->setMinFilter(GL_NEAREST);
_shadowVP->_texChunks[i]->setMagFilter(GL_NEAREST);
}
}
#endif
if(_shadowVP->getPixelWidth() != _width ||
_shadowVP->getPixelHeight() != _height)
{
_width = _shadowVP->getPixelWidth();
_height = _shadowVP->getPixelHeight();
if(_useNPOTTextures)
{
_colorMapImage->set(GL_RGB, _width, _height);
_shadowFactorMapImage->set(GL_RGB, _width, _height);
reInit(pEnv);
}
else
{
if(_width > _height)
_widthHeightPOT = osgNextPower2(_width - 1);
else
_widthHeightPOT = osgNextPower2(_height - 1);
_colorMapImage->set(GL_RGB, _widthHeightPOT, _widthHeightPOT);
_shadowFactorMapImage->set(GL_RGB, _widthHeightPOT,
_widthHeightPOT);
}
}
commitChanges();
if(_shadowVP->getMapAutoUpdate())
{
#ifdef USE_FBO_FOR_COLOR_AND_FACTOR_MAP
if(_useFBO && _useNPOTTextures)
createColorMapFBO(pEnv);
else
#endif
createColorMap(pEnv);
//deactivate transparent Nodes
for(UInt32 t = 0;t < _shadowVP->_transparent.size();++t)
_shadowVP->_transparent[t]->setTravMask(0);
if(_useFBO)
createShadowMapsFBO(pEnv);
else
createShadowMaps(pEnv);
// switch on all transparent geos
for(UInt32 t = 0;t < _shadowVP->_transparent.size();++t)
_shadowVP->_transparent[t]->setTravMask(TypeTraits<UInt32>::BitsSet);
for(UInt32 i = 0;i < _shadowVP->_lights.size();i++)
{
if(_shadowVP->_lightStates[i] != 0)
{
if(_shadowVP->getGlobalShadowIntensity() != 0.0 ||
_shadowVP->_lights[i].second->getShadowIntensity() != 0.0)
{
#ifdef USE_FBO_FOR_COLOR_AND_FACTOR_MAP
if(_useFBO && _useNPOTTextures)
createShadowFactorMapFBO(pEnv, i);
else
#endif
createShadowFactorMap(pEnv, i);
//_firstRun = 0;
}
}
}
}
else
{
if(_shadowVP->_trigger_update)
{
#ifdef USE_FBO_FOR_COLOR_AND_FACTOR_MAP
if(_useFBO && _useNPOTTextures)
createColorMapFBO(pEnv);
else
#endif
createColorMap(pEnv);
//deactivate transparent Nodes
for(UInt32 t = 0;t < _shadowVP->_transparent.size();++t)
_shadowVP->_transparent[t]->setTravMask(0);
if(_useFBO)
createShadowMapsFBO(pEnv);
else
createShadowMaps(pEnv);
// switch on all transparent geos
for(UInt32 t = 0;t < _shadowVP->_transparent.size();++t)
_shadowVP->_transparent[t]->setTravMask(TypeTraits<UInt32>::BitsSet);
for(UInt32 i = 0;i < _shadowVP->_lights.size();i++)
{
if(_shadowVP->_lightStates[i] != 0)
{
if(_shadowVP->getGlobalShadowIntensity() != 0.0 ||
_shadowVP->_lights[i].second->getShadowIntensity() != 0.0)
{
#ifdef USE_FBO_FOR_COLOR_AND_FACTOR_MAP
if(_useFBO && _useNPOTTextures)
createShadowFactorMapFBO(pEnv, i);
else
#endif
createShadowFactorMap(pEnv, i);
}
}
}
_shadowVP->_trigger_update = false;
}
}
drawCombineMap(pEnv);
glPopAttrib();
// render the foregrounds.
for(UInt16 i = 0;i < _shadowVP->getMFForegrounds()->size();++i)
{
_shadowVP->getForegrounds(i)->draw(pEnv, _shadowVP);
}
}
}
int main() {
// importation des donnees
Csv_meteoFranceParser* csvPoste = new Csv_meteoFranceParser(pathPoste);
Csv_meteoFranceParser* csvDatas = new Csv_meteoFranceParser(pathDatas);
Csv_meteoFranceParser* csvJoin = csv_join_force(csvPoste, csvDatas, std::string("ID"), std::string("numer_sta"), std::string("Id_Fusion"));
// selection des donnes requises (latitude, longitude, temperature, ...)
std::vector<std::string>* cities = (*csvJoin)[std::string("Nom")];
std::vector<std::string>* latitude = (*csvJoin)[std::string("Latitude")];
std::vector<std::string>* longitude = (*csvJoin)[std::string("Longitude")];
std::vector<std::string>* kelvin = (*csvJoin)[std::string("t")];
float minT, maxT;
findExtrema(minT, maxT, kelvin);
float minLat, maxLat;
float minLong, maxLong;
findExtrema(minLat, maxLat, latitude);
findExtrema(minLong, maxLong, longitude);
////////////////////////////// Instanciation //////////////////////////////
std::vector< std::vector< float >* >* interpoleShepard = new std::vector< std::vector< float >* >(resolution);
for (int i = 0; i < resolution; ++i) {
(*interpoleShepard)[i] = new std::vector<float>(resolution);
}
std::vector< std::vector< float >* >* interpoleHardy = new std::vector< std::vector< float >* >(resolution);
for (int i = 0; i < resolution; ++i) {
(*interpoleHardy)[i] = new std::vector<float>(resolution);
}
int resoSquare = resolution-1;
std::vector< std::vector< short >* >* square = new std::vector< std::vector< short >* >(resoSquare);
for (int i = 0; i < resoSquare; ++i) {
(*square)[i] = new std::vector<short>(resoSquare);
}
////////////////////////////// Interpolation //////////////////////////////
// interpolation des temperatures
computeShepard(interpoleShepard, latitude, longitude, kelvin);
computeHardy(interpoleHardy, latitude, longitude, kelvin);
std::vector< std::vector< float >* >* interpoleData = interpoleHardy;
////////////////////////////// Creation des images //////////////////////////////
QImage *imgSquare = new QImage(resoSquare * RESO, resoSquare * RESO, QImage::Format_ARGB32);
int count = 1;
// calcul des isolignes avec le marching square
for (float isoLine = minT; isoLine < maxT; isoLine += 1) {
computeMarchingSquare(square, interpoleData, isoLine);
drawMarchingSquare(imgSquare, square, interpoleData, isoLine);
imgSquare->save(QString("../Images/anim" + QString::number(count) + ".png"));
std::cout << "n° : " << count << " --> " << isoLine << std::endl;
count++;
}
// creation de la colormap
Colormap *colorMap = createColorMap(minT, maxT);
// calcul de la map des couleurs
QImage *imgColor = new QImage(resoSquare, resoSquare, QImage::Format_ARGB32);
imgColor->fill(qRgba(0,0,0,0));
drawData(imgColor, colorMap, interpoleData);
// dessine la colormap
QImage *imgColormap = new QImage(50, 200, QImage::Format_RGB32);
drawColorMap(imgColormap, colorMap, minT, maxT);
// ecriture dans les fichiers de sorties
imgColormap->save(QString("../Images/colorMap.png"));
imgColor->save(QString("../Images/colorData.png"));
writeKmlInfoFile(QString("../cities.kml"), cities, latitude, longitude);
writeKmlImgFile(QString("../colorData.kml"), latitude, longitude, QString("colorData.png"));
writeKmlImgFile(QString("../isoLine.kml"), latitude, longitude, QString("anim4.png"));
////////////////////////////// Free Memory //////////////////////////////
std::cout << "Delete memory" << std::endl;
delete csvPoste;
delete csvDatas;
delete csvJoin;
delete cities;
delete latitude;
delete longitude;
delete kelvin;
delete imgSquare;
delete imgColor;
delete colorMap;
delete imgColormap;
std::cout << "Fin" << std::endl;
return 0;
}
void PCSSShadowMap::render(RenderActionBase *action)
{
Window *win = action->getWindow();
initialize(win);
if(!_useGLSL || !_useShadowExt)
_shadowVP->Viewport::render(action);
else
{
glPushAttrib(GL_ENABLE_BIT | GL_LIGHTING_BIT);
if(!_initTexturesDone)
initTextures(win);
if(_useFBO)
{
if(!initFBO(win))
printf("ERROR with FBOBJECT\n");
}
GLfloat globalAmbient[] =
{
0.0, 0.0, 0.0, 1.0
};
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globalAmbient);
_firstRun = 1;
for(UInt32 i = 0;i < _shadowVP->_lights.size();i++)
{
beginEditCP(_shadowVP->_texChunks[i]);
{
_shadowVP->_texChunks[i]->setMinFilter(GL_NEAREST);
_shadowVP->_texChunks[i]->setMagFilter(GL_NEAREST);
}
endEditCP(_shadowVP->_texChunks[i]);
}
if(_shadowVP->getPixelWidth() != _width ||
_shadowVP->getPixelHeight() != _height)
{
_width = _shadowVP->getPixelWidth();
_height = _shadowVP->getPixelHeight();
if(_useNPOTTextures)
{
beginEditCP(_colorMap);
beginEditCP(_colorMapImage);
_colorMapImage->set(COLORMAP_FORMAT, _width, _height);
endEditCP(_colorMapImage);
endEditCP(_colorMap);
beginEditCP(_shadowFactorMap);
beginEditCP(_shadowFactorMapImage);
_shadowFactorMapImage->set(GL_RGB, _width, _height);
endEditCP(_shadowFactorMapImage);
endEditCP(_shadowFactorMap);
reInit(win);
}
else
{
if(_width > _height)
_widthHeightPOT = osgnextpower2(_width - 1);
else
_widthHeightPOT = osgnextpower2(_height - 1);
beginEditCP(_colorMap);
beginEditCP(_colorMapImage);
_colorMapImage->set(COLORMAP_FORMAT, _widthHeightPOT, _widthHeightPOT);
endEditCP(_colorMapImage);
endEditCP(_colorMap);
beginEditCP(_shadowFactorMap);
beginEditCP(_shadowFactorMapImage);
_shadowFactorMapImage->set(GL_RGB, _widthHeightPOT,
_widthHeightPOT);
endEditCP(_shadowFactorMapImage);
endEditCP(_shadowFactorMap);
}
}
// need possibility to tell cores like billboard not to change state
RenderAction *rAct = dynamic_cast<RenderAction*>(action);
bool effectsPassSave = rAct ? rAct->getEffectsPass() : false;
if(_shadowVP->getMapAutoUpdate())
{
#ifdef USE_FBO_FOR_COLOR_AND_FACTOR_MAP
if(_useFBO && _useNPOTTextures)
createColorMapFBO(action);
else
#endif
createColorMap(action);
//deactivate transparent Nodes
for(UInt32 t = 0;t < _shadowVP->_transparent.size();++t)
_shadowVP->_transparent[t]->setActive(false);
rAct->setEffectsPass(true);
if(_useFBO)
createShadowMapsFBO(action);
else
createShadowMaps(action);
// switch on all transparent geos
for(UInt32 t = 0;t < _shadowVP->_transparent.size();++t)
_shadowVP->_transparent[t]->setActive(true);
for(UInt32 i = 0;i < _shadowVP->_lights.size();i++)
{
if(_shadowVP->_lightStates[i] != 0)
{
if(_shadowVP->getGlobalShadowIntensity() != 0.0 ||
_shadowVP->_lights[i].second->getShadowIntensity() != 0.0)
{
#ifdef USE_FBO_FOR_COLOR_AND_FACTOR_MAP
if(_useFBO && _useNPOTTextures)
createShadowFactorMapFBO(action, i);
else
#endif
createShadowFactorMap(action, i);
//_firstRun = 0;
}
}
}
}
else
{
if(_shadowVP->_trigger_update)
{
#ifdef USE_FBO_FOR_COLOR_AND_FACTOR_MAP
if(_useFBO && _useNPOTTextures)
createColorMapFBO(action);
else
#endif
createColorMap(action);
//deactivate transparent Nodes
for(UInt32 t = 0;t < _shadowVP->_transparent.size();++t)
_shadowVP->_transparent[t]->setActive(false);
rAct->setEffectsPass(true);
if(_useFBO)
createShadowMapsFBO(action);
else
createShadowMaps(action);
// switch on all transparent geos
for(UInt32 t = 0;t < _shadowVP->_transparent.size();++t)
_shadowVP->_transparent[t]->setActive(true);
for(UInt32 i = 0;i < _shadowVP->_lights.size();i++)
{
if(_shadowVP->_lightStates[i] != 0)
{
if(_shadowVP->getGlobalShadowIntensity() != 0.0 ||
_shadowVP->_lights[i].second->getShadowIntensity() != 0.0)
{
#ifdef USE_FBO_FOR_COLOR_AND_FACTOR_MAP
if(_useFBO && _useNPOTTextures)
createShadowFactorMapFBO(action, i);
else
#endif
createShadowFactorMap(action, i);
}
}
}
_shadowVP->_trigger_update = false;
}
}
rAct->setEffectsPass(effectsPassSave);
drawCombineMap(action);
glPopAttrib();
// render the foregrounds.
for(UInt16 i = 0;i < _shadowVP->getMFForegrounds()->size();++i)
{
_shadowVP->getForegrounds(i)->draw(action, _shadowVP);
}
}
}
void ImageWidget::update(Cairo::RefPtr<Cairo::Context> cairo, unsigned width, unsigned height)
{
Image2DCPtr image = _image;
Mask2DCPtr mask = GetActiveMask(), originalMask = _originalMask, alternativeMask = _alternativeMask;
unsigned int
startX = (unsigned int) round(_startHorizontal * image->Width()),
startY = (unsigned int) round(_startVertical * image->Height()),
endX = (unsigned int) round(_endHorizontal * image->Width()),
endY = (unsigned int) round(_endVertical * image->Height());
size_t
imageWidth = endX - startX,
imageHeight = endY - startY;
if(imageWidth > 30000)
{
int shrinkFactor = (imageWidth + 29999) / 30000;
image = image->ShrinkHorizontally(shrinkFactor);
mask = mask->ShrinkHorizontally(shrinkFactor);
if(originalMask != 0)
originalMask = originalMask->ShrinkHorizontally(shrinkFactor);
if(alternativeMask != 0)
alternativeMask = alternativeMask->ShrinkHorizontally(shrinkFactor);
startX /= shrinkFactor;
endX /= shrinkFactor;
imageWidth = endX - startX;
}
num_t min, max;
findMinMax(image, mask, min, max);
// If these are not yet created, they are 0, so ok to delete.
delete _horiScale;
delete _vertScale;
delete _colorScale;
delete _plotTitle;
if(_showXYAxes)
{
_vertScale = new VerticalPlotScale();
_vertScale->SetDrawWithDescription(_showYAxisDescription);
_horiScale = new HorizontalPlotScale();
_horiScale->SetDrawWithDescription(_showXAxisDescription);
} else {
_vertScale = 0;
_horiScale = 0;
}
if(_showColorScale)
{
_colorScale = new ColorScale();
_colorScale->SetDrawWithDescription(_showZAxisDescription);
} else {
_colorScale = 0;
}
if(_showXYAxes)
{
if(_metaData != 0 && _metaData->HasBand()) {
_vertScale->InitializeNumericTicks(_metaData->Band().channels[startY].frequencyHz / 1e6, _metaData->Band().channels[endY-1].frequencyHz / 1e6);
_vertScale->SetUnitsCaption("Frequency (MHz)");
} else {
_vertScale->InitializeNumericTicks(-0.5 + startY, 0.5 + endY - 1.0);
}
if(_metaData != 0 && _metaData->HasObservationTimes())
{
_horiScale->InitializeTimeTicks(_metaData->ObservationTimes()[startX], _metaData->ObservationTimes()[endX-1]);
_horiScale->SetUnitsCaption("Time");
} else {
_horiScale->InitializeNumericTicks(-0.5 + startX, 0.5 + endX - 1.0);
}
if(_manualXAxisDescription)
_horiScale->SetUnitsCaption(_xAxisDescription);
if(_manualYAxisDescription)
_vertScale->SetUnitsCaption(_yAxisDescription);
}
if(_metaData != 0) {
if(_showColorScale && _metaData->ValueDescription()!="")
{
if(_metaData->ValueUnits()!="")
_colorScale->SetUnitsCaption(_metaData->ValueDescription() + " (" + _metaData->ValueUnits() + ")");
else
_colorScale->SetUnitsCaption(_metaData->ValueDescription());
}
}
if(_showColorScale)
{
if(_scaleOption == LogScale)
_colorScale->InitializeLogarithmicTicks(min, max);
else
_colorScale->InitializeNumericTicks(min, max);
if(_manualZAxisDescription)
_colorScale->SetUnitsCaption(_zAxisDescription);
}
if(_showTitle && !actualTitleText().empty())
{
_plotTitle = new Title();
_plotTitle->SetText(actualTitleText());
_plotTitle->SetPlotDimensions(width, height, 0.0);
_topBorderSize = _plotTitle->GetHeight(cairo);
} else {
_plotTitle = 0;
_topBorderSize = 10.0;
}
// The scale dimensions are depending on each other. However, since the height of the horizontal scale is practically
// not dependent on other dimensions, we give the horizontal scale temporary width/height, so that we can calculate its height:
if(_showXYAxes)
{
_horiScale->SetPlotDimensions(width, height, 0.0, 0.0);
_bottomBorderSize = _horiScale->GetHeight(cairo);
_rightBorderSize = _horiScale->GetRightMargin(cairo);
_vertScale->SetPlotDimensions(width - _rightBorderSize + 5.0, height - _topBorderSize - _bottomBorderSize, _topBorderSize);
_leftBorderSize = _vertScale->GetWidth(cairo);
} else {
_bottomBorderSize = 0.0;
_rightBorderSize = 0.0;
_leftBorderSize = 0.0;
}
if(_showColorScale)
{
_colorScale->SetPlotDimensions(width - _rightBorderSize, height - _topBorderSize, _topBorderSize);
_rightBorderSize += _colorScale->GetWidth(cairo) + 5.0;
}
if(_showXYAxes)
{
_horiScale->SetPlotDimensions(width - _rightBorderSize + 5.0, height -_topBorderSize - _bottomBorderSize, _topBorderSize, _vertScale->GetWidth(cairo));
}
class ColorMap *colorMap = createColorMap();
const double
minLog10 = min>0.0 ? log10(min) : 0.0,
maxLog10 = max>0.0 ? log10(max) : 0.0;
if(_showColorScale)
{
for(unsigned x=0;x<256;++x)
{
num_t colorVal = (2.0 / 256.0) * x - 1.0;
num_t imageVal;
if(_scaleOption == LogScale)
imageVal = exp10((x / 256.0) * (log10(max) - minLog10) + minLog10);
else
imageVal = (max-min) * x / 256.0 + min;
double
r = colorMap->ValueToColorR(colorVal),
g = colorMap->ValueToColorG(colorVal),
b = colorMap->ValueToColorB(colorVal);
_colorScale->SetColorValue(imageVal, r/255.0, g/255.0, b/255.0);
}
}
_imageSurface.clear();
_imageSurface =
Cairo::ImageSurface::create(Cairo::FORMAT_ARGB32, imageWidth, imageHeight);
_imageSurface->flush();
unsigned char *data = _imageSurface->get_data();
size_t rowStride = _imageSurface->get_stride();
Mask2DPtr highlightMask;
if(_highlighting)
{
highlightMask = Mask2D::CreateSetMaskPtr<false>(image->Width(), image->Height());
_highlightConfig->Execute(image, highlightMask, true, 10.0);
}
const bool
originalActive = _showOriginalMask && originalMask != 0,
altActive = _showAlternativeMask && alternativeMask != 0;
for(unsigned long y=startY;y<endY;++y) {
guint8* rowpointer = data + rowStride * (endY - y - 1);
for(unsigned long x=startX;x<endX;++x) {
int xa = (x-startX) * 4;
unsigned char r,g,b,a;
if(_highlighting && highlightMask->Value(x, y) != 0) {
r = 255; g = 0; b = 0; a = 255;
} else if(originalActive && originalMask->Value(x, y)) {
r = 255; g = 0; b = 255; a = 255;
} else if(altActive && alternativeMask->Value(x, y)) {
r = 255; g = 255; b = 0; a = 255;
} else {
num_t val = image->Value(x, y);
if(val > max) val = max;
else if(val < min) val = min;
if(_scaleOption == LogScale)
{
if(image->Value(x, y) <= 0.0)
val = -1.0;
else
val = (log10(image->Value(x, y)) - minLog10) * 2.0 / (maxLog10 - minLog10) - 1.0;
}
else
val = (image->Value(x, y) - min) * 2.0 / (max - min) - 1.0;
if(val < -1.0) val = -1.0;
else if(val > 1.0) val = 1.0;
r = colorMap->ValueToColorR(val);
g = colorMap->ValueToColorG(val);
b = colorMap->ValueToColorB(val);
a = colorMap->ValueToColorA(val);
}
rowpointer[xa]=b;
rowpointer[xa+1]=g;
rowpointer[xa+2]=r;
rowpointer[xa+3]=a;
}
}
delete colorMap;
if(_segmentedImage != 0)
{
for(unsigned long y=startY;y<endY;++y) {
guint8* rowpointer = data + rowStride * (y - startY);
for(unsigned long x=startX;x<endX;++x) {
if(_segmentedImage->Value(x,y) != 0)
{
int xa = (x-startX) * 4;
rowpointer[xa]=IntMap::R(_segmentedImage->Value(x,y));
rowpointer[xa+1]=IntMap::G(_segmentedImage->Value(x,y));
rowpointer[xa+2]=IntMap::B(_segmentedImage->Value(x,y));
rowpointer[xa+3]=IntMap::A(_segmentedImage->Value(x,y));
}
}
}
}
_imageSurface->mark_dirty();
while(_imageSurface->get_width() > (int) width || _imageSurface->get_height() > (int) height)
{
unsigned
newWidth = _imageSurface->get_width(),
newHeight = _imageSurface->get_height();
if(newWidth > width)
newWidth = width;
if(newHeight > height)
newHeight = height;
downsampleImageBuffer(newWidth, newHeight);
}
_isInitialized = true;
_initializedWidth = width;
_initializedHeight = height;
redrawWithoutChanges(cairo, width, height);
}