int grey(int n, int k) {
if(n == 0) return 0;
if(k >= N2[n-1])
return N2[n-1]|(grey(n-1, N2[n]-k-1));
else
return grey(n-1, k);
}
ulong
grey(int i)
{
if(i < 0)
return grey(0);
if(i > 255)
return grey(255);
return (i<<16)+(i<<8)+i;
}
std::vector<gmtl::Point3f> cPoints(std::vector<gmtl::Point3f> verts, char col)
{
std::vector<gmtl::Point3f> color;
//std::cout << vertices.size() << std::endl;;
for (unsigned int i = 0; i < verts.size(); i++)
{
gmtl::Point3f red(1, 0, 0);
gmtl::Point3f blue(0, 0, 1);
gmtl::Point3f green(0, 1, 0);
gmtl::Point3f white(1, 1, 1);
gmtl::Point3f grey(0.5f, 0.5f, 0.5f);
gmtl::Point3f old(verts.at(i));
switch (col)
{
case 'w':
color.push_back(white);
break;
case 'o':
color.push_back(old);
break;
case 'g':
color.push_back(grey);
break;
case 'h':
if (i < verts.size() / 2)
color.push_back(blue);
else
color.push_back(green);
break;
}
}
return color;
}
int
maintime::idle_progress (long ticks)
{
m_tick = ticks;
m_window->clear();
m_gc->set_foreground(black());
m_window->draw_rectangle
(
m_gc, false, 0, 0, m_window_x - 1, m_window_y - 1
);
int width = m_window_x - m_pill_width - 1;
int tick_x = ((m_tick % m_ppqn) * (m_window_x - 1)) / m_ppqn ;
int beat_x = (((m_tick / 4) % m_ppqn) * width) / m_ppqn ;
int bar_x = (((m_tick / 16) % m_ppqn) * width) / m_ppqn ;
if (tick_x <= (m_window_x / 4))
{
m_gc->set_foreground(grey());
m_window->draw_rectangle
(
m_gc, true, 2, /*tick_x + 2,*/ 2, m_window_x - 4, m_window_y - 4
);
}
m_gc->set_foreground(black());
m_window->draw_rectangle
(
m_gc, true, beat_x + 2, 2, m_pill_width, m_window_y - 4
);
m_window->draw_rectangle
(
m_gc, true, bar_x + 2, 2, m_pill_width, m_window_y - 4
);
return true;
}
void BinaryImage::save(const char* path, enum ImageEncoding enc)
{
GreyscaleImage grey(this->getWidth(), this->getHeight());
this->convert(&grey);
grey.saveContext(grey.getOscarContext(), path);
}
void greyscale()
{
g_print("greyscale\n");
SDL_Surface *ecran = NULL, *surface_tmp_g = NULL;
SDL_Rect position;
position.x = 0;
position.y = 0;
SDL_Init(SDL_INIT_VIDEO);
surface_tmp_g = IMG_Load(chemin);
ecran = SDL_SetVideoMode(surface_tmp_g->w, surface_tmp_g->h, 32, SDL_HWSURFACE);
SDL_WM_SetCaption("PicToText", NULL);
grey(surface_tmp_g);
SDL_SaveBMP(surface_tmp_g, "image_grey");
SDL_Flip(ecran);
SDL_FreeSurface(surface_tmp_g);
SDL_Quit();
GtkWidget *image, *pHbox, *window;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window),1550,900);
gtk_container_set_border_width(GTK_CONTAINER(window),10);
pHbox = gtk_hbox_new(FALSE,8);
image = gtk_image_new_from_file("image_grey");
gtk_box_pack_start(GTK_BOX(pHbox), image, FALSE,TRUE,0);
gtk_container_add(GTK_CONTAINER(window), pHbox);
gtk_widget_show_all(window);
}
void
perfroll::fill_background_pixmap ()
{
m_gc->set_foreground(white()); /* clear background */
m_background->draw_rectangle(m_gc, true, 0, 0, m_background_x, m_names_y);
m_gc->set_foreground(grey()); /* draw horz grey lines */
gint8 dash = 1;
m_gc->set_dashes(0, &dash, 1);
m_gc->set_line_attributes
(
1, Gdk::LINE_ON_OFF_DASH, Gdk::CAP_NOT_LAST, Gdk::JOIN_MITER
);
m_background->draw_line(m_gc, 0, 0, m_background_x, 0);
int beats = m_measure_length / m_beat_length;
for (int i = 0; i < beats ;) /* draw vertical lines */
{
if (i == 0)
{
m_gc->set_line_attributes
(
1, Gdk::LINE_SOLID, Gdk::CAP_NOT_LAST, Gdk::JOIN_MITER
);
}
else
{
m_gc->set_line_attributes
(
1, Gdk::LINE_ON_OFF_DASH, Gdk::CAP_NOT_LAST, Gdk::JOIN_MITER
);
}
m_gc->set_foreground(grey());
m_background->draw_line /* solid line, every beat */
(
m_gc, i * m_beat_length / m_perf_scale_x,
0, i * m_beat_length / m_perf_scale_x, m_names_y
);
if (m_beat_length < m_ppqn / 2) /* jump 2 if 16th notes */
i += (m_ppqn / m_beat_length);
else
++i;
}
m_gc->set_line_attributes /* reset line style */
(
1, Gdk::LINE_SOLID, Gdk::CAP_NOT_LAST, Gdk::JOIN_MITER
);
}
int main() {
int n, k, t;
for(n = 0; n <= 31; n++)
N2[n] = 1<<n;
ReadInt(&t);
while(t--) {
ReadInt(&n);
ReadInt(&k);
printf("%d\n", grey(n, k));
}
return 0;
}
void
GUIContainerStop::drawGL(const GUIVisualizationSettings& s) const {
glPushName(getGlID());
glPushMatrix();
RGBColor grey(177, 184, 186, 171);
RGBColor blue(83, 89, 172, 255);
// draw the area
int i;
glTranslated(0, 0, getType());
GLHelper::setColor(blue);
GLHelper::drawBoxLines(myFGShape, myFGShapeRotations, myFGShapeLengths, 1.0);
// draw details unless zoomed out to far
const SUMOReal exaggeration = s.addSize.getExaggeration(s);
if (s.scale * exaggeration >= 10) {
// draw the lines
for (i = 0; i != (int)myLines.size(); ++i) {
glPushMatrix();
glTranslated(myFGSignPos.x(), myFGSignPos.y(), 0);
glRotated(180, 1, 0, 0);
glRotated(myFGSignRot, 0, 0, 1);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
pfSetPosition(0, 0);
pfSetScale(1.f);
glScaled(exaggeration, exaggeration, 1);
glTranslated(1.2, -(double)i, 0);
pfDrawString(myLines[i].c_str());
glPopMatrix();
}
// draw the sign
glTranslated(myFGSignPos.x(), myFGSignPos.y(), 0);
int noPoints = 9;
if (s.scale * exaggeration > 25) {
noPoints = MIN2((int)(9.0 + (s.scale * exaggeration) / 10.0), 36);
}
glScaled(exaggeration, exaggeration, 1);
GLHelper::drawFilledCircle((SUMOReal) 1.1, noPoints);
glTranslated(0, 0, .1);
GLHelper::setColor(grey);
GLHelper::drawFilledCircle((SUMOReal) 0.9, noPoints);
if (s.scale * exaggeration >= 4.5) {
GLHelper::drawText("C", Position(), .1, 1.6 * exaggeration, blue, myFGSignRot);
}
}
glPopMatrix();
glPopName();
drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
for (std::vector<MSTransportable*>::const_iterator i = myWaitingTransportables.begin(); i != myWaitingTransportables.end(); ++i) {
glTranslated(0, 1, 0); // make multiple containers viewable
static_cast<GUIContainer*>(*i)->drawGL(s);
}
}
void
mousethread(void *v)
{
Point p;
Mouse m;
int i, n, prev;
char buf[100];
ulong rgb;
prev = -1;
while(readmouse(mousectl) >= 0){
m = mousectl->m;
switch(m.buttons){
case 1:
while(m.buttons){
if(screen->depth > 8)
n = 256;
else
n = 1<<screen->depth;
for(i=0; i!=n; i++)
if(i!=prev && ptinrect(m.xy, crect[i])){
if(ramp)
rgb = grey(i);
else
rgb = cmap2rgb(i);
sprint(buf, fmt,
i,
(rgb>>16)&0xFF,
(rgb>>8)&0xFF,
rgb&0xFF,
(rgb<<8) | 0xFF);
p = addpt(screen->r.min, Pt(2,2));
draw(screen, Rpt(p, addpt(p, stringsize(font, buf))), display->white, nil, p);
string(screen, p, display->black, ZP, font, buf);
prev=i;
break;
}
readmouse(mousectl);
m = mousectl->m;
}
break;
case 4:
switch(menuhit(3, mousectl, &menu, nil)){
case 0:
threadexitsall(0);
}
}
}
}
void ImageEffect::applyEffect(QImage &i, int effect) {
switch(effect)
{
case ImageEffect::Effect_None:
break;
case ImageEffect::Effect_Grey:
grey(i); break;
case ImageEffect::Effect_Invert:
invert(i); break;
case ImageEffect::Effect_Mono:
mono(i); break;
case ImageEffect::Effect_Smurf:
smurf(i); break;
}
}
bool task3_2(const cv::Mat& image) {
int suff = 1;
bool res = true;
for (int i = 0; i < task3_2c; ++i) {
cv::Mat grey(image);
grey.convertTo(grey, CV_32F);
grey /= 255;
cv::pow(grey, task3_2v[i], grey);
grey *= 255;
grey.convertTo(grey, CV_8U);
grey.push_back(image);
res &= cv::imwrite(PATH + generateName("Task3_2-", suff++), grey);
}
return res;
}
//expects blocks, not clusters!!
void NandWindow::DrawBlockMap( QList<quint16> newFile )
{
if( blocks.size() != 0x1000 )
{
qWarning() << "NandWindow::DrawBlockMap -> current blocks are f****d up, son" << hex << blocks.size();
return;
}
QPixmap blue( ":/blue.png" );
QPixmap green( ":/green.png" );
QPixmap pink( ":/pink.png" );
QPixmap grey( ":/grey.png" );
QPixmap black( ":/black.png" );
for( quint16 i = 0; i < 0x1000; i++ )
{
quint16 thisBlock;
if( !newFile.contains( i ) )
{
thisBlock = blocks.at( i );
}
else
{
thisBlock = 2;
}
switch( thisBlock )
{
default:
case 1://used, but not in this file
pmi[ i ]->setPixmap( green );
break;
case 2://used in this file
pmi[ i ]->setPixmap( pink );
break;
case 0xFFFE://free block
pmi[ i ]->setPixmap( grey );
break;
case 0xFFFC://reserved
pmi[ i ]->setPixmap( blue );
break;
case 0xFFFD: // bad block
pmi[ i ]->setPixmap( black );
break;
}
}
}
void grey_scale(t_img_desc* img)
{
if (img->comp < 3)
return;
// (i*3) because img->comp suck with BMP img
for (int i = 0; i < img->x * img->y; ++i) {
img->data[i] = grey(img->data[(i * 3)],
img->data[(i * 3) + 1],
img->data[(i * 3) + 2]);
}
// make the array shorter
uchar *tmp = realloc(img->data, sizeof(char) * img->x * img->y);
assert(tmp);
img->data = tmp;
img->comp = 1;
}
int
maintime::idle_progress (midipulse ticks)
{
if (ticks >= 0) /* ca 2016-03-17 to make bar appear */
{
const int yoff = 4;
int tick_x = (ticks % m_ppqn) * m_box_width / m_ppqn;
int beat_x = ((ticks / m_beat_width) % m_ppqn) * m_box_less_pill / m_ppqn;
int bar_x = ((ticks / m_bar_width) % m_ppqn) * m_box_less_pill / m_ppqn;
m_tick = ticks;
clear_window();
draw_rectangle(black(), 0, yoff, m_box_width, m_box_height, false);
if (tick_x <= m_flash_x) /* for flashing the maintime bar */
draw_rectangle(grey(), 2, yoff+2, m_flash_width, m_flash_height);
draw_rectangle(black(), beat_x + 2, yoff+2, m_pill_width, m_flash_height);
draw_rectangle(bar_x + 2, yoff+2, m_pill_width, m_flash_height);
}
return true;
}
void
daSplat::Update( float timeStep )
{
m_timer -= timeStep;
SetScale(vsVector2D(1.2f,1.2f));
if ( m_timer <= 0.f )
{
Extract(); // despawn us.
}
else
{
vsColor grey(0.5f,0.5f,0.5f,1.0f);
if ( m_timer > 1.0f )
SetColor(grey);
else
SetColor( vsInterpolate( m_timer, vsColor::Black, grey ) );
}
}
void GreyImage_test::testReadFromGrey() {
Block block;
GreyImage grey( 20, 10 );
// X X X X
// X X 1 2
// X X 3 4
grey[2][1] = 1;
grey[2][2] = 2;
grey[3][1] = 3;
grey[3][2] = 4;
grey.getBlock( block, 2, 1 );
QVERIFY( block[0][0] == 1 );
QVERIFY( block[0][1] == 2 );
QVERIFY( block[1][0] == 3 );
QVERIFY( block[1][1] == 4 );
}
bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
//the problem is same as finding a cycle in a directed graph
//this will hold the graph
//cout<<"here2\n";
vector<unordered_set<int>> graph(numCourses);
for (auto courses : prerequisites){
graph[courses.second].insert(courses.first);
}
vector<bool> visited(numCourses, false); //keeping track of all the taken courses
vector<bool> grey(numCourses, false); //keep track of the current visited node
//start dfs from the first node
//cout<<"here1\n";
for (int i=0; i<numCourses; i++) {
//if the node is not visited visit the node and do dfs from each of its connections
if (!visited[i]) {
if (hascycle(i,visited,graph,grey)) {
return false;
}
}
}
return true;
}
subObservationVisualiserBase::subObservationVisualiserBase(const context& contextObj, float pointSize)
:pointSize(pointSize), contextObj(contextObj),standardPointsItem(NULL), standardLinesItem(NULL), backgroundItem(NULL)
{
//We don't run this if there are no vertex positions
if(contextObj.getVertexPositions().size() == 0)
{
std::cout << "Specified graph did not have vertex positions, exiting..." << std::endl;
QTimer::singleShot(0, this, SLOT(close()));
return;
}
initialiseControls();
QPen pen(Qt::NoPen);
QColor grey("grey");
grey.setAlphaF(0.5);
QBrush brush;
brush.setColor(grey);
brush.setStyle(Qt::SolidPattern);
backgroundItem = new QGraphicsRectItem(minX, minY, maxX - minX, maxY - minY, NULL);
backgroundItem->setPen(pen);
backgroundItem->setBrush(brush);
backgroundItem->setZValue(-1);
graphicsScene->addItem(backgroundItem);
}
void
perfroll::draw_sequence_on (Glib::RefPtr<Gdk::Drawable> a_draw, int a_sequence)
{
if ((a_sequence < m_sequence_max) && perf().is_active(a_sequence))
{
long tick_offset = m_4bar_offset * m_ticks_per_bar;
long x_offset = tick_offset / m_perf_scale_x;
m_sequence_active[a_sequence] = true;
sequence * seq = perf().get_sequence(a_sequence);
seq->reset_draw_trigger_marker();
a_sequence -= m_sequence_offset;
long sequence_length = seq->get_length();
int length_w = sequence_length / m_perf_scale_x;
long tick_on;
long tick_off;
long offset;
bool selected;
while (seq->get_next_trigger(&tick_on, &tick_off, &selected, &offset))
{
if (tick_off > 0)
{
long x_on = tick_on / m_perf_scale_x;
long x_off = tick_off / m_perf_scale_x;
int w = x_off - x_on + 1;
int x = x_on;
int y = m_names_y * a_sequence + 1; // + 2
int h = m_names_y - 2; // - 4
x -= x_offset; /* adjust to screen coordinates */
if (selected)
m_gc->set_foreground(grey());
else
m_gc->set_foreground(white());
a_draw->draw_rectangle
(
m_gc, true, x, y, w, h
);
m_gc->set_foreground(black());
a_draw->draw_rectangle
(
m_gc, false, x, y, w, h
);
m_gc->set_foreground(black());
a_draw->draw_rectangle
(
m_gc, false, x, y,
m_size_box_w, m_size_box_w // ?
);
a_draw->draw_rectangle
(
m_gc, false,
x + w - m_size_box_w,
y + h - m_size_box_w,
m_size_box_w, m_size_box_w // ?
);
m_gc->set_foreground(black());
long length_marker_first_tick =
(
tick_on - (tick_on % sequence_length) +
(offset % sequence_length) - sequence_length
);
long tick_marker = length_marker_first_tick;
while (tick_marker < tick_off)
{
long tick_marker_x =
(tick_marker / m_perf_scale_x) - x_offset;
if (tick_marker > tick_on)
{
m_gc->set_foreground(light_grey());
a_draw->draw_rectangle
(
m_gc, true, tick_marker_x, y + 4, 1, h - 8
);
}
int lowest_note = seq->get_lowest_note_event();
int highest_note = seq->get_highest_note_event();
int height = highest_note - lowest_note + 2;
int length = seq->get_length();
long tick_s;
long tick_f;
int note;
bool selected;
int velocity;
draw_type dt;
seq->reset_draw_marker();
m_gc->set_foreground(black());
while
(
(
dt = seq->get_next_note_event
(
&tick_s, &tick_f, ¬e, &selected, &velocity
)
) != DRAW_FIN
)
{
int note_y =
(
(m_names_y-6) -
((m_names_y-6) * (note-lowest_note)) / height
) + 1;
int tick_s_x =
((tick_s * length_w) / length) + tick_marker_x;
int tick_f_x =
((tick_f * length_w) / length) + tick_marker_x;
if (dt == DRAW_NOTE_ON || dt == DRAW_NOTE_OFF)
tick_f_x = tick_s_x + 1;
if (tick_f_x <= tick_s_x)
tick_f_x = tick_s_x + 1;
if (tick_s_x < x)
tick_s_x = x;
if (tick_f_x > x + w)
tick_f_x = x + w;
if (tick_f_x >= x && tick_s_x <= x + w)
{
m_pixmap->draw_line
(
m_gc, tick_s_x, y + note_y,
tick_f_x, y + note_y
);
}
}
tick_marker += sequence_length;
}
}
}
}
}
void
MppTabBar :: paintEvent(QPaintEvent *event)
{
int ht = computeHeight(width());
if (ht != height())
doRepaintEnqueue();
QPainter paint(this);
int w = width();
int h = height();
int x_off = 0;
int y_off;
int n;
int r;
paint.setRenderHints(QPainter::Antialiasing, 1);
paint.setFont(font());
QColor grey(192,192,192);
QColor light(128,128,128);
QColor white(255,255,255);
QColor black(0,0,0);
paint.setPen(QPen(grey, 0));
paint.setBrush(grey);
paint.drawRoundedRect(QRect(0,0,w,h), 4, 4);
for (r = n = 0; n != ntabs; n++) {
int dw = computeWidth(n);
if (x_off != 0 && x_off + dw >= w) {
x_off = 0;
r++;
}
y_off = r * basic_size * 2;
if (isVisible(tabs[n].w)) {
paint.setPen(QPen(black, 0));
paint.setBrush(black);
} else {
paint.setPen(QPen(light, 0));
paint.setBrush(light);
}
if (tabs[n].flags & FLAG_LEFT) {
QPoint temp[3] = {
QPoint(x_off, y_off + basic_size),
QPoint(x_off + basic_size, y_off + (basic_size / 4)),
QPoint(x_off + basic_size, y_off + (basic_size * 2) - (basic_size / 4) - 1)
};
paint.drawPolygon(temp, 3);
} else if (tabs[n].flags & FLAG_RIGHT) {
QPoint temp[3] = {
QPoint(x_off + dw - basic_size, y_off + (basic_size / 4)),
QPoint(x_off + dw, y_off + basic_size),
QPoint(x_off + dw - basic_size, y_off + (basic_size * 2) - (basic_size / 4) - 1)
};
paint.drawPolygon(temp, 3);
}
tabs[n].area = QRect(x_off + (basic_size / 2), y_off + (basic_size / 4),
dw - basic_size, (basic_size * 2) - (basic_size / 2));
if (isVisible(tabs[n].w)) {
QRect area(x_off + basic_size, y_off + (basic_size / 4),
dw - (2*basic_size), (basic_size * 2) - (basic_size / 2));
paint.setPen(QPen(white, 0));
paint.setBrush(white);
paint.drawRect(area);
}
paint.setPen(QPen(black, 0));
paint.setBrush(black);
paint.drawText(QRect(x_off + basic_size + (basic_size / 4),
y_off + (basic_size / 2),
dw - (2 * basic_size) - (basic_size / 2), basic_size),
Qt::TextSingleLine | Qt::AlignCenter, tabs[n].name);
x_off += dw;
}
if (x_off != 0) {
x_off = 0;
r++;
}
for (n = 0; n != nwidgets; n++) {
int dw = (widgets[n].pWidget ? 4 : 3) * basic_size;
if (x_off != 0 && x_off + dw >= w) {
x_off = 0;
r++;
}
y_off = r * basic_size * 2;
x_off += dw;
if (widgets[n].pWidget == 0)
continue;
widgets[n].area = QRect(x_off - dw, y_off,
4 * basic_size, 2 * basic_size);
widgets[n].pWidget->setGeometry(widgets[n].area);
QWidget::eventFilter(widgets[n].pWidget, event);
}
y_off = (r + 1) * basic_size * 2;
}
void FileEditorWnd::setCommonStyle()
{
m_textCtrl->SetMarginWidth(MARGIN_LINE_NUMBERS, 50);
m_textCtrl->SetMarginType(MARGIN_LINE_NUMBERS, wxSTC_MARGIN_NUMBER);
m_textCtrl->SetMarginWidth(MARGIN_BREAKPOINTS, 16);
m_textCtrl->SetMarginType(MARGIN_BREAKPOINTS, wxSTC_MARGIN_SYMBOL);
m_textCtrl->SetMarginSensitive(MARGIN_BREAKPOINTS, true);
m_textCtrl->SetWrapMode(wxSTC_WRAP_NONE);
m_textCtrl->MarkerDefineBitmap(MARK_BREAKPOINT_ON, wxImage(breakpoint_on_xpm));
m_textCtrl->MarkerDefineBitmap(MARK_BREAKPOINT_OFF, wxImage(breakpoint_off_xpm));
m_textCtrl->MarkerDefineBitmap(MARK_BREAKPOINT_INVALID, wxImage(breakpoint_invalid_xpm));
m_textCtrl->MarkerDefineBitmap(MARK_DEBUGCURSOR, wxImage(debugcursor_xpm));
// ---- Enable code folding
m_textCtrl->SetMarginWidth(MARGIN_FOLD, 15);
m_textCtrl->SetMarginType(MARGIN_FOLD, wxSTC_MARGIN_SYMBOL);
m_textCtrl->SetMarginMask(MARGIN_FOLD, wxSTC_MASK_FOLDERS);
m_textCtrl->SetMarginSensitive(MARGIN_FOLD, true);
m_textCtrl->SetFoldMarginColour(true, wxColour(220, 220, 220));
m_textCtrl->SetFoldMarginHiColour(true, clDefaultBkg);
//wxColour foldMarginColour(clDefaultBkg);
//m_textCtrl->StyleSetBackground(MARGIN_FOLD, foldMarginColour);
// Properties found from http://www.scintilla.org/SciTEDoc.html
m_textCtrl->SetProperty(wxT("fold"), wxT("1"));
m_textCtrl->SetProperty(wxT("fold.comment"), wxT("1"));
m_textCtrl->SetProperty(wxT("fold.compact"), wxT("1"));
m_textCtrl->SetProperty(wxT("fold.preprocessor"), wxT("1"));
// Disable automatic detection of inactive code due to #if #else #endif,
// since lots of defines will be outside the file
m_textCtrl->SetProperty("lexer.cpp.track.preprocessor", "0");
wxColour grey(100, 100, 100);
wxColour fcolour(240, 240, 240);
m_textCtrl->MarkerDefine(wxSTC_MARKNUM_FOLDER, wxSTC_MARK_BOXPLUS);
m_textCtrl->MarkerSetForeground(wxSTC_MARKNUM_FOLDER, fcolour);
m_textCtrl->MarkerSetBackground(wxSTC_MARKNUM_FOLDER, grey);
m_textCtrl->MarkerDefine(wxSTC_MARKNUM_FOLDEROPEN, wxSTC_MARK_BOXMINUS);
m_textCtrl->MarkerSetForeground(wxSTC_MARKNUM_FOLDEROPEN, fcolour);
m_textCtrl->MarkerSetBackground(wxSTC_MARKNUM_FOLDEROPEN, grey);
m_textCtrl->MarkerDefine(wxSTC_MARKNUM_FOLDERSUB, wxSTC_MARK_VLINE);
m_textCtrl->MarkerSetForeground(wxSTC_MARKNUM_FOLDERSUB, grey);
m_textCtrl->MarkerSetBackground(wxSTC_MARKNUM_FOLDERSUB, grey);
m_textCtrl->MarkerDefine(wxSTC_MARKNUM_FOLDEREND, wxSTC_MARK_BOXPLUSCONNECTED);
m_textCtrl->MarkerSetForeground(wxSTC_MARKNUM_FOLDEREND, fcolour);
m_textCtrl->MarkerSetBackground(wxSTC_MARKNUM_FOLDEREND, grey);
m_textCtrl->MarkerDefine(wxSTC_MARKNUM_FOLDEROPENMID, wxSTC_MARK_BOXMINUSCONNECTED);
m_textCtrl->MarkerSetForeground(wxSTC_MARKNUM_FOLDEROPENMID, fcolour);
m_textCtrl->MarkerSetBackground(wxSTC_MARKNUM_FOLDEROPENMID, grey);
m_textCtrl->MarkerDefine(wxSTC_MARKNUM_FOLDERMIDTAIL, wxSTC_MARK_TCORNER);
m_textCtrl->MarkerSetForeground(wxSTC_MARKNUM_FOLDERMIDTAIL, grey);
m_textCtrl->MarkerSetBackground(wxSTC_MARKNUM_FOLDERMIDTAIL, grey);
m_textCtrl->MarkerDefine(wxSTC_MARKNUM_FOLDERTAIL, wxSTC_MARK_LCORNER);
m_textCtrl->MarkerSetForeground(wxSTC_MARKNUM_FOLDERTAIL, grey);
m_textCtrl->MarkerSetBackground(wxSTC_MARKNUM_FOLDERTAIL, grey);
// ---- End of code folding part
// Indentation settings
auto tabWidth = m_textCtrl->GetTabWidth();
m_textCtrl->SetUseTabs(true);
m_textCtrl->SetIndent(4);
m_textCtrl->SetTabWidth(4);
m_textCtrl->SetTabIndents(true);
m_textCtrl->SetBackSpaceUnIndents(true);
m_textCtrl->SetWhitespaceForeground(true, gWhiteSpaceColour);
// Set indicator styles
for (int i = 0; i < (int)gIndicatorStyles.size(); i++)
{
m_textCtrl->IndicatorSetStyle(i, gIndicatorStyles[i].style);
m_textCtrl->IndicatorSetForeground(i, gIndicatorStyles[i].colour);
m_textCtrl->IndicatorSetAlpha(i, gIndicatorStyles[i].alpha);
}
m_textCtrl->SetCaretLineBackground(clCurrentLineBkg);
m_textCtrl->SetCaretLineVisible(true);
}
void
World::build(void) {
int num_samples = 1;
// view plane
vp.set_hres(400);
vp.set_vres(400);
vp.set_pixel_size(0.5);
vp.set_samples(num_samples);
// the ambient light here is the same as the default set in the World
// constructor, and can therefore be left out
Ambient* ambient_ptr = new Ambient;
ambient_ptr->scale_radiance(1.0);
set_ambient_light(ambient_ptr);
background_color = black; // default color - this can be left out
tracer_ptr = new RayCast(this);
// camera
Pinhole* pinhole_ptr = new Pinhole;
pinhole_ptr->set_eye(0, 0, 500);
pinhole_ptr->set_lookat(0.0);
pinhole_ptr->set_view_distance(600.0);
pinhole_ptr->compute_uvw();
set_camera(pinhole_ptr);
// light
Directional* light_ptr1 = new Directional;
light_ptr1->set_direction(100, 100, 200);
light_ptr1->scale_radiance(3.0);
add_light(light_ptr1);
// colors
RGBColor yellow(1, 1, 0); // yellow
RGBColor brown(0.71, 0.40, 0.16); // brown
RGBColor darkGreen(0.0, 0.41, 0.41); // darkGreen
RGBColor orange(1, 0.75, 0); // orange
RGBColor green(0, 0.6, 0.3); // green
RGBColor lightGreen(0.65, 1, 0.30); // light green
RGBColor darkYellow(0.61, 0.61, 0); // dark yellow
RGBColor lightPurple(0.65, 0.3, 1); // light purple
RGBColor darkPurple(0.5, 0, 1); // dark purple
RGBColor grey(0.25); // grey
// Matte material reflection coefficients - common to all materials
float ka = 0.25;
float kd = 0.75;
// spheres
Matte* matte_ptr1 = new Matte;
matte_ptr1->set_ka(ka);
matte_ptr1->set_kd(kd);
matte_ptr1->set_cd(yellow);
Sphere* sphere_ptr1 = new Sphere(Point3D(5, 3, 0), 30);
sphere_ptr1->set_material(matte_ptr1); // yellow
add_object(sphere_ptr1);
Matte* matte_ptr2 = new Matte;
matte_ptr2->set_ka(ka);
matte_ptr2->set_kd(kd);
matte_ptr2->set_cd(brown);
Sphere* sphere_ptr2 = new Sphere(Point3D(45, -7, -60), 20);
sphere_ptr2->set_material(matte_ptr2); // brown
add_object(sphere_ptr2);
Matte* matte_ptr3 = new Matte;
matte_ptr3->set_ka(ka);
matte_ptr3->set_kd(kd);
matte_ptr3->set_cd(darkGreen);
Sphere* sphere_ptr3 = new Sphere(Point3D(40, 43, -100), 17);
sphere_ptr3->set_material(matte_ptr3); // dark green
add_object(sphere_ptr3);
Matte* matte_ptr4 = new Matte;
matte_ptr4->set_ka(ka);
matte_ptr4->set_kd(kd);
matte_ptr4->set_cd(orange);
Sphere* sphere_ptr4 = new Sphere(Point3D(-20, 28, -15), 20);
sphere_ptr4->set_material(matte_ptr4); // orange
add_object(sphere_ptr4);
Matte* matte_ptr5 = new Matte;
matte_ptr5->set_ka(ka);
matte_ptr5->set_kd(kd);
matte_ptr5->set_cd(green);
Sphere* sphere_ptr5 = new Sphere(Point3D(-25, -7, -35), 27);
sphere_ptr5->set_material(matte_ptr5); // green
add_object(sphere_ptr5);
Matte* matte_ptr6 = new Matte;
matte_ptr6->set_ka(ka);
matte_ptr6->set_kd(kd);
matte_ptr6->set_cd(lightGreen);
Sphere* sphere_ptr6 = new Sphere(Point3D(20, -27, -35), 25);
sphere_ptr6->set_material(matte_ptr6); // light green
add_object(sphere_ptr6);
Matte* matte_ptr7 = new Matte;
matte_ptr7->set_ka(ka);
matte_ptr7->set_kd(kd);
matte_ptr7->set_cd(green);
Sphere* sphere_ptr7 = new Sphere(Point3D(35, 18, -35), 22);
sphere_ptr7->set_material(matte_ptr7); // green
add_object(sphere_ptr7);
Matte* matte_ptr8 = new Matte;
matte_ptr8->set_ka(ka);
matte_ptr8->set_kd(kd);
matte_ptr8->set_cd(brown);
Sphere* sphere_ptr8 = new Sphere(Point3D(-57, -17, -50), 15);
sphere_ptr8->set_material(matte_ptr8); // brown
add_object(sphere_ptr8);
Matte* matte_ptr9 = new Matte;
matte_ptr9->set_ka(ka);
matte_ptr9->set_kd(kd);
matte_ptr9->set_cd(lightGreen);
Sphere* sphere_ptr9 = new Sphere(Point3D(-47, 16, -80), 23);
sphere_ptr9->set_material(matte_ptr9); // light green
add_object(sphere_ptr9);
Matte* matte_ptr10 = new Matte;
matte_ptr10->set_ka(ka);
matte_ptr10->set_kd(kd);
matte_ptr10->set_cd(darkGreen);
Sphere* sphere_ptr10 = new Sphere(Point3D(-15, -32, -60), 22);
sphere_ptr10->set_material(matte_ptr10); // dark green
add_object(sphere_ptr10);
Matte* matte_ptr11 = new Matte;
matte_ptr11->set_ka(ka);
matte_ptr11->set_kd(kd);
matte_ptr11->set_cd(darkYellow);
Sphere* sphere_ptr11 = new Sphere(Point3D(-35, -37, -80), 22);
sphere_ptr11->set_material(matte_ptr11); // dark yellow
add_object(sphere_ptr11);
Matte* matte_ptr12 = new Matte;
matte_ptr12->set_ka(ka);
matte_ptr12->set_kd(kd);
matte_ptr12->set_cd(darkYellow);
Sphere* sphere_ptr12 = new Sphere(Point3D(10, 43, -80), 22);
sphere_ptr12->set_material(matte_ptr12); // dark yellow
add_object(sphere_ptr12);
Matte* matte_ptr13 = new Matte;
matte_ptr13->set_ka(ka);
matte_ptr13->set_kd(kd);
matte_ptr13->set_cd(darkYellow);
Sphere* sphere_ptr13 = new Sphere(Point3D(30, -7, -80), 10);
sphere_ptr13->set_material(matte_ptr13);
add_object(sphere_ptr13); // dark yellow (hidden)
Matte* matte_ptr14 = new Matte;
matte_ptr14->set_ka(ka);
matte_ptr14->set_kd(kd);
matte_ptr14->set_cd(darkGreen);
Sphere* sphere_ptr14 = new Sphere(Point3D(-40, 48, -110), 18);
sphere_ptr14->set_material(matte_ptr14); // dark green
add_object(sphere_ptr14);
Matte* matte_ptr15 = new Matte;
matte_ptr15->set_ka(ka);
matte_ptr15->set_kd(kd);
matte_ptr15->set_cd(brown);
Sphere* sphere_ptr15 = new Sphere(Point3D(-10, 53, -120), 18);
sphere_ptr15->set_material(matte_ptr15); // brown
add_object(sphere_ptr15);
Matte* matte_ptr16 = new Matte;
matte_ptr16->set_ka(ka);
matte_ptr16->set_kd(kd);
matte_ptr16->set_cd(lightPurple);
Sphere* sphere_ptr16 = new Sphere(Point3D(-55, -52, -100), 10);
sphere_ptr16->set_material(matte_ptr16); // light purple
add_object(sphere_ptr16);
Matte* matte_ptr17 = new Matte;
matte_ptr17->set_ka(ka);
matte_ptr17->set_kd(kd);
matte_ptr17->set_cd(brown);
Sphere* sphere_ptr17 = new Sphere(Point3D(5, -52, -100), 15);
sphere_ptr17->set_material(matte_ptr17); // browm
add_object(sphere_ptr17);
Matte* matte_ptr18 = new Matte;
matte_ptr18->set_ka(ka);
matte_ptr18->set_kd(kd);
matte_ptr18->set_cd(darkPurple);
Sphere* sphere_ptr18 = new Sphere(Point3D(-20, -57, -120), 15);
sphere_ptr18->set_material(matte_ptr18); // dark purple
add_object(sphere_ptr18);
Matte* matte_ptr19 = new Matte;
matte_ptr19->set_ka(ka);
matte_ptr19->set_kd(kd);
matte_ptr19->set_cd(darkGreen);
Sphere* sphere_ptr19 = new Sphere(Point3D(55, -27, -100), 17);
sphere_ptr19->set_material(matte_ptr19); // dark green
add_object(sphere_ptr19);
Matte* matte_ptr20 = new Matte;
matte_ptr20->set_ka(ka);
matte_ptr20->set_kd(kd);
matte_ptr20->set_cd(brown);
Sphere* sphere_ptr20 = new Sphere(Point3D(50, -47, -120), 15);
sphere_ptr20->set_material(matte_ptr20); // browm
add_object(sphere_ptr20);
Matte* matte_ptr21 = new Matte;
matte_ptr21->set_ka(ka);
matte_ptr21->set_kd(kd);
matte_ptr21->set_cd(lightPurple);
Sphere* sphere_ptr21 = new Sphere(Point3D(70, -42, -150), 10);
sphere_ptr21->set_material(matte_ptr21); // light purple
add_object(sphere_ptr21);
Matte* matte_ptr22 = new Matte;
matte_ptr22->set_ka(ka);
matte_ptr22->set_kd(kd);
matte_ptr22->set_cd(lightPurple);
Sphere* sphere_ptr22 = new Sphere(Point3D(5, 73, -130), 12);
sphere_ptr22->set_material(matte_ptr22); // light purple
add_object(sphere_ptr22);
Matte* matte_ptr23 = new Matte;
matte_ptr23->set_ka(ka);
matte_ptr23->set_kd(kd);
matte_ptr23->set_cd(darkPurple);
Sphere* sphere_ptr23 = new Sphere(Point3D(66, 21, -130), 13);
sphere_ptr23->set_material(matte_ptr23); // dark purple
add_object(sphere_ptr23);
Matte* matte_ptr24 = new Matte;
matte_ptr24->set_ka(ka);
matte_ptr24->set_kd(kd);
matte_ptr24->set_cd(lightPurple);
Sphere* sphere_ptr24 = new Sphere(Point3D(72, -12, -140), 12);
sphere_ptr24->set_material(matte_ptr24); // light purple
add_object(sphere_ptr24);
Matte* matte_ptr25 = new Matte;
matte_ptr25->set_ka(ka);
matte_ptr25->set_kd(kd);
matte_ptr25->set_cd(green);
Sphere* sphere_ptr25 = new Sphere(Point3D(64, 5, -160), 11);
sphere_ptr25->set_material(matte_ptr25); // green
add_object(sphere_ptr25);
Matte* matte_ptr26 = new Matte;
matte_ptr26->set_ka(ka);
matte_ptr26->set_kd(kd);
matte_ptr26->set_cd(lightPurple);
Sphere* sphere_ptr26 = new Sphere(Point3D(55, 38, -160), 12);
sphere_ptr26->set_material(matte_ptr26); // light purple
add_object(sphere_ptr26);
Matte* matte_ptr27 = new Matte;
matte_ptr27->set_ka(ka);
matte_ptr27->set_kd(kd);
matte_ptr27->set_cd(lightPurple);
Sphere* sphere_ptr27 = new Sphere(Point3D(-73, -2, -160), 12);
sphere_ptr27->set_material(matte_ptr27); // light purple
add_object(sphere_ptr27);
Matte* matte_ptr28 = new Matte;
matte_ptr28->set_ka(ka);
matte_ptr28->set_kd(kd);
matte_ptr28->set_cd(darkPurple);
Sphere* sphere_ptr28 = new Sphere(Point3D(30, -62, -140), 15);
sphere_ptr28->set_material(matte_ptr28); // dark purple
add_object(sphere_ptr28);
Matte* matte_ptr29 = new Matte;
matte_ptr29->set_ka(ka);
matte_ptr29->set_kd(kd);
matte_ptr29->set_cd(darkPurple);
Sphere* sphere_ptr29 = new Sphere(Point3D(25, 63, -140), 15);
sphere_ptr29->set_material(matte_ptr29); // dark purple
add_object(sphere_ptr29);
Matte* matte_ptr30 = new Matte;
matte_ptr30->set_ka(ka);
matte_ptr30->set_kd(kd);
matte_ptr30->set_cd(darkPurple);
Sphere* sphere_ptr30 = new Sphere(Point3D(-60, 46, -140), 15);
sphere_ptr30->set_material(matte_ptr30); // dark purple
add_object(sphere_ptr30);
Matte* matte_ptr31 = new Matte;
matte_ptr31->set_ka(ka);
matte_ptr31->set_kd(kd);
matte_ptr31->set_cd(lightPurple);
Sphere* sphere_ptr31 = new Sphere(Point3D(-30, 68, -130), 12);
sphere_ptr31->set_material(matte_ptr31); // light purple
add_object(sphere_ptr31);
Matte* matte_ptr32 = new Matte;
matte_ptr32->set_ka(ka);
matte_ptr32->set_kd(kd);
matte_ptr32->set_cd(green);
Sphere* sphere_ptr32 = new Sphere(Point3D(58, 56, -180), 11);
sphere_ptr32->set_material(matte_ptr32); // green
add_object(sphere_ptr32);
Matte* matte_ptr33 = new Matte;
matte_ptr33->set_ka(ka);
matte_ptr33->set_kd(kd);
matte_ptr33->set_cd(green);
Sphere* sphere_ptr33 = new Sphere(Point3D(-63, -39, -180), 11);
sphere_ptr33->set_material(matte_ptr33); // green
add_object(sphere_ptr33);
Matte* matte_ptr34 = new Matte;
matte_ptr34->set_ka(ka);
matte_ptr34->set_kd(kd);
matte_ptr34->set_cd(lightPurple);
Sphere* sphere_ptr34 = new Sphere(Point3D(46, 68, -200), 10);
sphere_ptr34->set_material(matte_ptr34); // light purple
add_object(sphere_ptr34);
Matte* matte_ptr35 = new Matte;
matte_ptr35->set_ka(ka);
matte_ptr35->set_kd(kd);
matte_ptr35->set_cd(lightPurple);
Sphere* sphere_ptr35 = new Sphere(Point3D(-3, -72, -130), 12);
sphere_ptr35->set_material(matte_ptr35); // light purple
add_object(sphere_ptr35);
// vertical plane
Matte* matte_ptr36 = new Matte;
matte_ptr36->set_ka(ka);
matte_ptr36->set_kd(kd);
matte_ptr36->set_cd(grey);
Plane* plane_ptr = new Plane(Point3D(0, 0, -150), Normal(0, 0, 1));
plane_ptr->set_material(matte_ptr36);
add_object (plane_ptr);
}
//------------------------------------------------------------------------
void CWaveDisplay::draw(CDrawContext* pContext)
{
CPoint offset(38, 16);
CRect R(0, 0, getViewSize().getWidth(), getViewSize().getHeight());
back->draw(pContext, R.offset(offset), offset);
R(615 - getViewSize().left, 240 - getViewSize().top, 615 + heads->getWidth() - getViewSize().left, 240 + heads->getHeight() / 4 - getViewSize().top);
heads->draw(pContext, R.offset(offset), CPoint(0, (display * heads->getHeight()) / 4));
pContext->setDrawMode(CDrawMode(kAntiAliasing));
// trig-line
long triggerType = (long)(effect->getParameter(CSmartelectronixDisplay::kTriggerType) * CSmartelectronixDisplay::kNumTriggerTypes + 0.0001);
if (triggerType == CSmartelectronixDisplay::kTriggerRising || triggerType == CSmartelectronixDisplay::kTriggerFalling) {
long y = 1 + (long)((1.f - effect->getParameter(CSmartelectronixDisplay::kTriggerLevel)) * (getViewSize().getHeight() - 2));
CColor grey(229, 229, 229);
pContext->setFrameColor(grey);
pContext->drawLine(CPoint(0, y).offset(offset), CPoint(getViewSize().getWidth() - 1, y).offset(offset));
}
// zero-line
CColor orange(179, 111, 56);
pContext->setFrameColor(orange);
pContext->drawLine(CPoint(0, getViewSize().getHeight() * 0.5 - 1).offset(offset), CPoint(getViewSize().getWidth() - 1, getViewSize().getHeight() * 0.5 - 1).offset(offset));
// waveform
const std::vector<CPoint>& points = (effect->getParameter(CSmartelectronixDisplay::kSyncDraw) > 0.5f) ? effect->getCopy() : effect->getPeaks();
double counterSpeedInverse = pow(10.f, effect->getParameter(CSmartelectronixDisplay::kTimeWindow) * 5.f - 1.5);
if (counterSpeedInverse < 1.0) //draw interpolated lines!
{
CColor blue(64, 148, 172);
pContext->setFrameColor(blue);
double phase = counterSpeedInverse;
double dphase = counterSpeedInverse;
double prevxi = points[0].x;
double prevyi = points[0].y;
for (long i = 1; i < getViewSize().getWidth() - 1; i++) {
long index = (long)phase;
double alpha = phase - (double)index;
double xi = i;
double yi = (1.0 - alpha) * points[index * 2].y + alpha * points[(index + 1) * 2].y;
pContext->drawLine(CPoint(prevxi, prevyi).offset(offset), CPoint(xi, yi).offset(offset));
prevxi = xi;
prevyi = yi;
phase += dphase;
}
} else {
CColor grey(118, 118, 118);
pContext->setFrameColor(grey);
CPoint p1, p2;
for (unsigned int i=0; i<points.size()-1; i++)
{
p1 = points[i];
p2 = points[i+1];
pContext->drawLine(p1.offset(offset), p2.offset(offset));
}
}
//TODO clean this mess up...
if (where.x != -1) {
CPoint whereOffset = where;
whereOffset.offsetInverse(offset);
pContext->drawLine(CPoint(0, whereOffset.y).offset(offset), CPoint(getViewSize().getWidth() - 1, whereOffset.y).offset(offset));
pContext->drawLine(CPoint(whereOffset.x, 0).offset(offset), CPoint(whereOffset.x, getViewSize().getHeight() - 1).offset(offset));
float gain = powf(10.f, effect->getParameter(CSmartelectronixDisplay::kAmpWindow) * 6.f - 3.f);
float y = (-2.f * ((float)whereOffset.y + 1.f) / (float)OSC_HEIGHT + 1.f) / gain;
float x = (float)whereOffset.x * (float)counterSpeedInverse;
char text[256];
long lineSize = 10;
CColor color(179, 111, 56);
pContext->setFontColor(color);
pContext->setFont(kNormalFontSmaller);
readout->draw(pContext, CRect(508, 8, 508 + readout->getWidth(), 8 + readout->getHeight()).offset(offset), CPoint(0, 0));
CRect textRect(512, 10, 652, 10 + lineSize);
textRect.offset(offset);
sprintf(text, "y = %.5f", y);
pContext->drawString(text, textRect, kLeftText, true);
textRect.offset(0, lineSize);
sprintf(text, "y = %.5f dB", cf_lin2db(fabsf(y)));
pContext->drawString(text, textRect, kLeftText, true);
textRect.offset(0, lineSize * 2);
sprintf(text, "x = %.2f samples", x);
pContext->drawString(text, textRect, kLeftText, true);
textRect.offset(0, lineSize);
sprintf(text, "x = %.5f seconds", x / effect->getSampleRate());
pContext->drawString(text, textRect, kLeftText, true);
textRect.offset(0, lineSize);
sprintf(text, "x = %.5f ms", 1000.f * x / effect->getSampleRate());
pContext->drawString(text, textRect, kLeftText, true);
textRect.offset(0, lineSize);
if (x == 0)
sprintf(text, "x = infinite Hz");
else
sprintf(text, "x = %.3f Hz", effect->getSampleRate() / x);
pContext->drawString(text, textRect, kLeftText, true);
}
}
void GUIFCCharacterItem::draw()
{
if ( !IsVisible )
return;
SColor grey(255, 128, 128, 128);
SColor white(255, 255, 255, 255);
SColor charInset(255, 0, 64, 128);
SColor blue(255, 64, 128, 255);
core::rect<s32> rect = AbsoluteRect;
wstringstream s;
// draw the outline and background
m_pDriver->draw2DRectangle( rect, grey, grey, grey, grey);
rect.LowerRightCorner.X -= 2;
rect.LowerRightCorner.Y -= 2;
rect.UpperLeftCorner.X += 2;
rect.UpperLeftCorner.Y += 2;
if ( !m_bHighlight )
m_pDriver->draw2DRectangle( rect, white, white, white, white);
else
m_pDriver->draw2DRectangle( rect, white, white, blue, blue);
// draw the 'character image' inset
rect.UpperLeftCorner.X += 7;
rect.UpperLeftCorner.Y += 7;
rect.LowerRightCorner.Y -= 7;
rect.LowerRightCorner.X = rect.UpperLeftCorner.X + rect.getHeight();
m_pDriver->draw2DRectangle( rect, charInset, charInset, charInset, charInset );
// update rectangle for lines of text
rect.UpperLeftCorner.X = rect.LowerRightCorner.X + 10;
rect.LowerRightCorner.X = AbsoluteRect.LowerRightCorner.X - 10;
// create the character details string and textobject
IGUIFont* pFont = Environment->getSkin()->getFont();
if ( !pFont )
pFont = Environment->getBuiltInFont();
wstring str = m_pCharacter->GetName();
core::dimension2d<s32> extents = pFont->getDimension( str.c_str() );
rect.LowerRightCorner.Y = rect.UpperLeftCorner.Y + extents.Height;
pFont->draw( str.c_str(), rect, SColor(255, 0, 0, 0) );
rect.UpperLeftCorner.Y = rect.LowerRightCorner.Y;
rect.LowerRightCorner.Y += extents.Height;
s << L"Level: " << m_pCharacter->GetLevel();
str = s.str();
pFont->draw( str.c_str(), rect, SColor(255, 0, 0, 0) );
rect.UpperLeftCorner.Y = rect.LowerRightCorner.Y;
rect.LowerRightCorner.Y += extents.Height;
s.str(L"");
s << L"XP: " << m_pCharacter->GetXP();
str = s.str();
pFont->draw( str.c_str(), rect, SColor(255, 0, 0, 0) );
IGUIElement::draw();
}
void
GUIParkingArea::drawGL(const GUIVisualizationSettings& s) const {
glPushName(getGlID());
glPushMatrix();
RGBColor grey(177, 184, 186, 171);
RGBColor blue(83, 89, 172, 255);
RGBColor red(255, 0, 0, 255);
RGBColor green(0, 255, 0, 255);
// draw the area
glTranslated(0, 0, getType());
GLHelper::setColor(blue);
GLHelper::drawBoxLines(myShape, myShapeRotations, myShapeLengths, myWidth / 2.);
// draw details unless zoomed out to far
const SUMOReal exaggeration = s.addSize.getExaggeration(s);
if (s.scale * exaggeration >= 10) {
// draw the lots
glTranslated(0, 0, .1);
std::map<unsigned int, LotSpaceDefinition >::const_iterator i;
for (i = mySpaceOccupancies.begin(); i != mySpaceOccupancies.end(); i++) {
glPushMatrix();
glTranslated((*i).second.myPosition.x(), (*i).second.myPosition.y(), (*i).second.myPosition.z());
glRotated((*i).second.myRotation, 0, 0, 1);
Position pos = (*i).second.myPosition;
PositionVector geom;
SUMOReal w = (*i).second.myWidth / 2.;
SUMOReal h = (*i).second.myLength;
geom.push_back(Position(- w, + 0, 0.));
geom.push_back(Position(+ w, + 0, 0.));
geom.push_back(Position(+ w, + h, 0.));
geom.push_back(Position(- w, + h, 0.));
geom.push_back(Position(- w, + 0, 0.));
/*
geom.push_back(Position(pos.x(), pos.y(), pos.z()));
geom.push_back(Position(pos.x() + (*l).second.myWidth, pos.y(), pos.z()));
geom.push_back(Position(pos.x() + (*l).second.myWidth, pos.y() - (*l).second.myLength, pos.z()));
geom.push_back(Position(pos.x(), pos.y() - (*l).second.myLength, pos.z()));
geom.push_back(Position(pos.x(), pos.y(), pos.z()));
*/
GLHelper::setColor((*i).second.vehicle == 0 ? green : red);
GLHelper::drawBoxLines(geom, 0.1);
glPopMatrix();
}
GLHelper::setColor(blue);
// draw the lines
for (size_t i = 0; i != myLines.size(); ++i) {
glPushMatrix();
glTranslated(mySignPos.x(), mySignPos.y(), 0);
glRotated(180, 1, 0, 0);
glRotated(mySignRot, 0, 0, 1);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
pfSetPosition(0, 0);
pfSetScale(1.f);
glScaled(exaggeration, exaggeration, 1);
glTranslated(1.2, -(double)i, 0);
pfDrawString(myLines[i].c_str());
glPopMatrix();
}
// draw the sign
glTranslated(mySignPos.x(), mySignPos.y(), 0);
int noPoints = 9;
if (s.scale * exaggeration > 25) {
noPoints = MIN2((int)(9.0 + (s.scale * exaggeration) / 10.0), 36);
}
glScaled(exaggeration, exaggeration, 1);
GLHelper::drawFilledCircle((SUMOReal) 1.1, noPoints);
glTranslated(0, 0, .1);
GLHelper::setColor(grey);
GLHelper::drawFilledCircle((SUMOReal) 0.9, noPoints);
if (s.scale * exaggeration >= 4.5) {
GLHelper::drawText("P", Position(), .1, 1.6 * exaggeration, blue, mySignRot);
}
}
glPopMatrix();
glPopName();
drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
for (std::vector<MSTransportable*>::const_iterator i = myWaitingTransportables.begin(); i != myWaitingTransportables.end(); ++i) {
glTranslated(0, 1, 0); // make multiple containers viewable
static_cast<GUIContainer*>(*i)->drawGL(s);
}
}
void
GUIParkingArea::drawGL(const GUIVisualizationSettings& s) const {
glPushName(getGlID());
glPushMatrix();
RGBColor grey(177, 184, 186, 171);
RGBColor blue(83, 89, 172, 255);
RGBColor red(255, 0, 0, 255);
RGBColor green(0, 255, 0, 255);
// draw the area
glTranslated(0, 0, getType());
GLHelper::setColor(blue);
GLHelper::drawBoxLines(myShape, myShapeRotations, myShapeLengths, myWidth / 2.);
// draw details unless zoomed out to far
const double exaggeration = s.addSize.getExaggeration(s);
if (s.scale * exaggeration >= 1) {
// draw the lots
glTranslated(0, 0, .1);
std::map<unsigned int, LotSpaceDefinition >::const_iterator i;
for (i = mySpaceOccupancies.begin(); i != mySpaceOccupancies.end(); i++) {
glPushMatrix();
glTranslated((*i).second.myPosition.x(), (*i).second.myPosition.y(), (*i).second.myPosition.z());
glRotated((*i).second.myRotation, 0, 0, 1);
Position pos = (*i).second.myPosition;
PositionVector geom;
double w = (*i).second.myWidth / 2. - 0.1 * exaggeration;
double h = (*i).second.myLength;
geom.push_back(Position(- w, + 0, 0.));
geom.push_back(Position(+ w, + 0, 0.));
geom.push_back(Position(+ w, + h, 0.));
geom.push_back(Position(- w, + h, 0.));
geom.push_back(Position(- w, + 0, 0.));
/*
geom.push_back(Position(pos.x(), pos.y(), pos.z()));
geom.push_back(Position(pos.x() + (*l).second.myWidth, pos.y(), pos.z()));
geom.push_back(Position(pos.x() + (*l).second.myWidth, pos.y() - (*l).second.myLength, pos.z()));
geom.push_back(Position(pos.x(), pos.y() - (*l).second.myLength, pos.z()));
geom.push_back(Position(pos.x(), pos.y(), pos.z()));
*/
GLHelper::setColor((*i).second.vehicle == 0 ? green : red);
GLHelper::drawBoxLines(geom, 0.1 * exaggeration);
glPopMatrix();
}
GLHelper::setColor(blue);
// draw the lines
for (size_t i = 0; i != myLines.size(); ++i) {
// push a new matrix for every line
glPushMatrix();
// traslate and rotate
glTranslated(mySignPos.x(), mySignPos.y(), 0);
glRotated(180, 1, 0, 0);
glRotated(mySignRot, 0, 0, 1);
// draw line
GLHelper::drawText(myLines[i].c_str(), Position(1.2, (double)i), .1, 1.f, RGBColor(76, 170, 50), 0, FONS_ALIGN_LEFT);
// pop matrix for every line
glPopMatrix();
}
// draw the sign
glTranslated(mySignPos.x(), mySignPos.y(), 0);
int noPoints = 9;
if (s.scale * exaggeration > 25) {
noPoints = MIN2((int)(9.0 + (s.scale * exaggeration) / 10.0), 36);
}
glScaled(exaggeration, exaggeration, 1);
GLHelper::drawFilledCircle((double) 1.1, noPoints);
glTranslated(0, 0, .1);
GLHelper::setColor(grey);
GLHelper::drawFilledCircle((double) 0.9, noPoints);
if (s.scale * exaggeration >= 4.5) {
GLHelper::drawText("P", Position(), .1, 1.6, blue, mySignRot);
}
}
glPopMatrix();
if (s.addFullName.show && getMyName() != "") {
GLHelper::drawText(getMyName(), mySignPos, GLO_MAX - getType(), s.addFullName.scaledSize(s.scale), s.addFullName.color, s.getTextAngle(mySignRot));
}
glPopName();
drawName(getCenteringBoundary().getCenter(), s.scale, s.addName);
for (std::vector<MSTransportable*>::const_iterator i = myWaitingTransportables.begin(); i != myWaitingTransportables.end(); ++i) {
glTranslated(0, 1, 0); // make multiple containers viewable
static_cast<GUIContainer*>(*i)->drawGL(s);
}
// draw parking vehicles (their lane might not be within drawing range. if it is, they are drawn twice)
myLane.getVehiclesSecure();
for (std::set<const MSVehicle*>::const_iterator v = myLane.getParkingVehicles().begin(); v != myLane.getParkingVehicles().end(); ++v) {
static_cast<const GUIVehicle* const>(*v)->drawGL(s);
}
myLane.releaseVehicles();
}
void Astar::paintImage() {
int width = 15;
int height = 19;
int s = 19;
int r = s / 2;
int o = r + 1;
cv::Scalar white(255, 255, 255);
cv::Scalar grey(200, 200, 200);
cv::Scalar blue(200, 0, 0);
cv::Scalar purple(200, 0, 200);
cv::Scalar green(0, 200, 0);
cv::Scalar red(0, 0, 200);
cv::Scalar yellow(0, 255, 255);
cv::Mat img(s*width, s*height, CV_8UC3, white);
std::vector<Node> allNodes;
for (std::set<Node>::iterator it = closedList.begin(); it != closedList.end(); it++) {
allNodes.push_back(*it);
}
for (std::set<Node>::iterator it = openList.begin(); it != openList.end(); it++) {
allNodes.push_back(*it);
}
for (std::set<Node>::iterator it = obstacles.begin(); it != obstacles.end(); it++) {
allNodes.push_back(*it);
}
allNodes.push_back(this->goalNode);
allNodes.push_back(this->startingNode);
Node par;
for (std::vector<Node>::iterator it = allNodes.begin(); it != allNodes.end(); it++) {
Node cur = *it;
int x = cur.getX();
int y = cur.getY();
switch(cur.getPaint()) {
case OPEN: cv::circle(img, cv::Point(s*x+o, s*y+o), r, grey, -1);
break;
case CLOSED: cv::circle(img, cv::Point(s*x+o, s*y+o), r, purple, -1);
break;
case START: cv::circle(img, cv::Point(s*x+o, s*y+o), r, red, -1);
break;
case PATH: par = cur.getParent();
cv::circle(img, cv::Point(s*x+o, s*y+o), r/2, yellow, -1);
break;
case GOAL: cv::circle(img, cv::Point(s*x+o, s*y+o), r, blue, -1);
break;
case OBSTACLE: cv::circle(img, cv::Point(s*x+o, s*y+o), r, green, -1);
break;
}
}
for (std::vector<Node>::iterator it = path.begin(); it != path.end(); it++) {
Node cur = *it;
int x = cur.getX();
int y = cur.getY();
cv::circle(img, cv::Point(s*x+o, s*y+o), r/2, yellow, -1);
}
std::set<Node>::iterator it = std::min_element(obstacles.begin(), obstacles.end(), Node::CompareNode());
Node currentNode = *it;
std::stringstream title, filepath;
title << "i=" << (currentNode.getX()-3);
cv::namedWindow(title.str());
cv::imshow(title.str(), img);
filepath << "./img/" << "ue8_t2-" << ((currentNode.getX()-3)+2) << ".png";
cv::imwrite(filepath.str(), img);
cv::waitKey(0);
}
void FreeRegionGrabber::paintEvent( QPaintEvent* e )
{
Q_UNUSED( e );
if ( grabbing ) // grabWindow() should just get the background
return;
QPainter painter( this );
QPalette pal(QToolTip::palette());
QFont font = QToolTip::font();
QColor handleColor = pal.color( QPalette::Active, QPalette::Highlight );
handleColor.setAlpha( 160 );
QColor overlayColor( 0, 0, 0, 160 );
QColor textColor = pal.color( QPalette::Active, QPalette::Text );
QColor textBackgroundColor = pal.color( QPalette::Active, QPalette::Base );
painter.drawPixmap(0, 0, pixmap);
painter.setFont(font);
QPolygon pol = selection;
if ( !selection.boundingRect().isNull() )
{
// Draw outline around selection.
// Important: the 1px-wide outline is *also* part of the captured free-region because
// I found no way to draw the outline *around* the selection because I found no way
// to create a QPolygon which is smaller than the selection by 1px (QPolygon::translated
// is NOT equivalent to QRect::adjusted)
QPen pen(handleColor, 1, Qt::SolidLine, Qt::SquareCap, Qt::BevelJoin);
painter.setPen(pen);
painter.drawPolygon( pol );
// Draw the grey area around the selection
QRegion grey( rect() );
grey = grey - pol;
painter.setClipRegion( grey );
painter.setPen( Qt::NoPen );
painter.setBrush( overlayColor );
painter.drawRect( rect() );
painter.setClipRect( rect() );
drawPolygon( &painter, pol, handleColor);
}
if ( showHelp )
{
painter.setPen( textColor );
painter.setBrush( textBackgroundColor );
QString helpText = i18n( "Select a region using the mouse. To take the snapshot, press the Enter key or double click. Press Esc to quit." );
helpTextRect = painter.boundingRect( rect().adjusted( 2, 2, -2, -2 ), Qt::TextWordWrap, helpText );
helpTextRect.adjust( -2, -2, 4, 2 );
drawPolygon( &painter, helpTextRect, textColor, textBackgroundColor );
painter.drawText( helpTextRect.adjusted( 3, 3, -3, -3 ), helpText );
}
if ( selection.isEmpty() )
{
return;
}
// The grabbed region is everything which is covered by the drawn
// rectangles (border included). This means that there is no 0px
// selection, since a 0px wide rectangle will always be drawn as a line.
QString txt = QString( "%1x%2" ).arg( selection.boundingRect().width() )
.arg( selection.boundingRect().height() );
QRect textRect = painter.boundingRect( rect(), Qt::AlignLeft, txt );
QRect boundingRect = textRect.adjusted( -4, 0, 0, 0);
if ( textRect.width() < pol.boundingRect().width() - 2*handleSize &&
textRect.height() < pol.boundingRect().height() - 2*handleSize &&
( pol.boundingRect().width() > 100 && pol.boundingRect().height() > 100 ) ) // center, unsuitable for small selections
{
boundingRect.moveCenter( pol.boundingRect().center() );
textRect.moveCenter( pol.boundingRect().center() );
}
else if ( pol.boundingRect().y() - 3 > textRect.height() &&
pol.boundingRect().x() + textRect.width() < rect().right() ) // on top, left aligned
{
boundingRect.moveBottomLeft( QPoint( pol.boundingRect().x(), pol.boundingRect().y() - 3 ) );
textRect.moveBottomLeft( QPoint( pol.boundingRect().x() + 2, pol.boundingRect().y() - 3 ) );
}
else if ( pol.boundingRect().x() - 3 > textRect.width() ) // left, top aligned
{
boundingRect.moveTopRight( QPoint( pol.boundingRect().x() - 3, pol.boundingRect().y() ) );
textRect.moveTopRight( QPoint( pol.boundingRect().x() - 5, pol.boundingRect().y() ) );
}
else if ( pol.boundingRect().bottom() + 3 + textRect.height() < rect().bottom() &&
pol.boundingRect().right() > textRect.width() ) // at bottom, right aligned
{
boundingRect.moveTopRight( QPoint( pol.boundingRect().right(), pol.boundingRect().bottom() + 3 ) );
textRect.moveTopRight( QPoint( pol.boundingRect().right() - 2, pol.boundingRect().bottom() + 3 ) );
}
else if ( pol.boundingRect().right() + textRect.width() + 3 < rect().width() ) // right, bottom aligned
{
boundingRect.moveBottomLeft( QPoint( pol.boundingRect().right() + 3, pol.boundingRect().bottom() ) );
textRect.moveBottomLeft( QPoint( pol.boundingRect().right() + 5, pol.boundingRect().bottom() ) );
}
// if the above didn't catch it, you are running on a very tiny screen...
drawPolygon( &painter, boundingRect, textColor, textBackgroundColor );
painter.drawText( textRect, txt );
if ( ( pol.boundingRect().height() > handleSize*2 && pol.boundingRect().width() > handleSize*2 )
|| !mouseDown )
{
painter.setBrush(QBrush(Qt::transparent));
painter.setClipRegion( QRegion(pol));
painter.drawPolygon( rect() );
}
}
TAM::TAM(int numTones, int numRes, Image* stroke)
: images(numTones, std::vector<Image*>(numRes)) {
std::vector<Image> candidates(numRes);
for (int tone = 0; tone < numTones; ++tone) {
int imageSize = 1;
for (int resolution = 0; resolution < numRes; ++resolution) {
images[tone][resolution] = new Image(imageSize, imageSize);
static Pixel white = Pixel(1,1,1);
images[tone][resolution]->fillImage(white);
if (tone == 0) {
candidates[resolution] = Image(imageSize, imageSize);
}
imageSize *= 2;
}
}
double darkestTone =.9;
double lightestTone = .15;
double toneInterval;
if (numTones == 1) {
toneInterval = darkestTone - lightestTone;
} else {
toneInterval = (darkestTone - lightestTone) / (numTones - 1);
}
for (int toneLevel = 0; toneLevel < numTones; ++toneLevel) {
double maxTone = lightestTone + toneInterval * toneLevel;
while (fabs(maxTone - images[toneLevel][numRes-1]->getTone()) > (.1/(numRes-3))) {
RandomStroke bestStroke;
double bestTone = -10000;
for (int i = 0; i < 25; ++i) {
double toneSum = 0;
bool horizontalStroke = maxTone <= .7;
RandomStroke currentStroke = getRandomStroke(horizontalStroke);
for (int resolution = 3; resolution < numRes; ++resolution) {
if (fabs(maxTone - images[toneLevel][resolution]->getTone()) > (.1/(resolution-3+1.))) {
drawStroke(stroke, currentStroke, &candidates[resolution]);
// Get the effective length of the stroke, given that it might "run off" the edge
double withStroke = fabs(maxTone - candidates[resolution].getTone());
double withoutStroke = fabs(maxTone - images[toneLevel][resolution]->getTone());
if (withoutStroke < withStroke) {
continue;
}
double toneContribution = candidates[resolution].getTone() - images[toneLevel][resolution]->getTone();
// // All images are squares, side lengths are equal
// const double imageSize = images[toneLevel][resolution]->getWidth();
//
// double actualStrokeLength = currentStroke.length * stroke->getWidth();
// double normalizedStrokeLength;
// double actualStrokeX = currentStroke.x*imageSize;
// double actualStrokeY = currentStroke.y*imageSize;
// if(horizontalStroke){
// normalizedStrokeLength = getActualStrokeLength(actualStrokeX, actualStrokeLength, imageSize);
// }
// else {
// normalizedStrokeLength = getActualStrokeLength(actualStrokeY, actualStrokeLength, imageSize);
// }
toneContribution /= currentStroke.length;
toneSum += toneContribution;
candidates[resolution] = *images[toneLevel][resolution];
}
}
if (toneSum > bestTone) {
bestTone = toneSum;
bestStroke = currentStroke;
}
}
for (int candidate = 3; candidate < numRes; ++candidate) {
if (fabs(maxTone - images[toneLevel][candidate]->getTone()) > (.1/(candidate-3 + 1.))) {
drawStroke(stroke, bestStroke, images[toneLevel][candidate]);
candidates[candidate] = *images[toneLevel][candidate];
}
}
}
for (int resolution=0; resolution<3; resolution++){
float greyLevel = 1-maxTone;
Pixel grey(greyLevel, greyLevel, greyLevel);
images[toneLevel][resolution]->fillImage(grey);
}
if (toneLevel != numTones - 1) {
for (int resolution = 0; resolution < numRes; ++resolution) {
*images[toneLevel+1][resolution] = *images[toneLevel][resolution];
candidates[resolution] = *images[toneLevel][resolution];
}
}
}
}
