unsigned polygon_ctrl_impl::vertex(double* x, double* y)
{
unsigned cmd = path_cmd_stop;
double r = m_point_radius;
if(m_status == 0)
{
cmd = m_stroke.vertex(x, y);
if(!is_stop(cmd))
{
transform_xy(x, y);
return cmd;
}
if(m_node >= 0 && m_node == int(m_status)) r *= 1.2;
m_ellipse.init(xn(m_status), yn(m_status), r, r, 32);
++m_status;
}
cmd = m_ellipse.vertex(x, y);
if(!is_stop(cmd))
{
transform_xy(x, y);
return cmd;
}
if(m_status >= m_num_points) return path_cmd_stop;
if(m_node >= 0 && m_node == int(m_status)) r *= 1.2;
m_ellipse.init(xn(m_status), yn(m_status), r, r, 32);
++m_status;
cmd = m_ellipse.vertex(x, y);
if(!is_stop(cmd))
{
transform_xy(x, y);
}
return cmd;
}
//--------------------------------------------------------------------
unsigned rounded_rect::vertex(double* x, double* y)
{
unsigned cmd = path_cmd_stop;
switch(m_status)
{
case 0:
m_arc.init(m_x1 + m_rx1, m_y1 + m_ry1, m_rx1, m_ry1,
pi, pi+pi*0.5);
m_arc.rewind(0);
m_status++;
case 1:
cmd = m_arc.vertex(x, y);
if(is_stop(cmd)) m_status++;
else return cmd;
case 2:
m_arc.init(m_x2 - m_rx2, m_y1 + m_ry2, m_rx2, m_ry2,
pi+pi*0.5, 0.0);
m_arc.rewind(0);
m_status++;
case 3:
cmd = m_arc.vertex(x, y);
if(is_stop(cmd)) m_status++;
else return path_cmd_line_to;
case 4:
m_arc.init(m_x2 - m_rx3, m_y2 - m_ry3, m_rx3, m_ry3,
0.0, pi*0.5);
m_arc.rewind(0);
m_status++;
case 5:
cmd = m_arc.vertex(x, y);
if(is_stop(cmd)) m_status++;
else return path_cmd_line_to;
case 6:
m_arc.init(m_x1 + m_rx4, m_y2 - m_ry4, m_rx4, m_ry4,
pi*0.5, pi);
m_arc.rewind(0);
m_status++;
case 7:
cmd = m_arc.vertex(x, y);
if(is_stop(cmd)) m_status++;
else return path_cmd_line_to;
case 8:
cmd = path_cmd_end_poly | path_flags_close | path_flags_ccw;
m_status++;
break;
}
return cmd;
}
//------------------------------------------------------------------------
unsigned curve3_ctrl_impl::vertex(double* x, double* y)
{
unsigned cmd = path_cmd_stop;
switch(m_idx)
{
case 0:
case 1:
case 2:
cmd = m_stroke.vertex(x, y);
break;
case 3:
case 4:
case 5:
case 6:
cmd = m_ellipse.vertex(x, y);
break;
}
if(!is_stop(cmd))
{
transform_xy(x, y);
}
return cmd;
}
void down()
{
if (current_max_y+autodown_y+DRAW_BLOCK_SIZE > max_y || is_stop(VERRIFY_DOWN)) {
//get_russian();
//printf("--------11111111111111-------------\n");
//get_current_block();
//printf("--------22222222222222-------------\n");
copy();
//printf("-------333333333333--------------\n");
//get_russian();
//sleep(5);
free(block_entry_p->arr);
free(block_entry_p);
init_current_block();
draw_picture(ROW_CANVAS, 0x1a, IS_DRAW);
//exit(1);
return;
}
draw_picture(ROW_CANVAS, 0xfa, IS_DRAW);
autodown_y+=DRAW_BLOCK_SIZE;
draw_picture(ROW_CANVAS, 0x1a, IS_DRAW);
}
//------------------------------------------------------------------------
unsigned gamma_ctrl_impl::vertex(double* x, double* y)
{
unsigned cmd = path_cmd_line_to;
switch(m_idx)
{
case 0:
if(m_vertex == 0) cmd = path_cmd_move_to;
if(m_vertex >= 4) cmd = path_cmd_stop;
*x = m_vx[m_vertex];
*y = m_vy[m_vertex];
m_vertex++;
break;
case 1:
if(m_vertex == 0 || m_vertex == 4 || m_vertex == 8) cmd = path_cmd_move_to;
if(m_vertex >= 12) cmd = path_cmd_stop;
*x = m_vx[m_vertex];
*y = m_vy[m_vertex];
m_vertex++;
break;
case 2:
cmd = m_curve_poly.vertex(x, y);
break;
case 3:
if(m_vertex == 0 ||
m_vertex == 4 ||
m_vertex == 8 ||
m_vertex == 14) cmd = path_cmd_move_to;
if(m_vertex >= 20) cmd = path_cmd_stop;
*x = m_vx[m_vertex];
*y = m_vy[m_vertex];
m_vertex++;
break;
case 4: // Point1
case 5: // Point2
cmd = m_ellipse.vertex(x, y);
break;
case 6:
cmd = m_text_poly.vertex(x, y);
break;
default:
cmd = path_cmd_stop;
break;
}
if(!is_stop(cmd))
{
transform_xy(x, y);
}
return cmd;
}
void CPoolThread::CPoolThreadHelper::run()
{
// wait用于和主线程同步
do_millisleep(-1);
if (!is_stop())
{
if (_pool_thread->before_run())
{
while (!is_stop())
{
_pool_thread->run();
}
_pool_thread->after_run();
}
}
}
void right()
{
if (current_max_x+autodown_x+DRAW_BLOCK_SIZE > max_x|| is_stop(VERRIFY_RIGHT)) {
return;
}
draw_picture(ROW_CANVAS, 0xfa, IS_DRAW);
autodown_x+=DRAW_BLOCK_SIZE;
draw_picture(ROW_CANVAS, 0x1a, IS_DRAW);
}
void left()
{
if (current_min_x+autodown_x-DRAW_BLOCK_SIZE < min_x || is_stop(VERRIFY_LEFT)) {
return;
}
draw_picture(ROW_CANVAS, 0xfa, IS_DRAW);
autodown_x-=DRAW_BLOCK_SIZE;
draw_picture(ROW_CANVAS, 0x1a, IS_DRAW);
}
int parse_assignment(FILE *target, char *token, hash_t *var_map)
{
int var_type_length = strlen(token);
char var_type[var_type_length + 1];
memcpy(var_type, token, var_type_length);
var_type[var_type_length] = '\0';
char *current = get_token();
int var_name_length = strlen(current);
char var_name[var_name_length];
memcpy(var_name, current, var_name_length - 1);
var_name[var_name_length-1] = '\0';
if(strcmp(var_type, "string") != 0){
printf("Syntax error : only supports string assignment\n");
return 1;
}
if(next() == false){
printf("Syntax error : invalid assignment\n");
return 1;
}
current = get_token();
int var_value_length = strlen(current);
char var_value[var_value_length + 1];
memcpy(var_value, current, var_value_length);
var_value[var_value_length] = '\0';
if(is_string()){
write_one_operand_call(target, PUSHS, var_value);
} else if(is_alpha()){
char *var_value = hash_lookup(var_map, var_name);
if(NULL == var_value){
printf("The variable %s does not exist\n", var_name);
return 1;
}
write_variable_name(target, PUSHV, var_name);
}
if(next() == false || is_stop() == false){
printf("Every instruction must be closed by a semicolon\n");
return 1;
}
hash_insert(var_map, var_name, var_value);
write_variable_name(target, ASSIGN, var_name);
return 0;
}
unsigned interactive_polygon::vertex(double* x, double* y)
{
unsigned cmd = path_cmd_stop;
double r = m_point_radius;
if(m_status == 0)
{
cmd = m_stroke.vertex(x, y);
if(!is_stop(cmd)) return cmd;
if(m_node >= 0 && m_node == int(m_status)) r *= 1.2;
m_ellipse.init(xn(m_status), yn(m_status), r, r, 32);
++m_status;
}
cmd = m_ellipse.vertex(x, y);
if(!is_stop(cmd)) return cmd;
if(m_status >= m_num_points) return path_cmd_stop;
if(m_node >= 0 && m_node == int(m_status)) r *= 1.2;
m_ellipse.init(xn(m_status), yn(m_status), r, r, 32);
++m_status;
return m_ellipse.vertex(x, y);
}
void _path_operation(conv_clipper::clip_op op, const graphic_path& a, const graphic_path& b, graphic_path& r)
{
conv_clipper cliper(a, b, op);
cliper.rewind(0);
r.remove_all();
scalar x = 0, y = 0;
unsigned int cmd = 0;
while (!is_stop(cmd = cliper.vertex(&x, &y))) {
r.add_vertex(x, y, cmd);
}
}
// Emulate an instruction.
int idaapi emu(void) {
bool flow = !is_stop() || (cmd.auxpref & INSN_DELAY_SHOT);
if ( flow )
{
insn_t cmd_backup = cmd;
if ( decode_prev_insn(cmd.ea) != BADADDR ) {
flow = !(is_stop() && (cmd.auxpref & INSN_DELAY_SHOT));
}
cmd = cmd_backup;
}
if ( cmd.Op1.type != o_void) handle_operand(cmd.Op1 );
if ( cmd.Op2.type != o_void) handle_operand(cmd.Op2 );
if ( cmd.Op3.type != o_void) handle_operand(cmd.Op3 );
if ( cmd.Op4.type != o_void) handle_operand(cmd.Op4 );
if ( flow )
ua_add_cref(0, cmd.ea + cmd.size, fl_F);
return 1;
}
void CObserverThread::run()
{
#if ENABLE_SET_OBSERVER_THREAD_NAME==1
sys::CUtil::set_process_name("ob-thread");
#endif // ENABLE_SET_OBSERVER_THREAD_NAME
while (!is_stop())
{
do_millisleep(_observer_context->get_report_frequency_seconds());
_observer_context->collect();
}
}
void freq_main(void)
{
cli();
counter_init();
gate_init();
stop();
reset();
ff_clr();
key_init();
setup_timers();
setup_interrupts();
adc_init();
sti();
/*clear counter*/
TCNT2= 0;
TCNT0= 0;
TCNT1= 0xFF00;
T0_ovc = T1_ovc =0;
start();
//fast clear screen...
post_display(filter());//really result
while(1) {
key_process();
keep_live();
mode = read_adc_mode();
update_lcd_status();
if(is_stop()&&soft_stop){
calc_freq();
post_display(filter());//really result
c_live() ; //mark succeufull ..
if(loop>=(ST)){ //never clear
reset();
}
loop=0;
start();
}
}
}
int parse_call(FILE *target, char *function, hash_t *var_map)
{
if(strcmp(function, "print") != 0){
printf("The function call %s is not supported\n", function);
return 1;
}
if(next() == false){
printf("Not enough arguments to the function call %s\n", function);
return 1;
}
if(is_string()){
char *call = get_token();
write_one_operand_call(target, PUSHS, call);
} else if(is_alpha()){
char *var_name = get_token();
char *var_value = hash_lookup(var_map, var_name);
if(NULL == var_value){
printf("The variable %s does not exist\n", var_name);
return 1;
}
write_variable_name(target, PUSHV, var_name);
} else {
printf("Can only pass string or a variable to a function call\n");
return 1;
}
if(next() == false || is_right() == false){
printf("The function call must be closed with a right parenthesis\n");
return 1;
}
if(next() == false || is_stop() == false){
printf("Every instruction must be closed by a semicolon\n");
return 1;
}
write_simple_call(target, PRINT);
return 0;
}
void Widget::run() {
int dot_count = 0;
std::string info;
while (!is_stop()) {
dot_count = (dot_count > 6) ? 0 : dot_count;
info = "user login";
for (int i = 0; i < dot_count; ++i) {
info += ".";
}
label_info_set_text(info.c_str());
usleep(500000);
++dot_count;
}
}
//------------------------------------------------------------------------
unsigned slider_ctrl_impl::vertex(double* x, double* y)
{
unsigned cmd = path_cmd_line_to;
switch(m_idx)
{
case 0:
if(m_vertex == 0) cmd = path_cmd_move_to;
if(m_vertex >= 4) cmd = path_cmd_stop;
*x = m_vx[m_vertex];
*y = m_vy[m_vertex];
m_vertex++;
break;
case 1:
if(m_vertex == 0) cmd = path_cmd_move_to;
if(m_vertex >= 4) cmd = path_cmd_stop;
*x = m_vx[m_vertex];
*y = m_vy[m_vertex];
m_vertex++;
break;
case 2:
cmd = m_text_poly.vertex(x, y);
break;
case 3:
case 4:
cmd = m_ellipse.vertex(x, y);
break;
case 5:
cmd = m_storage.vertex(x, y);
break;
default:
cmd = path_cmd_stop;
break;
}
if(!is_stop(cmd))
{
transform_xy(x, y);
}
return cmd;
}
//------------------------------------------------------------------------
unsigned cbox_ctrl_impl::vertex(real* x, real* y)
{
unsigned cmd = path_cmd_line_to;
switch(m_idx)
{
case 0:
if(m_vertex == 0 || m_vertex == 4) cmd = path_cmd_move_to;
if(m_vertex >= 8) cmd = path_cmd_stop;
*x = m_vx[m_vertex];
*y = m_vy[m_vertex];
m_vertex++;
break;
case 1:
cmd = m_text_poly.vertex(x, y);
break;
case 2:
if(m_status)
{
if(m_vertex == 0) cmd = path_cmd_move_to;
if(m_vertex >= 8) cmd = path_cmd_stop;
*x = m_vx[m_vertex];
*y = m_vy[m_vertex];
m_vertex++;
}
else
{
cmd = path_cmd_stop;
}
break;
default:
cmd = path_cmd_stop;
break;
}
if(!is_stop(cmd))
{
transform_xy(x, y);
}
return cmd;
}
//------------------------------------------------------------------------
unsigned arc::vertex(real* x, real* y)
{
if(is_stop(m_path_cmd)) return path_cmd_stop;
if((m_angle < m_end - m_da/4) != m_ccw)
{
*x = m_x + (real)cos(m_end) * m_rx;
*y = m_y + (real)sin(m_end) * m_ry;
m_path_cmd = path_cmd_stop;
return path_cmd_line_to;
}
*x = m_x + (real)cos(m_angle) * m_rx;
*y = m_y + (real)sin(m_angle) * m_ry;
m_angle += m_da;
unsigned pf = m_path_cmd;
m_path_cmd = path_cmd_line_to;
return pf;
}
// gets line parameters from user
double* get_line()
{
double line[parameters] = {0, 0, 0};
while (is_line_wrong(line))
{
print("If you want to stop, enter 0 0 0.");
print("Enter line ax + by = c as space-separated parameters a b c: ");
cin >> line[a];
cin >> line[b];
cin >> line[c];
// stops on user command
if (is_stop(line))
break;
// repeats request if input was incorrect
if (is_line_wrong(line))
print("You have entered incorrect parameter A and B. They can not be 0 simultaneously.");
}
return line;
}
double path_length(VertexSource& vs, unsigned path_id = 0)
{
double len = 0.0;
double start_x = 0.0;
double start_y = 0.0;
double x1 = 0.0;
double y1 = 0.0;
double x2 = 0.0;
double y2 = 0.0;
bool first = true;
unsigned cmd;
vs.rewind(path_id);
while(!is_stop(cmd = vs.vertex(&x2, &y2)))
{
if(is_vertex(cmd))
{
if(first || is_move_to(cmd))
{
start_x = x2;
start_y = y2;
}
else
{
len += calc_distance(x1, y1, x2, y2);
}
x1 = x2;
y1 = y2;
first = false;
}
else
{
if(is_close(cmd) && !first)
{
len += calc_distance(x1, y1, start_x, start_y);
}
}
}
return len;
}
std::string CAgentThread::wait_domainname_or_iplist_ready(uint16_t* port)
{
std::string domainname_or_iplist;
// 如果_domainname_or_iplist为空，则一直等待，直到不为空，或线程收到了退出指令
while (!is_stop())
{
sys::LockHelper<sys::CLock> lh(_center_lock);
domainname_or_iplist = _domainname_or_iplist;
*port = _port;
if (!domainname_or_iplist.empty())
{
break;
}
AGENT_LOG_INFO("Waiting for domain name or IP not set.\n");
_center_event.wait(_center_lock);
}
return domainname_or_iplist;
}
//------------------------------------------------------------------------
unsigned rbox_ctrl_impl::vertex(real* x, real* y)
{
unsigned cmd = path_cmd_line_to;
switch(m_idx)
{
case 0:
if(m_vertex == 0) cmd = path_cmd_move_to;
if(m_vertex >= 4) cmd = path_cmd_stop;
*x = m_vx[m_vertex];
*y = m_vy[m_vertex];
m_vertex++;
break;
case 1:
if(m_vertex == 0 || m_vertex == 4) cmd = path_cmd_move_to;
if(m_vertex >= 8) cmd = path_cmd_stop;
*x = m_vx[m_vertex];
*y = m_vy[m_vertex];
m_vertex++;
break;
case 2:
cmd = m_text_poly.vertex(x, y);
if(is_stop(cmd))
{
m_draw_item++;
if(m_draw_item >= m_num_items)
{
break;
}
else
{
m_text.text(&m_items[m_draw_item][0]);
m_text.start_point(m_xs1 + m_dy * 1.5,
m_ys1 + m_dy * (m_draw_item + 1) - m_dy / 2.0f);
m_text_poly.rewind(0);
cmd = m_text_poly.vertex(x, y);
}
}
break;
case 3:
cmd = m_ellipse_poly.vertex(x, y);
if(is_stop(cmd))
{
m_draw_item++;
if(m_draw_item >= m_num_items)
{
break;
}
else
{
m_ellipse.init(m_xs1 + m_dy / 1.3,
m_ys1 + m_dy * m_draw_item + m_dy / 1.3,
m_text_height / 1.5,
m_text_height / 1.5, 32);
m_ellipse_poly.rewind(0);
cmd = m_ellipse_poly.vertex(x, y);
}
}
break;
case 4:
if(m_cur_item >= 0)
{
cmd = m_ellipse.vertex(x, y);
}
else
{
cmd = path_cmd_stop;
}
break;
default:
cmd = path_cmd_stop;
break;
}
if(!is_stop(cmd))
{
transform_xy(x, y);
}
return cmd;
}
//------------------------------------------------------------------------
unsigned vcgen_bspline::vertex(double* x, double* y)
{
unsigned cmd = path_cmd_line_to;
while(!is_stop(cmd))
{
switch(m_status)
{
case initial:
rewind(0);
case ready:
if(m_src_vertices.size() < 2)
{
cmd = path_cmd_stop;
break;
}
if(m_src_vertices.size() == 2)
{
*x = m_src_vertices[m_src_vertex].x;
*y = m_src_vertices[m_src_vertex].y;
m_src_vertex++;
if(m_src_vertex == 1) return path_cmd_move_to;
if(m_src_vertex == 2) return path_cmd_line_to;
cmd = path_cmd_stop;
break;
}
cmd = path_cmd_move_to;
m_status = polygon;
m_src_vertex = 0;
case polygon:
if(m_cur_abscissa >= m_max_abscissa)
{
if(m_closed)
{
m_status = end_poly;
break;
}
else
{
*x = m_src_vertices[m_src_vertices.size() - 1].x;
*y = m_src_vertices[m_src_vertices.size() - 1].y;
m_status = end_poly;
return path_cmd_line_to;
}
}
*x = m_spline_x.get_stateful(m_cur_abscissa);
*y = m_spline_y.get_stateful(m_cur_abscissa);
m_src_vertex++;
m_cur_abscissa += m_interpolation_step;
return (m_src_vertex == 1) ? path_cmd_move_to : path_cmd_line_to;
case end_poly:
m_status = stop;
return path_cmd_end_poly | m_closed;
case stop:
return path_cmd_stop;
}
}
return cmd;
}
//------------------------------------------------------------------------
unsigned vcgen_stroke::vertex(double* x, double* y)
{
unsigned cmd = path_cmd_line_to;
while(!is_stop(cmd))
{
switch(m_status)
{
case initial:
rewind(0);
case ready:
if(m_src_vertices.size() < 2 + unsigned(m_closed != 0))
{
cmd = path_cmd_stop;
break;
}
m_status = m_closed ? outline1 : cap1;
cmd = path_cmd_move_to;
m_src_vertex = 0;
m_out_vertex = 0;
break;
case cap1:
stroke_calc_cap(m_out_vertices,
m_src_vertices[0],
m_src_vertices[1],
m_src_vertices[0].dist,
m_line_cap,
m_width,
m_approx_scale);
m_src_vertex = 1;
m_prev_status = outline1;
m_status = out_vertices;
m_out_vertex = 0;
break;
case cap2:
stroke_calc_cap(m_out_vertices,
m_src_vertices[m_src_vertices.size() - 1],
m_src_vertices[m_src_vertices.size() - 2],
m_src_vertices[m_src_vertices.size() - 2].dist,
m_line_cap,
m_width,
m_approx_scale);
m_prev_status = outline2;
m_status = out_vertices;
m_out_vertex = 0;
break;
case outline1:
if(m_closed)
{
if(m_src_vertex >= m_src_vertices.size())
{
m_prev_status = close_first;
m_status = end_poly1;
break;
}
}
else
{
if(m_src_vertex >= m_src_vertices.size() - 1)
{
m_status = cap2;
break;
}
}
stroke_calc_join(m_out_vertices,
m_src_vertices.prev(m_src_vertex),
m_src_vertices.curr(m_src_vertex),
m_src_vertices.next(m_src_vertex),
m_src_vertices.prev(m_src_vertex).dist,
m_src_vertices.curr(m_src_vertex).dist,
m_width,
m_line_join,
m_inner_line_join,
m_miter_limit,
m_inner_miter_limit,
m_approx_scale);
++m_src_vertex;
m_prev_status = m_status;
m_status = out_vertices;
m_out_vertex = 0;
break;
case close_first:
m_status = outline2;
cmd = path_cmd_move_to;
case outline2:
if(m_src_vertex <= unsigned(m_closed == 0))
{
m_status = end_poly2;
m_prev_status = stop;
break;
}
--m_src_vertex;
stroke_calc_join(m_out_vertices,
m_src_vertices.next(m_src_vertex),
m_src_vertices.curr(m_src_vertex),
m_src_vertices.prev(m_src_vertex),
m_src_vertices.curr(m_src_vertex).dist,
m_src_vertices.prev(m_src_vertex).dist,
m_width,
m_line_join,
m_inner_line_join,
m_miter_limit,
m_inner_miter_limit,
m_approx_scale);
m_prev_status = m_status;
m_status = out_vertices;
m_out_vertex = 0;
break;
case out_vertices:
if(m_out_vertex >= m_out_vertices.size())
{
m_status = m_prev_status;
}
else
{
const point_type& c = m_out_vertices[m_out_vertex++];
*x = c.x;
*y = c.y;
return cmd;
}
break;
case end_poly1:
m_status = m_prev_status;
return path_cmd_end_poly | path_flags_close | path_flags_ccw;
case end_poly2:
m_status = m_prev_status;
return path_cmd_end_poly | path_flags_close | path_flags_cw;
case stop:
cmd = path_cmd_stop;
break;
}
}
return cmd;
}
//------------------------------------------------------------------------
unsigned vcgen_contour::vertex(double* x, double* y)
{
unsigned cmd = path_cmd_line_to;
while(!is_stop(cmd))
{
switch(m_status)
{
case initial:
rewind(0);
case ready:
if(m_src_vertices.size() < 2 + unsigned(m_closed != 0))
{
cmd = path_cmd_stop;
break;
}
m_status = outline;
cmd = path_cmd_move_to;
m_src_vertex = 0;
m_out_vertex = 0;
case outline:
if(m_src_vertex >= m_src_vertices.size())
{
m_status = end_poly;
break;
}
m_stroker.calc_join(m_out_vertices,
m_src_vertices.prev(m_src_vertex),
m_src_vertices.curr(m_src_vertex),
m_src_vertices.next(m_src_vertex),
m_src_vertices.prev(m_src_vertex).dist,
m_src_vertices.curr(m_src_vertex).dist);
++m_src_vertex;
m_status = out_vertices;
m_out_vertex = 0;
case out_vertices:
if(m_out_vertex >= m_out_vertices.size())
{
m_status = outline;
}
else
{
const point_d& c = m_out_vertices[m_out_vertex++];
*x = c.x;
*y = c.y;
return cmd;
}
break;
case end_poly:
if(!m_closed) return path_cmd_stop;
m_status = stop;
return path_cmd_end_poly | path_flags_close | path_flags_ccw;
case stop:
return path_cmd_stop;
}
}
return cmd;
}
//------------------------------------------------------------------------
unsigned vcgen_smooth_poly1::vertex(double* x, double* y)
{
unsigned cmd = path_cmd_line_to;
while(!is_stop(cmd))
{
switch(m_status)
{
case initial:
rewind(0);
case ready:
if(m_src_vertices.size() < 2)
{
cmd = path_cmd_stop;
break;
}
if(m_src_vertices.size() == 2)
{
*x = m_src_vertices[m_src_vertex].x;
*y = m_src_vertices[m_src_vertex].y;
m_src_vertex++;
if(m_src_vertex == 1) return path_cmd_move_to;
if(m_src_vertex == 2) return path_cmd_line_to;
cmd = path_cmd_stop;
break;
}
cmd = path_cmd_move_to;
m_status = polygon;
m_src_vertex = 0;
case polygon:
if(m_closed)
{
if(m_src_vertex >= m_src_vertices.size())
{
*x = m_src_vertices[0].x;
*y = m_src_vertices[0].y;
m_status = end_poly;
return path_cmd_curve4;
}
}
else
{
if(m_src_vertex >= m_src_vertices.size() - 1)
{
*x = m_src_vertices[m_src_vertices.size() - 1].x;
*y = m_src_vertices[m_src_vertices.size() - 1].y;
m_status = end_poly;
return path_cmd_curve3;
}
}
calculate(m_src_vertices.prev(m_src_vertex),
m_src_vertices.curr(m_src_vertex),
m_src_vertices.next(m_src_vertex),
m_src_vertices.next(m_src_vertex + 1));
*x = m_src_vertices[m_src_vertex].x;
*y = m_src_vertices[m_src_vertex].y;
m_src_vertex++;
if(m_closed)
{
m_status = ctrl1;
return ((m_src_vertex == 1) ?
path_cmd_move_to :
path_cmd_curve4);
}
else
{
if(m_src_vertex == 1)
{
m_status = ctrl_b;
return path_cmd_move_to;
}
if(m_src_vertex >= m_src_vertices.size() - 1)
{
m_status = ctrl_e;
return path_cmd_curve3;
}
m_status = ctrl1;
return path_cmd_curve4;
}
break;
case ctrl_b:
*x = m_ctrl2_x;
*y = m_ctrl2_y;
m_status = polygon;
return path_cmd_curve3;
case ctrl_e:
*x = m_ctrl1_x;
*y = m_ctrl1_y;
m_status = polygon;
return path_cmd_curve3;
case ctrl1:
*x = m_ctrl1_x;
*y = m_ctrl1_y;
m_status = ctrl2;
return path_cmd_curve4;
case ctrl2:
*x = m_ctrl2_x;
*y = m_ctrl2_y;
m_status = polygon;
return path_cmd_curve4;
case end_poly:
m_status = stop;
return path_cmd_end_poly | m_closed;
case stop:
return path_cmd_stop;
}
}
return cmd;
}
/* Returns a single amino acid for this position */
char amino(unsigned char *seq, int n, struct _training *tinf, int is_init) {
if(is_stop(seq, n, tinf) == 1) return '*';
if(is_start(seq, n, tinf) == 1 && is_init == 1) return 'M';
if(is_t(seq, n) == 1 && is_t(seq, n+1) == 1 && is_t(seq, n+2) == 1)
return 'F';
if(is_t(seq, n) == 1 && is_t(seq, n+1) == 1 && is_c(seq, n+2) == 1)
return 'F';
if(is_t(seq, n) == 1 && is_t(seq, n+1) == 1 && is_a(seq, n+2) == 1)
return 'L';
if(is_t(seq, n) == 1 && is_t(seq, n+1) == 1 && is_g(seq, n+2) == 1)
return 'L';
if(is_t(seq, n) == 1 && is_c(seq, n+1) == 1) return 'S';
if(is_t(seq, n) == 1 && is_a(seq, n+1) == 1 && is_t(seq, n+2) == 1)
return 'Y';
if(is_t(seq, n) == 1 && is_a(seq, n+1) == 1 && is_c(seq, n+2) == 1)
return 'Y';
if(is_t(seq, n) == 1 && is_a(seq, n+1) == 1 && is_a(seq, n+2) == 1) {
if(tinf->trans_table == 6) return 'Q';
if(tinf->trans_table == 14) return 'Y';
}
if(is_t(seq, n) == 1 && is_a(seq, n+1) == 1 && is_g(seq, n+2) == 1) {
if(tinf->trans_table == 6 || tinf->trans_table == 15) return 'Q';
if(tinf->trans_table == 22) return 'L';
}
if(is_t(seq, n) == 1 && is_g(seq, n+1) == 1 && is_t(seq, n+2) == 1)
return 'C';
if(is_t(seq, n) == 1 && is_g(seq, n+1) == 1 && is_c(seq, n+2) == 1)
return 'C';
if(is_t(seq, n) == 1 && is_g(seq, n+1) == 1 && is_a(seq, n+2) == 1)
return 'W';
if(is_t(seq, n) == 1 && is_g(seq, n+1) == 1 && is_g(seq, n+2) == 1)
return 'W';
if(is_c(seq, n) == 1 && is_t(seq, n+1) == 1 && is_t(seq, n+2) == 1) {
if(tinf->trans_table == 3) return 'T';
return 'L';
}
if(is_c(seq, n) == 1 && is_t(seq, n+1) == 1 && is_c(seq, n+2) == 1) {
if(tinf->trans_table == 3) return 'T';
return 'L';
}
if(is_c(seq, n) == 1 && is_t(seq, n+1) == 1 && is_a(seq, n+2) == 1) {
if(tinf->trans_table == 3) return 'T';
return 'L';
}
if(is_c(seq, n) == 1 && is_t(seq, n+1) == 1 && is_g(seq, n+2) == 1) {
if(tinf->trans_table == 3) return 'T';
if(tinf->trans_table == 12) return 'S';
return 'L';
}
if(is_c(seq, n) == 1 && is_c(seq, n+1) == 1) return 'P';
if(is_c(seq, n) == 1 && is_a(seq, n+1) == 1 && is_t(seq, n+2) == 1)
return 'H';
if(is_c(seq, n) == 1 && is_a(seq, n+1) == 1 && is_c(seq, n+2) == 1)
return 'H';
if(is_c(seq, n) == 1 && is_a(seq, n+1) == 1 && is_a(seq, n+2) == 1)
return 'Q';
if(is_c(seq, n) == 1 && is_a(seq, n+1) == 1 && is_g(seq, n+2) == 1)
return 'Q';
if(is_c(seq, n) == 1 && is_g(seq, n+1) == 1) return 'R';
if(is_a(seq, n) == 1 && is_t(seq, n+1) == 1 && is_t(seq, n+2) == 1)
return 'I';
if(is_a(seq, n) == 1 && is_t(seq, n+1) == 1 && is_c(seq, n+2) == 1)
return 'I';
if(is_a(seq, n) == 1 && is_t(seq, n+1) == 1 && is_a(seq, n+2) == 1) {
if(tinf->trans_table == 2 || tinf->trans_table == 3 ||
tinf->trans_table == 5 || tinf->trans_table == 13 ||
tinf->trans_table == 21) return 'M';
return 'I';
}
if(is_a(seq, n) == 1 && is_t(seq, n+1) == 1 && is_g(seq, n+2) == 1)
return 'M';
if(is_a(seq, n) == 1 && is_c(seq, n+1) == 1) return 'T';
if(is_a(seq, n) == 1 && is_a(seq, n+1) == 1 && is_t(seq, n+2) == 1)
return 'N';
if(is_a(seq, n) == 1 && is_a(seq, n+1) == 1 && is_c(seq, n+2) == 1)
return 'N';
if(is_a(seq, n) == 1 && is_a(seq, n+1) == 1 && is_a(seq, n+2) == 1) {
if(tinf->trans_table == 9 || tinf->trans_table == 14 ||
tinf->trans_table == 21) return 'N';
return 'K';
}
if(is_a(seq, n) == 1 && is_a(seq, n+1) == 1 && is_g(seq, n+2) == 1)
return 'K';
if(is_a(seq, n) == 1 && is_g(seq, n+1) == 1 && is_t(seq, n+2) == 1)
return 'S';
if(is_a(seq, n) == 1 && is_g(seq, n+1) == 1 && is_c(seq, n+2) == 1)
return 'S';
if(is_a(seq, n) == 1 && is_g(seq, n+1) == 1 && (is_a(seq, n+2) == 1 ||
is_g(seq, n+2) == 1)) {
if(tinf->trans_table == 13) return 'G';
if(tinf->trans_table == 5 || tinf->trans_table == 9 ||
tinf->trans_table == 14 || tinf->trans_table == 21) return 'S';
return 'R';
}
if(is_g(seq, n) == 1 && is_t(seq, n+1) == 1) return 'V';
if(is_g(seq, n) == 1 && is_c(seq, n+1) == 1) return 'A';
if(is_g(seq, n) == 1 && is_a(seq, n+1) == 1 && is_t(seq, n+2) == 1)
return 'D';
if(is_g(seq, n) == 1 && is_a(seq, n+1) == 1 && is_c(seq, n+2) == 1)
return 'D';
if(is_g(seq, n) == 1 && is_a(seq, n+1) == 1 && is_a(seq, n+2) == 1)
return 'E';
if(is_g(seq, n) == 1 && is_a(seq, n+1) == 1 && is_g(seq, n+2) == 1)
return 'E';
if(is_g(seq, n) == 1 && is_g(seq, n+1) == 1) return 'G';
return 'X';
}
unsigned conv_adaptor_vpgen<VertexSource, VPGen>::vertex(double* x, double* y)
{
unsigned cmd = path_cmd_stop;
for(;;)
{
cmd = m_vpgen.vertex(x, y);
if(!is_stop(cmd)) break;
if(m_poly_flags && !m_vpgen.auto_unclose())
{
*x = 0.0;
*y = 0.0;
cmd = m_poly_flags;
m_poly_flags = 0;
break;
}
if(m_vertices < 0)
{
if(m_vertices < -1)
{
m_vertices = 0;
return path_cmd_stop;
}
m_vpgen.move_to(m_start_x, m_start_y);
m_vertices = 1;
continue;
}
double tx, ty;
cmd = m_source->vertex(&tx, &ty);
if(is_vertex(cmd))
{
if(is_move_to(cmd))
{
if(m_vpgen.auto_close() && m_vertices > 2)
{
m_vpgen.line_to(m_start_x, m_start_y);
m_poly_flags = path_cmd_end_poly | path_flags_close;
m_start_x = tx;
m_start_y = ty;
m_vertices = -1;
continue;
}
m_vpgen.move_to(tx, ty);
m_start_x = tx;
m_start_y = ty;
m_vertices = 1;
}
else
{
m_vpgen.line_to(tx, ty);
++m_vertices;
}
}
else
{
if(is_end_poly(cmd))
{
m_poly_flags = cmd;
if(is_closed(cmd) || m_vpgen.auto_close())
{
if(m_vpgen.auto_close()) m_poly_flags |= path_flags_close;
if(m_vertices > 2)
{
m_vpgen.line_to(m_start_x, m_start_y);
}
m_vertices = 0;
}
}
else
{
// path_cmd_stop
if(m_vpgen.auto_close() && m_vertices > 2)
{
m_vpgen.line_to(m_start_x, m_start_y);
m_poly_flags = path_cmd_end_poly | path_flags_close;
m_vertices = -2;
continue;
}
break;
}
}
}
return cmd;
}
//------------------------------------------------------------------------
unsigned vcgen_dash::vertex(double* x, double* y)
{
unsigned cmd = path_cmd_move_to;
while(!is_stop(cmd))
{
switch(m_status)
{
case initial:
rewind(0);
case ready:
if(m_num_dashes < 2 || m_src_vertices.size() < 2)
{
cmd = path_cmd_stop;
break;
}
m_status = polyline;
m_src_vertex = 1;
m_v1 = &m_src_vertices[0];
m_v2 = &m_src_vertices[1];
m_curr_rest = m_v1->dist;
*x = m_v1->x;
*y = m_v1->y;
if(m_dash_start >= 0.0) calc_dash_start(m_dash_start);
return path_cmd_move_to;
case polyline:
{
double dash_rest = m_dashes[m_curr_dash] - m_curr_dash_start;
unsigned cmd = (m_curr_dash & 1) ?
path_cmd_move_to :
path_cmd_line_to;
if(m_curr_rest > dash_rest)
{
m_curr_rest -= dash_rest;
++m_curr_dash;
if(m_curr_dash >= m_num_dashes) m_curr_dash = 0;
m_curr_dash_start = 0.0;
*x = m_v2->x - (m_v2->x - m_v1->x) * m_curr_rest / m_v1->dist;
*y = m_v2->y - (m_v2->y - m_v1->y) * m_curr_rest / m_v1->dist;
}
else
{
m_curr_dash_start += m_curr_rest;
*x = m_v2->x;
*y = m_v2->y;
++m_src_vertex;
m_v1 = m_v2;
m_curr_rest = m_v1->dist;
if(m_closed)
{
if(m_src_vertex > m_src_vertices.size())
{
m_status = stop;
}
else
{
m_v2 = &m_src_vertices
[
(m_src_vertex >= m_src_vertices.size()) ? 0 :
m_src_vertex
];
}
}
else
{
if(m_src_vertex >= m_src_vertices.size())
{
m_status = stop;
}
else
{
m_v2 = &m_src_vertices[m_src_vertex];
}
}
}
return cmd;
}
break;
case stop:
cmd = path_cmd_stop;
break;
}
}
return path_cmd_stop;
}
