Esempio n. 1
0
/*===========================================================================*/
int * ghmm_dpmodel_viterbi_propagate_segment (ghmm_dpmodel *mo, ghmm_dpseq * X, ghmm_dpseq * Y,
				  double *log_p, int *path_length,
				  double max_size, int start_x, int start_y,
				  int stop_x, int stop_y, int start_state,
				  int stop_state, double start_log_p,
				  double stop_log_p) {
#define CUR_PROC "ghmm_dpmodel_viterbi_propagate_segment"
  int * path_seq = NULL;
  cell * start, * stop;
  plocal_propagate_store_t * pv = pviterbi_propagate_alloc(mo, Y->length);

  /* Precomputing the log(a_ij) and log(bj(ot)) */
  pviterbi_prop_precompute(mo, pv);

  /* init start and stop */
  start = init_cell (start_x, start_y, start_state, -1, start_log_p, 0);
  stop = init_cell (stop_x, stop_y, stop_state, stop_state, stop_log_p, 0);

  /* Launch the recursion */
  path_seq = pviterbi_propagate_recursion (mo, X, Y, log_p, path_length,
					   start, stop, max_size, pv);

  pviterbi_propagate_free (&pv, mo->N, mo->max_offset_x, mo->max_offset_y, Y->length);

  return path_seq;
#undef CUR_PROC
}
QStandardItem *TraitColumn::build_cell(Dwarf *d) {
    QStandardItem *item = init_cell(d);
    item->setData(CT_TRAIT, DwarfModel::DR_COL_TYPE);
    item->setData(0, DwarfModel::DR_SPECIAL_FLAG); //default, special flag stores the alpha for the border

    short raw_value = d->trait(m_trait_id);
    short rating = raw_value;
    QStringList infos;
    if (m_trait){
        infos << m_trait->level_message(raw_value).append(m_trait->belief_conficts_msgs(raw_value,d->trait_conflicts(m_trait_id)));
    }else{
        infos << tr("Unknown trait");
    }

    if(raw_value < 0){
        infos << tr("This unit doesn't have this trait!");
    }

    if (d->trait_is_active(m_trait_id)==false)
        infos << tr("Not an active trait for this dwarf.");

    int conflicting_belief_count = 0;
    if (m_trait){
        infos << m_trait->skill_conflicts_msgs(raw_value);
        infos << m_trait->special_messages(raw_value);

        conflicting_belief_count = m_trait->get_conflicting_beliefs().count();
        if(conflicting_belief_count > 0){
            infos << tr("<br/>This trait can conflict with %1").arg(m_trait->belief_conflicts_names());
        }
        if(m_trait->valued_inversely()){
            infos << Trait::inverted_message;
            if(raw_value != -1)
                rating = 100 - raw_value;
        }
    }

    infos.removeAll("");

    if(d->trait_is_conflicted(m_trait_id) && conflicting_belief_count > 0){
        int alpha = 255 * ((float)d->trait_conflicts(m_trait_id).count() / (float)conflicting_belief_count);
        item->setData(alpha, DwarfModel::DR_SPECIAL_FLAG);
    }

    item->setText(QString::number(raw_value));
    item->setData(rating, DwarfModel::DR_SORT_VALUE);
    item->setData(rating, DwarfModel::DR_RATING);
    item->setData(rating, DwarfModel::DR_DISPLAY_RATING);
    item->setData(raw_value, DwarfModel::DR_EXPORT);
    set_export_role(DwarfModel::DR_EXPORT);

    QString tooltip = QString("<center><h3>%1</h3> %2</center><br/>%3<br/>%4")
            .arg(m_title)
            .arg(tr("<b>Raw Value: %1</b>").arg(raw_value))
            .arg(infos.join("<br/>"))
            .arg(tooltip_name_footer(d));
    item->setToolTip(tooltip);

    return item;
}
Esempio n. 3
0
void test_cell_add_neighbour(void)
{
	printf("\ntest_cell_add_neighbour\n");
	s_cell cells[4];
	int c, result;
	uint8_t nb_cells;

	nb_cells = 3;
	for (c = 0; c < 4; c++) {
		init_cell(&cells[c], c, nb_cells);
	}

	result = cell_add_neighbour(&cells[0], &cells[1]);
	assert_int_equals(result, CELL_ADD_NEIGHBOUR_OK);
	assert_int_equals(cells[0].nb_neighbours, 1);
	assert_int_equals(cells[1].nb_neighbours, 1);

	result = cell_add_neighbour(&cells[0], &cells[1]);
	assert_int_equals(result, CELL_ERROR_ALREADY_NEIGHBOUR);
	assert_int_equals(cells[0].nb_neighbours, 1);
	assert_int_equals(cells[1].nb_neighbours, 1);

	cell_add_neighbour(&cells[0], &cells[2]);

	result = cell_add_neighbour(&cells[0], &cells[3]);
	assert_int_equals(result, CELL_ERROR_MAX_NEIGHBOURS_REACHED);
	assert_int_equals(cells[0].nb_neighbours, nb_cells - 1);
	assert_int_equals(cells[3].nb_neighbours, 0);

	for (c = 0; c < 4; c++) {
		free_cell(&cells[c]);
	}
}
Esempio n. 4
0
void test_cell_set_nb_pawns(void)
{
	printf("\ntest_cell_set_nb_pawns\n");
	s_cell c;
	s_player p;
	int result;

	init_cell(&c, 1, 4);
	init_player(&p, 1, "test", 1, STRATEGY_NONE, 10);

	result = cell_set_nb_pawns(&c, 13);
	assert_int_equals(result, CELL_ERROR_SET_PAWNS_NO_OWNER);
	assert_int_equals(c.nb_pawns, 0);
	cell_set_owner(&c, &p);

	result = cell_set_nb_pawns(&c, 13);
	assert_int_equals(result, CELL_ERROR_SET_PAWNS_NOT_ENOUGH_PAWNS);
	assert_int_equals(c.nb_pawns, 0);

	result = cell_set_nb_pawns(&c, 10);
	assert_int_equals(result, CELL_SET_PAWNS_OK);
	assert_int_equals(c.nb_pawns, 10);

	free_cell(&c);
}
Esempio n. 5
0
/**
 * Function to initalise the board.
 *
 * @param s_board *b The board to initialise
 * @param uint8_t nb_cells The board's number of cells
 * @param uint8_t nb_players The number of players
 *
 * @return int 1 if the board is correctly initialised,
 * 		ERROR_INIT_BOARD_INVALID_CELLS_NUMBER if the cells number is lower than
 * 		1, ERROR_INIT_BOARD_INVALID_PLAYERS_NUMBER if the players number is
 * 		lower than 1.
 */
int init_board(s_board *b, uint8_t nb_cells, uint8_t nb_players)
{
	int c;

	if (nb_cells < 1) {
		return ERROR_INIT_BOARD_INVALID_CELLS_NUMBER;
	}

	if (nb_players < 1) {
		return ERROR_INIT_BOARD_INVALID_PLAYERS_NUMBER;
	}

	b->nb_cells = nb_cells;
	b->cells = (s_cell*) calloc((size_t) nb_cells, sizeof(s_cell));

	b->nb_total_players = nb_players;
	b->nb_players = 0;
	b->players = (s_player **) calloc((size_t) nb_players, sizeof(s_player *));

	for (c = 0; c < nb_cells; c++) {
		init_cell(&b->cells[c], c + 1, nb_cells);
	}

	return INIT_BOARD_OK;
}
Esempio n. 6
0
QStandardItem *FlagColumn::build_cell(Dwarf *d) {
        QStandardItem *item = init_cell(d);

        item->setData(CT_FLAGS, DwarfModel::DR_COL_TYPE);
        item->setData(false,DwarfModel::DR_SPECIAL_FLAG); //default

        short rating = 0;
        if(d->get_flag_value(m_bit_pos))
            rating = 1;      
        //check to fix butchering pets. currently this will cause the butchered parts to still be recognized as a pet
        //and they'll put them into a burial recepticle, but won't use them as a food source
        if(m_bit_pos == 49){
            if(d->is_pet()){
                item->setToolTip(tr("<b>Please turn off pet availability first.</b><br/><br/>Sorry, pets cannot be butchered due to technical limitations!"));
                item->setData(QBrush(QColor(187,34,34,200)),Qt::BackgroundColorRole);
                item->setData(true,DwarfModel::DR_SPECIAL_FLAG); //indicates that the cell is disabled
                rating = -1;
            }else if(!d->get_caste()->can_butcher()){
                item->setToolTip(tr("<b>This creature cannot be butchered!</b>"));
                item->setData(QBrush(QColor(187,34,34,200)),Qt::BackgroundColorRole);
                item->setData(true,DwarfModel::DR_SPECIAL_FLAG); //indicates that the cell is disabled
                rating = -1;
            }

        }

        item->setData(rating, DwarfModel::DR_SORT_VALUE);
        item->setData(m_bit_pos, DwarfModel::DR_LABOR_ID);
        item->setData(m_set->name(), DwarfModel::DR_SET_NAME);
        return item;
}
QStandardItem *HappinessColumn::build_cell(Dwarf *d) {
	QStandardItem *item = init_cell(d);
	
    QString pixmap_name = QString(":status/img/%1.png").arg(Dwarf::happiness_name(d->get_happiness()));
    if(pixmap_name=="")
        pixmap_name = ":img/question-frame.png";

    item->setData(QIcon(pixmap_name), Qt::DecorationRole);
	item->setData(CT_HAPPINESS, DwarfModel::DR_COL_TYPE);
    item->setData(d->get_raw_happiness(), DwarfModel::DR_SORT_VALUE);

    QString tooltip = QString("<center><h3>%1</h3><h4>%2 (%3)</h4></center><p>%4</p>%5")
            .arg(m_title)
            .arg(Dwarf::happiness_name(d->get_happiness()))
            .arg(d->get_raw_happiness())
            .arg(d->get_thought_desc())
            .arg(tooltip_name_footer(d));

    item->setToolTip(tooltip);
	QColor bg = m_colors[d->get_happiness()];
//    item->setBackground(QBrush(bg));
    item->setData(bg,Qt::BackgroundColorRole);

	return item;
}
Esempio n. 8
0
static int resize_line(struct line *line, unsigned int width)
{
	struct cell *tmp;
	int ret;

	if (!line)
		return -EINVAL;

	if (!width)
		width = DEFAULT_WIDTH;

	if (line->size < width) {
		tmp = realloc(line->cells, width * sizeof(struct cell));
		if (!tmp)
			return -ENOMEM;

		line->cells = tmp;

		while (line->size < width) {
			ret = init_cell(&line->cells[line->size]);
			if (ret)
				return ret;
			line->size++;
		}
	} else if (line->size > width) {
		while (line->size > width) {
			line->size--;
			destroy_cell(&line->cells[line->size]);
		}
	}

	return 0;
}
QStandardItem *EquipmentColumn::build_cell(Dwarf *d){
    QStandardItem *item = init_cell(d);

    QColor rating_color = QColor(69,148,21);
    float rating =  d->get_uniform_rating();
    float coverage = d->get_coverage_rating();

    if(coverage < 100){ //prioritize coverage
        rating = coverage;
        rating_color = Item::color_uncovered();
    }else{
        if(rating < 100) //missing uniform items
            rating_color = Item::color_missing();
    }

    float sort_val = rating - d->get_inventory_wear();
    item->setData(d->get_inventory_wear(),DwarfModel::DR_SPECIAL_FLAG);
    item->setBackground(QBrush(rating_color));
    item->setData(CT_EQUIPMENT, DwarfModel::DR_COL_TYPE);
    item->setData(rating, DwarfModel::DR_RATING); //other drawing 0-100
    item->setData(sort_val, DwarfModel::DR_SORT_VALUE);
    set_export_role(DwarfModel::DR_RATING);

    QString tooltip = QString("<center><h3>%1</h3></center>%2%3")
            .arg(m_title)
            .arg(build_tooltip_desc(d))
            .arg(tooltip_name_footer(d));

    item->setToolTip(tooltip);
    return item;
}
Esempio n. 10
0
QStandardItem *TrainedColumn::build_cell(Dwarf *d){
    QStandardItem *item = init_cell(d);

    QString desc = get_animal_trained_descriptor(d->trained_level());
    float rating = (float)d->trained_level();
    float sort_val = rating;
    QString draw_rating = QString::number(rating);

    QChar sym_master(0x263C); //masterwork symbol in df
    QChar sym_exceptional(0x2261); //3 horizontal lines
    QFontMetrics fm(DT->user_settings()->value("options/grid/font", QFont(DefaultFonts::getRowFontName(), DefaultFonts::getRowFontSize())).value<QFont>());
    bool symbols_ok = false;
    if(fm.inFont(sym_master) && fm.inFont(sym_exceptional)){
        symbols_ok = true;
    }

    if(rating == 7){ //tame
            rating = 50.0f; //don't draw tame animals, this has to be within the uberdelegate's ignore range
            sort_val = -1;
            draw_rating = tr("");
    }else if(rating >= 1 && rating <= 6){ //trained levels
        if(symbols_ok){
            if(rating == 1)
                draw_rating = tr("T");
            else if(rating == 2)
                draw_rating = tr("-");
            else if(rating == 3)
                draw_rating = tr("+");
            else if(rating == 4)
                draw_rating = tr("*");
            else if(rating == 5)
                draw_rating = sym_exceptional;
            else if(rating == 6)
                draw_rating = sym_master;
        }
        rating = (rating / 6.0f * 100.0f / 2.0f) + 50.0f; //scale from 50 to 100
    }else if(rating == 0){ //semi-wild (medium red square)
        rating = 30.0f;
        draw_rating = tr("Sw");
    }else{ //wild, unknown (large red square)
        rating = 5.0f;
        sort_val = -2;
        draw_rating = tr("W");
    }


//    item->setBackground(QBrush(QColor(225,225,225)));
    item->setData(CT_TRAINED, DwarfModel::DR_COL_TYPE);
    item->setData(draw_rating, DwarfModel::DR_DISPLAY_RATING); //numeric drawing, single digits
    item->setData(rating, DwarfModel::DR_RATING); //other drawing 0-100
    item->setData(sort_val, DwarfModel::DR_SORT_VALUE);
    set_export_role(DwarfModel::DR_RATING);

    QString tooltip = QString("<center><h3>%1</h3></center>%2")
            .arg(desc)
            .arg(tooltip_name_footer(d));
    item->setToolTip(tooltip);
    return item;
}
Esempio n. 11
0
cell* init_row(int width) {
  cell* cells = malloc(sizeof(cell)*width);
  int i;
  for(i = 0; i < width; i++) {
    cells[i] = init_cell();
  }
  return cells;
}
Esempio n. 12
0
void
System::
reset()
{
  now_ = 0;
  init_cell();
  init_outer_limit();
  init_particles();
}
Esempio n. 13
0
void test_free_cell(void)
{
	printf("\ntest_free_cell\n");
	s_cell c;
	init_cell(&c, 1, 4);
	free_cell(&c);

	assert_null(c.neighbours);
}
Esempio n. 14
0
void graph::init_graph()
{
	init_dir32();

	init_cell();
	init_font();
	image::register_image_file("png",create_image_png);
	image::register_image_file("jpg",create_image_jpg);

	get_map()->init_map();
	//image::register_image_file("zgp",create_image_zgp);
	//简单的文件可以用register_image_file
	//复杂的多帧文件必须用regist_file_source
}
Esempio n. 15
0
void test_cell_set_owner(void)
{
	printf("\ntest_cell_set_owner\n");
	s_cell c;
	s_player p;
	init_cell(&c, 1, 4);
	init_player(&p, 1, "test", 1, STRATEGY_NONE, 10);

	assert_null(c.owner);
	cell_set_owner(&c, &p);
	assert_str_equals(c.owner->name, "test");
	assert_int_equals(c.owner->nb_cells, 1);

	free_cell(&c);
}
Esempio n. 16
0
void test_init_cell(void)
{
	printf("\ntest_init_cell\n");
	s_cell c;
	int result;

	result = init_cell(&c, 1, 4);
	assert_null(c.owner);
	assert_int_equals(result, 1);
	assert_int_equals(c.id, 1);
	assert_int_equals(c.nb_pawns, 0);
	assert_int_equals(c.nb_neighbours, 0);
	assert_int_equals(c.nb_max_neighbours, 3);

	free_cell(&c);
}
QStandardItem *AttributeColumn::build_cell(Dwarf *d) {
    QStandardItem *item = init_cell(d);
    Attribute a = d->get_attribute(m_attribute_type);
    QString descriptor = a.get_descriptor();
    float rating = a.rating() * 100.0f;

    //if this is an animal, we won't have any caste balanced ratings, so just take a rating out of an arbitrary absolute of 2250
    //that means any rating over 2250 will essentially be 100%, which is pretty reasonable, since
    //scaling to 0-5000 makes the drawn squares fairly small
    if(d->is_animal())
        rating = (float)(a.get_value() / 2250.0f * 100.0f);

    //the rating is used for drawing, should be between 0-100 for attributes
    item->setData(rating, DwarfModel::DR_RATING);
    item->setData(roundf(rating), DwarfModel::DR_DISPLAY_RATING);
    //flag so we know if we need to draw a border or not
    item->setData(a.syndrome_names().count(),DwarfModel::DR_SPECIAL_FLAG);

    if(DT->multiple_castes()){
        descriptor != "" ? descriptor = "(" + descriptor + ")" : "";
    }

    item->setData(CT_ATTRIBUTE, DwarfModel::DR_COL_TYPE);

    refresh_sort(d,m_current_sort);

    if(!descriptor.isEmpty()){
        descriptor = QString("%1%2").arg("<br/>").arg(descriptor);
    }
    QString syn_desc = a.get_syndrome_desc();
    if(!syn_desc.isEmpty()){
        syn_desc = QString("%1%1%2").arg("<br/>").arg(syn_desc);
    }

    QString tooltip = QString("<center><h3>%1</h3><b>%2</b>%3%4%5</center>")
            .arg(m_title)
            .arg(a.get_value_display())
            .arg(descriptor)
            .arg(syn_desc)
            .arg(tooltip_name_footer(d));

    item->setToolTip(tooltip);

    return item;
}
QStandardItem *AttributeColumn::build_cell(Dwarf *d) {
    QStandardItem *item = init_cell(d);
    Attribute a = d->get_attribute((int)m_attribute_type);
    short rawVal = a.value();
    QString descriptor = a.get_descriptor();
    float rating = a.rating() * 100.0f;    

    //if this is an animal, we won't have any caste balanced ratings, so just take a rating out of an arbitrary absolute of 2250
    //that means any rating over 2250 will essentially be 100%, which is pretty reasonable, since
    //scaling to 0-5000 makes the drawn squares fairly small
    if(d->is_animal())
        rating = (float)(a.value() / 2250.0f * 100.0f);

    //the rating is used for drawing, should be between 0-100 for attributes
    item->setData(rating, DwarfModel::DR_RATING);
    item->setData(roundf(rating), DwarfModel::DR_DISPLAY_RATING);


    //if no descriptor (middle ranges) then set the rating to a middle (hidden) value
    //this is primarily for vanilla, as the mid ranges don't have a description and are hidden in game
    //for multiple castes, we may as well draw everything as the descriptors can be different for each caste
    //since multiple castes append 'for a <caste name>' to the descriptor, this will only ever affect vanilla for now
    if(!DT->multiple_castes && a.get_descriptor_rank() == 4){
        item->setData(50.0f, DwarfModel::DR_RATING); //49-51 aren't drawn for attributes
    }else{
        descriptor != "" ? descriptor = "(" + descriptor + ")" : "";
    }

    //sort on the raw value
    item->setData(rawVal, DwarfModel::DR_SORT_VALUE);    
    item->setData(CT_ATTRIBUTE, DwarfModel::DR_COL_TYPE);

    QString tooltip = QString("<center><h3>%1</h3></center><b>%2</b> %3%4")
            .arg(m_title)            
            .arg(a.get_value_display())
            .arg(descriptor)
            .arg(tooltip_name_footer(d));

    item->setToolTip(tooltip);

    return item;
}
QStandardItem *TraitColumn::build_cell(Dwarf *d) {
    QStandardItem *item = init_cell(d);
    item->setData(CT_TRAIT, DwarfModel::DR_COL_TYPE);

    short score = d->trait(m_trait_id);
    QString msg = "???";
    if (m_trait)
        msg = tr("%1 (Raw: %2)").arg(m_trait->level_message(score)).arg(score);

    if (d->trait_is_active(m_trait_id)==false)
        msg += tr("<br/><br/>Not an active trait for this dwarf.");

    QString temp = m_trait->conflicts_messages(score);
    if(!temp.isEmpty())
        msg += tr("<br/><br/>%1").arg(temp);
    temp = m_trait->special_messages(score);
    if(!temp.isEmpty())
        msg += tr("<br/><br/>%1").arg(temp);

    int rating = score;
    QString warning = "";
    if(GameDataReader::ptr()->get_trait(m_trait_id)->inverted){
        warning = tr("<br/><h5 style=\"margin:0;\"><font color=red>*This trait's score should be valued inversely!</font></h5>");
        rating = 100 - score;
    }

    item->setText(QString::number(score));
    item->setData(rating, DwarfModel::DR_SORT_VALUE);
    item->setData(rating, DwarfModel::DR_RATING);
    item->setData(rating, DwarfModel::DR_DISPLAY_RATING);
    
    QString tooltip = QString("<center><h3>%1</h3></center>%2<br>%3%4")
            .arg(m_title)
            .arg(msg)
            .arg(warning)
            .arg(tooltip_name_footer(d));
    item->setToolTip(tooltip);

    return item;
}
Esempio n. 20
0
void test_cell_are_neighbours(void)
{
	printf("\ntest_cell_are_neighbours\n");
	s_cell cells[3];
	int c;
	uint8_t nb_cells;

	nb_cells = 3;
	for (c = 0; c < 4; c++) {
		init_cell(&cells[c], c, nb_cells);
	}

	cell_add_neighbour(&cells[0], &cells[1]);
	cell_add_neighbour(&cells[1], &cells[2]);

	assert_int_equals(cell_are_neighbours(&cells[0], &cells[1]), 1);
	assert_int_equals(cell_are_neighbours(&cells[1], &cells[2]), 1);
	assert_int_equals(cell_are_neighbours(&cells[0], &cells[2]), 0);

	for (c = 0; c < 3; c++) {
		free_cell(&cells[c]);
	}
}
QStandardItem *CurrentJobColumn::build_cell(Dwarf *d) {
    QStandardItem *item = init_cell(d);
    short job_id = d->current_job_id();
    QString pixmap_name(":img/question-frame.png");
    DwarfJob *job = GameDataReader::ptr()->get_job(job_id);
    if (job) {

        int pref_id = -1;
        if(!job->reactionClass.isEmpty() && !d->current_sub_job_id().isEmpty()) {
            Reaction* reaction = d->get_reaction();
            if(reaction!=0) {
                //job_type = DwarfJob::get_type(reaction->skill());
                pref_id = GameDataReader::ptr()->get_pref_from_skill(reaction->skill_id());
            }
        }

        if(pref_id != -1) {
            pixmap_name = ":/profession/img/profession icons/prof_" + QString::number(pref_id+1) + ".png";  //offset for the image name
            item->setData(QColor(50,50,50), DwarfModel::DR_DEFAULT_BG_COLOR); //shade the background
        } else {
            DwarfJob::DWARF_JOB_TYPE job_type = job->type;
            TRACE << "Dwarf: " << d->nice_name() << " job -" << job_id << ": (" << job->description << "," << job_type << ")";
            switch (job_type) {
            case DwarfJob::DJT_IDLE:
                pixmap_name = ":status/img/cross-small.png";
                break;
            case DwarfJob::DJT_ON_BREAK:
                pixmap_name = ":status/img/hourglass.png";
                break;
            case DwarfJob::DJT_SOLDIER:
                pixmap_name = ":status/img/exclamation-shield-frame.png";
                break;
            case DwarfJob::DJT_DIG:
                pixmap_name = ":status/img/shovel.png";
                break;
            case DwarfJob::DJT_CUT:
                pixmap_name = ":status/img/tree--minus.png";
                break;
            case DwarfJob::DJT_SLEEP:
                pixmap_name = ":status/img/moon.png";
                break;
            case DwarfJob::DJT_DRINK:
                pixmap_name = ":status/img/ale.png";
                break;
            case DwarfJob::DJT_FOOD:
                pixmap_name = ":status/img/cutlery.png";
                break;
            case DwarfJob::DJT_BUILD:
                pixmap_name = ":status/img/hammer--plain.png";
                break;
            case DwarfJob::DJT_HAUL:
                pixmap_name = ":status/img/cart-box.png";
                break;
            case DwarfJob::DJT_FIGHT:
                pixmap_name = ":status/img/crossed-swords.png";
                break;
            case DwarfJob::DJT_MOOD:
                pixmap_name = ":img/exclamation-red-frame.png";
                break;
            case DwarfJob::DJT_FORGE:
                pixmap_name = ":status/img/status_forge.png";
                break;
            case DwarfJob::DJT_MEDICAL:
                pixmap_name = ":status/img/first_aid_kit.png";
                break;
            case DwarfJob::DJT_WAX_WORKING:
                pixmap_name = ":status/img/lump.png";
                break;
            case DwarfJob::DJT_POTTERY:
                pixmap_name = ":status/img/pot.png";
                break;
            case DwarfJob::DJT_PRESSING:
                pixmap_name = ":status/img/cup2.png";
                break;
            case DwarfJob::DJT_SPINNING:
                pixmap_name = ":status/img/spinning.png";
                break;
            case DwarfJob::DJT_BEE_KEEPING:
                pixmap_name = ":status/img/bee_i_guess.png";
                break;
            case DwarfJob::DJT_STAIRS:
                pixmap_name = ":status/img/stairs.png";
                break;
            case DwarfJob::DJT_FORTIFICATION:
                pixmap_name = ":status/img/wall-brick.png";
                break;
            case DwarfJob::DJT_ENGRAVE:
                pixmap_name = ":status/img/paint-brush.png";
                break;
            case DwarfJob::DJT_LEAF:
                pixmap_name = ":status/img/leaf.png";
                break;
            case DwarfJob::DJT_BUILD_REMOVE:
                pixmap_name = ":status/img/hammer--minus.png";
                break;
            case DwarfJob::DJT_BAG_ADD:
                pixmap_name = ":status/img/paper-bag--plus.png";
                break;
            case DwarfJob::DJT_MONEY:
                pixmap_name = ":status/img/money-coin.png";
                break;
            case DwarfJob::DJT_TAX:
                pixmap_name = ":status/img/money--arrow.png";
                break;
            case DwarfJob::DJT_RETURN:
                pixmap_name = ":status/img/arrow-return.png";
                break;
            case DwarfJob::DJT_PARTY:
                pixmap_name = ":status/img/rubber-balloons.png";
                break;
            case DwarfJob::DJT_SOAP:
                pixmap_name = ":status/img/soap.png";
                break;
            case DwarfJob::DJT_SEEK:
                pixmap_name = ":status/img/eye--arrow.png";
                break;
            case DwarfJob::DJT_GEM_CUT:
                pixmap_name = ":status/img/diamond.png";
                break;
            case DwarfJob::DJT_GEM_ENCRUST:
                pixmap_name = ":status/img/ruby.png";
                break;
            case DwarfJob::DJT_SEEDS:
                pixmap_name = ":status/img/beans.png";
                break;
            case DwarfJob::DJT_LEAF_ARROW:
                pixmap_name = ":status/img/leaf--arrow.png";
                break;
            case DwarfJob::DJT_WATER_ARROW:
                pixmap_name = ":status/img/water--arrow.png";
                break;
            case DwarfJob::DJT_TOMBSTONE:
                pixmap_name = ":status/img/headstone-rip.png";
                break;
            case DwarfJob::DJT_ANIMAL:
                pixmap_name = ":status/img/animal.png";
                break;
            case DwarfJob::DJT_BOOK_OPEN:
                pixmap_name = ":status/img/book-open-list.png";
                break;
            case DwarfJob::DJT_HANDSHAKE:
                pixmap_name = ":status/img/hand-shake.png";
                break;
            case DwarfJob::DJT_CONSTRUCT:
                pixmap_name = ":status/img/hammer-screwdriver.png";
                break;
            case DwarfJob::DJT_ABACUS:
                pixmap_name = ":status/img/abacus.png";
                break;
            case DwarfJob::DJT_FURNACE:
                pixmap_name = ":status/img/fire.png";
                break;
            case DwarfJob::DJT_REPORT:
                pixmap_name = ":status/img/balloon-prohibition.png";
                break;
            case DwarfJob::DJT_JUSTICE:
                pixmap_name = ":status/img/balance.png";
                break;
            case DwarfJob::DJT_SHIELD:
                pixmap_name = ":status/img/shield.png";
                break;
            case DwarfJob::DJT_DEPOT:
                pixmap_name = ":status/img/wooden-box--arrow.png";
                break;
            case DwarfJob::DJT_BROOM:
                pixmap_name = ":status/img/broom.png";
                break;
            case DwarfJob::DJT_SWITCH:
                pixmap_name = ":status/img/switch.png";
                break;
            case DwarfJob::DJT_CHAIN:
                pixmap_name = ":status/img/chain.png";
                break;
            case DwarfJob::DJT_UNCHAIN:
                pixmap_name = ":status/img/chain-unchain.png";
                break;
            case DwarfJob::DJT_FILL_WATER:
                pixmap_name = ":status/img/water--plus.png";
                break;
            case DwarfJob::DJT_MARKET:
                pixmap_name = ":status/img/store-market-stall.png";
                break;
            case DwarfJob::DJT_KNIFE:
                pixmap_name = ":status/img/knife_bloody.png";
                break;
            case DwarfJob::DJT_BOW:
                pixmap_name = ":status/img/bow.png";
                break;
            case DwarfJob::DJT_CHEESE:
                pixmap_name = ":status/img/cheese.png";
                break;
            case DwarfJob::DJT_HELM:
                pixmap_name = ":status/img/helm.png";
                break;
            case DwarfJob::DJT_GLOVE:
                pixmap_name = ":status/img/glove.png";
                break;
            case DwarfJob::DJT_BOOT:
                pixmap_name = ":status/img/boot.png";
                break;
            case DwarfJob::DJT_ARMOR:
                pixmap_name = ":status/img/armor.png";
                break;
            case DwarfJob::DJT_FISH:
                pixmap_name = ":status/img/carp.png";
                break;
            case DwarfJob::DJT_RAW_FISH:
                pixmap_name = ":status/img/fish.png";
                break;
            case DwarfJob::DJT_MILK:
                pixmap_name = ":status/img/milk.png";
                break;
            case DwarfJob::DJT_REST:
                pixmap_name = ":status/img/bandaid--exclamation.png";
                break;
            case DwarfJob::DJT_COOKING:
                pixmap_name = ":status/img/meat.png";
                break;
            case DwarfJob::DJT_BUCKET_POUR:
                pixmap_name = ":status/img/paint-can--arrow.png";
                break;
            case DwarfJob::DJT_GIVE_LOVE:
                pixmap_name = ":status/img/heart--arrow.png";
                break;
            case DwarfJob::DJT_DYE:
                pixmap_name = ":status/img/color--plus.png";
                break;
            case DwarfJob::DJT_WEAPON:
                pixmap_name = ":status/img/weapon.png";
                break;
            case DwarfJob::DJT_SWITCH_CONNECT:
                pixmap_name = ":status/img/switch-network.png";
                break;
            case DwarfJob::DJT_ZONE_ADD:
                pixmap_name = ":status/img/zone--plus.png";
                break;
            case DwarfJob::DJT_CRAFTS:
                pixmap_name = ":status/img/crown.png";
                break;
            case DwarfJob::DJT_GEAR:
                pixmap_name = ":status/img/gear-small.png";
                break;
            case DwarfJob::DJT_TROUBLE:
                pixmap_name = ":status/img/hand-finger.png";
                break;
            case DwarfJob::DJT_STORAGE:
                pixmap_name = ":status/img/box--plus.png";
                break;
            case DwarfJob::DJT_STORE_OWNED:
                pixmap_name = ":status/img/safe--plus.png";
                break;
            case DwarfJob::DJT_CABINET_MAKE:
                pixmap_name = ":status/img/drawer--plus.png";
                break;
            case DwarfJob::DJT_CABINET_STORE:
                pixmap_name = ":status/img/drawer-open.png";
                break;
            case DwarfJob::DJT_DOOR_MAKE:
                pixmap_name = ":status/img/door--plus.png";
                break;
            case DwarfJob::DJT_CHAIR_MAKE:
                pixmap_name = ":status/img/chair--plus.png";
                break;
            case DwarfJob::DJT_BREW:
                pixmap_name = ":status/img/ale--plus.png";
                break;
            default:
            case DwarfJob::DJT_DEFAULT:
                pixmap_name = ":status/img/control_play_blue.png";
                break;
            }
        }
    }

    item->setData(QIcon(pixmap_name), Qt::DecorationRole);
    item->setData(CT_IDLE, DwarfModel::DR_COL_TYPE);
    item->setData(d->current_job_id(), DwarfModel::DR_SORT_VALUE);

//    QColor bg = QColor(175,175,175);
//    if(DT->user_settings()->value("options/grid/shade_cells",true)==false)
//        bg = QColor(255,255,255);
//    item->setData(bg,Qt::BackgroundColorRole);

    QString tooltip = QString("<center><h3>%1</h3>%2 (%3)%4</center>")
                      .arg(m_title)
                      .arg(d->current_job())
                      .arg(d->current_job_id())
                      .arg(tooltip_name_footer(d));
    item->setToolTip(tooltip);
    return item;
}
Esempio n. 22
0
/*============================================================================*/
static cell * pviterbi_propagate_step (ghmm_dpmodel *mo, ghmm_dpseq * X, ghmm_dpseq * Y,
				       cell * start, cell * stop,
				       double * log_p,
				       plocal_propagate_store_t * pv) {
#define CUR_PROC "pviterbi_step"
  /* printf("---- propagate step -----\n"); */
  int u, v, j, i;
  double value, max_value, previous_prob;  
  /* int len_path  = mo->N*len; the length of the path is not known apriori */
  int start_x, start_y, stop_x, stop_y;
  double log_b_i, log_in_a_ij;
  cell * middle = NULL;
  int middle_x;
  double (*log_in_a)(plocal_propagate_store_t*, int, int, ghmm_dpseq*, 
		     ghmm_dpseq*, int, int);
  log_in_a = &sget_log_in_a_prop;
  init_start_stop(start, stop, X, Y, &start_x, &start_y, &stop_x, &stop_y);
  middle_x = start_x + (stop_x - start_x) / 2;
/*   if (mo->model_type & kSilentStates &&  */
/*       mo->silent != NULL &&  */
/*       mo->topo_order == NULL) { */
/*     ghmm_dmodel_topo_order( mo );  */
/*   } */
  init_phi_prop(pv, X, Y, start, stop);
#ifdef DEBUG
  if (start != NULL && mo->s[start->state].offset_y == 0) {
    for (u = 0; u<=mo->max_offset_x; u++) {
      printf("row %i of phi\n", u);
      for (v = start_y - 1; v < stop_y; v++) {
	printf("phi(0, %i, %i): %f, ", v, start->state, get_phi_prop(pv, 0, v, 0, 0, start->state));
      }
      printf("\n\n");
    }
  }
#endif
  /* u, v > 0 */
  /** THIS IS THE MAIN RECURRENCE **/
  /* printf("Main loop x from %i to %i and y from %i to %i\n", 
     start_x + mo->max_offset_x + 1, stop_x, start_y, stop_y);*/
  for (u = start_x + mo->max_offset_x + 1; u < stop_x; u++) {
    for (v = start_y - mo->max_offset_y; v < stop_y; v++) {
      for (j = 0; j < mo->N; j++) 
	{
	  /** initialization of phi (lookback matrix) **/
	  set_phi_prop(pv, u, v, j, +1);
	  set_end_of_first(pv, 0, v, j, NULL);
	}
      for (i = 0; i < mo->N; i++) {
	/* Determine the maximum */
	/* max_phi = phi[i] + log_in_a[j][i] ... */
	if (!(mo->model_type & GHMM_kSilentStates) || !mo->silent[i]) {
	  max_value = -DBL_MAX;
	  set_end_of_first(pv, 0, v, i, NULL);
	  for (j = 0; j < mo->s[i].in_states; j++) {
	    /* look back in the phi matrix at the offsets */
	    previous_prob = get_phi_prop(pv, u, v, mo->s[i].offset_x,
					   mo->s[i].offset_y, mo->s[i].in_id[j]);
	    log_in_a_ij = (*log_in_a)(pv, i, j, X, Y, u, v);
	    if ( previous_prob != +1 && 
		 log_in_a_ij != +1) {
	      value = previous_prob + log_in_a_ij;
	      if (value > max_value) {
		max_value = value;
		/* Critical point for the propagate algorithm if we are at the
		   middle point of sequence X store this at the end point of
		   the first alignment */	      
		if (u - middle_x < mo->s[i].offset_x && u - middle_x >= 0) {
		  cell * end_of_first = init_cell(u - (mo->s[i].offset_x - 1),
						  v - (mo->s[i].offset_y - 1), 
						  i, mo->s[i].in_id[j],
						  previous_prob, 
						  log_in_a_ij);
		  if (get_end_of_first(pv, u, v, 0, 0, i) != NULL) {
		    cell * old = get_end_of_first(pv, u, v, 0, 0, i);
		    m_free(old);
		  }
		  set_end_of_first(pv, u, v, i, end_of_first);
		}
		else {
		  /* at all other points simply propagate the values on */
		  set_end_of_first(pv, u, v, i, get_end_of_first(pv, u, v, 
							     mo->s[i].offset_x,
							     mo->s[i].offset_y,
							     mo->s[i].in_id[j]));
		}
	      }
	    }
	    else
	      {;} /* fprintf(stderr, " %d --> %d = %f, \n", i,i,v->log_in_a[i][i]); */
	  }
#ifdef DEBUG
	  int emission = ghmm_dpmodel_pair(ghmm_dpseq_get_char(X, mo->s[i].alphabet, u), 
			      ghmm_dpseq_get_char(Y, mo->s[i].alphabet, v),
			      mo->size_of_alphabet[mo->s[i].alphabet],
			      mo->s[i].offset_x, mo->s[i].offset_y);
	  if (emission > ghmm_dpmodel_emission_table_size(mo, i)){
	    printf("State %i\n", i);
	    ghmm_dpmodel_state_print(&(mo->s[i]));
	    printf("charX: %i charY: %i alphabet size: %i emission table: %i emission index: %i\n", 
		   ghmm_dpseq_get_char(X, mo->s[i].alphabet, u),
		   ghmm_dpseq_get_char(Y, mo->s[i].alphabet, v),
		   mo->size_of_alphabet[mo->s[i].alphabet],
		   ghmm_dpmodel_emission_table_size(mo, i), emission);
	  }
#endif
	  log_b_i = log_b_prop(pv, i, ghmm_dpmodel_pair(ghmm_dpseq_get_char(X, mo->s[i].alphabet, u), 
					   ghmm_dpseq_get_char(Y, mo->s[i].alphabet, v),
					   mo->size_of_alphabet[mo->s[i].alphabet],
					   mo->s[i].offset_x, mo->s[i].offset_y));
	  /* No maximum found (that is, state never reached)
	     or the output O[t] = 0.0: */
	  if (max_value == -DBL_MAX ||/* and then also: (v->psi[t][j] == -1) */
	      log_b_i == +1 ) {
	    set_phi_prop(pv, u, v, i, 1);
	  }
	  else
	    set_phi_prop(pv, u, v, i, max_value + log_b_i);
	}
      } /* complete time step for emitting states */
    
	/* last_osc = osc; */ /* save last transition class */

      /*if (mo->model_type & kSilentStates) { 
	p__viterbi_silent( mo, t, v );
	}*/ /* complete time step for silent states */
      
      /**************
    for (j = 0; j < mo->N; j++) 
      {      
	printf("\npsi[%d],in:%d, phi=%f\n", t, v->psi[t][j], v->phi[j]);
       }
      
    for (i = 0; i < mo->N; i++){
      printf("%d\t", former_matchcount[i]);
    }

    for (i = 0; i < mo->N; i++){
      printf("%d\t", recent_matchcount[i]);
    }
      ****************/

    } /* End for v in Y */
    /* Next character in X */
    /* push back the old phi values */
    push_back_phi_prop(pv, Y->length);
  } /* End for u in X */
  /* Termination */
  max_value = -DBL_MAX;
  /* for the last segment search for the maximum probability at the end of the
     two sequences */
  if (stop == NULL){
    for (j = 0; j < mo->N; j++){
#ifdef DEBUG
    /* printf("phi(len_x)(len_y)(%i)=%f\n", j, pv->phi[0][stop_y-1][j]);
       ghmm_dpmodel_print_cell(pv->end_of_first[0][stop_y - 1][j]); */
#endif
      if ( get_phi_prop(pv, stop_x - 1, stop_y - 1, 0, 0, j) != +1 && 
	   get_phi_prop(pv, stop_x - 1, stop_y - 1, 0, 0, j) > max_value) { 
	max_value = get_phi_prop(pv, stop_x - 1, stop_y - 1, 0, 0, j);
	middle = get_end_of_first(pv, stop_x - 1, stop_y - 1, 0, 0, j);
      }
    }
  }
  /* traceback for the interior segments have to start with the previous state
     of the middle beacuse the path has to be connected */
  else {
    if ( get_phi_prop(pv, stop_x - 1, stop_y - 1, 0, 0, stop->previous_state) != +1 ) {
      max_value = get_phi_prop(pv, stop_x - 1, stop_y - 1, 0, 0, stop->previous_state);
      middle = get_end_of_first(pv, stop_x - 1, stop_y - 1, 0, 0, stop->previous_state);
    }
  }
  if (max_value == -DBL_MAX) {
    /* Sequence can't be generated from the model! */
    *log_p = +1;
  }
  else {
    *log_p = max_value;
  }
  return middle;
#undef CUR_PROC
}
Esempio n. 23
0
/*============================================================================*/
static void init_phi_prop (plocal_propagate_store_t * pv, ghmm_dpseq * X,
			   ghmm_dpseq * Y, cell * start, cell * stop) {
#define CUR_PROC "init_phi_prop"
  int u, v, j, i, off_x, y;
  double value, max_value, previous_prob, log_b_i, log_in_a_ij ;
  int start_x, start_y, stop_x, stop_y, middle_x;
  ghmm_dpmodel * mo = pv->mo;
  double (*log_in_a)(plocal_propagate_store_t*, int, int, ghmm_dpseq*, 
		     ghmm_dpseq*, int, int);
  log_in_a = &sget_log_in_a_prop;
  init_start_stop(start, stop, X, Y, &start_x, &start_y, &stop_x, &stop_y);
  pv->start_x = start_x;
  pv->start_y = start_y;
  middle_x = start_x + (stop_x - start_x) / 2;
  /* to be sure that we do not look up something out of the bounds set the
     whole matrix to 1 */
  /* Initialize the lookback matrix (for positions [-offsetX,0], [0, len_y]*/
  for (off_x=0; off_x<mo->max_offset_x + 1; off_x++)
    for (y=0; y<Y->length + mo->max_offset_y + 1; y++)
      for (j=0; j<mo->N; j++) {
	pv->phi[off_x][y][j] = +1;
      }
  /* Inititalize the end_of_first matrix */
  for (off_x=0; off_x<mo->max_offset_x + 1; off_x++)
    for (y=0; y<Y->length + mo->max_offset_y + 1; y++)
      for (j=0; j<mo->N; j++) 
	if (pv->end_of_first[off_x][y][j]) {
	  /* m_free(pv->end_of_first[off_x][y][j]); */
	  pv->end_of_first[off_x][y][j] = NULL;
	}
  if (mo->model_type & GHMM_kSilentStates) { /* could go into silent state at t=0 */
    /*p__viterbi_silent( mo, t=0, v);*/
  }
  /*for (j = 0; j < mo->N; j++)
    {
      printf("\npsi[%d],in:%d, phi=%f\n", t, v->psi[t][j], v->phi[j]);
    }

  for( i = 0; i < mo->N; i++){
    printf("%d\t", former_matchcount[i]);
  }
  for (i = 0; i < mo->N; i++){
    printf("%d\t", recent_matchcount[i]);
  }*/
  
  /* initialize for offsets > 1 (u < max_offset_x, v < max_offset_y) */
  /* this is in principle the same as the main recurrence but adds initial
     probabilities to states that cannot be inhabitated at u=0, v=0 because
     of greater offsets than one */
  /* u, v <= max offsets */
  for (u = -1; u <= mo->max_offset_x; u++) {
    for (v = start_y - mo->max_offset_y; v < stop_y; v++) {
      for (j = 0; j < mo->N; j++) 
	{
	  /** initialization of phi (lookback matrix) **/
	  set_phi_prop(pv, u, v, j, 1);
	  /** traceback for the propagate algorithm **/
	  set_end_of_first(pv, u, v, j, NULL);
	}
      for (i = 0; i < mo->N; i++) {
	/* Determine the maximum */
	/* max_phi = phi[i] + log_in_a[j][i] ... */
	if (!(mo->model_type & GHMM_kSilentStates) || !mo->silent[i] ) {
	  max_value = -DBL_MAX;
	  set_end_of_first(pv, u, v, i, NULL);
	  for (j = 0; j < mo->s[i].in_states; j++) {
	    /* look back in the phi matrix at the offsets */
	    previous_prob = get_phi_prop(pv, u, v, mo->s[i].offset_x, 
					 mo->s[i].offset_y, mo->s[i].in_id[j]);
	    log_in_a_ij = (*log_in_a)(pv, i, j, X, Y, u, v);
	    if ( previous_prob != +1 && log_in_a_ij != +1) {
	      value = previous_prob + log_in_a_ij;
	      if (value > max_value) {
		max_value = value;
		/* Critical point for the propagate algorithm if we are at the
		   middle point of sequence X store this at the end point of
		   the first alignment */
		if (u - middle_x < mo->s[i].offset_x && u - middle_x >= 0) {
		  cell * end_of_first = init_cell(u - (mo->s[i].offset_x - 1), 
						  v - (mo->s[i].offset_y - 1), 
						  i, mo->s[i].in_id[j],
						  previous_prob, 
						  log_in_a_ij);
		  if (get_end_of_first(pv, u, v, 0, 0, i) != NULL) {
		    cell * old = get_end_of_first(pv, u, v, 0, 0, i);
		    m_free(old);
		  }
		  set_end_of_first(pv, u, v, i, end_of_first);
		}
		else {
		  /* at all other points simply propagate the values on */
		  set_end_of_first(pv, u, v, i, get_end_of_first(pv, u, v, 
							     mo->s[i].offset_x,
							     mo->s[i].offset_y,
							     mo->s[i].in_id[j]));
		}
	      }
	    }
	    else
	      {;} /* fprintf(stderr, " %d --> %d = %f, \n", i,i,v->log_in_a[i][i]); */
	  }
#ifdef DEBUG
	  int emission = ghmm_dpmodel_pair(ghmm_dpseq_get_char(X, mo->s[i].alphabet, u + start_x), 
			      ghmm_dpseq_get_char(Y, mo->s[i].alphabet, v),
			      mo->size_of_alphabet[mo->s[i].alphabet],
			      mo->s[i].offset_x, mo->s[i].offset_y);
	  if (emission > ghmm_dpmodel_emission_table_size(mo, i)){
	    printf("State %i\n", i);
	    ghmm_dpmodel_state_print(&(mo->s[i]));
	    printf("charX: %i charY: %i alphabet size: %i emission table: %i emission index: %i\n", 
		   ghmm_dpseq_get_char(X, mo->s[i].alphabet, u),
		   ghmm_dpseq_get_char(Y, mo->s[i].alphabet, v),
		   mo->size_of_alphabet[mo->s[i].alphabet],
		   ghmm_dpmodel_emission_table_size(mo, i), emission);
	  }
#endif
	  log_b_i = log_b_prop(pv, i, ghmm_dpmodel_pair(ghmm_dpseq_get_char(X, 
							       mo->s[i].alphabet,
							       u + start_x),
					   ghmm_dpseq_get_char(Y, 
							       mo->s[i].alphabet,
							       v),
					   mo->size_of_alphabet[mo->s[i].alphabet],
					   mo->s[i].offset_x, mo->s[i].offset_y));

	  /* this is the difference from the main loop:
	     check whether this state could be an initial state and add the
	     initial probability */
	  if (log_b_i == +1 ) {
	    set_phi_prop(pv, u, v, i, +1);
	  }
	  else {
	    if (max_value == -DBL_MAX)
	      set_phi_prop(pv, u, v, i, +1);
	    else
	      set_phi_prop(pv, u, v, i, max_value);
	    /* if (mo->s[i].pi != 0 && mo->s[i].offset_x - 1 == u && 
	       mo->s[i].offset_y - 1 + start_y == v) { */
	    if (mo->s[i].log_pi != 1 && mo->s[i].offset_x - 1 == u && 
		mo->s[i].offset_y - 1 + start_y == v){
	      set_phi_prop(pv, u, v, i, mo->s[i].log_pi);
#ifdef DEBUG	     
	      printf("Initial log prob state %i at (%i, %i) = %f\n", i, start_x + u, v, get_phi_prop(pv, u, v, 0, 0, i));
	      printf("Characters emitted X: %i, Y: %i\n", 
		     ghmm_dpseq_get_char(X, mo->s[i].alphabet, u + start_x),
		     ghmm_dpseq_get_char(Y, mo->s[i].alphabet, v));
#endif
	    }
	    if (get_phi_prop(pv, u, v, 0, 0, i) != 1) {
	      set_phi_prop(pv, u, v, i, get_phi_prop(pv, u, v, 0, 0, i) + log_b_i);
	    }
	  }
	}
      } /* complete time step for emitting states */
    
	/* last_osc = osc; */ /* save last transition class */

      /*if (mo->model_type & kSilentStates) { 
	p__viterbi_silent( mo, t, v );
	}*/ /* complete time step for silent states */
      
      /**************
    for (j = 0; j < mo->N; j++) 
      {      
	printf("\npsi[%d],in:%d, phi=%f\n", t, v->psi[t][j], v->phi[j]);
       }
      
    for (i = 0; i < mo->N; i++){
      printf("%d\t", former_matchcount[i]);
    }

    for (i = 0; i < mo->N; i++){
      printf("%d\t", recent_matchcount[i]);
    }
      ****************/

    } /* End for v in Y */
    /* Next character in X */
    /* push back the old phi values */
    push_back_phi_prop(pv, Y->length);
#ifdef DEBUG
    if (start != NULL && mo->s[start->state].offset_y == 0) {
      max_value = -DBL_MAX;
      i = -1;     
      y = -1;
      off_x = -1;
      int x;
      for (x = 0; x<=mo->max_offset_x; x++)
	for (v = - mo->max_offset_y; v<Y->length; v++) {
	  for (j=0; j<mo->N; j++) {
	    if (get_phi_prop(pv, x, v, x, 0, j) >= max_value && 
		get_phi_prop(pv, x, v, x, 0, j) < 1 - PROP_EPS) {
	      max_value = get_phi_prop(pv, x, v, x, 0, j);
	      i = j;
	      off_x = x;
	      y = v;
	    }
	  }
	}
      printf("u = %i start_x = %i off_x = %i ", u, start_x, off_x);
      printf("max log prob state %i at (%i, %i) = %f after pushback\n",
	     i, start_x + u - (off_x - 1), y, get_phi_prop(pv, u, y, off_x, 0, i));
    }
#endif
  } /* End for u in X */
#undef CUR_PROC
}
Esempio n. 24
0
/*============================================================================*/
cell * ghmm_dpmodel_copy_cell(cell * c) {
  if (c)
    return init_cell(c->x, c->y, c->state, c->previous_state, c->log_p, c->log_a);
  else
    return NULL;
}
Esempio n. 25
0
QStandardItem *FlagColumn::build_cell(Dwarf *d) {
    QStandardItem *item = init_cell(d);

    item->setData(CT_FLAGS, DwarfModel::DR_COL_TYPE);
    item->setData(0,DwarfModel::DR_STATE); //default

    QString info_msg = "";
    QString info_col_name = "";

    short rating = 0;
    if(d->get_flag_value(m_bit_pos))
        rating = 1;
    //check to fix butchering pets. currently this will cause the butchered parts to still be recognized as a pet
    //and they'll put them into a burial recepticle, but won't use them as a food source
    ViewColumn::CELL_STATE state  = STATE_TOGGLE;
    if(m_bit_pos == FLAG_BUTCHER){
        if(d->is_pet()){
            info_msg = tr("<b>Pets cannot be slaughtered!</b>");
            state = STATE_DISABLED;
        }else if(!d->get_caste() || !d->get_caste()->flags().has_flag(BUTCHERABLE)){
            info_msg = tr("<b>This caste cannot be slaughtered!</b>");
            state = STATE_DISABLED;
        }else if(rating == 1){
            info_msg = tr("<b>This creature has been marked for slaughter.</b>");
            state = STATE_PENDING;
        }else if(d->trained_level() >= Dwarf::unknown_trained){
            info_msg = tr("<b>Captured wild animals cannot be butchered!</b>");
            state = STATE_DISABLED;
        }else{
            state = STATE_TOGGLE;
        }
    }else if(m_bit_pos == FLAG_GELD){
        if(d->get_gender() != Dwarf::SEX_M){
            info_msg = tr("<b>Only males can be gelded!</b>");
            state = STATE_DISABLED;
        }else if(d->has_health_issue(eHealth::HI_GELDED,0)){
            info_msg = tr("<b>This creature has already been gelded!</b>");
            state = STATE_ACTIVE;
        }else if(rating == 1){
            info_msg = tr("<b>This creature has been marked for gelding.</b>");
            state = STATE_PENDING;
        }else if(!d->get_caste()->is_geldable()){ //check last as it's the most expensive
            info_msg = tr("<b>This caste is not geldable!</b>");
            state = STATE_DISABLED;
        }else{
            state = STATE_TOGGLE;
        }
    }

    item->setData(state,DwarfModel::DR_STATE);
    info_col_name = get_state_color(state).name();//item->data(Qt::BackgroundColorRole).value<QColor>().name();

    item->setData(rating, DwarfModel::DR_SORT_VALUE);
    item->setData(m_bit_pos, DwarfModel::DR_OTHER_ID);
    item->setData(m_set->name(), DwarfModel::DR_SET_NAME);

    QString tooltip = QString("<center><h3>%1</h3>%2</center>%3")
            .arg(m_title)
            .arg(QString("<font color=%1>%2</font>").arg(info_col_name).arg(info_msg))
            .arg(tooltip_name_footer(d));
    item->setToolTip(tooltip);

    return item;
}
Esempio n. 26
0
void test_player_move_to_cell(void)
{
	printf("\ntest_player_move_to_cell\n");
	s_cell c1, c2, c3;
	s_player p1, p2;
	short result;

	init_cell(&c1, 1, 3);
	init_cell(&c2, 2, 3);
	init_cell(&c3, 3, 3);
	init_player(&p1, 1, "p1", 1, STRATEGY_NONE, 10);
	init_player(&p2, 2, "p2", 1, STRATEGY_NONE, 10);

	cell_add_neighbour(&c1, &c2);
	cell_add_neighbour(&c2, &c3);

	cell_set_owner(&c1, &p1);
	cell_set_nb_pawns(&c1, 10);
	cell_set_owner(&c3, &p2);
	cell_set_nb_pawns(&c3, 10);

	// test move all pawns from src cell
	result = player_move_to_cell(&p1, 10, &c1, &c2);
	assert_int_equals(result, PLAYER_ERROR_MOVE_ALL_PAWNS);

	// test move too many pawns
	result = player_move_to_cell(&p1, 11, &c1, &c2);
	assert_int_equals(result, PLAYER_ERROR_MOVE_NOT_ENOUGH_PAWNS);

	// test move to a cell too far away
	result = player_move_to_cell(&p1, 1, &c1, &c3);
	assert_int_equals(result, PLAYER_ERROR_MOVE_CELLS_NOT_NEIGHBOURS);

	// move no fight
	assert_int_equals(p1.nb_cells, 1);
	result = player_move_to_cell(&p1, 5, &c1, &c2);
	assert_int_equals(result, NO_FIGHT);
	assert_int_equals(c1.nb_pawns, 5);
	assert_int_equals(c2.nb_pawns, 5);
	assert_int_equals(p1.nb_pawns, 10);
	assert_int_equals(p1.nb_cells, 2);
	assert_int_equals(c2.owner->id, p1.id);

	// move fight win
	result = player_move_to_cell(&p2, 6, &c3, &c2);
	assert_int_equals(result, FIGHT_WON);
	assert_int_equals(c3.nb_pawns, 4);
	assert_int_equals(c2.nb_pawns, 6);
	assert_int_equals(p2.nb_pawns, 10);
	assert_int_equals(p2.nb_cells, 2);
	assert_int_equals(p1.nb_pawns, 5);
	assert_int_equals(p1.nb_cells, 1);
	assert_int_equals(c2.owner->id, p2.id);

	// move fight lose
	result = player_move_to_cell(&p1, 4, &c1, &c2);
	assert_int_equals(result, FIGHT_LOST);
	assert_int_equals(c1.nb_pawns, 1);
	assert_int_equals(c2.nb_pawns, 6);
	assert_int_equals(p1.nb_pawns, 1);
	assert_int_equals(p1.nb_cells, 1);
	assert_int_equals(p2.nb_pawns, 10);
	assert_int_equals(p2.nb_cells, 2);
	assert_int_equals(c2.owner->id, p2.id);

	// move fight draw
	result = player_move_to_cell(&p2, 1, &c2, &c1);
	assert_int_equals(result, FIGHT_DRAW);
	assert_int_equals(c2.nb_pawns, 6);
	assert_int_equals(c1.nb_pawns, 1);
	assert_int_equals(p1.nb_pawns, 1);
	assert_int_equals(p1.nb_cells, 1);
	assert_int_equals(p2.nb_pawns, 10);
	assert_int_equals(p2.nb_cells, 2);
	assert_int_equals(c2.owner->id, p2.id);
	assert_int_equals(c1.owner->id, p1.id);

	free_cell(&c1);
	free_cell(&c2);
	free_cell(&c3);
}
Esempio n. 27
0
com()
{
	int i, kuusho, hukasa;
	int x, y;
	char **a;
	char *bp;
	CELL *p;

	joseki();
	if(te)
		return;  
	kuusho = 0;
	a = aki;

	for (i = 0; i < 60;  ) {
		bp = ban + yuusen[i++];
		if(*bp == BLANK) {
			*(a++) = bp;
			kuusho++;
		}
	}

	*a = 0;

	sekisa = 0;
	for(y = 1; y < 9; y++) {
		for(x = 1; x < 9; x++) {
			switch(ban[y*9+x]) {
				case BLACK:
					sekisa++;
					break;
				case WHITE:
					sekisa--;
			}
		}
	}

	init_cell();
	p = get_cell();
	p->child = NULL;
	p->cdr = NULL;

	if(kuusho <= lvtbl[level-1].kanzen) {
		p->h = -64;
		mr2(p, kuusho, 64);
	}
		else if(kuusho <= lvtbl[level-1].hishou) {
			p->h = -1;
			mr2(p, kuusho, 1);
		}
		else {
			hukasa = lvtbl[level-1].hukasa;
			if(kuusho <= lvtbl[level-1].kyoka) 
				hukasa += 2;

			p->h = -10000;
			mr1(p, hukasa, 10000);
		}

		te = p->t;
}