void jump(int start_x,int x_end,int start_y,cv::Mat character,cv::Mat back,int width,int height){
cv::Mat blend;
cv::Mat img;
char c;
int walk_end_x = x_end-start_x-329;
int top_x =(start_x+x_end)/2;
int y = start_y-50;
int x = start_x;
int up_y=start_y+character.rows;
std::cout<<"y="<<y<<",start_y"<<start_y<<std::endl;
std::cout<<"x="<<x<<std::endl;
img = character;
x= 0;
std::cout<<"top_x"<<top_x<<std::endl;
while(start_x<=x_end){
overlay(img, back, blend, cv::Point(start_x+200,start_y));
cv::Mat anime(blend,cv::Rect(x+start_x,0,width,height));
//std::cout<<"x="<<start_x<<",y="<<start_y<<std::endl;
imshow(winname,anime);
if(start_y >= 255-img.rows){
start_y=start_y-6;
}else if(start_x<x_end){
start_x=start_x+6;
//std::cout<<"x_2="<<x+start_x<<std::endl;
}
c=cv::waitKey(10);
if(c==27){
break;
}
}
while(start_x>=x_end){
overlay(img, back, blend, cv::Point(start_x+200,start_y));
cv::Mat anime(blend,cv::Rect(x+start_x,0,width,height));
//std::cout<<"x="<<start_x<<",y="<<start_y<<std::endl;
imshow(winname,anime);
if(start_y <= y){
start_y=start_y+6;
}
else if(start_y>=y){
break;
}
c=cv::waitKey(10);
if(c==27){
break;
}
}
}
void Theme::build_transport(char *title,
unsigned char *png_overlay,
VFrame **bg_data,
int third)
{
if(!png_overlay) return;
VFrame default_data(png_overlay);
VFrame *data[3];
data[0] = new VFrame(0, default_data.get_w(), default_data.get_h(), BC_RGBA8888);
data[1] = new VFrame(0, default_data.get_w(), default_data.get_h(), BC_RGBA8888);
data[2] = new VFrame(0, default_data.get_w(), default_data.get_h(), BC_RGBA8888);
data[0]->clear_frame();
data[1]->clear_frame();
data[2]->clear_frame();
for(int i = 0; i < 3; i++)
{
int in_x1;
int in_x2;
if(!bg_data[i]) break;
switch(third)
{
case 0:
in_x1 = 0;
in_x2 = default_data.get_w();
break;
case 1:
in_x1 = (int)(bg_data[i]->get_w() * 0.33);
in_x2 = in_x1 + default_data.get_w();
break;
case 2:
in_x1 = bg_data[i]->get_w() - default_data.get_w();
in_x2 = in_x1 + default_data.get_w();
break;
}
overlay(data[i],
bg_data[i],
in_x1,
in_x2);
overlay(data[i],
&default_data);
}
new_image_set_images(title, 3, data[0], data[1], data[2]);
}
void build_gcsa_lcp(const HandleGraph& graph,
gcsa::GCSA*& gcsa,
gcsa::LCPArray*& lcp,
int kmer_size,
size_t doubling_steps,
size_t size_limit,
const string& base_file_name) {
// Add an overlay with the source and sink nodes for GCSA
SourceSinkOverlay overlay(&graph, kmer_size);
gcsa::ConstructionParameters params;
params.setSteps(doubling_steps);
params.setLimit(size_limit);
// Generate the kmers and reduce the size limit by their size.
size_t kmer_bytes = params.getLimitBytes();
string tmpfile = write_gcsa_kmers_to_tmpfile(overlay, kmer_size,
kmer_bytes,
overlay.get_id(overlay.get_source_handle()),
overlay.get_id(overlay.get_sink_handle()),
base_file_name);
params.reduceLimit(kmer_bytes);
// set up the input graph using the kmers
gcsa::InputGraph input_graph({ tmpfile }, true);
// run the GCSA construction
gcsa = new gcsa::GCSA(input_graph, params);
// and the LCP array construction
lcp = new gcsa::LCPArray(input_graph, params);
// delete the temporary debruijn graph file
temp_file::remove(tmpfile);
// results returned by reference
}
START_NS
ModelViewReadOnly::ModelViewReadOnly(QWidget * parent):
TreeView(parent)
{
setHeaderHidden(true);
//header()->setResizeMode(QHeaderView::Stretch);
setRootIsDecorated(false);
setIndentation(0);
setExpandsOnDoubleClick(true);
setItemDelegateForColumn(0, new ModelTreeDelegate());
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
setSelectionMode( SingleSelection );
setSelectionBehavior(SelectRows);
// we disable the provided dnd features,
// as we use a proprietary solution
setDragDropMode(QAbstractItemView::DragDrop);
setDragEnabled(true);
setAcceptDrops(false);
overlay()->setText(tr("Please load a model"));
connect(this, SIGNAL(clicked(QModelIndex)), this, SLOT(__clicked(QModelIndex)));
}
balls()
{
overlay(treescrn, treescrn2);
mvwaddch(treescrn2, 3, 9, (chtype)'@');
mvwaddch(treescrn2, 3, 15, (chtype)'@');
mvwaddch(treescrn2, 4, 8, (chtype)'@');
mvwaddch(treescrn2, 4, 16, (chtype)'@');
mvwaddch(treescrn2, 5, 7, (chtype)'@');
mvwaddch(treescrn2, 5, 17, (chtype)'@');
mvwaddch(treescrn2, 7, 6, (chtype)'@');
mvwaddch(treescrn2, 7, 18, (chtype)'@');
mvwaddch(treescrn2, 8, 5, (chtype)'@');
mvwaddch(treescrn2, 8, 19, (chtype)'@');
mvwaddch(treescrn2, 10, 4, (chtype)'@');
mvwaddch(treescrn2, 10, 20, (chtype)'@');
mvwaddch(treescrn2, 11, 2, (chtype)'@');
mvwaddch(treescrn2, 11, 22, (chtype)'@');
mvwaddch(treescrn2, 12, 1, (chtype)'@');
mvwaddch(treescrn2, 12, 23, (chtype)'@');
wrefresh(treescrn2);
wrefresh(w_del_msg);
return( 0 );
}
texture_2d fdog_filter(const texture_2d& src,
const texture_2d& tfm,
int n,
float sigma_e,
float sigma_r,
float tau,
float sigma_m,
float phi)
{
texture_2d tmp(src.clone_format());
texture_2d dst(src.clone_format());
for (int i = 0; i < n; ++i) {
texture_2d img = (i == 0)? src : overlay(dst, src);
glsl_program fdog0("fdog0_fs.glsl");
fdog0.use();
fdog0.bind_sampler("img", img, GL_LINEAR);
fdog0.bind_sampler("tfm", tfm, GL_NEAREST);
fdog0.set_uniform_1f("sigma_e", sigma_e);
fdog0.set_uniform_1f("sigma_r", sigma_r);
fdog0.set_uniform_1f("tau", tau);
fdog0.set_uniform_2f("img_size", (float)src.get_width(), (float)src.get_height());
fdog0.draw(&tmp);
glsl_program fdog1("fdog1_fs.glsl");
fdog1.use();
fdog1.bind_sampler("img", tmp, GL_LINEAR);
fdog1.bind_sampler("tfm", tfm, GL_NEAREST);
fdog1.set_uniform_1f("sigma_m", sigma_m);
fdog1.set_uniform_1f("phi", phi);
fdog1.set_uniform_2f("img_size", (float)src.get_width(), (float)src.get_height());
fdog0.draw(&dst);
}
return dst;
}
void Theme::build_toggle(VFrame** &data,
unsigned char *png_overlay,
VFrame *up_vframe,
VFrame *hi_vframe,
VFrame *checked_vframe,
VFrame *dn_vframe,
VFrame *checkedhi_vframe)
{
if(!png_overlay ||
!up_vframe ||
!hi_vframe ||
!checked_vframe ||
!dn_vframe ||
!checkedhi_vframe) return;
VFrame default_data(png_overlay);
data = new VFrame*[5];
data[0] = new VFrame(0, default_data.get_w(), default_data.get_h(), BC_RGBA8888);
data[1] = new VFrame(0, default_data.get_w(), default_data.get_h(), BC_RGBA8888);
data[2] = new VFrame(0, default_data.get_w(), default_data.get_h(), BC_RGBA8888);
data[3] = new VFrame(0, default_data.get_w(), default_data.get_h(), BC_RGBA8888);
data[4] = new VFrame(0, default_data.get_w(), default_data.get_h(), BC_RGBA8888);
data[0]->copy_from(up_vframe);
data[1]->copy_from(hi_vframe);
data[2]->copy_from(checked_vframe);
data[3]->copy_from(dn_vframe);
data[4]->copy_from(checkedhi_vframe);
for(int i = 0; i < 5; i++)
overlay(data[i],
&default_data);
}
void walk(int start_x,int end_x,int y,cv::Mat character1,cv::Mat character2,cv::Mat back,int width,int height){
int x=0;
char c;
cv::Mat blend;
cv::Mat img;
while(start_x+x<=end_x){
if(x%3==0){
if(!img.data) img = character1;
else if(img.data==character1.data) img = character2;
else if(img.data==character2.data) img = character1;
}
// std::cout<<"x="<<x+start_x<<",y="<<y<<std::endl;
// std::cout<<"width="<<width<<",height="<<height<<std::endl;
overlay(img, back, blend, cv::Point(200+x+start_x,225)); //合成
cv::Mat anime(blend,cv::Rect(start_x+x,0,width,height));
imshow(winname,anime);
x=x+4;
c=cv::waitKey(10);
if(c==27){
break;
}
}
}
START_NS
ProposalTreeWidget::ProposalTreeWidget(QWidget * p)
: QTreeWidget(p),
mOverlay(new Overlay(this)),
mAddRemoveEnabled(false),
mSolutionSelectionMultiple(true)
//mSolutionDelegate(new SolutionCheckDelegate(this) )
{
setDragEnabled(true);
setDragDropMode(InternalMove);
viewport()->setAcceptDrops(true);
setDropIndicatorShown(true);
setSelectionMode(SingleSelection);
setEditTriggers(AllEditTriggers);
// maintain order accordingly to ColumnId, ColumnProposalText, etc.
setHeaderLabels( QStringList() << tr("Id") << tr("Text") << tr("Solution") );
setRootIsDecorated(false);
setWordWrap(true);
overlay()->setText( tr("Right click to add new proposal") );
connect(this, SIGNAL(itemSelectionChanged()),this, SLOT(onSelectionChange()));
connect(this, SIGNAL(itemChanged(QTreeWidgetItem*,int)), this, SLOT(onItemChange(QTreeWidgetItem*,int)));
connect(this,SIGNAL(itemClicked(QTreeWidgetItem*,int)), this, SLOT(onClicked(QTreeWidgetItem*,int)));
}
void item_palette::setup(const config& cfg)
{
for (const config& group : cfg.child_range("item_group")) {
groups_.push_back(item_group(group));
for (const config& item : group.child_range("item")) {
item_map_.insert(std::pair<std::string, overlay>(item["id"], overlay(item)));
group_map_[group["id"]].push_back(item["id"]);
if (!group["core"].to_bool(false))
non_core_items_.insert(item["id"]);
}
nmax_items_ = std::max(nmax_items_, group_map_[group["id"]].size());
}
select_fg_item("anvil");
select_bg_item("altar");
// Set the default group
set_group("items");
if(active_group().empty()) {
ERR_ED << "No items found." << std::endl;
}
}
gui::OverlayPtr_T UIFactory::createOverlay(const gui::Coords& position, const gui::Coords& size)
{
gui::OverlayPtr_T overlay(new gui::Overlay());
overlay->setPosition(position);
overlay->setSize(size);
return overlay;
}
void ProposalTreeWidget::onActionRemove()
{
Q_ASSERT_X(mClickedIndex.isValid(), "ProposalTreeWidget::onActionRemove","Invalid model index");
model()->removeRow( mClickedIndex.row() );
overlay()->setVisible( model()->rowCount()==0 );
renumber();
}
void Theme::build_patches(VFrame** &data,
unsigned char *png_overlay,
VFrame **bg_data,
int region)
{
if(!png_overlay || !bg_data) return;
VFrame default_data(png_overlay);
data = new VFrame*[5];
data[0] = new VFrame(0, default_data.get_w(), default_data.get_h(), BC_RGBA8888);
data[1] = new VFrame(0, default_data.get_w(), default_data.get_h(), BC_RGBA8888);
data[2] = new VFrame(0, default_data.get_w(), default_data.get_h(), BC_RGBA8888);
data[3] = new VFrame(0, default_data.get_w(), default_data.get_h(), BC_RGBA8888);
data[4] = new VFrame(0, default_data.get_w(), default_data.get_h(), BC_RGBA8888);
for(int i = 0; i < 5; i++)
{
int in_x1;
int in_x2;
switch(region)
{
case 0:
in_x1 = 0;
in_x2 = default_data.get_w();
break;
case 1:
in_x1 = (int)(bg_data[i]->get_w() * 0.33);
in_x2 = in_x1 + default_data.get_w();
break;
case 2:
in_x1 = bg_data[i]->get_w() - default_data.get_w();
in_x2 = in_x1 + default_data.get_w();
break;
}
overlay(data[i],
bg_data[i]);
overlay(data[i],
&default_data);
}
}
bool IMGUI::findCollision(Box &r, Box &out){
for(auto &it : m_collRects){
if(overlay(it, r)){
out = it;
return true;
}
}
return false;
}
void QBlittablePixmapData::mergeOverlay()
{
if (m_unmergedCopy || !showRasterOverlay)
return;
m_unmergedCopy = new QImage(buffer()->copy());
QPainter p(buffer());
p.setCompositionMode(QPainter::CompositionMode_SourceOver);
p.drawImage(0,0,*overlay());
p.end();
}
// trivial implementation to highlight how to use
// wildcard search combined with exchange.
bool prehash_search_and_replace(const char *file) {
if (FILE *f = fopen(file, "rb")) {
fseek(f, 0, SEEK_END);
size_t size = ftell(f);
fseek(f, 0, SEEK_SET);
size_t buffer_size = size + PHASH_MAX_MARGIN;
if (void *buffer = malloc(buffer_size)) {
fread(buffer, size, 1, f);
fclose(f);
// create an overlay string to start scanning
strovl overlay((char*)buffer, (strl_t)buffer_size, (strl_t)size);
// calculate hash of entire file
unsigned int original_hash = overlay.fnv1a();
// find all instances of PHASH token
// extra quotes inserted to allow running tool over this file
strref pattern("P""HASH(*{ \t}\"*@\"*{!\n\r/})");
strref match;
strown<PHASH_MAX_LENGTH> replace;
while ((match = overlay.wildcard_after(pattern, match))) {
// get the keyword to hash
strref keyword = match.between('"', '"');
// generate a replacement to the original string
replace.sprintf("PHASH(\"" STRREF_FMT "\", 0x%08x)", STRREF_ARG(keyword), keyword.fnv1a());
// exchange the match with the evaluated string
overlay.exchange(match, replace.get_strref());
// if about to run out of space, early out.
if (overlay.len()>(overlay.cap()-PHASH_EXTEND_CHARACTERS))
break;
}
// check if there was a change to the data
if (size != overlay.len() || original_hash != overlay.fnv1a()) {
// write back if possible
if ((f = fopen(file, "wb"))) {
fwrite(overlay.get(), overlay.len(), 1, f);
fclose(f);
} else {
free(buffer);
return false;
}
}
free(buffer);
return true;
} else
fclose(f);
}
return false;
}
OverlayID OverlayManager::new_overlay_from_file(const unicode& rml_file) {
auto new_ui = new_overlay();
window_->loader_for(rml_file.encode())->into(std::shared_ptr<Overlay>(overlay(new_ui)));
try {
} catch(...) {
delete_overlay(new_ui);
throw;
}
return new_ui;
}
plotsDialog::plotsDialog(QString startPlot, bool fromTable, QWidget *parent) :
QDialog(parent),
ui(new Ui::plotsDialog)
{
ui->setupUi(this);
tabs = ui->tabWidget;
// setContextMenuPolicy(Qt::NoContextMenu);
setWindowFlags(Qt::Window);
setWindowModality(Qt::WindowModal);
setWindowTitle("Plots");
connect(tabs,SIGNAL(currentChanged(int)),SLOT(resetZoomer(int)));
contextMenu = new QMenu(this);
QAction *actionZoom = new QAction("Zoom",this);
actionZoom->setCheckable(true);
connect(actionZoom,SIGNAL(toggled(bool)),this,SLOT(enableZoomMode(bool)));
contextMenu->addAction(actionZoom);
QAction *actionFormat = new QAction("Format Plot",this);
connect(actionFormat,SIGNAL(triggered()),this,SLOT(edit()));
contextMenu->addAction(actionFormat);
ui->overlayButton->setText("Overlay");
connect(ui->overlayButton,SIGNAL(clicked()),SLOT(overlay()));
ui->deleteButton->setText("Delete");
connect(ui->deleteButton,SIGNAL(clicked()),SLOT(deleteCurrentPlot()));
statusBar = new QStatusBar;
ui->statusBarLayout->addWidget(statusBar);
QMenu* exportMenu = new QMenu;
exportMenu->addAction("Print");
exportMenu->addAction("pdf File");
exportButton = ui->exportMenuButton;
exportButton->setPopupMode(QToolButton::MenuButtonPopup);
exportButton->setMenu(exportMenu);
startPName = startPlot;
isFromTable = fromTable;
ui->zoomButton->setCheckable(true);
setupPlots(true);
theMainwindow->setTPMenu();
actionZoom->setChecked(false);
}
void QBlittablePixmapData::markRasterOverlayImpl(const QRectF &rect)
{
if (!showRasterOverlay)
return;
QRectF transformationRect = clipAndTransformRect(rect);
if(!transformationRect.isEmpty()) {
QPainter p(overlay());
p.setBrush(m_overlayColor);
p.setCompositionMode(QPainter::CompositionMode_Source);
p.fillRect(transformationRect,QBrush(m_overlayColor));
}
}
// Create "overlay" lookup table (multiply and screen combined)
unsigned char * palette_table_overlay(unsigned char *pal){
int fg, bg;
int red, green, blue;
unsigned char * lut;
if(pal==NULL) return NULL;
lut = (unsigned char*)malloc(256*256);
if(lut==NULL) return NULL;
for(fg=0; fg<256; fg++){
for(bg=fg; bg<256; bg++){
red = overlay(pal[bg*3], pal[fg*3]);
green = overlay(pal[bg*3+1], pal[fg*3+1]);
blue = overlay(pal[bg*3+2], pal[fg*3+2]);
lut[(fg<<8)+bg] = palette_find(pal, red, green, blue);
lut[(bg<<8)+fg] = lut[(fg<<8)+bg];
}
}
return lut;
}
void
IconShack::GenerateIpodScrobblingIcons( MooseEnums::UserIconColour eColour )
{
for( int i = 0; i < 4; i++ )
{
QImage icon = maGoodIcons[ eColour ].toImage();
QPainter iconPainter( &icon );
iconPainter.setCompositionMode( QPainter::CompositionMode_SourceOver );
QPixmap overlay( MooseUtils::dataPath( QString( "icons/ipod_overlay_%1.png" ).arg( i ) ) );
iconPainter.drawPixmap( 0, 0, overlay );
mIpodScrobblingIcons[ eColour ].push_back( QPixmap::fromImage( icon ) );
}
}
static TfToken
_GetProxyOverlayMode()
{
TfToken overlay(TfGetEnvSetting(USDVMP_PROXY_OVERLAY));
if (overlay != _tokens->ghosted
and overlay != _tokens->none
and overlay != _tokens->wireframe)
{
TF_WARN("Invalid proxy USDVMP_PROXY_OVERLAY mode: %s\n", overlay.GetText());
return _tokens->ghosted;
}
return overlay;
}
QSharedPointer<Node> Node::CreateClientServer(const PrivateIdentity &ident,
const Group &group, const QList<Address> &local,
const QList<Address> &remote, const QSharedPointer<ISink> &sink,
SessionFactory::SessionType session, AuthFactory::AuthType auth,
const QSharedPointer<KeyShare> &keys)
{
QSharedPointer<GroupHolder> gh(new GroupHolder(group));
QSharedPointer<ClientServer::Overlay> overlay(new ClientServer::Overlay(
ident.GetLocalId(), local, remote, QList<Connections::Id>(), ident.GetSuperPeer()));
QObject::connect(gh.data(), SIGNAL(GroupUpdated()),
overlay.data(), SLOT(GroupUpdated()));
QSharedPointer<Network> network(new CSNetwork(overlay));
return QSharedPointer<Node>(new Node(ident, gh, overlay,
network, sink, session, auth, keys));
}
QSharedPointer<Node> Node::CreateBasicGossip(const PrivateIdentity &ident,
const Group &group, const QList<Address> &local,
const QList<Address> &remote, const QSharedPointer<ISink> &sink,
SessionFactory::SessionType session, AuthFactory::AuthType auth,
const QSharedPointer<KeyShare> &keys)
{
QSharedPointer<GroupHolder> gh(new GroupHolder(group));
QSharedPointer<BaseOverlay> overlay(new BasicGossip(ident.GetLocalId(),
local, remote));
QSharedPointer<Network> network(new DefaultNetwork(
overlay->GetConnectionManager(),
overlay->GetRpcHandler()));
return QSharedPointer<Node>(new Node(ident, gh, overlay,
network, sink, session, auth, keys));
}
void ProposalTreeWidget::addProposalItem(const Proposal &proposal, bool solution)
{
QTreeWidgetItem * item = new QTreeWidgetItem();
item->setFlags( Qt::ItemIsEnabled | Qt::ItemIsSelectable );
addTopLevelItem(item);
item->setText(ColumnProposalText, proposal.text);
//item->setText(ColumnId, proposal.id); will be reset by renumber()
setItemSolution(item, solution);
renumber(); // resets id
resizeColumnToContents(ColumnId);
overlay()->hide();
}
int main( int argc, char const **argv ) {
parseArgs(argc,argv);
printf( "%ux%u\n", outw, outh );
fb2_overlay_t overlay(x,y,outw,outh,alpha,format); // V4L2_PIX_FMT_SGRBG8 ; //
if ( overlay.isOpen() ) {
printf( "opened successfully: mem=%p/%lu\n", overlay.getMem(), overlay.getMemSize() );
unsigned char val = 0 ;
while(1){
memset(overlay.getMem(), val++, overlay.getMemSize());
}
}
else
ERRMSG( "Error opening v4l output\n" );
return 0 ;
}
static int draw_text(struct panel *panel, struct vidframe *frame)
{
char buf[256];
int width = panel->size_text.w;
int height = panel->size_text.h;
struct vidframe f;
struct vidframe *f2 = NULL;
cairo_t *cr = panel->cr;
double tx, ty;
int err;
tx = 1;
ty = height - 3;
/* draw background */
cairo_rectangle (cr, 0, 0, width, height);
cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
cairo_fill (cr);
/* Draw text */
if (re_snprintf(buf, sizeof(buf), "%s %2.2f fps",
panel->label, panel->fps) < 0)
return ENOMEM;
cairo_move_to (cr, tx, ty);
cairo_text_path (cr, buf);
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
cairo_fill_preserve (cr);
cairo_set_line_width (cr, 0.6);
cairo_stroke (cr);
vidframe_init_buf(&f, VID_FMT_ARGB, &panel->size_text,
cairo_image_surface_get_data(panel->surface));
err = vidframe_alloc(&f2, frame->fmt, &panel->size_text);
if (err)
goto out;
vidconv(f2, &f, 0);
overlay(frame, panel->yoffs, f2);
out:
mem_deref(f2);
return err;
}
strng5()
{
mvwaddch(treescrn2, 11, 19, (chtype)'\'');
mvwaddch(treescrn2, 11, 18, (chtype)':');
mvwaddch(treescrn2, 11, 17, (chtype)'.');
mvwaddch(treescrn2, 11, 16, (chtype)',');
mvwaddch(treescrn2, 12, 15, (chtype)'\'');
mvwaddch(treescrn2, 12, 14, (chtype)':');
mvwaddch(treescrn2, 12, 13, (chtype)'.');
mvwaddch(treescrn2, 12, 12, (chtype)',');
/* save a fully lit tree */
overlay(treescrn2, treescrn);
wrefresh(treescrn2);
wrefresh(w_del_msg);
return( 0 );
}
/*!
* Иконка канала.
*/
QIcon ChatIcons::icon(ClientChannel channel, int options)
{
QString file = LS(":/images/channel.png");
if (channel->type() == ChatId::UserId || channel->id().isEmpty()) {
file = LS(":/images/user");
int gender = channel->gender().value();
int color = channel->gender().color();
if (gender == Gender::Unknown) {
file += LS("-unknown");
}
else if (gender == Gender::Ghost) {
file += LS("-ghost");
}
else if (gender == Gender::Bot) {
file += LS("-bot");
}
else if (color != Gender::Default) {
file += LS("-") + Gender::colorToString(color);
}
if (gender == Gender::Female)
file += LS("-female");
file += LS(".png");
}
else if (channel->type() == ChatId::ChannelId && channel->gender().color() == Gender::Green) {
file = LS(":/images/secure.png");
}
const Status& status = channel->status();
if (options & OfflineStatus && status.value() == Status::Offline && !(options & Statuses))
options |= Statuses;
if (options & Statuses) {
if (options & OfflineStatus && (status.value() == Status::Offline || !channel->isSynced()))
return QIcon(QIcon(file).pixmap(16, 16, QIcon::Disabled));
return ChatIcons::icon(file, overlay(status.value()));
}
return QIcon(file);
}
int main ()
{
// Construct the first arrangement, containing a square-shaped face.
Arrangement_2 arr1;
Segment_2 s1 (Point_2(2, 2), Point_2(6, 2));
Segment_2 s2 (Point_2(6, 2), Point_2(6, 6));
Segment_2 s3 (Point_2(6, 6), Point_2(2, 6));
Segment_2 s4 (Point_2(2, 6), Point_2(2, 2));
insert_non_intersecting_curve (arr1, s1);
insert_non_intersecting_curve (arr1, s2);
insert_non_intersecting_curve (arr1, s3);
insert_non_intersecting_curve (arr1, s4);
// Construct the second arrangement, containing a rhombus-shaped face.
Arrangement_2 arr2;
Segment_2 t1 (Point_2(4, 1), Point_2(7, 4));
Segment_2 t2 (Point_2(7, 4), Point_2(4, 7));
Segment_2 t3 (Point_2(4, 7), Point_2(1, 4));
Segment_2 t4 (Point_2(1, 4), Point_2(4, 1));
insert_non_intersecting_curve (arr2, t1);
insert_non_intersecting_curve (arr2, t2);
insert_non_intersecting_curve (arr2, t3);
insert_non_intersecting_curve (arr2, t4);
// Compute the overlay of the two arrangements.
Arrangement_2 overlay_arr;
Overlay_traits overlay_traits;
overlay (arr1, arr2, overlay_arr, overlay_traits);
// Print the size of the overlaid arrangement.
std::cout << "The overlaid arrangement size:" << std::endl
<< " V = " << overlay_arr.number_of_vertices()
<< ", E = " << overlay_arr.number_of_edges()
<< ", F = " << overlay_arr.number_of_faces() << std::endl;
return 0;
}
