void MemoryFrame::buildMemoryFrame(const QString& topLabel)
{
// Create the memory roof
Q_ASSERT(graphicsParentItem);
Q_ASSERT(memoryTop == nullptr);
memoryTop = new MemoryTop(rowSize, topLabel, graphicsParentItem, zValue);
addItem(memoryTop, memoryRoofRows / getHeightInRows(), zValue);
// Create the initial memory rows
createRows(rowCount, startByte);
// If asked, create memory legs
if ( withLegs )
buildMemoryLegs(zValue);
}
int MemoryFrame::grow(int extraRows, int initialDelay)
{
// If there is enough memory
Q_ASSERT(extraRows > 0);
if ( getSize() + extraRows * rowSize > maxSize )
return -1;
// The new memory rows will start after the last memory row or the beginning there isn't any
size_t fromByte = memoryRows.count() > 0 ? memoryRows[memoryRows.count() - 1]->getLastByte() : startByte;
// There is enough memory, create the rows
if ( ! createRows(extraRows, fromByte) )
return false;
// The number of rows grew
rowCount = memoryRows.count();
// We have added more rows, we have to update the proportions of all rows
updateRowProportions();
// ToDo: Animate the new rows raising up from the memory interface of the cpu core
Q_UNUSED(initialDelay);
return 0;
}
SpriteFont::SpriteFont(const char* font, int size, char cs, char ce) {
// Initialize SDL_ttf
if (!TTF_WasInit()) {
TTF_Init();
}
TTF_Font* f = TTF_OpenFont(font, size);
if (f == nullptr) {
fprintf(stderr, "Failed to open TTF font %s\n", font);
fflush(stderr);
throw 281;
}
_fontHeight = TTF_FontHeight(f);
_regStart = cs;
_regLength = ce - cs + 1;
int padding = size / 8;
// First neasure all the regions
glm::ivec4* glyphRects = new glm::ivec4[_regLength];
int i = 0, advance;
for (char c = cs; c <= ce; c++) {
TTF_GlyphMetrics(f, c, &glyphRects[i].x, &glyphRects[i].z, &glyphRects[i].y, &glyphRects[i].w, &advance);
glyphRects[i].z -= glyphRects[i].x;
glyphRects[i].x = 0;
glyphRects[i].w -= glyphRects[i].y;
glyphRects[i].y = 0;
i++;
}
// Find best partitioning of glyphs
int rows = 1, w, h, bestWidth = 0, bestHeight = 0, area = MAX_TEXTURE_RES * MAX_TEXTURE_RES, bestRows = 0;
std::vector<int>* bestPartition = nullptr;
while (rows <= _regLength) {
h = rows * (padding + _fontHeight) + padding;
auto gr = createRows(glyphRects, _regLength, rows, padding, w);
// Desire a power of 2 texture
w = closestPow2(w);
h = closestPow2(h);
// A texture must be feasible
if (w > MAX_TEXTURE_RES || h > MAX_TEXTURE_RES) {
rows++;
delete[] gr;
continue;
}
// Check for minimal area
if (area >= w * h) {
if (bestPartition) delete[] bestPartition;
bestPartition = gr;
bestWidth = w;
bestHeight = h;
bestRows = rows;
area = bestWidth * bestHeight;
rows++;
} else {
delete[] gr;
break;
}
}
// Can a bitmap font be made?
if (!bestPartition) {
fprintf(stderr, "Failed to Map TTF font %s to texture. Try lowering resolution.\n", font);
fflush(stderr);
throw 282;
}
// Create the texture
glGenTextures(1, &_texID);
glBindTexture(GL_TEXTURE_2D, _texID);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bestWidth, bestHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
// Now draw all the glyphs
SDL_Color fg = { 255, 255, 255, 255 };
int ly = padding;
for (int ri = 0; ri < bestRows; ri++) {
int lx = padding;
for (size_t ci = 0; ci < bestPartition[ri].size(); ci++) {
int gi = bestPartition[ri][ci];
SDL_Surface* glyphSurface = TTF_RenderGlyph_Blended(f, (char)(cs + gi), fg);
// Pre-multiplication occurs here
unsigned char* sp = (unsigned char*)glyphSurface->pixels;
int cp = glyphSurface->w * glyphSurface->h * 4;
for (int i = 0; i < cp; i += 4) {
float a = sp[i + 3] / 255.0f;
sp[i] = (unsigned char)((float)sp[i] * a);
sp[i + 1] = sp[i];
sp[i + 2] = sp[i];
}
// Save glyph image and update coordinates
glTexSubImage2D(GL_TEXTURE_2D, 0, lx, bestHeight - ly - 1 - glyphSurface->h, glyphSurface->w, glyphSurface->h, GL_BGRA, GL_UNSIGNED_BYTE, glyphSurface->pixels);
glyphRects[gi].x = lx;
glyphRects[gi].y = ly;
glyphRects[gi].z = glyphSurface->w;
glyphRects[gi].w = glyphSurface->h;
SDL_FreeSurface(glyphSurface);
glyphSurface = nullptr;
lx += glyphRects[gi].z + padding;
}
ly += _fontHeight + padding;
}
// Draw the unsupported glyph
int rs = padding - 1;
int* pureWhiteSquare = new int[rs * rs];
memset(pureWhiteSquare, 0xffffffff, rs * rs * sizeof(int));
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, rs, rs, GL_RGBA, GL_UNSIGNED_BYTE, pureWhiteSquare);
delete[] pureWhiteSquare;
pureWhiteSquare = nullptr;
// Set some texture parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// Create spriteBatch glyphs
_glyphs = new CharGlyph[_regLength + 1];
for (i = 0; i < _regLength; i++) {
_glyphs[i].character = (char)(cs + i);
_glyphs[i].size = glm::vec2(glyphRects[i].z, glyphRects[i].w);
_glyphs[i].uvRect = glm::vec4(
(float)glyphRects[i].x / (float)bestWidth,
(float)glyphRects[i].y / (float)bestHeight,
(float)glyphRects[i].z / (float)bestWidth,
(float)glyphRects[i].w / (float)bestHeight
);
}
_glyphs[_regLength].character = ' ';
_glyphs[_regLength].size = _glyphs[0].size;
_glyphs[_regLength].uvRect = glm::vec4(0, 0, (float)rs / (float)bestWidth, (float)rs / (float)bestHeight);
glBindTexture(GL_TEXTURE_2D, 0);
delete[] glyphRects;
delete[] bestPartition;
TTF_CloseFont(f);
}
/** creates a subproblem for subscip by fixing a number of variables */
static
SCIP_RETCODE setupSubproblem(
SCIP* scip, /**< original SCIP data structure */
SCIP* subscip, /**< SCIP data structure for the subproblem */
SCIP_VAR** subvars, /**< the variables of the subproblem */
int* selection, /**< pool of solutions crossover will use */
SCIP_HEURDATA* heurdata, /**< primal heuristic data */
SCIP_Bool* success /**< pointer to store whether the problem was created successfully */
)
{
SCIP_SOL** sols; /* array of all solutions found so far */
int nsols; /* number of all solutions found so far */
int nusedsols; /* number of solutions to use in crossover */
int i;
char consname[SCIP_MAXSTRLEN];
/* get solutions' data */
nsols = SCIPgetNSols(scip);
sols = SCIPgetSols(scip);
nusedsols = heurdata->nusedsols;
assert(nusedsols > 1);
assert(nsols >= nusedsols);
/* use nusedsols best solutions if randomization is deactivated or there are only nusedsols solutions at hand
* or a good new solution was found since last call */
if( !heurdata->randomization || nsols == nusedsols || heurdata->prevlastsol != sols[nusedsols-1] )
{
SOLTUPLE* elem;
SCIP_HEUR* solheur;
SCIP_Longint solnodenum;
SCIP_Bool allsame;
for( i = 0; i < nusedsols; i++ )
selection[i] = i;
SCIP_CALL( createSolTuple(scip, &elem, selection, nusedsols, heurdata) );
solheur = SCIPsolGetHeur(sols[0]);
solnodenum = SCIPsolGetNodenum(sols[0]);
allsame = TRUE;
/* check, whether all solutions have been found by the same heuristic at the same node; in this case we do not run
* crossover, since it would probably just optimize over the same space as the other heuristic
*/
for( i = 1; i < nusedsols; i++ )
{
if( SCIPsolGetHeur(sols[i]) != solheur || SCIPsolGetNodenum(sols[i]) != solnodenum )
allsame = FALSE;
}
*success = !allsame && !SCIPhashtableExists(heurdata->hashtable, elem);
/* check, whether solution tuple has already been tried */
if( !SCIPhashtableExists(heurdata->hashtable, elem) )
{
SCIP_CALL( SCIPhashtableInsert(heurdata->hashtable, elem) );
}
/* if solution tuple has already been tried, randomization is allowed and enough solutions are at hand, try
* to randomize another tuple. E.g., this can happen if the last crossover solution was among the best ones */
if( !(*success) && heurdata->randomization && nsols > nusedsols )
{
SCIP_CALL( selectSolsRandomized(scip, selection, heurdata, success) );
}
}
/* otherwise randomize the set of solutions */
else
{
SCIP_CALL( selectSolsRandomized(scip, selection, heurdata, success) );
}
/* no acceptable solution tuple could be created */
if( !(*success) )
return SCIP_OKAY;
/* get name of the original problem and add the string "_crossoversub" */
(void) SCIPsnprintf(consname, SCIP_MAXSTRLEN, "%s_crossoversub", SCIPgetProbName(scip));
/* set up the variables of the subproblem */
SCIP_CALL( fixVariables(scip, subscip, subvars, selection, heurdata, success) );
/* we copy the rows of the LP, if the enough variables could be fixed and we work on the MIP
relaxation of the problem */
if( *success && heurdata->uselprows )
{
SCIP_CALL( createRows(scip, subscip, subvars) );
}
return SCIP_OKAY;
}
