TEST_F(model_test, bucket_management_and_forgetting) {
static const size_t N = config_.bucket_size * 4;
static const size_t D = 2;
model_->push(get_points(N, D));
vector<weighted_point> coreset = model_->get_coreset();
ASSERT_EQ(
coreset.size(), static_cast<size_t>(config_.compressed_bucket_size));
model_->push(get_points(N, D));
coreset = model_->get_coreset();
ASSERT_EQ(
coreset.size(), static_cast<size_t>(config_.compressed_bucket_size));
}
Vector<Vector3> ConvexPolygonShape::_gen_debug_mesh_lines() {
DVector<Vector3> points = get_points();
if (points.size()>3) {
QuickHull qh;
Vector<Vector3> varr = Variant(points);
Geometry::MeshData md;
Error err = qh.build(varr,md);
if (err==OK) {
Vector<Vector3> lines;
lines.resize(md.edges.size()*2);
for(int i=0;i<md.edges.size();i++) {
lines[i*2+0]=md.vertices[md.edges[i].a];
lines[i*2+1]=md.vertices[md.edges[i].b];
}
return lines;
}
}
return Vector<Vector3>();
}
HTMLFont *
html_font_manager_get_font (HTMLFontManager *manager,
gchar *face_list,
GtkHTMLFontStyle style)
{
HTMLFontSet *set;
HTMLFont *font = NULL;
font = get_font (manager, &set, face_list, style);
if (!font) {
/* first try to alloc right one */
font = alloc_new_font (manager, &set, face_list, style);
if (!font) {
g_assert (set);
if (!face_list) {
/* default font, so the last chance is to get fixed font */
font = html_painter_alloc_font (manager->painter, NULL,
get_real_font_size (manager, style),
get_points (manager, style), style);
if (!font)
g_warning ("Cannot allocate fixed font\n");
} else {
/* some unavailable non-default font => use default one */
font = html_font_manager_get_font (manager, NULL, style);
html_font_ref (font, manager->painter);
}
if (font)
html_font_set_font (manager, set, style, font);
}
}
return font;
}
TEST_F(mixable_model_test, reduce) {
static const size_t N = 200;
static const size_t D = 2;
model_->push(get_points(N, D));
diff_t df;
storage_->get_diff(df);
diff_t df2;
storage_->mix(df, df2);
ASSERT_EQ(df2.size(), (size_t)1);
ASSERT_EQ(df2[0].first, name_);
ASSERT_EQ(df2[0].second.size(), N);
storage_->get_diff(df2);
storage_->mix(df, df2);
ASSERT_EQ(df2.size(), (size_t)1);
ASSERT_EQ(df2[0].first, name_);
ASSERT_EQ(df2[0].second.size(), 2*N);
storage_->get_diff(df2);
df2[0].first += "2";
storage_->mix(df, df2);
ASSERT_EQ(df2.size(), (size_t)2);
ASSERT_EQ(df2[0].first, name_);
ASSERT_EQ(df2[0].second.size(), N);
ASSERT_EQ(df2[1].first, name_+"2");
ASSERT_EQ(df2[1].second.size(), N);
}
static Uint8 move_enemy( ENEMY *e )
{
/* If the enemy is on the screen, then set their active flag. */
if( e->current->y +
e->current->surface[e->current->cur_frame]->h > 0 )
e->flags |= E_FLAG_ACTIVE; /* Set the active flag. */
/* Check if the enemy has left the bottom of the screen. */
if( e->current->y > (Sint32)screen_height() ) {
remove_enemy( e );
player_score -= get_points( e->type );
return 0;
}
/* If the enemy is not active then they only scroll down.
* once the enemy is active they follow their movement
* pattern. */
if( !IS_ACTIVE( e->flags ) )
e->current->y += ENEMY_SCROLL_SPEED;
else if( e->move_funct == NULL )
move_enemy_down( e );
else
e->move_funct( e );
return 1;
}
bool
AsciiProcessor::ins_polyline( const char * buf,
int fref,
BuilderBase * build,
const char * & next )
{
int id = 0, lay = 0, fil = 0;
RGBcolor col( 0, 0, 0 );
if ( ! get_obj_attr( buf, id, lay, col, fil, next ) )
{
return CMD_ERR;
}
int num = get_points( next, points, next );
if ( num < 2 )
{
return CMD_ERR;
}
build->set_cmd_insert_polyline( fref, id, points.cur_size, points.tab, lay, col );
return CMD_OK;
}
void gere_key2(int keycode, t_env *env)
{
if (keycode == 113)
COLOR += 0x010000;
if (keycode == 119)
COLOR += 0x000100;
if (keycode == 101)
COLOR += 0x01;
if (keycode == 97)
COLOR -= 0x00010000;
if (keycode == 115)
COLOR -= 0x00000100;
if (keycode == 100)
COLOR -= 0x00000001;
if (keycode == 65456)
{
COEFFZ = 1;
ANGLEX = 0;
ANGLEZ = 0;
CHOICE = 0;
COLOR = DEF_COLOR;
C = MIN(WIDTH / (MAX_X + 5), HEIGHT / (MAX_Y + 5));
C = C ? C : 1;
OFF = set_point(0, 0, 0);
get_points(env);
}
}
static void kill_enemy( ENEMY *e )
{
player_score += get_points( e->type );
new_explosion( e->current->x, e->current->y, BIG );
remove_enemy( e );
}
TEST_F(mixable_model_test, get_diff) {
static const size_t N = 200;
static const size_t D = 2;
model_->push(get_points(N, D));
diff_t df;
storage_->get_diff(df);
ASSERT_EQ(df.size(), (size_t)1);
ASSERT_EQ(df[0].first, name_);
ASSERT_EQ(df[0].second.size(), N);
}
TEST_F(model_gmm_test, push_small) {
static const size_t N = 99;
static const size_t D = 2;
model_->push(get_points(N, D));
vector<weighted_point> coreset = model_->get_coreset();
ASSERT_EQ(coreset.size(), N);
ASSERT_EQ(coreset.front().data.size(), D);
EXPECT_THROW(model_->get_k_center(), not_performed);
}
TEST_F(model_test, push_small) {
static const size_t N = 100;
static const size_t D = 2;
model_->push(get_points(N, D));
vector<weighted_point> coreset = model_->get_coreset();
ASSERT_EQ(coreset.size(), N);
ASSERT_EQ(coreset.front().data.size(), D);
vector<common::sfv_t> centers = model_->get_k_center();
ASSERT_EQ(centers.size(), 0ul);
}
simple_point ClosestPointQuery::operator()(const simple_point& queryPoint, const double maxDist, int brute_force) const
{
// find the intersection point of a line from the query point to the meshes bounding box
simple_point hit_point = get_bb_intersection(queryPoint);
std::cout << "\n";
std::cout << "query point x " << queryPoint.x << " y " << queryPoint.y << " z " << queryPoint.z << " intersects mesh at hit point x " << hit_point.x << " y " << hit_point.y << " z " << hit_point.z << "\n";
// search outwards from the intersection point up to maxDist for
std::vector<simple_point>* pts = nullptr;
if (brute_force)
{
// just for speed comparisons
pts = get_points_brute_force(hit_point, maxDist);
}
else
{
pts = get_points(hit_point, maxDist);
}
if (pts != nullptr)
std::cout << "searched " << pts->size() << " points\n";
else
return simple_point(-1.0, -1.0, -1.0);
// check resulting points to confirm which one is actually closest
simple_point best_point = simple_point(-1.0, -1.0, -1.0);
if (pts->size() > 0)
{
double min_dist = -1.0;
for (auto it = pts->begin(); it != pts->end(); ++it)
{
double dist = get_distance(queryPoint,*it);
if (min_dist == -1.0)
{
min_dist = dist;
best_point = *it;
}
else
{
if (dist < min_dist)
{
min_dist = dist;
best_point = *it;
}
}
}
}
return best_point;
}
void CUIFrameWindow::draw_tile_line(Frect rect, int i, bool b_horz, Fvector2 const& ts)
{
Fvector2 LTt, RBt;
Fvector2 LTp, RBp;
if(b_horz)
{
while(rect.lt.x+EPS_L<rect.rb.x)
{
get_points (rect, i, LTp, RBp, LTt, RBt);
rect.lt.x = RBp.x;
draw_rect (LTp, RBp, LTt, RBt, m_texture_color, ts);
}
}else
{
while(rect.lt.y+EPS_L<rect.rb.y)
{
get_points (rect, i, LTp, RBp, LTt, RBt);
rect.lt.y = RBp.y;
draw_rect (LTp, RBp, LTt, RBt, m_texture_color, ts);
}
}
}
void stock_coord(char *file_name, t_co *c)
{
int fd;
char *line;
int v;
v = 0;
line = NULL;
init_coord(file_name, c);
fd = open(file_name, O_RDONLY);
c->coord->vert = (t_point **)malloc(sizeof(t_point *) * c->coord->to_pts);
get_points(c, &fd, line, &v);
close(fd);
}
/* get user defined size */
BOOL
gsview_usersize()
{
TCHAR prompt[MAXSTR];
char answer[MAXSTR];
nHelpTopic = IDS_TOPICMEDIA;
load_string(IDS_USERWIDTH, prompt, sizeof(prompt)/sizeof(TCHAR)-1);
put_points(answer, sizeof(answer), (float)option.user_width);
if (!query_string(prompt,answer))
return FALSE;
option.user_width = (int)(get_points(answer) + 0.5);
load_string(IDS_USERHEIGHT, prompt, sizeof(prompt)/sizeof(TCHAR)-1);
put_points(answer, sizeof(answer), (float)option.user_height);
if (!query_string(prompt,answer))
return FALSE;
option.user_height = (int)(get_points(answer) + 0.5);
if ((option.user_width==0) || (option.user_height == 0)) {
option.user_width = 595;
option.user_width = 842;
}
gsview_check_usersize();
return TRUE;
}
void gere_key3(int keycode, t_env *env)
{
if (keycode == 65463)
ANGLEX -= 0.05;
if (keycode == 65465)
ANGLEX += 0.05;
if (keycode == 65459)
ANGLEZ -= 0.05;
if (keycode == 65457)
ANGLEZ += 0.05;
if (keycode == 65469 && CHOICE == 1)
{
CHOICE = 0;
OFF = set_point(0, 0, 0);
get_points(env);
}
if (keycode == 65455 && CHOICE == 0)
{
CHOICE = 1;
OFF = set_point(0, 0, 0);
get_points(env);
}
}
std::set<Attribute> Skybox::get_attributes(size_t const size)
{
std::set<std::tuple<GLenum, OpenGLValue>> values;
OpenGLValue points(GL_FLOAT, get_points(size));
OpenGLValue indices(GL_UNSIGNED_INT, get_indices(size));
values.emplace(GL_ARRAY_BUFFER, points);
values.emplace(GL_ELEMENT_ARRAY_BUFFER, indices);
std::set<Attribute> attribs;
attribs.emplace("vpoint", values);
return attribs;
}
TEST_F(mixable_model_test, put_diff) {
static const size_t N = 200;
static const size_t D = 2;
model_->push(get_points(N, D));
diff_t df, df2;
storage_->get_diff(df);
storage_->get_diff(df2);
df2[0].first = "name2";
storage_->mix(df, df2);
storage_->set_mixed_and_clear_diff(df2);
wplist coreset = model_->get_coreset();
ASSERT_EQ(coreset.size(), 2*N);
storage_->get_diff(df);
ASSERT_EQ(df.size(), (size_t)1);
ASSERT_EQ(df[0].second.size(), N);
}
/**
* USE: Provide sample points and how many to setup_hough() transformation and plot those points
* using plot_point() with each index of points you want to convert. The use print_classifier()
* or get_lines() to see the lines extracted.
*/
int main(int argc, char **argv) {
// Get points from image
SIZE_TYPE size;
POINT_TYPE *points = NULL;
sizep_t count = get_points("sample_small.bmp", &points, &size);
/*
* points : Array of points
* num_points : Number of points in the array
* threshold : Threshold to consider line intersection
* tolerance_t : Tolerance (in grades) to consider two lines are the same
* tolerance_r : Distance (in pixels) to consider two lines are the same
* precision : Precision for degrees (10 = decimals, 100 = cents...)
* size : Size of the image
* max_lines : Lines to look for (value -1 falls back to 500)
*/
clock_t cp = clock();
setup_hough(points, count, 12, 15.0, 5.0, 1, size, 10000);
// Plot every point and measure clock ticks
int n;
for (n=0; n<_num_points; n++) {
plot_point(n);
}
printf("_plot_point() ticks: %.4f\n", ((double)(clock()-cp))/1000000l);
print_accumulator("accumulator.bmp");
print_classifier();//*/
// Get lines from classifier
LINE_TYPE *lines;
sizep_t clines = get_lines(&lines);
// Print lines
print_lines("output.bmp", "sample.bmp", lines, clines, 10);
print_lines("output_small.bmp", "sample_small.bmp", lines, clines, 1);
// Free memory
finish_hough();
free(lines);
free(points);
printf("All clear!");
return EXIT_SUCCESS;
}
TEST_F(model_test, compression_and_clusteringing) {
static const size_t N = config_.bucket_size;
static const size_t D = 2;
std::cout << "total adding points : " << N << std::endl;
model_->push(get_points(N, D));
vector<weighted_point> coreset = model_->get_coreset();
ASSERT_EQ(
coreset.size(), static_cast<size_t>(config_.compressed_bucket_size));
vector<common::sfv_t> centers = model_->get_k_center();
ASSERT_EQ(centers.size(), static_cast<size_t>(config_.k));
vector<wplist> core_members = model_->get_core_members();
ASSERT_GT(core_members.size(), 0ul);
wplist nearest_members = model_->get_nearest_members(get_point(D).data);
ASSERT_GT(nearest_members.size(), 0ul);
common::sfv_t nearest_center = model_->get_nearest_center(get_point(D).data);
}
void gere_offset(int keycode, t_env *env)
{
if (keycode == 65464)
OFF.y -= 5;
if (keycode == 65458)
OFF.y += 5;
if (keycode == 65462)
OFF.x += 5;
if (keycode == 65460)
OFF.x -= 5;
if (keycode == 122)
COEFFZ++;
if (keycode == 120)
COEFFZ--;
if (keycode == 65463 || keycode == 65465 || keycode == 65459 ||
keycode == 65457)
{
OFF = set_point(0, 0, 0);
get_points(env);
}
}
static NV_INT32 get_lsurvey(FILE * infile, SURVEY * srv)
{
NV_CHAR buff[MBS];
NV_INT32 i = (-1), n = 0;
/* determine the id numbers of the lines & points */
rewind(infile);
n = 0;
while (fgets(buff, MBS, infile) != NULL)
{
strtolower(buff);
if (strncmp(buff, "line", 4) == 0)
{
n += get_ids(buff, &srv->line[++i]);
}
}
if (n != srv->n)
{
printf("get_survey: warning got %d (!= %d) line ids\n", n, srv->n);
}
/* now fill in the points for each line */
n = 0;
for (i = 0; i < srv->n; i++)
{
n += get_points(infile, &srv->line[i]);
}
if (n != srv->n)
{
printf("get_dsurvey: warning got %d (!= %d) lines\n", n, srv->n);
}
return n;
} /* get_lsurvey */
int gere_key(int keycode, t_env *env)
{
if (keycode == 65307)
{
kill_everything(env);
exit (1);
}
if (keycode == 65451)
C++;
if (keycode == 65453)
C = C > 1 ? C - 1 : 1;
if (keycode == 65461)
{
OFF = set_point(0, 0, 0);
get_points(env);
}
gere_key2(keycode, env);
gere_key3(keycode, env);
gere_offset(keycode, env);
draw(env);
return (0);
}
void raw_kill( CHAR_DATA *victim, int absolute )
{
int i = 0;
/*
if(victim->fighting != NULL)
{
if(victim->fighting->ooc_xp_count < 2) {
send_to_char("You learn from your encounter.\n\r",
victim->fighting);
victim->fighting->exp += 1;
}
stop_fighting( victim, TRUE );
}
*/
if(!absolute && victim->race == race_lookup("werewolf")
&& ((i = dice_rolls(victim, victim->max_RBPG, 8)) > 0
|| victim->agghealth > 0))
{
bool tag = FALSE;
if(victim->health < 0)
victim->health = 0;
if(victim->agghealth < 0) {
victim->agghealth = 0;
tag = TRUE;
}
if(absolute) tag = TRUE;
if(tag) {
i -= 7 - victim->health;
if(i > 0)
victim->agghealth +=
UMIN(7 - victim->agghealth, i);
}
else while((victim->agghealth + victim->health - 7) <= 0)
{
if(victim->health >= 7)
victim->agghealth++;
else victim->health++;
}
send_to_char("It hurts, but your body starts to heal.\n\r", victim);
update_pos(victim, 0);
if((victim->agghealth + victim->health - 7) > 0)
return;
}
if(victim->clan == clan_lookup("bone gnawer")
&& victim->disc[DISC_TRIBE] >= 5
&& victim->max_willpower > 0)
{
victim->max_willpower--;
if(victim->willpower > victim->max_willpower)
{
victim->willpower = victim->max_willpower;
}
if(victim->health <= 0)
victim->health = 1;
if(victim->agghealth <= 0)
victim->agghealth = 1;
while((victim->agghealth + victim->health - 7) <= 0)
{
if(victim->health >= 7)
victim->agghealth++;
else victim->health++;
}
send_to_char("It hurts, but you'll live.\n\r", victim);
return;
}
death_cry( victim );
make_corpse( victim );
if ( IS_NPC(victim) )
{
victim->pIndexData->killed++;
extract_char( victim, TRUE );
return;
}
clear_orgs(victim);
if(victim->desc)
victim->desc->connected = CON_DECEASED;
SET_BIT(victim->act, ACT_REINCARNATE);
char_from_room(victim);
char_from_list(victim);
send_to_char("You are DEAD!\n\r[Hit Return to Continue]\n\r", victim);
victim->exp = get_points(victim);
save_char_obj(victim);
return;
}
CubitStatus ChollaCurve::order_edges()
{
int i;
bool periodic = false;
if (NULL == startPoint)
{
DLIList<ChollaPoint *> cholla_points = get_points();
periodic = (cholla_points.size() == 1);
ChollaPoint *chpt = cholla_points.get();
CubitPoint *start_point = dynamic_cast<CubitPoint *> (chpt->get_facets());
this->set_start( start_point );
if (NULL == start_point)
return CUBIT_FAILURE;
start_point->set_as_feature();
if (periodic)
{
this->set_end(start_point);
}
else
{
chpt = cholla_points.step_and_get();
CubitPoint *end_point = dynamic_cast<CubitPoint *> (chpt->get_facets());
if (NULL == end_point)
return CUBIT_FAILURE;
this->set_end(end_point);
end_point->set_as_feature();
}
}
assert(startPoint);
assert(endPoint);
if (curveEdgeList.size() > 1)
{
DLIList<CubitFacetEdge*> edges_ordered;
CAST_LIST(curveEdgeList, edges_ordered, CubitFacetEdge);
CubitStatus stat = CubitFacetEdge::order_edge_list(edges_ordered, startPoint, endPoint);
if (CUBIT_FAILURE == stat)
return CUBIT_FAILURE;
// store the edges in the correct order
clean_out_edges();
edges_ordered.reset();
for (i=0; i< edges_ordered.size(); i++)
{
this->add_facet(edges_ordered.get_and_step());
}
}
// make sure all the edges are oriented correctly
DLIList<FacetEntity *> flist = this->get_facet_list();
flist.reset();
DLIList<CubitFacetEdge *> elist;
CAST_LIST( flist, elist, CubitFacetEdge );
elist.reset();
CubitPoint *cur_pt = startPoint, *tmp_pt;
for ( i = elist.size(); i > 0; i-- )
{
CubitFacetEdge *edge_ptr = elist.get_and_step();
CubitPoint *point0_ptr = edge_ptr->point(0);
CubitPoint *point1_ptr = edge_ptr->point(1);
if (point0_ptr != cur_pt)
{
assert( cur_pt == point1_ptr );
edge_ptr->flip();
tmp_pt = point0_ptr;
point0_ptr = point1_ptr;
point1_ptr = tmp_pt;
assert( point0_ptr == edge_ptr->point(0) &&
point1_ptr == edge_ptr->point(1) );
}
cur_pt = point1_ptr;
}
int mydebug = 0;
if (mydebug)
{
int i;
DLIList<FacetEntity *> flist = this->get_facet_list();
flist.reset();
DLIList<CubitFacetEdge *> elist;
CAST_LIST( flist, elist, CubitFacetEdge );
elist.reset();
for ( i = elist.size(); i > 0; i-- ) {
CubitFacetEdge *edge = elist.get_and_step();
CubitVector pt0_v = edge->point(0)->coordinates();
CubitVector pt1_v = edge->point(1)->coordinates();
GfxDebug::draw_point(pt0_v, CUBIT_GREEN );
GfxDebug::draw_point(pt1_v, CUBIT_RED );
GfxDebug::draw_line( pt0_v, pt1_v, CUBIT_YELLOW );
GfxDebug::flush();
int view = 0;
if (view)
dview();
}
}
return CUBIT_SUCCESS;
}
void CUIFrameWindow::DrawElements()
{
UIRender->SetShader (*m_shader);
Fvector2 ts;
UIRender->GetActiveTextureResolution(ts);
Frect rect;
GetAbsoluteRect (rect);
UI().ClientToScreenScaled (rect.lt);
UI().ClientToScreenScaled (rect.rb);
Fvector2 back_len = {0.0f, 0.0f};
u32 rect_count = 4; //lt+rt+lb+rb
back_len.x = rect.width()-m_tex_rect[fmLT].width()-m_tex_rect[fmRT].width();
back_len.y = rect.height()-m_tex_rect[fmLT].height()-m_tex_rect[fmRB].height();
R_ASSERT (back_len.x+EPS_L>=0.0f && back_len.y+EPS_L>=0.0f);
u32 cnt =0;
if(back_len.x>0.0f)//top+bottom
cnt = 2* iCeil(back_len.x/m_tex_rect[fmT].width());
rect_count += cnt;
if(back_len.y>0.0f)//left+right
cnt = 2* iCeil(back_len.y/m_tex_rect[fmL].height());
rect_count += cnt;
if(back_len.x>0.0f && back_len.y>0.0f) //back
cnt = iCeil(back_len.x/m_tex_rect[fmBK].width()) * iCeil(back_len.y/m_tex_rect[fmBK].height()) ;
rect_count += cnt;
rect_count *= 6;
UIRender->StartPrimitive (rect_count, IUIRender::ptTriList, UI().m_currentPointType);
Fvector2 LTt, RBt;
Fvector2 LTp, RBp;
Frect tmp = rect;
get_points (tmp, fmLT, LTp, RBp, LTt, RBt);
draw_rect (LTp, RBp, LTt, RBt, m_texture_color, ts);
tmp.lt.x = rect.lt.x;
tmp.lt.y = rect.rb.y - m_tex_rect[fmLB].height();
get_points (tmp, fmLB, LTp, RBp, LTt, RBt);
draw_rect (LTp, RBp, LTt, RBt, m_texture_color, ts);
tmp.lt.x = rect.rb.x - m_tex_rect[fmRT].width();
tmp.lt.y = rect.lt.y;;
get_points (tmp, fmRT, LTp, RBp, LTt, RBt);
draw_rect (LTp, RBp, LTt, RBt, m_texture_color, ts);
tmp.lt.x = rect.rb.x - m_tex_rect[fmRB].width();
tmp.lt.y = rect.rb.y - m_tex_rect[fmRB].height();
get_points (tmp, fmRB, LTp, RBp, LTt, RBt);
draw_rect (LTp, RBp, LTt, RBt, m_texture_color, ts);
if(back_len.x>0.0f)
{
tmp.lt = rect.lt;
tmp.lt.x += m_tex_rect[fmLT].width();
tmp.rb.x = rect.rb.x-m_tex_rect[fmRT].width();
tmp.rb.y = rect.lt.y+m_tex_rect[fmT].height();
draw_tile_line (tmp, fmT, true, ts);
tmp.lt.x = rect.lt.x+m_tex_rect[fmLT].width();
tmp.lt.y = rect.rb.y-m_tex_rect[fmB].height();
tmp.rb.x = rect.rb.x-m_tex_rect[fmRT].width();
tmp.rb.y = rect.rb.y;
draw_tile_line (tmp, fmB, true, ts);
}
if(back_len.y>0.0f)
{
tmp.lt = rect.lt;
tmp.lt.y += m_tex_rect[fmLT].height();
tmp.rb.x = rect.lt.x+m_tex_rect[fmL].width();
tmp.rb.y = rect.rb.y-m_tex_rect[fmLB].height();
draw_tile_line (tmp, fmL, false, ts);
tmp.lt.x = rect.rb.x-m_tex_rect[fmR].width();
tmp.lt.y = rect.lt.y+m_tex_rect[fmRT].height();;
tmp.rb.x = rect.rb.x;
tmp.rb.y = rect.rb.y-m_tex_rect[fmRB].height();
draw_tile_line (tmp, fmR, false, ts);
}
if(back_len.x>0.0f && back_len.y>0.0f)
{
tmp.lt.x = rect.lt.x+m_tex_rect[fmLT].width();
tmp.lt.y = rect.lt.y+m_tex_rect[fmLT].height();
tmp.rb.x = rect.rb.x-m_tex_rect[fmRB].width();
tmp.rb.y = rect.rb.y-m_tex_rect[fmRB].height();
draw_tile_rect (tmp, fmBK, ts);
}
UIRender->FlushPrimitive ();
}
// Returns the snake path in the dynamic matrix described as a succes
std::vector<std::pair<int, int> > compute_snake(std::string A, std::string B) {
// We have to index the dynamic from 1
A = " " + A;
B = " " + B;
// Indices for comparing texts
int begin_i = 0;
int begin_j = 0;
int end_i = A.length() - 1;
int end_j = B.length() - 1;
// Maximum editing distance
int maxD = (2 + A.length() + B.length()) / 2;
// Remember positions in the "snakes"
std::vector<std::map<int, std::pair<int, int> > > distance_begin(maxD);
std::vector<std::map<int, std::pair<int, int> > > distance_end(maxD);
// We need this for remembering the track of the cells
std::map<std::pair<int, int>, std::pair<int, int> > father;
// We use these to mark whether we reached the cell on the other corner
std::map<std::pair<int, int>, bool> reachA;
std::map<std::pair<int, int>, bool> reachB;
forward_advance(begin_i, begin_j, A, B);
distance_begin[0][0] = {begin_i, begin_j};
father[{begin_i, begin_j}] = {-1, -1};
reachA[{begin_i, begin_j}] = true;
// In this case the taexts are identical
if (begin_i == A.length() - 1 && begin_j == B.length() - 1) {
return get_points({begin_i, begin_j}, {end_i + 1, end_j + 1}, father);
}
backward_advance(end_i, end_j, A, B);
distance_end[0][B.length() - A.length()] = {end_i, end_j};
father[{end_i, end_j}] = {A.length(), B.length()};
reachB[{end_i, end_j}] = true;
// Iterate through the diffing distance
for (int d = 1; d <= maxD; d += 1) {
// In all of the if conditions that are followed by returns it means that the 2 snakes have met
// Iterate throguh the best for each diagonal starting from top-left
for (auto &it : distance_begin[d - 1]) {
// Advance and update by making another step
int diagonal_decay = it.first;
begin_i = it.second.first;
begin_j = it.second.second;
if (begin_i + 1 < A.length()) {
int new_decay = diagonal_decay - 1;
int new_i = begin_i + 1;
int new_j = begin_j;
if (reachB[{new_i, new_j}]) {
return get_points(it.second, {new_i, new_j}, father);
}
forward_advance(new_i, new_j, A, B);
reachA[distance_begin[d + 1][new_decay]] = false;
auto cell = distance_begin[d + 1][new_decay];
if (!cell.first || cell.first + cell.second < new_i + new_j) {
distance_begin[d + 1][new_decay] = {new_i, new_j};
father[{new_i, new_j}] = {begin_i, begin_j};
}
reachA[distance_begin[d + 1][new_decay]] = true;
}
if (begin_j + 1 < B.length()) {
int new_decay = diagonal_decay + 1;
int new_i = begin_i;
int new_j = begin_j + 1;
if (reachB[{new_i, new_j}]) {
return get_points(it.second, {new_i, new_j}, father);
}
forward_advance(new_i, new_j, A, B);
reachA[distance_begin[d + 1][new_decay]] = false;
auto cell = distance_begin[d + 1][new_decay];
if (!cell.first || cell.first + cell.second < new_i + new_j) {
distance_begin[d + 1][new_decay] = {new_i, new_j};
father[{new_i, new_j}] = {begin_i, begin_j};
}
reachA[distance_begin[d + 1][new_decay]] = true;
}
}
// Same as previous for but starting from bottom-right
for (auto &it : distance_end[d - 1]) {
// Same as previous for
int diagonal_decay = it.first;
begin_i = it.second.first;
begin_j = it.second.second;
if (begin_i - 1 >= 0) {
int new_decay = diagonal_decay + 1;
int new_i = begin_i - 1;
int new_j = begin_j;
if (reachA[{new_i, new_j}]) {
return get_points({new_i, new_j}, it.second, father);
}
backward_advance(new_i, new_j, A, B);
reachB[distance_end[d + 1][new_decay]] = false;
auto cell = distance_end[d + 1][new_decay];
if (!cell.first || cell.first + cell.second > new_i + new_j) {
distance_end[d + 1][new_decay] = {new_i, new_j};
father[{new_i, new_j}] = {begin_i, begin_j};
}
reachB[distance_end[d + 1][new_decay]] = true;
}
if (begin_j - 1 >= 0) {
int new_decay = diagonal_decay - 1;
int new_i = begin_i;
int new_j = begin_j - 1;
if (reachA[{new_i, new_j}]) {
return get_points({new_i, new_j}, it.second, father);
}
backward_advance(new_i, new_j, A, B);
reachB[distance_end[d + 1][new_decay]] = false;
auto cell = distance_end[d + 1][new_decay];
if (!cell.first || cell.first + cell.second > new_i + new_j) {
distance_end[d + 1][new_decay] = {new_i, new_j};
father[{new_i, new_j}] = {begin_i, begin_j};
}
reachB[distance_end[d + 1][new_decay]] = true;
}
}
}
return {{0,0}};
}
static gpointer
manager_alloc_font (HTMLFontManager *manager,
gchar *face,
GtkHTMLFontStyle style)
{
return html_painter_alloc_font (manager->painter, face, get_real_font_size (manager, style), get_points (manager, style), style);
}
int main(int argc, char *argv[]) { /* MAIN CODE STARTS HERE */
int i, /* j, */ bin;
double val, bin_width;
STATS stats;
char log_name[25];
/* Check for correct number of comand line arguments */
if (argc != 4) {
fprintf(stderr,
"Missing comand line arguments,\nUSAGE: <program name> <config file> <points file> <wind file>\n\n");
exit(1);
}
/* Each node opens a file for logging */
sprintf(log_name, "%s", LOG_FILE);
fprintf(stderr, "%s\n", log_name);
log_file = fopen(log_name, "w+");
if (log_file == NULL) {
fprintf(stderr, "Cannot open LOG file=[%s]:[%s]. Exiting.\n",
log_name, strerror(errno));
exit(1);
}
/* Initialize the global variables (see top of file) with inputs from the configuration file. */
if ( init_globals(argv[1]) ) {
exit(1);
}
#ifdef _PRINT
fflush(log_file);
#endif
/*make sure the points file exists*/
in_points= fopen(argv[2], "r");
if (in_points == NULL) {
fprintf(stderr, "Cannot open points file=[%s]:[%s]. Exiting.\n",
argv[2], strerror(errno));
exit_now(1);
}
/* Input the data points from a file using the
get_points function.
*/
if (get_points(in_points) ) {
exit_now(1);
}
#ifdef _PRINT
fflush(log_file);
#endif
/*make sure the wind file exists*/
in_wind= fopen(argv[3], "r");
if (in_wind == NULL) {
fprintf(stderr, "Cannot open wind file=[%s]:[%s]. Exiting.\n",
argv[3], strerror(errno));
exit_now(1);
}
if (get_wind(in_wind) ) {
exit_now(1);
}
#ifdef _PRINT
fflush(log_file);
#endif
set_global_values(log_file);
#ifdef _PRINT
fflush(log_file);
#endif
set_eruption_values(&e, W[0]);
for (i = 0; i < num_pts; i++)
{/* For each location */
tephra_calc(&e, pt+i, W[0], &stats);
}
#ifdef _PRINT
fprintf(log_file, "Calculated mass...\n");
for (i = 0; i < num_pts; i++) {
fprintf(log_file, "[%.0f][%.0f] %g ", (pt+i)->easting, (pt+i)->northing, (pt+i)->calculated_mass) ;
fprintf(log_file, "\n");
}
fprintf(log_file, "Finished.\n");
fflush(log_file);
#endif
fprintf(stderr,"\nMin Particle Fall Time = %gs\nMax Particle Fall Time = %gs\n",stats.min_falltime, stats.max_falltime);
//printf("Mean_fall_time %15.6e\n",stats.
/*phi_bins = (int)((erupt+j)->max_phi - (erupt+j)->min_phi);
if (phi_bins < 1) phi_bins = 1; */
bin_width = (e.max_phi - e.min_phi)/PART_STEPS;
printf("#EAST NORTH ELEV Kg/m^2 ");
for (bin = 0; bin < PART_STEPS; bin++)
printf("[%6.5f:%6.5f) ",
e.min_phi + bin_width*bin,
e.min_phi + bin_width*(bin+1));
printf("\n");
fprintf(stderr, "PART_STEPS=%d bin_width=%g\n", PART_STEPS, bin_width);
for (i=0; i < num_pts; i++) {
printf("%20.8e %20.8e %20.8e %20.8e ",
(pt+i)->easting,
(pt+i)->northing,
(pt+i)->elevation,
(pt+i)->calculated_mass);
///* Print out percent of total */
for (bin=0; bin < PART_STEPS; bin++) {
//val = ((pt+i)->calculated_phi[bin]/(pt+i)->calculated_mass);
val = (pt+i)->calculated_phi[bin];
//fprintf(stderr, "bin = %g mass = %g ", (pt+i)->phi[bin], (pt+i)->mass )
printf("%20.8e ", val);
}
printf("\n");
}
print_for_stats(0);
fprintf(log_file, "Finished.\n");
exit_now(0);
return 1;
}
