void PictureDecorator::draw( Picture& dstpic, const Rect& rectangle, Mode mode, bool useAlpha )
{
switch( mode )
{
case whiteArea: drawArea( dstpic, rectangle, 348, 10, 12, useAlpha ); break;
case blackArea: drawArea( dstpic, rectangle, 487, 5, 7, useAlpha ); break;
case greyPanel: drawPanel( dstpic, rectangle, 25, useAlpha ); break;
case lightgreyPanel: drawPanel( dstpic, rectangle, 22, useAlpha ); break;
case smallBrownPanel: drawPanel( dstpic, rectangle, 65, useAlpha ); break;
case smallGreyPanel: drawPanel( dstpic, rectangle, 68, useAlpha ); break;
case whiteBorder: drawBorder( dstpic, rectangle, 336, 468, 347, 358, 10, 12, 335, 467, 346, 478, useAlpha ); break;
case blackBorder: drawBorder( dstpic, rectangle, 480, 522, 486, 492, 5, 7, 479, 521, 485, 527, useAlpha ); break;
case brownBorder: drawBorder(dstpic, rectangle, 555, useAlpha ); break;
case whiteBorderA: drawBorder( dstpic, rectangle, 547, useAlpha ); break;
case whiteFrame:
draw( dstpic, Rect( rectangle.UpperLeftCorner + Point( 16, 16 ), rectangle.LowerRightCorner - Point( 16, 16 ) ), whiteArea ); // draws the inside of the box
draw( dstpic, rectangle, whiteBorder ); // draws borders
break;
case blackFrame:
draw(dstpic, Rect( rectangle.UpperLeftCorner + Point( 16, 16 ), rectangle.LowerRightCorner - Point( 16, 16 ) ), blackArea ); // draws the inside of the box
draw(dstpic, rectangle, blackBorder ); // draws borders
break;
case brownFrame: drawFrame(dstpic, rectangle, 28, useAlpha); break;
case greyFrame: drawFrame(dstpic, rectangle, 37, useAlpha); break;
}
}
void nurbs_plugin::create()
{
if(widget) return;
if(mesh()->name == "empty"){
document()->deleteModel(document()->getModel("empty"));
}
drawArea()->setRenderer( mesh(), "Transparent");
drawArea()->camera()->setType(qglviewer::Camera::PERSPECTIVE);
entireMesh = (SurfaceMeshModel*)document()->selectedModel();
entirePoints = entireMesh->vertex_property<Vector3>("v:point");
for(int i = 0; i < 10; i++)
randColors.push_back(starlab::qRandomColor());
loadGroupsFromOBJ();
m = mesh();
points = m->vertex_property<Vector3>("v:point");
graph = new Structure::Graph;
ModePluginDockWidget * dockwidget = new ModePluginDockWidget("NURBS plugin", mainWindow());
widget = new NURBSTools(this);
dockwidget->setWidget(widget);
dockwidget->setWindowTitle(widget->windowTitle());
mainWindow()->addDockWidget(Qt::RightDockWidgetArea,dockwidget);
widget->fillList();
mainWindow()->showMaximized();
//buildSamples();
}
void symmetry::applyFilter(RichParameterSet *pars)
{
SymmetryAnalysis sanalysis( mesh() );
mainWindow()->setStatusBarMessage( sanalysis.description() );
bool isVisualize = pars->getBool("Visualize");
if( isVisualize )
{
if( sanalysis.isRotational )
{
starlab::SphereSoup * centerSphere = new starlab::SphereSoup;
centerSphere->addSphere( starlab::QVector3(sanalysis.boundingVolume.center()), 0.1f );
drawArea()->addRenderObject(centerSphere);
drawArea()->drawSegment(sanalysis.boundingVolume.center(), sanalysis.boundingVolume.center() + sanalysis.axis);
}
if( sanalysis.isFitLine )
{
drawArea()->drawSegment( sanalysis.origin - sanalysis.axis, sanalysis.origin + sanalysis.axis, 10 );
}
if( sanalysis.isReflecitonal && !sanalysis.isFitLine )
{
drawArea()->drawSegment( sanalysis.origin - sanalysis.primaryAxis, sanalysis.origin + sanalysis.primaryAxis, 10, Qt::green );
drawArea()->drawSegment( sanalysis.origin - sanalysis.secondaryAxis, sanalysis.origin + sanalysis.secondaryAxis, 10, Qt::blue );
}
}
foreach(auto m, sanalysis.meshes)
document()->addModel(m);
}
void Health::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
//draw background
//engine.draw( tile.picture(), screenPos );
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int healthLevel = -1;
if( _isVisibleObject( overlay->type() ) )
{
// Base set of visible objects
needDrawAnimations = true;
}
else if( _flags.count( overlay->type() ) )
{
needDrawAnimations = true;
//city::Helper helper( _city() );
//drawArea( engine, helper.getArea( overlay ), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
else if( overlay->type() == object::house )
{
HousePtr house = ptr_cast<House>( overlay );
healthLevel = _getLevelValue( house );
needDrawAnimations = (house->spec().level() == 1) && (house->habitants().empty());
if( !needDrawAnimations )
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
}
else //other buildings
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( healthLevel > 0 )
{
drawColumn( engine, screenPos, healthLevel );
}
}
tile.setWasDrawn();
}
void Tax::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
//draw background
engine.draw( tile.picture(), screenPos );
}
else
{
bool needDrawAnimations = false;
TileOverlayPtr overlay = tile.overlay();
int taxLevel = -1;
if( _isVisibleObject( overlay->type() ) )
{
// Base set of visible objects
needDrawAnimations = true;
}
else if( overlay->type() == objects::house )
{
HousePtr house = ptr_cast<House>( overlay );
//taxLevel = house->getServiceValue( Service::forum );
taxLevel = math::clamp<int>( house->taxesThisYear(), 0, 100 );
needDrawAnimations = (house->spec().level() == 1) && (house->habitants().empty());
if( needDrawAnimations )
{
int taxAccess = house->hasServiceAccess( Service::forum );
needDrawAnimations = (taxAccess < 25);
}
if( !needDrawAnimations )
{
city::Helper helper( _city() );
drawArea( engine, helper.getArea( overlay ), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
}
else
{
city::Helper helper( _city() );
drawArea( engine, helper.getArea( overlay ), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( taxLevel > 0 )
{
_addColumn( screenPos, taxLevel );
//drawColumn( engine, screenPos, taxLevel );
}
}
tile.setWasDrawn();
}
void Unemployed::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
//draw background
//engine.draw( tile.picture(), screenPos );
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
WorkingBuildingPtr workBuilding = overlay.as<WorkingBuilding>();
int worklessPercent = 0;
if( _isVisibleObject( overlay->type() ) )
{
needDrawAnimations = true;
}
else if( overlay->type() == object::house )
{
HousePtr house = overlay.as<House>();
int worklessNumber = (int)house->getServiceValue( Service::recruter );
int matureNumber = (int)house->habitants().mature_n();
worklessPercent = math::percentage( worklessNumber, matureNumber );
needDrawAnimations = (house->spec().level() == 1) && house->habitants().empty();
if( !needDrawAnimations )
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
}
else if( workBuilding.isValid() )
{
worklessPercent = math::percentage( workBuilding->needWorkers(), workBuilding->maximumWorkers() );
needDrawAnimations = workBuilding->needWorkers() > 0;
if( !needDrawAnimations )
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( worklessPercent > 0 )
{
drawColumn( engine, screenPos, worklessPercent );
}
}
tile.setWasDrawn();
}
void Religion::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
//draw background
//engine.draw( tile.picture(), screenPos );
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int religionLevel = -1;
if( _isVisibleObject( overlay->type() ) )
{
// Base set of visible objects
needDrawAnimations = true;
}
else if( overlay->type() == object::house )
{
HousePtr house = ptr_cast<House>( overlay );
religionLevel = (int) house->getServiceValue(Service::religionMercury);
religionLevel += house->getServiceValue(Service::religionVenus);
religionLevel += house->getServiceValue(Service::religionMars);
religionLevel += house->getServiceValue(Service::religionNeptune);
religionLevel += house->getServiceValue(Service::religionCeres);
religionLevel = math::clamp( religionLevel / (house->spec().minReligionLevel()+1), 0, 100 );
needDrawAnimations = (house->spec().level() == 1) && house->habitants().empty();
if( !needDrawAnimations )
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
}
else
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( religionLevel > 0 )
{
drawColumn( engine, screenPos, religionLevel );
}
}
tile.setWasDrawn();
}
void Tax::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
//draw background
//engine.draw( tile.picture(), screenPos );
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int taxLevel = -1;
if( _isVisibleObject( overlay->type() ) )
{
// Base set of visible objects
needDrawAnimations = true;
}
else if( overlay->type() == object::house )
{
auto house = overlay.as<House>();
int taxAccess = house->getServiceValue( Service::forum );
taxLevel = math::clamp<int>( house->taxesThisYear(), 0, 100 );
needDrawAnimations = ((house->level() <= HouseLevel::hovel && house->habitants().empty())
|| taxAccess < 25);
if( !needDrawAnimations )
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
}
else
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( taxLevel > 0 )
{
drawColumn( engine, screenPos, taxLevel );
}
}
tile.setRendered();
}
void Fire::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
//draw background
//engine.draw( tile.picture(), screenPos );
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int fireLevel = 0;
if( _isVisibleObject( overlay->type() ) )
{
// Base set of visible objects
needDrawAnimations = true;
}
else if( overlay->type() == object::house )
{
HousePtr house = ptr_cast<House>( overlay );
fireLevel = (int)house->state( pr::fire );
needDrawAnimations = (house->spec().level() == 1) && house->habitants().empty();
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
else //other buildings
{
ConstructionPtr constr = ptr_cast<Construction>( overlay );
if( constr != 0 )
{
fireLevel = (int)constr->state( pr::fire );
}
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( fireLevel >= 0)
{
_addColumn( screenPos, fireLevel );
}
}
tile.setWasDrawn();
}
void Sentiment::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
//draw background
//engine.draw( tile.picture(), screenPos );
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int sentimentLevel = 0;
if( _isVisibleObject( overlay->type() ) )
{
needDrawAnimations = true;
}
else if( overlay->type() == object::house )
{
HousePtr house = overlay.as<House>();
sentimentLevel = (int)house->state( pr::happiness );
needDrawAnimations = (house->spec().level() == 1) && house->habitants().empty();
if( !needDrawAnimations )
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
}
else
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( sentimentLevel > 0 )
{
drawColumn( engine, screenPos, 100 - sentimentLevel );
}
}
tile.setWasDrawn();
}
void Entertainment::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int entertainmentLevel = -1;
if( _isVisibleObject( overlay->type() ) )
{
// Base set of visible objects
needDrawAnimations = true;
}
else if( _flags.count( overlay->type() ) > 0 )
{
needDrawAnimations = true;
}
else if( overlay->type() == object::house )
{
auto house = overlay.as<House>();
entertainmentLevel = _getLevelValue( house );
needDrawAnimations = (house->level() <= HouseLevel::hovel) && (house->habitants().empty());
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
else
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( entertainmentLevel > 0 )
{
drawColumn( engine, screenPos, entertainmentLevel );
}
}
tile.setRendered();
}
void MarketAccess::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int accessLevel = 0;
if( _isVisibleObject( overlay->type() ) )
{
needDrawAnimations = true;
}
else if( overlay->type() == object::house )
{
auto house = overlay.as<House>();
accessLevel = (int)house->getServiceValue( Service::market );
needDrawAnimations = (house->level() <= HouseLevel::hovel) && house->habitants().empty();
if( !needDrawAnimations )
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
}
else
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( accessLevel >= 0 )
{
drawColumn( engine, screenPos, accessLevel );
}
}
tile.setRendered();
}
bool PDCounter::delAreaByClick(Mat& frame) {
////////////Pending to write./////////////////
Mat show_frame;
Point choose;
for (vector<PDDetector>::iterator it = Detectors.begin(); it != Detectors.end(); it++) {
drawArea(show_frame, show_frame, (*it).getArea(), AREA_COLOR);
}
pic_manipulator painter(show_frame);
painter.get_click_info();
choose = painter.getPoint();
for (vector<PDDetector>::iterator it = Detectors.begin(); it != Detectors.end(); it++) {
if (choose.inside((*it).getArea())) {
int ID = (*it).getID();
(*it).boom();
Detectors.erase(it);
// if (it == Detectors.end()) {
// break;
// }
lastLog.assign("Successfully delete the " + i_to_s(ID) + " zone.");
return true;
}
}
lastLog.assign("Where you click is no zones.");
return false;
}
bool surfacemesh_mode_arapdeform::endSelection(const QPoint &)
{
glFlush();
GLint nbHits = glRenderMode(GL_RENDER);
QSet<int> selection;
if (nbHits > 0)
for (int i=0; i<nbHits; ++i)
selection.insert((drawArea()->selectBuffer())[4*i+3]);
foreach(int idx, selection){
Face f(idx);
switch(currentMode)
{
case CONTROL_FACES:
if(selectMode == ADD){
controlFaces.insert(f);
anchorFaces.remove(f);
}
if(selectMode == REMOVE){
controlFaces.remove(f);
}
break;
case ANCHOR_FACES:
if(selectMode == ADD) {anchorFaces.insert(f); controlFaces.remove(f); }
if(selectMode == REMOVE) anchorFaces.remove(f);
break;
case DEFORM:
break;
}
}
/* @Core */
Mat PDCounter::detect(Mat& input) {
string log1("Begin detecting...\n");
Mat output = input.clone();
for (vector<PDDetector>::iterator it = Detectors.begin(); it != Detectors.end(); it++) {
(*it).detect(output, Trackers);// NO parallel
}
string log2("All areas are detected...\n");
string lost = i_to_s(Trackers.tracking(output)); // NO parallel
string log3("Tracking completed...\nThe trackers lost " + lost + " pedestrians in this frame.\n");
if (showPedestrian) {
drawFounds(output, Trackers.getCurrRects(), PEDESTRIAN_COLOR);
}
if (showArea) {
for (vector<PDDetector>::iterator it = Detectors.begin(); it != Detectors.end(); it++) {
drawArea(output, (*it).getArea(), AREA_COLOR);
}
}
if (showTrajectory) {
for (int i = 0; i < Trackers.getSize(); i++) {
drawTrajectory(output, Trackers[i].getTrajectory(), Trajectory_COLOR);
}
}
string log4("Drawing completed");
lastLog = log1 + log2 + log3 + log4;
return output;
}
void dynamic_voxel::create(){
showMesh = false;
showVoxels = false;
drawArea()->updateGL();
}
void Aborigens::drawTile(Engine& engine, Tile& tile, const Point& offset)
{
Point screenPos = tile.mappos() + offset;
if( tile.overlay().isNull() )
{
//draw background
//engine.draw( tile.picture(), screenPos );
drawPass( engine, tile, offset, Renderer::ground );
drawPass( engine, tile, offset, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int discontentLevel = 0;
if( _isVisibleObject( overlay->type() ) )
{
needDrawAnimations = true;
}
else if( overlay->type() == object::native_hut )
{
auto nativeHut = overlay.as<NativeHut>();
discontentLevel = (int)nativeHut->discontent();
needDrawAnimations = false;
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::inHouseBase );
}
else
{
drawArea( engine, overlay->area(), offset, ResourceGroup::foodOverlay, OverlayPic::base );
}
if( needDrawAnimations )
{
Layer::drawTile( engine, tile, offset );
registerTileForRendering( tile );
}
else if( discontentLevel >= 0 )
{
drawColumn( engine, screenPos, discontentLevel );
}
}
tile.setRendered();
}
void Crime::drawTile( const RenderInfo& rinfo, Tile& tile)
{
if( tile.overlay().isNull() )
{
drawPass( rinfo, tile, Renderer::ground );
drawPass( rinfo, tile, Renderer::groundAnimation );
}
else
{
bool needDrawAnimations = false;
OverlayPtr overlay = tile.overlay();
int crime = -1;
if( _isVisibleObject( overlay->type() ) )
{
needDrawAnimations = true;
}
else if( overlay->type() == object::house )
{
auto house = overlay.as<House>();
crime = (int)house->getServiceValue( Service::crime );
needDrawAnimations = (house->level() <= HouseLevel::hovel) && house->habitants().empty(); // In case of vacant terrain
drawArea( rinfo, overlay->area(), config::layer.ground, config::tile.house );
}
else
{
drawArea( rinfo, overlay->area(), config::layer.ground, config::tile.constr );
}
if( needDrawAnimations )
{
Layer::drawTile( rinfo, tile );
registerTileForRendering( tile );
}
else if( crime >= 0)
{
Point screenPos = tile.mappos() + rinfo.offset;
drawColumn( rinfo, screenPos, crime );
}
}
tile.setRendered();
}
void ItemDocument::print() {
static KPrinter *printer = new KPrinter;
if (! printer->setup(KTechlab::self()))
return;
// setup the printer. with Qt, you always "print" to a
// QPainter.. whether the output medium is a pixmap, a screen,
// or paper
QPainter p;
p.begin(printer);
// we let our view do the actual printing
QPaintDeviceMetrics metrics(printer);
// Round to 16 so that we cut in the middle of squares
int w = metrics.width();
w = (w & 0xFFFFFFF0) + ((w << 1) & 0x10);
int h = metrics.height();
h = (h & 0xFFFFFFF0) + ((h << 1) & 0x10);
p.setClipping(true);
p.setClipRect(0, 0, w, h, QPainter::CoordPainter);
// Send off the painter for drawing
m_canvas->setBackgroundPixmap(0);
QRect bounding = canvasBoundingRect();
unsigned int rows = (unsigned) std::ceil(double(bounding.height()) / double(h));
unsigned int cols = (unsigned) std::ceil(double(bounding.width()) / double(w));
int offset_x = bounding.x();
int offset_y = bounding.y();
for (unsigned row = 0; row < rows; ++row) {
for (unsigned col = 0; col < cols; ++col) {
if (row != 0 || col != 0)
printer->newPage();
QRect drawArea(offset_x + (col * w), offset_y + (row * h), w, h);
m_canvas->drawArea(drawArea, & p);
p.translate(-w, 0);
}
p.translate(w * cols, -h);
}
updateBackground();
// and send the result to the printer
p.end();
}
void GameArea::initGame()
{
init_map(_cur_map, _row, _col);
init_map(_copy_map, _row, _col);
_cur_block = nullptr;
_next_block = nullptr;
_is_first_item = true;
_over = false;
_full_row = 0;
drawArea();
_score = 0;
}
void Decorator::draw( Pictures& stack, const Rect& rectangle, Decorator::Mode mode, Rects* rects, bool negY )
{
switch( mode )
{
case whiteArea: drawArea( stack, rectangle, 348, 10, 12 ); break;
case blackArea: drawArea( stack, rectangle, 487, 5, 7 ); break;
case greyPanel: drawPanel( stack, rectangle, 25, rects ); break;
case lightgreyPanel: drawPanel( stack, rectangle, 22, rects ); break;
case greyPanelBig: drawPanel( stack, rectangle, 631, rects ); break;
case lightgreyPanelBig: drawPanel( stack, rectangle, 634, rects ); break;
case greyPanelSmall: drawPanel( stack, rectangle, 68, rects ); break;
case brownPanelSmall: drawPanel( stack, rectangle, 65, rects ); break;
case greenPanelSmall: drawPanel( stack, rectangle, 62, rects ); break;
case redPanelSmall: drawPanel( stack, rectangle, 1165, rects ); break;
case whiteBorder: drawBorder( stack, rectangle, 336, 468, 347, 358, 10, 12, 335, 467, 346, 478 ); break;
case blackBorder: drawBorder( stack, rectangle, 480, 522, 486, 492, 5, 7, 479, 521, 485, 527 ); break;
case brownBorder: drawBorder(stack, rectangle, 555 ); break;
case whiteBorderA: drawBorder( stack, rectangle, 547 ); break;
case whiteFrame:
{
Point offset( 16, 16 );
draw( stack, Rect( rectangle.lefttop() + offset, rectangle.rightbottom() - offset ), whiteArea );
draw( stack, rectangle, whiteBorder ); // draws borders
}
break;
case blackFrame:
draw(stack, Rect( rectangle.lefttop(), rectangle.rightbottom() - Point( 16, 16 ) ), blackArea ); // draws the inside of the box
draw(stack, rectangle, blackBorder ); // draws borders
break;
case brownFrame: drawFrame(stack, rectangle, 28); break;
case greyFrame: drawFrame(stack, rectangle, 37); break;
case pure: break;
default: break;
}
if( !negY )
reverseYoffset( stack );
}
void filter::applyFilter(RichParameterSet* pars){
/// Draw the input vertices if overlay was required
if(pars->getBool(overlayInput)){
Vector3VertexProperty points = mesh()->get_vertex_property<Vector3>(VPOINT);
foreach(Vertex v, mesh()->vertices())
drawArea()->drawPoint(points[v],1,Qt::red);
}
bool isEmbed = pars->getBool(embedVertices);
// We need normals
mesh()->update_face_normals();
mesh()->update_vertex_normals();
QElapsedTimer timer;
timer.start();
VoronoiHelper h(mesh(), drawArea());
h.computeVoronoiDiagram();
h.searchVoronoiPoles();
h.getMedialSpokeAngleAndRadii();
h.setToMedial(isEmbed);
qDebug() << "[VOROMAT]" << timer.elapsed() << "ms";
/// Colorize one of the exposed properties
if( pars->getBool(colorizeRadii) || pars->getBool(colorizeAngle) ){
drawArea()->setRenderer(mesh(),"Smooth");
std::string propname;
if( pars->getBool(colorizeRadii) ) propname = VRADII;
if( pars->getBool(colorizeAngle) ) propname = VANGLE;
ColorizeHelper(mesh(),unsignedColorMap).vscalar_to_vcolor(propname);
// qDebug() << ScalarStatisticsHelper(mesh).statistics(propname);
}
#if 0
/// Test of lambda medial axis
drawArea()->deleteAllRenderObjects();
Vector3VertexProperty vpoles = mesh()->get_vertex_property<Vector3>(VPOLE);
ScalarVertexProperty vangles = mesh()->get_vertex_property<Scalar>(VANGLE);
SurfaceMeshModel* model = new SurfaceMeshModel("", "cloud");
qDebug() << StatisticsHelper<Scalar>(mesh()).statistics(VANGLE);
document()->addModel(model);
drawArea()->setRenderer(mesh(),"Transparent");
drawArea()->setRenderer(model, "Vertices as Dots");
foreach(Vertex v, mesh()->vertices()){
if(vangles[v] > 3.1415*.4)
drawArea()->drawPoint(vpoles[v]);
}
#endif
}
void GameArea::startGame()
{
_start_x = _init_start_x;
_start_y = _init_start_y;
_full_row = 0;
if (_is_first_item) {
_cur_block = _block->genBlock();
_is_first_item = false;
} else {
_cur_block = _next_block;
}
_next_block = _block->genBlock();
cur_block_2_map();
drawArea();
}
bool ForestOrthoLayer::doCreateTile(int level, int tx, int ty, TileStorage::Slot *data)
{
if (Logger::DEBUG_LOGGER != NULL) {
ostringstream oss;
oss << "OrthoForest tile " << getProducerId() << " " << level << " " << tx << " " << ty;
Logger::DEBUG_LOGGER->log("ORTHO", oss.str());
}
if (level >= displayLevel) {
ptr<FrameBuffer> fb = SceneManager::getCurrentFrameBuffer();
TileCache::Tile * t = graphProducer->findTile(level, tx, ty);
assert(t != NULL);
ObjectTileStorage::ObjectSlot *graphData = dynamic_cast<ObjectTileStorage::ObjectSlot*>(t->getData());
GraphPtr g = graphData->data.cast<Graph>();
if (g != NULL) {
vec3d q = getTileCoords(level, tx, ty);
float scale = 2.0f * (1.0f - getTileBorder() * 2.0f / getTileSize()) / q.z;
vec3d tileOffset = vec3d(q.x + q.z / 2.0f, q.y + q.z / 2.0f, scale);
//offsetU->set(vec3f(q.x + q.z / 2.0f, q.y + q.z / 2.0f, scale));
offsetU->set(vec3f(0.0, 0.0, 1.0));
colorU->set(vec4f(color.x, color.y, color.z, color.w));
mesh->setMode(TRIANGLES);
mesh->clear();
ptr<Graph::AreaIterator> ai = g->getAreas();
while (ai->hasNext()) {
AreaPtr a = ai->next();
tess->beginPolygon(mesh);
drawArea(tileOffset, a, *tess);
tess->endPolygon();
}
fb->draw(layerProgram, *mesh);
} else {
if (Logger::DEBUG_LOGGER != NULL) {
ostringstream oss;
oss << "NULL Graph : " << level << " " << tx << " " << ty;
Logger::DEBUG_LOGGER->log("GRAPH", oss.str());
}
}
}
return true;
}
void WMNMap::startGenerate(int timeInterval)
{
if (haveInputParams == false)
{
QMessageBox::critical(this, "Failed", "Input parameters not setted", QMessageBox::Close);
return;
}
if (timeInterval < 1 || timeInterval > 8)
{
QMessageBox::critical(this, "Failed", "Unexpected time interval", QMessageBox::Close);
return;
}
generateArea();
generateTrafficFromTP(TrafficMap.at(timeInterval - 1));
tryMinimize();
drawArea();
drawLinks();
}
int sys_updatePartialWindow()
{
int window_id;
int x1, y1, x2, y2;
color16* context;
WindowLink pWindow;
if (argint(0, &window_id) < 0)
return -1;
pWindow = getWindowById(window_id);
cprintf("updatePartialWindow called: %d\n", pWindow);
if (pWindow == 0) return -1;
int size = ((pWindow->window_position).right_x - (pWindow->window_position).left_x) *
((pWindow->window_position).right_y - (pWindow->window_position).left_y);
//cprintf("window size: %d\n", size);
if (size < 0) return -1;
if (argptr(1, (void*)&context, sizeof(color16) * size) < 0)
return -1;
if (argint(2, &x1) < 0 || argint(3, &y1) < 0 || argint(4, &x2) < 0 || argint(5, &y2) < 0)
return -1;
drawArea(pWindow, context, x1, y1, x2, y2);
return 0;
}
bool dynamic_voxel::keyPressEvent( QKeyEvent* event )
{
bool used = false;
if(event->key() == Qt::Key_V) {
showVoxels = !showVoxels;
Vector3d to(2,2,0);
double radius = 0.5;
vox.begin();
QVector<Vector3d> points;
points.push_back(Vector3d(-1,-1,0));
points.push_back(Vector3d(0,-1,0));
points.push_back(Vector3d(0,0,0));
points.push_back(Vector3d(1,0,0));
points.push_back(Vector3d(1,1,0));
points.push_back(Vector3d(2,1,0));
points.push_back(Vector3d(2,2,0));
vox.addPolyLine(points, radius);
vox.end();
used = true;
}
if(event->key() == Qt::Key_M) {
used = true;
}
drawArea()->updateGL();
return used;
}
void Water::drawTile( const RenderInfo& rinfo, Tile& tile)
{
bool needDrawAnimations = false;
Size areaSize = Size::square(1);
if( tile.overlay().isNull() )
{
drawLandTile( rinfo, tile );
}
else
{
OverlayPtr overlay = tile.overlay();
if( _isVisibleObject( overlay->type() ) )
{
// Base set of visible objects
needDrawAnimations = true;
areaSize = overlay->size();
}
else
{
int tileNumber = 0;
bool haveWater = tile.param( Tile::pFountainWater ) > 0 || tile.param( Tile::pWellWater ) > 0;
needDrawAnimations = false;
if ( overlay->type() == object::house )
{
auto house = overlay.as<House>();
needDrawAnimations = (house->level() <= HouseLevel::hovel) && house->habitants().empty();
tileNumber = config::tile.house-1;
haveWater = haveWater || house->hasServiceAccess(Service::fountain) || house->hasServiceAccess(Service::well);
}
if( !needDrawAnimations )
{
tileNumber += (haveWater ? config::layer.haveWater : 0);
tileNumber += tile.param( Tile::pReservoirWater ) > 0 ? config::layer.reservoirRange : 0;
drawArea( rinfo, overlay->area(), config::layer.water, config::tile.constr + tileNumber );
areaSize = Size::zero;
}
}
if ( needDrawAnimations )
{
Point screenPos = tile.mappos() + rinfo.offset;
Layer::drawTile( rinfo, tile );
if( _d->showWaterValue )
{
auto aqueduct = tile.overlay<Aqueduct>();
if( aqueduct.isValid() )
{
Font f = Font::create( "FONT_2" ).withColor( ColorList::red );
int df = aqueduct->water();
f.draw( rinfo.engine.screen(), utils::format( 0xff, "%x", df), screenPos + Point( 20, -80 ), false );
}
int wellValue = tile.param( Tile::pWellWater );
int fountainValue = tile.param( Tile::pFountainWater );
int reservoirWater = tile.param( Tile::pReservoirWater );
if( wellValue > 0 || fountainValue > 0 || reservoirWater > 0 )
{
std::string text = utils::format( 0xff, "%d/%d/%d", wellValue, fountainValue, reservoirWater );
Font f = Font::create( "FONT_2" ).withColor( ColorList::red );
f.draw( rinfo.engine.screen(), text, screenPos + Point( 20, -80 ), false );
}
}
registerTileForRendering( tile );
}
}
if( !needDrawAnimations && ( tile.isWalkable(true) || tile.getFlag( Tile::tlOverlay ) ) )
{
_drawLandTile( rinfo, tile, areaSize );
}
tile.setRendered();
}
void GameArea::key_press(QKeyEvent* event)
{
switch (event->key()) {
case Qt::Key_Left: {
_start_x -= _step;
if (is_left_most()) {
_start_x += _step;
} else {
cur_block_2_map();
drawArea();
}
break;
}
case Qt::Key_Right: {
_start_x += _step;
if (is_right_most()) {
_start_x -= _step;
} else {
cur_block_2_map();
drawArea();
}
break;
}
case Qt::Key_Up: {
rotate_block();
cur_block_2_map();
drawArea();
break;
}
case Qt::Key_Down: {
if (_is_straight_down) {
_start_y += _step;
if (isMoveFini()) {
_start_y -= _step;
} else {
cur_block_2_map();
drawArea();
}
} else {
int i = 0;
while (!this->isMoveFini()) {
_start_y += _step;
++i;
}
_start_y -= _step;
if (i > 0) {
cur_block_2_map();
drawArea();
}
}
break;
}
default:
QFrame::keyPressEvent(event);
}
}
void analyze::applyFilter(RichParameterSet* pars)
{
starlab::LineSegments * bbox_lines = new starlab::LineSegments(1);
std::vector<starlab::LineSegments*> dir_lines(3, new starlab::LineSegments(2));
starlab::PolygonSoup * ps = new starlab::PolygonSoup;
std::vector< std::vector<double> > colors = starlab::randomColors(12);
mainWindow()->setStatusBarMessage("Finding connected pieces..");
QApplication::processEvents();
std::vector< SurfaceMesh::SurfaceMeshModel* > pieces = connectedPieces( mesh() );
std::vector<Vector3> all_points;
std::vector<MinOBB::OBB> obb( pieces.size() );
mainWindow()->setStatusBarMessage("Finding OBBs..");
QApplication::processEvents();
QElapsedTimer timer; timer.start();
if( pars->getBool("IsParallel") )
{
int N = pieces.size();
#pragma omp parallel for
for(int i = 0; i < N; i++)
{
Vector3VertexProperty points = pieces[i]->vertex_coordinates();
std::vector<Vector3> all_points;
for(auto v: pieces[i]->vertices()) all_points.push_back( points[v] );
obb[i] = MinOBB::OBB( all_points, true );
}
}
else
{
for(size_t pi = 0; pi < pieces.size(); pi++)
{
auto piece = pieces[pi];
Vector3VertexProperty points = piece->vertex_coordinates();
std::vector<Vector3> all_points;
for(auto v: piece->vertices()) all_points.push_back( points[v] );
bool isAddJitter = true;
obb[pi] = MinOBB::OBB( all_points, isAddJitter );
std::vector<Vector3> dir(3);
for(int i = 0; i < 3; i++){
dir[0][i] = obb[pi].bb.dir_1[i];
dir[1][i] = obb[pi].bb.dir_2[i];
dir[2][i] = obb[pi].bb.dir_3[i];
}
std::vector<Vector3> c = obb[pi].corners<Vector3>();
bbox_lines->addLines( (QVector<Vector3>() << c[0] << c[1] << c[5] << c[4] << c[0]).toStdVector(), Qt::black );
bbox_lines->addLines( (QVector<Vector3>() << c[0] << c[1] << c[3] << c[2] << c[0]).toStdVector(), Qt::black );
bbox_lines->addLines( (QVector<Vector3>() << c[6] << c[7] << c[3] << c[2] << c[6]).toStdVector(), Qt::black );
bbox_lines->addLines( (QVector<Vector3>() << c[6] << c[7] << c[5] << c[4] << c[6]).toStdVector(), Qt::black );
Vector3 mean(0,0,0);
for(auto p: c) mean += p;
mean /= c.size();
dir_lines[0]->addLine(mean, Vector3(mean + dir[0] * 0.5 * obb[pi].bb.length(0)), Qt::red);
dir_lines[1]->addLine(mean, Vector3(mean + dir[1] * 0.5 * obb[pi].bb.length(1)), Qt::green);
dir_lines[2]->addLine(mean, Vector3(mean + dir[2] * 0.5 * obb[pi].bb.length(2)), Qt::blue);
if( pars->getBool("VisualizeBoxes") ){
std::vector< std::vector<Vector3> > face = obb[pi].faces<Vector3>();
for(size_t i = 0; i < face.size(); i++){
ps->addPoly((QVector<starlab::QVector3>() << face[i][2] << face[i][1] << face[i][0]), QColor::fromRgbF(colors[i][0],colors[i][1],colors[i][2], 0.1));
}
}
}
}
if( pars->getBool("Visualize") )
{
drawArea()->addRenderObject(bbox_lines);
for(size_t i = 0; i < dir_lines.size(); i++) drawArea()->addRenderObject( dir_lines[i] );
drawArea()->addRenderObject(ps);
}
mainWindow()->setStatusBarMessage( QString("Done finding OBBs. (%1 ms)").arg(timer.elapsed()));
QApplication::processEvents();
Structure::Graph * graph = new Structure::Graph();
for(size_t bi = 0; bi < obb.size(); bi++)
{
MinOBB::OBB::OBBOX<Vector3> oi( obb[bi].bb );
std::vector<Vector3> dir(3);
for(int i = 0; i < 3; i++){
dir[0][i] = obb[bi].bb.dir_1[i];
dir[1][i] = obb[bi].bb.dir_2[i];
dir[2][i] = obb[bi].bb.dir_3[i];
}
Vector3 delta = dir[2] * oi.HalfSize[2];
Vector3 from = oi.Center + delta;
Vector3 to = oi.Center - delta;
NURBS::NURBSCurved curve = NURBS::NURBSCurved::createCurve(from, to);
Structure::Curve * n = new Structure::Curve(curve, QString("node%1").arg(bi));
graph->addNode( n );
}
mainWindow()->setStatusBarMessage("Now finding edges..");
QApplication::processEvents();
starlab::LineSegments * graphLines = new starlab::LineSegments(4);
for(size_t i = 0; i < obb.size(); i++){
MinOBB::OBB::OBBOX<Vector3> oi( obb[i].bb );
for(size_t j = i + 1; j < obb.size(); j++){
MinOBB::OBB::OBBOX<Vector3> oj( obb[j].bb );
bool isIsect = MinOBB::OBB::testObbObb<Vector3>( oi, oj );
if( isIsect )
{
graph->addEdge(QString("node%1").arg(i), QString("node%1").arg(j));
if( pars->getBool("VisualizeGraph") )
graphLines->addLine( oi.Center, oj.Center, Qt::magenta );
}
}
}
drawArea()->addRenderObject( graphLines );
graph->saveToFile("graph.xml");
}
